@quatrain/worker 1.2.7 → 1.2.9

package/dist/FileSystem.test.js

@@ -88,17 +88,17 @@ describe('FileSystem Utilities (Worker)', () => {
             return node_stream_1.Readable.from(Buffer.alloc(35 * 1024));
         });
         jest.spyOn(node_fs_1.default, 'existsSync').mockImplementation((p) => {
-            if (typeof p === 'string' && (p.endsWith('test.txt') || p.endsWith('small.mp4') || p.endsWith('large.mp4') || p.endsWith('large-fail.mp4'))) {
+            if (typeof p === 'string' && (p.endsWith('test.txt') || p.endsWith('small.mp4') || p.endsWith('large.mp4') || p.endsWith('large-fail.mp4') || p.endsWith('small-fail.mp4') || p.endsWith('large-sync-fail.mp4'))) {
                 return true;
             }
             return originalExistsSync(p);
         });
         jest.spyOn(node_fs_1.default, 'statSync').mockImplementation((p) => {
             if (typeof p === 'string') {
-                if (p.endsWith('small.mp4')) {
+                if (p.endsWith('small.mp4') || p.endsWith('small-fail.mp4')) {
                     return { size: 13 };
                 }
-                if (p.endsWith('large.mp4') || p.endsWith('large-fail.mp4')) {
+                if (p.endsWith('large.mp4') || p.endsWith('large-fail.mp4') || p.endsWith('large-sync-fail.mp4')) {
                     return { size: 35 * 1024 };
                 }
             }
@@ -252,8 +252,18 @@ describe('FileSystem Utilities (Worker)', () => {
             ffmpeg.ffprobe.mockImplementation((file, callback) => {
                 callback(null, mockMetadata);
             });
-            node_fetch_native_1.default.mockResolvedValue({
-                ok: true
+            node_fetch_native_1.default.mockImplementation((url, options) => {
+                return new Promise((resolve) => {
+                    if (options.body && typeof options.body.on === 'function') {
+                        options.body.on('data', () => { });
+                        options.body.on('end', () => {
+                            resolve({ ok: true });
+                        });
+                    }
+                    else {
+                        resolve({ ok: true });
+                    }
+                });
             });
             const meta = {
                 bucket: 'mock-bucket',
@@ -281,5 +291,42 @@ describe('FileSystem Utilities (Worker)', () => {
             };
             await expect(FileSystem_1.FileSystem.uploadFile(testFile, meta)).rejects.toThrow('Connection abort');
         });
+        it('should reject small uploads if HTTP request fails', async () => {
+            const testFile = node_path_1.default.join(testBaseDir, 'small-fail.mp4');
+            const mockMetadata = {
+                streams: [{ width: 320, height: 240, duration: '1', bit_rate: '100', nb_frames: '10' }]
+            };
+            ffmpeg.ffprobe.mockImplementation((file, callback) => {
+                callback(null, mockMetadata);
+            });
+            node_fetch_native_1.default.mockRejectedValue(new Error('Upload failed'));
+            // Stub readFileSync for small content read
+            jest.spyOn(node_fs_1.default, 'readFileSync').mockReturnValue(Buffer.from('small content'));
+            const meta = {
+                bucket: 'mock-bucket',
+                ref: 'remote/small-fail.mp4',
+                uploadUrl: 'https://upload.com/small-fail.mp4'
+            };
+            await expect(FileSystem_1.FileSystem.uploadFile(testFile, meta)).rejects.toThrow('Upload failed');
+        });
+        it('should handle synchronous errors inside stream initialization', async () => {
+            const testFile = node_path_1.default.join(testBaseDir, 'large-sync-fail.mp4');
+            const mockMetadata = {
+                streams: [{ width: 1280, height: 720, duration: '5', bit_rate: '2000', nb_frames: '150' }]
+            };
+            ffmpeg.ffprobe.mockImplementation((file, callback) => {
+                callback(null, mockMetadata);
+            });
+            // Make createReadStream throw a synchronous error
+            jest.spyOn(node_fs_1.default, 'createReadStream').mockImplementationOnce(() => {
+                throw new Error('Sync stream error');
+            });
+            const meta = {
+                bucket: 'mock-bucket',
+                ref: 'remote/large-sync-fail.mp4',
+                uploadUrl: 'https://upload.com/large-sync-fail.mp4'
+            };
+            await expect(FileSystem_1.FileSystem.uploadFile(testFile, meta)).rejects.toThrow('Sync stream error');
+        });
     });
 });

package/dist/Helpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Helpers.test.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Helpers_1 = require("./Helpers");
+const Worker_1 = require("./Worker");
+jest.mock('./Worker', () => {
+    const original = jest.requireActual('./Worker');
+    return {
+        Worker: {
+            ...original.Worker,
+            getSystemCommandPath: jest.fn().mockResolvedValue('/usr/bin/ffmpeg'),
+            execPromise: jest.fn().mockResolvedValue(true),
+            info: jest.fn(),
+        }
+    };
+});
+describe('Helpers', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should generate video thumbnail parameters correctly and execute ffmpeg', async () => {
+        const videoPath = 'test.mp4';
+        const outputPath = 'output.jpg';
+        const result = await Helpers_1.Helpers.generateVideoThumbnail(videoPath, outputPath, 5, 640);
+        expect(result).toBe(true);
+        expect(Worker_1.Worker.execPromise).toHaveBeenCalledWith('/usr/bin/ffmpeg', [
+            '-i',
+            'test.mp4',
+            '-vframes',
+            '1',
+            '-vf',
+            'select=gte(n\\,5)',
+            '-s',
+            '640x480',
+            '-ss',
+            '1',
+            'output.jpg',
+            '-y'
+        ]);
+    });
+    it('should use default values for frame and width', async () => {
+        const videoPath = 'test.mp4';
+        const outputPath = 'output.jpg';
+        const result = await Helpers_1.Helpers.generateVideoThumbnail(videoPath, outputPath);
+        expect(result).toBe(true);
+        expect(Worker_1.Worker.execPromise).toHaveBeenCalledWith('/usr/bin/ffmpeg', [
+            '-i',
+            'test.mp4',
+            '-vframes',
+            '1',
+            '-vf',
+            'select=gte(n\\,0)',
+            '-s',
+            '320x240',
+            '-ss',
+            '1',
+            'output.jpg',
+            '-y'
+        ]);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quatrain/worker",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "description": "Container Worker helpers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,7 +34,7 @@
     "typescript": "^5.1.5"
   },
   "dependencies": {
-    "@quatrain/core": "^1.2.14",
+    "@quatrain/core": "^1.2.15",
     "@quatrain/queue": "^1.2.3",
     "@quatrain/storage": "^1.2.9",
     "axios": "^1.7.7",

package/src/FileSystem.test.ts

@@ -57,7 +57,7 @@ describe('FileSystem Utilities (Worker)', () => {
       })
 
       jest.spyOn(fs, 'existsSync').mockImplementation((p) => {
-         if (typeof p === 'string' && (p.endsWith('test.txt') || p.endsWith('small.mp4') || p.endsWith('large.mp4') || p.endsWith('large-fail.mp4'))) {
+         if (typeof p === 'string' && (p.endsWith('test.txt') || p.endsWith('small.mp4') || p.endsWith('large.mp4') || p.endsWith('large-fail.mp4') || p.endsWith('small-fail.mp4') || p.endsWith('large-sync-fail.mp4'))) {
             return true
          }
          return originalExistsSync(p)
@@ -65,10 +65,10 @@ describe('FileSystem Utilities (Worker)', () => {
 
       jest.spyOn(fs, 'statSync').mockImplementation((p) => {
          if (typeof p === 'string') {
-            if (p.endsWith('small.mp4')) {
+            if (p.endsWith('small.mp4') || p.endsWith('small-fail.mp4')) {
                return { size: 13 } as any
             }
-            if (p.endsWith('large.mp4') || p.endsWith('large-fail.mp4')) {
+            if (p.endsWith('large.mp4') || p.endsWith('large-fail.mp4') || p.endsWith('large-sync-fail.mp4')) {
                return { size: 35 * 1024 } as any
             }
          }
@@ -255,8 +255,17 @@ describe('FileSystem Utilities (Worker)', () => {
             callback(null, mockMetadata)
          });
 
-         (fetch as any).mockResolvedValue({
-            ok: true
+         (fetch as any).mockImplementation((url: string, options: any) => {
+            return new Promise((resolve) => {
+               if (options.body && typeof options.body.on === 'function') {
+                  options.body.on('data', () => {})
+                  options.body.on('end', () => {
+                     resolve({ ok: true })
+                  })
+               } else {
+                  resolve({ ok: true })
+               }
+            })
          })
 
          const meta = {
@@ -291,5 +300,53 @@ describe('FileSystem Utilities (Worker)', () => {
 
          await expect(FileSystem.uploadFile(testFile, meta)).rejects.toThrow('Connection abort')
       })
+
+      it('should reject small uploads if HTTP request fails', async () => {
+         const testFile = path.join(testBaseDir, 'small-fail.mp4')
+
+         const mockMetadata = {
+            streams: [{ width: 320, height: 240, duration: '1', bit_rate: '100', nb_frames: '10' }]
+         };
+         (ffmpeg.ffprobe as any).mockImplementation((file: string, callback: any) => {
+            callback(null, mockMetadata)
+         });
+
+         (fetch as any).mockRejectedValue(new Error('Upload failed'))
+
+         // Stub readFileSync for small content read
+         jest.spyOn(fs, 'readFileSync').mockReturnValue(Buffer.from('small content'))
+
+         const meta = {
+            bucket: 'mock-bucket',
+            ref: 'remote/small-fail.mp4',
+            uploadUrl: 'https://upload.com/small-fail.mp4'
+         }
+
+         await expect(FileSystem.uploadFile(testFile, meta)).rejects.toThrow('Upload failed')
+      })
+
+      it('should handle synchronous errors inside stream initialization', async () => {
+         const testFile = path.join(testBaseDir, 'large-sync-fail.mp4')
+
+         const mockMetadata = {
+            streams: [{ width: 1280, height: 720, duration: '5', bit_rate: '2000', nb_frames: '150' }]
+         };
+         (ffmpeg.ffprobe as any).mockImplementation((file: string, callback: any) => {
+            callback(null, mockMetadata)
+         });
+
+         // Make createReadStream throw a synchronous error
+         jest.spyOn(fs, 'createReadStream').mockImplementationOnce(() => {
+            throw new Error('Sync stream error')
+         })
+
+         const meta = {
+            bucket: 'mock-bucket',
+            ref: 'remote/large-sync-fail.mp4',
+            uploadUrl: 'https://upload.com/large-sync-fail.mp4'
+         }
+
+         await expect(FileSystem.uploadFile(testFile, meta)).rejects.toThrow('Sync stream error')
+      })
    })
 })

package/src/Helpers.test.ts

@@ -0,0 +1,66 @@
+import { Helpers } from './Helpers'
+import { Worker } from './Worker'
+
+jest.mock('./Worker', () => {
+   const original = jest.requireActual('./Worker')
+   return {
+      Worker: {
+         ...original.Worker,
+         getSystemCommandPath: jest.fn().mockResolvedValue('/usr/bin/ffmpeg'),
+         execPromise: jest.fn().mockResolvedValue(true),
+         info: jest.fn(),
+      }
+   }
+})
+
+describe('Helpers', () => {
+   beforeEach(() => {
+      jest.clearAllMocks()
+   })
+
+   it('should generate video thumbnail parameters correctly and execute ffmpeg', async () => {
+      const videoPath = 'test.mp4'
+      const outputPath = 'output.jpg'
+      
+      const result = await Helpers.generateVideoThumbnail(videoPath, outputPath, 5, 640)
+      
+      expect(result).toBe(true)
+      expect(Worker.execPromise).toHaveBeenCalledWith('/usr/bin/ffmpeg', [
+         '-i',
+         'test.mp4',
+         '-vframes',
+         '1',
+         '-vf',
+         'select=gte(n\\,5)',
+         '-s',
+         '640x480',
+         '-ss',
+         '1',
+         'output.jpg',
+         '-y'
+      ])
+   })
+
+   it('should use default values for frame and width', async () => {
+      const videoPath = 'test.mp4'
+      const outputPath = 'output.jpg'
+      
+      const result = await Helpers.generateVideoThumbnail(videoPath, outputPath)
+      
+      expect(result).toBe(true)
+      expect(Worker.execPromise).toHaveBeenCalledWith('/usr/bin/ffmpeg', [
+         '-i',
+         'test.mp4',
+         '-vframes',
+         '1',
+         '-vf',
+         'select=gte(n\\,0)',
+         '-s',
+         '320x240',
+         '-ss',
+         '1',
+         'output.jpg',
+         '-y'
+      ])
+   })
+})