refactor: 프론트엔드 리펙토링

tests/unit/product-features.test.ts

@@ -16,7 +16,7 @@ import {
 } from "../../src/features/installed-feature-contracts.ts";
 
 const COMPILED = Object.freeze([
-  Object.freeze({ featureId: "reference-feature" }),
+  Object.freeze({ featureId: "alpha-feature" }),
   Object.freeze({ featureId: "billing" }),
 ]);
 
@@ -26,7 +26,7 @@ describe("build-time product selection", () => {
       expect(
         selectCompiledProductFeatures(COMPILED, declared).map((f) => f.featureId),
         String(declared),
-      ).toEqual(["reference-feature", "billing"]);
+      ).toEqual(["alpha-feature", "billing"]);
     }
   });
 
@@ -35,10 +35,10 @@ describe("build-time product selection", () => {
       selectCompiledProductFeatures(COMPILED, "billing").map((f) => f.featureId),
     ).toEqual(["billing"]);
     expect(
-      selectCompiledProductFeatures(COMPILED, " billing , reference-feature ").map(
+      selectCompiledProductFeatures(COMPILED, " billing , alpha-feature ").map(
         (f) => f.featureId,
       ),
-    ).toEqual(["reference-feature", "billing"]);
+    ).toEqual(["alpha-feature", "billing"]);
   });
 
   it("selects nothing only when asked explicitly", () => {
@@ -79,13 +79,13 @@ describe("build-time product selection", () => {
 describe("runtime product feature resolution", () => {
   it("reports active, disabled and not-installed distinctly", () => {
     const statuses = resolveProductFeatures(
-      ["reference-feature", "billing"],
-      ["reference-feature"],
-      { "reference-feature": "DISABLED" },
+      ["alpha-feature", "billing"],
+      ["alpha-feature"],
+      { "alpha-feature": "DISABLED" },
     );
     expect(statuses).toEqual([
+      { featureId: "alpha-feature", state: "DISABLED_BY_CONFIG" },
       { featureId: "billing", state: "NOT_INSTALLED" },
-      { featureId: "reference-feature", state: "DISABLED_BY_CONFIG" },
     ]);
     expect(activeProductFeatureIds(statuses)).toEqual([]);
   });
@@ -103,11 +103,11 @@ describe("runtime product feature resolution", () => {
     // A shared runtime document may cover several builds, so a stale key is
     // inert rather than fatal.
     const statuses = resolveProductFeatures(
-      ["reference-feature"],
-      ["reference-feature"],
+      ["alpha-feature"],
+      ["alpha-feature"],
       { analytics: "DISABLED" },
     );
-    expect(activeProductFeatureIds(statuses)).toEqual(["reference-feature"]);
+    expect(activeProductFeatureIds(statuses)).toEqual(["alpha-feature"]);
   });
 
   it("leaves an installed feature active without an override", () => {
@@ -140,15 +140,15 @@ describe("runtime config carries the switch", () => {
     expect(
       runtimeConfigV2ArtifactSchema.parse({
         ...base,
-        FEATURE_OVERRIDES: { "reference-feature": "DISABLED" },
+        FEATURE_OVERRIDES: { "alpha-feature": "DISABLED" },
       }).FEATURE_OVERRIDES,
-    ).toEqual({ "reference-feature": "DISABLED" });
+    ).toEqual({ "alpha-feature": "DISABLED" });
     // There is no "ENABLED": the vocabulary itself is what makes the rule
     // unbreakable, not a check somewhere downstream.
     expect(
       runtimeConfigV2ArtifactSchema.safeParse({
         ...base,
-        FEATURE_OVERRIDES: { "reference-feature": "ENABLED" },
+        FEATURE_OVERRIDES: { "alpha-feature": "ENABLED" },
       }).success,
     ).toBe(false);
   });
@@ -212,11 +212,13 @@ describe("route ownership", () => {
     }
   });
 
-  it("owns exactly the routes the registry received from features", () => {
+  it("owns exactly routes that exist in the composed registry", () => {
     const owned = Object.keys(ROUTE_FEATURE_OWNER);
-    expect(owned.length).toBeGreaterThan(0);
     for (const routeId of owned) {
       expect(Object.keys(ROUTE_REGISTRY), routeId).toContain(routeId);
     }
+    expect(
+      owned.every((routeId) => ROUTE_FEATURE_OWNER[routeId] !== undefined),
+    ).toBe(true);
   });
 });