Extend integration test to all registered benchmark providers

Author: ravikiranvm

packages/server/api/test/integration/ce/benchmark/benchmark-module.test.ts

@@ -108,6 +108,10 @@ afterAll(async () => {
   process.env = originalEnv;
 });
 
+const allBenchmarkProviders = Object.values(
+  BenchmarkProviders,
+) as BenchmarkProviders[];
+
 describe('Benchmark wizard API', () => {
   const postWizard = async ({
     provider,
@@ -127,61 +131,68 @@ describe('Benchmark wizard API', () => {
 
   describe('POST /v1/benchmarks/:provider/wizard', () => {
     beforeEach(() => {
+      wizardServiceMock.resolveWizardNavigation.mockClear();
       wizardServiceMock.resolveWizardNavigation.mockResolvedValue(
         mockWizardStep,
       );
       process.env.OPS_FINOPS_BENCHMARK_ENABLED = 'true';
     });
 
-    it('calls resolveWizardNavigation with AWS provider, body, and projectId and returns mocked step', async () => {
-      const { token, project } = await createAndInsertMocks();
-      const body = {};
-
-      const response = await postWizard({
-        provider: BenchmarkProviders.AWS,
-        token,
-        body,
-      });
-
-      expect(response?.statusCode).toBe(StatusCodes.OK);
-      expect(response?.json()).toEqual(mockWizardStep);
-      expect(wizardServiceMock.resolveWizardNavigation).toHaveBeenCalledTimes(
-        1,
-      );
-      expect(wizardServiceMock.resolveWizardNavigation).toHaveBeenCalledWith(
-        BenchmarkProviders.AWS,
-        {
-          currentStep: undefined,
-          benchmarkConfiguration: undefined,
-        },
-        project.id,
-      );
-    });
-
-    it('passes currentStep and benchmarkConfiguration to resolveWizardNavigation', async () => {
-      const { token, project } = await createAndInsertMocks();
-      const body = {
-        currentStep: 'connection',
-        benchmarkConfiguration: { connection: ['conn-1'] },
-      };
-
-      const response = await postWizard({
-        provider: BenchmarkProviders.AWS,
-        token,
-        body,
-      });
+    it.each(allBenchmarkProviders)(
+      'calls resolveWizardNavigation with %s provider, body, and projectId and returns mocked step',
+      async (provider) => {
+        const { token, project } = await createAndInsertMocks();
+        const body = {};
+
+        const response = await postWizard({
+          provider,
+          token,
+          body,
+        });
+
+        expect(response?.statusCode).toBe(StatusCodes.OK);
+        expect(response?.json()).toEqual(mockWizardStep);
+        expect(wizardServiceMock.resolveWizardNavigation).toHaveBeenCalledTimes(
+          1,
+        );
+        expect(wizardServiceMock.resolveWizardNavigation).toHaveBeenCalledWith(
+          provider,
+          {
+            currentStep: undefined,
+            benchmarkConfiguration: undefined,
+          },
+          project.id,
+        );
+      },
+    );
 
-      expect(response?.statusCode).toBe(StatusCodes.OK);
-      expect(response?.json()).toEqual(mockWizardStep);
-      expect(wizardServiceMock.resolveWizardNavigation).toHaveBeenCalledWith(
-        BenchmarkProviders.AWS,
-        {
+    it.each(allBenchmarkProviders)(
+      'passes currentStep and benchmarkConfiguration to resolveWizardNavigation (%s)',
+      async (provider) => {
+        const { token, project } = await createAndInsertMocks();
+        const body = {
           currentStep: 'connection',
           benchmarkConfiguration: { connection: ['conn-1'] },
-        },
-        project.id,
-      );
-    });
+        };
+
+        const response = await postWizard({
+          provider,
+          token,
+          body,
+        });
+
+        expect(response?.statusCode).toBe(StatusCodes.OK);
+        expect(response?.json()).toEqual(mockWizardStep);
+        expect(wizardServiceMock.resolveWizardNavigation).toHaveBeenCalledWith(
+          provider,
+          {
+            currentStep: 'connection',
+            benchmarkConfiguration: { connection: ['conn-1'] },
+          },
+          project.id,
+        );
+      },
+    );
 
     it('returns 400 when provider is not in BenchmarkProviders enum', async () => {
       const { token } = await createAndInsertMocks();
@@ -254,38 +265,49 @@ describe('Benchmark wizard API', () => {
 });
 
 describe('Create Benchmark API (POST /v1/benchmarks/:provider)', () => {
-  const validCreateBody = {
+  const validAwsCreateBody = {
     benchmarkConfiguration: {
       connection: ['conn-1'],
       workflows: ['AWS Benchmark - Unattached EBS'],
       regions: ['us-east-1'],
     },
   };
 
-  const mockCreateResult = {
+  const validAzureCreateBody = {
+    benchmarkConfiguration: {
+      connection: ['conn-1'],
+      workflows: ['Azure Benchmark - Unattached Managed Disks'],
+      regions: ['eastus'],
+      subscriptions: ['sub-a', 'sub-b'],
+    },
+  };
+
+  const mockCreateBenchmarkWorkflows = [
+    {
+      flowId: 'flow-1',
+      displayName: 'Orchestrator',
+      isOrchestrator: true,
+      isCleanup: false,
+    },
+    {
+      flowId: 'flow-2',
+      displayName: 'Cleanup',
+      isOrchestrator: false,
+      isCleanup: true,
+    },
+    {
+      flowId: 'flow-3',
+      displayName: 'Sub',
+      isOrchestrator: false,
+      isCleanup: false,
+    },
+  ];
+
+  const mockAwsCreateResult = {
     benchmarkId: 'bench-1',
     folderId: 'folder-1',
-    provider: 'aws',
-    workflows: [
-      {
-        flowId: 'flow-1',
-        displayName: 'Orchestrator',
-        isOrchestrator: true,
-        isCleanup: false,
-      },
-      {
-        flowId: 'flow-2',
-        displayName: 'Cleanup',
-        isOrchestrator: false,
-        isCleanup: true,
-      },
-      {
-        flowId: 'flow-3',
-        displayName: 'Sub',
-        isOrchestrator: false,
-        isCleanup: false,
-      },
-    ],
+    provider: BenchmarkProviders.AWS,
+    workflows: mockCreateBenchmarkWorkflows,
     webhookPayload: {
       webhookBaseUrl: 'https://api.example.com',
       workflows: ['flow-3'],
@@ -295,6 +317,37 @@ describe('Create Benchmark API (POST /v1/benchmarks/:provider)', () => {
     },
   };
 
+  const mockAzureCreateResult = {
+    benchmarkId: 'bench-1',
+    folderId: 'folder-1',
+    provider: BenchmarkProviders.AZURE,
+    workflows: mockCreateBenchmarkWorkflows,
+    webhookPayload: {
+      webhookBaseUrl: 'https://api.example.com',
+      workflows: ['flow-3'],
+      cleanupWorkflows: ['flow-2'],
+      subscriptions: ['sub-a', 'sub-b'],
+      regions: ['eastus'],
+    },
+  };
+
+  const createBenchmarkSuccessCases: ReadonlyArray<{
+    provider: BenchmarkProviders;
+    body: typeof validAwsCreateBody | typeof validAzureCreateBody;
+    mockResult: typeof mockAwsCreateResult | typeof mockAzureCreateResult;
+  }> = [
+    {
+      provider: BenchmarkProviders.AWS,
+      body: validAwsCreateBody,
+      mockResult: mockAwsCreateResult,
+    },
+    {
+      provider: BenchmarkProviders.AZURE,
+      body: validAzureCreateBody,
+      mockResult: mockAzureCreateResult,
+    },
+  ];
+
   const postCreate = async ({
     provider,
     token,
@@ -308,41 +361,44 @@ describe('Create Benchmark API (POST /v1/benchmarks/:provider)', () => {
       method: 'POST',
       url: `/v1/benchmarks/${provider}`,
       headers: token ? { authorization: `Bearer ${token}` } : undefined,
-      body: body ?? validCreateBody,
+      body: body ?? validAwsCreateBody,
     });
 
   beforeEach(() => {
     createBenchmarkServiceMock.createBenchmark.mockReset();
     process.env.OPS_FINOPS_BENCHMARK_ENABLED = 'true';
   });
 
-  it('returns 201 and BenchmarkCreationResult when body is valid', async () => {
-    createBenchmarkServiceMock.createBenchmark.mockResolvedValue(
-      mockCreateResult,
-    );
-    const { token, project } = await createAndInsertMocks();
+  it.each(createBenchmarkSuccessCases)(
+    'returns 201 and BenchmarkCreationResult when body is valid ($provider)',
+    async ({ provider, body, mockResult }) => {
+      createBenchmarkServiceMock.createBenchmark.mockResolvedValue(mockResult);
+      const { token, project } = await createAndInsertMocks();
 
-    const response = await postCreate({
-      provider: BenchmarkProviders.AWS,
-      token,
-      body: validCreateBody,
-    });
+      const response = await postCreate({
+        provider,
+        token,
+        body,
+      });
 
-    expect(response?.statusCode).toBe(StatusCodes.CREATED);
-    expect(response?.json()).toEqual(mockCreateResult);
-    expect(createBenchmarkServiceMock.createBenchmark).toHaveBeenCalledTimes(1);
-    expect(createBenchmarkServiceMock.createBenchmark).toHaveBeenCalledWith({
-      provider: BenchmarkProviders.AWS,
-      projectId: project.id,
-      userId: expect.any(String),
-      benchmarkConfiguration: validCreateBody.benchmarkConfiguration,
-    });
-  });
+      expect(response?.statusCode).toBe(StatusCodes.CREATED);
+      expect(response?.json()).toEqual(mockResult);
+      expect(createBenchmarkServiceMock.createBenchmark).toHaveBeenCalledTimes(
+        1,
+      );
+      expect(createBenchmarkServiceMock.createBenchmark).toHaveBeenCalledWith({
+        provider,
+        projectId: project.id,
+        userId: expect.any(String),
+        benchmarkConfiguration: body.benchmarkConfiguration,
+      });
+    },
+  );
 
   it('returns 401 when not authenticated', async () => {
     const response = await postCreate({
       provider: BenchmarkProviders.AWS,
-      body: validCreateBody,
+      body: validAwsCreateBody,
     });
 
     expect(response?.statusCode).toBe(StatusCodes.UNAUTHORIZED);
@@ -356,7 +412,7 @@ describe('Create Benchmark API (POST /v1/benchmarks/:provider)', () => {
     const response = await postCreate({
       provider: BenchmarkProviders.AWS,
       token,
-      body: validCreateBody,
+      body: validAwsCreateBody,
     });
 
     expect(response?.statusCode).toBe(StatusCodes.PAYMENT_REQUIRED);
@@ -371,7 +427,7 @@ describe('Create Benchmark API (POST /v1/benchmarks/:provider)', () => {
     const response = await postCreate({
       provider: 'invalidprovider',
       token,
-      body: validCreateBody,
+      body: validAwsCreateBody,
     });
 
     expect(response?.statusCode).toBe(StatusCodes.BAD_REQUEST);
@@ -546,20 +602,23 @@ describe('List benchmarks API', () => {
       });
     });
 
-    it('passes provider filter to listBenchmarks', async () => {
-      const { token, project } = await createAndInsertMocks();
-
-      const response = await getBenchmarkList({
-        token,
-        provider: BenchmarkProviders.AWS,
-      });
-
-      expect(response?.statusCode).toBe(StatusCodes.OK);
-      expect(benchmarkStatusServiceMock.listBenchmarks).toHaveBeenCalledWith({
-        projectId: project.id,
-        provider: BenchmarkProviders.AWS,
-      });
-    });
+    it.each(allBenchmarkProviders)(
+      'passes provider filter to listBenchmarks (%s)',
+      async (provider) => {
+        const { token, project } = await createAndInsertMocks();
+
+        const response = await getBenchmarkList({
+          token,
+          provider,
+        });
+
+        expect(response?.statusCode).toBe(StatusCodes.OK);
+        expect(benchmarkStatusServiceMock.listBenchmarks).toHaveBeenCalledWith({
+          projectId: project.id,
+          provider,
+        });
+      },
+    );
 
     it('returns 400 when provider is not a valid BenchmarkProviders value', async () => {
       const { token } = await createAndInsertMocks();