Fixing failing videoGeneration tests.

Author: ai16z-demirix

packages/core/src/tests/videoGeneration.test.ts

@@ -1,14 +1,12 @@
-import { IAgentRuntime } from "@ai16z/eliza";
+import { IAgentRuntime, Memory, State } from "@ai16z/eliza";
 import { describe, it, expect, beforeEach, vi } from "vitest";
 
 // Mock the fetch function
 global.fetch = vi.fn();
 
 // Mock the fs module
-vi.mock("fs", async (importOriginal) => {
-    const actual = await importOriginal();
+vi.mock("fs", async () => {
     return {
-        ...actual,
         default: {
             writeFileSync: vi.fn(),
             existsSync: vi.fn(),
@@ -20,31 +18,55 @@ vi.mock("fs", async (importOriginal) => {
     };
 });
 
-// Create a mock VideoService class
-class MockVideoService {
-    private CONTENT_CACHE_DIR = "./content_cache";
+// Mock the video generation plugin
+const mockVideoGenerationPlugin = {
+    actions: [
+        {
+            validate: vi.fn().mockImplementation(async (runtime) => {
+                const apiKey = runtime.getSetting("LUMA_API_KEY");
+                return !!apiKey;
+            }),
+            handler: vi.fn().mockImplementation(async (runtime, message, state, options, callback) => {
+                // Initial response
+                callback({
+                    text: "I'll generate a video based on your prompt",
+                });
 
-    isVideoUrl(url: string): boolean {
-        return (
-            url.includes("youtube.com") ||
-            url.includes("youtu.be") ||
-            url.includes("vimeo.com")
-        );
-    }
-
-    async downloadMedia(url: string): Promise<string> {
-        if (!this.isVideoUrl(url)) {
-            throw new Error("Invalid video URL");
-        }
-        const videoId = url.split("v=")[1] || url.split("/").pop();
-        return `${this.CONTENT_CACHE_DIR}/${videoId}.mp4`;
-    }
-}
-
-describe("Video Service", () => {
+                // Check if there's an API error
+                const fetchResponse = await global.fetch();
+                if (!fetchResponse.ok) {
+                    callback({
+                        text: "Video generation failed: API Error",
+                        error: true,
+                    });
+                    return;
+                }
+
+                // Final response with video
+                callback(
+                    {
+                        text: "Here's your generated video!",
+                        attachments: [
+                            {
+                                source: "videoGeneration",
+                                url: "https://example.com/video.mp4",
+                            },
+                        ],
+                    },
+                    ["generated_video_123.mp4"]
+                );
+            }),
+        },
+    ],
+};
+
+vi.mock("../index", () => ({
+    videoGenerationPlugin: mockVideoGenerationPlugin,
+}));
+
+describe("Video Generation Plugin", () => {
     let mockRuntime: IAgentRuntime;
     let mockCallback: ReturnType<typeof vi.fn>;
-    let videoService: MockVideoService;
 
     beforeEach(() => {
         // Reset mocks
@@ -58,7 +80,6 @@ describe("Video Service", () => {
         } as unknown as IAgentRuntime;
 
         mockCallback = vi.fn();
-        videoService = new MockVideoService();
 
         // Setup fetch mock for successful response
         (global.fetch as ReturnType<typeof vi.fn>).mockImplementation(() =>
@@ -77,25 +98,89 @@ describe("Video Service", () => {
         );
     });
 
-    it("should validate video URLs", () => {
-        expect(videoService.isVideoUrl("https://www.youtube.com/watch?v=123")).toBe(true);
-        expect(videoService.isVideoUrl("https://youtu.be/123")).toBe(true);
-        expect(videoService.isVideoUrl("https://vimeo.com/123")).toBe(true);
-        expect(videoService.isVideoUrl("https://example.com/video")).toBe(false);
+    it("should validate when API key is present", async () => {
+        const mockMessage = {} as Memory;
+        const result = await mockVideoGenerationPlugin.actions[0].validate(
+            mockRuntime,
+            mockMessage
+        );
+        expect(result).toBe(true);
+        expect(mockRuntime.getSetting).toHaveBeenCalledWith("LUMA_API_KEY");
     });
 
-    it("should handle video download", async () => {
-        const mockUrl = "https://www.youtube.com/watch?v=123";
-        const result = await videoService.downloadMedia(mockUrl);
-        
-        expect(result).toBeDefined();
-        expect(typeof result).toBe("string");
-        expect(result).toContain(".mp4");
-        expect(result).toContain("123.mp4");
+    it("should handle video generation request", async () => {
+        const mockMessage = {
+            content: {
+                text: "Generate a video of a sunset",
+            },
+        } as Memory;
+        const mockState = {} as State;
+
+        await mockVideoGenerationPlugin.actions[0].handler(
+            mockRuntime,
+            mockMessage,
+            mockState,
+            {},
+            mockCallback
+        );
+
+        // Check initial callback
+        expect(mockCallback).toHaveBeenCalledWith(
+            expect.objectContaining({
+                text: expect.stringContaining(
+                    "I'll generate a video based on your prompt"
+                ),
+            })
+        );
+
+        // Check final callback with video
+        expect(mockCallback).toHaveBeenCalledWith(
+            expect.objectContaining({
+                text: "Here's your generated video!",
+                attachments: expect.arrayContaining([
+                    expect.objectContaining({
+                        source: "videoGeneration",
+                    }),
+                ]),
+            }),
+            expect.arrayContaining([
+                expect.stringMatching(/generated_video_.*\.mp4/),
+            ])
+        );
     });
 
-    it("should handle download errors gracefully", async () => {
-        const mockUrl = "https://example.com/invalid";
-        await expect(videoService.downloadMedia(mockUrl)).rejects.toThrow("Invalid video URL");
+    it("should handle API errors gracefully", async () => {
+        // Mock API error
+        (global.fetch as ReturnType<typeof vi.fn>).mockImplementationOnce(() =>
+            Promise.resolve({
+                ok: false,
+                status: 500,
+                statusText: "Internal Server Error",
+                text: () => Promise.resolve("API Error"),
+            })
+        );
+
+        const mockMessage = {
+            content: {
+                text: "Generate a video of a sunset",
+            },
+        } as Memory;
+        const mockState = {} as State;
+
+        await mockVideoGenerationPlugin.actions[0].handler(
+            mockRuntime,
+            mockMessage,
+            mockState,
+            {},
+            mockCallback
+        );
+
+        // Check error callback
+        expect(mockCallback).toHaveBeenCalledWith(
+            expect.objectContaining({
+                text: expect.stringContaining("Video generation failed"),
+                error: true,
+            })
+        );
     });
 });