@quatrain/worker 1.2.5 → 1.2.7

package/dist/FileSystem.js

@@ -135,9 +135,10 @@ class FileSystem {
      * @param mime
      * @returns Promise
      */
-    static uploadFile(filename, meta, mime = 'video/mp4') {
+    static async uploadFile(filename, meta, mime = 'video/mp4') {
         // try to get more file metadata
-        meta = { ...meta, ...FileSystem.getInfo(filename) };
+        const info = await FileSystem.getInfo(filename);
+        meta = { ...meta, ...info };
         Worker_1.Worker.info(`Uploading file ${filename} to ${meta.uploadUrl}`);
         const { size } = node_fs_1.default.statSync(filename);
         if (size < 32 * 1024) {

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/Worker.test.js

@@ -9,6 +9,18 @@ const node_child_process_1 = require("node:child_process");
 // Mock dependencies
 jest.mock('axios');
 jest.mock('node:child_process');
+jest.mock('@quatrain/queue', () => {
+    const mockQueueInstance = {
+        listen: jest.fn(),
+    };
+    return {
+        Queue: {
+            addQueue: jest.fn(),
+            getQueue: jest.fn(() => mockQueueInstance),
+            info: jest.fn(),
+        },
+    };
+}, { virtual: true });
 const mockedAxios = axios_1.default;
 const mockedSpawn = node_child_process_1.spawn;
 describe('Worker', () => {
@@ -77,6 +89,25 @@ describe('Worker', () => {
                 metadata: { size: 1024 },
             }));
         });
+        it('should execute then block on success in pushEvent', async () => {
+            Worker_1.Worker.endpoint = 'https://api.example.com/events';
+            mockedAxios.patch.mockResolvedValue({
+                statusText: 'OK',
+                data: { success: true },
+            });
+            Worker_1.Worker.pushEvent('test-event');
+            // Allow microtasks to run so .then is executed
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(mockedAxios.patch).toHaveBeenCalled();
+        });
+        it('should handle axios error in pushEvent', async () => {
+            Worker_1.Worker.endpoint = 'https://api.example.com/events';
+            mockedAxios.patch.mockRejectedValue(new Error('Network error'));
+            Worker_1.Worker.pushEvent('test-event');
+            // Allow microtasks to run so .catch is executed
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(mockedAxios.patch).toHaveBeenCalled();
+        });
     });
     describe('pushEventAsync', () => {
         it('should return false when endpoint is not set', async () => {
@@ -213,6 +244,83 @@ describe('Worker', () => {
                 shell: false,
             });
         });
+        it('should throw an error when spawn itself throws', async () => {
+            mockedSpawn.mockImplementationOnce(() => {
+                throw new Error('Spawn failure');
+            });
+            await expect(Worker_1.Worker.execPromise('cmd')).rejects.toThrow('Spawn failure');
+        });
+        it('should throw and log when an error occurs before the promise constructor', async () => {
+            const spyInfo = jest.spyOn(Worker_1.Worker, 'info').mockImplementationOnce(() => {
+                throw new Error('Before promise error');
+            });
+            await expect(() => Worker_1.Worker.execPromise('cmd')).toThrow('Before promise error');
+            spyInfo.mockRestore();
+        });
+    });
+    describe('handler', () => {
+        let originalExit;
+        beforeAll(() => {
+            originalExit = process.exit;
+            process.exit = jest.fn();
+        });
+        afterAll(() => {
+            process.exit = originalExit;
+        });
+        beforeEach(() => {
+            jest.clearAllMocks();
+            delete process.env.JSON;
+        });
+        it('should listen to queue in queue mode', async () => {
+            const messageHandler = jest.fn();
+            const config = {
+                mode: 'queue',
+                topic: 'test-topic',
+                queueAdapter: 'test-adapter',
+                concurrency: 5,
+                gpu: false,
+            };
+            const { Queue } = require('@quatrain/queue');
+            await Worker_1.Worker.handler(messageHandler, config);
+            expect(Queue.addQueue).toHaveBeenCalledWith('test-adapter', 'default', true);
+            expect(Queue.getQueue().listen).toHaveBeenCalledWith('test-topic', messageHandler, {
+                concurrency: 5,
+                gpu: false,
+            });
+        });
+        it('should handle test mode and call messageHandler', async () => {
+            const messageHandler = jest.fn();
+            const config = {
+                mode: 'test',
+            };
+            await Worker_1.Worker.handler(messageHandler, config);
+            expect(messageHandler).toHaveBeenCalledWith(expect.objectContaining({ dummy: 'test-data' }));
+        });
+        it('should handle cli mode with environment variable', async () => {
+            const messageHandler = jest.fn();
+            process.env.JSON = JSON.stringify({ cli: 'data' });
+            const config = {
+                mode: 'cli',
+            };
+            await Worker_1.Worker.handler(messageHandler, config);
+            expect(messageHandler).toHaveBeenCalledWith(JSON.stringify({ cli: 'data' }));
+        });
+        it('should throw when cli mode has no environment variable', async () => {
+            const messageHandler = jest.fn();
+            const config = {
+                mode: 'cli',
+            };
+            await Worker_1.Worker.handler(messageHandler, config);
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+        it('should exit when mode is unknown', async () => {
+            const messageHandler = jest.fn();
+            const config = {
+                mode: 'unknown',
+            };
+            await Worker_1.Worker.handler(messageHandler, config);
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
     });
     describe('logger', () => {
         it('should have a logger instance', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quatrain/worker",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "description": "Container Worker helpers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,9 +34,9 @@
     "typescript": "^5.1.5"
   },
   "dependencies": {
-    "@quatrain/core": "^1.2.9",
+    "@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/FileSystem.ts

@@ -105,13 +105,14 @@ export class FileSystem {
     * @param mime
     * @returns Promise
     */
-   static uploadFile(
+   static async uploadFile(
       filename: string,
       meta: FileType,
       mime = 'video/mp4'
    ): Promise<FileType> {
       // try to get more file metadata
-      meta = { ...meta, ...FileSystem.getInfo(filename) }
+      const info = await FileSystem.getInfo(filename)
+      meta = { ...meta, ...info }
       Worker.info(`Uploading file ${filename} to ${meta.uploadUrl}`)
       const { size } = fs.statSync(filename)
 

package/src/Worker.test.ts

@@ -5,6 +5,18 @@ import { spawn } from 'node:child_process'
 // Mock dependencies
 jest.mock('axios')
 jest.mock('node:child_process')
+jest.mock('@quatrain/queue', () => {
+   const mockQueueInstance = {
+      listen: jest.fn(),
+   }
+   return {
+      Queue: {
+         addQueue: jest.fn(),
+         getQueue: jest.fn(() => mockQueueInstance),
+         info: jest.fn(),
+      },
+   }
+}, { virtual: true })
 
 const mockedAxios = axios as jest.Mocked<typeof axios>
 const mockedSpawn = spawn as jest.MockedFunction<typeof spawn>
@@ -101,6 +113,35 @@ describe('Worker', () => {
             })
          )
       })
+
+      it('should execute then block on success in pushEvent', async () => {
+         Worker.endpoint = 'https://api.example.com/events'
+
+         mockedAxios.patch.mockResolvedValue({
+            statusText: 'OK',
+            data: { success: true },
+         })
+
+         Worker.pushEvent('test-event')
+
+         // Allow microtasks to run so .then is executed
+         await new Promise((resolve) => setTimeout(resolve, 0))
+
+         expect(mockedAxios.patch).toHaveBeenCalled()
+      })
+
+      it('should handle axios error in pushEvent', async () => {
+         Worker.endpoint = 'https://api.example.com/events'
+
+         mockedAxios.patch.mockRejectedValue(new Error('Network error'))
+
+         Worker.pushEvent('test-event')
+
+         // Allow microtasks to run so .catch is executed
+         await new Promise((resolve) => setTimeout(resolve, 0))
+
+         expect(mockedAxios.patch).toHaveBeenCalled()
+      })
    })
 
    describe('pushEventAsync', () => {
@@ -282,6 +323,109 @@ describe('Worker', () => {
             shell: false,
          })
       })
+
+      it('should throw an error when spawn itself throws', async () => {
+         mockedSpawn.mockImplementationOnce(() => {
+            throw new Error('Spawn failure')
+         })
+
+         await expect(Worker.execPromise('cmd')).rejects.toThrow('Spawn failure')
+      })
+
+      it('should throw and log when an error occurs before the promise constructor', async () => {
+         const spyInfo = jest.spyOn(Worker, 'info').mockImplementationOnce(() => {
+            throw new Error('Before promise error')
+         })
+
+         await expect(() => Worker.execPromise('cmd')).toThrow('Before promise error')
+         spyInfo.mockRestore()
+      })
+   })
+
+   describe('handler', () => {
+      let originalExit: any
+
+      beforeAll(() => {
+         originalExit = process.exit
+         process.exit = jest.fn() as any
+      })
+
+      afterAll(() => {
+         process.exit = originalExit
+      })
+
+      beforeEach(() => {
+         jest.clearAllMocks()
+         delete process.env.JSON
+      })
+
+      it('should listen to queue in queue mode', async () => {
+         const messageHandler = jest.fn()
+         const config = {
+            mode: 'queue' as const,
+            topic: 'test-topic',
+            queueAdapter: 'test-adapter' as any,
+            concurrency: 5,
+            gpu: false,
+         }
+
+         const { Queue } = require('@quatrain/queue')
+
+         await Worker.handler(messageHandler, config)
+
+         expect(Queue.addQueue).toHaveBeenCalledWith('test-adapter', 'default', true)
+         expect(Queue.getQueue().listen).toHaveBeenCalledWith('test-topic', messageHandler, {
+            concurrency: 5,
+            gpu: false,
+         })
+      })
+
+      it('should handle test mode and call messageHandler', async () => {
+         const messageHandler = jest.fn()
+         const config = {
+            mode: 'test' as const,
+         }
+
+         await Worker.handler(messageHandler, config)
+
+         expect(messageHandler).toHaveBeenCalledWith(
+            expect.objectContaining({ dummy: 'test-data' })
+         )
+      })
+
+      it('should handle cli mode with environment variable', async () => {
+         const messageHandler = jest.fn()
+         process.env.JSON = JSON.stringify({ cli: 'data' })
+         const config = {
+            mode: 'cli' as const,
+         }
+
+         await Worker.handler(messageHandler, config)
+
+         expect(messageHandler).toHaveBeenCalledWith(JSON.stringify({ cli: 'data' }))
+      })
+
+      it('should throw when cli mode has no environment variable', async () => {
+         const messageHandler = jest.fn()
+         const config = {
+            mode: 'cli' as const,
+         }
+
+         await Worker.handler(messageHandler, config)
+
+         expect(process.exit).toHaveBeenCalledWith(1)
+      })
+
+      it('should exit when mode is unknown', async () => {
+         const messageHandler = jest.fn()
+         const config = {
+            mode: 'unknown' as any,
+         }
+
+         await Worker.handler(messageHandler, config)
+
+         expect(process.exit).toHaveBeenCalledWith(1)
+      })
    })
 
    describe('logger', () => {