@rancher/shell 0.5.2 → 0.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rancher/shell",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Rancher Dashboard Shell",
   "repository": "https://github.com/rancherlabs/dashboard",
   "license": "Apache-2.0",

package/pages/c/_cluster/settings/DefaultLinksEditor.vue

@@ -81,6 +81,7 @@ export default {
             v-if="!isView"
             v-model="row.enabled"
             label-key="customLinks.settings.showLabel"
+            :data-testid="`custom-links__checkbox-${i}`"
             @input="showhide(row, i, $event)"
           />
         </div>

package/pages/c/_cluster/settings/brand.vue

@@ -238,6 +238,7 @@ export default {
             <label class="text-muted">{{ t('branding.logos.lightPreview') }}</label>
             <img
               class="logo-preview"
+              data-testid="branding-logo-light-preview"
               :src="uiLogoLight ? uiLogoLight : uiLogoDark"
             >
           </SimpleBox>
@@ -262,6 +263,7 @@ export default {
             <label class="text-muted">{{ t('branding.logos.darkPreview') }}</label>
             <img
               class="logo-preview"
+              data-testid="branding-logo-dark-preview"
               :src="uiLogoDark ? uiLogoDark : uiLogoLight"
             >
           </SimpleBox>
@@ -304,6 +306,7 @@ export default {
             <label class="text-muted">{{ t('branding.favicon.preview') }}</label>
             <img
               class="logo-preview"
+              data-testid="branding-favicon-preview"
               :src="uiFavicon"
             >
           </SimpleBox>

package/pages/c/_cluster/uiplugins/AddExtensionRepos.vue

@@ -10,6 +10,7 @@ import {
   UI_PLUGINS_PARTNERS_REPO_URL,
   UI_PLUGINS_PARTNERS_REPO_BRANCH,
 } from '@shell/config/uiplugins';
+import { isRancherPrime } from '@shell/config/version';
 
 export default {
   components: {
@@ -27,6 +28,7 @@ export default {
     return {
       errors:   [],
       repos:    [],
+      prime:    isRancherPrime(),
       addRepos: {
         official: true,
         partners: true
@@ -54,16 +56,13 @@ export default {
     },
     hasRancherUIPartnersPluginsRepo() {
       return !!this.repos.find((r) => r.urlDisplay === UI_PLUGINS_PARTNERS_REPO_URL);
-    },
-    isAnyRepoAvailableForInstall() {
-      return !this.hasRancherUIPluginsRepo || !this.hasRancherUIPartnersPluginsRepo;
     }
   },
 
   methods: {
     showDialog() {
       this.addRepos = {
-        official: !this.hasRancherUIPluginsRepo,
+        official: isRancherPrime() && !this.hasRancherUIPluginsRepo,
         partners: !this.hasRancherUIPartnersPluginsRepo,
       };
       this.$modal.show('add-extensions-repos');
@@ -121,6 +120,7 @@ export default {
       </p>
       <!-- Official repo -->
       <div
+        v-if="prime"
         class="mb-15"
       >
         <Checkbox

package/pages/c/_cluster/uiplugins/SetupUIPlugins.vue

@@ -7,6 +7,7 @@ import { CATALOG as CATALOG_ANNOTATIONS } from '@shell/config/labels-annotations
 import Dialog from '@shell/components/Dialog.vue';
 import Checkbox from '@components/Form/Checkbox/Checkbox.vue';
 import Banner from '@components/Banner/Banner.vue';
+import { isRancherPrime } from '@shell/config/version';
 
 import {
   UI_PLUGIN_NAMESPACE,
@@ -68,6 +69,7 @@ export default {
       haveCharts:    false,
       installCharts: [],
       errors:        [],
+      prime:         isRancherPrime(),
       addRepos:      {
         official: true,
         partners: true,
@@ -98,7 +100,7 @@ export default {
       return !!this.repos.find((r) => r.urlDisplay === UI_PLUGINS_PARTNERS_REPO_URL);
     },
     isAnyRepoAvailableForInstall() {
-      return !this.hasRancherUIPluginsRepo || !this.hasRancherUIPartnersPluginsRepo;
+      return (isRancherPrime() && !this.hasRancherUIPluginsRepo) || !this.hasRancherUIPartnersPluginsRepo;
     }
   },
 
@@ -155,7 +157,7 @@ export default {
 
       // Reset checkbox based on if the repo is already installed
       this.addRepos = {
-        official: !this.hasRancherUIPluginsRepo,
+        official: isRancherPrime() && !this.hasRancherUIPluginsRepo,
         partners: !this.hasRancherUIPartnersPluginsRepo,
       };
 
@@ -286,6 +288,7 @@ export default {
         </Banner>
         <!-- Official rancher repo -->
         <div
+          v-if="prime"
           class="mb-15"
         >
           <Checkbox

package/pages/c/_cluster/uiplugins/__tests__/AddExtensionRepos.test.ts

@@ -0,0 +1,96 @@
+import { mount } from '@vue/test-utils';
+import {
+  UI_PLUGINS_REPO_URL,
+  UI_PLUGINS_PARTNERS_REPO_URL,
+} from '@shell/config/uiplugins';
+import AddExtensionRepos from '@shell/pages/c/_cluster/uiplugins/AddExtensionRepos.vue';
+const mockedStore = () => {
+  return {
+    getters: {
+      'i18n/t':               (text: string) => text,
+      'i18n/exists':          (text: string) => text,
+      t:                      (text: string) => text,
+      'management/schemaFor': () => true,
+      'management/findAll':   () => [
+        { urlDisplay: UI_PLUGINS_REPO_URL },
+        { urlDisplay: UI_PLUGINS_PARTNERS_REPO_URL },
+      ]
+    }
+  };
+};
+
+const requiredSetup = () => {
+  return {
+    mocks: {
+      $store:      mockedStore(),
+      $fetchState: {},
+    }
+  };
+};
+
+describe('component: AddExtensionRepos', () => {
+  it('should NOT SHOW a checkbox to install official Rancher repo if NOT prime', async() => {
+    jest.useFakeTimers();
+
+    const wrapper = mount(AddExtensionRepos, {
+      ...requiredSetup(),
+      // since vue-js-modal uses transitions, we need disable
+      // the default behaviour of transition-stubbing that vue-test-utils has...
+      stubs: { transition: false }
+    });
+
+    wrapper.vm.showDialog();
+
+    // these couple of nextTick + advanceTimersByTime are needed for
+    // the dialog content to be rendered!
+    await wrapper.vm.$nextTick();
+
+    jest.advanceTimersByTime(1);
+
+    await wrapper.vm.$nextTick();
+
+    jest.advanceTimersByTime(1);
+
+    const rancherCheckbox = wrapper.find('[data-testid="add-extensions-repos-modal-add-official-repo"]');
+    const partnersCheckbox = wrapper.find('[data-testid="add-extensions-repos-modal-add-partners-repo"]');
+
+    expect(rancherCheckbox.exists()).toBe(false);
+    expect(partnersCheckbox.exists()).toBe(true);
+
+    jest.clearAllTimers();
+    wrapper.destroy();
+  });
+
+  it('should SHOW a checkbox to install official Rancher repo if IS prime', async() => {
+    jest.useFakeTimers();
+
+    const wrapper = mount(AddExtensionRepos, {
+      ...requiredSetup(),
+      // since vue-js-modal uses transitions, we need disable
+      // the default behaviour of transition-stubbing that vue-test-utils has...
+      stubs: { transition: false }
+    });
+
+    wrapper.vm.prime = true;
+    wrapper.vm.showDialog();
+
+    // these couple of nextTick + advanceTimersByTime are needed for
+    // the dialog content to be rendered!
+    await wrapper.vm.$nextTick();
+
+    jest.advanceTimersByTime(1);
+
+    await wrapper.vm.$nextTick();
+
+    jest.advanceTimersByTime(1);
+
+    const rancherCheckbox = wrapper.find('[data-testid="add-extensions-repos-modal-add-official-repo"]');
+    const partnersCheckbox = wrapper.find('[data-testid="add-extensions-repos-modal-add-partners-repo"]');
+
+    expect(rancherCheckbox.exists()).toBe(true);
+    expect(partnersCheckbox.exists()).toBe(true);
+
+    jest.clearAllTimers();
+    wrapper.destroy();
+  });
+});

package/pages/c/_cluster/uiplugins/__tests__/SetupUIPlugins.test.ts

@@ -0,0 +1,128 @@
+import { mount, createLocalVue } from '@vue/test-utils';
+import Vuex from 'vuex';
+import {
+  UI_PLUGINS_REPO_URL,
+  UI_PLUGINS_PARTNERS_REPO_URL,
+} from '@shell/config/uiplugins';
+import SetupUIPlugins from '@shell/pages/c/_cluster/uiplugins/SetupUIPlugins.vue';
+
+describe('component: SetupUIPlugins', () => {
+  const localVue = createLocalVue();
+
+  localVue.use(Vuex);
+
+  it('should NOT SHOW a checkbox to install official Rancher repo if NOT prime', async() => {
+    const store = new Vuex.Store({
+      modules: {
+        catalog: {
+          namespaced: true,
+          getters:    {
+            repos: () => [
+              { urlDisplay: UI_PLUGINS_REPO_URL },
+              { urlDisplay: UI_PLUGINS_PARTNERS_REPO_URL },
+            ],
+            repo:      () => {},
+            rawCharts: () => [],
+          }
+        }
+      },
+      getters: {
+        'i18n/t':               () => jest.fn(),
+        'i18n/exists':          () => jest.fn(),
+        t:                      () => jest.fn(),
+        'management/schemaFor': () => true,
+        'management/findAll':   () => [],
+        'management/find':      () => {}
+      }
+    });
+
+    jest.useFakeTimers();
+
+    const wrapper = mount(SetupUIPlugins, {
+      store,
+      localVue,
+      // since vue-js-modal uses transitions, we need disable
+      // the default behaviour of transition-stubbing that vue-test-utils has...
+      stubs: { transition: false }
+    });
+
+    wrapper.vm.enable();
+
+    // these couple of nextTick + advanceTimersByTime are needed for
+    // the dialog content to be rendered!
+    await wrapper.vm.$nextTick();
+
+    jest.advanceTimersByTime(1);
+
+    await wrapper.vm.$nextTick();
+
+    jest.advanceTimersByTime(1);
+
+    const rancherCheckbox = wrapper.find('[data-testid="extension-enable-operator-official-repo"]');
+    const partnersCheckbox = wrapper.find('[data-testid="extension-enable-operator-partners-repo"]');
+
+    expect(rancherCheckbox.exists()).toBe(false);
+    expect(partnersCheckbox.exists()).toBe(true);
+
+    jest.clearAllTimers();
+    wrapper.destroy();
+  });
+
+  it('should SHOW a checkbox to install official Rancher repo if IS prime', async() => {
+    const store = new Vuex.Store({
+      modules: {
+        catalog: {
+          namespaced: true,
+          getters:    {
+            repos: () => [
+              { urlDisplay: UI_PLUGINS_REPO_URL },
+              { urlDisplay: UI_PLUGINS_PARTNERS_REPO_URL },
+            ],
+            repo:      () => {},
+            rawCharts: () => [],
+          }
+        }
+      },
+      getters: {
+        'i18n/t':               () => jest.fn(),
+        'i18n/exists':          () => jest.fn(),
+        t:                      () => jest.fn(),
+        'management/schemaFor': () => true,
+        'management/findAll':   () => [],
+        'management/find':      () => {}
+      }
+    });
+
+    jest.useFakeTimers();
+
+    const wrapper = mount(SetupUIPlugins, {
+      store,
+      localVue,
+      // since vue-js-modal uses transitions, we need disable
+      // the default behaviour of transition-stubbing that vue-test-utils has...
+      stubs: { transition: false }
+    });
+
+    wrapper.vm.prime = true;
+    wrapper.vm.enable();
+
+    // these couple of nextTick + advanceTimersByTime are needed for
+    // the dialog content to be rendered!
+    await wrapper.vm.$nextTick();
+
+    jest.advanceTimersByTime(1);
+
+    await wrapper.vm.$nextTick();
+
+    jest.advanceTimersByTime(1);
+
+    const rancherCheckbox = wrapper.find('[data-testid="extension-enable-operator-official-repo"]');
+    const partnersCheckbox = wrapper.find('[data-testid="extension-enable-operator-partners-repo"]');
+
+    expect(rancherCheckbox.exists()).toBe(true);
+    expect(partnersCheckbox.exists()).toBe(true);
+
+    jest.clearAllTimers();
+    wrapper.destroy();
+  });
+});

package/plugins/dashboard-store/__tests__/actions.test.ts

@@ -1,127 +1,127 @@
 import _actions from '@shell/plugins/dashboard-store/actions';
 
-const { findAll } = _actions;
+const { findAll, findMatching } = _actions;
 
 describe('dashboard-store: actions', () => {
-  const setupContext = () => {
-    const commit = jest.fn();
-    const dispatch = jest.fn((...args) => {
-      switch (args[0]) {
-      case 'request':
-        return { data: ['requestData'] };
-      }
-    });
-    const state = { config: { namespace: 'unitTest' } };
-    const getters = {
-      normalizeType:    jest.fn(() => 'getters.normalizeType'),
-      typeRegistered:   jest.fn(() => false),
-      haveAll:          jest.fn(() => false),
-      haveAllNamespace: jest.fn(() => false),
-      all:              jest.fn(() => 'getters.all'),
-      urlFor:           jest.fn(() => 'getters.urlFor'), // we're not testing the urlFor getter so we don't need to do anything with opt here
-    };
-    const rootGetters = {
-      'type-map/optionsFor': jest.fn(),
-      'auth/fromHeader':     'foo'
-    };
+  describe('findAll', () => {
+    // Note - there are TS errors alll over this describe and should not have merged with them in.
+    const setupContext = () => {
+      const commit = jest.fn();
+      const dispatch = jest.fn((...args) => {
+        switch (args[0]) {
+        case 'request':
+          return { data: ['requestData'] };
+        }
+      });
+      const state = { config: { namespace: 'unitTest' } };
+      const getters = {
+        normalizeType:    jest.fn(() => 'getters.normalizeType'),
+        typeRegistered:   jest.fn(() => false),
+        haveAll:          jest.fn(() => false),
+        haveAllNamespace: jest.fn(() => false),
+        all:              jest.fn(() => 'getters.all'),
+        urlFor:           jest.fn(() => 'getters.urlFor'), // we're not testing the urlFor getter so we don't need to do anything with opt here
+      };
+      const rootGetters = {
+        'type-map/optionsFor': jest.fn(),
+        'auth/fromHeader':     'foo'
+      };
 
-    // we're not testing function output based off of state or getter inputs here since they are dependencies and should be tested independently
-    return {
-      state,
-      getters,
-      rootGetters,
-      commit,
-      dispatch
+      // we're not testing function output based off of state or getter inputs here since they are dependencies and should be tested independently
+      return {
+        state,
+        getters,
+        rootGetters,
+        commit,
+        dispatch
+      };
     };
-  };
 
-  const standardAssertions = {
-    returnsPromise:
-      {
+    const standardAssertions = {
+      returnsPromise: {
         assertionLabel: 'returns a promise',
         valueGetter:    ({ findAllPromise }) => typeof findAllPromise.then,
         valueExpected:  'function'
       },
-    callsAll: {
-      assertionLabel: 'calls the "all" getter with the normalizedType',
-      valueGetter:    ({ getters }) => getters.all.mock.calls[0][0],
-      valueExpected:  'getters.normalizeType'
-    },
-    returnsFromAll: {
-      assertionLabel: 'returns the value expected from the "all" getter',
-      valueGetter:    ({ findAllReturnValue }) => findAllReturnValue,
-      valueExpected:  'getters.all'
-    },
-    firstDispatchAction: {
-      assertionLabel: 'first dispatch should be the "request" action',
-      valueGetter:    ({ dispatch }) => dispatch.mock.calls[0][0],
-      valueExpected:  'request'
-    },
-    firstDispatchParams: {
-      assertionLabel: 'first dispatch parameters should be provided a normalized type and a url, streaming, and "metadata.managedFields" excluded under opt',
-      valueGetter:    ({ dispatch }) => dispatch.mock.calls[0][1],
-      valueExpected:  {
-        type: 'getters.normalizeType',
-        opt:  {
-          url:    'getters.urlFor',
-          stream: true
-        }
+      callsAll: {
+        assertionLabel: 'calls the "all" getter with the normalizedType',
+        valueGetter:    ({ getters }) => getters.all.mock.calls[0][0],
+        valueExpected:  'getters.normalizeType'
+      },
+      returnsFromAll: {
+        assertionLabel: 'returns the value expected from the "all" getter',
+        valueGetter:    ({ findAllReturnValue }) => findAllReturnValue,
+        valueExpected:  'getters.all'
       },
-      assertionMethod: 'toMatchObject'
-    },
-    secondDispatchAction: {
-      assertionLabel: 'second dispatch should be the "watch" action',
-      valueGetter:    ({ dispatch }) => dispatch.mock.calls[1][0],
-      valueExpected:  'watch'
-    },
-    secondDispatchParams: {
-      assertionLabel:  'second dispatch parameters should have a normalized type and force set to false',
-      valueGetter:     ({ dispatch }) => dispatch.mock.calls[1][1],
-      valueExpected:   { type: 'getters.normalizeType', force: false },
-      assertionMethod: 'toMatchObject'
-    },
-    countDispatches: {
-      assertionLabel:  'should only make two dispatches',
-      valueGetter:     ({ dispatch }) => dispatch.mock.calls,
-      valueExpected:   2,
-      assertionMethod: 'toHaveLength'
-    },
-    firstCommitMutation: {
-      assertionLabel: 'first commit should be the "registerType" mutation',
-      valueGetter:    ({ commit }) => commit.mock.calls[0][0],
-      valueExpected:  'registerType'
-    },
-    firstCommitParams: {
-      assertionLabel: 'first commit parameter should be a normalized type',
-      valueGetter:    ({ commit }) => commit.mock.calls[0][1],
-      valueExpected:  'getters.normalizeType'
-    },
-    secondCommitMutation: {
-      assertionLabel: 'second commit should be the "loadAll" mutation',
-      valueGetter:    ({ commit }) => commit.mock.calls[1][0],
-      valueExpected:  'loadAll'
-    },
-    secondCommitParams: {
-      assertionLabel: 'second commit parameters should have a normalized type, ctx.state.config.namespace, data returned by request, and skipHaveAll set to false',
-      valueGetter:    ({ commit }) => commit.mock.calls[1][1],
-      valueExpected:  {
-        type:        'getters.normalizeType',
-        ctx:         { state: { config: { namespace: 'unitTest' } } },
-        data:        ['requestData'],
-        skipHaveAll: false,
+      firstDispatchAction: {
+        assertionLabel: 'first dispatch should be the "request" action',
+        valueGetter:    ({ dispatch }) => dispatch.mock.calls[0][0],
+        valueExpected:  'request'
+      },
+      firstDispatchParams: {
+        assertionLabel: 'first dispatch parameters should be provided a normalized type and a url, streaming, and "metadata.managedFields" excluded under opt',
+        valueGetter:    ({ dispatch }) => dispatch.mock.calls[0][1],
+        valueExpected:  {
+          type: 'getters.normalizeType',
+          opt:  {
+            url:    'getters.urlFor',
+            stream: true
+          }
+        },
+        assertionMethod: 'toMatchObject'
+      },
+      secondDispatchAction: {
+        assertionLabel: 'second dispatch should be the "watch" action',
+        valueGetter:    ({ dispatch }) => dispatch.mock.calls[1][0],
+        valueExpected:  'watch'
+      },
+      secondDispatchParams: {
+        assertionLabel:  'second dispatch parameters should have a normalized type and force set to false',
+        valueGetter:     ({ dispatch }) => dispatch.mock.calls[1][1],
+        valueExpected:   { type: 'getters.normalizeType', force: false },
+        assertionMethod: 'toMatchObject'
+      },
+      countDispatches: {
+        assertionLabel:  'should only make two dispatches',
+        valueGetter:     ({ dispatch }) => dispatch.mock.calls,
+        valueExpected:   2,
+        assertionMethod: 'toHaveLength'
+      },
+      firstCommitMutation: {
+        assertionLabel: 'first commit should be the "registerType" mutation',
+        valueGetter:    ({ commit }) => commit.mock.calls[0][0],
+        valueExpected:  'registerType'
+      },
+      firstCommitParams: {
+        assertionLabel: 'first commit parameter should be a normalized type',
+        valueGetter:    ({ commit }) => commit.mock.calls[0][1],
+        valueExpected:  'getters.normalizeType'
+      },
+      secondCommitMutation: {
+        assertionLabel: 'second commit should be the "loadAll" mutation',
+        valueGetter:    ({ commit }) => commit.mock.calls[1][0],
+        valueExpected:  'loadAll'
+      },
+      secondCommitParams: {
+        assertionLabel: 'second commit parameters should have a normalized type, ctx.state.config.namespace, data returned by request, and skipHaveAll set to false',
+        valueGetter:    ({ commit }) => commit.mock.calls[1][1],
+        valueExpected:  {
+          type:        'getters.normalizeType',
+          ctx:         { state: { config: { namespace: 'unitTest' } } },
+          data:        ['requestData'],
+          skipHaveAll: false,
+        },
+        assertionMethod: 'toMatchObject'
       },
-      assertionMethod: 'toMatchObject'
-    },
-    countCommits: {
-      assertionLabel:  'should only make two commits',
-      valueGetter:     ({ commit }) => commit.mock.calls,
-      valueExpected:   2,
-      assertionMethod: 'toHaveLength'
-    }
-
-  };
-
-  describe('dashboard-store > actions > findAll', () => {
+      countCommits: {
+        assertionLabel:  'should only make two commits',
+        valueGetter:     ({ commit }) => commit.mock.calls,
+        valueExpected:   2,
+        assertionMethod: 'toHaveLength'
+      }
+
+    };
+
     describe('called without a cache for the type in the second param', () => {
       const {
         dispatch, commit, getters, rootGetters, state
@@ -162,4 +162,89 @@ describe('dashboard-store: actions', () => {
       );
     });
   });
+
+  describe('findMatching', () => {
+    const setupContext = () => {
+      const commit = jest.fn();
+      const dispatch = jest.fn(() => 'dispatch');
+
+      const state = { config: { namespace: 'unitTest' } };
+      const getters = {
+        normalizeType:  jest.fn((type) => type),
+        typeRegistered: jest.fn(() => true),
+        haveSelector:   jest.fn(() => false),
+        matching:       jest.fn(() => 'getters.all'),
+        urlFor:         jest.fn(() => 'getters.urlFor'),
+        urlOptions:     jest.fn(() => 'getters.urlOptions')
+      };
+      const rootGetters = { 'type-map/optionsFor': jest.fn() };
+
+      // we're not testing function output based off of state or getter inputs here since they are dependencies and should be tested independently
+      return {
+        state,
+        getters,
+        rootGetters,
+        commit,
+        dispatch
+      };
+    };
+    const genericType = 'services';
+    const genericSelector = 'a=b';
+    const genericOpt = {};
+
+    const assertionChain = [{
+      assertionLabel: 'Basic Selector',
+      input:          {
+        type:      genericType,
+        selector:  genericSelector,
+        opt:       { ...genericOpt },
+        namespace: undefined
+      },
+      output: {
+        getters: {
+          urlFor: [
+            genericType,
+            null,
+            {
+              ...genericOpt,
+              depaginate:    undefined,
+              labelSelector: genericSelector,
+              url:           'getters.urlFor',
+            }
+          ]
+        },
+        actions: {
+          request: {
+            opt:  {},
+            type: genericType
+          }
+        }
+      }
+    }];
+
+    const {
+      dispatch,
+      commit,
+      getters,
+      rootGetters,
+      state
+    } = setupContext();
+
+    it.each(assertionChain)(
+      '$assertionLabel',
+      async({ input, output }) => {
+        await findMatching(
+          {
+            dispatch,
+            getters,
+            rootGetters,
+            state,
+            commit,
+          },
+          input
+        );
+        expect(getters.urlFor).toHaveBeenCalledWith(...output.getters.urlFor);
+      }
+    );
+  });
 });