@quatrain/worker 1.2.5 → 1.2.6

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/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.6",
   "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.9",
+    "@quatrain/core": "^1.2.14",
     "@quatrain/queue": "^1.2.3",
     "@quatrain/storage": "^1.2.8",
     "axios": "^1.7.7",

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', () => {