@rancher/shell 3.0.12-rc.2 → 3.0.12-rc.4

package/models/__tests__/workload.test.ts

@@ -1,6 +1,6 @@
 import Workload from '@shell/models/workload.js';
 import { steveClassJunkObject } from '@shell/plugins/steve/__tests__/utils/steve-mocks';
-import { WORKLOAD_TYPES, SERVICE } from '@shell/config/types';
+import { WORKLOAD_TYPES, SERVICE, INGRESS } from '@shell/config/types';
 
 describe('class: Workload', () => {
   describe('given custom workload keys', () => {
@@ -160,12 +160,7 @@ describe('class: Workload', () => {
   });
 
   describe('getter: relatedServices', () => {
-    it('should return services that match workload pods', () => {
-      const mockPod = {
-        metadata: {
-          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
-        }
-      };
+    it('should return services that match workload pod template labels', () => {
       const mockService = {
         metadata: { name: 'my-service', namespace: 'default' },
         spec:     { selector: { app: 'my-app' } }
@@ -173,7 +168,7 @@ describe('class: Workload', () => {
       const workload = new Workload({
         type:     WORKLOAD_TYPES.DEPLOYMENT,
         metadata: { name: 'test', namespace: 'default' },
-        spec:     {}
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
       }, {
         getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
         dispatch:    jest.fn(),
@@ -183,20 +178,12 @@ describe('class: Workload', () => {
         },
       });
 
-      // Mock pods getter
-      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
-
       const related = workload.relatedServices;
 
       expect(related).toContain(mockService);
     });
 
     it('should not return services from different namespace', () => {
-      const mockPod = {
-        metadata: {
-          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
-        }
-      };
       const mockService = {
         metadata: { name: 'my-service', namespace: 'other-namespace' },
         spec:     { selector: { app: 'my-app' } }
@@ -204,7 +191,7 @@ describe('class: Workload', () => {
       const workload = new Workload({
         type:     WORKLOAD_TYPES.DEPLOYMENT,
         metadata: { name: 'test', namespace: 'default' },
-        spec:     {}
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
       }, {
         getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
         dispatch:    jest.fn(),
@@ -214,19 +201,12 @@ describe('class: Workload', () => {
         },
       });
 
-      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
-
       const related = workload.relatedServices;
 
       expect(related).toHaveLength(0);
     });
 
     it('should not return services with non-matching selectors', () => {
-      const mockPod = {
-        metadata: {
-          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
-        }
-      };
       const mockService = {
         metadata: { name: 'my-service', namespace: 'default' },
         spec:     { selector: { app: 'different-app' } }
@@ -234,7 +214,7 @@ describe('class: Workload', () => {
       const workload = new Workload({
         type:     WORKLOAD_TYPES.DEPLOYMENT,
         metadata: { name: 'test', namespace: 'default' },
-        spec:     {}
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
       }, {
         getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
         dispatch:    jest.fn(),
@@ -244,7 +224,28 @@ describe('class: Workload', () => {
         },
       });
 
-      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
+      const related = workload.relatedServices;
+
+      expect(related).toHaveLength(0);
+    });
+
+    it('should return empty array when pod template has no labels', () => {
+      const mockService = {
+        metadata: { name: 'my-service', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     { template: { metadata: {} } }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      jest.fn(),
+          'cluster/all': (type: string) => (type === SERVICE ? [mockService] : [])
+        },
+      });
 
       const related = workload.relatedServices;
 
@@ -506,4 +507,378 @@ describe('class: Workload', () => {
       expect(jobsCard).toBeDefined();
     });
   });
+
+  describe('getter: matchingIngresses', () => {
+    const makeWorkload = (services: any[], ingresses: any[], pods: any[] = []) => {
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      jest.fn(),
+          'cluster/all': (type: string) => {
+            if (type === SERVICE) {
+              return services;
+            }
+            if (type === INGRESS) {
+              return ingresses;
+            }
+
+            return [];
+          }
+        },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => pods });
+
+      return workload;
+    };
+
+    it('should return empty array when no related services', () => {
+      const workload = makeWorkload([], [
+        {
+          metadata: { namespace: 'default' },
+          spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'svc1' } } }] } }] }
+        }
+      ]);
+
+      expect(workload.matchingIngresses).toStrictEqual([]);
+    });
+
+    it('should find matching ingresses', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'svc1', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const mockIngress = {
+        metadata: { namespace: 'default' },
+        spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'svc1' } } }] } }] }
+      };
+
+      const workload = makeWorkload([mockService], [mockIngress], [mockPod]);
+
+      expect(workload.matchingIngresses).toHaveLength(1);
+      expect(workload.matchingIngresses[0]).toStrictEqual(mockIngress);
+    });
+
+    it('should not match ingresses from other namespaces', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'svc1', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const mockIngress = {
+        metadata: { namespace: 'other' },
+        spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'svc1' } } }] } }] }
+      };
+
+      const workload = makeWorkload([mockService], [mockIngress], [mockPod]);
+
+      expect(workload.matchingIngresses).toHaveLength(0);
+    });
+
+    it('should not match ingresses pointing to other services', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'svc1', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const mockIngress = {
+        metadata: { namespace: 'default' },
+        spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'svc2' } } }] } }] }
+      };
+
+      const workload = makeWorkload([mockService], [mockIngress], [mockPod]);
+
+      expect(workload.matchingIngresses).toHaveLength(0);
+    });
+
+    it('should handle ingresses with no rules', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'svc1', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const mockIngress = {
+        metadata: { namespace: 'default' },
+        spec:     {}
+      };
+
+      const workload = makeWorkload([mockService], [mockIngress], [mockPod]);
+
+      expect(workload.matchingIngresses).toHaveLength(0);
+    });
+
+    it('should handle ingress rules with no paths', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'svc1', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const mockIngress = {
+        metadata: { namespace: 'default' },
+        spec:     { rules: [{ http: {} }] }
+      };
+
+      const workload = makeWorkload([mockService], [mockIngress], [mockPod]);
+
+      expect(workload.matchingIngresses).toHaveLength(0);
+    });
+
+    it('should handle ingress paths with no backend service', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'svc1', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const mockIngress = {
+        metadata: { namespace: 'default' },
+        spec:     { rules: [{ http: { paths: [{ backend: {} }] } }] }
+      };
+
+      const workload = makeWorkload([mockService], [mockIngress], [mockPod]);
+
+      expect(workload.matchingIngresses).toHaveLength(0);
+    });
+
+    it('should find one of many ingresses', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'svc1', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const ingresses = [
+        {
+          metadata: { namespace: 'other' },
+          spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'svc1' } } }] } }] }
+        },
+        {
+          metadata: { namespace: 'default' },
+          spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'svc1' } } }] } }] }
+        },
+        {
+          metadata: { namespace: 'default' },
+          spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'svc2' } } }] } }] }
+        }
+      ];
+
+      const workload = makeWorkload([mockService], ingresses, [mockPod]);
+
+      expect(workload.matchingIngresses).toHaveLength(1);
+      expect(workload.matchingIngresses[0]).toStrictEqual(ingresses[1]);
+    });
+  });
+
+  describe('getter: resourcesCardRows', () => {
+    it('should include services row when related services exist', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata:         { name: 'svc1', namespace: 'default' },
+        spec:             { selector: { app: 'my-app' } },
+        stateDisplay:     'Active',
+        stateSimpleColor: 'success'
+      };
+
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      (key: string) => key,
+          'cluster/all': (type: string) => {
+            if (type === SERVICE) {
+              return [mockService];
+            }
+
+            return [];
+          }
+        },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
+
+      const rows = workload.resourcesCardRows;
+      const servicesRow = rows.find((r: any) => r.label === 'component.resource.detail.card.resourcesCard.rows.services');
+
+      expect(servicesRow).toBeDefined();
+    });
+
+    it('should include ingresses row when matching ingresses exist', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata:         { name: 'svc1', namespace: 'default' },
+        spec:             { selector: { app: 'my-app' } },
+        stateDisplay:     'Active',
+        stateSimpleColor: 'success'
+      };
+      const mockIngress = {
+        metadata:         { namespace: 'default' },
+        spec:             { rules: [{ http: { paths: [{ backend: { service: { name: 'svc1' } } }] } }] },
+        stateDisplay:     'Active',
+        stateSimpleColor: 'success'
+      };
+
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      (key: string) => key,
+          'cluster/all': (type: string) => {
+            if (type === SERVICE) {
+              return [mockService];
+            }
+            if (type === INGRESS) {
+              return [mockIngress];
+            }
+
+            return [];
+          }
+        },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
+
+      const rows = workload.resourcesCardRows;
+      const ingressesRow = rows.find((r: any) => r.label === 'component.resource.detail.card.resourcesCard.rows.ingresses');
+
+      expect(ingressesRow).toBeDefined();
+      expect(ingressesRow.to).toBe('#ingresses');
+    });
+
+    it('should order services before ingresses', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata:         { name: 'svc1', namespace: 'default' },
+        spec:             { selector: { app: 'my-app' } },
+        stateDisplay:     'Active',
+        stateSimpleColor: 'success'
+      };
+      const mockIngress = {
+        metadata:         { namespace: 'default' },
+        spec:             { rules: [{ http: { paths: [{ backend: { service: { name: 'svc1' } } }] } }] },
+        stateDisplay:     'Active',
+        stateSimpleColor: 'success'
+      };
+
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      (key: string) => key,
+          'cluster/all': (type: string) => {
+            if (type === SERVICE) {
+              return [mockService];
+            }
+            if (type === INGRESS) {
+              return [mockIngress];
+            }
+
+            return [];
+          }
+        },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
+
+      const rows = workload.resourcesCardRows;
+
+      expect(rows[0].label).toBe('component.resource.detail.card.resourcesCard.rows.services');
+      expect(rows[1].label).toBe('component.resource.detail.card.resourcesCard.rows.ingresses');
+    });
+
+    it('should not include ingresses row when no matching ingresses', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata:         { name: 'svc1', namespace: 'default' },
+        spec:             { selector: { app: 'my-app' } },
+        stateDisplay:     'Active',
+        stateSimpleColor: 'success'
+      };
+
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     { template: { metadata: { labels: { app: 'my-app' } } } }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      (key: string) => key,
+          'cluster/all': (type: string) => {
+            if (type === SERVICE) {
+              return [mockService];
+            }
+
+            return [];
+          }
+        },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
+
+      const rows = workload.resourcesCardRows;
+      const ingressesRow = rows.find((r: any) => r.label === 'component.resource.detail.card.resourcesCard.rows.ingresses');
+
+      expect(ingressesRow).toBeUndefined();
+    });
+  });
 });

package/models/base-cluster.x-k8s.io.js

@@ -0,0 +1,26 @@
+import { escapeHtml } from '@shell/utils/string';
+import SteveModel from '@shell/plugins/steve/steve-class';
+import { CAPI } from '@shell/config/types';
+
+export default class CapiMachineRoot extends SteveModel {
+  get cluster() {
+    if ( !this.spec.clusterName ) {
+      return null;
+    }
+
+    // This is used to get the cluster's human name
+    // Ideally we get this via the management cluster. To find it though we have to go via the provisioning cluster. So might as well just use that
+
+    const clusterId = `${ this.metadata.namespace }/${ this.spec.clusterName }`;
+
+    return this.$rootGetters['management/byId'](CAPI.RANCHER_CLUSTER, clusterId);
+  }
+
+  get clusterName() {
+    return this.cluster?.nameDisplay || this.spec.clusterName;
+  }
+
+  get groupByLabel() {
+    return this.$rootGetters['i18n/t']('resourceTable.groupLabel.cluster', { name: escapeHtml(this.clusterName) });
+  }
+}

package/models/catalog.cattle.io.clusterrepo.js

@@ -4,8 +4,10 @@ import { insertAt } from '@shell/utils/array';
 import { CLUSTER_REPO_APPCO_AUTH_GENERATE_NAME, CATALOG as CATALOG_TYPE } from '@shell/config/types';
 import { colorForState, stateDisplay } from '@shell/plugins/dashboard-store/resource-class';
 import { _CREATE } from '@shell/config/query-params';
+import { formatDuration } from '@shell/utils/duration';
 
 import SteveModel from '@shell/plugins/steve/steve-class';
+import { SUSE_APPCO_DISPLAY_NAME } from '@shell/utils/fleet-appco';
 
 export default class ClusterRepo extends SteveModel {
   applyDefaults() {
@@ -183,7 +185,7 @@ export default class ClusterRepo extends SteveModel {
 
   get typeDisplay() {
     if (this.isSuseAppCollectionFromUI) {
-      return 'SUSE AppCo';
+      return SUSE_APPCO_DISPLAY_NAME;
     }
     if ( this.spec.gitRepo ) {
       return 'git';
@@ -218,15 +220,37 @@ export default class ClusterRepo extends SteveModel {
     return this.spec?.gitBranch || '(default)';
   }
 
+  get defaultRefreshIntervalHours() {
+    return this.isOciType ? 24 : 1;
+  }
+
+  get defaultRefreshInterval() {
+    return 60 * 60 * this.defaultRefreshIntervalHours;
+  }
+
+  get refreshIntervalDisplay() {
+    const val = this.spec?.refreshInterval;
+
+    if (val < 0) {
+      return this.t('generic.disabled');
+    }
+
+    return formatDuration(val ?? this.defaultRefreshInterval);
+  }
+
   get details() {
     return [
       {
-        label:   'Type',
+        label:   this.t('generic.type'),
         content: this.typeDisplay,
       },
       {
-        label:         'Downloaded',
-        content:       this.status.downloadTime,
+        label:   this.t('catalog.repo.refreshInterval.label'),
+        content: this.refreshIntervalDisplay,
+      },
+      {
+        label:         this.t('catalog.repo.downloaded.label'),
+        content:       this.status?.downloadTime,
         formatter:     'LiveDate',
         formatterOpts: { addSuffix: true },
       },

package/models/cluster.js

@@ -69,6 +69,6 @@ export default class NormanCluster extends NormanModel {
       const id = this.provisioningClusterId;
 
       return id && !!this.$rootGetters['management/byId'](CAPI.RANCHER_CLUSTER, id);
-    }, this.$rootGetters['i18n/t']('cluster.managementTimeout'), timeout, interval);
+    }, this.$rootGetters['i18n/t']('cluster.managementTimeout', { type: CAPI.RANCHER_CLUSTER, name: this.provisioningClusterId }), timeout, interval);
   }
 }

package/models/cluster.x-k8s.io.machine.js

@@ -2,11 +2,10 @@ import { ADDRESSES, CAPI, NODE } from '@shell/config/types';
 import { CAPI as CAPI_LABELS, MACHINE_ROLES } from '@shell/config/labels-annotations';
 import { NAME as EXPLORER } from '@shell/config/product/explorer';
 import { listNodeRoles } from '@shell/models/cluster/node';
-import { escapeHtml } from '@shell/utils/string';
 import { insertAt, findBy } from '@shell/utils/array';
 import { get } from '@shell/utils/object';
 import { downloadUrl } from '@shell/utils/download';
-import SteveModel from '@shell/plugins/steve/steve-class';
+import CapiMachineRoot from '@shell/models/base-cluster.x-k8s.io';
 
 /**
  * Prevent scaling down control plane or etcd machines to zero
@@ -53,7 +52,8 @@ export function notOnlyOfRole(current, all) {
 
   return false;
 }
-export default class CapiMachine extends SteveModel {
+
+export default class CapiMachine extends CapiMachineRoot {
   get _availableActions() {
     const out = super._availableActions;
 
@@ -144,18 +144,6 @@ export default class CapiMachine extends SteveModel {
     return await this.$dispatch('find', { type: kind, id });
   }
 
-  get cluster() {
-    if ( !this.spec.clusterName ) {
-      return null;
-    }
-
-    const clusterId = `${ this.metadata.namespace }/${ this.spec.clusterName }`;
-
-    const cluster = this.$rootGetters['management/byId'](CAPI.RANCHER_CLUSTER, clusterId);
-
-    return cluster;
-  }
-
   get poolName() {
     return this.metadata?.labels?.[ CAPI_LABELS.DEPLOYMENT_NAME ] || '';
   }
@@ -182,7 +170,7 @@ export default class CapiMachine extends SteveModel {
       return {
         name:   'c-cluster-product-resource-id',
         params: {
-          cluster:  this.cluster.status.clusterName,
+          cluster,
           product:  EXPLORER,
           resource: NODE,
           id:       kubeId
@@ -193,12 +181,6 @@ export default class CapiMachine extends SteveModel {
     return kubeId;
   }
 
-  get groupByLabel() {
-    const name = this.cluster?.nameDisplay || this.spec.clusterName;
-
-    return this.$rootGetters['i18n/t']('resourceTable.groupLabel.cluster', { name: escapeHtml(name) });
-  }
-
   get labels() {
     return this.metadata?.labels || {};
   }

package/models/cluster.x-k8s.io.machinedeployment.js

@@ -1,33 +1,15 @@
 import { CAPI } from '@shell/config/types';
 import { escapeHtml } from '@shell/utils/string';
 import { sortBy } from '@shell/utils/sort';
-import SteveModel from '@shell/plugins/steve/steve-class';
 import { exceptionToErrorsArray } from '@shell/utils/error';
 import { handleConflict } from '@shell/plugins/dashboard-store/normalize';
 import { CAPI as CAPI_ANNOTATIONS, MACHINE_ROLES } from '@shell/config/labels-annotations';
 import { notOnlyOfRole } from '@shell/models/cluster.x-k8s.io.machine';
 import { KIND } from '../config/elemental-types';
 import { KIND as HARVESTER_KIND } from '../config/harvester-manager-types';
+import CapiMachineRoot from '@shell/models/base-cluster.x-k8s.io';
 
-export default class CapiMachineDeployment extends SteveModel {
-  get cluster() {
-    if ( !this.spec.clusterName ) {
-      return null;
-    }
-
-    const clusterId = `${ this.metadata.namespace }/${ this.spec.clusterName }`;
-
-    const cluster = this.$rootGetters['management/byId'](CAPI.RANCHER_CLUSTER, clusterId);
-
-    return cluster;
-  }
-
-  get groupByLabel() {
-    const name = this.cluster?.nameDisplay || this.spec.clusterName;
-
-    return this.$rootGetters['i18n/t']('resourceTable.groupLabel.cluster', { name: escapeHtml(name) });
-  }
-
+export default class CapiMachineDeployment extends CapiMachineRoot {
   get groupByPoolLabel() {
     return `${ this.$rootGetters['i18n/t']('resourceTable.groupLabel.machinePool', { name: escapeHtml(this.nameDisplay) }) }`;
   }