@spinnaker/core 2026.2.2 → 2026.3.0

package/src/cluster/AllClustersGroupings.tsx

@@ -1,4 +1,3 @@
-import { UIRouterContext } from '@uirouter/react-hybrid';
 import React from 'react';
 import type { ListRowProps } from 'react-virtualized';
 import { AutoSizer, CellMeasurer, CellMeasurerCache, List } from 'react-virtualized';
@@ -9,8 +8,8 @@ import { ClusterPod } from './ClusterPod';
 import type { Application } from '../application';
 import type { IClusterGroup, IClusterSubgroup } from './filter/ClusterFilterService';
 import type { ISortFilter } from '../filterModel';
-import type { IStateChange } from '../reactShims';
-import { ReactInjector } from '../reactShims';
+import type { IRouterInjectedProps, IRouterStateChange } from '../navigation/routerContext';
+import { stateChangeSuccess$, withRouter } from '../navigation/routerContext';
 import { ClusterState } from '../state';
 
 export interface IAllClustersGroupingsProps {
@@ -23,20 +22,21 @@ export interface IAllClustersGroupingsState {
   sortFilter: ISortFilter;
 }
 
-@UIRouterContext
-export class AllClustersGroupings extends React.Component<IAllClustersGroupingsProps, IAllClustersGroupingsState> {
+export class AllClustersGroupingsComponent extends React.Component<
+  IAllClustersGroupingsProps & IRouterInjectedProps,
+  IAllClustersGroupingsState
+> {
   private clusterFilterService = ClusterState.filterService;
   private clusterFilterModel = ClusterState.filterModel;
 
   private groupsSubscription: Subscription;
   private routeChangedSubscription: Subscription;
-  private unwatchSortFilter: Function;
 
   private cellCache: CellMeasurerCache;
 
   private listRef: List;
 
-  constructor(props: IAllClustersGroupingsProps) {
+  constructor(props: IAllClustersGroupingsProps & IRouterInjectedProps) {
     super(props);
     this.cellCache = new CellMeasurerCache({
       fixedWidth: true,
@@ -75,7 +75,7 @@ export class AllClustersGroupings extends React.Component<IAllClustersGroupingsP
     this.cellCache.clearAll();
   };
 
-  private handleRouteChange = (stateChange: IStateChange) => {
+  private handleRouteChange = (stateChange: IRouterStateChange) => {
     const { to } = stateChange;
     if (
       to.name === 'home.applications.application.insight.clusters.instanceDetails' ||
@@ -89,21 +89,15 @@ export class AllClustersGroupings extends React.Component<IAllClustersGroupingsP
     window.addEventListener('resize', this.handleWindowResize);
     const onGroupsChanged = (groups: IClusterGroup[]) => {
       this.setState(
-        { groups: groups.reduce((a, b) => a.concat(b.subgroups), []) },
+        {
+          groups: groups.reduce((a, b) => a.concat(b.subgroups), []),
+          sortFilter: this.clusterFilterModel.asFilterModel.sortFilter,
+        },
         () => this.listRef && this.listRef.recomputeRowHeights(0),
       );
     };
     this.groupsSubscription = this.clusterFilterService.groupsUpdatedStream.subscribe(onGroupsChanged);
-    this.routeChangedSubscription = ReactInjector.stateEvents.stateChangeSuccess.subscribe(this.handleRouteChange);
-
-    const getSortFilter = () => this.clusterFilterModel.asFilterModel.sortFilter;
-    const onFilterChanged = ({ ...sortFilter }: any) => {
-      const shouldResetCache = sortFilter.listInstances !== this.state.sortFilter.listInstances;
-      this.setState({ sortFilter }, () => shouldResetCache && this.cellCache.clearAll());
-    };
-    // TODO: Remove $rootScope. Keeping it here so we can use $watch for now.
-    //       Eventually, there should be events fired when filters change.
-    this.unwatchSortFilter = ReactInjector.$rootScope.$watch(getSortFilter, onFilterChanged, true);
+    this.routeChangedSubscription = stateChangeSuccess$(this.props.router).subscribe(this.handleRouteChange);
 
     this.scrollToRow();
   }
@@ -112,20 +106,19 @@ export class AllClustersGroupings extends React.Component<IAllClustersGroupingsP
     window.removeEventListener('resize', this.handleWindowResize);
     this.groupsSubscription.unsubscribe();
     this.routeChangedSubscription.unsubscribe();
-    this.unwatchSortFilter();
   }
 
   private scrollToRow = () => {
-    const { $stateParams } = ReactInjector;
-    // Automatically scroll server group into view if deep linkedif ($stateParams.serverGroup) {
+    const { stateParams } = this.props;
+    // Automatically scroll server group into view if deep linkedif (stateParams.serverGroup) {
     this.clusterFilterService.groupsUpdatedStream.pipe(take(1)).subscribe(() => {
       const scrollToRow = this.state.groups.findIndex((group) =>
         group.subgroups.some((subgroup) =>
           subgroup.serverGroups.some(
             (sg) =>
-              sg.account === $stateParams.accountId &&
-              sg.name === $stateParams.serverGroup &&
-              sg.region === $stateParams.region,
+              sg.account === stateParams.accountId &&
+              sg.name === stateParams.serverGroup &&
+              sg.region === stateParams.region,
           ),
         ),
       );
@@ -202,3 +195,6 @@ export class AllClustersGroupings extends React.Component<IAllClustersGroupingsP
     );
   }
 }
+
+export const AllClustersGroupings = withRouter(AllClustersGroupingsComponent);
+AllClustersGroupings.displayName = 'AllClustersGroupings';

package/src/cluster/ClusterMaster.spec.tsx

@@ -0,0 +1,117 @@
+import { mount } from 'enzyme';
+import React from 'react';
+import { act } from 'react-dom/test-utils';
+
+import type { Application } from '../application';
+import { ClusterState, initialize } from '../state';
+import { useClusterMasterState } from './ClusterMaster';
+
+interface IDeferred<T> {
+  promise: Promise<T>;
+  reject: (error: Error) => void;
+  resolve: (value: T) => void;
+}
+
+function deferred<T>(): IDeferred<T> {
+  let resolve: (value: T) => void;
+  let reject: (error: Error) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+class TestServerGroupsDataSource {
+  public callbacks: Array<() => void> = [];
+  public onRefresh = jasmine.createSpy('onRefresh').and.callFake((callback: () => void) => {
+    this.callbacks.push(callback);
+    return () => {
+      this.callbacks = this.callbacks.filter((candidate) => candidate !== callback);
+    };
+  });
+  public ready = jasmine.createSpy('ready').and.callFake(() => this.readiness.promise);
+
+  constructor(private readiness: IDeferred<unknown>) {}
+
+  public emit(): void {
+    this.callbacks.forEach((callback) => callback());
+  }
+}
+
+function StateHarness({ app }: { app: Application }): JSX.Element {
+  const state = useClusterMasterState(app);
+  return <span>{`${state.initialized}:${state.loadError}`}</span>;
+}
+
+const makeApplication = (serverGroups: TestServerGroupsDataSource) =>
+  (({
+    serverGroups,
+    setActiveState: jasmine.createSpy('setActiveState'),
+  } as any) as Application);
+
+describe('ClusterMaster lifecycle', () => {
+  beforeEach(() => initialize());
+
+  it('activates filters and server groups, subscribes before readiness, and updates groups initially and on refresh', async () => {
+    const readiness = deferred<unknown>();
+    const serverGroups = new TestServerGroupsDataSource(readiness);
+    const app = makeApplication(serverGroups);
+    const activate = spyOn(ClusterState.filterModel, 'activate');
+    const updateClusterGroups = spyOn(ClusterState.filterService, 'updateClusterGroups');
+    const clearAll = spyOn(ClusterState.multiselectModel, 'clearAll');
+    const wrapper = mount(<StateHarness app={app} />);
+
+    expect(app.setActiveState).toHaveBeenCalledWith(serverGroups as any);
+    expect(activate).toHaveBeenCalledTimes(1);
+    expect(serverGroups.onRefresh).toHaveBeenCalledBefore(serverGroups.ready);
+    expect(wrapper.text()).toBe('false:false');
+
+    await act(async () => readiness.resolve(undefined));
+    wrapper.update();
+
+    expect(wrapper.text()).toBe('true:false');
+    expect(updateClusterGroups).toHaveBeenCalledTimes(1);
+
+    act(() => serverGroups.emit());
+    expect(updateClusterGroups).toHaveBeenCalledTimes(2);
+
+    wrapper.unmount();
+    expect(serverGroups.callbacks).toHaveSize(0);
+    expect(app.setActiveState).toHaveBeenCalledWith();
+    expect(clearAll).toHaveBeenCalledTimes(1);
+  });
+
+  it('initializes with a load error when server-group readiness rejects', async () => {
+    const readiness = deferred<unknown>();
+    const serverGroups = new TestServerGroupsDataSource(readiness);
+    const wrapper = mount(<StateHarness app={makeApplication(serverGroups)} />);
+
+    await act(async () => readiness.reject(new Error('load failed')));
+    wrapper.update();
+
+    expect(wrapper.text()).toBe('true:true');
+    wrapper.unmount();
+  });
+
+  it('ignores late readiness resolution and rejection after unmount', async () => {
+    const updateClusterGroups = spyOn(ClusterState.filterService, 'updateClusterGroups');
+    const resolvingReadiness = deferred<unknown>();
+    const resolvingWrapper = mount(
+      <StateHarness app={makeApplication(new TestServerGroupsDataSource(resolvingReadiness))} />,
+    );
+    resolvingWrapper.unmount();
+
+    await act(async () => resolvingReadiness.resolve(undefined));
+    expect(updateClusterGroups).not.toHaveBeenCalled();
+
+    const rejectingReadiness = deferred<unknown>();
+    const rejectingWrapper = mount(
+      <StateHarness app={makeApplication(new TestServerGroupsDataSource(rejectingReadiness))} />,
+    );
+    rejectingWrapper.unmount();
+
+    await act(async () => rejectingReadiness.reject(new Error('late failure')));
+    expect(updateClusterGroups).not.toHaveBeenCalled();
+  });
+});

package/src/cluster/ClusterMaster.tsx

@@ -0,0 +1,60 @@
+import React, { useEffect, useState } from 'react';
+
+import { AllClusters } from './AllClusters';
+import type { Application } from '../application';
+import { ClusterState } from '../state';
+
+export interface IClusterMasterProps {
+  app: Application;
+}
+
+export interface IClusterMasterState {
+  initialized: boolean;
+  loadError: boolean;
+}
+
+export function useClusterMasterState(app: Application): IClusterMasterState {
+  const [state, setState] = useState<IClusterMasterState>({ initialized: false, loadError: false });
+
+  useEffect(() => {
+    let active = true;
+
+    app.setActiveState(app.serverGroups);
+    (ClusterState.filterModel as any).activate();
+    const updateClusterGroups = (): void => {
+      if (active) {
+        ClusterState.filterService.updateClusterGroups(app);
+      }
+    };
+    const unsubscribe = app.serverGroups.onRefresh(updateClusterGroups);
+
+    app.serverGroups.ready().then(
+      () => {
+        if (active) {
+          updateClusterGroups();
+          setState({ initialized: true, loadError: false });
+        }
+      },
+      (): void => {
+        if (active) {
+          setState({ initialized: true, loadError: true });
+        }
+      },
+    );
+
+    return () => {
+      active = false;
+      unsubscribe();
+      app.setActiveState();
+      ClusterState.multiselectModel.clearAll();
+    };
+  }, [app]);
+
+  return state;
+}
+
+export function ClusterMaster({ app }: IClusterMasterProps) {
+  const { initialized, loadError } = useClusterMasterState(app);
+
+  return <AllClusters app={app} initialized={initialized} loadError={loadError} />;
+}

package/src/cluster/ClusterPodTitleWrapper.tsx

@@ -3,7 +3,7 @@ import React from 'react';
 import { DefaultClusterPodTitle } from './DefaultClusterPodTitle';
 import type { Application } from '../application/application.model';
 import type { IClusterSubgroup } from './filter/ClusterFilterService';
-import { ReactInjector } from '../reactShims';
+import { overrideRegistry } from '../overrideRegistry/override.registry';
 
 export interface IClusterPodTitleProps {
   grouping: IClusterSubgroup;
@@ -13,7 +13,6 @@ export interface IClusterPodTitleProps {
 
 export class ClusterPodTitleWrapper extends React.Component<IClusterPodTitleProps> {
   public render(): React.ReactElement<ClusterPodTitleWrapper> {
-    const { overrideRegistry } = ReactInjector;
     const config = overrideRegistry.getComponent('clusterPodTitle');
     const Title = config || DefaultClusterPodTitle;
 

package/src/cluster/cluster.module.ts

@@ -1,14 +1 @@
-import { module } from 'angular';
-
-import { CORE_CLUSTER_ALLCLUSTERS_CONTROLLER } from './allClusters.controller';
-import { CLUSTER_ALLCLUSTERSGROUPINGS } from './allClustersGroupings.component';
 import './clusterSearchResultType';
-import { ON_DEMAND_CLUSTER_PICKER_COMPONENT } from './onDemand/onDemandClusterPicker.component';
-
-export const CLUSTER_MODULE = 'spinnaker.core.cluster';
-
-module(CLUSTER_MODULE, [
-  CORE_CLUSTER_ALLCLUSTERS_CONTROLLER,
-  CLUSTER_ALLCLUSTERSGROUPINGS,
-  ON_DEMAND_CLUSTER_PICKER_COMPONENT,
-]);

package/src/cluster/cluster.service.spec.ts

@@ -1,22 +1,20 @@
-import { mock } from 'angular';
 import { find } from 'lodash';
 
 import { mockHttpClient } from '../api/mock/jasmine';
 import type { Application } from '../application/application.model';
 import { ApplicationModelBuilder } from '../application/applicationModel.builder';
-import type { ClusterService } from './cluster.service';
-import { CLUSTER_SERVICE } from './cluster.service';
+import { ClusterService } from './cluster.service';
+import { ProviderServiceDelegate } from '../cloudProvider';
 import { SETTINGS } from '../config/settings';
 import type { IInstanceCounts, IServerGroup } from '../domain';
-import { REACT_MODULE } from '../reactShims';
 import * as State from '../state';
+import { nativePromiseService } from '../utils/nativePromiseService';
 
 const ClusterState = State.ClusterState;
 
 describe('Service: Cluster', function () {
-  beforeEach(mock.module(CLUSTER_SERVICE, REACT_MODULE));
-
   let clusterService: ClusterService;
+  let serverGroupTransformer: any;
   let application: Application;
 
   function buildTask(config: { status: string; variables: { [key: string]: any } }) {
@@ -28,29 +26,63 @@ describe('Service: Cluster', function () {
     };
   }
 
-  beforeEach(
-    mock.inject((_clusterService_: ClusterService) => {
-      clusterService = _clusterService_;
-
-      application = ApplicationModelBuilder.createApplicationForTests(
-        'app',
-        { key: 'serverGroups', defaultData: [] },
-        { key: 'runningExecutions', defaultData: [] },
-        { key: 'runningTasks', defaultData: [] },
-      );
-      application.getDataSource('serverGroups').data = [
-        { name: 'the-target', account: 'not-the-target', region: 'us-east-1' },
-        { name: 'the-target', account: 'test', region: 'not-the-target' },
-        { name: 'the-target', account: 'test', region: 'us-east-1' },
-        { name: 'not-the-target', account: 'test', region: 'us-east-1' },
-        { name: 'the-source', account: 'test', region: 'us-east-1' },
-      ];
-    }),
-  );
+  beforeEach(() => {
+    serverGroupTransformer = {
+      normalizeServerGroup: (serverGroup: IServerGroup) => Promise.resolve(serverGroup),
+    };
+    clusterService = new ClusterService(
+      nativePromiseService,
+      serverGroupTransformer,
+      new ProviderServiceDelegate(nativePromiseService),
+    );
+
+    application = ApplicationModelBuilder.createApplicationForTests(
+      'app',
+      { key: 'serverGroups', defaultData: [] },
+      { key: 'runningExecutions', defaultData: [] },
+      { key: 'runningTasks', defaultData: [] },
+    );
+    application.getDataSource('serverGroups').data = [
+      { name: 'the-target', account: 'not-the-target', region: 'us-east-1' },
+      { name: 'the-target', account: 'test', region: 'not-the-target' },
+      { name: 'the-target', account: 'test', region: 'us-east-1' },
+      { name: 'not-the-target', account: 'test', region: 'us-east-1' },
+      { name: 'the-source', account: 'test', region: 'us-east-1' },
+    ];
+  });
 
   beforeEach(() => State.initialize());
 
   describe('lazy cluster fetching', () => {
+    it('retains multi-account cluster summaries and fetches selected clusters by exact key', async () => {
+      const http = mockHttpClient();
+      const clustersByAccount = {
+        accountA: ['cluster-a'],
+        accountB: Array.from({ length: SETTINGS.onDemandClusterThreshold }, (_, index) => `cluster-b-${index}`),
+      };
+      ClusterState.filterModel.asFilterModel.sortFilter.clusters = {
+        'accountA:cluster-a': true,
+        'accountB:cluster-b-1': true,
+        'accountB:cluster-b-2': false,
+      };
+      http.expectGET('/applications/app/clusters').respond(200, clustersByAccount);
+      http
+        .expectGET('/applications/app/serverGroups')
+        .withParams({ clusters: 'accountA:cluster-a,accountB:cluster-b-1' }, true)
+        .respond(200, []);
+
+      const serverGroupsPromise = clusterService.loadServerGroups(application);
+      await http.flush();
+      const serverGroups = await serverGroupsPromise;
+
+      expect(application.serverGroups.fetchOnDemand).toBe(true);
+      expect(application.serverGroups.clusters).toEqual([
+        { account: 'accountA', name: 'cluster-a' },
+        ...clustersByAccount.accountB.map((name) => ({ account: 'accountB', name })),
+      ]);
+      expect(serverGroups).toEqual([]);
+    });
+
     it('switches to lazy cluster fetching if there are more than the on demand threshold for clusters', async () => {
       const http = mockHttpClient();
       const clusters = [...Array(SETTINGS.onDemandClusterThreshold + 1)];
@@ -75,6 +107,22 @@ describe('Service: Cluster', function () {
       expect(serverGroups).toEqual([]);
     });
 
+    it('loads server groups with missing instances', async () => {
+      const http = mockHttpClient();
+      const clusters = Array(SETTINGS.onDemandClusterThreshold);
+      http.expectGET('/applications/app/clusters').respond(200, { test: clusters });
+      http
+        .expectGET('/applications/app/serverGroups')
+        .respond(200, [({ name: 'app-v001', account: 'test', region: 'us-east-1' } as unknown) as IServerGroup]);
+      spyOn(serverGroupTransformer, 'normalizeServerGroup').and.callFake((serverGroup: IServerGroup) => serverGroup);
+      let serverGroups: IServerGroup[] = null;
+
+      clusterService.loadServerGroups(application).then((result: IServerGroup[]) => (serverGroups = result));
+      await http.flush();
+
+      expect(serverGroups.find(({ name }) => name === 'app-v001').instances).toEqual([]);
+    });
+
     it('converts clusters parameter to q and account params when there are fewer than 251 clusters', async () => {
       const http = mockHttpClient();
       spyOn(ClusterState.filterModel.asFilterModel, 'applyParamsToUrl').and.callFake(() => {});
@@ -93,6 +141,25 @@ describe('Service: Cluster', function () {
   });
 
   describe('health count rollups', () => {
+    it('treats missing instances as an empty instance list', () => {
+      const serverGroups = [
+        {
+          cluster: 'cluster-a',
+          name: 'cluster-a-v001',
+          account: 'test',
+          region: 'us-east-1',
+          cloudProvider: 'kubernetes',
+          category: 'serverGroup',
+          instanceCounts: { total: 0 },
+        } as IServerGroup,
+      ];
+
+      const clusters = clusterService.createServerGroupClusters(serverGroups);
+
+      expect(clusters.length).toBe(1);
+      expect(serverGroups[0].instances).toEqual([]);
+    });
+
     it('aggregates health counts from server groups', () => {
       application.serverGroups.data = [
         {

package/src/cluster/cluster.service.ts

@@ -1,5 +1,3 @@
-import type { IQService } from 'angular';
-import { module } from 'angular';
 import { flatten, forOwn, groupBy, has, head, keyBy, keys, values } from 'lodash';
 
 import { REST } from '../api';
@@ -18,21 +16,20 @@ import type {
 } from '../domain';
 import { FilterModelService } from '../filterModel';
 import { NameUtils } from '../naming';
-import { CORE_SERVERGROUP_SERVERGROUP_TRANSFORMER } from '../serverGroup/serverGroup.transformer';
 import { ClusterState } from '../state';
 import { taskMatcher } from './task.matcher';
+import type { PromiseService } from '../utils/nativePromiseService';
 
 export class ClusterService {
-  public static $inject = ['$q', 'serverGroupTransformer', 'providerServiceDelegate'];
   constructor(
-    private $q: IQService,
+    private promiseService: PromiseService,
     private serverGroupTransformer: any,
     private providerServiceDelegate: ProviderServiceDelegate,
   ) {}
 
   // Retrieves and normalizes all server groups. If a server group for an unsupported cloud provider (i.e. one that does
   // not have a server group transformer) is encountered, it will be omitted from the result.
-  public loadServerGroups(application: Application): PromiseLike<IServerGroup[]> {
+  public loadServerGroups(application: Application): Promise<IServerGroup[]> {
     return this.getClusters(application.name).then((clusters: IClusterSummary[]) => {
       const dataSource = application.getDataSource('serverGroups');
       let serverGroupLoader = REST('/applications').path(application.name, 'serverGroups');
@@ -50,7 +47,7 @@ export class ClusterService {
       return serverGroupLoader.get().then((serverGroups: IServerGroup[]) => {
         serverGroups.forEach((sg) => this.addHealthStatusCheck(sg));
         serverGroups.forEach((sg) => this.addNameParts(sg));
-        return this.$q
+        return this.promiseService
           .all(serverGroups.map((sg) => this.serverGroupTransformer.normalizeServerGroup(sg, application)))
           .then((normalized) => normalized.filter(Boolean));
       });
@@ -236,7 +233,7 @@ export class ClusterService {
     this.getArtifactExtractor(cluster.cloudProvider).removeArtifact(cluster, artifactId);
   }
 
-  private getClusters(application: string): PromiseLike<IClusterSummary[]> {
+  private getClusters(application: string): Promise<IClusterSummary[]> {
     return REST('/applications')
       .path(application, 'clusters')
       .get()
@@ -281,6 +278,7 @@ export class ClusterService {
 
   private addProvidersAndServerGroupsToInstances(serverGroups: IServerGroup[]) {
     serverGroups.forEach((serverGroup) => {
+      serverGroup.instances = serverGroup.instances || [];
       serverGroup.instances.forEach((instance) => {
         instance.provider = serverGroup.type || serverGroup.provider;
         instance.serverGroup = instance.serverGroup || serverGroup.name;
@@ -303,6 +301,7 @@ export class ClusterService {
   }
 
   private addHealthStatusCheck(serverGroup: IServerGroup): void {
+    serverGroup.instances = serverGroup.instances || [];
     serverGroup.instances.forEach((instance) => {
       instance.hasHealthStatus = (instance.health || []).some((h) => h.state !== 'Unknown');
     });
@@ -335,6 +334,3 @@ export class ClusterService {
     });
   }
 }
-
-export const CLUSTER_SERVICE = 'spinnaker.core.cluster.service';
-module(CLUSTER_SERVICE, [CORE_SERVERGROUP_SERVERGROUP_TRANSFORMER]).service('clusterService', ClusterService);

package/src/cluster/clusterSearchResultType.spec.ts

@@ -0,0 +1,38 @@
+import { of } from 'rxjs';
+
+import { UrlBuilder } from '../navigation';
+import { SearchStatus, searchResultTypeRegistry } from '../search';
+import './clusterSearchResultType';
+
+describe('cluster search result type', () => {
+  it('builds cluster links from result metadata', async () => {
+    const buildFromMetadata = spyOn(UrlBuilder, 'buildFromMetadata').and.returnValue(
+      '/clusters?acct=prod&q=cluster:payments',
+    );
+    const resultType = searchResultTypeRegistry.get('clusters');
+
+    const result = await resultType
+      .search(
+        {} as any,
+        of({
+          results: [
+            {
+              account: 'prod',
+              application: 'payments',
+              cluster: 'payments',
+              provider: 'aws',
+              stack: '',
+            },
+          ],
+          status: SearchStatus.FINISHED,
+          type: { id: 'serverGroups' },
+        } as any),
+      )
+      .toPromise();
+
+    expect(buildFromMetadata).toHaveBeenCalledWith(
+      jasmine.objectContaining({ account: 'prod', application: 'payments', cluster: 'payments', type: 'clusters' }),
+    );
+    expect(result.results[0].href).toBe('/clusters?acct=prod&q=cluster:payments');
+  });
+});

package/src/cluster/clusterSearchResultType.tsx

@@ -4,8 +4,7 @@ import type { Observable } from 'rxjs';
 import { filter, first, map } from 'rxjs/operators';
 
 import type { IQueryParams } from '../navigation';
-import { ReactInjector } from '../reactShims';
-import { Registry } from '../registry';
+import { UrlBuilder } from '../navigation';
 import type { ISearchColumn, ISearchResult, ISearchResults, ISearchResultSet } from '../search';
 import {
   AccountCell,
@@ -67,9 +66,8 @@ class ClustersSearchResultType extends SearchResultType<IClusterSearchResult> {
 
   private makeSearchResult(serverGroup: IServerGroupSearchResult): IClusterSearchResult {
     const type = this.id;
-    const urlBuilder = Registry.urlBuilder.getBuilder(type);
     const input = { type, ...serverGroup };
-    const href = urlBuilder.build(input, ReactInjector.$state);
+    const href = UrlBuilder.buildFromMetadata(input);
 
     const { account, application, cluster, provider, stack } = serverGroup;
     return { account, application, cluster, provider, stack, displayName: cluster, href, type };