Update tests for feature resolution

Author: markcowl

packages/typespec-azure-resource-manager/src/resource.ts

@@ -1294,7 +1294,7 @@ export function resolveResourceBaseType(type?: string | undefined): ResourceBase
 
 export const [getResourceFeature, setResourceFeature] = useStateMap<
   Model | Interface | Namespace,
-  string
+  EnumMember
 >(ArmStateKeys.armFeature);
 
 export const [getResourceFeatureSet, setResourceFeatureSet] = useStateMap<
@@ -1307,6 +1307,11 @@ export const [getResourceFeatureOptions, setResourceFeatureOptions] = useStateMa
   ArmFeatureOptions
 >(ArmStateKeys.armFeatureOptions);
 
+const commonFeatureOptions: ArmFeatureOptions = {
+  featureName: "Common",
+  fileName: "common",
+  description: "",
+};
 export function getFeatureOptions(program: Program, feature: EnumMember): ArmFeatureOptions {
   const defaultFeatureName: string = (feature.value ?? feature.name) as string;
   const defaultOptions: ArmFeatureOptions = {
@@ -1317,14 +1322,74 @@ export function getFeatureOptions(program: Program, feature: EnumMember): ArmFea
   return program.stateMap(ArmStateKeys.armFeatureOptions).get(feature) ?? defaultOptions;
 }
 
+/**
+ * Get the FeatureOptions for a given type, these could be inherited from the namespace or parent type
+ * @param program - The program to process.
+ * @param entity - The type entity to get feature options for.
+ * @returns The ArmFeatureOptions if found, otherwise undefined.
+ */
+export function getFeature(program: Program, entity: Type): ArmFeatureOptions {
+  switch (entity.kind) {
+    case "Namespace": {
+      const feature = getResourceFeature(program, entity);
+      if (feature === undefined) return commonFeatureOptions;
+      const options = getFeatureOptions(program, feature);
+      return options;
+    }
+    case "Interface":
+    case "Model": {
+      let feature = getResourceFeature(program, entity);
+      if (feature !== undefined) return getFeatureOptions(program, feature);
+      const namespace = entity.namespace;
+      if (namespace === undefined) return commonFeatureOptions;
+      feature = getResourceFeature(program, namespace);
+      if (feature === undefined) return commonFeatureOptions;
+      return getFeatureOptions(program, feature);
+    }
+    case "Operation": {
+      const opInterface = entity.interface;
+      if (opInterface !== undefined) {
+        return getFeature(program, opInterface);
+      }
+      const namespace = entity.namespace;
+      if (namespace === undefined) return commonFeatureOptions;
+      const feature = getResourceFeature(program, namespace);
+      if (feature === undefined) return commonFeatureOptions;
+      return getFeatureOptions(program, feature);
+    }
+    case "EnumMember": {
+      return getFeature(program, entity.enum);
+    }
+    case "UnionVariant": {
+      return getFeature(program, entity.union);
+    }
+    case "ModelProperty": {
+      if (entity.model === undefined) return commonFeatureOptions;
+      return getFeature(program, entity.model);
+    }
+    case "Enum":
+    case "Union":
+    case "Scalar": {
+      const namespace = entity.namespace;
+      if (namespace === undefined) return commonFeatureOptions;
+      const feature = getResourceFeature(program, namespace);
+      if (feature === undefined) return commonFeatureOptions;
+      return getFeatureOptions(program, feature);
+    }
+
+    default:
+      return commonFeatureOptions;
+  }
+}
+
 export const $feature: FeatureDecorator = (
   context: DecoratorContext,
   entity: Model | Interface | Namespace,
   featureName: EnumMember,
 ) => {
   const { program } = context;
   const options = getFeatureOptions(program, featureName);
-  setResourceFeature(program, entity, options.featureName);
+  setResourceFeature(program, entity, featureName);
 };
 
 export const $features: FeaturesDecorator = (

packages/typespec-azure-resource-manager/test/resource.test.ts

@@ -7,6 +7,7 @@ import { ArmLifecycleOperationKind } from "../src/operations.js";
 import {
   ArmResourceDetails,
   getArmResources,
+  getFeature,
   getResourceFeature,
   getResourceFeatureSet,
 } from "../src/resource.js";
@@ -517,9 +518,9 @@ enum Features {
       });
 
       const fooFeature = getResourceFeature(result.program, result.FooResource);
-      expect(fooFeature).toMatch("FeatureA");
+      expect(fooFeature?.name).toMatch("FeatureA");
       const barFeature = getResourceFeature(result.program, result.BarResource);
-      expect(barFeature).toMatch("FeatureB");
+      expect(barFeature?.name).toMatch("FeatureB");
     });
     it("allows customizing features and feature options", async () => {
       const [result, diagnostics] = await Tester.compileAndDiagnose(t.code`
@@ -575,9 +576,118 @@ enum Features {
       });
 
       const fooFeature = getResourceFeature(result.program, result.FooResource);
-      expect(fooFeature).toMatch("FeatureA");
+      expect(fooFeature?.name).toMatch("FeatureA");
       const barFeature = getResourceFeature(result.program, result.BarResource);
-      expect(barFeature).toMatch("FeatureB");
+      expect(barFeature?.name).toMatch("FeatureB");
+    });
+    it("reports correct features for child types", async () => {
+      const [result, diagnostics] = await Tester.compileAndDiagnose(t.code`
+
+@Azure.ResourceManager.Legacy.features(Features)
+@versioned(Versions)
+@armProviderNamespace("Microsoft.Test")
+namespace ${t.namespace("MSTest")};
+/** Contoso API versions */
+enum Versions {
+  /** 2021-10-01-preview version */
+  v2025_11_19_preview: "2025-11-19-preview",
+}
+enum Features {
+  /** Feature A */
+  @Azure.ResourceManager.Legacy.featureOptions(#{featureName: "FeatureA", fileName: "feature-a", description: "The data for feature A"})
+  FeatureA: "Feature A",
+  /** Feature B */
+  @Azure.ResourceManager.Legacy.featureOptions(#{featureName: "FeatureB", fileName: "feature-b", description: "The data for feature B"})
+  FeatureB: "Feature B",
+}
+      @secret
+      scalar secretString extends string;
+
+      @Azure.ResourceManager.Legacy.feature(Features.FeatureA)
+      model ${t.model("FooResource")} is TrackedResource<FooResourceProperties> {
+         ...ResourceNameParameter<FooResource>;
+      }
+      
+      @Azure.ResourceManager.Legacy.feature(Features.FeatureA)
+      model ${t.model("FooResourceProperties")} { 
+        ...DefaultProvisioningStateProperty;
+        password: secretString;
+      }
+
+      @Azure.ResourceManager.Legacy.feature(Features.FeatureB)
+      model ${t.model("BarResource")} is ProxyResource<BarResourceProperties> {
+          ...ResourceNameParameter<BarResource>;
+      }
+      model ${t.model("BarResourceProperties")} { 
+        ...DefaultProvisioningStateProperty;
+        password: secretString;
+      }
+
+      @Azure.ResourceManager.Legacy.feature(Features.FeatureA)
+      @armResourceOperations
+      interface ${t.interface("Foos")} extends Azure.ResourceManager.TrackedResourceOperations<FooResource, FooResourceProperties> {}
+
+      @Azure.ResourceManager.Legacy.feature(Features.FeatureB)
+      @armResourceOperations
+      interface ${t.interface("Bars")} extends Azure.ResourceManager.TrackedResourceOperations<BarResource, BarResourceProperties> {}
+      `);
+      const featureAObject = {
+        featureName: "FeatureA",
+        fileName: "feature-a",
+        description: "The data for feature A",
+      };
+      const featureBObject = {
+        featureName: "FeatureB",
+        fileName: "feature-b",
+        description: "The data for feature B",
+      };
+
+      const defaultObject = {
+        featureName: "Common",
+        fileName: "common",
+        description: "",
+      };
+      expectDiagnosticEmpty(diagnostics);
+      const features = getResourceFeatureSet(result.program, result.MSTest);
+      expect(features).toBeDefined();
+      ok(features);
+      const keys = Array.from(features.keys());
+      expect(keys).toEqual(["FeatureA", "FeatureB"]);
+      expect(features?.get("FeatureA")).toEqual(featureAObject);
+      expect(features?.get("FeatureB")).toEqual(featureBObject);
+
+      const fooFeature = getFeature(result.program, result.FooResource);
+      expect(fooFeature).toMatchObject(featureAObject);
+      const fooPropertiesFeature = getFeature(result.program, result.FooResourceProperties);
+      expect(fooPropertiesFeature).toMatchObject(featureAObject);
+      const fooPasswordProperty = result.FooResourceProperties.properties.get("password");
+      expect(fooPasswordProperty).toBeDefined();
+      const fooPasswordFeature = getFeature(result.program, fooPasswordProperty!);
+      expect(fooPasswordFeature).toMatchObject(featureAObject);
+      const fooPasswordTypeFeature = getFeature(result.program, fooPasswordProperty!.type);
+      expect(fooPasswordTypeFeature).toMatchObject(defaultObject);
+      const foosFeature = getFeature(result.program, result.Foos);
+      expect(foosFeature).toMatchObject(featureAObject);
+      for (const op of [...result.Foos.operations.values()]) {
+        const opFeature = getFeature(result.program, op);
+        expect(opFeature).toMatchObject(featureAObject);
+      }
+      const barFeature = getFeature(result.program, result.BarResource);
+      expect(barFeature).toMatchObject(featureBObject);
+      const barPropertiesFeature = getFeature(result.program, result.BarResourceProperties);
+      expect(barPropertiesFeature).toMatchObject(defaultObject);
+      const barPasswordProperty = result.BarResourceProperties.properties.get("password");
+      expect(barPasswordProperty).toBeDefined();
+      const barPasswordFeature = getFeature(result.program, barPasswordProperty!);
+      expect(barPasswordFeature).toMatchObject(defaultObject);
+      const barPasswordTypeFeature = getFeature(result.program, barPasswordProperty!.type);
+      expect(barPasswordTypeFeature).toMatchObject(defaultObject);
+      const barsFeature = getFeature(result.program, result.Bars);
+      expect(barsFeature).toMatchObject(featureBObject);
+      for (const op of [...result.Bars.operations.values()]) {
+        const opFeature = getFeature(result.program, op);
+        expect(opFeature).toMatchObject(featureBObject);
+      }
     });
   });
   describe("network security perimeter", () => {