feat: adjust jest.config and fix test converage (#2)

Author: makdeniss

jest.config.ts

@@ -7,7 +7,13 @@ module.exports = {
   rootDir: '.',
   testRegex: '.*\\.spec\\.ts$',
   transform: {
-    '^.+\\.(t|j)s$': 'ts-jest',
+    '^.+\\.(t|j)s$': [
+      'ts-jest',
+      {
+        tsconfig: 'tsconfig.test.json',
+        useESM: true,
+      },
+    ],
   },
   collectCoverageFrom: ['**/*.(t|j)s'],
   coverageDirectory: './coverage',
@@ -20,11 +26,6 @@ module.exports = {
   },
   preset: 'ts-jest/presets/default-esm',
   extensionsToTreatAsEsm: ['.ts'],
-  globals: {
-    'ts-jest': {
-      useESM: true,
-    },
-  },
   transformIgnorePatterns: [
     '/node_modules/(?!(@openmfp/portal-server-lib|graphql-request)/)',
   ],

src/portal-options/request-context-provider/openmfp-request-context-provider.spec.ts

@@ -0,0 +1,48 @@
+import { OpenmfpPortalContextService } from '../portal-context-provider/openmfp-portal-context.service';
+import { RequestContextProviderImpl } from './openmfp-request-context-provider';
+import { EnvService } from '@openmfp/portal-server-lib';
+import type { Request } from 'express';
+import { mock } from 'jest-mock-extended';
+
+describe('RequestContextProviderImpl', () => {
+  let provider: RequestContextProviderImpl;
+  const envService = mock<EnvService>();
+  const portalContext = mock<OpenmfpPortalContextService>();
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    (envService.getDomain as unknown as jest.Mock).mockReturnValue({
+      idpName: 'org1',
+      domain: 'org1.example.com',
+    });
+    (portalContext.getContextValues as unknown as jest.Mock).mockResolvedValue({
+      crdGatewayApiUrl: 'http://gateway/graphql',
+      other: 'x',
+    });
+
+    provider = new RequestContextProviderImpl(
+      envService as any,
+      portalContext as any,
+    );
+  });
+
+  it('should merge request query, portal context and organization from envService', async () => {
+    const req = {
+      query: { account: 'acc-123', extra: '1' },
+      hostname: 'org1.example.com',
+    } as unknown as Request;
+
+    const result = await provider.getContextValues(req);
+
+    expect(result).toMatchObject({
+      account: 'acc-123',
+      extra: '1',
+      crdGatewayApiUrl: 'http://gateway/graphql',
+      other: 'x',
+      organization: 'org1',
+    });
+
+    expect(envService.getDomain).toHaveBeenCalledWith(req);
+    expect(portalContext.getContextValues).toHaveBeenCalledWith(req);
+  });
+});

src/portal-options/service-providers/iam/auth-callback-provider.spec.ts

@@ -39,4 +39,30 @@ describe('AuthCallbackProvider', () => {
     expect(iamServiceMock.addUser).toHaveBeenCalledTimes(1);
     expect(iamServiceMock.addUser).toHaveBeenCalledWith('idtoken', req);
   });
+
+  it('should log error if addUser throws', async () => {
+    const req = mock<Request>();
+    const res = mock<Response>();
+    const error = new Error('boom');
+    (iamServiceMock.addUser as jest.Mock).mockRejectedValueOnce(error);
+
+    const errorSpy = jest
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .spyOn((callback as any).logger, 'error')
+      .mockImplementation(() => undefined as unknown as never);
+
+    await callback.handleSuccess(req, res, {
+      id_token: 'bad',
+    } as AuthTokenData);
+
+    expect(iamServiceMock.addUser).toHaveBeenCalledTimes(1);
+    expect(errorSpy).toHaveBeenCalledWith(error);
+  });
+
+  it('should resolve handleFailure without action', async () => {
+    const req = mock<Request>();
+    const res = mock<Response>();
+
+    await expect(callback.handleFailure(req, res)).resolves.toBeUndefined();
+  });
 });

src/portal-options/service-providers/kubernetes-service-providers.service.spec.ts

@@ -0,0 +1,137 @@
+import { KubernetesServiceProvidersService } from './kubernetes-service-providers.service';
+
+const listClusterCustomObject = jest.fn();
+
+jest.mock('@kubernetes/client-node', () => {
+  class KubeConfig {
+    loadFromDefault = jest.fn();
+    getCurrentCluster = jest
+      .fn()
+      .mockReturnValue({ server: 'https://k8s.example.com/base' });
+    makeApiClient = jest.fn().mockImplementation(() => ({
+      listClusterCustomObject,
+    }));
+  }
+  class CustomObjectsApi {}
+  return { KubeConfig, CustomObjectsApi };
+});
+
+jest.mock('@kubernetes/client-node/dist/gen/middleware.js', () => ({
+  PromiseMiddlewareWrapper: class {
+    pre?: (ctx: any) => Promise<any> | any;
+    post?: (ctx: any) => Promise<any> | any;
+    constructor(opts: any) {
+      this.pre = opts.pre;
+      this.post = opts.post;
+    }
+  },
+}));
+
+describe('KubernetesServiceProvidersService', () => {
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it('should return empty list when API returns no items', async () => {
+    listClusterCustomObject.mockImplementation(
+      async (_gvr: any, _opts: any) => {
+        return {};
+      },
+    );
+
+    const svc = new KubernetesServiceProvidersService();
+    const res = await svc.getServiceProviders('token', [], {
+      organization: 'org',
+    });
+    expect(res.rawServiceProviders).toEqual([]);
+  });
+
+  it('should map items to contentConfiguration and fill url from spec when missing', async () => {
+    let capturedUrl = '';
+    listClusterCustomObject.mockImplementation(async (_gvr: any, opts: any) => {
+      const mw = opts?.middleware?.[0];
+      const ctx = {
+        _url: 'https://k8s.example.com/base',
+        getUrl() {
+          return this._url;
+        },
+        setUrl(u: string) {
+          this._url = u;
+        },
+      };
+      if (mw?.pre) await mw.pre(ctx);
+      capturedUrl = ctx._url;
+      return {
+        items: [
+          {
+            status: { configurationResult: JSON.stringify({}) },
+            spec: {
+              remoteConfiguration: { url: 'http://fallback.example/app' },
+            },
+          },
+        ],
+      };
+    });
+
+    const svc = new KubernetesServiceProvidersService();
+    const res = await svc.getServiceProviders('token', ['main'], {
+      organization: 'acme',
+      account: 'a1',
+    });
+
+    expect(res.rawServiceProviders[0].contentConfiguration).toHaveLength(1);
+    expect(res.rawServiceProviders[0].contentConfiguration[0].url).toBe(
+      'http://fallback.example/app',
+    );
+
+    expect(capturedUrl).toContain(
+      '/clusters/root:orgs:acme:a1/apis/core.openmfp.io/v1alpha1/contentconfigurations',
+    );
+  });
+
+  it('should retry once on HTTP 429 and log retry message', async () => {
+    jest.useFakeTimers();
+    const sequence: any[] = [
+      Object.assign(new Error('Too Many Requests'), { code: 429 }),
+      { items: [] },
+    ];
+    listClusterCustomObject.mockImplementation(async () => {
+      const next = sequence.shift();
+      if (next instanceof Error || next?.code === 429) {
+        throw next;
+      }
+      return next;
+    });
+
+    const logSpy = jest
+      .spyOn(console, 'log')
+      .mockImplementation(() => undefined as unknown as never);
+    const errSpy = jest
+      .spyOn(console, 'error')
+      .mockImplementation(() => undefined as unknown as never);
+
+    const svc = new KubernetesServiceProvidersService();
+    const promise = svc.getServiceProviders('token', [], {
+      organization: 'org',
+    });
+
+    await jest.advanceTimersByTimeAsync(1000);
+
+    const res = await promise;
+    expect(res.rawServiceProviders).toEqual([
+      {
+        name: 'openmfp-system',
+        displayName: '',
+        creationTimestamp: '',
+        contentConfiguration: [],
+      },
+    ]);
+    expect(logSpy).toHaveBeenCalledWith(
+      'Retry after 1 second reading kubernetes resources.',
+    );
+
+    logSpy.mockRestore();
+    errSpy.mockRestore();
+    jest.useRealTimers();
+  });
+});