updating comparison output. Normalizing rg name always.

Author: EMaher

src/cli/compare-command.ts

@@ -232,14 +232,9 @@ function outputTable(result: CompareResult): void {
 
   if (result.totalDifferences === 0) {
     console.log('✅ PASS — Instances are identical');
-    console.log(
-      `   ${result.totalTypes} resource types compared, ${result.totalResources} resources matched`,
-    );
   } else {
     console.log('❌ FAIL — Differences found');
-    console.log(
-      `   ${result.totalDifferences} difference(s) across ${result.totalTypes} resource types`,
-    );
+    console.log(`   ${result.totalDifferences} difference(s) found`);
     console.log('');
 
     // Group by resource type
@@ -336,13 +331,9 @@ async function runLocalCompare(
 
 function outputText(result: CompareResult): void {
   if (result.totalDifferences === 0) {
-    logger.info(
-      `✅ PASS — ${result.totalTypes} resource types compared, ${result.totalResources} resources matched`,
-    );
+    logger.info('✅ PASS — Instances are identical');
   } else {
-    logger.error(
-      `❌ FAIL — ${result.totalDifferences} difference(s) found across ${result.totalTypes} resource types`,
-    );
+    logger.error(`❌ FAIL — ${result.totalDifferences} difference(s) found`);
     for (const diff of result.differences) {
       if (diff.diffType === 'missing') {
         logger.error(

src/lib/compare-normalizer.ts

@@ -155,6 +155,13 @@ function normalizeString(value: string, context: NormalizeContext): string {
   s = s.replace(new RegExp(escapeRegex(sourceSub), 'g'), placeholderSub);
   s = s.replace(new RegExp(escapeRegex(targetSub), 'g'), placeholderSub);
 
+  // Normalize resource group segment for any ARM resource ID under normalized subscriptions.
+  // This avoids false diffs when equivalent dependent resources live in different RGs.
+  s = s.replace(
+    /\/subscriptions\/\{\{sub\}\}\/resourceGroups\/[^/]+(?=\/providers\/)/g,
+    '/subscriptions/{{sub}}/resourceGroups/{{rg}}',
+  );
+
   // Neutralize service name in any remaining positions
   s = s.replace(
     new RegExp(escapeRegex(context.sourceServiceName), 'g'),

src/services/compare-service.ts

@@ -27,15 +27,15 @@ import { LogLevel } from '../lib/logger.js';
 import { loadLocalArtifacts } from './local-artifact-loader.js';
 
 export interface CompareResult {
-  totalTypes: number;
-  totalResources: number;
   totalDifferences: number;
   differences: ComparisonDifference[];
 }
 
 export interface ComparisonDifference {
+  instance?: 'source' | 'target';
   resourceType: string;
   resourceName: string;
+  displayName?: string;
   diffType: 'missing' | 'extra' | 'property-diff';
   diffs?: ResourceDiff[];
 }
@@ -66,8 +66,6 @@ export async function compareApimInstances(
   };
 
   const differences: ComparisonDifference[] = [];
-  let totalTypes = 0;
-  let totalResources = 0;
 
   // Get clients from config
   const sourceClient: IApimClient = config.sourceClient;
@@ -113,8 +111,6 @@ export async function compareApimInstances(
       typeConfig.skipLoggerCreds ?? false,
     );
     differences.push(...typeDiffs);
-    totalTypes++;
-    totalResources += typeDiffs.length;
   }
 
   // Compare APIs
@@ -128,8 +124,6 @@ export async function compareApimInstances(
     EXCLUDE_APIS,
   );
   differences.push(...apiDiffs);
-  totalTypes++;
-  totalResources += apiDiffs.length;
 
   // Enumerate APIs for child resource comparison
   const sourceApis = await safeListResources(
@@ -170,8 +164,6 @@ export async function compareApimInstances(
         config.target,
       );
       differences.push(...childDiffs);
-      totalTypes++;
-      totalResources += childDiffs.length;
     }
 
     // API Operation Policies
@@ -195,8 +187,6 @@ export async function compareApimInstances(
         config.target,
       );
       differences.push(...opPolicyDiffs);
-      totalTypes++;
-      totalResources += opPolicyDiffs.length;
     }
 
     // API Resolver Policies
@@ -220,8 +210,6 @@ export async function compareApimInstances(
         config.target,
       );
       differences.push(...resolverPolicyDiffs);
-      totalTypes++;
-      totalResources += resolverPolicyDiffs.length;
     }
   }
 
@@ -259,8 +247,6 @@ export async function compareApimInstances(
         config.target,
       );
       differences.push(...childDiffs);
-      totalTypes++;
-      totalResources += childDiffs.length;
     }
   }
 
@@ -283,8 +269,6 @@ export async function compareApimInstances(
       config.target,
     );
     differences.push(...gatewayApiDiffs);
-    totalTypes++;
-    totalResources += gatewayApiDiffs.length;
   }
 
   // Note: Workspace comparison disabled - Workspace types not yet defined in ResourceType enum
@@ -326,8 +310,6 @@ export async function compareApimInstances(
         config.target,
       );
       differences.push(...childDiffs);
-      totalTypes++;
-      totalResources += childDiffs.length;
     }
   }
   */
@@ -337,8 +319,6 @@ export async function compareApimInstances(
   ).length;
 
   return {
-    totalTypes,
-    totalResources,
     totalDifferences,
     differences,
   };
@@ -657,21 +637,31 @@ function compareResourceLists(
   // Find missing resources (in source but not in target)
   for (const name of sourceMap.keys()) {
     if (!targetMap.has(name)) {
+      const sourceResource = sourceMap.get(name)!;
+      const displayName = getComparisonDisplayName(sourceResource);
+
       differences.push({
         resourceType: typeLabel,
         resourceName: name,
         diffType: 'missing',
+        ...(displayName === undefined ? {} : { displayName }),
+        instance: 'source',
       });
     }
   }
 
   // Find extra resources (in target but not in source)
   for (const name of targetMap.keys()) {
     if (!sourceMap.has(name)) {
+      const targetResource = targetMap.get(name)!;
+      const displayName = getComparisonDisplayName(targetResource);
+
       differences.push({
         resourceType: typeLabel,
         resourceName: name,
         diffType: 'extra',
+        ...(displayName === undefined ? {} : { displayName }),
+        instance: 'target',
       });
     }
   }
@@ -682,6 +672,9 @@ function compareResourceLists(
 
     const sourceResource = sourceMap.get(name)!;
     const targetResource = targetMap.get(name)!;
+    const displayName =
+      getComparisonDisplayName(sourceResource) ??
+      getComparisonDisplayName(targetResource);
 
     const sourceNorm = normalizeResource(sourceResource, normalizeContext);
     const targetNorm = normalizeResource(targetResource, normalizeContext);
@@ -728,6 +721,7 @@ function compareResourceLists(
         resourceType: typeLabel,
         resourceName: name,
         diffType: 'property-diff',
+        ...(displayName === undefined ? {} : { displayName }),
         diffs,
       });
     }
@@ -736,6 +730,25 @@ function compareResourceLists(
   return differences;
 }
 
+function getComparisonDisplayName(
+  resource: Record<string, unknown>,
+): string | undefined {
+  const properties = resource.properties;
+  if (typeof properties === 'object' && properties !== null) {
+    const displayName = (properties as Record<string, unknown>).displayName;
+    if (typeof displayName === 'string' && displayName.length > 0) {
+      return displayName;
+    }
+  }
+
+  const displayName = resource.displayName;
+  if (typeof displayName === 'string' && displayName.length > 0) {
+    return displayName;
+  }
+
+  return undefined;
+}
+
 /**
  * Builds a resource map keyed by name, handling auto-generated IDs
  */
@@ -844,8 +857,6 @@ export async function compareLocalArtifacts(
   };
 
   const differences: ComparisonDifference[] = [];
-  let totalTypes = 0;
-  let totalResources = 0;
 
   // Get all unique resource types from both sources
   const allTypes = new Set<string>();
@@ -872,17 +883,13 @@ export async function compareLocalArtifacts(
     );
 
     differences.push(...typeDiffs);
-    totalTypes++;
-    totalResources += Math.max(sourceResources.length, targetResources.length);
   }
 
   const totalDifferences = differences.filter(
     (d) => d.diffType !== 'property-diff' || (d.diffs && d.diffs.length > 0),
   ).length;
 
   return {
-    totalTypes,
-    totalResources,
     totalDifferences,
     differences,
   };

tests/unit/lib/compare-normalizer.test.ts

@@ -0,0 +1,82 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import { describe, it, expect } from 'vitest';
+import { normalizeResource, type NormalizeContext } from '../../../src/lib/compare-normalizer.js';
+
+const context: NormalizeContext = {
+  sourceServiceName: 'src-apim',
+  targetServiceName: 'tgt-apim',
+  sourceSubscriptionId: '00000000-0000-0000-0000-000000000001',
+  targetSubscriptionId: '00000000-0000-0000-0000-000000000001',
+  sourceResourceGroup: 'src-apim-rg',
+  targetResourceGroup: 'tgt-apim-rg',
+};
+
+describe('compare-normalizer', () => {
+  it('normalizes backend function resourceId when only resource group differs', () => {
+    const source = {
+      properties: {
+        resourceId:
+          '/subscriptions/00000000-0000-0000-0000-000000000001/resourceGroups/src-function-rg/providers/Microsoft.Web/sites/src-backend-function',
+      },
+    };
+    const target = {
+      properties: {
+        resourceId:
+          '/subscriptions/00000000-0000-0000-0000-000000000001/resourceGroups/tgt-function-rg/providers/Microsoft.Web/sites/src-backend-function',
+      },
+    };
+
+    const sourceNorm = normalizeResource(source, context);
+    const targetNorm = normalizeResource(target, context);
+
+    expect(sourceNorm).toEqual(targetNorm);
+    expect((sourceNorm.properties as Record<string, unknown>).resourceId).toBe(
+      '/subscriptions/{{sub}}/resourceGroups/{{rg}}/providers/Microsoft.Web/sites/src-backend-function',
+    );
+  });
+
+  it('normalizes backend logic app resourceId when only resource group differs', () => {
+    const source = {
+      properties: {
+        resourceId:
+          '/subscriptions/00000000-0000-0000-0000-000000000001/resourceGroups/src-logicapp-rg/providers/Microsoft.Logic/workflows/src-backend-logicapp',
+      },
+    };
+    const target = {
+      properties: {
+        resourceId:
+          '/subscriptions/00000000-0000-0000-0000-000000000001/resourceGroups/tgt-logicapp-rg/providers/Microsoft.Logic/workflows/src-backend-logicapp',
+      },
+    };
+
+    const sourceNorm = normalizeResource(source, context);
+    const targetNorm = normalizeResource(target, context);
+
+    expect(sourceNorm).toEqual(targetNorm);
+    expect((sourceNorm.properties as Record<string, unknown>).resourceId).toBe(
+      '/subscriptions/{{sub}}/resourceGroups/{{rg}}/providers/Microsoft.Logic/workflows/src-backend-logicapp',
+    );
+  });
+
+  it('keeps meaningful provider or resource-name differences', () => {
+    const source = {
+      properties: {
+        resourceId:
+          '/subscriptions/00000000-0000-0000-0000-000000000001/resourceGroups/src-function-rg/providers/Microsoft.Web/sites/src-backend-function',
+      },
+    };
+    const target = {
+      properties: {
+        resourceId:
+          '/subscriptions/00000000-0000-0000-0000-000000000001/resourceGroups/tgt-function-rg/providers/Microsoft.Logic/workflows/src-backend-function',
+      },
+    };
+
+    const sourceNorm = normalizeResource(source, context);
+    const targetNorm = normalizeResource(target, context);
+
+    expect(sourceNorm).not.toEqual(targetNorm);
+  });
+});