@tstdl/base 0.93.182 → 0.93.183

package/api/server/tests/csrf.middleware.test.js

@@ -1,91 +0,0 @@
-import { ForbiddenError } from '../../../errors/index.js';
-import { HttpHeaders } from '../../../http/http-headers.js';
-import { HttpServerResponse } from '../../../http/server/index.js';
-import { toArray } from '../../../utils/array/array.js';
-import { describe, expect, it, vi } from 'vitest';
-import { csrfMiddleware } from '../middlewares/csrf.middleware.js';
-describe('csrfMiddleware', () => {
-    const middleware = csrfMiddleware();
-    it('should allow safe methods (GET, HEAD, OPTIONS, TRACE)', async () => {
-        const safeMethods = ['GET', 'HEAD', 'OPTIONS', 'TRACE'];
-        for (const method of safeMethods) {
-            const context = {
-                request: { method, headers: new HttpHeaders() },
-                response: new HttpServerResponse(),
-            };
-            const next = vi.fn();
-            await middleware(context, next);
-            expect(next).toHaveBeenCalled();
-        }
-    });
-    it('should allow mutating methods (POST, PUT, DELETE, PATCH) without headers (non-browser client)', async () => {
-        const mutatingMethods = ['POST', 'PUT', 'DELETE', 'PATCH'];
-        for (const method of mutatingMethods) {
-            const context = {
-                request: { method, headers: new HttpHeaders() },
-                response: new HttpServerResponse(),
-            };
-            const next = vi.fn();
-            await middleware(context, next);
-            expect(next).toHaveBeenCalled();
-        }
-    });
-    it('should allow same-origin requests via Sec-Fetch-Site', async () => {
-        const headers = new HttpHeaders();
-        headers.set('Sec-Fetch-Site', 'same-origin');
-        const context = {
-            request: { method: 'POST', headers },
-            response: new HttpServerResponse(),
-        };
-        const next = vi.fn();
-        await middleware(context, next);
-        expect(next).toHaveBeenCalled();
-    });
-    it('should allow user-initiated requests via Sec-Fetch-Site (none) when enabled', async () => {
-        const middlewareWithNone = csrfMiddleware({ allowFetchSiteNone: true });
-        const headers = new HttpHeaders();
-        headers.set('Sec-Fetch-Site', 'none');
-        const context = {
-            request: { method: 'POST', headers },
-            response: new HttpServerResponse(),
-        };
-        const next = vi.fn();
-        await middlewareWithNone(context, next);
-        expect(next).toHaveBeenCalled();
-    });
-    it('should reject cross-site requests via Sec-Fetch-Site', async () => {
-        const headers = new HttpHeaders();
-        headers.set('Sec-Fetch-Site', 'cross-site');
-        const context = {
-            request: { method: 'POST', headers },
-            response: new HttpServerResponse(),
-        };
-        const next = vi.fn();
-        await expect(middleware(context, next)).rejects.toThrow(ForbiddenError);
-        expect(next).not.toHaveBeenCalled();
-    });
-    it('should allow same-origin requests via Origin fallback', async () => {
-        const headers = new HttpHeaders();
-        headers.set('Origin', 'http://localhost:8080');
-        headers.set('Host', 'localhost:8080');
-        const context = {
-            request: { method: 'POST', headers },
-            response: new HttpServerResponse(),
-        };
-        const next = vi.fn();
-        await middleware(context, next);
-        expect(next).toHaveBeenCalled();
-    });
-    it('should include Vary: Sec-Fetch-Site, Origin for mutating methods', async () => {
-        const context = {
-            request: { method: 'POST', headers: new HttpHeaders() },
-            response: new HttpServerResponse(),
-        };
-        const next = vi.fn();
-        await middleware(context, next);
-        const vary = context.response.headers.tryGet('Vary');
-        const varyArray = toArray(vary).flatMap((v) => v.split(',').map((s) => s.trim()));
-        expect(varyArray).toContain('Sec-Fetch-Site');
-        expect(varyArray).toContain('Origin');
-    });
-});

package/authentication/tests/authentication-password-requirements.validator.test.d.ts

@@ -1 +0,0 @@
-export {};

package/authentication/tests/authentication-password-requirements.validator.test.js

@@ -1,29 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { PasswordRequirementsError } from '../errors/password-requirements.error.js';
-import { DefaultAuthenticationPasswordRequirementsValidator } from '../server/authentication-password-requirements.validator.js';
-describe('DefaultAuthenticationPasswordRequirementsValidator', () => {
-    const validator = new DefaultAuthenticationPasswordRequirementsValidator();
-    it('should return success when password is strong and not pwned', async () => {
-        // A very long random string is unlikely to be pwned and will be strong
-        const result = await validator.testPasswordRequirements('Very-Strong-And-Long-Password-2026!@#$%^&*()');
-        expect(result.success).toBe(true);
-    });
-    it('should return failure when password is pwned', async () => {
-        // "password" is definitely pwned
-        const result = await validator.testPasswordRequirements('password');
-        expect(result.success).toBe(false);
-        expect(result.reason).toContain('exposed in data breach');
-    });
-    it('should return failure when password is too weak', async () => {
-        // "abc" is too weak (and likely pwned)
-        const result = await validator.testPasswordRequirements('abc');
-        expect(result.success).toBe(false);
-        expect(result.reason).toBeDefined();
-    });
-    it('should throw PasswordRequirementsError on validation failure', async () => {
-        await expect(validator.validatePasswordRequirements('abc')).rejects.toThrow(PasswordRequirementsError);
-    });
-    it('should not throw on validation success', async () => {
-        await expect(validator.validatePasswordRequirements('Very-Strong-And-Long-Password-2026!@#$%^&*()')).resolves.not.toThrow();
-    });
-});

package/authentication/tests/authentication.api-controller.test.d.ts

@@ -1 +0,0 @@
-export {};

package/authentication/tests/authentication.api-controller.test.js

@@ -1,156 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
-import { Auditor } from '../../audit/index.js';
-import { AuthenticationClientService } from '../../authentication/client/index.js';
-import { AuthenticationAncillaryService, AuthenticationService as AuthenticationServerService } from '../../authentication/server/index.js';
-import { HttpClientOptions } from '../../http/client/index.js';
-import { HttpServer } from '../../http/server/index.js';
-import { runInInjectionContext } from '../../injector/index.js';
-import { clearTenantData, setupIntegrationTest } from '../../testing/index.js';
-import { currentTimestampSeconds } from '../../utils/date-time.js';
-import { SubjectService } from '../server/subject.service.js';
-import { DefaultAuthenticationAncillaryService } from './authentication.test-ancillary-service.js';
-describe('AuthenticationApiController Integration', () => {
-    let injector;
-    let database;
-    let service;
-    let serverService;
-    let subjectService;
-    let server;
-    const schema = 'authentication';
-    const tenantId = crypto.randomUUID();
-    beforeAll(async () => {
-        const storage = new Map();
-        globalThis.localStorage = {
-            getItem: vi.fn((key) => storage.get(key) ?? null),
-            setItem: vi.fn((key, value) => storage.set(key, value)),
-            removeItem: vi.fn((key) => storage.delete(key)),
-            clear: vi.fn(() => storage.clear()),
-        };
-        ({ injector, database } = await setupIntegrationTest({
-            modules: { authentication: true, audit: true, keyValueStore: true, signals: true, api: true, webServer: true },
-            authentication: {
-                ancillaryService: DefaultAuthenticationAncillaryService,
-            },
-        }));
-        await runInInjectionContext(injector, async () => {
-            server = injector.resolve(HttpServer);
-            const httpClientOptions = injector.resolve(HttpClientOptions);
-            httpClientOptions.baseUrl = `http://localhost:${server.port}`;
-            serverService = await injector.resolveAsync(AuthenticationServerService);
-            subjectService = await injector.resolveAsync(SubjectService);
-            service = await injector.resolveAsync(AuthenticationClientService);
-            service.initialize();
-        });
-    });
-    afterAll(async () => {
-        await server?.close(1000);
-        await injector?.dispose();
-    });
-    beforeEach(async () => {
-        globalThis.localStorage?.clear();
-        await clearTenantData(database, schema, ['used_totp_tokens', 'totp_recovery_code', 'totp', 'password', 'session', 'user', 'service_account', 'system_account', 'subject'], tenantId);
-    });
-    test('login should work via API client', async () => {
-        await runInInjectionContext(injector, async () => {
-            const user = await subjectService.createUser({ tenantId, email: 'api-login@example.com', firstName: 'A', lastName: 'L' });
-            await serverService.setPassword(user, 'Strong-Password-2026!');
-            await service.login({ tenantId, subject: user.id }, 'Strong-Password-2026!');
-            expect(service.isLoggedIn()).toBe(true);
-            expect(service.subjectId()).toBe(user.id);
-        });
-    });
-    test('login should work even if an expired token is present in the Authorization header', async () => {
-        await runInInjectionContext(injector, async () => {
-            const user = await subjectService.createUser({ tenantId, email: 'expired-token-login@example.com', firstName: 'E', lastName: 'L' });
-            await serverService.setPassword(user, 'Strong-Password-2026!');
-            // Create an expired token
-            const now = currentTimestampSeconds();
-            const expiredTokenResult = await serverService.createToken({
-                subject: user,
-                sessionId: crypto.randomUUID(),
-                impersonator: undefined,
-                additionalTokenPayload: {},
-                refreshTokenExpiration: now - 3600,
-                expiration: now - 3600, // Expired 1 hour ago
-                issuedAt: now - 7200,
-                timestamp: (now - 7200) * 1000,
-            });
-            // Inject the expired token into the client service
-            service.updateRawTokens(`Bearer ${expiredTokenResult.token}`);
-            // Now try to login
-            await service.login({ tenantId, subject: user.id }, 'Strong-Password-2026!');
-            expect(service.isLoggedIn()).toBe(true);
-            expect(service.subjectId()).toBe(user.id);
-        });
-    });
-    test('checkPassword should work via API client', async () => {
-        const result = await service.checkPassword('abc');
-        expect(result.strength).toBeLessThan(2);
-    });
-    test('refresh should work via API client', async () => {
-        await runInInjectionContext(injector, async () => {
-            const user = await subjectService.createUser({ tenantId, email: 'api-refresh@example.com', firstName: 'A', lastName: 'L' });
-            await serverService.setPassword(user, 'Strong-Password-2026!');
-            await service.login({ tenantId, subject: user.id }, 'Strong-Password-2026!');
-            const initialToken = service.token()?.jti;
-            await service.refresh();
-            expect(service.token()?.jti).not.toBe(initialToken);
-        });
-    });
-    test('impersonation should work via API client', async () => {
-        await runInInjectionContext(injector, async () => {
-            const admin = await subjectService.createUser({ tenantId, email: 'api-admin@example.com', firstName: 'A', lastName: 'D' });
-            const user = await subjectService.createUser({ tenantId, email: 'api-user@example.com', firstName: 'U', lastName: 'S' });
-            await serverService.setPassword(admin, 'Admin-Pass-123!');
-            expect(await subjectService.exists(tenantId, admin.id)).toBe(true);
-            expect(await subjectService.exists(tenantId, user.id)).toBe(true);
-            await service.login({ tenantId, subject: admin.id }, 'Admin-Pass-123!');
-            await service.impersonate(user.id);
-            expect(service.subjectId()).toBe(user.id);
-            expect(service.token()?.impersonator).toBe(admin.id);
-            await service.unimpersonate();
-            expect(service.subjectId()).toBe(admin.id);
-        });
-    });
-    test('password reset should work via API client', async () => {
-        await runInInjectionContext(injector, async () => {
-            const user = await subjectService.createUser({ tenantId, email: 'api-reset@example.com', firstName: 'A', lastName: 'L' });
-            const ancillaryService = await injector.resolveAsync(AuthenticationAncillaryService);
-            await service.initPasswordReset({ tenantId, subject: user.id }, undefined);
-            await vi.waitFor(() => expect(ancillaryService.lastResetData).toBeDefined(), { timeout: 5000, interval: 50 });
-            await service.resetPassword(ancillaryService.lastResetData.token, 'New-API-Pass-123!');
-            await service.login({ tenantId, subject: user.id }, 'New-API-Pass-123!');
-            expect(service.isLoggedIn()).toBe(true);
-        });
-    });
-    test('listSessions and invalidateAllOtherSessions should work via API client', async () => {
-        await runInInjectionContext(injector, async () => {
-            const user = await subjectService.createUser({ tenantId, email: 'api-sessions@example.com', firstName: 'S', lastName: 'E' });
-            await serverService.setPassword(user, 'Strong-Password-2026!');
-            // Create two sessions
-            const auditor = injector.resolve(Auditor);
-            await serverService.login({ tenantId, subject: user.id }, 'Strong-Password-2026!', undefined, auditor);
-            await service.login({ tenantId, subject: user.id }, 'Strong-Password-2026!');
-            const sessions = await service.listSessions();
-            expect(sessions.length).toBe(2);
-            expect(sessions[0]).toHaveProperty('id');
-            expect(sessions[0]).toHaveProperty('begin');
-            expect(sessions[0]).toHaveProperty('end');
-            await service.invalidateAllOtherSessions();
-            const updatedSessions = await service.listSessions();
-            // Only the current session should remain
-            expect(updatedSessions.length).toBe(1);
-            expect(updatedSessions[0].id).toBe(service.sessionId());
-        });
-    });
-    test('changePassword should work via API client', async () => {
-        await runInInjectionContext(injector, async () => {
-            const user = await subjectService.createUser({ tenantId, email: 'api-change-secret@example.com', firstName: 'C', lastName: 'S' });
-            await serverService.setPassword(user, 'Old-Strong-Password-2026!');
-            await service.login({ tenantId, subject: user.id }, 'Old-Strong-Password-2026!');
-            await service.changePassword('Old-Strong-Password-2026!', 'New-Strong-Password-2026!');
-            const authResult = await serverService.authenticateWithPassword({ tenantId, subject: user.id }, 'New-Strong-Password-2026!');
-            expect(authResult.success).toBe(true);
-        });
-    });
-});

package/authentication/tests/authentication.api-request-token.provider.test.d.ts

@@ -1 +0,0 @@
-export {};

package/authentication/tests/authentication.api-request-token.provider.test.js

@@ -1,48 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from 'vitest';
-import { AuthenticationApiRequestTokenProvider } from '../../authentication/server/authentication-api-request-token.provider.js';
-import { AuthenticationService } from '../../authentication/server/index.js';
-import { runInInjectionContext } from '../../injector/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { SubjectService } from '../server/subject.service.js';
-describe('AuthenticationApiRequestTokenProvider', () => {
-    let injector;
-    let authenticationService;
-    let subjectService;
-    let tokenProvider;
-    const tenantId = crypto.randomUUID();
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { authentication: true, signals: true } }));
-        authenticationService = await injector.resolveAsync(AuthenticationService);
-        subjectService = await injector.resolveAsync(SubjectService);
-        tokenProvider = injector.resolve(AuthenticationApiRequestTokenProvider);
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    test('should extract and validate token', async () => {
-        await runInInjectionContext(injector, async () => {
-            const user = await subjectService.createUser({ tenantId, email: 'provider-test@example.com', firstName: 'P', lastName: 'T' });
-            const tokenResult = await authenticationService.getToken(user, undefined);
-            const request = {
-                headers: {
-                    tryGet: (name) => name == 'Authorization' ? `Bearer ${tokenResult.token}` : undefined,
-                },
-                cookies: {
-                    tryGet: () => undefined,
-                },
-            };
-            const data = { request };
-            const token = await tokenProvider.tryGetToken(data);
-            expect(token.payload.subject).toBe(user.id);
-        });
-    });
-    test('should return null if no token', async () => {
-        const request = {
-            headers: { tryGet: () => undefined },
-            cookies: { tryGet: () => undefined },
-        };
-        const data = { request };
-        const token = await tokenProvider.tryGetToken(data);
-        expect(token).toBeNull();
-    });
-});

package/authentication/tests/authentication.client-error-handling.test.d.ts

@@ -1 +0,0 @@
-export {};

package/authentication/tests/authentication.client-error-handling.test.js

@@ -1,123 +0,0 @@
-import { Subject } from 'rxjs';
-import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
-import { AuthenticationClientService } from '../../authentication/client/authentication.service.js';
-import { AUTHENTICATION_API_CLIENT } from '../../authentication/client/tokens.js';
-import { CancellationSignal, CancellationToken } from '../../cancellation/token.js';
-import { BadRequestError } from '../../errors/bad-request.error.js';
-import { ForbiddenError } from '../../errors/forbidden.error.js';
-import { InvalidTokenError } from '../../errors/invalid-token.error.js';
-import { NotFoundError } from '../../errors/not-found.error.js';
-import { NotSupportedError } from '../../errors/not-supported.error.js';
-import { UnauthorizedError } from '../../errors/unauthorized.error.js';
-import { Injector } from '../../injector/index.js';
-import { Lock } from '../../lock/index.js';
-import { Logger } from '../../logger/index.js';
-import { MessageBus } from '../../message-bus/index.js';
-import { configureDefaultSignalsImplementation } from '../../signals/implementation/configure.js';
-import { currentTimestampSeconds } from '../../utils/date-time.js';
-import { timeout } from '../../utils/timing.js';
-describe('AuthenticationClientService Error Handling & Stuck States', () => {
-    let injector;
-    let service;
-    let mockApiClient;
-    let mockLock;
-    let mockMessageBus;
-    let mockLogger;
-    let disposeToken;
-    beforeEach(() => {
-        const storage = new Map();
-        globalThis.localStorage = {
-            getItem: vi.fn((key) => storage.get(key) ?? null),
-            setItem: vi.fn((key, value) => storage.set(key, value)),
-            removeItem: vi.fn((key) => storage.delete(key)),
-            clear: vi.fn(() => storage.clear()),
-        };
-        configureDefaultSignalsImplementation();
-        injector = new Injector('Test');
-        mockApiClient = {
-            login: vi.fn(),
-            refresh: vi.fn(),
-            timestamp: vi.fn().mockResolvedValue(currentTimestampSeconds()),
-            endSession: vi.fn().mockResolvedValue(undefined),
-        };
-        mockLock = {
-            tryUse: vi.fn(async (_timeout, callback) => {
-                const result = await callback({ lost: false });
-                return { success: true, result };
-            }),
-            use: vi.fn(async (_timeout, callback) => {
-                return await callback({ lost: false });
-            }),
-        };
-        mockMessageBus = {
-            publishAndForget: vi.fn(),
-            messages$: new Subject(),
-            dispose: vi.fn(),
-            allMessages$: new Subject(),
-        };
-        mockLogger = {
-            error: vi.fn(),
-            warn: vi.fn(),
-            info: vi.fn(),
-            debug: vi.fn(),
-        };
-        injector.register(AUTHENTICATION_API_CLIENT, { useValue: mockApiClient });
-        injector.register(Lock, { useValue: mockLock });
-        injector.register(MessageBus, { useValue: mockMessageBus });
-        injector.register(Logger, { useValue: mockLogger });
-        disposeToken = new CancellationToken();
-        injector.register(CancellationSignal, { useValue: disposeToken.signal });
-    });
-    afterEach(async () => {
-        disposeToken.set();
-        await injector.dispose();
-    });
-    function setupServiceWithToken(iatOffset = -10, expOffset = 5) {
-        const now = currentTimestampSeconds();
-        const initialToken = { iat: now + iatOffset, exp: now + expOffset, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
-    }
-    test('Corrupt Storage: should handle invalid JSON in storage gracefully', async () => {
-        // initialize with corrupt token
-        globalThis.localStorage.setItem('AuthenticationService:token', '{ invalid-json');
-        service = injector.resolve(AuthenticationClientService);
-        expect(service.token()).toBeUndefined();
-        expect(mockLogger.warn).toHaveBeenCalled(); // Should warn about parse error
-    });
-    test.each([
-        ['InvalidTokenError', new InvalidTokenError()],
-        ['NotFoundError', new NotFoundError('Session not found')],
-        ['ForbiddenError', new ForbiddenError()],
-        ['UnauthorizedError', new UnauthorizedError()],
-        ['NotSupportedError', new NotSupportedError()],
-        ['BadRequestError', new BadRequestError()],
-    ])('Unrecoverable Errors: should logout on %s during refresh', async (_, error) => {
-        setupServiceWithToken();
-        mockApiClient.refresh.mockRejectedValue(error);
-        // Wait for loop to pick up refresh
-        await timeout(20);
-        expect(mockApiClient.endSession).toHaveBeenCalled();
-        expect(service.token()).toBeUndefined();
-    });
-    test('Recoverable Errors: should NOT logout on generic Error during refresh', async () => {
-        setupServiceWithToken();
-        mockApiClient.refresh.mockRejectedValue(new Error('Network failure'));
-        await timeout(20);
-        // Should NOT have called endSession (logout)
-        expect(mockApiClient.endSession).not.toHaveBeenCalled();
-        // Token should still be present (retry logic handles it)
-        expect(service.token()).toBeDefined();
-        // Trigger immediate retry to finish test quickly
-        service.requestRefresh();
-        await timeout(20);
-    });
-    test('Logout Failure: should clear local token even if server logout fails', async () => {
-        setupServiceWithToken(-1000, 1000);
-        mockApiClient.endSession.mockRejectedValue(new Error('Network error during logout'));
-        await service.logout();
-        expect(mockApiClient.endSession).toHaveBeenCalled();
-        expect(service.token()).toBeUndefined();
-        expect(mockMessageBus.publishAndForget).toHaveBeenCalled(); // loggedOutBus
-    });
-});

package/authentication/tests/authentication.client-middleware.test.d.ts

@@ -1 +0,0 @@
-export {};

package/authentication/tests/authentication.client-middleware.test.js

@@ -1,118 +0,0 @@
-import { of } from 'rxjs';
-import { describe, expect, test, vi } from 'vitest';
-import { HttpClientRequest, HttpClientResponse, HttpError, HttpErrorReason } from '../../http/index.js';
-import { dontWaitForValidToken } from '../authentication.api.js';
-import { logoutOnUnauthorizedMiddleware, waitForAuthenticationMiddleware } from '../client/http-client.middleware.js';
-describe('waitForAuthenticationMiddleware', () => {
-    test('should wait for token and call next', async () => {
-        const authenticationServiceMock = {
-            token: vi.fn().mockReturnValue({ jti: 'test-token' }),
-            validToken$: of({ jti: 'test-token' }),
-            hasValidToken: true,
-        };
-        const middleware = waitForAuthenticationMiddleware(authenticationServiceMock);
-        const request = new HttpClientRequest('http://localhost');
-        request.context = {
-            endpoint: {
-                credentials: true,
-            },
-        };
-        const next = vi.fn().mockResolvedValue(undefined);
-        await middleware({ request }, next);
-        expect(next).toHaveBeenCalled();
-    });
-    test('should NOT wait if endpoint has dontWaitForValidToken', async () => {
-        const authenticationServiceMock = {
-            isLoggedIn: vi.fn().mockReturnValue(true),
-            hasValidToken: false,
-        };
-        const middleware = waitForAuthenticationMiddleware(authenticationServiceMock);
-        const request = new HttpClientRequest('http://localhost');
-        request.context = {
-            endpoint: {
-                credentials: true,
-                data: {
-                    [dontWaitForValidToken]: true,
-                },
-            },
-        };
-        const next = vi.fn().mockResolvedValue(undefined);
-        await middleware({ request }, next);
-        expect(next).toHaveBeenCalled();
-    });
-    test('should NOT wait if credentials is NOT true', async () => {
-        const authenticationServiceMock = {
-            isLoggedIn: vi.fn().mockReturnValue(true),
-            hasValidToken: false,
-        };
-        const middleware = waitForAuthenticationMiddleware(authenticationServiceMock);
-        const request = new HttpClientRequest('http://localhost');
-        request.context = {
-            endpoint: {
-                credentials: false,
-            },
-        };
-        const next = vi.fn().mockResolvedValue(undefined);
-        await middleware({ request }, next);
-        expect(next).toHaveBeenCalled();
-    });
-});
-describe('logoutOnUnauthorizedMiddleware', () => {
-    test('should call logout on 401 error', async () => {
-        const authenticationServiceMock = {
-            logout: vi.fn().mockResolvedValue(undefined),
-        };
-        const middleware = logoutOnUnauthorizedMiddleware(authenticationServiceMock);
-        const request = new HttpClientRequest('http://localhost');
-        const response = new HttpClientResponse({
-            request,
-            statusCode: 401,
-            statusMessage: 'Unauthorized',
-            headers: {},
-            body: undefined,
-            closeHandler: () => { }
-        });
-        const error = new HttpError(HttpErrorReason.StatusCode, request, { response });
-        const next = vi.fn().mockRejectedValue(error);
-        await expect(middleware({ request }, next)).rejects.toThrow(HttpError);
-        expect(authenticationServiceMock.logout).toHaveBeenCalled();
-    });
-    test('should NOT call logout on 401 error if endpoint has dontWaitForValidToken', async () => {
-        const authenticationServiceMock = {
-            logout: vi.fn().mockResolvedValue(undefined),
-        };
-        const middleware = logoutOnUnauthorizedMiddleware(authenticationServiceMock);
-        const request = new HttpClientRequest('http://localhost');
-        request.context = {
-            endpoint: {
-                resource: 'end-session',
-                data: {
-                    [dontWaitForValidToken]: true,
-                },
-            },
-        };
-        const response = new HttpClientResponse({
-            request,
-            statusCode: 401,
-            statusMessage: 'Unauthorized',
-            headers: {},
-            body: undefined,
-            closeHandler: () => { }
-        });
-        const error = new HttpError(HttpErrorReason.StatusCode, request, { response });
-        const next = vi.fn().mockRejectedValue(error);
-        await expect(middleware({ request }, next)).rejects.toThrow(HttpError);
-        expect(authenticationServiceMock.logout).not.toHaveBeenCalled();
-    });
-    test('should not call logout on other errors', async () => {
-        const authenticationServiceMock = {
-            logout: vi.fn().mockResolvedValue(undefined),
-        };
-        const middleware = logoutOnUnauthorizedMiddleware(authenticationServiceMock);
-        const request = new HttpClientRequest('http://localhost');
-        const error = new Error('Some other error');
-        const next = vi.fn().mockRejectedValue(error);
-        await expect(middleware({ request }, next)).rejects.toThrow('Some other error');
-        expect(authenticationServiceMock.logout).not.toHaveBeenCalled();
-    });
-});

package/authentication/tests/authentication.client-service-methods.test.d.ts

@@ -1 +0,0 @@
-export {};