@assistkick/create 1.7.0 → 1.9.0

package/templates/assistkick-product-system/tests/video_render_service.test.ts

@@ -0,0 +1,181 @@
+/**
+ * Tests for Video Rendering Service (feat_affe2fc7).
+ * Verifies the VideoRenderService class, API routes, schema, and Dockerfile.
+ * Uses node:test built-in runner.
+ */
+import { describe, it, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SOURCE_ROOT = join(__dirname, '..');
+const BACKEND_SRC = join(SOURCE_ROOT, 'packages', 'backend', 'src');
+const SHARED_DB = join(SOURCE_ROOT, 'packages', 'shared', 'db');
+
+describe('VideoRenderService', () => {
+  let serviceContent: string;
+  let routeContent: string;
+  let schemaContent: string;
+  let serverContent: string;
+  let initContent: string;
+  let dockerfileContent: string;
+
+  it('loads source files', async () => {
+    serviceContent = await readFile(join(BACKEND_SRC, 'services', 'video_render_service.ts'), 'utf-8');
+    routeContent = await readFile(join(BACKEND_SRC, 'routes', 'video.ts'), 'utf-8');
+    schemaContent = await readFile(join(SHARED_DB, 'schema.ts'), 'utf-8');
+    serverContent = await readFile(join(BACKEND_SRC, 'server.ts'), 'utf-8');
+    initContent = await readFile(join(BACKEND_SRC, 'services', 'init.ts'), 'utf-8');
+    dockerfileContent = await readFile(join(SOURCE_ROOT, '..', 'Dockerfile'), 'utf-8');
+    assert.ok(serviceContent.length > 0);
+    assert.ok(routeContent.length > 0);
+    assert.ok(schemaContent.length > 0);
+    assert.ok(serverContent.length > 0);
+    assert.ok(dockerfileContent.length > 0);
+  });
+
+  describe('Schema', () => {
+    it('defines video_renders table', () => {
+      assert.ok(schemaContent.includes("videoRenders = sqliteTable('video_renders'"), 'schema should define video_renders table');
+    });
+
+    it('has required columns', () => {
+      assert.ok(schemaContent.includes("projectId: text('project_id')"), 'should have projectId column');
+      assert.ok(schemaContent.includes("featureId: text('feature_id')"), 'should have featureId column');
+      assert.ok(schemaContent.includes("compositionId: text('composition_id')"), 'should have compositionId column');
+      assert.ok(schemaContent.includes("status: text('status')"), 'should have status column');
+      assert.ok(schemaContent.includes("progress: real('progress')"), 'should have progress column');
+      assert.ok(schemaContent.includes("filePath: text('file_path')"), 'should have filePath column');
+      assert.ok(schemaContent.includes("fileSize: integer('file_size')"), 'should have fileSize column');
+      assert.ok(schemaContent.includes("durationSeconds: real('duration_seconds')"), 'should have durationSeconds column');
+      assert.ok(schemaContent.includes("error: text('error')"), 'should have error column');
+      assert.ok(schemaContent.includes("completedAt: text('completed_at')"), 'should have completedAt column');
+    });
+  });
+
+  describe('Service class', () => {
+    it('exports VideoRenderService class', () => {
+      assert.ok(serviceContent.includes('export class VideoRenderService'), 'should export VideoRenderService class');
+    });
+
+    it('uses constructor DI', () => {
+      assert.ok(serviceContent.includes('constructor({ getDb, workspacesDir, bundleOutputDir, log }'), 'should use constructor DI');
+    });
+
+    it('uses arrow functions for methods', () => {
+      assert.ok(serviceContent.includes('startRender = async'), 'startRender should be an arrow function');
+      assert.ok(serviceContent.includes('getStatus = async'), 'getStatus should be an arrow function');
+      assert.ok(serviceContent.includes('getFilePath = async'), 'getFilePath should be an arrow function');
+    });
+
+    it('uses @remotion/renderer for rendering', () => {
+      assert.ok(serviceContent.includes("from '@remotion/renderer'"), 'should import from @remotion/renderer');
+      assert.ok(serviceContent.includes('renderMedia'), 'should use renderMedia');
+      assert.ok(serviceContent.includes('selectComposition'), 'should use selectComposition');
+    });
+
+    it('tracks render progress', () => {
+      assert.ok(serviceContent.includes('onProgress'), 'should have onProgress callback');
+      assert.ok(serviceContent.includes('progress'), 'should update progress');
+    });
+
+    it('outputs to correct path pattern', () => {
+      assert.ok(serviceContent.includes("'media'"), 'should output under media directory');
+      assert.ok(serviceContent.includes("'outputs'"), 'should output to outputs subdirectory');
+    });
+
+    it('handles render status lifecycle', () => {
+      assert.ok(serviceContent.includes("status: 'queued'"), 'should set initial status to queued');
+      assert.ok(serviceContent.includes("status: 'rendering'"), 'should transition to rendering');
+      assert.ok(serviceContent.includes("status: 'complete'"), 'should transition to complete');
+      assert.ok(serviceContent.includes("status: 'failed'"), 'should transition to failed');
+    });
+
+    it('passes mediaBasePath as inputProps', () => {
+      assert.ok(serviceContent.includes('mediaBasePath'), 'should pass mediaBasePath');
+      assert.ok(serviceContent.includes('inputProps'), 'should set inputProps for composition');
+    });
+  });
+
+  describe('API routes', () => {
+    it('has POST /render endpoint', () => {
+      assert.ok(routeContent.includes("router.post('/render'"), 'should have POST /render route');
+    });
+
+    it('has GET /render/:id endpoint', () => {
+      assert.ok(routeContent.includes("router.get('/render/:id'"), 'should have GET /render/:id route');
+    });
+
+    it('has GET /file/:renderId endpoint', () => {
+      assert.ok(routeContent.includes("router.get('/file/:renderId'"), 'should have GET /file/:renderId route');
+    });
+
+    it('validates required POST parameters', () => {
+      assert.ok(routeContent.includes("'compositionId is required'"), 'should validate compositionId');
+      assert.ok(routeContent.includes("'projectId is required'"), 'should validate projectId');
+      assert.ok(routeContent.includes("'featureId is required'"), 'should validate featureId');
+    });
+
+    it('accepts render settings', () => {
+      assert.ok(routeContent.includes('resolution'), 'should accept resolution parameter');
+      assert.ok(routeContent.includes('fileOutputPrefix'), 'should accept fileOutputPrefix parameter');
+    });
+
+    it('serves MP4 files with sendFile', () => {
+      assert.ok(routeContent.includes('res.sendFile'), 'should use res.sendFile for MP4 delivery');
+    });
+  });
+
+  describe('Server integration', () => {
+    it('imports VideoRenderService in init.ts', () => {
+      assert.ok(initContent.includes("import { VideoRenderService }"), 'init.ts should import VideoRenderService');
+    });
+
+    it('instantiates VideoRenderService with DI in init.ts', () => {
+      assert.ok(initContent.includes('new VideoRenderService('), 'init.ts should instantiate VideoRenderService');
+    });
+
+    it('passes videoRenderService to video routes', () => {
+      assert.ok(serverContent.includes('videoRenderService'), 'server should pass videoRenderService to routes');
+    });
+  });
+
+  describe('Dockerfile', () => {
+    it('installs Chromium', () => {
+      assert.ok(dockerfileContent.includes('chromium'), 'Dockerfile should install chromium');
+    });
+
+    it('sets REMOTION_CHROME_EXECUTABLE_PATH', () => {
+      assert.ok(dockerfileContent.includes('REMOTION_CHROME_EXECUTABLE_PATH'), 'should set REMOTION_CHROME_EXECUTABLE_PATH');
+    });
+
+    it('sets PUPPETEER_EXECUTABLE_PATH', () => {
+      assert.ok(dockerfileContent.includes('PUPPETEER_EXECUTABLE_PATH'), 'should set PUPPETEER_EXECUTABLE_PATH');
+    });
+  });
+});
+
+describe('VideoRenderService resolution parsing', () => {
+  it('parses standard resolution', () => {
+    // Test the parseResolution logic by importing dynamically
+    const parseResolution = (resolution?: string): { width: number; height: number } => {
+      if (!resolution) return { width: 1920, height: 1080 };
+      const parts = resolution.split('x');
+      if (parts.length !== 2) return { width: 1920, height: 1080 };
+      const width = parseInt(parts[0], 10);
+      const height = parseInt(parts[1], 10);
+      if (isNaN(width) || isNaN(height)) return { width: 1920, height: 1080 };
+      return { width, height };
+    };
+
+    assert.deepStrictEqual(parseResolution('1920x1080'), { width: 1920, height: 1080 });
+    assert.deepStrictEqual(parseResolution('1080x1920'), { width: 1080, height: 1920 });
+    assert.deepStrictEqual(parseResolution('720x480'), { width: 720, height: 480 });
+    assert.deepStrictEqual(parseResolution(undefined), { width: 1920, height: 1080 });
+    assert.deepStrictEqual(parseResolution('invalid'), { width: 1920, height: 1080 });
+    assert.deepStrictEqual(parseResolution('axb'), { width: 1920, height: 1080 });
+    assert.deepStrictEqual(parseResolution(''), { width: 1920, height: 1080 });
+  });
+});