feat(ui): preserve platform setup canonical routes

2026-03-08 11:12:42 +02:00
parent d0f2cc3b2c
commit 6870649abf
19 changed files with 478 additions and 42 deletions
--- a/src/Web/StellaOps.Web/src/app/features/platform/setup/platform-setup-defaults-guardrails-page.component.ts
+++ b/src/Web/StellaOps.Web/src/app/features/platform/setup/platform-setup-defaults-guardrails-page.component.ts
@@ -54,8 +54,8 @@ interface GuardrailRow {
      </article>

      <footer class="links">
-        <a routerLink="/platform/setup/gate-profiles">Open Gate Profiles</a>
-        <a routerLink="/platform/setup/feed-policy">Open Feed Policy</a>
+        <a routerLink="/ops/platform-setup/gate-profiles">Open Gate Profiles</a>
+        <a routerLink="/ops/platform-setup/policy-bindings">Open Feed Policy</a>
        <a routerLink="/platform/ops/data-integrity">Open Data Integrity</a>
      </footer>
    </section>
--- a/src/Web/StellaOps.Web/src/app/features/platform/setup/platform-setup-gate-profiles-page.component.ts
+++ b/src/Web/StellaOps.Web/src/app/features/platform/setup/platform-setup-gate-profiles-page.component.ts
@@ -57,8 +57,8 @@ interface GateProfileRow {
      </article>

      <footer class="links">
-        <a routerLink="/platform/setup/workflows-gates">Open Workflows & Gates</a>
-        <a routerLink="/platform/setup/defaults-guardrails">Open Defaults & Guardrails</a>
+        <a routerLink="/ops/platform-setup/workflows-gates">Open Workflows & Gates</a>
+        <a routerLink="/ops/platform-setup/defaults-guardrails">Open Defaults & Guardrails</a>
        <a routerLink="/security/overview">Open Security Baseline</a>
      </footer>
    </section>
--- a/src/Web/StellaOps.Web/src/app/features/platform/setup/platform-setup-home.component.ts
+++ b/src/Web/StellaOps.Web/src/app/features/platform/setup/platform-setup-home.component.ts
@@ -370,10 +370,10 @@ export class PlatformSetupHomeComponent implements AfterViewInit, OnDestroy {
  private allLinks: TopoLink[] = [];

  readonly quickLinks = [
-    { title: 'Regions & Environments', description: 'Region-first setup and risk tiers.', route: '/setup/topology/regions' },
-    { title: 'Promotion Paths', description: 'Promotion flow graph and rules.', route: '/setup/topology/promotion-graph' },
-    { title: 'Workflows & Gates', description: 'Workflow inventory and gate bindings.', route: '/setup/topology/workflows' },
-    { title: 'Gate Profiles', description: 'Strict, risk-aware, and expedited lanes.', route: '/setup/topology/gate-profiles' },
+    { title: 'Regions & Environments', description: 'Region-first setup and risk tiers.', route: '/ops/platform-setup/regions-environments' },
+    { title: 'Promotion Paths', description: 'Promotion flow graph and rules.', route: '/ops/platform-setup/promotion-paths' },
+    { title: 'Workflows & Gates', description: 'Workflow inventory and gate bindings.', route: '/ops/platform-setup/workflows-gates' },
+    { title: 'Gate Profiles', description: 'Strict, risk-aware, and expedited lanes.', route: '/ops/platform-setup/gate-profiles' },
    { title: 'Release Templates', description: 'Release template and evidence defaults.', route: '/ops/platform-setup/release-templates' },
    { title: 'Policy Bindings', description: 'Freshness thresholds and feed-policy bindings.', route: '/ops/platform-setup/policy-bindings' },
    { title: 'Defaults & Guardrails', description: 'Policy impact labels and degraded-mode.', route: '/ops/platform-setup/defaults-guardrails' },
@@ -795,7 +795,7 @@ export class PlatformSetupHomeComponent implements AfterViewInit, OnDestroy {
      case 'tenant':
        break; // Already on this page
      case 'region':
-        void this.router.navigate(['/setup/topology/regions']);
+        void this.router.navigate(['/ops/platform-setup/regions-environments']);
        break;
      case 'environment':
        if (node.environmentId) {
--- a/src/Web/StellaOps.Web/src/app/features/platform/setup/platform-setup-promotion-paths-page.component.ts
+++ b/src/Web/StellaOps.Web/src/app/features/platform/setup/platform-setup-promotion-paths-page.component.ts
@@ -54,7 +54,7 @@ interface PromotionRule {

      <footer class="links">
        <a routerLink="/releases/runs">Open Release Runs</a>
-        <a routerLink="/topology/promotion-paths">Open Topology Path View</a>
+        <a routerLink="/setup/topology/promotion-graph">Open Topology Path View</a>
      </footer>
    </section>
  `,
--- a/src/Web/StellaOps.Web/src/app/features/platform/setup/platform-setup-regions-environments-page.component.ts
+++ b/src/Web/StellaOps.Web/src/app/features/platform/setup/platform-setup-regions-environments-page.component.ts
@@ -79,7 +79,7 @@ interface RegionRow {
      </article>

      <footer class="links">
-        <a routerLink="/topology/environments">Open Topology Environment Posture</a>
+        <a routerLink="/setup/topology/environments">Open Topology Environment Posture</a>
        <a routerLink="/security/overview">Open Security Policy Baseline</a>
      </footer>
    </section>
--- a/src/Web/StellaOps.Web/src/app/features/platform/setup/platform-setup-workflows-gates-page.component.ts
+++ b/src/Web/StellaOps.Web/src/app/features/platform/setup/platform-setup-workflows-gates-page.component.ts
@@ -57,7 +57,7 @@ interface WorkflowRow {

      <footer class="links">
        <a routerLink="/security/overview">Open Security Policy Baseline</a>
-        <a routerLink="/topology/workflows">Open Topology Workflow Inventory</a>
+        <a routerLink="/setup/topology/workflows">Open Topology Workflow Inventory</a>
      </footer>
    </section>
  `,
--- a/src/Web/StellaOps.Web/src/app/features/platform/setup/platform-setup.routes.ts
+++ b/src/Web/StellaOps.Web/src/app/features/platform/setup/platform-setup.routes.ts
@@ -12,22 +12,28 @@ export const PLATFORM_SETUP_ROUTES: Routes = [
    path: 'regions-environments',
    title: 'Setup Regions & Environments',
    data: { breadcrumb: 'Regions & Environments' },
-    redirectTo: '/setup/topology/regions',
-    pathMatch: 'full',
+    loadComponent: () =>
+      import('./platform-setup-regions-environments-page.component').then(
+        (m) => m.PlatformSetupRegionsEnvironmentsPageComponent,
+      ),
  },
  {
    path: 'promotion-paths',
    title: 'Setup Promotion Paths',
    data: { breadcrumb: 'Promotion Paths' },
-    redirectTo: '/setup/topology/promotion-graph',
-    pathMatch: 'full',
+    loadComponent: () =>
+      import('./platform-setup-promotion-paths-page.component').then(
+        (m) => m.PlatformSetupPromotionPathsPageComponent,
+      ),
  },
  {
    path: 'workflows-gates',
    title: 'Setup Workflows & Gates',
    data: { breadcrumb: 'Workflows & Gates' },
-    redirectTo: '/setup/topology/workflows',
-    pathMatch: 'full',
+    loadComponent: () =>
+      import('./platform-setup-workflows-gates-page.component').then(
+        (m) => m.PlatformSetupWorkflowsGatesPageComponent,
+      ),
  },
  {
    path: 'release-templates',
@@ -51,8 +57,10 @@ export const PLATFORM_SETUP_ROUTES: Routes = [
    path: 'gate-profiles',
    title: 'Gate Profiles',
    data: { breadcrumb: 'Gate Profiles' },
-    redirectTo: '/setup/topology/gate-profiles',
-    pathMatch: 'full',
+    loadComponent: () =>
+      import('./platform-setup-gate-profiles-page.component').then(
+        (m) => m.PlatformSetupGateProfilesPageComponent,
+      ),
  },
  {
    path: 'defaults-guardrails',
--- a/src/Web/StellaOps.Web/src/tests/platform/platform-setup-canonical-links.spec.ts
+++ b/src/Web/StellaOps.Web/src/tests/platform/platform-setup-canonical-links.spec.ts
@@ -0,0 +1,102 @@
+import { signal, Type } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { provideRouter, Router } from '@angular/router';
+import { of } from 'rxjs';
+
+import { ConsoleSessionStore } from '../../app/core/console/console-session.store';
+import { PlatformContextStore } from '../../app/core/context/platform-context.store';
+import { PlatformSetupDefaultsGuardrailsPageComponent } from '../../app/features/platform/setup/platform-setup-defaults-guardrails-page.component';
+import { PlatformSetupGateProfilesPageComponent } from '../../app/features/platform/setup/platform-setup-gate-profiles-page.component';
+import { PlatformSetupHomeComponent } from '../../app/features/platform/setup/platform-setup-home.component';
+import { PlatformSetupPromotionPathsPageComponent } from '../../app/features/platform/setup/platform-setup-promotion-paths-page.component';
+import { PlatformSetupRegionsEnvironmentsPageComponent } from '../../app/features/platform/setup/platform-setup-regions-environments-page.component';
+import { PlatformSetupWorkflowsGatesPageComponent } from '../../app/features/platform/setup/platform-setup-workflows-gates-page.component';
+import { TopologyDataService } from '../../app/features/topology/topology-data.service';
+
+describe('platform setup canonical links', () => {
+  it('keeps home quick links on canonical ops/platform-setup leaves', async () => {
+    const topologyApi = {
+      list: jasmine.createSpy('list').and.returnValue(of([])),
+    };
+
+    await TestBed.configureTestingModule({
+      imports: [PlatformSetupHomeComponent],
+      providers: [
+        provideRouter([]),
+        {
+          provide: PlatformContextStore,
+          useValue: {
+            initialize: jasmine.createSpy('initialize'),
+            contextVersion: signal(0),
+          },
+        },
+        {
+          provide: ConsoleSessionStore,
+          useValue: {
+            currentTenant: () => ({ id: 'tenant-default', displayName: 'Default Tenant' }),
+          },
+        },
+        { provide: TopologyDataService, useValue: topologyApi },
+      ],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(PlatformSetupHomeComponent);
+    const component = fixture.componentInstance;
+    const router = TestBed.inject(Router);
+    spyOn(router, 'navigate').and.returnValue(Promise.resolve(true));
+
+    expect(component.quickLinks.slice(0, 4).map((link) => link.route)).toEqual([
+      '/ops/platform-setup/regions-environments',
+      '/ops/platform-setup/promotion-paths',
+      '/ops/platform-setup/workflows-gates',
+      '/ops/platform-setup/gate-profiles',
+    ]);
+
+    (component as unknown as { navigateToNode(node: { kind: string; id: string }): void }).navigateToNode({
+      kind: 'region',
+      id: 'region:eu-west',
+    });
+
+    expect(router.navigate).toHaveBeenCalledWith(['/ops/platform-setup/regions-environments']);
+  });
+
+  it('keeps page-local platform setup links inside the canonical ops subtree', async () => {
+    const gateProfilesFixture = await createFixture(PlatformSetupGateProfilesPageComponent);
+    const defaultsFixture = await createFixture(PlatformSetupDefaultsGuardrailsPageComponent);
+
+    expect(extractHrefs(gateProfilesFixture)).toContain('/ops/platform-setup/workflows-gates');
+    expect(extractHrefs(gateProfilesFixture)).toContain('/ops/platform-setup/defaults-guardrails');
+    expect(extractHrefs(defaultsFixture)).toContain('/ops/platform-setup/gate-profiles');
+    expect(extractHrefs(defaultsFixture)).toContain('/ops/platform-setup/policy-bindings');
+  });
+
+  it('uses valid mounted topology routes for explicit topology drill-ins', async () => {
+    const regionsFixture = await createFixture(PlatformSetupRegionsEnvironmentsPageComponent);
+    const promotionFixture = await createFixture(PlatformSetupPromotionPathsPageComponent);
+    const workflowsFixture = await createFixture(PlatformSetupWorkflowsGatesPageComponent);
+
+    expect(extractHrefs(regionsFixture)).toContain('/setup/topology/environments');
+    expect(extractHrefs(promotionFixture)).toContain('/setup/topology/promotion-graph');
+    expect(extractHrefs(workflowsFixture)).toContain('/setup/topology/workflows');
+  });
+});
+
+async function createFixture<T>(component: Type<T>): Promise<ComponentFixture<T>> {
+  TestBed.resetTestingModule();
+  await TestBed.configureTestingModule({
+    imports: [component],
+    providers: [provideRouter([])],
+  }).compileComponents();
+
+  const fixture = TestBed.createComponent(component);
+  fixture.detectChanges();
+  await fixture.whenStable();
+  fixture.detectChanges();
+  return fixture;
+}
+
+function extractHrefs(fixture: ComponentFixture<unknown>): string[] {
+  return Array.from(fixture.nativeElement.querySelectorAll('a') as NodeListOf<HTMLAnchorElement>)
+    .map((link) => link.getAttribute('href'))
+    .filter((href): href is string => typeof href === 'string');
+}
--- a/src/Web/StellaOps.Web/src/tests/platform/platform-setup-routes.spec.ts
+++ b/src/Web/StellaOps.Web/src/tests/platform/platform-setup-routes.spec.ts
@@ -15,22 +15,34 @@ describe('PLATFORM_SETUP_ROUTES (pre-alpha)', () => {
    expect(defaults?.loadComponent).toBeDefined();
  });

-  it('redirects absorbed topology and trust pages into canonical setup owners', () => {
+  it('keeps canonical platform-setup topology leaves mounted under ops/platform-setup', () => {
    const regions = PLATFORM_SETUP_ROUTES.find((item) => item.path === 'regions-environments');
    const promotion = PLATFORM_SETUP_ROUTES.find((item) => item.path === 'promotion-paths');
    const workflows = PLATFORM_SETUP_ROUTES.find((item) => item.path === 'workflows-gates');
    const gateProfiles = PLATFORM_SETUP_ROUTES.find((item) => item.path === 'gate-profiles');
+
+    expect(regions?.loadComponent).toBeDefined();
+    expect(promotion?.loadComponent).toBeDefined();
+    expect(workflows?.loadComponent).toBeDefined();
+    expect(gateProfiles?.loadComponent).toBeDefined();
+  });
+
+  it('keeps trust signing as a redirect into the canonical setup trust owner', () => {
    const trustSigning = PLATFORM_SETUP_ROUTES.find((item) => item.path === 'trust-signing');

-    expect(regions?.redirectTo).toBe('/setup/topology/regions');
-    expect(promotion?.redirectTo).toBe('/setup/topology/promotion-graph');
-    expect(workflows?.redirectTo).toBe('/setup/topology/workflows');
-    expect(gateProfiles?.redirectTo).toBe('/setup/topology/gate-profiles');
    expect(trustSigning?.redirectTo).toBe('/setup/trust-signing');
  });

  it('retains mounted routes for the remaining platform setup surfaces', () => {
-    const mountedPaths = ['policy-bindings', 'release-templates', 'defaults-guardrails'];
+    const mountedPaths = [
+      'regions-environments',
+      'promotion-paths',
+      'workflows-gates',
+      'gate-profiles',
+      'policy-bindings',
+      'release-templates',
+      'defaults-guardrails',
+    ];

    for (const path of mountedPaths) {
      const route = PLATFORM_SETUP_ROUTES.find((item) => item.path === path);
--- a/src/Web/StellaOps.Web/tests/e2e/platform-setup-canonical-route-preservation.spec.ts
+++ b/src/Web/StellaOps.Web/tests/e2e/platform-setup-canonical-route-preservation.spec.ts
@@ -0,0 +1,195 @@
+import { expect, test, type Page, type Route } from '@playwright/test';
+
+import type { StubAuthSession } from '../../src/app/testing/auth-fixtures';
+
+const operatorSession: StubAuthSession = {
+  subjectId: 'platform-setup-e2e-user',
+  tenant: 'tenant-default',
+  scopes: ['admin', 'ui.read', 'ui.admin', 'orch:read', 'orch:operate', 'release:read'],
+};
+
+const mockConfig = {
+  authority: {
+    issuer: '/authority',
+    clientId: 'stella-ops-ui',
+    authorizeEndpoint: '/authority/connect/authorize',
+    tokenEndpoint: '/authority/connect/token',
+    logoutEndpoint: '/authority/connect/logout',
+    redirectUri: 'https://127.0.0.1:4400/auth/callback',
+    postLogoutRedirectUri: 'https://127.0.0.1:4400/',
+    scope: 'openid profile email ui.read',
+    audience: '/gateway',
+    dpopAlgorithms: ['ES256'],
+    refreshLeewaySeconds: 60,
+  },
+  apiBaseUrls: {
+    authority: '/authority',
+    scanner: '/scanner',
+    policy: '/policy',
+    concelier: '/concelier',
+    attestor: '/attestor',
+    gateway: '/gateway',
+  },
+  quickstartMode: true,
+  setup: 'complete',
+};
+
+const topologyRegions = [{ regionId: 'eu-west', displayName: 'EU West', environmentCount: 1, targetCount: 2 }];
+const topologyEnvironments = [
+  {
+    environmentId: 'prod',
+    regionId: 'eu-west',
+    environmentType: 'prod',
+    displayName: 'Production',
+    targetCount: 2,
+  },
+];
+const topologyAgents = [
+  {
+    agentId: 'agent-001',
+    agentName: 'Agent One',
+    regionId: 'eu-west',
+    environmentId: 'prod',
+    status: 'active',
+    assignedTargetCount: 2,
+  },
+];
+const promotionPaths = [
+  {
+    pathId: 'path-001',
+    regionId: 'eu-west',
+    sourceEnvironmentId: 'stage',
+    targetEnvironmentId: 'prod',
+    status: 'running',
+    requiredApprovals: 1,
+  },
+];
+
+async function fulfillJson(route: Route, body: unknown, status = 200): Promise<void> {
+  await route.fulfill({
+    status,
+    contentType: 'application/json',
+    body: JSON.stringify(body),
+  });
+}
+
+async function setupHarness(page: Page): Promise<void> {
+  await page.addInitScript((session) => {
+    (window as { __stellaopsTestSession?: unknown }).__stellaopsTestSession = session;
+  }, operatorSession);
+
+  await page.route('**/api/**', (route) => fulfillJson(route, {}));
+  await page.route('**/platform/envsettings.json', (route) => fulfillJson(route, mockConfig));
+  await page.route('**/platform/i18n/*.json', (route) => fulfillJson(route, {}));
+  await page.route('**/config.json', (route) => fulfillJson(route, mockConfig));
+  await page.route('**/.well-known/openid-configuration', (route) =>
+    fulfillJson(route, {
+      issuer: 'https://127.0.0.1:4400/authority',
+      authorization_endpoint: 'https://127.0.0.1:4400/authority/connect/authorize',
+      token_endpoint: 'https://127.0.0.1:4400/authority/connect/token',
+      jwks_uri: 'https://127.0.0.1:4400/authority/.well-known/jwks.json',
+      response_types_supported: ['code'],
+      subject_types_supported: ['public'],
+      id_token_signing_alg_values_supported: ['RS256'],
+    }),
+  );
+  await page.route('**/authority/.well-known/jwks.json', (route) => fulfillJson(route, { keys: [] }));
+  await page.route('**/console/branding**', (route) =>
+    fulfillJson(route, {
+      tenantId: operatorSession.tenant,
+      appName: 'Stella Ops',
+      logoUrl: null,
+      cssVariables: {},
+    }),
+  );
+  await page.route('**/console/profile**', (route) =>
+    fulfillJson(route, {
+      subjectId: operatorSession.subjectId,
+      username: 'platform-setup-e2e',
+      displayName: 'Platform Setup E2E',
+      tenant: operatorSession.tenant,
+      roles: ['platform-admin'],
+      scopes: operatorSession.scopes,
+    }),
+  );
+  await page.route('**/console/token/introspect**', (route) =>
+    fulfillJson(route, {
+      active: true,
+      tenant: operatorSession.tenant,
+      subject: operatorSession.subjectId,
+      scopes: operatorSession.scopes,
+    }),
+  );
+  await page.route('**/authority/console/tenants**', (route) =>
+    fulfillJson(route, {
+      tenants: [
+        {
+          tenantId: operatorSession.tenant,
+          displayName: 'Default Tenant',
+          isDefault: true,
+          isActive: true,
+        },
+      ],
+    }),
+  );
+  await page.route('**/api/v2/context/regions**', (route) =>
+    fulfillJson(route, [{ regionId: 'eu-west', displayName: 'EU West', sortOrder: 1, enabled: true }]),
+  );
+  await page.route('**/api/v2/context/environments**', (route) =>
+    fulfillJson(route, [
+      {
+        environmentId: 'prod',
+        regionId: 'eu-west',
+        environmentType: 'prod',
+        displayName: 'Production',
+        sortOrder: 1,
+        enabled: true,
+      },
+    ]),
+  );
+  await page.route('**/api/v2/context/preferences**', (route) =>
+    fulfillJson(route, {
+      tenantId: operatorSession.tenant,
+      actorId: operatorSession.subjectId,
+      regions: ['eu-west'],
+      environments: ['prod'],
+      timeWindow: '24h',
+      stage: 'all',
+      updatedAt: '2026-03-08T07:00:00Z',
+      updatedBy: operatorSession.subjectId,
+    }),
+  );
+
+  await page.route(/\/api\/v2\/topology\/regions(?:\?.*)?$/, (route) => fulfillJson(route, topologyRegions));
+  await page.route(/\/api\/v2\/topology\/environments(?:\?.*)?$/, (route) =>
+    fulfillJson(route, topologyEnvironments),
+  );
+  await page.route(/\/api\/v2\/topology\/agents(?:\?.*)?$/, (route) => fulfillJson(route, topologyAgents));
+  await page.route(/\/api\/v2\/topology\/promotion-paths(?:\?.*)?$/, (route) =>
+    fulfillJson(route, promotionPaths),
+  );
+}
+
+test.beforeEach(async ({ page }) => {
+  await setupHarness(page);
+});
+
+test('platform setup canonical leaves preserve ops urls during setup topology cutover', async ({ page }) => {
+  await page.goto('/ops/platform-setup', { waitUntil: 'networkidle' });
+  const regionsCard = page.locator('.setup-home__card').filter({ hasText: 'Regions & Environments' });
+  await regionsCard.getByRole('link', { name: 'Open' }).click();
+  await expect(page).toHaveURL(/\/ops\/platform-setup\/regions-environments(?:\?.*)?$/);
+  await expect(page.getByRole('heading', { name: 'Regions & Environments' })).toBeVisible();
+
+  await page.goto('/ops/platform-setup/promotion-paths', { waitUntil: 'networkidle' });
+  await expect(page).toHaveURL(/\/ops\/platform-setup\/promotion-paths(?:\?.*)?$/);
+  await expect(page.getByRole('heading', { name: 'Promotion Paths' })).toBeVisible();
+
+  await page.goto('/ops/platform-setup/workflows-gates', { waitUntil: 'networkidle' });
+  await expect(page).toHaveURL(/\/ops\/platform-setup\/workflows-gates(?:\?.*)?$/);
+  await expect(page.getByRole('heading', { name: 'Workflows & Gates' })).toBeVisible();
+
+  await page.goto('/ops/platform-setup/gate-profiles', { waitUntil: 'networkidle' });
+  await expect(page).toHaveURL(/\/ops\/platform-setup\/gate-profiles(?:\?.*)?$/);
+  await expect(page.getByRole('heading', { name: 'Gate Profiles' })).toBeVisible();
+});
--- a/src/Web/StellaOps.Web/tests/e2e/topology-trust-admin-cutover.spec.ts
+++ b/src/Web/StellaOps.Web/tests/e2e/topology-trust-admin-cutover.spec.ts
@@ -281,7 +281,6 @@ test('topology and trust cutover keeps setup handoffs and legacy trust entry poi
  await page.goto('/ops/platform-setup', { waitUntil: 'networkidle' });
  const regionsCard = page.locator('.setup-home__card').filter({ hasText: 'Regions & Environments' });
  await regionsCard.getByRole('link', { name: 'Open' }).click();
-  await expect(page).toHaveURL(/\/setup\/topology\/regions(?:\?.*)?$/);
-  await expect(page.getByRole('heading', { name: 'Topology' })).toBeVisible();
+  await expect(page).toHaveURL(/\/ops\/platform-setup\/regions-environments(?:\?.*)?$/);
  await expect(page.getByRole('heading', { name: 'Regions & Environments' })).toBeVisible();
 });