pp-command-bus 1.5.0 → 2.0.1

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

@@ -1,712 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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 (event-driven)
-jest.mock('./worker-metrics-collector', () => {
-    return jest.fn().mockImplementation(() => ({
-        onJobActive: jest.fn(),
-        onJobCompleted: jest.fn(),
-        onJobFailed: jest.fn(),
-    }));
-});
-describe('WorkerOrchestrator', () => {
-    let workerOrchestrator;
-    let mockRedisConnection;
-    let mockJobProcessor;
-    let mockLogger;
-    let mockWorker;
-    const concurrency = 5;
-    const maxAttempts = 1;
-    // Storage dla concurrency każdego workera
-    const workerConcurrencyStorage = new Map();
-    beforeEach(() => {
-        jest.clearAllMocks();
-        workerConcurrencyStorage.clear();
-        mockLogger = {
-            log: jest.fn(),
-            error: jest.fn(),
-            warn: jest.fn(),
-            debug: jest.fn(),
-        };
-        // Mock Redis connection - przekazywany przez DI
-        mockRedisConnection = {};
-        mockJobProcessor = {
-            process: jest.fn().mockResolvedValue({ success: true }),
-        };
-        // 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, concurrency, maxAttempts, mockLogger);
-    });
-    describe('registerWorker', () => {
-        it('powinno utworzyć nowy worker dla komendy', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const commandName = 'TestCommand';
-            // When
-            yield workerOrchestrator.registerWorker(commandName);
-            // Then
-            expect(bullmq_1.Worker).toHaveBeenCalledWith(`{${commandName}}`, expect.any(Function), expect.objectContaining({
-                connection: mockRedisConnection,
-                concurrency: 5, // Z benchmark result
-            }));
-            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', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const commandName = 'TestCommand';
-            yield workerOrchestrator.registerWorker(commandName);
-            // When & Then
-            expect(() => workerOrchestrator.registerWorker(commandName)).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
-            yield workerOrchestrator.registerWorker(commandName);
-            // Then
-            expect(mockWorker.on).toHaveBeenCalledWith('failed', expect.any(Function));
-            expect(mockWorker.on).toHaveBeenCalledWith('completed', expect.any(Function));
-            expect(mockWorker.on).toHaveBeenCalledWith('active', expect.any(Function));
-            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';
-            yield workerOrchestrator.registerWorker(commandName);
-            const workerCalls = bullmq_1.Worker.mock.calls;
-            const jobHandler = workerCalls[0][1];
-            const mockJob = {
-                id: 'job-123',
-                data: { __id: 'cmd-123' },
-            };
-            // When
-            yield jobHandler(mockJob);
-            // Then
-            expect(mockJobProcessor.process).toHaveBeenCalledWith(mockJob, commandName);
-        }));
-        it('powinno propagować błędy z jobProcessor dla BullMQ retry', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const commandName = 'TestCommand';
-            const processorError = new Error('Processor error');
-            mockJobProcessor.process.mockRejectedValueOnce(processorError);
-            yield workerOrchestrator.registerWorker(commandName);
-            const workerCalls = bullmq_1.Worker.mock.calls;
-            const jobHandler = workerCalls[0][1];
-            const mockJob = {
-                id: 'job-123',
-                data: { __id: 'cmd-123' },
-            };
-            // When & Then
-            yield expect(jobHandler(mockJob)).rejects.toThrow('Processor error');
-            expect(mockLogger.error).toHaveBeenCalledWith('Worker handler critical error', expect.objectContaining({
-                commandName,
-                jobId: 'job-123',
-                error: 'Processor error',
-            }));
-        }));
-    });
-    describe('setupWorkerEventHandlers', () => {
-        it("powinno zalogować event 'failed'", () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const commandName = 'TestCommand';
-            yield workerOrchestrator.registerWorker(commandName);
-            const failedHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'failed')[1];
-            const mockJob = {
-                id: 'job-123',
-                data: { __id: 'cmd-123' },
-                attemptsMade: 0,
-                opts: { attempts: maxAttempts },
-            };
-            const error = new Error('Job failed');
-            // When
-            failedHandler(mockJob, error);
-            // Then
-            expect(mockLogger.error).toHaveBeenCalledWith('Job zakończony niepowodzeniem', expect.objectContaining({
-                commandName,
-                jobId: 'job-123',
-                error: 'Job failed',
-                attempt: 0,
-                maxAttempts,
-                isRetryable: true,
-            }));
-        }));
-        it("powinno zalogować event 'completed'", () => __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: 'job-123',
-                data: { __id: 'cmd-123' },
-                returnvalue: { success: true },
-            };
-            // When
-            completedHandler(mockJob);
-            // Then
-            expect(mockLogger.log).toHaveBeenCalledWith('Job zakończony pomyślnie', expect.objectContaining({
-                commandName,
-                jobId: 'job-123',
-                hasReturnValue: true,
-            }));
-        }));
-        it("powinno zalogować event 'active'", () => __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 mockJob = {
-                id: 'job-123',
-                data: { __id: 'cmd-123' },
-            };
-            // When
-            activeHandler(mockJob);
-            // Then
-            expect(mockLogger.debug).toHaveBeenCalledWith('Job rozpoczęty', expect.objectContaining({
-                commandName,
-                jobId: 'job-123',
-            }));
-        }));
-        it("powinno zalogować event 'stalled'", () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const commandName = 'TestCommand';
-            yield workerOrchestrator.registerWorker(commandName);
-            const stalledHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'stalled')[1];
-            const jobId = 'job-123';
-            // When
-            stalledHandler(jobId);
-            // Then
-            expect(mockLogger.warn).toHaveBeenCalledWith('Job zatrzymany (stalled)', expect.objectContaining({
-                commandName,
-                jobId,
-                reason: 'Prawdopodobnie worker przestał odpowiadać',
-            }));
-        }));
-        it("powinno zalogować event 'progress'", () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const commandName = 'TestCommand';
-            yield workerOrchestrator.registerWorker(commandName);
-            const progressHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'progress')[1];
-            const mockJob = {
-                id: 'job-123',
-                data: { __id: 'cmd-123' },
-            };
-            const progress = 50;
-            // When
-            progressHandler(mockJob, progress);
-            // Then
-            expect(mockLogger.debug).toHaveBeenCalledWith('Job - postęp przetwarzania', expect.objectContaining({
-                commandName,
-                jobId: 'job-123',
-                progress: 50,
-            }));
-        }));
-        it("powinno zalogować event 'error'", () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const commandName = 'TestCommand';
-            yield workerOrchestrator.registerWorker(commandName);
-            const errorHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'error')[1];
-            const error = new Error('Worker error');
-            // When
-            errorHandler(error);
-            // Then
-            expect(mockLogger.error).toHaveBeenCalledWith('Błąd workera', expect.objectContaining({
-                commandName,
-                error: 'Worker error',
-            }));
-        }));
-        it('powinno obsłużyć brak attempt info w failed event', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const commandName = 'TestCommand';
-            yield workerOrchestrator.registerWorker(commandName);
-            const failedHandler = mockWorker.on.mock.calls.find((call) => call[0] === 'failed')[1];
-            const mockJob = {
-                id: 'job-123',
-                data: { __id: 'cmd-123' },
-                // Brak attemptsMade i opts
-            };
-            const error = new Error('Job failed');
-            // When
-            failedHandler(mockJob, error);
-            // Then
-            expect(mockLogger.error).toHaveBeenCalledWith('Job zakończony niepowodzeniem', expect.objectContaining({
-                attempt: undefined, // attemptsMade jest undefined gdy nie ma tej właściwości
-                maxAttempts,
-                isRetryable: true, // (0 || 0) < maxAttempts = true
-            }));
-        }));
-    });
-    describe('getWorker', () => {
-        it('powinno zwrócić workera dla komendy', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const commandName = 'TestCommand';
-            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');
-            // Then
-            expect(worker).toBeUndefined();
-        });
-    });
-    describe('closeAll', () => {
-        it('powinno zamknąć wszystkich workerów', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            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 - 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
-            yield workerOrchestrator.registerWorker('TestCommand');
-            yield workerOrchestrator.closeAll();
-            // When
-            const worker = workerOrchestrator.getWorker('TestCommand');
-            // Then
-            expect(worker).toBeUndefined();
-        }));
-        it('powinno działać gdy brak workerów', () => __awaiter(void 0, void 0, void 0, function* () {
-            // When & Then
-            yield expect(workerOrchestrator.closeAll()).resolves.toBeUndefined();
-        }));
-        it('powinno wyczyścić wszystkie collectory metryk', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            yield workerOrchestrator.registerWorker('TestCommand');
-            // When
-            yield workerOrchestrator.closeAll();
-            // Then - event-driven collectors nie wymagają stop(), tylko cleanup referencji
-            const stats = workerOrchestrator.getWorkerStats();
-            expect(stats.activeWorkersCount).toBe(0);
-        }));
-        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(() => {
-            // Wyczyść wszystkie pending timery przed przywróceniem real timers
-            jest.clearAllTimers();
-            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);
-            // Poczekaj na zakończenie asynchronicznego benchmarku
-            yield new Promise((resolve) => setTimeout(resolve, 100));
-            // Then - sprawdź że concurrency zostało zaktualizowane po benchmarku
-            const worker = workerOrchestrator.getWorker(commandName);
-            expect(worker === null || worker === void 0 ? void 0 : worker.concurrency).toBe(42);
-        }), 15000);
-    });
-    describe('integracja z WorkerMetricsCollector', () => {
-        it('powinno utworzyć metrics collector (event-driven)', () => __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, mockLogger, expect.any(Function));
-            // Event-driven collector nie wymaga start() - działa od razu
-            const collectorInstance = WorkerMetricsCollector.mock.results[0].value;
-            expect(collectorInstance.onJobActive).toBeDefined();
-            expect(collectorInstance.onJobCompleted).toBeDefined();
-            expect(collectorInstance.onJobFailed).toBeDefined();
-        }));
-        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 (pozycja 2: commandName, logger, callback)
-            const WorkerMetricsCollector = jest.requireMock('./worker-metrics-collector');
-            const collectorCallback = WorkerMetricsCollector.mock.calls[0][2];
-            // 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][2];
-            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(() => {
-            // Wyczyść wszystkie pending timery przed przywróceniem real timers
-            jest.clearAllTimers();
-            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 - event-driven metrics: onJobActive i onJobCompleted
-            expect(collectorInstance.onJobActive).toHaveBeenCalledWith('job-123');
-            expect(collectorInstance.onJobCompleted).toHaveBeenCalledWith('job-123', 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ć onJobCompleted
-            const WorkerMetricsCollector = jest.requireMock('./worker-metrics-collector');
-            const collectorInstance = WorkerMetricsCollector.mock.results[0].value;
-            expect(collectorInstance.onJobCompleted).not.toHaveBeenCalled();
-        }));
-        it('powinno wywołać onJobFailed 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 mockJob = {
-                id: 'job-123',
-                data: { __id: 'cmd-123' },
-                attemptsMade: 1,
-                opts: { attempts: 1 },
-            };
-            const WorkerMetricsCollector = jest.requireMock('./worker-metrics-collector');
-            const collectorInstance = WorkerMetricsCollector.mock.results[0].value;
-            // When - job fails
-            activeHandler(mockJob);
-            failedHandler(mockJob, new Error('Job failed'));
-            // Then - event-driven metrics: onJobActive i onJobFailed
-            expect(collectorInstance.onJobActive).toHaveBeenCalledWith('job-123');
-            expect(collectorInstance.onJobFailed).toHaveBeenCalledWith('job-123');
-        }));
-    });
-    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