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

package/machine-config/__tests__/generic.test.ts

@@ -0,0 +1,163 @@
+import Generic from '@shell/machine-config/generic.vue';
+import { shallowMount } from '@vue/test-utils';
+import { MANAGEMENT } from '@shell/config/types';
+import { NODE_DRIVER_FIELD_HINTS } from '@shell/config/labels-annotations';
+import { Banner } from '@components/Banner';
+import Questions from '@shell/components/Questions';
+
+const PROVIDER = 'testdriver';
+
+const buildFields = () => ({
+  zone:       { type: 'string' },
+  diskSize:   { type: 'string' },
+  enginePort: { type: 'string' },
+});
+
+const mockedStore = (fieldHints: Record<string, { type: string }> | null = null) => {
+  const driver = { metadata: { annotations: { ...(fieldHints ? { [NODE_DRIVER_FIELD_HINTS]: JSON.stringify(fieldHints) } : {}) } } };
+
+  return {
+    getters: {
+      'i18n/t':                           (key: string) => key,
+      t:                                  (key: string) => key,
+      'plugins/fieldsForDriver':          () => Promise.resolve(buildFields()),
+      'plugins/credentialFieldForDriver': () => PROVIDER,
+      'plugins/fieldNamesForDriver':      () => [],
+      'rancher/schemaFor':                () => null,
+    },
+    dispatch: jest.fn((_action: string, args: any) => {
+      if (args?.type === MANAGEMENT.NODE_DRIVER && args?.id === PROVIDER) {
+        return Promise.resolve(driver);
+      }
+
+      return Promise.resolve(null);
+    }),
+  };
+};
+
+const mountAndFetch = async(storeOverrides: Record<string, any> = {}) => {
+  const store = {
+    ...mockedStore(null),
+    ...storeOverrides,
+    getters: {
+      ...mockedStore(null).getters,
+      ...(storeOverrides.getters || {}),
+    },
+  };
+
+  if (storeOverrides.dispatch) {
+    store.dispatch = storeOverrides.dispatch;
+  }
+
+  const wrapper = shallowMount(Generic, {
+    props: {
+      credentialId: 'cattle-global-data:cc-12345',
+      provider:     PROVIDER,
+      value:        { metadata: { namespace: 'fleet-default' } },
+      mode:         'edit',
+    },
+    global: {
+      mocks: {
+        $store:      store,
+        $fetchState: { pending: false },
+      },
+    },
+  });
+
+  await (Generic as any).fetch.call(wrapper.vm);
+  await wrapper.vm.$nextTick();
+
+  return wrapper;
+};
+
+describe('generic machine config', () => {
+  describe('io.cattle.nodedriver/ui-field-hints annotation', () => {
+    it('should override field types when type hints are provided', async() => {
+      const hints = {
+        zone:     { type: 'multiline' },
+        diskSize: { type: 'multiline' },
+      };
+      const wrapper = await mountAndFetch({
+        ...mockedStore(hints),
+        getters: { ...mockedStore(hints).getters },
+      });
+
+      expect((wrapper.vm as any).fields.zone.type).toBe('multiline');
+      expect((wrapper.vm as any).fields.diskSize.type).toBe('multiline');
+    });
+
+    it('should not modify fields that are not in the hints', async() => {
+      const hints = { zone: { type: 'multiline' } };
+      const wrapper = await mountAndFetch({
+        ...mockedStore(hints),
+        getters: { ...mockedStore(hints).getters },
+      });
+
+      expect((wrapper.vm as any).fields.enginePort.type).toBe('string');
+    });
+
+    it('should not modify fields when no hints annotation exists', async() => {
+      const wrapper = await mountAndFetch();
+
+      expect((wrapper.vm as any).fields.zone.type).toBe('string');
+      expect((wrapper.vm as any).fields.diskSize.type).toBe('string');
+      expect((wrapper.vm as any).fields.enginePort.type).toBe('string');
+    });
+
+    it('should ignore hint entries for fields not present in the schema', async() => {
+      const hints = { nonExistentField: { type: 'multiline' } };
+      const wrapper = await mountAndFetch({
+        ...mockedStore(hints),
+        getters: { ...mockedStore(hints).getters },
+      });
+
+      expect((wrapper.vm as any).fields.zone.type).toBe('string');
+      expect((wrapper.vm as any).fields.nonExistentField).toBeUndefined();
+    });
+
+    it('should ignore hint entries that do not specify a type', async() => {
+      const hints = { zone: { otherKey: 'blah' } } as any;
+      const wrapper = await mountAndFetch({
+        ...mockedStore(hints),
+        getters: { ...mockedStore(hints).getters },
+      });
+
+      expect((wrapper.vm as any).fields.zone.type).toBe('string');
+    });
+
+    it('should handle malformed JSON in the annotation gracefully', async() => {
+      const driver = { metadata: { annotations: { [NODE_DRIVER_FIELD_HINTS]: 'testing bad json{' } } };
+      const wrapper = await mountAndFetch({ dispatch: jest.fn(() => Promise.resolve(driver)) });
+
+      expect((wrapper.vm as any).fields.zone.type).toBe('string');
+      expect((wrapper.vm as any).errors.length).toBe(1);
+    });
+  });
+
+  describe('data fetching failures', () => {
+    it('should render an error banner and not render Questions when unable to determine fields for the driver', async() => {
+      const wrapper = await mountAndFetch({ getters: { 'plugins/fieldsForDriver': () => Promise.resolve(null) } });
+
+      expect((wrapper.vm as any).errors.length).toBe(1);
+      expect((wrapper.vm as any).errors[0].message).toContain(`Machine Driver config schema not found for rke-machine-config.cattle.io.${ PROVIDER }config`);
+
+      const banners = wrapper.findAllComponents(Banner);
+
+      expect(banners.length).toBe(1);
+      expect(wrapper.findComponent(Questions).exists()).toBe(false);
+    });
+
+    it('should render an error banner but still render Questions when unable to retrieve node driver field hints', async() => {
+      const driverError = 'node driver not found';
+      const wrapper = await mountAndFetch({ dispatch: jest.fn(() => Promise.reject(new Error(driverError))) });
+
+      expect((wrapper.vm as any).errors.length).toBe(1);
+      expect((wrapper.vm as any).errors[0].message).toContain(driverError);
+
+      const banners = wrapper.findAllComponents(Banner);
+
+      expect(banners.length).toBe(1);
+      expect(wrapper.findComponent(Questions).exists()).toBe(true);
+    });
+  });
+});

package/machine-config/components/EC2Networking.vue

@@ -10,6 +10,7 @@ import { Banner } from '@components/Banner';
 import { scrollToBottom } from '@shell/utils/scroll';
 import { _CREATE } from '@shell/config/query-params';
 import { getSubnetDisplayName, getVpcDisplayName, isIpv4Network, isIpv6Network } from '@shell/utils/aws';
+import { STACK_PREFS } from '@shell/edit/provisioning.cattle.io.cluster/tabs/networking/index.vue';
 
 export default {
   name: 'Ec2MachinePoolNetworking',
@@ -297,10 +298,27 @@ export default {
       return this.mode === _CREATE || (this.isNew && this.somePoolisIpv6OrDual) || this.enableIpv6;
     },
 
-    poolsInvalid() {
-      const somePoolHasIpv4 = !!this.machinePools.find((p) => !p.isIpv6 && !p.isDualStack);
+    dualStackModeInvalid() {
+      const poolNetworkModes = new Set(this.machinePools.map((p) => {
+        if (p.isDualStack || p.isIpv6) {
+          return STACK_PREFS.DUAL;
+        }
+
+        return STACK_PREFS.IPV4;
+      }));
 
-      return this.somePoolisIpv6OrDual && somePoolHasIpv4;
+      return poolNetworkModes.size > 1;
+    },
+    ipv6ModeInvalid() {
+      const poolNetworkModes = new Set(this.machinePools.map((p) => {
+        if (p.isIpv6) {
+          return STACK_PREFS.IPV6;
+        }
+
+        return 'other';
+      }));
+
+      return poolNetworkModes.size > 1;
     },
 
     addressCountInvalid() {
@@ -308,7 +326,7 @@ export default {
     },
 
     allValid() {
-      return !this.poolsInvalid && !this.addressCountInvalid;
+      return !this.dualStackModeInvalid && !this.addressCountInvalid && !this.ipv6ModeInvalid;
     }
   },
 
@@ -356,10 +374,10 @@ export default {
 
 <template>
   <Banner
-    v-if="poolsInvalid"
+    v-if="dualStackModeInvalid"
     color="error"
-    :label="t('cluster.machineConfig.amazonEc2.ipv6ValidationWarning')"
-    data-testid="amazonEc2__ipv6Warning"
+    :label="t('cluster.machineConfig.amazonEc2.dualStackValidationWarning')"
+    data-testid="amazonEc2__dualStackWarning"
   />
   <div
     v-if="showIpv6Options"
@@ -410,6 +428,12 @@ export default {
       </LabeledSelect>
     </div>
   </div>
+  <Banner
+    v-if="enableIpv6 && ipv6ModeInvalid"
+    color="error"
+    :label="t('cluster.machineConfig.amazonEc2.ipv6ValidationWarning')"
+    data-testid="amazonEc2__ipv6Warning"
+  />
   <div
     v-if="enableIpv6"
     class="row mb-10 ipv6-row"

package/machine-config/components/__tests__/EC2Networking.test.ts

@@ -1,4 +1,4 @@
-import { mount, shallowMount } from '@vue/test-utils';
+import { shallowMount } from '@vue/test-utils';
 import EC2Networking from '@shell/machine-config/components/EC2Networking.vue';
 
 import { vpcInfo, subnetInfo } from './utils/vpcSubnetMockData';
@@ -16,6 +16,7 @@ describe('component: EC2Networking', () => {
     },
     global: {
       mocks: {
+        t:           (key: string) => key,
         $fetchState: { pending: false },
         $store:      { getters: defaultGetters },
       },
@@ -65,16 +66,9 @@ describe('component: EC2Networking', () => {
   });
 
   it('should render the ipv6 only checkbox when the selected network is dual-stack', async() => {
-    const wrapper = mount(EC2Networking, defaultCreateSetup);
-    const ipv6Checkbox = wrapper.findComponent('[data-testid="amazonEc2__enableIpv6"]');
-
-    ipv6Checkbox.vm.$emit('update:value', true);
-    await wrapper.vm.$nextTick();
-
-    const networkDropdown = wrapper.findComponent('[data-testid="amazonEc2__selectedNetwork"]');
+    const wrapper = shallowMount(EC2Networking, defaultCreateSetup);
 
-    networkDropdown.vm.$emit('selecting', 'subnet-321');
-    await wrapper.vm.$nextTick();
+    await wrapper.setData({ enableIpv6: true, selectedNetwork: 'vpc-12345' });
 
     const ipv6OnlyCheckbox = wrapper.findComponent('[data-testid="amazonEc2__ipv6AddressOnly"]');
 
@@ -82,14 +76,19 @@ describe('component: EC2Networking', () => {
   });
 
   it.each([
-    [[{ isIpv6: true }, { isIpv6: false }], true],
-    [[{ isIpv6: false }, { isIpv6: false }], false],
-    [[{ isIpv6: true }, { isIpv6: true }], false],
-  ])('should show an error banner if pools do not either all have ipv6 or all have ipv4', (pools, shouldShowError) => {
+    [[{ isIpv6: true }, { isIpv6: false }], true, true],
+    [[{ isIpv6: false, isDualStack: true }, { isIpv6: false, isDualStack: false }], true, false],
+    [[{ isIpv6: true, isDualStack: false }, { isIpv6: false, isDualStack: true }], false, true],
+    [[{ isIpv6: false, isDualStack: false }, { isIpv6: false, isDualStack: false }], false, false],
+    [[{ isIpv6: true, isDualStack: false }, { isIpv6: true, isDualStack: false }], false, false],
+    [[{ isIpv6: false, isDualStack: true }, { isIpv6: false, isDualStack: true }], false, false],
+  ])('should show the correct warning banner based on mixed machine pool network modes', (pools, shouldShowDualStackWarning, shouldShowIpv6Warning) => {
     const wrapper = shallowMount(EC2Networking, { ...defaultCreateSetup, propsData: { ...defaultCreateSetup.propsData, machinePools: pools } });
+    const dualStackWarning = wrapper.findComponent('[data-testid="amazonEc2__dualStackWarning"]');
     const ipv6Warning = wrapper.findComponent('[data-testid="amazonEc2__ipv6Warning"]');
 
-    expect(ipv6Warning.exists()).toBe(shouldShowError);
+    expect(dualStackWarning.exists()).toBe(shouldShowDualStackWarning);
+    expect(ipv6Warning.exists()).toBe(shouldShowIpv6Warning);
   });
 
   it('should show ipv6 inputs and automatically check the enable ipv6 checkbox when adding a new pool if some other pool in the cluster is using ipv6 or dual stack', () => {
@@ -145,4 +144,28 @@ describe('component: EC2Networking', () => {
 
     expect(wrapper.emitted('validationChanged')?.[0][0]).toBe(true);
   });
+
+  it('should emit a validationChanged: false event when ipv6-only and dual-stack pools are mixed', async() => {
+    const wrapper = shallowMount(EC2Networking, {
+      ...defaultCreateSetup,
+      propsData: {
+        ...defaultCreateSetup.propsData,
+        machinePools: [{ isIpv6: true, isDualStack: false }, { isIpv6: false, isDualStack: true }],
+      },
+    });
+
+    expect(wrapper.emitted('validationChanged')?.[0][0]).toBe(false);
+  });
+
+  it('should emit a validationChanged: true event when all pools are dual-stack', async() => {
+    const wrapper = shallowMount(EC2Networking, {
+      ...defaultCreateSetup,
+      propsData: {
+        ...defaultCreateSetup.propsData,
+        machinePools: [{ isIpv6: false, isDualStack: true }, { isIpv6: false, isDualStack: true }],
+      },
+    });
+
+    expect(wrapper.emitted('validationChanged')?.[0][0]).toBe(true);
+  });
 });

package/machine-config/generic.vue

@@ -4,6 +4,10 @@ import { Banner } from '@components/Banner';
 import CreateEditView from '@shell/mixins/create-edit-view';
 import { exceptionToErrorsArray, stringify } from '@shell/utils/error';
 import Questions from '@shell/components/Questions';
+import { MANAGEMENT } from '@shell/config/types';
+import { NODE_DRIVER_FIELD_HINTS } from '@shell/config/labels-annotations';
+import { isEmpty } from '@shell/utils/object';
+import cloneDeep from 'lodash/cloneDeep';
 
 export default {
   emits: ['input'],
@@ -35,12 +39,36 @@ export default {
     this.errors = [];
 
     try {
-      this.fields = await this.$store.getters['plugins/fieldsForDriver'](this.provider);
+      const fields = await this.$store.getters['plugins/fieldsForDriver'](this.provider);
+
+      // copy the result of the getter before modifying it to add hints
+      this.fields = cloneDeep(fields);
       const name = `rke-machine-config.cattle.io.${ this.provider }config`;
 
       if ( !this.fields ) {
         throw new Error(`Machine Driver config schema not found for ${ name }`);
       }
+    } catch (e) {
+      this.errors = exceptionToErrorsArray(e);
+
+      return;
+    }
+
+    try {
+      const driver = await this.$store.dispatch('management/find', { type: MANAGEMENT.NODE_DRIVER, id: this.provider } );
+      const fieldHints = driver?.metadata?.annotations?.[NODE_DRIVER_FIELD_HINTS];
+      let parsedHints;
+
+      if (fieldHints) {
+        parsedHints = JSON.parse(fieldHints);
+      }
+      if (parsedHints && !isEmpty(parsedHints)) {
+        Object.keys(this.fields).forEach((fieldKey) => {
+          if (parsedHints[fieldKey] && parsedHints[fieldKey].type) {
+            this.fields[fieldKey].type = parsedHints[fieldKey].type;
+          }
+        });
+      }
     } catch (e) {
       this.errors = exceptionToErrorsArray(e);
     }
@@ -77,7 +105,7 @@ export default {
     v-if="$fetchState.pending"
     :delayed="true"
   />
-  <div v-else-if="errors.length">
+  <template v-else>
     <div
       v-for="(err, idx) in errors"
       :key="idx"
@@ -87,9 +115,8 @@ export default {
         :label="stringify(err)"
       />
     </div>
-  </div>
-  <div v-else>
     <Questions
+      v-if="fields"
       :value="value"
       :mode="mode"
       :tabbed="false"
@@ -99,5 +126,5 @@ export default {
       :disabled="disabled"
       @update:value="$emit('input', $event)"
     />
-  </div>
+  </template>
 </template>

package/mixins/resource-fetch.js

@@ -35,7 +35,7 @@ export default {
     // Normally owner components supply `resource` and `inStore` as part of their data, however these are needed here before parent data runs
     // So set up both here
     const params = { ...this.$route.params };
-    const resource = params.resource || this.schema?.id; // Resource can either be on a page showing single list, or a page of a resource showing a list of another resource
+    const resource = this.schema?.id || params.resource; // Resource can either be on a page showing single list, or a page of a resource showing a list of another resource
     const inStore = this.$store.getters['currentStore'](resource);
 
     return {

package/models/__tests__/provisioning.cattle.io.cluster.test.ts

@@ -1,5 +1,12 @@
 import ProvCluster from '@shell/models/provisioning.cattle.io.cluster';
 import MgmtCluster from '@shell/models/management.cattle.io.cluster';
+import { IMPORTED_DAY_2_OPS } from '@shell/config/features';
+import { OPERATION_ANNOTATIONS } from '@shell/config/labels-annotations';
+import { SETTING } from '@shell/config/settings';
+import { MANAGEMENT, OPERATION } from '@shell/config/types';
+import { createOperationCR } from '@shell/utils/operation-cr';
+
+jest.mock('@shell/utils/operation-cr', () => ({ createOperationCR: jest.fn() }));
 
 jest.mock('@shell/utils/provider', () => ({
   isHostedProvider: jest.fn().mockImplementation((context, provider) => {
@@ -441,4 +448,153 @@ describe('class ProvCluster', () => {
       jest.clearAllMocks();
     });
   });
+  describe('day 2 operations', () => {
+    const createContext = ({
+      byId = jest.fn(),
+      all = jest.fn(() => []),
+      schemaFor = jest.fn(() => ({})),
+    } = {}) => {
+      return {
+        getters:     { schemaFor },
+        rootGetters: {
+          'management/byId': byId,
+          'management/all':  all,
+        }
+      };
+    };
+
+    it('should return true when the day 2 operations feature is enabled', () => {
+      const byId = jest.fn().mockImplementation((type, id) => {
+        if (type === MANAGEMENT.FEATURE && id === IMPORTED_DAY_2_OPS) {
+          return { enabled: true };
+        }
+
+        return undefined;
+      });
+      const cluster = new ProvCluster({}, createContext({ byId }));
+
+      expect(cluster.isDayTwoOpsFeatureEnabled).toBe(true);
+    });
+
+    it('should return true for imported RKE2 day 2 operations when the annotation is enabled', () => {
+      const byId = jest.fn().mockImplementation((type, id) => {
+        if (type === MANAGEMENT.FEATURE && id === IMPORTED_DAY_2_OPS) {
+          return { enabled: true };
+        }
+
+        return undefined;
+      });
+      const cluster = new ProvCluster({}, createContext({ byId }));
+
+      jest.spyOn(cluster, 'mgmt', 'get').mockReturnValue({ metadata: { annotations: { [OPERATION_ANNOTATIONS.ENABLED]: 'true' } } });
+      jest.spyOn(cluster, 'isImportedRke2K3s', 'get').mockReturnValue(true);
+
+      expect(cluster.isImportedWithDayTwoOps).toBe(true);
+    });
+
+    it('should return true for imported RKE2 day 2 operations when the global setting is enabled', () => {
+      const byId = jest.fn().mockImplementation((type, id) => {
+        if (type === MANAGEMENT.FEATURE && id === IMPORTED_DAY_2_OPS) {
+          return { enabled: true };
+        }
+
+        if (type === MANAGEMENT.SETTING && id === SETTING.IMPORTED_CLUSTER_DAY2_OPS_DEFAULT) {
+          return { value: 'true' };
+        }
+
+        return undefined;
+      });
+      const cluster = new ProvCluster({}, createContext({ byId }));
+
+      jest.spyOn(cluster, 'mgmt', 'get').mockReturnValue({ metadata: { annotations: {} } });
+      jest.spyOn(cluster, 'isImportedRke2K3s', 'get').mockReturnValue(true);
+
+      expect(cluster.isImportedWithDayTwoOps).toBe(true);
+    });
+
+    it('should return false for imported RKE2 day 2 operations when the feature is disabled', () => {
+      const byId = jest.fn().mockImplementation((type, id) => {
+        if (type === MANAGEMENT.SETTING && id === SETTING.IMPORTED_CLUSTER_DAY2_OPS_DEFAULT) {
+          return { value: 'true' };
+        }
+
+        return undefined;
+      });
+      const cluster = new ProvCluster({}, createContext({ byId }));
+
+      jest.spyOn(cluster, 'mgmt', 'get').mockReturnValue({ metadata: { annotations: { [OPERATION_ANNOTATIONS.ENABLED]: 'true' } } });
+      jest.spyOn(cluster, 'isImportedRke2K3s', 'get').mockReturnValue(true);
+
+      expect(cluster.isImportedWithDayTwoOps).toBeFalsy();
+    });
+
+    it('should return false for imported RKE2 day 2 operations when operation schema is missing', () => {
+      const byId = jest.fn().mockImplementation((type, id) => {
+        if (type === MANAGEMENT.FEATURE && id === IMPORTED_DAY_2_OPS) {
+          return { enabled: true };
+        }
+
+        if (type === MANAGEMENT.SETTING && id === SETTING.IMPORTED_CLUSTER_DAY2_OPS_DEFAULT) {
+          return { value: 'true' };
+        }
+
+        return undefined;
+      });
+      const schemaFor = jest.fn().mockReturnValue(undefined);
+      const cluster = new ProvCluster({}, createContext({ byId, schemaFor }));
+
+      jest.spyOn(cluster, 'mgmt', 'get').mockReturnValue({ metadata: { annotations: { [OPERATION_ANNOTATIONS.ENABLED]: 'true' } } });
+      jest.spyOn(cluster, 'isImportedRke2K3s', 'get').mockReturnValue(true);
+
+      expect(cluster.isImportedWithDayTwoOps).toBeFalsy();
+    });
+
+    it('should filter etcd snapshots by management cluster fields for imported day 2 operations clusters', () => {
+      const snapshots = [
+        {
+          metadata: { namespace: 'c-m-1' },
+          spec:     { clusterName: 'imported-cluster' }
+        },
+        {
+          metadata: { namespace: 'c-m-1' },
+          spec:     { clusterName: 'other-cluster' }
+        },
+        {
+          metadata: { namespace: 'c-m-2' },
+          spec:     { clusterName: 'imported-cluster' }
+        }
+      ];
+      const all = jest.fn().mockReturnValue(snapshots);
+      const cluster = new ProvCluster({}, createContext({ all }));
+
+      jest.spyOn(cluster, 'isImportedWithDayTwoOps', 'get').mockReturnValue(true);
+      jest.spyOn(cluster, 'mgmt', 'get').mockReturnValue({ id: 'c-m-1', metadata: { name: 'imported-cluster' } });
+
+      expect(cluster.etcdSnapshots).toStrictEqual([snapshots[0]]);
+    });
+
+    it('should create an operation CR when taking a snapshot on an imported RKE2 or K3s cluster', () => {
+      const cluster = new ProvCluster({}, createContext());
+
+      (createOperationCR as jest.Mock).mockResolvedValue(undefined);
+
+      jest.spyOn(cluster, 'isRke1', 'get').mockReturnValue(false);
+      jest.spyOn(cluster, 'isImportedWithDayTwoOps', 'get').mockReturnValue(true);
+      jest.spyOn(cluster, 'mgmt', 'get').mockReturnValue({ id: 'c-m-1', metadata: { name: 'imported-cluster' } });
+
+      cluster.takeSnapshot();
+
+      expect(createOperationCR).toHaveBeenCalledTimes(1);
+      expect((createOperationCR as jest.Mock).mock.calls[0][1]).toBe(OPERATION.ETCD_SNAPSHOT);
+      expect((createOperationCR as jest.Mock).mock.calls[0][2]).toStrictEqual({
+        clusterRef: {
+          apiVersion: 'management.cattle.io/v3',
+          kind:       'Cluster',
+          name:       'c-m-1',
+        }
+      });
+      expect((createOperationCR as jest.Mock).mock.calls[0][3]).toBe('c-m-1');
+      expect((createOperationCR as jest.Mock).mock.calls[0][4]).toBe('imported-cluster');
+    });
+  });
 });

package/models/__tests__/rke-machine.cattle.io.vmwarevspheremachinetemplate.test.ts

@@ -0,0 +1,22 @@
+import VmwarevsphereMachineTemplate from '@shell/models/rke-machine.cattle.io.vmwarevspheremachinetemplate';
+
+describe('class VmwarevsphereMachineTemplate', () => {
+  describe('providerLocation', () => {
+    it.each([
+      ['/DC1/host/ClusterA/Resources', 'ClusterA'],
+      ['/DC1/host/ClusterA/Resources/PoolX', 'ClusterA'],
+      ['/DC1/host/ClusterA/Resources/', 'ClusterA'],
+      ['/DC1/host/esxi01/Resources', 'esxi01'],
+      ['/DC1/vm/FolderA', null],
+      ['/DC1/host/foo/ResourcesPool/bar', null],
+      ['/DC1/host//Resources/PoolX', null],
+      ['', null],
+      [null, null],
+      [undefined, null],
+    ])('returns %p for pool %p', (pool: string | null | undefined, expected: string | null) => {
+      const machineTemplate = new VmwarevsphereMachineTemplate({ spec: { template: { spec: { pool } } } });
+
+      expect(machineTemplate.providerLocation).toStrictEqual(expected);
+    });
+  });
+});

package/models/__tests__/secret.test.ts

@@ -1,7 +1,8 @@
 import Secret from '@shell/models/secret';
-import { SECRET_TYPES as TYPES } from '@shell/config/secret';
+import { SECRET_TYPES as TYPES, GITHUB_APP_SECRET_KEYS } from '@shell/config/secret';
 import { VIRTUAL_TYPES } from '@shell/config/types';
 import { UI_PROJECT_SECRET } from '@shell/config/labels-annotations';
+import { base64Encode } from '@shell/utils/crypto';
 
 describe('class Secret', () => {
   describe('detailLocation', () => {
@@ -132,4 +133,70 @@ ${ part }`;
       expect(result).toBe(supported);
     });
   });
+
+  describe('isGithubApp', () => {
+    const githubAppData = {
+      github_app_id:              'MTI=',
+      github_app_installation_id: 'MzQ=',
+      github_app_private_key:     'a2V5',
+    };
+
+    it.each([
+      [
+        false,
+        'type is not Opaque',
+        TYPES.SSH,
+        githubAppData,
+      ],
+      [
+        false,
+        'data is null',
+        TYPES.OPAQUE,
+        null,
+      ],
+      [
+        false,
+        'Opaque but missing a GitHub App key',
+        TYPES.OPAQUE,
+        { github_app_id: 'MTI=', github_app_installation_id: 'MzQ=' },
+      ],
+      [
+        true,
+        'Opaque with all GitHub App keys',
+        TYPES.OPAQUE,
+        githubAppData,
+      ],
+    ])('is %p if %p', (
+      expected,
+      descr,
+      _type,
+      data
+    ) => {
+      const secret = new Secret({ _type, data });
+
+      expect(secret.isGithubApp).toBe(expected);
+    });
+  });
+
+  describe('GitHub App display', () => {
+    const githubAppData = {
+      [GITHUB_APP_SECRET_KEYS.APP_ID]:          base64Encode('12345'),
+      [GITHUB_APP_SECRET_KEYS.INSTALLATION_ID]: base64Encode('67890'),
+      [GITHUB_APP_SECRET_KEYS.PRIVATE_KEY]:     base64Encode('a-private-key'),
+    };
+
+    const ctx = { rootGetters: { 'i18n/withFallback': (_key: string, _args: any, fallback: string) => fallback } };
+
+    it('dataPreview should show the decoded App ID and Installation ID', () => {
+      const secret = new Secret({ _type: TYPES.OPAQUE, data: githubAppData }, ctx);
+
+      expect(secret.dataPreview).toBe('12345 / 67890');
+    });
+
+    it('subTypeDisplay should resolve to the GitHub App label', () => {
+      const secret = new Secret({ _type: TYPES.OPAQUE, data: githubAppData }, ctx);
+
+      expect(secret.subTypeDisplay).toBe('GitHub App');
+    });
+  });
 });