Add scouthub-home-be

2026-07-23 19:36:55 +02:00
parent cfd2de4ca3
commit 566754f825
45 changed files with 8233 additions and 0 deletions
@@ -0,0 +1,102 @@
+import nock from 'nock';
+
+process.env.KEYCLOAK_BASE_URL = 'http://keycloak.test';
+process.env.KEYCLOAK_REALM = 'scouthub';
+process.env.KEYCLOAK_ORG_SERVICE_CLIENT_ID = 'test-client';
+process.env.KEYCLOAK_ORG_SERVICE_CLIENT_SECRET = 'test-secret';
+process.env.DATABASE_URL = 'postgresql://user:pass@localhost:5432/scouthub_home_test';
+process.env.FRONTEND_BASE_URL = 'http://localhost:4200';
+
+import { getAccessToken, resetTokenCache } from '../../../src/keycloak-admin/tokenManager';
+
+const KEYCLOAK_HOST = 'http://keycloak.test';
+const TOKEN_PATH = '/realms/scouthub/protocol/openid-connect/token';
+
+function mockTokenEndpoint(accessToken: string, expiresInSeconds: number) {
+  return nock(KEYCLOAK_HOST)
+    .post(TOKEN_PATH)
+    .reply(200, { access_token: accessToken, expires_in: expiresInSeconds, token_type: 'Bearer' });
+}
+
+// Il modulo calcola la scadenza con Date.now(): per simulare il passare del
+// tempo mockiamo solo Date.now (non i timer), così le richieste HTTP mockate
+// da nock continuano a risolversi normalmente sull'event loop reale.
+let nowSpy: jest.SpyInstance<number, []> | undefined;
+
+function advanceTimeBy(ms: number): void {
+  const current = nowSpy ? (nowSpy.getMockImplementation()?.() ?? Date.now()) : Date.now();
+  nowSpy = jest.spyOn(Date, 'now').mockReturnValue(current + ms);
+}
+
+beforeEach(() => {
+  resetTokenCache();
+});
+
+afterEach(() => {
+  nowSpy?.mockRestore();
+  nowSpy = undefined;
+  nock.cleanAll();
+});
+
+describe('keycloak-admin tokenManager', () => {
+  test("ottiene un access token dall'endpoint client_credentials", async () => {
+    const scope = mockTokenEndpoint('token-1', 300);
+
+    const token = await getAccessToken();
+
+    expect(token).toBe('token-1');
+    expect(scope.isDone()).toBe(true);
+  });
+
+  test('riutilizza il token in cache invece di richiederne uno nuovo ad ogni chiamata', async () => {
+    const scope = mockTokenEndpoint('token-1', 300);
+
+    const first = await getAccessToken();
+    const second = await getAccessToken();
+    const third = await getAccessToken();
+
+    expect(first).toBe('token-1');
+    expect(second).toBe('token-1');
+    expect(third).toBe('token-1');
+    // Un solo interceptor registrato (consumato una volta sola): se il codice
+    // avesse richiesto un nuovo token per ogni chiamata, la seconda/terza
+    // sarebbero fallite per mancanza di un match su nock.
+    expect(scope.isDone()).toBe(true);
+  });
+
+  test('rinnova il token quando è vicino alla scadenza (entro il margine di sicurezza)', async () => {
+    mockTokenEndpoint('token-1', 300);
+    await getAccessToken();
+
+    // 295s dopo: mancano 5s alla scadenza reale, sotto al margine di sicurezza di 10s.
+    advanceTimeBy(295_000);
+
+    const renewalScope = mockTokenEndpoint('token-2', 300);
+    const renewed = await getAccessToken();
+
+    expect(renewed).toBe('token-2');
+    expect(renewalScope.isDone()).toBe(true);
+  });
+
+  test('non rinnova il token se la scadenza è ancora lontana', async () => {
+    mockTokenEndpoint('token-1', 300);
+    await getAccessToken();
+
+    advanceTimeBy(60_000); // ben dentro la validità dei 300s
+
+    const token = await getAccessToken();
+
+    expect(token).toBe('token-1');
+  });
+
+  test('richieste concorrenti senza token in cache generano una sola chiamata HTTP', async () => {
+    const scope = mockTokenEndpoint('token-1', 300);
+
+    const [a, b, c] = await Promise.all([getAccessToken(), getAccessToken(), getAccessToken()]);
+
+    expect(a).toBe('token-1');
+    expect(b).toBe('token-1');
+    expect(c).toBe('token-1');
+    expect(scope.isDone()).toBe(true);
+  });
+});
@@ -0,0 +1,128 @@
+import { generateKeyPairSync } from 'crypto';
+import express from 'express';
+import request from 'supertest';
+import nock from 'nock';
+import jwt from 'jsonwebtoken';
+
+process.env.KEYCLOAK_BASE_URL = 'http://keycloak.test';
+process.env.KEYCLOAK_REALM = 'scouthub';
+process.env.KEYCLOAK_ORG_SERVICE_CLIENT_ID = 'test-client';
+process.env.KEYCLOAK_ORG_SERVICE_CLIENT_SECRET = 'test-secret';
+process.env.DATABASE_URL = 'postgresql://user:pass@localhost:5432/scouthub_home_test';
+process.env.FRONTEND_BASE_URL = 'http://localhost:4200';
+
+import { authenticate } from '../../../src/middleware/authenticate';
+import { requireRole } from '../../../src/middleware/requireRole';
+
+const KEYCLOAK_HOST = 'http://keycloak.test';
+const CERTS_PATH = '/realms/scouthub/protocol/openid-connect/certs';
+const KID = 'test-kid';
+
+const { publicKey, privateKey } = generateKeyPairSync('rsa', { modulusLength: 2048 });
+const jwk = publicKey.export({ format: 'jwk' }) as Record<string, unknown>;
+const privateKeyPem = privateKey.export({ type: 'pkcs1', format: 'pem' }) as string;
+
+// Keypair "estranea": usata per firmare token che non devono validare contro
+// le chiavi pubblicate nel JWKS mockato (firma non corrispondente).
+const { privateKey: rogueKey } = generateKeyPairSync('rsa', { modulusLength: 2048 });
+const rogueKeyPem = rogueKey.export({ type: 'pkcs1', format: 'pem' }) as string;
+
+function mockJwks(): void {
+  nock(KEYCLOAK_HOST)
+    .persist()
+    .get(CERTS_PATH)
+    .reply(200, { keys: [{ ...jwk, kid: KID, alg: 'RS256', use: 'sig' }] });
+}
+
+function signValidToken(payload: object, signOptions: jwt.SignOptions = {}): string {
+  return jwt.sign(payload, privateKeyPem, {
+    algorithm: 'RS256',
+    keyid: KID,
+    expiresIn: '5m',
+    ...signOptions,
+  });
+}
+
+const CAPO_GRUPPO_PAYLOAD = {
+  sub: 'user-123',
+  email: 'capo@example.com',
+  realm_access: { roles: ['capo-gruppo', 'utente'] },
+  organization: {
+    'gruppo-alfa': { id: 'org-1', roles: ['owner'] },
+  },
+};
+
+function buildApp() {
+  const app = express();
+  app.get('/capo', authenticate, requireRole('capo-gruppo'), (req, res) => {
+    res.json({ auth: req.auth });
+  });
+  app.get('/solo-admin', authenticate, requireRole('super-admin'), (req, res) => {
+    res.json({ auth: req.auth });
+  });
+  return app;
+}
+
+beforeAll(() => {
+  mockJwks();
+});
+
+afterAll(() => {
+  nock.cleanAll();
+});
+
+describe('authenticate + requireRole', () => {
+  test('restituisce 401 se manca il token', async () => {
+    const app = buildApp();
+
+    const response = await request(app).get('/capo');
+
+    expect(response.status).toBe(401);
+  });
+
+  test('restituisce 401 se il token è scaduto', async () => {
+    const app = buildApp();
+    const token = signValidToken(CAPO_GRUPPO_PAYLOAD, { expiresIn: '-10s' });
+
+    const response = await request(app).get('/capo').set('Authorization', `Bearer ${token}`);
+
+    expect(response.status).toBe(401);
+  });
+
+  test('restituisce 401 se il token ha una firma non valida', async () => {
+    const app = buildApp();
+    const token = jwt.sign(CAPO_GRUPPO_PAYLOAD, rogueKeyPem, {
+      algorithm: 'RS256',
+      keyid: KID,
+      expiresIn: '5m',
+    });
+
+    const response = await request(app).get('/capo').set('Authorization', `Bearer ${token}`);
+
+    expect(response.status).toBe(401);
+  });
+
+  test('restituisce 403 se il token è valido ma manca il ruolo richiesto', async () => {
+    const app = buildApp();
+    const token = signValidToken(CAPO_GRUPPO_PAYLOAD);
+
+    const response = await request(app).get('/solo-admin').set('Authorization', `Bearer ${token}`);
+
+    expect(response.status).toBe(403);
+  });
+
+  test('restituisce 200 e popola req.auth se il token è valido con il ruolo corretto', async () => {
+    const app = buildApp();
+    const token = signValidToken(CAPO_GRUPPO_PAYLOAD);
+
+    const response = await request(app).get('/capo').set('Authorization', `Bearer ${token}`);
+
+    expect(response.status).toBe(200);
+    expect(response.body.auth).toEqual({
+      userId: 'user-123',
+      email: 'capo@example.com',
+      organizationId: 'org-1',
+      roles: ['capo-gruppo', 'utente', 'owner'],
+    });
+  });
+});