@rancher/shell 0.2.5 → 0.3.1

package/plugins/dashboard-store/__tests__/mutations.spec.js

@@ -0,0 +1,406 @@
+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';
+
+describe('dashboard-store: mutations', () => {
+  const ctx = {
+    rootGetters: { 'type-map/optionsFor': type => ({}) },
+    getters:     {
+      classify:      resource => Resource,
+      cleanResource: (existing, resource) => resource
+    }
+  };
+
+  const create = type => ({
+    id: '1',
+    type
+  });
+
+  const createResource = (type, props = {}) => new Resource({
+    ...create(type),
+    ...props
+  });
+
+  const createPod = () => create(POD);
+
+  const createPodResource = (props = {}) => createResource(POD, props);
+
+  const createCache = props => ({
+    generation:    0,
+    haveAll:       false,
+    haveNamespace: undefined,
+    haveSelector:  {},
+    list:          [],
+    loadCounter:   0,
+    revision:      0,
+    map:           new Map(),
+    ...props
+  });
+
+  const createNoOp = () => {
+    const emptyState = { types: {} };
+
+    return {
+      params: [emptyState, {
+        ctx,
+        batch: { }
+      }],
+      expected: { state: emptyState }
+    };
+  };
+
+  const createRegister = () => {
+    return {
+      params: [{ types: {} }, {
+        ctx,
+        batch: { [POD]: {} }
+      }],
+      expected: { types: { [POD]: createCache({ generation: 1 }) } }
+    };
+  };
+
+  const createNewEntry = () => {
+    const pod = createPod();
+
+    return {
+      params: [
+        { types: {} },
+        {
+          ctx,
+          batch: { [POD]: { [pod.id]: pod } }
+        }
+      ],
+      expected: {
+        types: {
+          [POD]: createCache({
+            generation: 1,
+            list:       [new Resource(pod)],
+            map:        new Map([
+              [pod.id, new Resource(pod)]
+            ])
+          })
+        }
+      }
+    };
+  };
+
+  const createExisting = () => {
+    const existingPod = createPodResource();
+    const newPod = createPodResource({ change: true });
+
+    return {
+      params: [
+        {
+          types: {
+            [POD]: createCache({
+              list: [existingPod],
+              map:  new Map([
+                [existingPod.id, existingPod]
+              ])
+            })
+          }
+        },
+        {
+          ctx,
+          batch: { [POD]: { [newPod.id]: createPodResource({ change: true }) } }
+        }
+      ],
+      expected: {
+        types: {
+          [POD]: createCache({
+            generation: 1,
+            list:       [newPod],
+            map:        new Map([
+              [newPod.id, newPod]
+            ])
+          })
+
+        },
+      }
+    };
+  };
+
+  const createRemove = () => {
+    const existingPod = createPodResource();
+
+    return {
+      params: [
+        {
+          types: {
+            [POD]: createCache({
+              list: [existingPod],
+              map:  new Map([
+                [existingPod.id, existingPod]
+              ])
+            })
+          }
+        },
+        {
+          ctx,
+          batch: { [POD]: { [existingPod.id]: {} } }
+        }
+      ],
+      expected: {
+        types: {
+          [POD]: createCache({
+            generation: 1,
+            list:       [],
+            map:        new Map()
+          })
+        },
+      }
+    };
+  };
+
+  const createAddRemove = () => {
+    const existingPod1 = createPodResource({ id: '1' });
+    // const newPod1 = createPodResource({ id: '1', new: true });
+    const existingPod2 = createPodResource({ id: '2' });
+
+    return {
+      params: [
+        {
+          types: {
+            [POD]: createCache({
+              list: [existingPod2],
+              map:  new Map([
+                [existingPod2.id, existingPod2]
+              ])
+            })
+
+          }
+        },
+        {
+          ctx,
+          batch: {
+            [POD]: {
+              [existingPod1.id]: existingPod1,
+              [existingPod2.id]: {}
+            }
+          }
+        }
+      ],
+      expected: {
+        types: {
+          [POD]: createCache({
+            generation: 1,
+            list:       [existingPod1],
+            map:        new Map([
+              [existingPod1.id, existingPod1]
+            ])
+          })
+        },
+      }
+    };
+  };
+
+  const createRemoveAdd = () => {
+    const existingPod1 = createPodResource({ id: '1' });
+    // const newPod1 = createPodResource({ id: '1', new: true });
+    const existingPod2 = createPodResource({ id: '2' });
+
+    return {
+      params: [
+        {
+          types: {
+            [POD]: createCache({
+              list: [existingPod2],
+              map:  new Map([
+                [existingPod2.id, existingPod2]
+              ])
+            })
+          }
+        },
+        {
+          ctx,
+          batch: {
+            [POD]: {
+              [existingPod2.id]: {},
+              [existingPod1.id]: existingPod1,
+            }
+          }
+        }
+      ],
+      expected: {
+        types: {
+          [POD]: createCache({
+            generation: 1,
+            list:       [existingPod1],
+            map:        new Map([
+              [existingPod1.id, existingPod1]
+            ])
+          })
+        },
+      }
+    };
+  };
+
+  const createAddMultipleTypes = () => {
+    const pod = createPodResource({ id: '1' });
+    const deployment = createResource({ id: '2', type: WORKLOAD_TYPES.DEPLOYMENT });
+
+    return {
+      params: [
+        {
+          types: {
+            [POD]: createCache({
+              list: [],
+              map:  new Map()
+            }),
+            [WORKLOAD_TYPES.DEPLOYMENT]: createCache({
+              list: [],
+              map:  new Map()
+            })
+          }
+        },
+        {
+          ctx,
+          batch: {
+            [POD]:                        { [pod.id]: pod },
+            [ WORKLOAD_TYPES.DEPLOYMENT]: { [deployment.id]: deployment }
+          }
+        }
+      ],
+      expected: {
+        types: {
+          [POD]: createCache({
+            generation: 1,
+            list:       [pod],
+            map:        new Map([
+              [pod.id, pod]
+            ])
+          }),
+          [WORKLOAD_TYPES.DEPLOYMENT]: createCache({
+            generation: 1,
+            list:       [deployment],
+            map:        new Map([[deployment.id, deployment]])
+          })
+        },
+      }
+    };
+  };
+
+  const removeNonExisting = () => {
+    const pod1 = createPodResource({ id: '1' });
+    const pod2 = createPodResource({ id: '2' });
+
+    return {
+      params: [
+        {
+          types: {
+            [POD]: createCache({
+              list: [pod1],
+              map:  new Map([[pod1.id, pod1]])
+            }),
+          }
+        },
+        {
+          ctx,
+          batch: { [POD]: { [pod2.id]: {} } }
+        }
+      ],
+      expected: {
+        types: {
+          [POD]: createCache({
+            generation: 1,
+            list:       [pod1],
+            map:        new Map([[pod1.id, pod1]])
+          }),
+        },
+      }
+    };
+  };
+
+  const muchMuchChange = () => {
+    const pod1NoChange = createPodResource({ id: '1' });
+
+    const pod2Add = createPodResource({ id: '2' });
+    const pod3Remove = createPodResource({ id: '3' });
+    const pod4RemoveNoneExistant = createPodResource({ id: '4' });
+    const pod5Add = createPodResource({ id: '5' });
+    const pod6Original = createPodResource({ id: '6' });
+    const pod6WithChange = createPodResource({ id: '6', change: true }); // Cannot be same reference
+    const pod6WithChangeRef = createPodResource({ id: '6', change: true });
+
+    expect(pod6Original.id).toBe('6');
+    expect(pod6WithChange.id).toBe('6');
+    expect(pod6WithChangeRef.id).toBe('6');
+
+    return {
+      params: [
+        {
+          types: {
+            [POD]: createCache({
+              list: [pod1NoChange, pod3Remove, pod6Original],
+              map:  new Map([
+                [pod1NoChange.id, pod1NoChange],
+                [pod3Remove.id, pod3Remove],
+                [pod6Original.id, pod6Original],
+              ])
+            }),
+          }
+        },
+        {
+          ctx,
+          batch: {
+            [POD]: {
+              [pod2Add.id]:                pod2Add,
+              [pod3Remove.id]:             {},
+              [pod4RemoveNoneExistant.id]: {},
+              [pod5Add.id]:                pod5Add,
+              [pod6WithChangeRef.id]:      pod6WithChange // Cannot be same reference,
+            },
+          }
+        }
+      ],
+      expected: {
+        types: {
+          [POD]: createCache({
+            generation: 1,
+            list:       [pod1NoChange, pod6WithChangeRef, pod2Add, pod5Add], // Order important
+            map:        new Map([
+              [pod1NoChange.id, pod1NoChange],
+              [pod2Add.id, pod2Add],
+              [pod5Add.id, pod5Add],
+              [pod6WithChangeRef.id, pod6WithChangeRef],
+
+            ])
+          }),
+        },
+      }
+    };
+  };
+
+  describe('batchChanges', () => {
+    it.each([['No change', createNoOp()]])('%s', (_, run) => {
+      batchChanges(...run.params);
+
+      expect(run.params[0]).toStrictEqual(run.expected.state);
+    });
+
+    it.each([
+      ['Register the type', createRegister()],
+      ['Add a new pod', createNewEntry()],
+      ['Change a pod', createExisting()],
+      ['Remove a pod', createRemove()],
+      ['Create one pod, remove another', createAddRemove()],
+      ['Remove one pod, create another', createRemoveAdd()],
+      ['Add multiple types', createAddMultipleTypes()],
+      ['Remove a non-existing pod', removeNonExisting()],
+      ['Much much change', muchMuchChange()],
+    ])('%s', (_, run) => { // eslint-disable-line jest/no-identical-title
+      batchChanges(...run.params);
+      // Don't do straight up run.params[0] vs run.expected.... map doesn't get 'provided' so check fails
+      Object.entries(run.params[0].types).forEach(([type, cache]) => {
+        const { map: cacheMap, ...cacheState } = cache;
+        const { map: expectedMap, ...expected } = run.expected.types[type];
+
+        expect(cacheMap).toBeDefined();
+        expect(expectedMap).toBeDefined();
+
+        expect(cacheState).toStrictEqual(expected);
+        expect(cacheMap).toStrictEqual(expectedMap);
+      });
+    });
+  });
+});

package/plugins/dashboard-store/actions.js

@@ -6,6 +6,7 @@ import { createYaml } from '@shell/utils/create-yaml';
 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';
 
 export const _ALL = 'all';
 export const _MERGE = 'merge';
@@ -48,10 +49,7 @@ export async function loadSchemas(ctx, watch = true) {
     res.data = res.concat(spoofedTypes);
   }
 
-  res.data.forEach((schema) => {
-    schema._id = normalizeType(schema.id);
-    schema._group = normalizeType(schema.attributes?.group);
-  });
+  res.data.forEach(addSchemaIndexFields);
 
   commit('loadAll', {
     ctx,
@@ -85,6 +83,12 @@ export default {
 
     type = getters.normalizeType(type);
 
+    // if there's no registered type, then register it so
+    // that we don't have issues on 'loadAdd' mutation
+    if ( !getters.typeRegistered(type) ) {
+      commit('registerType', type);
+    }
+
     const loadCount = getters['loadCounter'](type);
 
     try {
@@ -117,7 +121,11 @@ export default {
         if (opt.hasManualRefresh) {
           dispatch('resource-fetch/updateManualRefreshIsLoading', false, { root: true });
         }
-        commit('setHaveAll', { type });
+        if (opt.namespaced) {
+          commit('setHaveNamespace', { type, namespace: opt.namespaced });
+        } else {
+          commit('setHaveAll', { type });
+        }
       }
     } catch (e) {
       if (opt.hasManualRefresh) {
@@ -140,16 +148,14 @@ export default {
       commit('registerType', type);
     }
 
-    if ( opt.force !== true && getters['haveAll'](type) ) {
+    if ( opt.force !== true && (getters['haveAll'](type) || getters['haveAllNamespace'](type, opt.namespaced))) {
       const args = {
         type,
         revision:  '',
         namespace: opt.watchNamespace
       };
 
-      // if we are coming from a resource that wasn't watched
-      // but for which we have results already, just return the results but start watching it
-      if (opt.watch !== false && !getters.watchStarted(args)) {
+      if (opt.watch !== false ) {
         dispatch('watch', args);
       }
 
@@ -297,8 +303,9 @@ export default {
         commit('loadAll', {
           ctx,
           type,
-          data: out.data,
-          skipHaveAll
+          data:      out.data,
+          skipHaveAll,
+          namespace: opt.namespaced,
         });
       }
     }
@@ -483,6 +490,15 @@ export default {
     });
   },
 
+  batchChanges(ctx, batch) {
+    const { commit } = ctx;
+
+    commit('batchChanges', {
+      ctx,
+      batch
+    });
+  },
+
   loadAll(ctx, { type, data }) {
     const { commit } = ctx;
 
@@ -516,20 +532,7 @@ export default {
   // Forget a type in the store
   // Remove all entries for that type and stop watching it
   forgetType({ commit, getters, dispatch }, type) {
-    const obj = {
-      type,
-      stop: true, // Stops the watch on a type
-    };
-
-    if (getters['schemaFor'](type) && getters['watchStarted'](obj)) {
-      // Set that we don't want to watch this type
-      // Otherwise, the dispatch to unwatch below will just cause a re-watch when we
-      // detect the stop message from the backend over the web socket
-      commit('setWatchStopped', obj);
-      dispatch('watch', obj); // Ask the backend to stop watching the type
-      // Make sure anything in the pending queue for the type is removed, since we've now removed the type
-      commit('clearFromQueue', type);
-    }
+    dispatch('unwatch', type);
 
     commit('forgetType', type);
   },
@@ -572,6 +575,10 @@ export default {
     return resource;
   },
 
+  cleanForDownload(ctx, resource) {
+    return resource;
+  },
+
   // Wait for a schema that is expected to exist that may not have been loaded yet (for instance when loadCluster is still running).
   async waitForSchema({ getters, dispatch }, { type }) {
     let tries = SCHEMA_CHECK_RETRIES;

package/plugins/dashboard-store/getters.js

@@ -11,6 +11,40 @@ import { keyFieldFor, normalizeType } from './normalize';
 import { lookup } from './model-loader';
 import garbageCollect from '@shell/utils/gc/gc';
 
+export const urlFor = (state, getters) => (type, id, opt) => {
+  opt = opt || {};
+  type = getters.normalizeType(type);
+  let url = opt.url;
+
+  if ( !url ) {
+    const schema = getters.schemaFor(type);
+
+    if ( !schema ) {
+      throw new Error(`Unknown schema for type: ${ type }`);
+    }
+
+    url = schema.links.collection;
+
+    if ( !url ) {
+      throw new Error(`You don't have permission to list this type: ${ type }`);
+    }
+
+    if ( id ) {
+      url += `/${ id }`;
+    }
+  }
+
+  if ( !url.startsWith('/') && !url.startsWith('http') ) {
+    const baseUrl = state.config.baseUrl.replace(/\/$/, '');
+
+    url = `${ baseUrl }/${ url }`;
+  }
+
+  url = getters.urlOptions(url, opt);
+
+  return url;
+};
+
 export default {
 
   all: (state, getters, rootState) => (type) => {
@@ -225,6 +259,21 @@ export default {
     return false;
   },
 
+  haveAllNamespace: (state, getters) => (type, namespace) => {
+    if (!namespace) {
+      return false;
+    }
+
+    type = getters.normalizeType(type);
+    const entry = state.types[type];
+
+    if ( entry ) {
+      return entry.haveNamespace === namespace;
+    }
+
+    return false;
+  },
+
   haveSelector: (state, getters) => (type, selector) => {
     type = getters.normalizeType(type);
     const entry = state.types[type];
@@ -244,39 +293,7 @@ export default {
     return keyFieldFor(type);
   },
 
-  urlFor: (state, getters) => (type, id, opt) => {
-    opt = opt || {};
-    type = getters.normalizeType(type);
-    let url = opt.url;
-
-    if ( !url ) {
-      const schema = getters.schemaFor(type);
-
-      if ( !schema ) {
-        throw new Error(`Unknown schema for type: ${ type }`);
-      }
-
-      url = schema.links.collection;
-
-      if ( !url ) {
-        throw new Error(`You don't have permission to list this type: ${ type }`);
-      }
-
-      if ( id ) {
-        url += `/${ id }`;
-      }
-    }
-
-    if ( !url.startsWith('/') && !url.startsWith('http') ) {
-      const baseUrl = state.config.baseUrl.replace(/\/$/, '');
-
-      url = `${ baseUrl }/${ url }`;
-    }
-
-    url = getters.urlOptions(url, opt);
-
-    return url;
-  },
+  urlFor,
 
   urlOptions: () => (url, opt) => {
     return url;