pp-command-bus 1.0.2 → 1.1.0

package/dist/command-bus/worker/worker-orchestrator.spec.js

@@ -16,16 +16,38 @@ const bullmq_1 = require("bullmq");
 const worker_orchestrator_1 = __importDefault(require("./worker-orchestrator"));
 // Mock BullMQ
 jest.mock('bullmq');
+// Mock WorkerBenchmark
+jest.mock('./worker-benchmark', () => {
+    return jest.fn().mockImplementation(() => ({
+        run: jest.fn().mockResolvedValue({
+            recommendedConcurrency: 5,
+            jobsPerSecond: 100,
+            avgProcessingTime: 10,
+        }),
+    }));
+});
+// Mock WorkerMetricsCollector
+jest.mock('./worker-metrics-collector', () => {
+    return jest.fn().mockImplementation(() => ({
+        start: jest.fn(),
+        stop: jest.fn(),
+        recordJobProcessingTime: jest.fn(),
+    }));
+});
 describe('WorkerOrchestrator', () => {
     let workerOrchestrator;
     let mockRedisConnection;
     let mockJobProcessor;
+    let mockQueueManager;
     let mockLogger;
     let mockWorker;
     const concurrency = 5;
     const maxAttempts = 3;
+    // Storage dla concurrency każdego workera
+    const workerConcurrencyStorage = new Map();
     beforeEach(() => {
         jest.clearAllMocks();
+        workerConcurrencyStorage.clear();
         mockLogger = {
             log: jest.fn(),
             error: jest.fn(),
@@ -37,42 +59,64 @@ describe('WorkerOrchestrator', () => {
         mockJobProcessor = {
             process: jest.fn().mockResolvedValue({ success: true }),
         };
-        // Mock Worker
-        mockWorker = {
-            close: jest.fn().mockResolvedValue(undefined),
-            on: jest.fn().mockReturnThis(),
-            removeAllListeners: jest.fn().mockReturnThis(),
+        // Mock QueueManager
+        mockQueueManager = {
+            getOrCreateQueue: jest.fn().mockReturnValue({
+                name: 'test-queue',
+            }),
         };
-        bullmq_1.Worker.mockImplementation(() => mockWorker);
-        workerOrchestrator = new worker_orchestrator_1.default(mockRedisConnection, mockJobProcessor, concurrency, maxAttempts, mockLogger);
+        // Mock Worker factory z concurrency property per-instance
+        bullmq_1.Worker.mockImplementation((_queueName, _processor, options) => {
+            var _a;
+            const workerInstance = {
+                close: jest.fn().mockResolvedValue(undefined),
+                on: jest.fn().mockReturnThis(),
+                removeAllListeners: jest.fn().mockReturnThis(),
+                get concurrency() {
+                    var _a;
+                    return (_a = workerConcurrencyStorage.get(workerInstance)) !== null && _a !== void 0 ? _a : 5;
+                },
+                set concurrency(value) {
+                    workerConcurrencyStorage.set(workerInstance, value);
+                },
+            };
+            // Ustaw początkową wartość z opcji lub domyślnie 5
+            const initialConcurrency = (_a = options === null || options === void 0 ? void 0 : options.concurrency) !== null && _a !== void 0 ? _a : 5;
+            workerConcurrencyStorage.set(workerInstance, initialConcurrency);
+            mockWorker = workerInstance;
+            return workerInstance;
+        });
+        workerOrchestrator = new worker_orchestrator_1.default(mockRedisConnection, mockJobProcessor, mockQueueManager, concurrency, maxAttempts, mockLogger);
     });
     describe('registerWorker', () => {
-        it('powinno utworzyć nowy worker dla komendy', () => {
+        it('powinno utworzyć nowy worker dla komendy', () => __awaiter(void 0, void 0, void 0, function* () {
             // Given
             const commandName = 'TestCommand';
             // When
-            workerOrchestrator.registerWorker(commandName);
+            yield workerOrchestrator.registerWorker(commandName);
             // Then
             expect(bullmq_1.Worker).toHaveBeenCalledWith(`{${commandName}}`, expect.any(Function), expect.objectContaining({
                 connection: mockRedisConnection,
-                concurrency,
+                concurrency: 5, // Z benchmark result
             }));
-            expect(mockLogger.log).toHaveBeenCalledWith(`Worker zarejestrowany dla komendy ${commandName}`, expect.objectContaining({
-                concurrency,
+            expect(mockLogger.log).toHaveBeenCalledWith('Benchmark zakończony - tworzę workera', expect.objectContaining({
+                commandName,
+                oldConcurrency: concurrency,
+                newConcurrency: 5,
             }));
-        });
-        it('powinno rzucić błąd gdy worker już istnieje dla komendy', () => {
+        }));
+        it('powinno rzucić błąd gdy worker już istnieje dla komendy', () => __awaiter(void 0, void 0, void 0, function* () {
             // Given
             const commandName = 'TestCommand';
-            workerOrchestrator.registerWorker(commandName);
+            yield workerOrchestrator.registerWorker(commandName);
             // When & Then
-            expect(() => workerOrchestrator.registerWorker(commandName)).toThrow(`Worker dla komendy ${commandName} już istnieje`);
-        });
-        it('powinno skonfigurować event handlery dla workera', () => {
+            yield expect(workerOrchestrator.registerWorker(commandName)).rejects.toThrow(`Worker dla komendy ${commandName} już istnieje`);
+        }));
+        it('powinno skonfigurować event handlery dla workera', () => __awaiter(void 0, void 0, void 0, function* () {
             // Given
             const commandName = 'TestCommand';
             // When
-            workerOrchestrator.registerWorker(commandName);
+            yield workerOrchestrator.registerWorker(commandName);
             // Then
             expect(mockWorker.on).toHaveBeenCalledWith('failed', expect.any(Function));
             expect(mockWorker.on).toHaveBeenCalledWith('completed', expect.any(Function));
@@ -80,11 +124,11 @@ describe('WorkerOrchestrator', () => {
             expect(mockWorker.on).toHaveBeenCalledWith('stalled', expect.any(Function));
             expect(mockWorker.on).toHaveBeenCalledWith('progress', expect.any(Function));
             expect(mockWorker.on).toHaveBeenCalledWith('error', expect.any(Function));
-        });
+        }));
         it("powinno wywołać jobProcessor.process w handler'ze workera", () => __awaiter(void 0, void 0, void 0, function* () {
             // Given
             const commandName = 'TestCommand';
-            workerOrchestrator.registerWorker(commandName);
+            yield workerOrchestrator.registerWorker(commandName);
             const workerCalls = bullmq_1.Worker.mock.calls;
             const jobHandler = workerCalls[0][1];
             const mockJob = {
@@ -101,7 +145,7 @@ describe('WorkerOrchestrator', () => {
             const commandName = 'TestCommand';
             const processorError = new Error('Processor error');
             mockJobProcessor.process.mockRejectedValueOnce(processorError);
-            workerOrchestrator.registerWorker(commandName);
+            yield workerOrchestrator.registerWorker(commandName);
             const workerCalls = bullmq_1.Worker.mock.calls;
             const jobHandler = workerCalls[0][1];
             const mockJob = {
@@ -118,10 +162,10 @@ describe('WorkerOrchestrator', () => {
         }));
     });
     describe('setupWorkerEventHandlers', () => {
-        it("powinno zalogować event 'failed'", () => {
+        it("powinno zalogować event 'failed'", () => __awaiter(void 0, void 0, void 0, function* () {
             // Given
             const commandName = 'TestCommand';
-            workerOrchestrator.registerWorker(commandName);
+            yield workerOrchestrator.registerWorker(commandName);
             const failedHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'failed')[1];
             const mockJob = {
                 id: 'job-123',
@@ -141,11 +185,11 @@ describe('WorkerOrchestrator', () => {
                 maxAttempts,
                 isRetryable: true,
             }));
-        });
-        it("powinno zalogować event 'completed'", () => {
+        }));
+        it("powinno zalogować event 'completed'", () => __awaiter(void 0, void 0, void 0, function* () {
             // Given
             const commandName = 'TestCommand';
-            workerOrchestrator.registerWorker(commandName);
+            yield workerOrchestrator.registerWorker(commandName);
             const completedHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'completed')[1];
             const mockJob = {
                 id: 'job-123',
@@ -160,11 +204,11 @@ describe('WorkerOrchestrator', () => {
                 jobId: 'job-123',
                 hasReturnValue: true,
             }));
-        });
-        it("powinno zalogować event 'active'", () => {
+        }));
+        it("powinno zalogować event 'active'", () => __awaiter(void 0, void 0, void 0, function* () {
             // Given
             const commandName = 'TestCommand';
-            workerOrchestrator.registerWorker(commandName);
+            yield workerOrchestrator.registerWorker(commandName);
             const activeHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'active')[1];
             const mockJob = {
                 id: 'job-123',
@@ -177,11 +221,11 @@ describe('WorkerOrchestrator', () => {
                 commandName,
                 jobId: 'job-123',
             }));
-        });
-        it("powinno zalogować event 'stalled'", () => {
+        }));
+        it("powinno zalogować event 'stalled'", () => __awaiter(void 0, void 0, void 0, function* () {
             // Given
             const commandName = 'TestCommand';
-            workerOrchestrator.registerWorker(commandName);
+            yield workerOrchestrator.registerWorker(commandName);
             const stalledHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'stalled')[1];
             const jobId = 'job-123';
             // When
@@ -192,11 +236,11 @@ describe('WorkerOrchestrator', () => {
                 jobId,
                 reason: 'Prawdopodobnie worker przestał odpowiadać',
             }));
-        });
-        it("powinno zalogować event 'progress'", () => {
+        }));
+        it("powinno zalogować event 'progress'", () => __awaiter(void 0, void 0, void 0, function* () {
             // Given
             const commandName = 'TestCommand';
-            workerOrchestrator.registerWorker(commandName);
+            yield workerOrchestrator.registerWorker(commandName);
             const progressHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'progress')[1];
             const mockJob = {
                 id: 'job-123',
@@ -211,11 +255,11 @@ describe('WorkerOrchestrator', () => {
                 jobId: 'job-123',
                 progress: 50,
             }));
-        });
-        it("powinno zalogować event 'error'", () => {
+        }));
+        it("powinno zalogować event 'error'", () => __awaiter(void 0, void 0, void 0, function* () {
             // Given
             const commandName = 'TestCommand';
-            workerOrchestrator.registerWorker(commandName);
+            yield workerOrchestrator.registerWorker(commandName);
             const errorHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'error')[1];
             const error = new Error('Worker error');
             // When
@@ -225,11 +269,11 @@ describe('WorkerOrchestrator', () => {
                 commandName,
                 error: 'Worker error',
             }));
-        });
-        it('powinno obsłużyć brak attempt info w failed event', () => {
+        }));
+        it('powinno obsłużyć brak attempt info w failed event', () => __awaiter(void 0, void 0, void 0, function* () {
             // Given
             const commandName = 'TestCommand';
-            workerOrchestrator.registerWorker(commandName);
+            yield workerOrchestrator.registerWorker(commandName);
             const failedHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'failed')[1];
             const mockJob = {
                 id: 'job-123',
@@ -245,18 +289,18 @@ describe('WorkerOrchestrator', () => {
                 maxAttempts,
                 isRetryable: true, // (0 || 0) < maxAttempts = true
             }));
-        });
+        }));
     });
     describe('getWorker', () => {
-        it('powinno zwrócić workera dla komendy', () => {
+        it('powinno zwrócić workera dla komendy', () => __awaiter(void 0, void 0, void 0, function* () {
             // Given
             const commandName = 'TestCommand';
-            workerOrchestrator.registerWorker(commandName);
+            yield workerOrchestrator.registerWorker(commandName);
             // When
             const worker = workerOrchestrator.getWorker(commandName);
             // Then
             expect(worker).toBe(mockWorker);
-        });
+        }));
         it('powinno zwrócić undefined dla niezarejestrowanego workera', () => {
             // When
             const worker = workerOrchestrator.getWorker('NonExistentCommand');
@@ -267,17 +311,22 @@ describe('WorkerOrchestrator', () => {
     describe('closeAll', () => {
         it('powinno zamknąć wszystkich workerów', () => __awaiter(void 0, void 0, void 0, function* () {
             // Given
-            workerOrchestrator.registerWorker('TestCommand1');
-            workerOrchestrator.registerWorker('TestCommand2');
-            workerOrchestrator.registerWorker('TestCommand3');
+            yield workerOrchestrator.registerWorker('TestCommand1');
+            yield workerOrchestrator.registerWorker('TestCommand2');
+            yield workerOrchestrator.registerWorker('TestCommand3');
+            const worker1 = workerOrchestrator.getWorker('TestCommand1');
+            const worker2 = workerOrchestrator.getWorker('TestCommand2');
+            const worker3 = workerOrchestrator.getWorker('TestCommand3');
             // When
             yield workerOrchestrator.closeAll();
-            // Then
-            expect(mockWorker.close).toHaveBeenCalledTimes(3);
+            // Then - każdy worker powinien mieć wywołane close
+            expect(worker1 === null || worker1 === void 0 ? void 0 : worker1.close).toHaveBeenCalledTimes(1);
+            expect(worker2 === null || worker2 === void 0 ? void 0 : worker2.close).toHaveBeenCalledTimes(1);
+            expect(worker3 === null || worker3 === void 0 ? void 0 : worker3.close).toHaveBeenCalledTimes(1);
         }));
         it('powinno wyczyścić cache workerów', () => __awaiter(void 0, void 0, void 0, function* () {
             // Given
-            workerOrchestrator.registerWorker('TestCommand');
+            yield workerOrchestrator.registerWorker('TestCommand');
             yield workerOrchestrator.closeAll();
             // When
             const worker = workerOrchestrator.getWorker('TestCommand');
@@ -288,6 +337,378 @@ describe('WorkerOrchestrator', () => {
             // When & Then
             yield expect(workerOrchestrator.closeAll()).resolves.toBeUndefined();
         }));
+        it('powinno zatrzymać wszystkie collectory metryk', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given
+            const WorkerMetricsCollector = jest.requireMock('./worker-metrics-collector');
+            yield workerOrchestrator.registerWorker('TestCommand');
+            // When
+            yield workerOrchestrator.closeAll();
+            // Then
+            const collectorInstance = WorkerMetricsCollector.mock.results[0].value;
+            expect(collectorInstance.stop).toHaveBeenCalled();
+        }));
+        it('powinno usunąć wszystkie event listeners przed zamknięciem', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given
+            yield workerOrchestrator.registerWorker('TestCommand');
+            // When
+            yield workerOrchestrator.closeAll();
+            // Then
+            expect(mockWorker.removeAllListeners).toHaveBeenCalled();
+        }));
+    });
+    describe('adjustConcurrency', () => {
+        beforeEach(() => {
+            jest.useFakeTimers();
+        });
+        afterEach(() => {
+            jest.useRealTimers();
+        });
+        it('powinno zwiększyć concurrency o 20%', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given - użyj wyższego początkowego concurrency żeby test był sensowny
+            const WorkerBenchmark = jest.requireMock('./worker-benchmark');
+            WorkerBenchmark.mockImplementation(() => ({
+                run: jest.fn().mockResolvedValue({
+                    recommendedConcurrency: 50, // Wysokie początkowe concurrency
+                    jobsPerSecond: 100,
+                    avgProcessingTime: 10,
+                }),
+            }));
+            const commandName = 'TestCommand';
+            yield workerOrchestrator.registerWorker(commandName);
+            const worker = workerOrchestrator.getWorker(commandName);
+            // When
+            workerOrchestrator.adjustConcurrency(commandName, 'increase', 'Test reason');
+            // Then: 50 * 1.2 = 60
+            expect(worker === null || worker === void 0 ? void 0 : worker.concurrency).toBe(60);
+            expect(mockLogger.log).toHaveBeenCalledWith('Dynamiczna zmiana concurrency', expect.objectContaining({
+                commandName,
+                oldConcurrency: 50,
+                newConcurrency: 60,
+                change: '+20%',
+                direction: 'increase',
+                reason: 'Test reason',
+            }));
+        }));
+        it('powinno zmniejszyć concurrency o 20%', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given - użyj wyższego początkowego concurrency
+            const WorkerBenchmark = jest.requireMock('./worker-benchmark');
+            WorkerBenchmark.mockImplementation(() => ({
+                run: jest.fn().mockResolvedValue({
+                    recommendedConcurrency: 50,
+                    jobsPerSecond: 100,
+                    avgProcessingTime: 10,
+                }),
+            }));
+            const commandName = 'TestCommand';
+            yield workerOrchestrator.registerWorker(commandName);
+            const worker = workerOrchestrator.getWorker(commandName);
+            // When
+            workerOrchestrator.adjustConcurrency(commandName, 'decrease', 'Low backlog');
+            // Then: 50 * 0.8 = 40
+            expect(worker === null || worker === void 0 ? void 0 : worker.concurrency).toBe(40);
+            expect(mockLogger.log).toHaveBeenCalledWith('Dynamiczna zmiana concurrency', expect.objectContaining({
+                oldConcurrency: 50,
+                newConcurrency: 40,
+                change: '-20%',
+                direction: 'decrease',
+            }));
+        }));
+        it('powinno zastosować limit minimum 10', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given
+            const commandName = 'TestCommand';
+            yield workerOrchestrator.registerWorker(commandName);
+            const worker = workerOrchestrator.getWorker(commandName);
+            // Zmniejsz kilka razy do limitu
+            workerOrchestrator.adjustConcurrency(commandName, 'decrease', 'reason');
+            jest.advanceTimersByTime(31000); // Przekrocz cooldown
+            workerOrchestrator.adjustConcurrency(commandName, 'decrease', 'reason');
+            jest.advanceTimersByTime(31000);
+            workerOrchestrator.adjustConcurrency(commandName, 'decrease', 'reason');
+            jest.advanceTimersByTime(31000);
+            // When - próba zmniejszenia poniżej 10
+            workerOrchestrator.adjustConcurrency(commandName, 'decrease', 'reason');
+            // Then - powinno zatrzymać się na 10
+            expect(worker === null || worker === void 0 ? void 0 : worker.concurrency).toBeGreaterThanOrEqual(10);
+        }));
+        it('powinno zastosować limit maksimum 2000', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given - mockuj benchmark aby zwrócił wysokie concurrency
+            const WorkerBenchmark = jest.requireMock('./worker-benchmark');
+            WorkerBenchmark.mockImplementation(() => ({
+                run: jest.fn().mockResolvedValue({
+                    recommendedConcurrency: 1800,
+                    jobsPerSecond: 1000,
+                    avgProcessingTime: 5,
+                }),
+            }));
+            const commandName = 'HighConcurrencyCommand';
+            yield workerOrchestrator.registerWorker(commandName);
+            const worker = workerOrchestrator.getWorker(commandName);
+            // Zwiększ kilka razy
+            workerOrchestrator.adjustConcurrency(commandName, 'increase', 'reason');
+            jest.advanceTimersByTime(31000);
+            workerOrchestrator.adjustConcurrency(commandName, 'increase', 'reason');
+            jest.advanceTimersByTime(31000);
+            // When - próba zwiększenia powyżej 2000
+            workerOrchestrator.adjustConcurrency(commandName, 'increase', 'reason');
+            // Then - powinno zatrzymać się na 2000
+            expect(worker === null || worker === void 0 ? void 0 : worker.concurrency).toBeLessThanOrEqual(2000);
+        }));
+        it('powinno respektować cooldown 30s między zmianami', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given
+            const commandName = 'TestCommand';
+            yield workerOrchestrator.registerWorker(commandName);
+            const worker = workerOrchestrator.getWorker(commandName);
+            // First change
+            workerOrchestrator.adjustConcurrency(commandName, 'increase', 'reason 1');
+            const firstConcurrency = worker === null || worker === void 0 ? void 0 : worker.concurrency;
+            // When - próba zmiany w czasie cooldown
+            jest.advanceTimersByTime(15000); // 15s - poniżej cooldown
+            workerOrchestrator.adjustConcurrency(commandName, 'increase', 'reason 2');
+            // Then - concurrency nie powinno się zmienić
+            expect(worker === null || worker === void 0 ? void 0 : worker.concurrency).toBe(firstConcurrency);
+            expect(mockLogger.debug).toHaveBeenCalledWith('Cooldown aktywny - pomijam zmianę concurrency', expect.any(Object));
+        }));
+        it('powinno pozwolić na zmianę po upływie cooldown', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            // Given - użyj wyższego początkowego concurrency
+            const WorkerBenchmark = jest.requireMock('./worker-benchmark');
+            WorkerBenchmark.mockImplementation(() => ({
+                run: jest.fn().mockResolvedValue({
+                    recommendedConcurrency: 1000,
+                    jobsPerSecond: 100,
+                    avgProcessingTime: 10,
+                }),
+            }));
+            const commandName = 'TestCommand';
+            yield workerOrchestrator.registerWorker(commandName);
+            const worker = workerOrchestrator.getWorker(commandName);
+            // First change: 1000 * 1.2 = 1200
+            workerOrchestrator.adjustConcurrency(commandName, 'increase', 'reason 1');
+            const firstConcurrency = (_a = worker === null || worker === void 0 ? void 0 : worker.concurrency) !== null && _a !== void 0 ? _a : 0;
+            expect(firstConcurrency).toBe(1200);
+            // When - czekamy > 30s i zmieniamy ponownie
+            jest.advanceTimersByTime(31000); // 31s - powyżej cooldown
+            workerOrchestrator.adjustConcurrency(commandName, 'increase', 'reason 2');
+            // Then - concurrency powinno się zmienić: 1200 * 1.2 = 1440
+            expect(worker === null || worker === void 0 ? void 0 : worker.concurrency).toBe(1440);
+        }));
+        it('powinno zalogować warning gdy worker nie istnieje', () => {
+            // When
+            workerOrchestrator.adjustConcurrency('NonExistentCommand', 'increase', 'reason');
+            // Then
+            expect(mockLogger.warn).toHaveBeenCalledWith('Nie można dostosować concurrency - worker nie istnieje', expect.objectContaining({
+                commandName: 'NonExistentCommand',
+            }));
+        });
+        it('nie powinno zmieniać concurrency gdy wartość się nie zmienia (na limicie)', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            // Given - zresetuj mock benchmark do domyślnych wartości
+            const WorkerBenchmark = jest.requireMock('./worker-benchmark');
+            WorkerBenchmark.mockImplementation(() => ({
+                run: jest.fn().mockResolvedValue({
+                    recommendedConcurrency: 50, // Wystarczająco wysokie aby test miał sens
+                    jobsPerSecond: 100,
+                    avgProcessingTime: 10,
+                }),
+            }));
+            const commandName = 'TestCommand';
+            yield workerOrchestrator.registerWorker(commandName);
+            const worker = workerOrchestrator.getWorker(commandName);
+            // Ustaw na minimum (10): 50 -> 40 -> 32 -> 26 -> 21 -> 17 -> 14 -> 11 -> 10 -> 10
+            for (let i = 0; i < 10; i++) {
+                workerOrchestrator.adjustConcurrency(commandName, 'decrease', 'reason');
+                jest.advanceTimersByTime(31000);
+            }
+            const minConcurrency = (_a = worker === null || worker === void 0 ? void 0 : worker.concurrency) !== null && _a !== void 0 ? _a : 0;
+            expect(minConcurrency).toBe(10); // Powinno osiągnąć minimum 10
+            // When - próba dalszego zmniejszenia na limicie
+            workerOrchestrator.adjustConcurrency(commandName, 'decrease', 'reason');
+            // Then - wartość nie powinna się zmienić
+            expect(worker === null || worker === void 0 ? void 0 : worker.concurrency).toBe(minConcurrency);
+            expect(mockLogger.debug).toHaveBeenCalledWith('Concurrency bez zmian - osiągnięto limit', expect.any(Object));
+        }));
+    });
+    describe('integracja z WorkerBenchmark', () => {
+        it('powinno uruchomić benchmark przed utworzeniem workera', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given
+            const WorkerBenchmark = jest.requireMock('./worker-benchmark');
+            const commandName = 'TestCommand';
+            // When
+            yield workerOrchestrator.registerWorker(commandName);
+            // Then
+            expect(WorkerBenchmark).toHaveBeenCalledWith(commandName, mockRedisConnection, mockJobProcessor, mockLogger);
+            const benchmarkInstance = WorkerBenchmark.mock.results[0].value;
+            expect(benchmarkInstance.run).toHaveBeenCalled();
+        }));
+        it('powinno użyć recommendedConcurrency z benchmarku', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given
+            const WorkerBenchmark = jest.requireMock('./worker-benchmark');
+            WorkerBenchmark.mockImplementation(() => ({
+                run: jest.fn().mockResolvedValue({
+                    recommendedConcurrency: 42,
+                    jobsPerSecond: 200,
+                    avgProcessingTime: 20,
+                }),
+            }));
+            const commandName = 'OptimizedCommand';
+            // When
+            yield workerOrchestrator.registerWorker(commandName);
+            // Then
+            expect(bullmq_1.Worker).toHaveBeenCalledWith(`{${commandName}}`, expect.any(Function), expect.objectContaining({
+                concurrency: 42,
+            }));
+        }));
+    });
+    describe('integracja z WorkerMetricsCollector', () => {
+        it('powinno utworzyć i uruchomić metrics collector', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given
+            const WorkerMetricsCollector = jest.requireMock('./worker-metrics-collector');
+            const commandName = 'TestCommand';
+            // When
+            yield workerOrchestrator.registerWorker(commandName);
+            // Then
+            expect(WorkerMetricsCollector).toHaveBeenCalledWith(commandName, expect.any(Object), // queue
+            mockLogger, expect.any(Function));
+            const collectorInstance = WorkerMetricsCollector.mock.results[0].value;
+            expect(collectorInstance.start).toHaveBeenCalled();
+        }));
+        it('powinno wywołać adjustConcurrency gdy collector rekomenduje zmianę', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given
+            const commandName = 'TestCommand';
+            yield workerOrchestrator.registerWorker(commandName);
+            // Pobierz callback przekazany do WorkerMetricsCollector
+            const WorkerMetricsCollector = jest.requireMock('./worker-metrics-collector');
+            const collectorCallback = WorkerMetricsCollector.mock.calls[0][3];
+            // When - symuluj rekomendację od collectora
+            collectorCallback({
+                shouldAdjust: true,
+                direction: 'increase',
+                reason: 'High backlog detected',
+                currentMetrics: {
+                    waiting: 100,
+                    active: 10,
+                    jobsPerSecond: 5,
+                    avgProcessingTimeMs: 200,
+                    timestamp: Date.now(),
+                },
+            });
+            // Then
+            expect(mockWorker.concurrency).toBeGreaterThan(5); // Zwiększone o 20%
+        }));
+        it('nie powinno wywoływać adjustConcurrency gdy direction=none', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given
+            const commandName = 'TestCommand';
+            yield workerOrchestrator.registerWorker(commandName);
+            const WorkerMetricsCollector = jest.requireMock('./worker-metrics-collector');
+            const collectorCallback = WorkerMetricsCollector.mock.calls[0][3];
+            const initialConcurrency = mockWorker.concurrency;
+            // When - symuluj brak rekomendacji
+            collectorCallback({
+                shouldAdjust: false,
+                direction: 'none',
+                reason: 'Stable metrics',
+                currentMetrics: {
+                    waiting: 10,
+                    active: 10,
+                    jobsPerSecond: 10,
+                    avgProcessingTimeMs: 100,
+                    timestamp: Date.now(),
+                },
+            });
+            // Then - concurrency nie zmienione
+            expect(mockWorker.concurrency).toBe(initialConcurrency);
+        }));
+    });
+    describe('tracking czasu przetwarzania jobów', () => {
+        beforeEach(() => {
+            jest.useFakeTimers();
+        });
+        afterEach(() => {
+            jest.useRealTimers();
+        });
+        it('powinno zapisać czas przetwarzania w metricsCollector', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given
+            const commandName = 'TestCommand';
+            yield workerOrchestrator.registerWorker(commandName);
+            const WorkerMetricsCollector = jest.requireMock('./worker-metrics-collector');
+            const collectorInstance = WorkerMetricsCollector.mock.results[0].value;
+            // Pobierz handlery eventów
+            const activeHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'active')[1];
+            const completedHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'completed')[1];
+            const mockJob = {
+                id: 'job-123',
+                data: { __id: 'cmd-123' },
+                returnvalue: { success: true },
+            };
+            // When - symuluj job lifecycle
+            activeHandler(mockJob); // Start job
+            jest.advanceTimersByTime(150); // 150ms przetwarzania
+            completedHandler(mockJob); // Complete job
+            // Then - czas przetwarzania powinien być zapisany
+            expect(collectorInstance.recordJobProcessingTime).toHaveBeenCalledWith(150);
+        }));
+        it('powinno obsłużyć sytuację gdy brak jobId', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given
+            const commandName = 'TestCommand';
+            yield workerOrchestrator.registerWorker(commandName);
+            const completedHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'completed')[1];
+            const mockJob = {
+                id: undefined, // Brak ID
+                data: { __id: 'cmd-123' },
+            };
+            // When
+            completedHandler(mockJob);
+            // Then - nie powinno wywołać recordJobProcessingTime
+            const WorkerMetricsCollector = jest.requireMock('./worker-metrics-collector');
+            const collectorInstance = WorkerMetricsCollector.mock.results[0].value;
+            expect(collectorInstance.recordJobProcessingTime).not.toHaveBeenCalled();
+        }));
+        it('powinno wyczyścić czas startu dla failed jobs', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given
+            const commandName = 'TestCommand';
+            yield workerOrchestrator.registerWorker(commandName);
+            const activeHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'active')[1];
+            const failedHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'failed')[1];
+            const completedHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'completed')[1];
+            const mockJob = {
+                id: 'job-123',
+                data: { __id: 'cmd-123' },
+                attemptsMade: 1,
+                opts: { attempts: 3 },
+            };
+            // When - job fails
+            activeHandler(mockJob);
+            failedHandler(mockJob, new Error('Job failed'));
+            // Then - próba completed nie powinna zapisać czasu (start time został wyczyszczony)
+            completedHandler(mockJob);
+            const WorkerMetricsCollector = jest.requireMock('./worker-metrics-collector');
+            const collectorInstance = WorkerMetricsCollector.mock.results[0].value;
+            // recordJobProcessingTime nie powinno być wywołane dla failed job
+            expect(collectorInstance.recordJobProcessingTime).not.toHaveBeenCalled();
+        }));
+    });
+    describe('getWorkerStats', () => {
+        it('powinno zwrócić statystyki workerów', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Given
+            yield workerOrchestrator.registerWorker('Command1');
+            yield workerOrchestrator.registerWorker('Command2');
+            // When
+            const stats = workerOrchestrator.getWorkerStats();
+            // Then
+            expect(stats).toEqual({
+                activeWorkersCount: 2,
+                workerNames: ['Command1', 'Command2'],
+            });
+        }));
+        it('powinno zwrócić puste statystyki gdy brak workerów', () => {
+            // When
+            const stats = workerOrchestrator.getWorkerStats();
+            // Then
+            expect(stats).toEqual({
+                activeWorkersCount: 0,
+                workerNames: [],
+            });
+        });
     });
 });
 //# sourceMappingURL=worker-orchestrator.spec.js.map