@rancher/shell 3.0.12-rc.3 → 3.0.12-rc.5

package/edit/__tests__/catalog.cattle.io.clusterrepo.test.ts

@@ -0,0 +1,248 @@
+import { shallowMount, VueWrapper } from '@vue/test-utils';
+import CruCatalogRepo from '@shell/edit/catalog.cattle.io.clusterrepo.vue';
+import { _CREATE, _EDIT } from '@shell/config/query-params';
+
+const createEditViewMock = {
+  props: {
+    value: {
+      type:    Object,
+      default: () => ({}),
+    },
+    realMode: {
+      type:    String,
+      default: _CREATE,
+    },
+  },
+  data() {
+    return { errors: [] };
+  },
+  computed: {
+    isCreate:     () => false,
+    isEdit:       () => true,
+    isView:       () => false,
+    schema:       () => ({}),
+    isNamespaced: () => false,
+    labels:       {
+      get: jest.fn(() => ({})),
+      set: jest.fn(),
+    },
+    annotations: {
+      get: jest.fn(() => ({})),
+      set: jest.fn(),
+    },
+    doneRoute:  () => 'mockedRoute',
+    doneParams: () => ({}),
+  },
+  methods: {
+    done:               jest.fn(),
+    conflict:           jest.fn(() => Promise.resolve([])),
+    save:               jest.fn(() => Promise.resolve()),
+    actuallySave:       jest.fn(() => Promise.resolve()),
+    setErrors:          jest.fn(),
+    registerBeforeHook: jest.fn(),
+  }
+};
+
+jest.mock('@shell/config/version', () => ({ getVersionData: () => ({ RancherPrime: 'false' }) }));
+jest.mock('@shell/utils/require-asset', () => ({ requireAsset: (path: string) => path }));
+
+const defaultGlobalMocks = {
+  $store: {
+    getters: {
+      'i18n/t':       (key: string) => key,
+      currentProduct: { inStore: 'cluster' },
+      'cluster/byId': () => null,
+      'cluster/all':  () => [],
+    },
+    dispatch: jest.fn(),
+  },
+  $route: {
+    name:  'test-route',
+    query: {},
+  },
+  $fetchState: { pending: false },
+};
+
+const createWrapper = (specOverrides = {}, mode = _EDIT): VueWrapper<any> => {
+  return shallowMount(CruCatalogRepo, {
+    props: {
+      value: {
+        spec:                      { url: 'https://test.com', ...specOverrides },
+        isOciType:                 false,
+        isSuseAppCollectionFromUI: false,
+        metadata:                  { name: 'test-repo', annotations: {} },
+      },
+      realMode: mode,
+    },
+    mixins: [createEditViewMock],
+    global: {
+      mocks: defaultGlobalMocks,
+      stubs: {
+        AsyncButton:              true,
+        Footer:                   true,
+        NameNsDescription:        true,
+        Labels:                   true,
+        SelectOrCreateAuthSecret: true,
+        Banner:                   true,
+        RcItemCard:               true,
+        UnitInput:                true,
+      },
+    },
+  });
+};
+
+describe('CruCatalogRepo - refresh interval', () => {
+  describe('initial state', () => {
+    it('defaults to enabled with null display value when no refreshInterval is set', () => {
+      const wrapper = createWrapper();
+
+      expect(wrapper.vm.refreshEnabled).toStrictEqual(true);
+      expect(wrapper.vm.refreshDisplayValue).toStrictEqual(null);
+      expect(wrapper.vm.refreshUnit).toStrictEqual(3600);
+    });
+
+    it('parses existing refreshInterval into display value and unit', () => {
+      const wrapper = createWrapper({ refreshInterval: 7200 });
+
+      expect(wrapper.vm.refreshEnabled).toStrictEqual(true);
+      expect(wrapper.vm.refreshDisplayValue).toStrictEqual(2);
+      expect(wrapper.vm.refreshUnit).toStrictEqual(3600);
+    });
+
+    it('parses refreshInterval that maps to minutes', () => {
+      const wrapper = createWrapper({ refreshInterval: 300 });
+
+      expect(wrapper.vm.refreshEnabled).toStrictEqual(true);
+      expect(wrapper.vm.refreshDisplayValue).toStrictEqual(5);
+      expect(wrapper.vm.refreshUnit).toStrictEqual(60);
+    });
+
+    it('parses refreshInterval that maps to days', () => {
+      const wrapper = createWrapper({ refreshInterval: 172800 });
+
+      expect(wrapper.vm.refreshEnabled).toStrictEqual(true);
+      expect(wrapper.vm.refreshDisplayValue).toStrictEqual(2);
+      expect(wrapper.vm.refreshUnit).toStrictEqual(86400);
+    });
+
+    it('parses refreshInterval that maps to seconds', () => {
+      const wrapper = createWrapper({ refreshInterval: 45 });
+
+      expect(wrapper.vm.refreshEnabled).toStrictEqual(true);
+      expect(wrapper.vm.refreshDisplayValue).toStrictEqual(45);
+      expect(wrapper.vm.refreshUnit).toStrictEqual(1);
+    });
+
+    it('sets refreshEnabled to false when refreshInterval is -1', () => {
+      const wrapper = createWrapper({ refreshInterval: -1 });
+
+      expect(wrapper.vm.refreshEnabled).toStrictEqual(false);
+      expect(wrapper.vm.refreshDisplayValue).toStrictEqual(null);
+    });
+  });
+
+  describe('syncRefreshIntervalToSpec', () => {
+    it('sets spec.refreshInterval to -1 when disabled', () => {
+      const wrapper = createWrapper();
+
+      wrapper.vm.onRefreshEnabledChange(false);
+
+      expect(wrapper.vm.value.spec.refreshInterval).toStrictEqual(-1);
+    });
+
+    it('deletes spec.refreshInterval when input is empty', () => {
+      const wrapper = createWrapper({ refreshInterval: 3600 });
+
+      wrapper.vm.onRefreshValueChange('');
+
+      expect(wrapper.vm.value.spec.refreshInterval).toStrictEqual(undefined);
+    });
+
+    it('deletes spec.refreshInterval when input is 0', () => {
+      const wrapper = createWrapper({ refreshInterval: 3600 });
+
+      wrapper.vm.onRefreshValueChange('0');
+
+      expect(wrapper.vm.value.spec.refreshInterval).toStrictEqual(undefined);
+    });
+
+    it('converts display value and unit to seconds on spec', () => {
+      const wrapper = createWrapper();
+
+      wrapper.vm.onRefreshValueChange('5');
+
+      expect(wrapper.vm.value.spec.refreshInterval).toStrictEqual(5 * 3600);
+    });
+
+    it('recalculates when unit changes', () => {
+      const wrapper = createWrapper();
+
+      wrapper.vm.onRefreshValueChange('2');
+      wrapper.vm.onRefreshUnitChange(60);
+
+      expect(wrapper.vm.value.spec.refreshInterval).toStrictEqual(120);
+    });
+
+    it('recalculates when re-enabled', () => {
+      const wrapper = createWrapper();
+
+      wrapper.vm.onRefreshValueChange('10');
+      wrapper.vm.onRefreshEnabledChange(false);
+
+      expect(wrapper.vm.value.spec.refreshInterval).toStrictEqual(-1);
+
+      wrapper.vm.onRefreshEnabledChange(true);
+
+      expect(wrapper.vm.value.spec.refreshInterval).toStrictEqual(10 * 3600);
+    });
+  });
+
+  describe('onRefreshValueChange', () => {
+    it('normalizes empty string to null', () => {
+      const wrapper = createWrapper();
+
+      wrapper.vm.onRefreshValueChange('');
+
+      expect(wrapper.vm.refreshDisplayValue).toStrictEqual(null);
+    });
+
+    it('normalizes null to null', () => {
+      const wrapper = createWrapper();
+
+      wrapper.vm.onRefreshValueChange(null);
+
+      expect(wrapper.vm.refreshDisplayValue).toStrictEqual(null);
+    });
+
+    it('coerces string value to number', () => {
+      const wrapper = createWrapper();
+
+      wrapper.vm.onRefreshValueChange('42');
+
+      expect(wrapper.vm.refreshDisplayValue).toStrictEqual(42);
+    });
+  });
+
+  describe('validation', () => {
+    it('returns error for negative values', () => {
+      const wrapper = createWrapper();
+      const rule = wrapper.vm.refreshIntervalRules[0];
+
+      expect(rule(-1)).toBeDefined();
+    });
+
+    it('returns undefined for zero', () => {
+      const wrapper = createWrapper();
+      const rule = wrapper.vm.refreshIntervalRules[0];
+
+      expect(rule(0)).toStrictEqual(undefined);
+    });
+
+    it('returns undefined for positive values', () => {
+      const wrapper = createWrapper();
+      const rule = wrapper.vm.refreshIntervalRules[0];
+
+      expect(rule(5)).toStrictEqual(undefined);
+    });
+  });
+});

package/edit/__tests__/fleet.cattle.io.gitrepo.test.ts

@@ -1,6 +1,7 @@
 import { mount } from '@vue/test-utils';
 import { _CREATE, _EDIT, _VIEW } from '@shell/config/query-params';
 import { AUTH_TYPE } from '@shell/config/types';
+import { base64Encode } from '@shell/utils/crypto';
 import GitRepo from '@shell/models/fleet.cattle.io.gitrepo';
 import GitRepoComponent from '@shell/edit/fleet.cattle.io.gitrepo.vue';
 
@@ -327,3 +328,94 @@ describe('view: fleet.cattle.io.gitrepo, GitHub password banner - should', () =>
     expect(githubBanner.exists()).toBe(shouldShowBanner);
   });
 });
+
+describe('view: fleet.cattle.io.gitrepo, GitHub App auth - should', () => {
+  const originalDispatch = mockStore.dispatch;
+
+  afterEach(() => {
+    mockStore.dispatch = originalDispatch;
+  });
+
+  it('create an Opaque secret with the GitHub App data keys on doCreate', async() => {
+    const fakeSecret: any = {
+      metadata: { name: 'gitrepo-auth-abc' },
+      save:     jest.fn().mockResolvedValue(undefined),
+    };
+
+    mockStore.dispatch = jest.fn().mockResolvedValue(fakeSecret);
+
+    const wrapper = mount(GitRepoComponent, initGitRepo({ mode: _CREATE }));
+
+    await (wrapper.vm as any).doCreate('clientSecretName', {
+      selected:                AUTH_TYPE._GITHUB_APP,
+      githubAppId:             'app-id',
+      githubAppInstallationId: 'install-id',
+      githubAppPrivateKey:     'private-key',
+    });
+
+    expect(fakeSecret._type).toBe('Opaque');
+    expect(fakeSecret.data).toStrictEqual({
+      github_app_id:              base64Encode('app-id'),
+      github_app_installation_id: base64Encode('install-id'),
+      github_app_private_key:     base64Encode('private-key'),
+    });
+    expect(fakeSecret.save).toHaveBeenCalledWith();
+  });
+});
+
+describe('view: fleet.cattle.io.gitrepo, beforeNext dryRun validation', () => {
+  it('should call dryRunCreate when leaving stepMetadata in create mode', async() => {
+    const wrapper = mount(GitRepoComponent, initGitRepo({ mode: _CREATE }));
+    const vm = wrapper.vm as any;
+
+    vm.value.dryRunCreate = jest.fn().mockResolvedValue({});
+
+    await vm.beforeNext({ name: 'stepMetadata' });
+
+    expect(vm.value.dryRunCreate).toHaveBeenCalledWith(expect.objectContaining({
+      type:     'fleet.cattle.io.gitrepo',
+      metadata: expect.objectContaining({
+        name:      'test',
+        namespace: 'test',
+      }),
+      spec: expect.objectContaining({ repo: 'https://example.com/placeholder' }),
+    }));
+  });
+
+  it('should not call dryRunCreate for non-metadata steps', async() => {
+    const wrapper = mount(GitRepoComponent, initGitRepo({ mode: _CREATE }));
+    const vm = wrapper.vm as any;
+
+    vm.value.dryRunCreate = jest.fn();
+
+    await vm.beforeNext({ name: 'stepRepo' });
+
+    expect(vm.value.dryRunCreate).not.toHaveBeenCalled();
+  });
+
+  it('should not call dryRunCreate in edit mode', async() => {
+    const wrapper = mount(GitRepoComponent, initGitRepo({ mode: _EDIT }));
+    const vm = wrapper.vm as any;
+
+    vm.value.dryRunCreate = jest.fn();
+
+    await vm.beforeNext({ name: 'stepMetadata' });
+
+    expect(vm.value.dryRunCreate).not.toHaveBeenCalled();
+  });
+
+  it('should reject with API errors when dryRunCreate fails', async() => {
+    const apiError = {
+      _status:    409,
+      message:    'gitrepos.fleet.cattle.io "test" already exists',
+      statusText: 'Conflict',
+    };
+
+    const wrapper = mount(GitRepoComponent, initGitRepo({ mode: _CREATE }));
+    const vm = wrapper.vm as any;
+
+    vm.value.dryRunCreate = jest.fn().mockRejectedValue(apiError);
+
+    await expect(vm.beforeNext({ name: 'stepMetadata' })).rejects.toStrictEqual(apiError);
+  });
+});

package/edit/__tests__/fleet.cattle.io.helmop.test.ts

@@ -28,12 +28,17 @@ const mocks = {
   $fetchState: { pending: false },
   $route:      {
     query: { AS: '' },
+    hash:  '',
     name:  {
       endsWith: () => {
         return false;
       }
     }
   },
+  $router: {
+    currentRoute: { _value: { hash: '' } },
+    replace:      jest.fn(),
+  },
 };
 
 const mockComputed = {
@@ -152,6 +157,106 @@ describe('helmOp component lifecycle', () => {
   });
 });
 
+describe('onCancel', () => {
+  it('should navigate back to the AppCo chart page with version when isSuseAppCollection is true and mode is CREATE', () => {
+    const routerPush = jest.fn();
+    const appCoMocks = {
+      ...mocks,
+      $route: {
+        ...mocks.$route,
+        query: {
+          AS:      '',
+          type:    'suse-application-collection',
+          chart:   'alertmanager',
+          version: '1.37.0',
+          secret:  'fleet-appco-auth-2n9px',
+        },
+        params: { cluster: 'local' },
+      },
+      $router: {
+        ...mocks.$router,
+        push: routerPush,
+      },
+    };
+
+    const wrapper = mount(HelmOpComponent, {
+      ...initHelmOp({ mode: _CREATE, realMode: _CREATE }),
+      computed: {
+        ...mockComputed,
+        isSuseAppCollection: () => true,
+      },
+      global: { mocks: appCoMocks },
+    });
+
+    wrapper.vm.onCancel();
+
+    expect(routerPush).toHaveBeenCalledWith({
+      name:   'c-cluster-fleet-application-appco-chart',
+      params: { cluster: 'local' },
+      query:  {
+        'repo-type': 'cluster',
+        repo:        'fleet-appco-repo-2n9px',
+        chart:       'alertmanager',
+        version:     '1.37.0',
+        secret:      'fleet-appco-auth-2n9px',
+      },
+    });
+  });
+
+  it('should navigate back to the AppCo chart page without version when version is not in query', () => {
+    const routerPush = jest.fn();
+    const appCoMocks = {
+      ...mocks,
+      $route: {
+        ...mocks.$route,
+        query: {
+          AS:     '',
+          type:   'suse-application-collection',
+          chart:  'alertmanager',
+          secret: 'fleet-appco-auth-2n9px',
+        },
+        params: { cluster: 'local' },
+      },
+      $router: {
+        ...mocks.$router,
+        push: routerPush,
+      },
+    };
+
+    const wrapper = mount(HelmOpComponent, {
+      ...initHelmOp({ mode: _CREATE, realMode: _CREATE }),
+      computed: {
+        ...mockComputed,
+        isSuseAppCollection: () => true,
+      },
+      global: { mocks: appCoMocks },
+    });
+
+    wrapper.vm.onCancel();
+
+    expect(routerPush).toHaveBeenCalledWith({
+      name:   'c-cluster-fleet-application-appco-chart',
+      params: { cluster: 'local' },
+      query:  {
+        'repo-type': 'cluster',
+        repo:        'fleet-appco-repo-2n9px',
+        chart:       'alertmanager',
+        version:     undefined,
+        secret:      'fleet-appco-auth-2n9px',
+      },
+    });
+  });
+
+  it('should call done() when not a SuseAppCollection', () => {
+    const wrapper = mount(HelmOpComponent, initHelmOp({ mode: _CREATE, realMode: _CREATE }));
+
+    jest.spyOn(wrapper.vm, 'done').mockImplementation(jest.fn());
+    wrapper.vm.onCancel();
+
+    expect(wrapper.vm.done).toHaveBeenCalledWith();
+  });
+});
+
 describe.each([
   _CREATE,
   _EDIT,
@@ -316,6 +421,12 @@ describe.each([
     expect(wrapper.vm.value.spec.downstreamResources).toStrictEqual([{ name: 'configMap2', kind: 'ConfigMap' }, { name: 'configMap3', kind: 'ConfigMap' }]);
   });
 
+  it('should have a beforeNext method', () => {
+    const wrapper = mount(HelmOpComponent, initHelmOp({ mode }));
+
+    expect(typeof wrapper.vm.beforeNext).toBe('function');
+  });
+
   if (mode === _CREATE) {
     it('should set created-by-user-id label when updateBeforeSave is called in CREATE mode', () => {
       const mockCurrentUser = { id: 'user-123' };
@@ -370,3 +481,98 @@ describe.each([
     });
   }
 });
+
+describe('view: fleet.cattle.io.helmop, beforeNext dryRun validation', () => {
+  const initHelmOpWithMetadata = (props: any) => {
+    const value = new HelmOp({
+      ...mockHelmOp,
+      metadata: {
+        name:      'test-helmop',
+        namespace: 'fleet-default',
+      },
+    }, {
+      getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+      dispatch:    jest.fn(),
+      rootGetters: { 'i18n/t': jest.fn() },
+    });
+
+    value.applyDefaults = () => {};
+
+    return {
+      props: {
+        value,
+        ...props
+      },
+      provide: {
+        store: createStore({
+          getters: {
+            currentStore:                   () => 'current_store',
+            'management/paginationEnabled': () => () => false
+          }
+        })
+      },
+      computed: mockComputed,
+      global:   { mocks },
+    };
+  };
+
+  it('should call dryRunCreate when leaving basics step in create mode', async() => {
+    const wrapper = mount(HelmOpComponent, initHelmOpWithMetadata({ mode: _CREATE }));
+    const vm = wrapper.vm as any;
+
+    vm.value.dryRunCreate = jest.fn().mockResolvedValue({});
+
+    await vm.beforeNext({ name: 'basics' });
+
+    expect(vm.value.dryRunCreate).toHaveBeenCalledWith(expect.objectContaining({
+      type:     'fleet.cattle.io.helmop',
+      metadata: expect.objectContaining({
+        name:      'test-helmop',
+        namespace: 'fleet-default',
+      }),
+      spec: expect.objectContaining({
+        helm: expect.objectContaining({
+          chart: 'placeholder',
+          repo:  'https://example.com',
+        }),
+      }),
+    }));
+  });
+
+  it('should not call dryRunCreate for non-basics steps', async() => {
+    const wrapper = mount(HelmOpComponent, initHelmOpWithMetadata({ mode: _CREATE }));
+    const vm = wrapper.vm as any;
+
+    vm.value.dryRunCreate = jest.fn();
+
+    await vm.beforeNext({ name: 'chart' });
+
+    expect(vm.value.dryRunCreate).not.toHaveBeenCalled();
+  });
+
+  it('should not call dryRunCreate in edit mode', async() => {
+    const wrapper = mount(HelmOpComponent, initHelmOpWithMetadata({ mode: _EDIT }));
+    const vm = wrapper.vm as any;
+
+    vm.value.dryRunCreate = jest.fn();
+
+    await vm.beforeNext({ name: 'basics' });
+
+    expect(vm.value.dryRunCreate).not.toHaveBeenCalled();
+  });
+
+  it('should reject with API errors when dryRunCreate fails', async() => {
+    const apiError = {
+      _status:    409,
+      message:    'helmops.fleet.cattle.io "test-helmop" already exists',
+      statusText: 'Conflict',
+    };
+
+    const wrapper = mount(HelmOpComponent, initHelmOpWithMetadata({ mode: _CREATE }));
+    const vm = wrapper.vm as any;
+
+    vm.value.dryRunCreate = jest.fn().mockRejectedValue(apiError);
+
+    await expect(vm.beforeNext({ name: 'basics' })).rejects.toStrictEqual(apiError);
+  });
+});

package/edit/__tests__/management.cattle.io.setting.test.ts

@@ -1,5 +1,5 @@
 import { mount } from '@vue/test-utils';
-import Settings from '@shell/edit/management.cattle.io.setting.vue';
+import Settings from '@shell/edit/management.cattle.io.setting/index.vue';
 import { SETTING } from '@shell/config/settings';
 
 const requiredSetup = () => ({
@@ -18,6 +18,7 @@ const requiredSetup = () => ({
       },
       $route:  { query: { AS: '' } },
       $router: { applyQuery: jest.fn() },
+      t:       (key: string) => key,
     }
   }
 });

package/edit/auditlog.cattle.io.auditpolicy/__tests__/__snapshots__/General.test.ts.snap

@@ -21,6 +21,7 @@ exports[`component: General rendering & initial state should render with default
           labelkey="auditPolicy.general.enabled.checkbox"
           mode="create"
           primary="false"
+          usebodytextcolor="false"
           value="false"
           valuewhentrue="true"
         />
@@ -71,6 +72,7 @@ exports[`component: General rendering & initial state should render with default
               label="auditPolicy.general.verbosity.level.label"
               loading="false"
               localizedlabel="false"
+              lockedoptions=""
               mode="create"
               nooptionslabelkey="labelSelect.noOptions.empty"
               optionlabel="label"
@@ -112,6 +114,7 @@ exports[`component: General rendering & initial state should render with default
                 label="auditPolicy.general.verbosity.request.requestHeaders"
                 mode="create"
                 primary="false"
+                usebodytextcolor="false"
                 value="false"
                 valuewhentrue="true"
               />
@@ -127,6 +130,7 @@ exports[`component: General rendering & initial state should render with default
                 label="auditPolicy.general.verbosity.request.requestBody"
                 mode="create"
                 primary="false"
+                usebodytextcolor="false"
                 value="false"
                 valuewhentrue="true"
               />
@@ -152,6 +156,7 @@ exports[`component: General rendering & initial state should render with default
                 label="auditPolicy.general.verbosity.response.responseHeaders"
                 mode="create"
                 primary="false"
+                usebodytextcolor="false"
                 value="false"
                 valuewhentrue="true"
               />
@@ -167,6 +172,7 @@ exports[`component: General rendering & initial state should render with default
                 label="auditPolicy.general.verbosity.response.responseBody"
                 mode="create"
                 primary="false"
+                usebodytextcolor="false"
                 value="false"
                 valuewhentrue="true"
               />

package/edit/auditlog.cattle.io.auditpolicy/__tests__/__snapshots__/index.test.ts.snap

@@ -19,6 +19,7 @@ exports[`component: CRUAuditPolicy (index) rendering & initial state should rend
     prevententersubmit="false"
     resource="[object Object]"
     showcancel="true"
+    showtoc="false"
     steps=""
     stepsoptions="[object Object]"
     subtypes=""