@rancher/shell 0.5.2 → 1.2.0

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

@@ -0,0 +1,250 @@
+import _actions from '@shell/plugins/dashboard-store/actions';
+
+const { findAll, findMatching } = _actions;
+
+describe('dashboard-store: actions', () => {
+  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
+      };
+    };
+
+    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
+          }
+        },
+        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'
+      },
+      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
+      } = setupContext();
+
+      const findAllPromise = findAll(
+        {
+          dispatch, commit, getters, rootGetters, state
+        },
+        { type: 'type' }
+      );
+
+      const assertionChain = [
+        standardAssertions.returnsPromise,
+        standardAssertions.callsAll,
+        standardAssertions.returnsFromAll,
+        standardAssertions.firstDispatchAction,
+        standardAssertions.firstDispatchParams,
+        standardAssertions.secondDispatchAction,
+        standardAssertions.secondDispatchParams,
+        standardAssertions.countDispatches,
+        standardAssertions.firstCommitMutation,
+        standardAssertions.firstCommitParams,
+        standardAssertions.secondCommitMutation,
+        standardAssertions.secondCommitParams,
+        standardAssertions.countCommits
+      ];
+
+      it.each(assertionChain)(
+        '$assertionLabel',
+        async({ valueGetter, valueExpected, assertionMethod = 'toBe' }) => {
+          const findAllReturnValue = await findAllPromise;
+
+          expect(valueGetter({
+            findAllPromise, findAllReturnValue, getters, dispatch, commit
+          }))[assertionMethod](valueExpected);
+        }
+      );
+    });
+  });
+
+  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);
+      }
+    );
+  });
+});

package/plugins/dashboard-store/__tests__/{mutations.test.ts → mutations.spec.ts}

@@ -1,4 +1,4 @@
-import { batchChanges } from '@shell/plugins/dashboard-store/mutations.js';
+import { batchChanges } from '@shell/plugins/dashboard-store/mutations';
 import { POD, WORKLOAD_TYPES } from '@shell/config/types';
 import Resource from '@shell/plugins/dashboard-store/resource-class';
 

package/plugins/dashboard-store/actions.js

@@ -7,6 +7,7 @@ import { classify } from '@shell/plugins/dashboard-store/classify';
 import { normalizeType } from './normalize';
 import garbageCollect from '@shell/utils/gc/gc';
 import { addSchemaIndexFields } from '@shell/plugins/steve/schema.utils';
+import { addParam } from '@shell/utils/url';
 
 export const _ALL = 'all';
 export const _MERGE = 'merge';
@@ -71,10 +72,6 @@ export async function loadSchemas(ctx, watch = true) {
   return all;
 }
 
-const findAllGetter = (getters, type, opt) => {
-  return opt.namespaced ? getters.matching(type, null, opt.namespaced, { skipSelector: true }) : getters.all(type);
-};
-
 export default {
   request() {
     throw new Error('Not Implemented');
@@ -156,19 +153,19 @@ export default {
 
     // No need to request the resources if we have them already
     if ( opt.force !== true && (getters['haveAll'](type) || getters['haveAllNamespace'](type, opt.namespaced))) {
-      const args = {
-        type,
-        revision:  '',
-        // watchNamespace - used sometimes when we haven't fetched the results of a single namespace
-        // namespaced - used when we have fetched the result of a single namespace (see https://github.com/rancher/dashboard/pull/7329/files)
-        namespace: opt.watchNamespace || opt.namespaced
-      };
-
       if (opt.watch !== false ) {
+        const args = {
+          type,
+          revision:  '',
+          // watchNamespace - used sometimes when we haven't fetched the results of a single namespace
+          // namespaced - used when we have fetched the result of a single namespace (see https://github.com/rancher/dashboard/pull/7329/files)
+          namespace: opt.watchNamespace || opt.namespaced
+        };
+
         dispatch('watch', args);
       }
 
-      return findAllGetter(getters, type, opt);
+      return getters.all(type);
     }
 
     let load = (opt.load === undefined ? _ALL : opt.load);
@@ -208,12 +205,12 @@ export default {
 
       const pageFetchOpts = {
         ...opt,
-        url: `${ opt.url }?limit=${ opt.incremental }`
+        url: addParam(opt.url, 'limit', `${ opt.incremental }`),
       };
 
       // this is where we "hijack" the limit for the dispatch('request') some lines below
       // and therefore have 2 initial requests in parallel
-      opt.url = `${ opt.url }?limit=100`;
+      opt.url = addParam(opt.url, 'limit', '100');
       skipHaveAll = true;
 
       // since we are forcing a request, clear the haveAll
@@ -333,7 +330,7 @@ export default {
       dispatch('watch', args);
     }
 
-    const all = findAllGetter(getters, type, opt);
+    const all = getters.all(type);
 
     if (!opt.incremental && opt.hasManualRefresh) {
       dispatch('resource-fetch/updateManualRefreshIsLoading', false, { root: true });
@@ -368,10 +365,7 @@ export default {
     const typeOptions = rootGetters['type-map/optionsFor'](type);
 
     opt = opt || {};
-
-    opt.filter = opt.filter || {};
-    opt.filter['labelSelector'] = selector;
-
+    opt.labelSelector = selector;
     opt.url = getters.urlFor(type, null, opt);
     opt.depaginate = typeOptions?.depaginate;
 
@@ -445,8 +439,13 @@ export default {
       const watchMsg = {
         type,
         id,
-        revision: res?.metadata?.resourceVersion,
-        force:    opt.forceWatch === true,
+        // Although not used by sockets, we need this for when resyncWatch calls find.... which needs namespace to construct the url
+        namespace: opt.namespaced,
+        // Override the revision. Used in cases where we need to avoid using the resource's own revision which would be `too old`.
+        // For the above case opt.revision will be `null`. If left as `undefined` the subscribe mechanism will try to determine a revision
+        // from resources in store (which would be this one, with the too old revision)
+        revision:  typeof opt.revision !== 'undefined' ? opt.revision : res?.metadata?.resourceVersion,
+        force:     opt.forceWatch === true,
       };
 
       const idx = id.indexOf('/');

package/plugins/dashboard-store/classify.js

@@ -12,7 +12,24 @@ export function classify(ctx, obj, isClone = false) {
 
   const customModel = ctx.getters['classify'](obj);
 
-  const out = new customModel(obj, ctx, null, isClone);
+  const out = new customModel(obj, ctx, (process.server ? ctx.state.config.namespace : null), isClone);
+
+  if ( process.server ) {
+    Object.defineProperty(obj, '__rehydrate', {
+      value:        ctx.state.config.namespace,
+      enumerable:   true,
+      configurable: true
+    });
+
+    if ( isClone ) {
+      Object.defineProperty(obj, '__clone', {
+        value:        true,
+        enumerable:   true,
+        configurable: true,
+        writable:     true
+      });
+    }
+  }
 
   return out;
 }

package/plugins/dashboard-store/getters.js

@@ -64,24 +64,19 @@ export default {
     return state.types[type].list;
   },
 
-  matching: (state, getters, rootState) => (type, selector, namespace, config = { skipSelector: false }) => {
-    let matching = getters['all'](type);
+  matching: (state, getters, rootState) => (type, selector, namespace) => {
+    let all = getters['all'](type);
 
     // Filter first by namespace if one is provided, since this is efficient
-    if (namespace && typeof namespace === 'string') {
-      matching = matching.filter((obj) => obj.namespace === namespace);
+    if (namespace) {
+      all = all.filter((obj) => obj.namespace === namespace);
     }
 
     garbageCollect.gcUpdateLastAccessed({
       state, getters, rootState
     }, type);
 
-    // Looks like a falsy selector is a thing, so if we're not interested in filtering by the selector... explicitly avoid it
-    if (config.skipSelector) {
-      return matching;
-    }
-
-    return matching.filter((obj) => {
+    return all.filter((obj) => {
       return matches(obj, selector);
     });
   },

package/plugins/dashboard-store/index.js

@@ -33,9 +33,21 @@ export default (vuexModule, config, init) => {
   const namespace = config.namespace || '';
 
   return function(store) {
+    // const inst = SteveFactory(namespace, config.baseUrl);
+
     store.registerModule(namespace, vuexModule);
     store.commit(`${ namespace }/applyConfig`, config);
 
+    if ( !process.client ) {
+      return;
+    }
+
+    // store.subscribe(({ type }, state) => {
+    //   if ( type === 'auth/loggedOut' ) {
+    //     store.dispatch(`${ namespace }/unsubscribe`);
+    //   }
+    // });
+
     const module = store._modules.root._children[namespace];
     const fromServer = window.__NUXT__;
 

package/plugins/dashboard-store/mutations.js

@@ -23,6 +23,10 @@ function registerType(state, type) {
     // Not enumerable so they don't get sent back to the client for SSR
     Object.defineProperty(cache, 'map', { value: new Map() });
 
+    if ( process.server && !cache.list.__rehydrateAll ) {
+      Object.defineProperty(cache.list, '__rehydrateAll', { value: `${ state.config.namespace }/${ type }`, enumerable: true });
+    }
+
     Vue.set(state.types, type, cache);
   }
 

package/plugins/dashboard-store/resource-class.js

@@ -105,7 +105,6 @@ export const STATES_ENUM = {
   ERRORING:         'erroring',
   ERRORS:           'errors',
   EXPIRED:          'expired',
-  EXPIRING:         'expiring',
   FAIL:             'fail',
   FAILED:           'failed',
   HEALTHY:          'healthy',
@@ -168,13 +167,6 @@ export const STATES_ENUM = {
   WARNING:          'warning',
 };
 
-export function mapStateToEnum(statusString) {
-  // e.g. in fleet Status is Capitalized. This function will map it to the enum
-  return Object.values(STATES_ENUM).find((val) => {
-    return val.toLowerCase() === statusString.toLocaleLowerCase();
-  });
-}
-
 export const STATES = {
   [STATES_ENUM.IN_USE]: {
     color: 'success', icon: 'dot-open', label: 'In Use', compoundIcon: 'checkmark'
@@ -261,10 +253,7 @@ export const STATES = {
     color: 'error', icon: 'error', label: 'Errors', compoundIcon: 'error'
   },
   [STATES_ENUM.EXPIRED]: {
-    color: 'error', icon: 'error', label: 'Expired', compoundIcon: 'warning'
-  },
-  [STATES_ENUM.EXPIRING]: {
-    color: 'warning', icon: 'error', label: 'Expiring', compoundIcon: 'error'
+    color: 'warning', icon: 'error', label: 'Expired', compoundIcon: 'warning'
   },
   [STATES_ENUM.FAIL]: {
     color: 'error', icon: 'error', label: 'Fail', compoundIcon: 'error'
@@ -523,28 +512,6 @@ export function stateDisplay(state) {
   return key.split(/-/).map(ucFirst).join('-');
 }
 
-export function primaryDisplayStatusFromCount(status) {
-  const statusOrder = [
-    STATES_ENUM.ERROR,
-    STATES_ENUM.FAILED,
-    STATES_ENUM.WARNING,
-    STATES_ENUM.MODIFIED,
-    STATES_ENUM.WAIT_APPLIED,
-    STATES_ENUM.ORPHANED,
-    STATES_ENUM.MISSING,
-    STATES_ENUM.UNKNOWN,
-    STATES_ENUM.NOT_READY,
-    STATES_ENUM.READY,
-  ];
-
-  // sort status by order of statusOrder
-  const existingStatuses = Object.keys(status).filter((key) => {
-    return status[key] > 0 && statusOrder.includes(key.toLowerCase());
-  }).sort((a, b) => statusOrder.indexOf(a.toLowerCase()) - statusOrder.indexOf(b.toLowerCase()));
-
-  return existingStatuses[0] ? existingStatuses[0] : STATES_ENUM.UNKNOWN;
-}
-
 export function stateSort(color, display) {
   color = color.replace(/^(text|bg)-/, '');
 
@@ -1122,16 +1089,6 @@ export default class Resource {
     return this._save(...arguments);
   }
 
-  /**
-   * Remove any unwanted properties from the object that will be saved
-   */
-  cleanForSave(data, forNew) {
-    delete data.__rehydrate;
-    delete data.__clone;
-
-    return data;
-  }
-
   /**
    * Allow to handle the response of the save request
    * @param {*} res Full request response
@@ -1139,6 +1096,9 @@ export default class Resource {
   processSaveResponse(res) { }
 
   async _save(opt = {}) {
+    delete this.__rehydrate;
+    delete this.__clone;
+
     const forNew = !this.id;
 
     const errors = await this.validationErrors(this, opt.ignoreFields);
@@ -1185,24 +1145,22 @@ export default class Resource {
     // @TODO remove this once the API maps steve _type <-> k8s type in both directions
     opt.data = this.toSave() || { ...this };
 
-    if (opt.data._type) {
+    if (opt?.data._type) {
       opt.data.type = opt.data._type;
     }
 
-    if (opt.data._name) {
+    if (opt?.data._name) {
       opt.data.name = opt.data._name;
     }
 
-    if (opt.data._labels) {
+    if (opt?.data._labels) {
       opt.data.labels = opt.data._labels;
     }
 
-    if (opt.data._annotations) {
+    if (opt?.data._annotations) {
       opt.data.annotations = opt.data._annotations;
     }
 
-    opt.data = this.cleanForSave(opt.data, forNew);
-
     // handle "replace" opt as a query param _replace=true for norman PUT requests
     if (opt?.replace && opt.method === 'put') {
       const argParam = opt.url.includes('?') ? '&' : '?';
@@ -1260,11 +1218,19 @@ export default class Resource {
   // ------------------------------------------------------------------
 
   currentRoute() {
-    return window.$nuxt.$route;
+    if ( process.server ) {
+      return this.$rootState.$route;
+    } else {
+      return window.$nuxt.$route;
+    }
   }
 
   currentRouter() {
-    return window.$nuxt.$router;
+    if ( process.server ) {
+      return this.$rootState.$router;
+    } else {
+      return window.$nuxt.$router;
+    }
   }
 
   get listLocation() {
@@ -1965,11 +1931,4 @@ export default class Resource {
   get creationTimestamp() {
     return this.metadata?.creationTimestamp;
   }
-
-  /**
-   * Allows model to specify JSON Paths that should be folded in the YAML editor by default
-   */
-  get yamlFolding() {
-    return [];
-  }
 }

package/plugins/i18n.js

@@ -1,7 +1,7 @@
 import Vue from 'vue';
 import { escapeHtml } from '../utils/string';
 
-function stringFor(store, key, args, raw = false, escapehtml = true) {
+export function stringFor(store, key, args, raw = false, escapehtml = true) {
   const translation = store.getters['i18n/t'](key, args);
 
   let out;