@rancher/shell 0.5.2 → 1.2.0

package/models/__tests__/provisioning.cattle.io.cluster.test.ts

@@ -1,90 +0,0 @@
-import ProvCluster from '@shell/models/provisioning.cattle.io.cluster';
-
-describe('class ProvCluster', () => {
-  const importedClusterInfo = {
-    clusterName: 'test', provisioner: 'imported', mgmt: { spec: { gkeConfig: {} } }, spec: {}
-  };
-  const importedGkeClusterInfo = {
-    clusterName: 'test', provisioner: 'rke2', mgmt: { spec: { gkeConfig: { imported: true } } }
-  };
-  const importedAksClusterInfo = {
-    clusterName: 'test', provisioner: 'rke2', mgmt: { spec: { aksConfig: { imported: true } } }
-  };
-  const importedEksClusterInfo = {
-    clusterName: 'test', provisioner: 'rke2', mgmt: { spec: { eksConfig: { imported: true } } }
-  };
-  const notImportedGkeClusterInfo = {
-    clusterName: 'test', provisioner: 'rke2', mgmt: { spec: { gkeConfig: { imported: false } }, rkeConfig: {} }
-  };
-  const importedClusterInfoWithProviderForEmberParam = {
-    clusterName: 'test', provisioner: 'rke2', mgmt: { providerForEmberParam: 'import' }
-  };
-  const localClusterInfo = {
-    clusterName: 'test', provisioner: 'imported', mgmt: { isLocal: true, spec: { gkeConfig: {} } }, spec: {}
-  };
-  const doRke2Info = {
-    clusterName: 'test', provisioner: 'rke2', mgmt: { isLocal: false, providerForEmberParam: 'import' }, spec: { rkeConfig: {} }
-  };
-
-  describe('isImported', () => {
-    const testCases = [
-      [importedClusterInfo, true],
-      [importedGkeClusterInfo, true],
-      [importedAksClusterInfo, true],
-      [importedEksClusterInfo, true],
-      [notImportedGkeClusterInfo, false],
-      [importedClusterInfoWithProviderForEmberParam, true],
-      [localClusterInfo, false],
-      [doRke2Info, false],
-      [{}, false],
-    ];
-    const resetMocks = () => {
-      // Clear all mock function calls:
-      jest.clearAllMocks();
-    };
-
-    it.each(testCases)('should return the isImported value properly based on the props data', (clusterData: Object, expected: Boolean) => {
-      const cluster = new ProvCluster({ spec: clusterData.spec });
-
-      jest.spyOn(cluster, 'mgmt', 'get').mockReturnValue(
-        clusterData.mgmt
-      );
-      jest.spyOn(cluster, 'provisioner', 'get').mockReturnValue(
-        clusterData.provisioner
-      );
-
-      expect(cluster.isImported).toBe(expected);
-      resetMocks();
-    }
-    );
-  });
-
-  describe('mgmt', () => {
-    const testCases = [
-      [importedClusterInfo, importedClusterInfo.mgmt],
-      [importedGkeClusterInfo, importedGkeClusterInfo.mgmt],
-      [importedAksClusterInfo, importedAksClusterInfo.mgmt],
-      [importedEksClusterInfo, importedEksClusterInfo.mgmt],
-      [notImportedGkeClusterInfo, notImportedGkeClusterInfo.mgmt],
-      [importedClusterInfoWithProviderForEmberParam, importedClusterInfoWithProviderForEmberParam.mgmt],
-      [localClusterInfo, localClusterInfo.mgmt],
-      [doRke2Info, doRke2Info.mgmt],
-      [{}, null],
-    ];
-
-    const resetMocks = () => {
-      // Clear all mock function calls:
-      jest.clearAllMocks();
-    };
-
-    it.each(testCases)('should return the isImported value properly based on the props data', (clusterData: Object, expected: Object) => {
-      const clusterMock = jest.fn(() => clusterData.mgmt);
-      const ctx = { rootGetters: { 'management/byId': clusterMock } };
-      const cluster = new ProvCluster({ status: { clusterName: clusterData.clusterName } }, ctx);
-
-      expect(cluster.mgmt).toBe(expected);
-      resetMocks();
-    }
-    );
-  });
-});

package/models/__tests__/workload.test.ts

@@ -1,91 +0,0 @@
-import Workload from '@shell/models/workload.js';
-import { steveClassJunkObject } from '@shell/plugins/steve/__tests__/utils/steve-mocks';
-
-describe('class: Workload', () => {
-  describe('given custom workload keys', () => {
-    const customContainerImage = 'image';
-    const customContainer = {
-      image:    customContainerImage,
-      __active: 'whatever',
-      active:   'whatever',
-      _init:    'whatever',
-      error:    'whatever',
-    };
-    const customWorkload = {
-      ...steveClassJunkObject,
-      type:        '123abv',
-      __rehydrate: 'whatever',
-      __clone:     'whatever',
-      spec:        {
-        template: {
-          spec: {
-            containers:     [customContainer],
-            initContainers: [customContainer],
-          }
-        }
-      }
-    };
-
-    customWorkload.metadata.name = 'abc';
-
-    it('should keep internal keys', () => {
-      const workload = new Workload(customWorkload, {
-        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
-        dispatch:    jest.fn(),
-        rootGetters: { 'i18n/t': jest.fn() },
-      });
-
-      expect({ ...workload }).toStrictEqual(customWorkload);
-    });
-
-    describe('method: save', () => {
-      it('should remove all the internal keys', async() => {
-        const dispatch = jest.fn();
-        const workload = new Workload(customWorkload, {
-          getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
-          dispatch,
-          rootGetters: {
-            'i18n/t':      jest.fn(),
-            'i18n/exists': () => true,
-          },
-        });
-        const expectation = {
-          metadata: {
-            name:                       'abc',
-            fields:                     'whatever',
-            resourceVersion:            'whatever',
-            clusterName:                'whatever',
-            deletionGracePeriodSeconds: 'whatever',
-            generateName:               'whatever',
-          },
-          spec: {
-            template: {
-              spec: {
-                containers:     [{ image: customContainerImage }],
-                initContainers: [{ image: customContainerImage }]
-              }
-            }
-          }
-        };
-
-        await workload.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: customWorkload.type });
-
-        // Original workload model should remain unchanged
-        expect({ ...workload }).toStrictEqual(customWorkload);
-      });
-    });
-  });
-});

package/plugins/clean-html.js

@@ -1,53 +0,0 @@
-import DOMPurify from 'dompurify';
-import { uniq } from '@shell/utils/array';
-
-const ALLOWED_TAGS = [
-  'code',
-  'li',
-  'a',
-  'p',
-  'b',
-  'br',
-  'ul',
-  'pre',
-  'span',
-  'div',
-  'i',
-  'em',
-  'strong',
-  'h1',
-  'h2',
-  'h3',
-  'h4',
-  'h5',
-  'h6',
-  'table',
-  'thead',
-  'tr',
-  'th',
-  'tbody',
-  'td',
-  'blockquote'
-];
-
-// Allow 'A' tags to keep the target=_blank attribute if they have it
-DOMPurify.addHook('uponSanitizeAttribute', (node, data) => {
-  if (node.tagName === 'A' && data.attrName === 'target' && data.attrValue === '_blank') {
-    data.forceKeepAttr = true;
-  }
-});
-
-// Ensure if an 'A' tag has target=_blank that we add noopener, noreferrer and nofollow to the 'rel' attribute
-DOMPurify.addHook('afterSanitizeAttributes', (node) => {
-  if (node.tagName === 'A' && node?.target === '_blank') {
-    const rel = ['noopener', 'noreferrer', 'nofollow'];
-    const existingRel = node.rel?.length ? node.rel.split(' ') : [];
-    const combined = uniq([...rel, ...existingRel]);
-
-    node.setAttribute('rel', combined.join(' '));
-  }
-});
-
-export const purifyHTML = (value, options = { ALLOWED_TAGS }) => {
-  return DOMPurify.sanitize(value, options);
-};

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

@@ -1,165 +0,0 @@
-import _actions from '@shell/plugins/dashboard-store/actions';
-
-const { findAll } = _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'
-    };
-
-    // 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('dashboard-store > actions > findAll', () => {
-    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);
-        }
-      );
-    });
-  });
-});

package/plugins/dashboard-store/__tests__/resource-class.test.ts

@@ -1,49 +0,0 @@
-import Resource from '@shell/plugins/dashboard-store/resource-class.js';
-import { resourceClassJunkObject } from '@shell/plugins/dashboard-store/__tests__/utils/store-mocks';
-
-describe('class: Resource', () => {
-  describe('given custom resource keys', () => {
-    const customResource = resourceClassJunkObject;
-
-    it('should keep internal keys', () => {
-      const resource = new Resource(customResource, {
-        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
-        dispatch:    jest.fn(),
-        rootGetters: { 'i18n/t': jest.fn() },
-      });
-
-      expect({ ...resource }).toStrictEqual(customResource);
-    });
-
-    describe('method: save', () => {
-      it('should remove all the internal keys', async() => {
-        const dispatch = jest.fn();
-        const resource = new Resource(customResource, {
-          getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
-          dispatch,
-          rootGetters: { 'i18n/t': jest.fn() },
-        });
-
-        const expectation = { type: customResource.type };
-
-        await resource.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({ ...resource }).toStrictEqual(customResource);
-      });
-    });
-  });
-});

package/plugins/dashboard-store/__tests__/utils/store-mocks.ts

@@ -1,7 +0,0 @@
-const customType = 'dsaf';
-
-export const resourceClassJunkObject = {
-  type:        customType,
-  __rehydrate: 'whatever',
-  __clone:     'whatever',
-};

package/plugins/index.js

@@ -1,11 +0,0 @@
-/**
- * Load the directives
- *
- * These are included in a function that can be explictly called, so that we can be sure
- * of the execution order, rather than importing them at the top of a file.
- */
-export function loadDirectives() {
-  import('./clean-html-directive');
-  import('./clean-tooltip-directive');
-  import('./directives');
-}

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

@@ -1,59 +0,0 @@
-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__/utils/steve-mocks.ts

@@ -1,31 +0,0 @@
-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/scripts/.gitlab/workflows/build-extension-catalog.gitlab-ci.yml

@@ -1,50 +0,0 @@
-.podman-setup: &podman-setup
-  - zypper --non-interactive install jq podman
-  - usermod --add-subuids 100000-165535 --add-subgids 100000-165535 $(id -nu)
-  - podman login -u $REGISTRY_USER -p $REGISTRY_PASSWORD $REGISTRY
-
-check_version_collisions:
-  stage: check_version
-  rules:
-    - changes:
-        - package.json
-  script:
-    - *podman-setup
-    - |
-      PACKAGE_VERSION=`jq -r .version package.json`
-      PACKAGE_NAME=`jq -r .name package.json`
-
-      readarray -t VERSIONS < <(podman search $REGISTRY/$IMAGE_NAMESPACE/ui-extension-$PACKAGE_NAME --list-tags --format {{.Tag}})
-
-      echo -e "Checking for version collisions with Extension version: ${PACKAGE_VERSION}"
-      for version in ${VERSIONS[@]}; do
-        if [[ ${version} == ${PACKAGE_VERSION} ]]; then
-          echo "Cannot overwrite production image version ${version} since it already exists."
-          podman logout $REGISTRY
-          exit 1
-        fi
-      done
-
-      echo -e "Published image not found for version ${PACKAGE_VERSION}, continuing build..."
-  tags:
-    - linux
-
-build_and_release:
-  stage: build_catalog
-  rules:
-    - changes:
-        - package.json
-  script:
-    - *podman-setup
-    - zypper addrepo https://download.opensuse.org/repositories/devel:languages:nodejs/SLE_12_SP5/devel:languages:nodejs.repo
-    - zypper --non-interactive --no-gpg-checks refresh
-    - zypper --non-interactive install go git nodejs14 npm helm
-    - YQ_URL="https://github.com/mikefarah/yq/releases/download/v4.35.2/yq_linux_amd64"
-    - curl -sLf ${YQ_URL} -o /usr/bin/yq && chmod +x /usr/bin/yq
-    - npm install -g --unsafe-perm yarn
-    - yarn
-    - yarn publish-pkgs -cl -r $REGISTRY -o $IMAGE_NAMESPACE
-    - podman push `podman images -f reference!=registry.suse.com/bci/bci-base --format "{{index .Names 0}}"`
-    - podman logout $REGISTRY
-  tags:
-    - linux