Register Azure benchmark provider (#2167)

ravikiranvm · web-flow · commit 049b37abe802 · 2026-03-25T14:26:14.000+05:30
Fixes OPS-3950 ## Additional Notes - Registers `Azure` provider - Extend `getBenchmarkFolderDisplayName` to Azure - Adds Azure related flows to `PROVIDER_LIFECYCLE_WORKFLOWS` - Modify integration tests to cover all registered providers
diff --git a/packages/server/api/src/app/benchmark/catalog-manifests.ts b/packages/server/api/src/app/benchmark/catalog-manifests.ts
@@ -8,4 +8,8 @@ export const PROVIDER_LIFECYCLE_WORKFLOWS: Record<string, LifecycleWorkflow> = {
     orchestratorWorkflowId: 'Run AWS Benchmark - orchestrator',
     cleanupWorkflowId: 'Clean-up AWS Benchmark data',
   },
+  azure: {
+    orchestratorWorkflowId: 'Run Azure Benchmark - orchestrator',
+    cleanupWorkflowId: 'Clean-up Azure Benchmark data',
+  },
 };
diff --git a/packages/server/api/src/app/benchmark/create-benchmark.service.ts b/packages/server/api/src/app/benchmark/create-benchmark.service.ts
@@ -73,6 +73,8 @@ function getBenchmarkFolderDisplayName(provider: string): string {
   switch (provider) {
     case BenchmarkProviders.AWS:
       return 'AWS Benchmark';
+    case BenchmarkProviders.AZURE:
+      return 'Azure Benchmark';
     default:
       throwValidationError(`Unknown provider: ${provider}`);
   }
diff --git a/packages/server/api/src/app/benchmark/register-providers.ts b/packages/server/api/src/app/benchmark/register-providers.ts
@@ -1,9 +1,11 @@
 import { BenchmarkProviders } from '@openops/shared';
 import { registerProvider } from './provider-adapter';
 import { awsProviderAdapter } from './providers/aws';
+import { azureProviderAdapter } from './providers/azure';
 
 function registerProviders(): void {
   registerProvider(BenchmarkProviders.AWS, awsProviderAdapter);
+  registerProvider(BenchmarkProviders.AZURE, azureProviderAdapter);
 }
 
 registerProviders();
diff --git a/packages/server/api/test/integration/ce/benchmark/benchmark-module.test.ts b/packages/server/api/test/integration/ce/benchmark/benchmark-module.test.ts
@@ -108,6 +108,8 @@ afterAll(async () => {
   process.env = originalEnv;
 });
 
+const allBenchmarkProviders = Object.values(BenchmarkProviders);
+
 describe('Benchmark wizard API', () => {
   const postWizard = async ({
     provider,
@@ -127,61 +129,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 +263,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 +315,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 +359,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 +410,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 +425,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 +600,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();
diff --git a/packages/server/api/test/unit/benchmark/create-benchmark.service.test.ts b/packages/server/api/test/unit/benchmark/create-benchmark.service.test.ts

Original file line number	Diff line number	Diff line change
`@@ -73,6 +73,8 @@ function getBenchmarkFolderDisplayName(provider: string): string {`
`73`	`73`	`switch (provider) {`
`74`	`74`	`case BenchmarkProviders.AWS:`
`75`	`75`	`return 'AWS Benchmark';`
	`76`	`+ case BenchmarkProviders.AZURE:`
	`77`	`+ return 'Azure Benchmark';`
`76`	`78`	`default:`
`77`	`79`	throwValidationError(`Unknown provider: ${provider}`);
`78`	`80`	`}`