@rancher/shell 3.0.5-rc.3 → 3.0.5-rc.6

package/mixins/__tests__/brand.spec.ts

@@ -0,0 +1,170 @@
+import { mount } from '@vue/test-utils';
+import { CATALOG, MANAGEMENT } from '@shell/config/types';
+import Brand from '@shell/mixins/brand';
+
+describe('brandMixin', () => {
+  const createWrapper = (vaiOn = false) => {
+    const Component = {
+      template: '<div></div>',
+      mixins:   [Brand],
+    };
+
+    const data = {
+      apps: null, haveAppsAndSettings: null, canPaginate: false
+    };
+
+    const store = {
+      dispatch: (action, ...args) => {
+        switch (action) {
+        case 'management/findAll':
+          if (args[0] === MANAGEMENT.SETTING) {
+            return [];
+          }
+          if (args[0] === CATALOG.APP) {
+            return [];
+          }
+          break;
+        }
+      },
+      getters: {
+        'auth/loggedIn':        () => true,
+        'auth/fromHeader':      () => false,
+        'management/byId':      () => undefined,
+        'management/canList':   () => () => true,
+        'management/schemaFor': (type: string) => {
+          switch (type) {
+          case MANAGEMENT.SETTING:
+            return { linkFor: () => undefined };
+          }
+        },
+        'management/generation':        () => undefined,
+        'management/paginationEnabled': () => vaiOn,
+        'management/all':               (type: string) => {
+          switch (type) {
+          case MANAGEMENT.SETTING:
+            return [];
+          }
+        },
+      }
+    };
+
+    const wrapper = mount(
+      Component,
+      {
+        data:   () => data,
+        global: { mocks: { $store: store } }
+      });
+    const spyManagementFindAll = jest.spyOn(store, 'dispatch');
+
+    return {
+      wrapper,
+      store,
+      spyManagementFindAll,
+    };
+  };
+
+  describe('should make correct requests', () => {
+    it('vai off', async() => {
+      const { wrapper, spyManagementFindAll } = createWrapper(false);
+
+      // NOTE - wrapper.vm.$options.fetch() doesn't work
+      await wrapper.vm.$options.fetch.apply(wrapper.vm);
+
+      // wrapper.vm.$nextTick();
+      expect(spyManagementFindAll).toHaveBeenNthCalledWith(1, 'management/findAll', {
+        type: MANAGEMENT.SETTING,
+        opt:  {
+          load: 'multi', redirectUnauthorized: false, url: `/v1/${ MANAGEMENT.SETTING }s`
+        }
+      });
+      expect(spyManagementFindAll).toHaveBeenNthCalledWith(2, 'management/findAll', { type: CATALOG.APP });
+    });
+
+    it('vai on', async() => {
+      const { wrapper, spyManagementFindAll } = createWrapper(true);
+
+      // NOTE - wrapper.vm.$options.fetch() doesn't work
+      await wrapper.vm.$options.fetch.apply(wrapper.vm);
+
+      expect(spyManagementFindAll).toHaveBeenNthCalledWith(1, 'management/findAll', {
+        type: MANAGEMENT.SETTING,
+        opt:  {
+          load: 'multi', url: `/v1/${ MANAGEMENT.SETTING }s`, redirectUnauthorized: false
+        }
+      });
+      expect(spyManagementFindAll).toHaveBeenNthCalledWith(2, 'management/findPage', {
+        type: CATALOG.APP,
+        opt:  {
+          pagination: {
+            filters: [{
+              equals: true,
+              fields: [{
+                equals: true, exact: true, field: 'metadata.name', value: 'rancher-csp-adapter'
+              }, {
+                equals: true, exact: true, field: 'metadata.name', value: 'rancher-csp-billing-adapter'
+              }],
+              param: 'filter'
+            }],
+            labelSelector:        undefined,
+            page:                 null,
+            pageSize:             null,
+            projectsOrNamespaces: [],
+            sort:                 []
+          }
+        }
+      });
+    });
+  });
+
+  describe('cspAdapter', () => {
+    it('should have correct csp values (off)', async() => {
+      const { wrapper, store } = createWrapper();
+
+      const spyManagementFindAll = jest.spyOn(store, 'dispatch').mockImplementation((_, options) => {
+        const { type } = options as any;
+
+        if (type === MANAGEMENT.SETTING) {
+          return Promise.resolve([]);
+        }
+        if (type === CATALOG.APP) {
+          return Promise.resolve([]);
+        }
+
+        return Promise.reject(new Error('reason'));
+      });
+
+      // NOTE - wrapper.vm.$options.fetch() doesn't work
+      await wrapper.vm.$options.fetch.apply(wrapper.vm, []);
+
+      expect(spyManagementFindAll).toHaveBeenCalledTimes(2);
+
+      expect(wrapper.vm.canCalcCspAdapter).toBeTruthy();
+      expect(wrapper.vm.cspAdapter).toBeFalsy();
+    });
+
+    it.each(['rancher-csp-adapter', 'rancher-csp-billing-adapter'])('should have correct csp values (on - %p )', async(chartName) => {
+      const { wrapper, store } = createWrapper();
+
+      const spyManagementFindAll = jest.spyOn(store, 'dispatch').mockImplementation((_, options) => {
+        const { type } = options as any;
+
+        if (type === MANAGEMENT.SETTING) {
+          return Promise.resolve([]);
+        }
+        if (type === CATALOG.APP) {
+          return Promise.resolve([{ metadata: { name: chartName } }]);
+        }
+
+        return Promise.reject(new Error('reason'));
+      });
+
+      // NOTE - wrapper.vm.$options.fetch() doesn't work
+      await wrapper.vm.$options.fetch.apply(wrapper.vm, []);
+
+      expect(spyManagementFindAll).toHaveBeenCalledTimes(2);
+
+      expect(wrapper.vm.canCalcCspAdapter).toBeTruthy();
+      expect(wrapper.vm.cspAdapter).toBeTruthy();
+    });
+  });
+});

package/mixins/auth-config.js

@@ -307,7 +307,14 @@ export default {
 
         // KeyCloakOIDCConfig --> OIDCConfig
         this.model.rancherUrl = `${ serverUrl }/verify-auth`;
-        this.model.scope = this.model.id === 'keycloakoidc' ? BASE_SCOPES.keycloakoidc[0] : BASE_SCOPES.genericoidc[0];
+
+        // If there are base scopes defined for this provider, use those
+        if (Array.isArray(BASE_SCOPES[this.model.id])) {
+          this.model.scope = BASE_SCOPES[this.model.id][0];
+        } else {
+          // Default if base scopes not defined for this auth provider
+          this.model.scope = BASE_SCOPES.genericoidc[0];
+        }
         break;
       }
 

package/mixins/brand.js

@@ -1,39 +1,38 @@
 import { mapGetters } from 'vuex';
-import { CATALOG, MANAGEMENT } from '@shell/config/types';
+import { MANAGEMENT } from '@shell/config/types';
 import { SETTING } from '@shell/config/settings';
 import { createCssVars } from '@shell/utils/color';
 import { setTitle } from '@shell/config/private-label';
 import { setFavIcon, haveSetFavIcon } from '@shell/utils/favicon';
-
-const cspAdaptorApp = ['rancher-csp-adapter', 'rancher-csp-billing-adapter'];
-
-export const hasCspAdapter = (apps) => {
-  return apps?.find((a) => cspAdaptorApp.includes(a.metadata?.name));
-};
+import { allHash } from '@shell/utils/promise';
+import { fetchInitialSettings } from '@shell/utils/settings';
+import CspAdapterUtils from '@shell/utils/cspAdaptor';
 
 export default {
   async fetch() {
-    // For the login page, the schemas won't be loaded - we don't need the apps in this case
     try {
-      if (this.$store.getters['management/canList'](CATALOG.APP)) {
-        this.apps = await this.$store.dispatch('management/findAll', { type: CATALOG.APP });
-      }
-    } catch (e) {}
+      const res = await allHash({
+        // Ensure we read the settings even when we are not authenticated
+        globalSettings: fetchInitialSettings(this.$store),
+        apps:           CspAdapterUtils.fetchCspAdaptorApp(this.$store),
+      });
 
-    // Ensure we read the settings even when we are not authenticated
-    try {
       // The favicon is implicitly dependent on the initial settings having already been fetched
       if (!haveSetFavIcon()) {
         setFavIcon(this.$store);
       }
-    } catch (e) {}
+
+      this.apps = res.apps;
+    } catch (e) { }
 
     // Setting this up front will remove `computed` churn, and we only care that we've initialised them
     this.haveAppsAndSettings = !!this.apps && !!this.globalSettings;
   },
 
   data() {
-    return { apps: null, haveAppsAndSettings: null };
+    return {
+      apps: null, haveAppsAndSettings: null, canPaginate: false
+    };
   },
 
   computed: {
@@ -87,7 +86,7 @@ export default {
       // Note! this used to be `findBy(this.app)` however for that case we lost reactivity on the collection
       // (computed fires before fetch, fetch happens and update apps, computed would not fire again - even with vue.set)
       // So use `.find` in method instead
-      return hasCspAdapter(this.apps);
+      return CspAdapterUtils.hasCspAdapter({ $store: this.$store, apps: this.apps });
     },
 
     canCalcCspAdapter() {

package/mixins/create-edit-view/index.js

@@ -44,5 +44,10 @@ export default defineComponent({
       type:    Boolean,
       default: false,
     },
+
+    useTabbedHash: {
+      type:    Boolean,
+      default: undefined
+    }
   },
 });

package/mixins/preset.js

@@ -0,0 +1,100 @@
+import { watch } from 'vue';
+import { dasherize } from '@shell/utils/string';
+import { NORMAN } from '@shell/config/types';
+
+export default {
+  data() {
+    return {
+      _init:   [],
+      presets: {},
+    };
+  },
+
+  mounted() {
+    this.presetKey = dasherize(this.$options.name || '');
+
+    const version = this.presetVersion;
+
+    if (!version) {
+      console.warn('Preset: version not found, skip.'); // eslint-disable-line no-console
+
+      return;
+    }
+
+    let presets = null;
+
+    try {
+      presets = JSON.parse(window.localStorage.getItem(this.presetKey));
+    } catch (error) {
+      console.warn(`Preset: load presets failed, invalid presets [${ this.presetKey }]`); // eslint-disable-line no-console
+    }
+
+    if (presets?.data && presets?.user === this.user && presets?.version === version) {
+      this.presets = presets;
+
+      return;
+    }
+
+    this.presets = {
+      data: {},
+      user: this.user,
+      version
+    };
+  },
+
+  computed: {
+    user() {
+      const principal = this.$store.getters['rancher/byId'](NORMAN.PRINCIPAL, this.$store.getters['auth/principalId']) || {};
+
+      return principal.loginName;
+    }
+  },
+
+  methods: {
+    preset(key, type) {
+      if (this._init.includes(key)) {
+        return;
+      }
+
+      this._init.push(key);
+
+      if (!this.presetVersion) {
+        return;
+      }
+
+      if (!this.presetKey) {
+        return;
+      }
+
+      if (!this.presets?.data) {
+        return;
+      }
+
+      if (this[key] === undefined) {
+        return;
+      }
+
+      const preset = this.presets.data[key];
+
+      if (preset !== undefined && typeof preset === type) { // eslint-disable-line valid-typeof
+        this[key] = preset;
+      }
+
+      watch(
+        () => this[key],
+        (neu) => {
+          this.presets.data[key] = neu;
+
+          try {
+            const presets = JSON.stringify(this.presets);
+
+            window.localStorage.setItem(this.presetKey, presets);
+          } catch (error) {
+            console.warn(`Preset: save presets failed, invalid presets [${ this.presetKey }]`); // eslint-disable-line no-console
+          }
+        },
+        { deep: true }
+      );
+    },
+  },
+};

package/mixins/resource-fetch-api-pagination.js

@@ -7,6 +7,7 @@ import paginationUtils from '@shell/utils/pagination-utils';
 import debounce from 'lodash/debounce';
 import { PaginationParamFilter, PaginationFilterField, PaginationArgs } from '@shell/types/store/pagination.types';
 import stevePaginationUtils from '@shell/plugins/steve/steve-pagination-utils';
+import { STEVE_WATCH_MODE } from '@shell/types/store/subscribe.types';
 
 /**
  * Companion mixin used with `resource-fetch` for `ResourceList` to determine if the user needs to filter the list by a single namespace
@@ -47,6 +48,8 @@ export default {
       },
 
       paginationFromList: null,
+
+      isPaginationManualRefreshEnabled: paginationUtils.isListManualRefreshEnabled({ rootGetters: this.$store.getters }),
     };
   },
 
@@ -348,4 +351,19 @@ export default {
       });
     }
   },
+
+  unmounted() {
+    if (this.havePaginated) {
+      // of type @STEVE_WATCH_PARAMS
+      const watchArgs = {
+        type: this.resource,
+        mode: STEVE_WATCH_MODE.RESOURCE_CHANGES,
+      };
+
+      this.$store.dispatch(`${ this.inStore }/forgetType`, this.resource, (watchParams) => {
+        return watchParams.type === watchArgs.type &&
+        watchParams.mode === watchArgs.type.mode;
+      });
+    }
+  }
 };

package/mixins/resource-fetch.js

@@ -280,7 +280,7 @@ export default {
       if (manualDataRefreshEnabled && resourceCount >= manualDataRefreshThreshold) {
         watch = false;
         isTooManyItemsToAutoUpdate = true;
-      } else if (this.canPaginate) {
+      } else if (this.canPaginate && this.isPaginationManualRefreshEnabled) {
         isTooManyItemsToAutoUpdate = true;
       }
 

package/mixins/resource-table-watch.js

@@ -0,0 +1,45 @@
+import { STEVE_WATCH_MODE } from '@shell/types/store/subscribe.types';
+
+// This is functionality used to stop or start sockets used to watch resources in the vai world.
+// Currently disabled via (non-public) perf setting
+// See https://github.com/rancher/dashboard/issues/14359 for long term plan
+
+export default {
+  props: {
+    schema: {
+      type:    Object,
+      default: null,
+    },
+  },
+
+  data() {
+    // Note - does not cover anything fetched by secondary / page functions
+    const watchOpts = this.schema?.id ? {
+      type: this.schema.id,
+      mode: STEVE_WATCH_MODE.RESOURCE_CHANGES
+      // Note - we don't restrict watch by namespace (would involve unwatch, request, watch with new revision on every change to ns filter)
+    } : undefined;
+
+    return { watchOpts };
+  },
+
+  computed: {
+    watching() {
+      return this.$store.getters[`${ this.inStore }/watchStarted`](this.watchOpts);
+    },
+  },
+
+  methods: {
+    toggleWatch(toggle) {
+      if (toggle) {
+        // Assume there's a gap between cache and reality, to restart watch with something that will make a new http request to refresh it
+        this.$store.dispatch(`${ this.inStore }/resyncWatch`, {
+          ...this.watchOpts,
+          resourceType: this.watchOpts?.type
+        });
+      } else {
+        this.$store.dispatch(`${ this.inStore }/unwatch`, this.watchOpts);
+      }
+    }
+  }
+};

package/mixins/vue-select-overrides.js

@@ -20,6 +20,7 @@ export default {
         e.preventDefault();
         e.stopPropagation();
 
+        this.isOpen = false;
         vm.open = false;
         vm.search = '';