pp-command-bus 1.5.0 → 2.0.0

package/dist/command-bus/rpc/rpc-coordinator.spec.js

@@ -1,621 +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 rpc_coordinator_1 = __importDefault(require("./rpc-coordinator"));
-const command_1 = __importDefault(require("../command"));
-describe('RpcCoordinator - Shared Subscriber Pattern z Redis Pub/Sub', () => {
-    let rpcCoordinator;
-    let mockLogger;
-    let mockRedisConnection;
-    let mockSharedSubscriber;
-    let mockCompressionService;
-    let mockCancellationService;
-    let mockRemoveJobCallback;
-    let processInstanceId;
-    // Mock Command class for testing
-    class TestCommand extends command_1.default {
-        constructor(payload) {
-            super(payload);
-        }
-    }
-    beforeEach(() => {
-        var _a, _b;
-        jest.clearAllMocks();
-        mockLogger = {
-            log: jest.fn(),
-            error: jest.fn(),
-            warn: jest.fn(),
-            debug: jest.fn(),
-        };
-        // Mock Shared Subscriber
-        mockSharedSubscriber = {
-            psubscribe: jest
-                .fn()
-                .mockImplementation((_pattern, callback) => {
-                // Wywołaj callback natychmiast jeśli został przekazany
-                if (callback) {
-                    setImmediate(() => callback(null, 1));
-                }
-                return Promise.resolve(undefined);
-            }),
-            punsubscribe: jest.fn().mockResolvedValue(undefined),
-            on: jest.fn().mockReturnThis(),
-            once: jest.fn().mockImplementation((event, handler) => {
-                // Automatycznie wywołaj handler 'ready' natychmiast
-                if (event === 'ready') {
-                    setImmediate(() => handler());
-                }
-                return mockSharedSubscriber;
-            }),
-            removeAllListeners: jest.fn().mockReturnThis(),
-            quit: jest.fn().mockResolvedValue(undefined),
-        };
-        // Mock Redis connection
-        mockRedisConnection = {
-            duplicate: jest.fn().mockReturnValue(mockSharedSubscriber),
-        };
-        // Mock PayloadCompressionService
-        mockCompressionService = {
-            compress: jest.fn().mockResolvedValue({ data: '{}', compressed: false }),
-            decompress: jest.fn().mockImplementation((message) => {
-                return Promise.resolve(JSON.parse(message));
-            }),
-        };
-        // Mock RpcJobCancellationService
-        mockCancellationService = {
-            markAsCancelled: jest.fn().mockResolvedValue(undefined),
-            isCancelled: jest.fn().mockResolvedValue(false),
-            clearCancellation: jest.fn().mockResolvedValue(undefined),
-            tryRemoveJob: jest.fn().mockResolvedValue(false),
-        };
-        // Mock RemoveJobCallback
-        mockRemoveJobCallback = jest.fn().mockResolvedValue(false);
-        rpcCoordinator = new rpc_coordinator_1.default(mockLogger, mockRedisConnection, mockCompressionService, mockCancellationService, mockRemoveJobCallback);
-        // Ekstraktuj processInstanceId z logów debug
-        const debugCalls = mockLogger.debug.mock.calls;
-        const initCall = debugCalls.find((call) => call[0] === 'Inicjalizacja RpcCoordinator');
-        processInstanceId = (_b = (_a = initCall === null || initCall === void 0 ? void 0 : initCall[1]) === null || _a === void 0 ? void 0 : _a.processInstanceId) !== null && _b !== void 0 ? _b : 'test-process-id';
-    });
-    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
-        // Zamknij RpcCoordinator
-        yield rpcCoordinator.close();
-        // Wyczyść wszystkie pending promises
-        yield new Promise((resolve) => setImmediate(resolve));
-    }));
-    describe('Konstrukcja i inicjalizacja', () => {
-        it('powinno utworzyć shared subscriber przy konstrukcji', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Verify: duplicate() called once dla shared subscriber
-            expect(mockRedisConnection.duplicate).toHaveBeenCalledTimes(1);
-            // Poczekaj na async ready event
-            yield new Promise((resolve) => setImmediate(resolve));
-            // Verify: psubscribe z pattern zawierającym processInstanceId
-            expect(mockSharedSubscriber.psubscribe).toHaveBeenCalledTimes(1);
-            const pattern = mockSharedSubscriber.psubscribe.mock.calls[0][0];
-            expect(pattern).toMatch(/^rpc:response:[0-9a-f-]{36}:\*$/); // UUID pattern
-            expect(pattern).toBe(`rpc:response:${processInstanceId}:*`);
-        }));
-        it('powinno zarejestrować handlery pmessage i error', () => {
-            // Verify: pmessage handler zarejestrowany
-            const pmessageCalls = mockSharedSubscriber.on.mock.calls.filter((call) => call[0] === 'pmessage');
-            expect(pmessageCalls).toHaveLength(1);
-            // Verify: error handler zarejestrowany
-            const errorCalls = mockSharedSubscriber.on.mock.calls.filter((call) => call[0] === 'error');
-            expect(errorCalls).toHaveLength(1);
-        });
-    });
-    describe('Gotowość subscribera - waitForSubscriberReady', () => {
-        it('powinno poczekać na gotowość subscribera przed rejestrowaniem call', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const correlationId = 'ready-test-123';
-            const commandName = 'TestCommand';
-            const timeout = 100;
-            const responseChannel = `rpc:response:${processInstanceId}:${correlationId}`;
-            // Symuluj odpowiedź RPC natychmiast (subscriber już gotowy dzięki mock)
-            setTimeout(() => {
-                var _a;
-                const pmessageHandler = (_a = mockSharedSubscriber.on.mock.calls.find((call) => call[0] === 'pmessage')) === null || _a === void 0 ? void 0 : _a[1];
-                if (pmessageHandler) {
-                    const wrapper = {
-                        data: JSON.stringify({
-                            correlationId,
-                            result: { success: true },
-                            error: null,
-                        }),
-                        compressed: false,
-                    };
-                    pmessageHandler(`rpc:response:${processInstanceId}:*`, responseChannel, JSON.stringify(wrapper));
-                }
-            }, 10);
-            // When
-            const promise = rpcCoordinator.registerCall(correlationId, commandName, timeout);
-            // Then
-            yield expect(promise).resolves.toEqual({ success: true });
-        }));
-        it('powinno rzucić wyjątek timeout gdy subscriber nie jest gotowy w ciągu 5s', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Use fake timers dla tego testu
-            jest.useFakeTimers();
-            try {
-                // Given: Utwórz nowy coordinator z subscriber który NIGDY nie będzie gotowy
-                const slowSubscriber = {
-                    psubscribe: jest.fn().mockImplementation(() => {
-                        // NIE wywołujemy callback - subscriber nigdy nie będzie gotowy
-                        return Promise.resolve(undefined);
-                    }),
-                    on: jest.fn().mockReturnThis(),
-                    once: jest.fn().mockReturnThis(), // NIE wywołujemy 'ready' event
-                    removeAllListeners: jest.fn().mockReturnThis(),
-                    quit: jest.fn().mockResolvedValue(undefined),
-                };
-                const slowRedisConnection = {
-                    duplicate: jest.fn().mockReturnValue(slowSubscriber),
-                };
-                const slowCoordinator = new rpc_coordinator_1.default(mockLogger, slowRedisConnection, mockCompressionService);
-                const correlationId = 'timeout-subscriber-test';
-                const commandName = 'TestCommand';
-                const timeout = 100; // Timeout dla RPC call (nie subscriber ready)
-                // When
-                const promise = slowCoordinator.registerCall(correlationId, commandName, timeout);
-                // Fast-forward time
-                jest.advanceTimersByTime(5000);
-                // Then
-                yield expect(promise).rejects.toThrow('Subscriber timeout: nie udało się nawiązać połączenia w ciągu 5000ms');
-                // Cleanup
-                yield slowCoordinator.close().catch(() => {
-                    /* ignore */
-                });
-            }
-            finally {
-                // Przywróć rzeczywiste timery
-                jest.useRealTimers();
-            }
-        }));
-    });
-    describe('registerCall - shared subscriber', () => {
-        it('powinno użyć shared subscriber zamiast tworzyć nowe połączenie', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const correlationId = 'test-correlation-123';
-            const commandName = 'TestCommand';
-            const timeout = 100;
-            const responseChannel = `rpc:response:${processInstanceId}:${correlationId}`;
-            // Symuluj odpowiedź RPC przez pmessage handler
-            setTimeout(() => {
-                var _a;
-                const pmessageHandler = (_a = mockSharedSubscriber.on.mock.calls.find((call) => call[0] === 'pmessage')) === null || _a === void 0 ? void 0 : _a[1];
-                if (pmessageHandler) {
-                    // Wrapper z metadanymi kompresji
-                    const wrapper = {
-                        data: JSON.stringify({
-                            correlationId,
-                            result: { success: true },
-                            error: null,
-                        }),
-                        compressed: false,
-                    };
-                    pmessageHandler(`rpc:response:${processInstanceId}:*`, responseChannel, JSON.stringify(wrapper));
-                }
-            }, 10);
-            // When
-            const promise = rpcCoordinator.registerCall(correlationId, commandName, timeout);
-            // Then
-            yield expect(promise).resolves.toEqual({ success: true });
-            // Verify: NIE wywołano duplicate() ponownie (używa shared subscriber)
-            expect(mockRedisConnection.duplicate).toHaveBeenCalledTimes(1);
-            // Verify: NIE wywołano subscribe/unsubscribe per call (używa psubscribe)
-            expect(mockSharedSubscriber.psubscribe).toHaveBeenCalledTimes(1); // Tylko przy konstrukcji
-        }));
-        it('powinno reject przy timeout', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const correlationId = 'timeout-test';
-            const commandName = 'TestCommand';
-            const timeout = 50; // Krótki timeout
-            // When & Then
-            yield expect(rpcCoordinator.registerCall(correlationId, commandName, timeout)).rejects.toThrow('RPC timeout');
-        }));
-        it('powinno reject przy błędzie w odpowiedzi', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const correlationId = 'error-test';
-            const commandName = 'TestCommand';
-            const timeout = 100;
-            const responseChannel = `rpc:response:${processInstanceId}:${correlationId}`;
-            // Symuluj odpowiedź z błędem
-            setTimeout(() => {
-                var _a;
-                const pmessageHandler = (_a = mockSharedSubscriber.on.mock.calls.find((call) => call[0] === 'pmessage')) === null || _a === void 0 ? void 0 : _a[1];
-                if (pmessageHandler) {
-                    const wrapper = {
-                        data: JSON.stringify({
-                            correlationId,
-                            result: null,
-                            error: 'Test error',
-                        }),
-                        compressed: false,
-                    };
-                    pmessageHandler(`rpc:response:${processInstanceId}:*`, responseChannel, JSON.stringify(wrapper));
-                }
-            }, 10);
-            // When & Then
-            yield expect(rpcCoordinator.registerCall(correlationId, commandName, timeout)).rejects.toThrow('Test error');
-        }));
-    });
-    describe('prepareRpcCommand', () => {
-        it('powinno dodać metadata z responseChannel zawierającym processInstanceId', () => {
-            // Given
-            const command = new TestCommand({ value: 42 });
-            const responseChannel = `rpc:response:${processInstanceId}:${command.__id}`;
-            // When
-            const result = rpcCoordinator.prepareRpcCommand(command);
-            // Then
-            expect(result.__rpcMetadata).toBeDefined();
-            expect(result.__rpcMetadata.correlationId).toBe(command.__id);
-            expect(result.__rpcMetadata.responseChannel).toBe(responseChannel);
-            expect(result.__rpcMetadata.responseChannel).toContain(processInstanceId);
-            expect(result.__rpcMetadata.timestamp).toBeDefined();
-        });
-    });
-    describe('Izolacja processInstanceId', () => {
-        it('powinno ignorować wiadomości z innym processInstanceId', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const correlationId = 'isolation-test';
-            const commandName = 'TestCommand';
-            const timeout = 100;
-            const wrongProcessId = 'wrong-process-id-123';
-            // Symuluj odpowiedź z INNYM processInstanceId
-            setTimeout(() => {
-                var _a;
-                const pmessageHandler = (_a = mockSharedSubscriber.on.mock.calls.find((call) => call[0] === 'pmessage')) === null || _a === void 0 ? void 0 : _a[1];
-                if (pmessageHandler) {
-                    const wrapper = {
-                        data: JSON.stringify({
-                            correlationId,
-                            result: { wrong: true },
-                            error: null,
-                        }),
-                        compressed: false,
-                    };
-                    pmessageHandler(`rpc:response:${wrongProcessId}:*`, `rpc:response:${wrongProcessId}:${correlationId}`, JSON.stringify(wrapper));
-                }
-            }, 10);
-            // When
-            const promise = rpcCoordinator.registerCall(correlationId, commandName, timeout);
-            // Then: Powinno timeout (wiadomość zignorowana)
-            yield expect(promise).rejects.toThrow('RPC timeout');
-            // Verify: Log warning o wiadomości dla innego procesu
-            expect(mockLogger.warn).toHaveBeenCalledWith('Otrzymano wiadomość dla innego procesu', expect.objectContaining({
-                processInstanceId,
-                receivedProcessId: wrongProcessId,
-                correlationId,
-            }));
-        }));
-        it('powinno ignorować wiadomości dla nieistniejących pending calls', () => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            // Given
-            const nonExistentCorrelationId = 'non-existent-123';
-            const responseChannel = `rpc:response:${processInstanceId}:${nonExistentCorrelationId}`;
-            // Symuluj odpowiedź dla nieistniejącego call
-            const pmessageHandler = (_a = mockSharedSubscriber.on.mock.calls.find((call) => call[0] === 'pmessage')) === null || _a === void 0 ? void 0 : _a[1];
-            if (pmessageHandler) {
-                const wrapper = {
-                    data: JSON.stringify({
-                        correlationId: nonExistentCorrelationId,
-                        result: { data: 'test' },
-                        error: null,
-                    }),
-                    compressed: false,
-                };
-                pmessageHandler(`rpc:response:${processInstanceId}:*`, responseChannel, JSON.stringify(wrapper));
-            }
-            // Wait for async handling
-            yield new Promise((resolve) => setTimeout(resolve, 50));
-            // Verify: Log warning o nieistniejącym pending call
-            expect(mockLogger.warn).toHaveBeenCalledWith('Otrzymano odpowiedź dla nieistniejącego RPC call', expect.objectContaining({
-                processInstanceId,
-                correlationId: nonExistentCorrelationId,
-            }));
-        }));
-    });
-    describe('Concurrent RPC calls - Shared Subscriber', () => {
-        it('powinno obsłużyć 16 jednoczesnych RPC calls używając 1 shared subscriber', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const concurrentCalls = 16;
-            const timeout = 200;
-            const responseDelay = 50;
-            // When: Wystartuj 16 równoległych RPC calls
-            const promises = Array.from({ length: concurrentCalls }, (_, index) => {
-                const correlationId = `concurrent-test-${index}`;
-                const commandName = 'ConcurrentTestCommand';
-                const responseChannel = `rpc:response:${processInstanceId}:${correlationId}`;
-                // Symuluj odpowiedź RPC dla każdego call
-                setTimeout(() => {
-                    var _a;
-                    const pmessageHandler = (_a = mockSharedSubscriber.on.mock.calls.find((call) => call[0] === 'pmessage')) === null || _a === void 0 ? void 0 : _a[1];
-                    if (pmessageHandler) {
-                        const wrapper = {
-                            data: JSON.stringify({
-                                correlationId,
-                                result: { index, success: true },
-                                error: null,
-                            }),
-                            compressed: false,
-                        };
-                        pmessageHandler(`rpc:response:${processInstanceId}:*`, responseChannel, JSON.stringify(wrapper));
-                    }
-                }, responseDelay);
-                return rpcCoordinator.registerCall(correlationId, commandName, timeout);
-            });
-            // Then: Wszystkie 16 calls powinno się zakończyć sukcesem
-            const results = yield Promise.all(promises);
-            // Weryfikacja: wszystkie wyniki są poprawne
-            expect(results).toHaveLength(concurrentCalls);
-            results.forEach((result, index) => {
-                expect(result).toEqual({ index, success: true });
-            });
-            // Weryfikacja: TYLKO 1 duplicate() (shared subscriber)
-            expect(mockRedisConnection.duplicate).toHaveBeenCalledTimes(1);
-            // Weryfikacja: TYLKO 1 psubscribe (przy konstrukcji)
-            expect(mockSharedSubscriber.psubscribe).toHaveBeenCalledTimes(1);
-        }), 10000);
-        it('powinno obsłużyć race condition - odpowiedź publikowana natychmiast po rejestracji', () => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            // Given: Worker bardzo szybki - publikuje odpowiedź natychmiast po rejestracji
-            const correlationId = 'race-condition-test';
-            const commandName = 'FastCommand';
-            const timeout = 100;
-            const responseChannel = `rpc:response:${processInstanceId}:${correlationId}`;
-            // When: Rejestruj call i natychmiast po tym publikuj odpowiedź
-            const resultPromise = rpcCoordinator.registerCall(correlationId, commandName, timeout);
-            // Poczekaj minimalny czas na rejestrację pending call w Map
-            // (registerCall() jest async ze względu na waitForSubscriberReady)
-            yield new Promise((resolve) => setTimeout(resolve, 5));
-            // Symuluj NATYCHMIASTOWĄ odpowiedź po rejestracji
-            const pmessageHandler = (_a = mockSharedSubscriber.on.mock.calls.find((call) => call[0] === 'pmessage')) === null || _a === void 0 ? void 0 : _a[1];
-            if (pmessageHandler) {
-                const wrapper = {
-                    data: JSON.stringify({
-                        correlationId,
-                        result: { veryFast: true },
-                        error: null,
-                    }),
-                    compressed: false,
-                };
-                pmessageHandler(`rpc:response:${processInstanceId}:*`, responseChannel, JSON.stringify(wrapper));
-            }
-            const result = yield resultPromise;
-            // Then: Powinna dotrzeć odpowiedź (shared subscriber zawsze gotowy)
-            expect(result).toEqual({ veryFast: true });
-            // Verify: Brak timeout
-            expect(mockLogger.error).not.toHaveBeenCalledWith('RPC timeout', expect.any(Object));
-        }));
-    });
-    describe('close()', () => {
-        it('powinno reject wszystkie pending calls przy zamykaniu', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given: Zarejestruj 3 pending calls
-            const promises = Array.from({ length: 3 }, (_, index) => {
-                const correlationId = `close-test-${index}`;
-                return rpcCoordinator
-                    .registerCall(correlationId, 'TestCommand', 1000)
-                    .catch((error) => ({ rejected: true, error: error.message }));
-            });
-            // Wait for calls to register
-            yield new Promise((resolve) => setTimeout(resolve, 50));
-            // When: Zamknij coordinator
-            yield rpcCoordinator.close();
-            // Then: Wszystkie calls zostały rejected
-            const results = yield Promise.all(promises);
-            results.forEach((result) => {
-                expect(result).toEqual({
-                    rejected: true,
-                    error: 'RpcCoordinator is closing',
-                });
-            });
-            // Verify: Zamknięcie shared subscriber
-            expect(mockSharedSubscriber.punsubscribe).toHaveBeenCalledWith(`rpc:response:${processInstanceId}:*`);
-            expect(mockSharedSubscriber.quit).toHaveBeenCalled();
-        }));
-    });
-    describe('setJobId() - powiązanie pending call z jobem BullMQ', () => {
-        it('powinno ustawić jobId i queueName dla istniejącego pending call', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const correlationId = 'set-job-id-test';
-            const commandName = 'TestCommand';
-            const timeout = 200;
-            const jobId = 'job-123';
-            const queueName = 'TestQueue';
-            const responseChannel = `rpc:response:${processInstanceId}:${correlationId}`;
-            // Symuluj odpowiedź RPC
-            setTimeout(() => {
-                var _a;
-                const pmessageHandler = (_a = mockSharedSubscriber.on.mock.calls.find((call) => call[0] === 'pmessage')) === null || _a === void 0 ? void 0 : _a[1];
-                if (pmessageHandler) {
-                    const wrapper = {
-                        data: JSON.stringify({
-                            correlationId,
-                            result: { success: true },
-                            error: null,
-                        }),
-                        compressed: false,
-                    };
-                    pmessageHandler(`rpc:response:${processInstanceId}:*`, responseChannel, JSON.stringify(wrapper));
-                }
-            }, 50);
-            // When
-            const promise = rpcCoordinator.registerCall(correlationId, commandName, timeout);
-            // Poczekaj na rejestrację pending call
-            yield new Promise((resolve) => setTimeout(resolve, 10));
-            // Ustaw jobId
-            rpcCoordinator.setJobId(correlationId, jobId, queueName);
-            // Then
-            yield expect(promise).resolves.toEqual({ success: true });
-        }));
-        it('powinno ignorować setJobId dla nieistniejącego pending call', () => {
-            // Given
-            const nonExistentCorrelationId = 'non-existent-123';
-            const jobId = 'job-456';
-            const queueName = 'TestQueue';
-            // When & Then - nie powinno rzucić błędu
-            expect(() => {
-                rpcCoordinator.setJobId(nonExistentCorrelationId, jobId, queueName);
-            }).not.toThrow();
-            // Verify: zalogowano debug
-            expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining('Próba ustawienia jobId dla nieistniejącego pending call'), expect.objectContaining({ correlationId: nonExistentCorrelationId }));
-        });
-    });
-    describe('Cancellation przy timeout', () => {
-        it('powinno wywołać markAsCancelled przy timeout', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const correlationId = 'cancellation-test';
-            const commandName = 'TestCommand';
-            const timeout = 50;
-            // When
-            yield expect(rpcCoordinator.registerCall(correlationId, commandName, timeout)).rejects.toThrow('RPC timeout');
-            // Poczekaj na async handleTimeout
-            yield new Promise((resolve) => setTimeout(resolve, 10));
-            // Then
-            expect(mockCancellationService.markAsCancelled).toHaveBeenCalledWith(correlationId);
-        }));
-        it('powinno wywołać tryRemoveJob gdy jobId jest ustawione', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const correlationId = 'remove-job-test';
-            const commandName = 'TestCommand';
-            const timeout = 100;
-            const jobId = 'job-to-remove-789';
-            const queueName = 'TestQueueRemove';
-            // When
-            const promise = rpcCoordinator.registerCall(correlationId, commandName, timeout);
-            // Poczekaj na rejestrację i ustaw jobId
-            yield new Promise((resolve) => setTimeout(resolve, 10));
-            rpcCoordinator.setJobId(correlationId, jobId, queueName);
-            // Czekaj na timeout
-            yield expect(promise).rejects.toThrow('RPC timeout');
-            // Poczekaj na async handleTimeout
-            yield new Promise((resolve) => setTimeout(resolve, 20));
-            // Then
-            expect(mockCancellationService.markAsCancelled).toHaveBeenCalledWith(correlationId);
-            expect(mockCancellationService.tryRemoveJob).toHaveBeenCalledWith(jobId, queueName, mockRemoveJobCallback);
-        }));
-        it('powinno wywołać clearCancellation gdy job został usunięty', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const correlationId = 'clear-after-remove-test';
-            const commandName = 'TestCommand';
-            const timeout = 100;
-            const jobId = 'job-removed-successfully';
-            const queueName = 'TestQueueClear';
-            // Symuluj pomyślne usunięcie joba
-            mockCancellationService.tryRemoveJob.mockResolvedValue(true);
-            // When
-            const promise = rpcCoordinator.registerCall(correlationId, commandName, timeout);
-            yield new Promise((resolve) => setTimeout(resolve, 10));
-            rpcCoordinator.setJobId(correlationId, jobId, queueName);
-            yield expect(promise).rejects.toThrow('RPC timeout');
-            yield new Promise((resolve) => setTimeout(resolve, 20));
-            // Then
-            expect(mockCancellationService.clearCancellation).toHaveBeenCalledWith(correlationId);
-        }));
-        it('NIE powinno wywołać clearCancellation gdy job nie został usunięty', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const correlationId = 'no-clear-test';
-            const commandName = 'TestCommand';
-            const timeout = 100;
-            const jobId = 'job-not-removed';
-            const queueName = 'TestQueueNoClear';
-            // Symuluj nieudane usunięcie joba (już przetwarzany)
-            mockCancellationService.tryRemoveJob.mockResolvedValue(false);
-            // When
-            const promise = rpcCoordinator.registerCall(correlationId, commandName, timeout);
-            yield new Promise((resolve) => setTimeout(resolve, 10));
-            rpcCoordinator.setJobId(correlationId, jobId, queueName);
-            yield expect(promise).rejects.toThrow('RPC timeout');
-            yield new Promise((resolve) => setTimeout(resolve, 20));
-            // Then - clearCancellation NIE wywołane
-            expect(mockCancellationService.clearCancellation).not.toHaveBeenCalled();
-        }));
-        it('NIE powinno wywołać tryRemoveJob gdy jobId nie jest ustawione', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const correlationId = 'no-job-id-test';
-            const commandName = 'TestCommand';
-            const timeout = 50;
-            // When - NIE ustawiamy jobId
-            yield expect(rpcCoordinator.registerCall(correlationId, commandName, timeout)).rejects.toThrow('RPC timeout');
-            yield new Promise((resolve) => setTimeout(resolve, 10));
-            // Then - markAsCancelled wywołane, ale tryRemoveJob NIE
-            expect(mockCancellationService.markAsCancelled).toHaveBeenCalledWith(correlationId);
-            expect(mockCancellationService.tryRemoveJob).not.toHaveBeenCalled();
-        }));
-        it('powinno obsłużyć błędy cancellation service gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Given
-            const correlationId = 'error-handling-test';
-            const commandName = 'TestCommand';
-            const timeout = 50;
-            // Symuluj błąd w cancellation service
-            mockCancellationService.markAsCancelled.mockRejectedValue(new Error('Redis error'));
-            // When - nie powinno zmienić zachowania timeout
-            yield expect(rpcCoordinator.registerCall(correlationId, commandName, timeout)).rejects.toThrow('RPC timeout');
-            // Then - błąd obsłużony, nie propagowany
-            // (test przechodzi jeśli nie ma unhandled rejection)
-        }));
-    });
-    describe('Logowanie reconnect', () => {
-        it('powinno logować INFO po udanym reconnect', () => {
-            var _a, _b;
-            // Given: Pobierz handlery eventów
-            const onCalls = mockSharedSubscriber.on.mock.calls;
-            const reconnectingHandler = (_a = onCalls.find((call) => call[0] === 'reconnecting')) === null || _a === void 0 ? void 0 : _a[1];
-            const readyHandler = (_b = onCalls.find((call) => call[0] === 'ready')) === null || _b === void 0 ? void 0 : _b[1];
-            expect(reconnectingHandler).toBeDefined();
-            expect(readyHandler).toBeDefined();
-            // When: Symuluj reconnect
-            reconnectingHandler();
-            readyHandler();
-            // Then: Powinno zalogować INFO (logger.log) o ponownym połączeniu
-            expect(mockLogger.log).toHaveBeenCalledWith('Shared subscriber RPC - ponowne łączenie', expect.objectContaining({
-                processInstanceId,
-            }));
-            expect(mockLogger.log).toHaveBeenCalledWith('Shared subscriber RPC - ponownie połączony', expect.objectContaining({
-                processInstanceId,
-                reconnected: true,
-            }));
-        });
-        it('NIE powinno logować INFO przy pierwszym ready (bez reconnecting)', () => {
-            var _a;
-            // Given: Pobierz handler ready
-            const onCalls = mockSharedSubscriber.on.mock.calls;
-            const readyHandler = (_a = onCalls.find((call) => call[0] === 'ready')) === null || _a === void 0 ? void 0 : _a[1];
-            expect(readyHandler).toBeDefined();
-            // Wyczyść poprzednie wywołania
-            mockLogger.log.mockClear();
-            // When: Wywołaj ready BEZ wcześniejszego reconnecting
-            readyHandler();
-            // Then: NIE powinno logować "ponownie połączony"
-            expect(mockLogger.log).not.toHaveBeenCalledWith('Shared subscriber RPC - ponownie połączony', expect.any(Object));
-        });
-        it('powinno resetować flagę isReconnecting po logowaniu', () => {
-            var _a, _b;
-            // Given: Pobierz handlery eventów
-            const onCalls = mockSharedSubscriber.on.mock.calls;
-            const reconnectingHandler = (_a = onCalls.find((call) => call[0] === 'reconnecting')) === null || _a === void 0 ? void 0 : _a[1];
-            const readyHandler = (_b = onCalls.find((call) => call[0] === 'ready')) === null || _b === void 0 ? void 0 : _b[1];
-            expect(reconnectingHandler).toBeDefined();
-            expect(readyHandler).toBeDefined();
-            // When: Symuluj reconnect
-            reconnectingHandler();
-            readyHandler();
-            // Wyczyść wywołania
-            mockLogger.log.mockClear();
-            // Drugie wywołanie ready (bez reconnecting)
-            readyHandler();
-            // Then: Drugie ready NIE loguje INFO (flaga zresetowana)
-            expect(mockLogger.log).not.toHaveBeenCalledWith('Shared subscriber RPC - ponownie połączony', expect.any(Object));
-        });
-    });
-});
-//# sourceMappingURL=rpc-coordinator.spec.js.map