Support provider specific benchmark webhook payloads (#2165)

Fixes OPS-3975.

## Additional Notes

Author: ravikiranvm

packages/server/api/src/app/benchmark/attach-benchmark-flows.service.ts

@@ -27,10 +27,11 @@ export type AttachFlowsToBenchmarkResponse = {
 };
 
 async function buildPayloadForWebhook(params: {
+  provider: BenchmarkProviders;
   benchmarkConfiguration: BenchmarkConfiguration;
   workflows: BenchmarkWorkflowBase[];
 }): Promise<BenchmarkWebhookPayload> {
-  const { benchmarkConfiguration, workflows } = params;
+  const { provider, benchmarkConfiguration, workflows } = params;
 
   if (workflows.length < 3) {
     throwValidationError(
@@ -46,13 +47,30 @@ async function buildPayloadForWebhook(params: {
     .filter((w) => w.isCleanup)
     .map((w) => w.flowId);
 
-  return {
+  const webhookPayloadCommon = {
     webhookBaseUrl,
     workflows: subWorkflowFlowIds,
     cleanupWorkflows: cleanupFlowIds,
-    accounts: benchmarkConfiguration.accounts ?? [],
-    regions: benchmarkConfiguration.regions,
+    regions: benchmarkConfiguration.regions ?? [],
   };
+
+  switch (provider) {
+    case BenchmarkProviders.AWS:
+      return {
+        ...webhookPayloadCommon,
+        accounts: benchmarkConfiguration.accounts ?? [],
+      };
+    case BenchmarkProviders.AZURE:
+      return {
+        ...webhookPayloadCommon,
+        subscriptions: benchmarkConfiguration.subscriptions ?? [],
+      };
+    default: {
+      throwValidationError(
+        `Unsupported benchmark provider for webhook payload: ${provider}`,
+      );
+    }
+  }
 }
 
 async function insertBenchmarkRecords(params: {
@@ -110,6 +128,7 @@ export async function attachFlowsToBenchmark(
   } = params;
 
   const payload = await buildPayloadForWebhook({
+    provider,
     benchmarkConfiguration,
     workflows,
   });

packages/server/api/test/unit/benchmark/attach-benchmark-flows.service.test.ts

@@ -143,10 +143,54 @@ describe('create-benchmark-flows.service', () => {
     expect(result.payload.webhookBaseUrl).toBe(defaultWebhookBaseUrl);
     expect(result.payload.workflows).toEqual(['flow-sub']);
     expect(result.payload.cleanupWorkflows).toEqual(['flow-cleanup']);
-    expect(result.payload.accounts).toEqual([]);
+    expect('accounts' in result.payload).toBe(true);
+    if ('accounts' in result.payload) {
+      expect(result.payload.accounts).toEqual([]);
+    }
     expect(result.payload.regions).toEqual(['us-east-1']);
   });
 
+  it('attachFlowsToBenchmark builds Azure payload with subscriptions from configuration', async () => {
+    mockBenchmarkRepoSave.mockImplementation((row: Record<string, unknown>) =>
+      Promise.resolve({
+        ...row,
+        created: new Date().toISOString(),
+        updated: new Date().toISOString(),
+      }),
+    );
+    mockBenchmarkFlowRepoSave.mockResolvedValue(undefined);
+
+    const azureRequest: AttachFlowsToBenchmarkRequest = {
+      ...attachFlowsToBenchmarkRequest,
+      provider: BenchmarkProviders.AZURE,
+      benchmarkConfiguration: {
+        connection: ['conn-1'],
+        workflows: ['w1'],
+        subscriptions: ['sub-a', 'sub-b'],
+        regions: ['eastus'],
+      },
+    };
+
+    const result = await attachFlowsToBenchmark(azureRequest);
+
+    expect('subscriptions' in result.payload).toBe(true);
+    if ('subscriptions' in result.payload) {
+      expect(result.payload.subscriptions).toEqual(['sub-a', 'sub-b']);
+    }
+    expect(result.payload.regions).toEqual(['eastus']);
+    expect(mockBenchmarkRepoSave).toHaveBeenCalledTimes(1);
+    const saved = mockBenchmarkRepoSave.mock.calls[0][0] as Record<
+      string,
+      unknown
+    >;
+    expect(saved.payload).toEqual(
+      expect.objectContaining({
+        subscriptions: ['sub-a', 'sub-b'],
+        regions: ['eastus'],
+      }),
+    );
+  });
+
   it('attachFlowsToBenchmark throws when workflows has fewer than 3 items', async () => {
     await expect(
       attachFlowsToBenchmark({

packages/server/api/test/unit/benchmark/providers/azure/azure-option-resolver.test.ts

@@ -143,7 +143,7 @@ describe('resolveOptions (Azure)', () => {
     ]);
   });
 
-  it('omits imageLogoUrl for getSubscriptionsList when getAuthProviderLogoUrl returns undefined', async () => {
+  it('omits imageLogoUrl for getSubscriptionsList when auth metadata has no logo', async () => {
     mockGetOneOrThrow.mockResolvedValue({
       authProviderKey: 'Azure',
       value: {

packages/shared/src/lib/benchmark/dto/create-benchmark-response.ts

@@ -9,14 +9,40 @@ export const BenchmarkWorkflowBase = Type.Object({
 
 export type BenchmarkWorkflowBase = Static<typeof BenchmarkWorkflowBase>;
 
-export const BenchmarkWebhookPayload = Type.Object({
+const BenchmarkWebhookPayloadBase = Type.Object({
   webhookBaseUrl: Type.String(),
   workflows: Type.Array(Type.String()),
   cleanupWorkflows: Type.Array(Type.String()),
-  accounts: Type.Array(Type.String()),
   regions: Type.Array(Type.String()),
 });
 
+export const AwsBenchmarkWebhookPayload = Type.Intersect([
+  BenchmarkWebhookPayloadBase,
+  Type.Object({
+    accounts: Type.Array(Type.String()),
+  }),
+]);
+
+export type AwsBenchmarkWebhookPayload = Static<
+  typeof AwsBenchmarkWebhookPayload
+>;
+
+export const AzureBenchmarkWebhookPayload = Type.Intersect([
+  BenchmarkWebhookPayloadBase,
+  Type.Object({
+    subscriptions: Type.Array(Type.String()),
+  }),
+]);
+
+export type AzureBenchmarkWebhookPayload = Static<
+  typeof AzureBenchmarkWebhookPayload
+>;
+
+export const BenchmarkWebhookPayload = Type.Union([
+  AwsBenchmarkWebhookPayload,
+  AzureBenchmarkWebhookPayload,
+]);
+
 export type BenchmarkWebhookPayload = Static<typeof BenchmarkWebhookPayload>;
 
 export const BenchmarkCreationResult = Type.Object({