@quatrain/worker 1.2.6 → 1.2.8

package/dist/FileSystem.test.d.ts

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

package/dist/FileSystem.test.js

@@ -0,0 +1,285 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const FileSystem_1 = require("./FileSystem");
+const axios_1 = __importDefault(require("axios"));
+const node_fetch_native_1 = __importDefault(require("node-fetch-native"));
+const ffmpeg = __importStar(require("fluent-ffmpeg"));
+const node_stream_1 = require("node:stream");
+jest.mock('axios');
+jest.mock('node-fetch-native');
+jest.mock('fluent-ffmpeg', () => ({
+    ffprobe: jest.fn()
+}));
+// Mock @quatrain/log globally to completely silence all logging calls across the monorepo graph during worker tests.
+// Returns a valid dummy logger object to satisfy Core.addLogger and Worker.addLogger definitions.
+jest.mock('@quatrain/log', () => {
+    const dummyLoggerInstance = {
+        log: jest.fn(),
+        info: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn()
+    };
+    return {
+        Log: {
+            info: jest.fn(),
+            debug: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+            addLogger: jest.fn().mockReturnValue(dummyLoggerInstance)
+        },
+        LogLevel: {
+            INFO: 1,
+            DEBUG: 0,
+            ERROR: 3,
+            WARN: 2
+        },
+        DefaultLoggerAdapter: jest.fn().mockImplementation(() => dummyLoggerInstance)
+    };
+});
+const originalExistsSync = node_fs_1.default.existsSync;
+describe('FileSystem Utilities (Worker)', () => {
+    const testBaseDir = node_path_1.default.resolve(__dirname, 'temp_test_dir');
+    beforeEach(() => {
+        // Mock createWriteStream and createReadStream to return in-memory streams.
+        // This completely prevents physical file descriptor locks and background ENOENT races.
+        jest.spyOn(node_fs_1.default, 'createWriteStream').mockImplementation(() => {
+            return new node_stream_1.PassThrough();
+        });
+        jest.spyOn(node_fs_1.default, 'createReadStream').mockImplementation(() => {
+            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'))) {
+                return true;
+            }
+            return originalExistsSync(p);
+        });
+        jest.spyOn(node_fs_1.default, 'statSync').mockImplementation((p) => {
+            if (typeof p === 'string') {
+                if (p.endsWith('small.mp4')) {
+                    return { size: 13 };
+                }
+                if (p.endsWith('large.mp4') || p.endsWith('large-fail.mp4')) {
+                    return { size: 35 * 1024 };
+                }
+            }
+            return (jest.requireActual('node:fs').statSync)(p);
+        });
+        // Setup base temp folder if needed
+        if (originalExistsSync(testBaseDir)) {
+            node_fs_1.default.rmSync(testBaseDir, { recursive: true, force: true });
+        }
+    });
+    afterEach(() => {
+        // Clean up base temp folder
+        if (originalExistsSync(testBaseDir)) {
+            node_fs_1.default.rmSync(testBaseDir, { recursive: true, force: true });
+        }
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+    });
+    describe('prepare and Directory Actions', () => {
+        it('should prepare standard workspace layouts', () => {
+            // Restore real fs methods for actual directory testing
+            jest.restoreAllMocks();
+            FileSystem_1.FileSystem.prepare(testBaseDir);
+            expect(node_fs_1.default.existsSync(testBaseDir)).toBe(true);
+            expect(node_fs_1.default.existsSync(node_path_1.default.join(testBaseDir, 'images'))).toBe(true);
+            expect(node_fs_1.default.existsSync(node_path_1.default.join(testBaseDir, 'vecto'))).toBe(true);
+        });
+        it('should create directories using makeFolder', () => {
+            jest.restoreAllMocks();
+            node_fs_1.default.mkdirSync(testBaseDir);
+            const subDir = node_path_1.default.join(testBaseDir, 'custom');
+            FileSystem_1.FileSystem.makeFolder(subDir);
+            expect(node_fs_1.default.existsSync(subDir)).toBe(true);
+        });
+        it('should recursively clear directories', () => {
+            jest.restoreAllMocks();
+            FileSystem_1.FileSystem.prepare(testBaseDir);
+            const sub = node_path_1.default.join(testBaseDir, 'images', 'nested');
+            node_fs_1.default.mkdirSync(sub);
+            node_fs_1.default.writeFileSync(node_path_1.default.join(sub, 'file.txt'), 'hello');
+            node_fs_1.default.writeFileSync(node_path_1.default.join(testBaseDir, 'rootfile.txt'), 'world');
+            expect(node_fs_1.default.existsSync(sub)).toBe(true);
+            FileSystem_1.FileSystem.removeFolder(testBaseDir, true);
+            expect(node_fs_1.default.existsSync(testBaseDir)).toBe(false);
+        });
+        it('should throw an error on non-recursive deletion containing directories', () => {
+            jest.restoreAllMocks();
+            node_fs_1.default.mkdirSync(testBaseDir);
+            node_fs_1.default.mkdirSync(node_path_1.default.join(testBaseDir, 'nested'));
+            expect(() => FileSystem_1.FileSystem.removeFolder(testBaseDir, false)).toThrow('Folder contains folder');
+        });
+    });
+    describe('downloadFile', () => {
+        it('should download files to target local paths', async () => {
+            const mockStream = {
+                pipe: jest.fn((writer) => {
+                    process.nextTick(() => {
+                        writer.end();
+                    });
+                })
+            };
+            axios_1.default.get.mockResolvedValue({
+                data: mockStream
+            });
+            const filepath = node_path_1.default.join(testBaseDir, 'test.txt');
+            const result = await FileSystem_1.FileSystem.downloadFile('https://example.com/test.txt', filepath);
+            expect(result).toBe(true);
+            expect(axios_1.default.get).toHaveBeenCalledWith('https://example.com/test.txt', {
+                responseType: 'stream'
+            });
+            expect(node_fs_1.default.existsSync(filepath)).toBe(true);
+        });
+        it('should catch and propagate download failures', async () => {
+            axios_1.default.get.mockRejectedValue(new Error('Network error'));
+            const filepath = node_path_1.default.join(testBaseDir, 'test.txt');
+            await expect(FileSystem_1.FileSystem.downloadFile('https://example.com/test.txt', filepath)).rejects.toThrow('Network error');
+        });
+    });
+    describe('safeString', () => {
+        it('should convert spaces to underscores', () => {
+            expect(FileSystem_1.FileSystem.safeString('hello world  test')).toBe('hello_world_test');
+            expect(FileSystem_1.FileSystem.safeString('clean-name')).toBe('clean-name');
+        });
+    });
+    describe('getInfo (Media probe)', () => {
+        it('should resolve metadata from video extensions', async () => {
+            const mockMetadata = {
+                streams: [
+                    {
+                        width: 1920,
+                        height: 1080,
+                        duration: '10.5',
+                        bit_rate: '5000',
+                        nb_frames: '300'
+                    }
+                ]
+            };
+            ffmpeg.ffprobe.mockImplementation((file, callback) => {
+                callback(null, mockMetadata);
+            });
+            const info = await FileSystem_1.FileSystem.getInfo('video.mp4');
+            expect(info).toEqual({
+                width: 1920,
+                height: 1080,
+                framerate: 29,
+                duration: 10,
+                bitrate: '5000'
+            });
+        });
+        it('should bypass non-video extensions silently', async () => {
+            const info = await FileSystem_1.FileSystem.getInfo('document.pdf');
+            expect(info).toEqual({});
+        });
+        it('should bubble up probe errors', async () => {
+            ffmpeg.ffprobe.mockImplementation((file, callback) => {
+                callback(new Error('Probe failed'));
+            });
+            await expect(FileSystem_1.FileSystem.getInfo('video.mp4')).rejects.toThrow('Probe failed');
+        });
+    });
+    describe('uploadFile', () => {
+        it('should upload small files (< 32KB) using full read buffers', async () => {
+            const testFile = node_path_1.default.join(testBaseDir, 'small.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.mockResolvedValue({
+                ok: true
+            });
+            // 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.mp4',
+                uploadUrl: 'https://upload.com/small.mp4'
+            };
+            const result = await FileSystem_1.FileSystem.uploadFile(testFile, meta);
+            expect(result.size).toBe(13);
+            expect(result.width).toBe(320);
+            expect(result.uploadUrl).toBeUndefined();
+            expect(node_fetch_native_1.default).toHaveBeenCalledWith('https://upload.com/small.mp4', expect.any(Object));
+        });
+        it('should upload large files (>= 32KB) using readable streams', async () => {
+            const testFile = node_path_1.default.join(testBaseDir, 'large.mp4');
+            const mockMetadata = {
+                streams: [{ width: 1280, height: 720, duration: '5', bit_rate: '2000', nb_frames: '150' }]
+            };
+            ffmpeg.ffprobe.mockImplementation((file, callback) => {
+                callback(null, mockMetadata);
+            });
+            node_fetch_native_1.default.mockResolvedValue({
+                ok: true
+            });
+            const meta = {
+                bucket: 'mock-bucket',
+                ref: 'remote/large.mp4',
+                uploadUrl: 'https://upload.com/large.mp4'
+            };
+            const result = await FileSystem_1.FileSystem.uploadFile(testFile, meta);
+            expect(result.size).toBe(35 * 1024);
+            expect(result.uploadUrl).toBeUndefined();
+            expect(node_fetch_native_1.default).toHaveBeenCalledWith('https://upload.com/large.mp4', expect.any(Object));
+        });
+        it('should reject large uploads if HTTP request fails', async () => {
+            const testFile = node_path_1.default.join(testBaseDir, 'large-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);
+            });
+            node_fetch_native_1.default.mockRejectedValue(new Error('Connection abort'));
+            const meta = {
+                bucket: 'mock-bucket',
+                ref: 'remote/large-fail.mp4',
+                uploadUrl: 'https://upload.com/large-fail.mp4'
+            };
+            await expect(FileSystem_1.FileSystem.uploadFile(testFile, meta)).rejects.toThrow('Connection abort');
+        });
+    });
+});

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.6",
+  "version": "1.2.8",
   "description": "Container Worker helpers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -36,7 +36,7 @@
   "dependencies": {
     "@quatrain/core": "^1.2.14",
     "@quatrain/queue": "^1.2.3",
-    "@quatrain/storage": "^1.2.8",
+    "@quatrain/storage": "^1.2.9",
     "axios": "^1.7.7",
     "fluent-ffmpeg": "^2.1.2",
     "fs-extra": "^11.2.0",

package/src/FileSystem.test.ts

@@ -0,0 +1,295 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { FileSystem } from './FileSystem'
+import axios from 'axios'
+import fetch from 'node-fetch-native'
+import * as ffmpeg from 'fluent-ffmpeg'
+import { PassThrough, Readable } from 'node:stream'
+
+jest.mock('axios')
+jest.mock('node-fetch-native')
+jest.mock('fluent-ffmpeg', () => ({
+   ffprobe: jest.fn()
+}))
+
+// Mock @quatrain/log globally to completely silence all logging calls across the monorepo graph during worker tests.
+// Returns a valid dummy logger object to satisfy Core.addLogger and Worker.addLogger definitions.
+jest.mock('@quatrain/log', () => {
+   const dummyLoggerInstance = {
+      log: jest.fn(),
+      info: jest.fn(),
+      debug: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn()
+   }
+   return {
+      Log: {
+         info: jest.fn(),
+         debug: jest.fn(),
+         error: jest.fn(),
+         warn: jest.fn(),
+         addLogger: jest.fn().mockReturnValue(dummyLoggerInstance)
+      },
+      LogLevel: {
+         INFO: 1,
+         DEBUG: 0,
+         ERROR: 3,
+         WARN: 2
+      },
+      DefaultLoggerAdapter: jest.fn().mockImplementation(() => dummyLoggerInstance)
+   }
+})
+
+const originalExistsSync = fs.existsSync
+
+describe('FileSystem Utilities (Worker)', () => {
+   const testBaseDir = path.resolve(__dirname, 'temp_test_dir')
+
+   beforeEach(() => {
+      // Mock createWriteStream and createReadStream to return in-memory streams.
+      // This completely prevents physical file descriptor locks and background ENOENT races.
+      jest.spyOn(fs, 'createWriteStream').mockImplementation(() => {
+         return new PassThrough() as any
+      })
+
+      jest.spyOn(fs, 'createReadStream').mockImplementation(() => {
+         return Readable.from(Buffer.alloc(35 * 1024)) as any
+      })
+
+      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'))) {
+            return true
+         }
+         return originalExistsSync(p)
+      })
+
+      jest.spyOn(fs, 'statSync').mockImplementation((p) => {
+         if (typeof p === 'string') {
+            if (p.endsWith('small.mp4')) {
+               return { size: 13 } as any
+            }
+            if (p.endsWith('large.mp4') || p.endsWith('large-fail.mp4')) {
+               return { size: 35 * 1024 } as any
+            }
+         }
+         return (jest.requireActual('node:fs').statSync)(p)
+      })
+
+      // Setup base temp folder if needed
+      if (originalExistsSync(testBaseDir)) {
+         fs.rmSync(testBaseDir, { recursive: true, force: true })
+      }
+   })
+
+   afterEach(() => {
+      // Clean up base temp folder
+      if (originalExistsSync(testBaseDir)) {
+         fs.rmSync(testBaseDir, { recursive: true, force: true })
+      }
+      jest.clearAllMocks()
+      jest.restoreAllMocks()
+   })
+
+   describe('prepare and Directory Actions', () => {
+      it('should prepare standard workspace layouts', () => {
+         // Restore real fs methods for actual directory testing
+         jest.restoreAllMocks()
+         FileSystem.prepare(testBaseDir)
+
+         expect(fs.existsSync(testBaseDir)).toBe(true)
+         expect(fs.existsSync(path.join(testBaseDir, 'images'))).toBe(true)
+         expect(fs.existsSync(path.join(testBaseDir, 'vecto'))).toBe(true)
+      })
+
+      it('should create directories using makeFolder', () => {
+         jest.restoreAllMocks()
+         fs.mkdirSync(testBaseDir)
+         const subDir = path.join(testBaseDir, 'custom')
+         FileSystem.makeFolder(subDir)
+         expect(fs.existsSync(subDir)).toBe(true)
+      })
+
+      it('should recursively clear directories', () => {
+         jest.restoreAllMocks()
+         FileSystem.prepare(testBaseDir)
+         const sub = path.join(testBaseDir, 'images', 'nested')
+         fs.mkdirSync(sub)
+         fs.writeFileSync(path.join(sub, 'file.txt'), 'hello')
+         fs.writeFileSync(path.join(testBaseDir, 'rootfile.txt'), 'world')
+
+         expect(fs.existsSync(sub)).toBe(true)
+
+         FileSystem.removeFolder(testBaseDir, true)
+         expect(fs.existsSync(testBaseDir)).toBe(false)
+      })
+
+      it('should throw an error on non-recursive deletion containing directories', () => {
+         jest.restoreAllMocks()
+         fs.mkdirSync(testBaseDir)
+         fs.mkdirSync(path.join(testBaseDir, 'nested'))
+
+         expect(() => FileSystem.removeFolder(testBaseDir, false)).toThrow('Folder contains folder')
+      })
+   })
+
+   describe('downloadFile', () => {
+      it('should download files to target local paths', async () => {
+         const mockStream = {
+            pipe: jest.fn((writer) => {
+               process.nextTick(() => {
+                  writer.end()
+               })
+            })
+         };
+
+         (axios.get as jest.Mock).mockResolvedValue({
+            data: mockStream
+         })
+
+         const filepath = path.join(testBaseDir, 'test.txt')
+
+         const result = await FileSystem.downloadFile('https://example.com/test.txt', filepath)
+         expect(result).toBe(true)
+         expect(axios.get).toHaveBeenCalledWith('https://example.com/test.txt', {
+            responseType: 'stream'
+         })
+         expect(fs.existsSync(filepath)).toBe(true)
+      })
+
+      it('should catch and propagate download failures', async () => {
+         (axios.get as jest.Mock).mockRejectedValue(new Error('Network error'))
+
+         const filepath = path.join(testBaseDir, 'test.txt')
+
+         await expect(FileSystem.downloadFile('https://example.com/test.txt', filepath)).rejects.toThrow('Network error')
+      })
+   })
+
+   describe('safeString', () => {
+      it('should convert spaces to underscores', () => {
+         expect(FileSystem.safeString('hello world  test')).toBe('hello_world_test')
+         expect(FileSystem.safeString('clean-name')).toBe('clean-name')
+      })
+   })
+
+   describe('getInfo (Media probe)', () => {
+      it('should resolve metadata from video extensions', async () => {
+         const mockMetadata = {
+            streams: [
+               {
+                  width: 1920,
+                  height: 1080,
+                  duration: '10.5',
+                  bit_rate: '5000',
+                  nb_frames: '300'
+               }
+            ]
+         };
+
+         (ffmpeg.ffprobe as any).mockImplementation((file: string, callback: any) => {
+            callback(null, mockMetadata)
+         })
+
+         const info = await FileSystem.getInfo('video.mp4')
+         expect(info).toEqual({
+            width: 1920,
+            height: 1080,
+            framerate: 29,
+            duration: 10,
+            bitrate: '5000'
+         })
+      })
+
+      it('should bypass non-video extensions silently', async () => {
+         const info = await FileSystem.getInfo('document.pdf')
+         expect(info).toEqual({})
+      })
+
+      it('should bubble up probe errors', async () => {
+         (ffmpeg.ffprobe as any).mockImplementation((file: string, callback: any) => {
+            callback(new Error('Probe failed'))
+         })
+
+         await expect(FileSystem.getInfo('video.mp4')).rejects.toThrow('Probe failed')
+      })
+   })
+
+   describe('uploadFile', () => {
+      it('should upload small files (< 32KB) using full read buffers', async () => {
+         const testFile = path.join(testBaseDir, 'small.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).mockResolvedValue({
+            ok: true
+         })
+
+         // Stub readFileSync for small content read
+         jest.spyOn(fs, 'readFileSync').mockReturnValue(Buffer.from('small content'))
+
+         const meta = {
+            bucket: 'mock-bucket',
+            ref: 'remote/small.mp4',
+            uploadUrl: 'https://upload.com/small.mp4'
+         }
+
+         const result = await FileSystem.uploadFile(testFile, meta)
+         expect(result.size).toBe(13)
+         expect(result.width).toBe(320)
+         expect(result.uploadUrl).toBeUndefined()
+         expect(fetch).toHaveBeenCalledWith('https://upload.com/small.mp4', expect.any(Object))
+      })
+
+      it('should upload large files (>= 32KB) using readable streams', async () => {
+         const testFile = path.join(testBaseDir, 'large.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)
+         });
+
+         (fetch as any).mockResolvedValue({
+            ok: true
+         })
+
+         const meta = {
+            bucket: 'mock-bucket',
+            ref: 'remote/large.mp4',
+            uploadUrl: 'https://upload.com/large.mp4'
+         }
+
+         const result = await FileSystem.uploadFile(testFile, meta)
+         expect(result.size).toBe(35 * 1024)
+         expect(result.uploadUrl).toBeUndefined()
+         expect(fetch).toHaveBeenCalledWith('https://upload.com/large.mp4', expect.any(Object))
+      })
+
+      it('should reject large uploads if HTTP request fails', async () => {
+         const testFile = path.join(testBaseDir, 'large-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)
+         });
+
+         (fetch as any).mockRejectedValue(new Error('Connection abort'))
+
+         const meta = {
+            bucket: 'mock-bucket',
+            ref: 'remote/large-fail.mp4',
+            uploadUrl: 'https://upload.com/large-fail.mp4'
+         }
+
+         await expect(FileSystem.uploadFile(testFile, meta)).rejects.toThrow('Connection abort')
+      })
+   })
+})

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'
+      ])
+   })
+})