@rancher/shell 1.2.0 → 2.0.0

package/plugins/steve/__tests__/{getters.spec.ts → getters.test.ts}

@@ -1,9 +1,9 @@
 import _getters from '@shell/plugins/steve/getters';
 
-const { urlFor, urlOptions } = _getters;
+const { urlFor, urlOptions, pathExistsInSchema } = _getters;
 
-describe('steve: getters', () => {
-  describe('steve > getters > urlFor', () => {
+describe('steve: getters:', () => {
+  describe('urlFor', () => {
     // we're not testing function output based off of state or getter inputs here since they are dependencies
     const baseUrl = '/v1';
     const collectionUrl = 'https://abc.com/v1/urlFoo';
@@ -20,7 +20,7 @@ describe('steve: getters', () => {
         }
       },
       // this has its own tests so it just returns the input string
-      urlOptions: (url: string, opt: any) => {
+      urlOptions: (url: string, opt: any, type: string) => {
         if (opt.addParam) {
           url += '?param=true';
         }
@@ -65,7 +65,7 @@ describe('steve: getters', () => {
     });
   });
 
-  describe('steve > getters > urlOptions', () => {
+  describe('urlOptions', () => {
     // we're not testing function output based off of state or getter inputs here since they are dependencies
     const state = { config: { baseUrl: 'protocol' } };
     const getters = {
@@ -94,8 +94,8 @@ 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 NOT 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?bar=baz');
+    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');
@@ -125,16 +125,87 @@ describe('steve: getters', () => {
       expect(urlOptionsGetter('foo', { sortBy: 'bar' })).toBe('foo?sort=bar');
     });
     it('returns a string with a sorting criteria formatted for steve if the sort option is provided and the url starts with "/v1"', () => {
-      expect(urlOptionsGetter('/v1/foo', { sortBy: 'bar' })).toBe('/v1/foo?exclude=metadata.managedFields&sort=bar');
+      expect(urlOptionsGetter('/v1/foo', { sortBy: 'bar' })).toBe('/v1/foo?sort=bar&exclude=metadata.managedFields');
     });
     it('returns a string with a sorting criteria if the sort option is provided and an order if sortOrder is provided', () => {
       expect(urlOptionsGetter('foo', { sortBy: 'bar', sortOrder: 'baz' })).toBe('foo?sort=bar&order=baz');
     });
     it('returns a string with a sorting criteria formatted for steve if the sort option is provided and an order if sortOrder is provided and the url starts with "/v1"', () => {
-      expect(urlOptionsGetter('/v1/foo', { sortBy: 'bar', sortOrder: 'baz' })).toBe('/v1/foo?exclude=metadata.managedFields&sort=bar');
+      expect(urlOptionsGetter('/v1/foo', { sortBy: 'bar', sortOrder: 'baz' })).toBe('/v1/foo?sort=bar&exclude=metadata.managedFields');
     });
     it('returns a string with a sorting criteria formatted for steve if the sort option is provided and an order if sortOrder is "desc" and the url starts with "/v1"', () => {
-      expect(urlOptionsGetter('/v1/foo', { sortBy: 'bar', sortOrder: 'desc' })).toBe('/v1/foo?exclude=metadata.managedFields&sort=-bar');
+      expect(urlOptionsGetter('/v1/foo', { sortBy: 'bar', sortOrder: 'desc' })).toBe('/v1/foo?sort=-bar&exclude=metadata.managedFields');
+    });
+  });
+
+  describe('pathExistsInSchema', () => {
+    const state = {};
+
+    const getters = { schemaFor: (type: string) => ({}) };
+
+    it('expects pathExistsInSchema to return a function', () => {
+      expect(typeof pathExistsInSchema(state, getters)).toBe('function');
+    });
+
+    describe('resourceFields', () => {
+      it('requires resourceFields but no resourceFields', () => {
+        expect(pathExistsInSchema(state, {
+          ...getters,
+          schemaFor: () => ({
+            requiresResourceFields: true,
+            hasResourceFields:      false,
+          })
+        })()).toBe(false);
+      });
+
+      it('requires resourceFields but empty resourceFields', () => {
+        expect(pathExistsInSchema(state, {
+          ...getters,
+          schemaFor: () => ({
+            requiresResourceFields: true,
+            hasResourceFields:      true,
+            schemaDefinitions:      {}
+          })
+        })('', 'name')).toBe(false);
+      });
+
+      it('requires resourceFields and has resourceFields', () => {
+        expect(pathExistsInSchema(state, {
+          ...getters,
+          schemaFor: () => ({
+            requiresResourceFields: true,
+            hasResourceFields:      true,
+            resourceFields:         { name: { type: 'string' } },
+            schemaDefinitions:      { name: { } },
+          })
+        })('n/a', 'name')).toBe(true);
+      });
+
+      it('requires nested resourceFields and has resourceFields', () => {
+        expect(pathExistsInSchema(state, {
+          ...getters,
+          schemaFor: (type) => {
+            const metadata = { resourceFields: { name: { type: 'string' } } };
+
+            switch (type) {
+            case 'root':
+              return {
+                requiresResourceFields: true,
+                hasResourceFields:      true,
+                resourceFields:         { metadata: { type: 'metadata' } },
+                schemaDefinitions:      { metadata: { ...metadata } },
+              };
+            case 'metadata':
+              return {
+                requiresResourceFields: true,
+                hasResourceFields:      true,
+                ...metadata,
+              };
+            }
+            expect(type).toBe('Something known');
+          }
+        })('root', 'metadata.name')).toBe(true);
+      });
     });
   });
 });

package/plugins/steve/__tests__/mutations.test.ts

@@ -0,0 +1,49 @@
+import mutations from '@shell/plugins/steve/mutations.js';
+import { POD } from '@shell/config/types';
+import Resource from '@shell/plugins/dashboard-store/resource-class';
+import mutationHelpers from '@shell/plugins/steve/__tests__/utils/mutation.test.helpers';
+
+describe('steve-store: mutations', () => {
+  describe('loadAdd', () => {
+    const createNewEntry = () => {
+      const res = mutationHelpers.loadAll.createNewEntry();
+      const pod = res.params[1].data[0];
+
+      res.params[0].podsByNamespace = {};
+      res.expected.podsByNamespace = {
+        [pod.namespace]: {
+          list: [new Resource(pod)],
+          map:  new Map([
+            [pod.id, new Resource(pod)]
+          ])
+        }
+      };
+
+      return res;
+    };
+
+    it.each([['No change', mutationHelpers.loadAll.createNoOp()]])('%s', (_, run) => {
+      mutations.loadAdd(...run.params);
+
+      expect(run.params[0]).toStrictEqual(run.expected.state);
+    });
+
+    it.each([
+      ['Add a new pod', createNewEntry()],
+    ])('%s', (_, run) => { // eslint-disable-line jest/no-identical-title
+      mutations.loadAdd(...run.params);
+      const { map: cacheMap, ...cacheState } = run.params[0].types?.[POD] ;
+      const cachePodsByNamespace = run.params[0].podsByNamespace ;
+      const { map: expectedMap, ...expected } = run.expected.types?.[POD];
+      const expectedPodsByNamespace = run.expected.podsByNamespace ;
+
+      expect(cacheMap).toBeDefined();
+      expect(expectedMap).toBeDefined();
+
+      expect(cacheState).toStrictEqual(expected);
+      expect(cacheMap).toStrictEqual(expectedMap);
+
+      expect(cachePodsByNamespace).toStrictEqual(expectedPodsByNamespace);
+    });
+  });
+});

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

package/plugins/steve/__tests__/steve-class.test.ts

@@ -0,0 +1,59 @@
+import Steve from '@shell/plugins/steve/steve-class.js';
+import { steveClassJunkObject } from './utils/steve-mocks';
+
+describe('class: Steve', () => {
+  describe('given custom resource keys', () => {
+    const customResource = steveClassJunkObject;
+
+    it('should keep internal keys', () => {
+      const steve = new Steve(customResource, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: { 'i18n/t': jest.fn() },
+      });
+
+      expect({ ...steve }).toStrictEqual(customResource);
+    });
+
+    describe('method: save', () => {
+      it('should remove all the internal keys', async() => {
+        const dispatch = jest.fn();
+        const steve = new Steve(customResource, {
+          getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+          dispatch,
+          rootGetters: { 'i18n/t': jest.fn() },
+        });
+
+        const expectation = {
+          type:     customResource.type,
+          metadata: {
+            resourceVersion:            'whatever',
+            fields:                     'whatever',
+            clusterName:                'whatever',
+            deletionGracePeriodSeconds: 'whatever',
+            generateName:               'whatever',
+          },
+          spec: { versions: {} }
+        };
+
+        await steve.save();
+
+        const opt = {
+          data:    expectation,
+          headers: {
+            accept:         'application/json',
+            'content-type': 'application/json',
+          },
+          method: 'post',
+          url:    undefined,
+        };
+
+        // Data sent should have been cleaned
+        expect(dispatch).toHaveBeenCalledWith('request', { opt, type: customResource.type });
+
+        // Original workload model should remain unchanged
+        expect({ ...steve }).toStrictEqual(customResource);
+      });
+    });
+  });
+});

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

@@ -10,7 +10,10 @@ describe('steve: subscribe', () => {
         inError:       () => false,
         watchStarted:  () => false,
       };
-      const rootGetters = { 'type-map/isSpoofed': () => false };
+      const rootGetters = {
+        'type-map/isSpoofed': () => false,
+        'features/get':       () => false,
+      };
 
       const type = 'test';
       const selector = undefined;

package/plugins/steve/__tests__/utils/mutation.test.helpers.ts

@@ -0,0 +1,105 @@
+import { POD } from '@shell/config/types';
+import Resource from '@shell/plugins/dashboard-store/resource-class';
+
+const createCtx = () => ({
+  rootGetters: { 'type-map/optionsFor': (type: string) => ({}) },
+  getters:     {
+    classify:        (resource: any) => Resource,
+    cleanResource:   (existing: Resource, resource: any) => resource,
+    keyFieldForType: () => 'id',
+  }
+});
+
+const create = (type: string) => ({
+  id: '1',
+  type,
+});
+
+const createResource = (type: string, props = {}) => new Resource({
+  ...create(type),
+  ...props
+});
+
+const createPod = () => create(POD);
+
+const createPodResource = (props = {}) => createResource(POD, props);
+
+const createCache = (props: any) => ({
+  generation:    0,
+  haveAll:       false,
+  haveNamespace: undefined,
+  havePage:      undefined,
+  haveSelector:  {},
+  list:          [],
+  loadCounter:   0,
+  revision:      0,
+  map:           new Map(),
+  ...props
+});
+
+const createNoOp = () => {
+  const emptyState = { types: {} };
+
+  return {
+    params: [emptyState, {
+      ctx:   createCtx(),
+      batch: { }
+    }],
+    expected: { state: emptyState }
+  };
+};
+
+const loadAllCreateNoOp = () => {
+  const emptyState = { types: {} };
+
+  return {
+    params: [
+      emptyState,
+      {
+        ctx:  createCtx(),
+        type: POD,
+        data: [],
+      }],
+    expected: { state: emptyState }
+  };
+};
+
+const loadAllCreateNewEntry = () => {
+  const pod = createPodResource({ namespace: 'namespace' } );
+
+  return {
+    params: [
+      { types: { [POD]: createCache({}) } },
+      {
+        ctx:  createCtx(),
+        type: POD,
+        data: [pod]
+      }
+    ],
+    expected: {
+      types: {
+        [POD]: createCache({
+          generation: 1,
+          list:       [new Resource(pod)],
+          map:        new Map([
+            [pod.id, new Resource(pod)]
+          ])
+        })
+      },
+      podsByNamespace: {},
+    }
+  };
+};
+
+export default {
+  createCtx,
+  createCache,
+  createNoOp,
+  createResource,
+  createPod,
+  createPodResource,
+  loadAll: {
+    createNewEntry: loadAllCreateNewEntry,
+    createNoOp:     loadAllCreateNoOp
+  }
+};

package/plugins/steve/__tests__/utils/steve-mocks.ts

@@ -0,0 +1,31 @@
+import { resourceClassJunkObject } from '@shell/plugins/dashboard-store/__tests__/utils/store-mocks';
+
+const customType = 'asdasd';
+
+export const steveClassJunkObject = {
+  ...resourceClassJunkObject,
+  type:     customType,
+  __clone:  'whatever',
+  metadata: {
+    clusterName:                'whatever',
+    creationTimestamp:          'whatever',
+    deletionGracePeriodSeconds: 'whatever',
+    deletionTimestamp:          'whatever',
+    fields:                     'whatever',
+    finalizers:                 'whatever',
+    generateName:               'whatever',
+    generation:                 'whatever',
+    initializers:               'whatever',
+    managedFields:              'whatever',
+    ownerReferences:            'whatever',
+    relationships:              'whatever',
+    selfLink:                   'whatever',
+    state:                      'whatever',
+    uid:                        'whatever',
+    resourceVersion:            'whatever',
+  },
+  spec:       { versions: { schema: 'whatever' } },
+  links:      'whatever',
+  status:     'whatever',
+  stringData: 'whatever',
+};

package/plugins/steve/accept-or-reject-socket-message.ts

@@ -0,0 +1,103 @@
+import pAndNFiltering from '@shell/plugins/steve/projectAndNamespaceFiltering.utils';
+
+type TypeIsCached = { [type: string]: boolean }
+
+/**
+ * There are scenarios where we can't subscribe to subsets of a resource type
+ * - Multiple namespaces or projects
+ * - Result of Pagination (a single page of resources that have been sorted / filtered)
+ *
+ * For those scenarios we subscribe to allll changes BUT ignore changes that are not applicable to that subset
+ */
+class AcceptOrRejectSocketMessage {
+  typeIsNamespaced({ getters }: any, type: string): boolean {
+    return getters.haveNamespace(type)?.length > 0;
+  }
+
+  typeIsPaginated({ getters }: any, type: string): boolean {
+    return !!getters.havePage(type);
+  }
+
+  filteredNamespaces({ rootGetters }: any) {
+    // Note - activeNamespaceCache should be accurate for both namespace/project filtering and pagination namespace/project filtering
+    return rootGetters.activeNamespaceCache;
+  }
+
+  /**
+   * Note - namespace can be a list of projects or namespaces
+   */
+  subscribeNamespace(namespace: string[]) {
+    if (pAndNFiltering.isApplicable({ namespaced: namespace, type: 'n/a' }) && namespace.length) {
+      return undefined; // AKA sub to everything
+    }
+
+    return namespace;
+  }
+
+  validChange({ getters, rootGetters }: any, type: string, data: any) {
+    // If the resource is in namespace outside of the one's we have selected in the header... ignore the change
+    if (this.typeIsNamespaced({ getters }, type)) {
+      const namespaces = this.filteredNamespaces({ rootGetters });
+
+      if (!namespaces[data.metadata.namespace]) {
+        return false;
+      }
+    }
+
+    // If the resource does not meet the previously fetched paginated resource... ignore the change
+    if (this.typeIsPaginated({ getters }, type)) {
+      const page = getters['all'](type);
+
+      return !!page.find((pR: any) => pR.id === data.id);
+    }
+
+    return true;
+  }
+
+  validateBatchChange({ getters, rootGetters }: any, batch: { [key: string]: any}) {
+    const namespaces = this.filteredNamespaces({ rootGetters });
+
+    const typeIs: { namespaced: TypeIsCached, paginated: TypeIsCached} = {
+      namespaced: {},
+      paginated:  {},
+    };
+
+    Object.entries(batch).forEach(([type, entries]) => {
+      if (typeIs.namespaced[type] === undefined) {
+        typeIs.namespaced[type] = this.typeIsNamespaced({ getters }, type);
+      }
+      if (typeIs.namespaced[type]) {
+        const schema = getters.schemaFor(type);
+
+        if (!schema?.attributes?.namespaced) {
+          return;
+        }
+
+        Object.keys(entries).forEach((id) => {
+          const namespace = id.split('/')[0];
+
+          if (!namespace || !namespaces[namespace]) {
+            delete entries[id];
+          }
+        });
+      }
+
+      if (typeIs.paginated[type] === undefined) {
+        typeIs.paginated[type] = this.typeIsPaginated({ getters }, type);
+      }
+      if (typeIs.paginated[type]) {
+        const page = getters['all'](type);
+
+        Object.keys(entries).forEach((id) => {
+          if (!page.find((pR: any) => pR.id === id)) {
+            delete entries[id];
+          }
+        });
+      }
+    });
+
+    return batch;
+  }
+}
+
+export default new AcceptOrRejectSocketMessage();