@rancher/shell 0.5.1 → 0.5.3

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);
+      }
+    );
+  });
 });

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';
@@ -208,12 +209,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
@@ -368,10 +369,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;
 

package/plugins/dashboard-store/getters.js

@@ -1,5 +1,5 @@
 
-import { SCHEMA } from '@shell/config/types';
+import { SCHEMA, COUNT } from '@shell/config/types';
 
 import { matches } from '@shell/utils/selector';
 import { typeMunge, typeRef, SIMPLE_TYPES } from '@shell/utils/create-yaml';
@@ -45,6 +45,29 @@ export const urlFor = (state, getters) => (type, id, opt) => {
   return url;
 };
 
+/**
+ * Find the number of resources given
+ * - if the type is namespaced
+ * - if there are any counts per namespace
+ * - if there are no namespaces
+ * - if there is no total count
+ */
+function matchingCounts(typeObj, namespaces) {
+  // That was easy
+  if ( !typeObj.namespaced || !typeObj.byNamespace || namespaces === null || typeObj.count === null) {
+    return typeObj.count;
+  }
+
+  let out = 0;
+
+  // Otherwise start with 0 and count up
+  for ( const namespace of namespaces ) {
+    out += typeObj.byNamespace[namespace]?.count || 0;
+  }
+
+  return out;
+}
+
 export default {
 
   all: (state, getters, rootState) => (type) => {
@@ -345,5 +368,40 @@ export default {
 
   gcIgnoreTypes: () => {
     return {};
-  }
+  },
+
+  /**
+   * For the given type, and it's settings, find the number of resources associated with it
+   *
+   * This takes into account if the type is namespaced.
+   *
+   * @param typeObj see inners for properties. must have at least `name` (resource type)
+   *
+   */
+  count: (state, getters, rootState, rootGetters) => (typeObj) => {
+    let _typeObj = typeObj;
+    const { name: type, count } = _typeObj;
+
+    if (!type) {
+      throw new Error(`Resource type required to calc count: ${ JSON.stringify(typeObj) }`);
+    }
+
+    if (!count) {
+      const schema = getters.schemaFor(type);
+      const counts = getters.all(COUNT)?.[0]?.counts || {};
+      const count = counts[type];
+
+      _typeObj = {
+        count:       count ? count.summary.count || 0 : null,
+        byNamespace: count ? count.namespaces : {},
+        revision:    count ? count.revision : null,
+        namespaced:  schema?.attributes?.namespaced
+      };
+    }
+
+    const namespaces = Object.keys(rootGetters.activeNamespaceCache || {});
+
+    return matchingCounts(_typeObj, namespaces.length ? namespaces : null);
+  },
+
 };

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

@@ -1381,7 +1381,7 @@ export default class Resource {
 
   async download() {
     const value = await this.followLink('view', { headers: { accept: 'application/yaml' } });
-    const data = await this.$dispatch('cleanForDownload', value.data);
+    const data = await this.cleanForDownload(value.data);
 
     downloadFile(`${ this.nameDisplay }.yaml`, data, 'application/yaml');
   }
@@ -1404,7 +1404,7 @@ export default class Resource {
     await eachLimit(items, 10, (item, idx) => {
       return item.followLink('view', { headers: { accept: 'application/yaml' } } ).then(async(data) => {
         const yaml = data.data || data;
-        const cleanedYaml = await this.$dispatch('cleanForDownload', yaml);
+        const cleanedYaml = await this.cleanForDownload(yaml);
 
         files[`resources/${ names[idx] }`] = cleanedYaml;
       });
@@ -1481,6 +1481,10 @@ export default class Resource {
     this.$dispatch(`cleanForDiff`, this.toJSON());
   }
 
+  async cleanForDownload(yaml) {
+    return this.$dispatch(`cleanForDownload`, yaml);
+  }
+
   yamlForSave(yaml) {
     try {
       const obj = jsyaml.load(yaml);

package/plugins/steve/__tests__/getters.spec.ts

@@ -37,6 +37,7 @@ describe('steve: getters', () => {
       expect(urlForGetter('typeFoo', undefined, { namespaced: ['nsBar', 'nsBaz'] })).toBe('protocol/urlFoo');
     });
   });
+
   describe('steve > getters > urlOptions', () => {
     // we're not testing function output based off of state or getter inputs here since they are dependencies
     const state = { config: { baseUrl: 'protocol' } };
@@ -71,12 +72,21 @@ describe('steve: getters', () => {
     it('returns a string with a single filter statement applied and formatted for steve if a single filter statement is applied and the url starts with "/v1"', () => {
       expect(urlOptionsGetter('/v1/foo', { filter: { bar: 'baz' } })).toBe('/v1/foo?filter=bar=baz&exclude=metadata.managedFields');
     });
+    it('returns a string with a single filter statement applied and formatted for steve if a single filter statement is applied and the url starts with "/k8s/clusters/c-m-n4x45x4b/v1/"', () => {
+      expect(urlOptionsGetter('/k8s/clusters/c-m-n4x45x4b/v1/foo', { filter: { bar: 'baz' } })).toBe('/k8s/clusters/c-m-n4x45x4b/v1/foo?filter=bar=baz&exclude=metadata.managedFields');
+    });
     it('returns a string with a multiple filter statements applied if a single filter statement is applied', () => {
       expect(urlOptionsGetter('foo', { filter: { bar: 'baz', far: 'faz' } })).toBe('foo?bar=baz&far=faz');
     });
     it('returns a string with a multiple filter statements applied and formatted for steve if a single filter statement is applied and the url starts with "/v1"', () => {
       expect(urlOptionsGetter('/v1/foo', { filter: { bar: 'baz', far: 'faz' } })).toBe('/v1/foo?filter=bar=baz&far=faz&exclude=metadata.managedFields');
     });
+    it('returns a string with a labelSelector and formatted for steve if the url starts with "/v1"', () => {
+      expect(urlOptionsGetter('/v1/foo', { labelSelector: 'a=b' })).toBe('/v1/foo?labelSelector=a=b&exclude=metadata.managedFields');
+    });
+    it('returns a string with a labelSelector and filter, and formatted for steve if the url starts with "/v1"', () => {
+      expect(urlOptionsGetter('/v1/foo', { labelSelector: 'a=b', filter: { bar: 'baz', far: 'faz' } })).toBe('/v1/foo?labelSelector=a=b&filter=bar=baz&far=faz&exclude=metadata.managedFields');
+    });
     it('returns a string with an exclude statement for "bar" and "metadata.managedFields" if excludeFields is a single element array with the string "bar" and the url starts with "/v1/"', () => {
       expect(urlOptionsGetter('/v1/foo', { excludeFields: ['bar'] })).toBe('/v1/foo?exclude=bar&exclude=metadata.managedFields');
     });

package/plugins/steve/__tests__/resource-utils.test.ts

@@ -0,0 +1,159 @@
+import { steveCleanForDownload } from '@shell/plugins/steve/resource-utils';
+
+describe('steve: ressource-utils', () => {
+  it('should do nothing if the yaml is not passed', () => {
+    const r = steveCleanForDownload();
+
+    expect(r).toBeUndefined();
+  });
+  it('should remove all default rootKeys', () => {
+    const expectedYamlStr = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+`;
+    const yamlStr = `
+id: test_id
+links: 
+  view: https://example.com2
+type: test_type
+actions:
+  remove: https://example.com
+${ expectedYamlStr }
+`;
+    const cleanedYamlStr = steveCleanForDownload(yamlStr);
+
+    expect(cleanedYamlStr).toBe(expectedYamlStr);
+  });
+  it('should remove all the specified root keys', () => {
+    const part = `apiVersion: v1
+kind: Secret
+metadata:
+  name: my-secret`;
+
+    const rootKeyToYamlStringMap = {
+      id:    'id: test_id',
+      links: `links:
+  view: https://example.com`,
+      actions: `actions:
+  remove: https://example.com`,
+      type: 'type: Opaque'
+    };
+
+    const entries = Object.entries(rootKeyToYamlStringMap);
+    const yamlStr = `${ part }
+${ entries.map(([_, str]) => str).join('\n') }`;
+
+    entries.forEach(([key, str]) => {
+      const expectedYamlStr = `${ part }
+${ entries.filter(([k]) => k !== key).map(([_, str]) => str).join('\n') }\n`;
+      const cleanedYamlStr = steveCleanForDownload(yamlStr, { rootKeys: [key] });
+
+      expect(cleanedYamlStr).toBe(expectedYamlStr);
+    });
+  });
+  it('should remove all default metadata keys', () => {
+    const expectedYamlStr = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+`;
+    const yamlStr = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+  fields: 
+    - kube-root-ca.crt
+    - 1
+    - 7d23h
+  relationships:
+    - rel: 'owner'
+  state: 'active'
+`;
+    const cleanedYamlStr = steveCleanForDownload(yamlStr);
+
+    expect(cleanedYamlStr).toBe(expectedYamlStr);
+  });
+
+  it('should remove all the specified metadata keys', () => {
+    const part = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap`;
+
+    const metadataKeyToYamlStringMap = {
+      fields:
+`  fields:
+    - kube-root-ca.crt
+    - 1
+    - 7d23h`,
+      relationships:
+`  relationships:
+    - rel: owner`,
+      state: `  state: active`
+    };
+
+    const entries = Object.entries(metadataKeyToYamlStringMap);
+    const yamlStr = `${ part }
+${ entries.map(([_, str]) => str).join('\n') }`;
+
+    entries.forEach(([key, str]) => {
+      const expectedYamlStr = `${ part }
+${ entries.filter(([k]) => k !== key).map(([_, str]) => str).join('\n') }\n`;
+      const cleanedYamlStr = steveCleanForDownload(yamlStr, { metadataKeys: [key] });
+
+      expect(cleanedYamlStr).toBe(expectedYamlStr);
+    });
+  });
+  it('should remove all defalut condition keys', () => {
+    const expectedYamlStr = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+status:
+  conditions:
+    - {}
+    - {}
+    - message: message
+`;
+    const yamlStr = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+status:
+  conditions:
+    - error: 'error'
+    - transitioning: false
+    - message: message
+`;
+    const cleanedYamlStr = steveCleanForDownload(yamlStr);
+
+    expect(cleanedYamlStr).toBe(expectedYamlStr);
+  });
+  it('should remove all the specified condition keys', () => {
+    const part = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+status:
+  conditions:
+    - message: message`;
+
+    const conditionKeyToYamlStringMap = {
+      error:         '    - error: error',
+      transitioning: '    - transitioning: false'
+    };
+
+    const entries = Object.entries(conditionKeyToYamlStringMap);
+    const yamlStr = `${ part }
+${ entries.map(([_, str]) => str).join('\n') }`;
+
+    entries.forEach(([key, str]) => {
+      const expectedYamlStr = `${ part }
+${ entries.map(([k, str]) => k === key ? '    - {}' : str).join('\n') }\n`;
+      const cleanedYamlStr = steveCleanForDownload(yamlStr, { conditionKeys: [key] });
+
+      expect(cleanedYamlStr).toBe(expectedYamlStr);
+    });
+  });
+});