@rancher/shell 1.2.3 → 2.0.1

package/models/__tests__/namespace.test.ts

@@ -1,11 +1,48 @@
 import Namespace from '@shell/models/namespace';
+import { SYSTEM_NAMESPACE } from '@shell/config/labels-annotations';
+import SYSTEM_NAMESPACES from '@shell/config/system-namespaces';
 
 describe('class Namespace', () => {
   describe('checking if isSystem', () => {
     it.each([
-      ['c-whatever-system', true],
-      ['whatever', false]
-    ])('should return true if end with "-system', (name, expectation) => {
+      ['whatever1', SYSTEM_NAMESPACE, true],
+      ['whatever2', 'any-annotation', false],
+      ['whatever3', '', false]
+    ])('should return true if it has the correct annotation', (name, annotation, expectation) => {
+      const namespace = new Namespace({});
+
+      namespace.metadata = { ...namespace.metadata, name };
+
+      if (annotation) {
+        namespace.metadata.annotations = { [annotation]: 'true' };
+      }
+
+      expect(namespace.isSystem).toBe(expectation);
+    });
+
+    const assertionsArr = [];
+
+    SYSTEM_NAMESPACES.forEach((ns) => {
+      assertionsArr.push([ns, true]);
+    });
+
+    assertionsArr.push(['c-whatever-system', false]);
+    assertionsArr.push(['cattle-whatever', false]);
+    assertionsArr.push(['', false]);
+
+    it.each(assertionsArr)('should return true if it belongs to the curated list of namespaces', (name, expectation) => {
+      const namespace = new Namespace({});
+
+      namespace.metadata = { ...namespace.metadata, name };
+
+      expect(namespace.isSystem).toBe(expectation);
+    });
+
+    it.each([
+      ['cattle-c-whatever-system', true],
+      ['cattle-whatever', false],
+      ['c-whatever-system', false]
+    ])('should return true if starts with "cattle-" end with "-system', (name, expectation) => {
       const namespace = new Namespace({});
 
       namespace.metadata = { ...namespace.metadata, name };
@@ -18,18 +55,21 @@ describe('class Namespace', () => {
 
   describe('checking if isObscure', () => {
     it.each([
-      ['c-whatever-system', true],
-      ['whatever', false],
-      ['', false]
-    ])('should return a value if has or not a name in the metadata', (name, expectation) => {
+      ['c-whatever-system', 'management.cattle.io/system-namespace', true],
+      ['p-whatever', SYSTEM_NAMESPACE, true],
+      ['p-whatever', '', false],
+      ['', '', false]
+    ])('should return a value if is system AND has the correct prefix', (name, annotation, expectation) => {
       const namespace = new Namespace({});
 
       namespace.metadata = { ...namespace.metadata, name };
 
+      if (annotation) {
+        namespace.metadata.annotations = { [annotation]: 'true' };
+      }
+
       expect(namespace.isObscure).toBe(expectation);
     });
-
-    it.todo('should return a value if is or not system');
   });
 
   it.each([

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

@@ -0,0 +1,241 @@
+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: {} }
+  };
+
+  const gkeClusterWithPrivateEndpoint = {
+    clusterName: 'test',
+    provisioner: 'GKE',
+    spec:        { rkeConfig: {} },
+    mgmt:        { spec: { gkeConfig: { privateClusterConfig: { enablePrivateEndpoint: true } } } }
+  };
+
+  const eksClusterWithPrivateEndpoint = {
+    clusterName: 'test',
+    provisioner: 'EKS',
+    spec:        { rkeConfig: {} },
+    mgmt:        { spec: { eksConfig: { privateAccess: true } } }
+  };
+
+  const aksClusterWithPrivateEndpoint = {
+    clusterName: 'test',
+    provisioner: 'AKS',
+    spec:        { rkeConfig: {} },
+    mgmt:        { spec: { aksConfig: { privateCluster: true } } }
+  };
+
+  // Related to https://github.com/rancher/dashboard/issues/9402
+  describe('isHostedKubernetesProvider + isPrivateHostedProvider', () => {
+    const testCases = [
+      [gkeClusterWithPrivateEndpoint, true],
+      [eksClusterWithPrivateEndpoint, true],
+      [aksClusterWithPrivateEndpoint, true],
+    ];
+    const resetMocks = () => {
+      // Clear all mock function calls:
+      jest.clearAllMocks();
+    };
+
+    it.each(testCases)('should return the isHostedKubernetesProvider and isPrivateHostedProvider values 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.isRke2).toBe(expected);
+      expect(cluster.isHostedKubernetesProvider).toBe(expected);
+      expect(cluster.isPrivateHostedProvider).toBe(expected);
+      resetMocks();
+    });
+  });
+
+  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();
+    });
+  });
+
+  describe('hasError', () => {
+    const conditionsWithoutError = [
+      {
+        error:          false,
+        lastUpdateTime: '2022-10-17T23:09:15Z',
+        status:         'True',
+        transitioning:  false,
+        type:           'Ready'
+      },
+    ];
+
+    const conditionsWithoutReady = [
+      {
+        error:          true,
+        lastUpdateTime: '2022-10-17T23:09:15Z',
+        status:         'False',
+        message:        'some-error-message',
+        transitioning:  false,
+        type:           'Pending'
+      },
+    ];
+
+    const noConditions:[] = [];
+
+    const conditionsWithReadyLatest = [
+      {
+        error:          true,
+        lastUpdateTime: '2022-10-17T23:09:15Z',
+        status:         'False',
+        message:        'some-error-message',
+        transitioning:  false,
+        type:           'Pending'
+      },
+      {
+        error:          false,
+        lastUpdateTime: '2023-10-17T23:09:15Z',
+        status:         'True',
+        transitioning:  false,
+        type:           'Ready'
+      }
+    ];
+
+    const conditionsWithErrorLatest = [
+      {
+        error:          false,
+        lastUpdateTime: '2022-10-17T23:09:15Z',
+        status:         'True',
+        transitioning:  false,
+        type:           'Ready'
+      },
+      {
+        error:          true,
+        lastUpdateTime: '2023-10-17T23:09:15Z',
+        status:         'False',
+        message:        'some-error-message',
+        transitioning:  false,
+        type:           'Pending'
+      }
+    ];
+
+    const conditionsWithProblemInLastUpdateTimeProp = [
+      {
+        error:          true,
+        lastUpdateTime: '',
+        status:         'False',
+        message:        'some-error-message',
+        transitioning:  false,
+        type:           'Pending'
+      },
+      {
+        error:          false,
+        lastUpdateTime: '2023-10-17T23:09:15Z',
+        status:         'True',
+        transitioning:  false,
+        type:           'Ready'
+      }
+    ];
+
+    const testCases = [
+      ['conditionsWithoutError', conditionsWithoutError, false],
+      ['conditionsWithoutReady', conditionsWithoutReady, true],
+      ['noConditions', noConditions, false],
+      ['conditionsWithReadyLatest', conditionsWithReadyLatest, false],
+      ['conditionsWithErrorLatest', conditionsWithErrorLatest, true],
+      ['conditionsWithProblemInLastUpdateTimeProp', conditionsWithProblemInLastUpdateTimeProp, false],
+    ];
+
+    const resetMocks = () => {
+      // Clear all mock function calls
+      jest.clearAllMocks();
+    };
+
+    it.each(testCases)('should return the hasError value properly based on the "status.conditions" props data for testcase %p', (testName: string, conditions: Array, expected: Boolean) => {
+      const ctx = { rootGetters: { 'management/byId': jest.fn() } };
+      const cluster = new ProvCluster({ status: { conditions } }, ctx);
+
+      expect(cluster.hasError).toBe(expected);
+      resetMocks();
+    }
+    );
+  });
+});

package/models/__tests__/schema.tests.ts

@@ -0,0 +1,24 @@
+import { parseType } from '@shell/models/schema';
+
+describe('class: schema:', () => {
+  describe('parseType', () => {
+    it.each([
+      ['array', undefined, ['array']],
+      ['map', undefined, ['map']],
+      ['io.cattle.provisioning.v1.Cluster.status', undefined, ['io.cattle.provisioning.v1.Cluster.status']],
+
+      ['array[string]', undefined, ['array', 'string']],
+      ['array', { subtype: 'string' }, ['array', 'string']],
+      ['map[string]', undefined, ['map', 'string']],
+      ['map', { subtype: 'string' }, ['map', 'string']],
+
+      ['array[io.cattle.provisioning.v1.Cluster.status]', undefined, ['array', 'io.cattle.provisioning.v1.Cluster.status']],
+      ['array', { subtype: 'io.cattle.provisioning.v1.Cluster.status' }, ['array', 'io.cattle.provisioning.v1.Cluster.status']],
+      ['map[io.cattle.provisioning.v1.Cluster.status]', undefined, ['map', 'io.cattle.provisioning.v1.Cluster.status']],
+      ['map', { subtype: 'io.cattle.provisioning.v1.Cluster.status' }, ['map', 'io.cattle.provisioning.v1.Cluster.status']],
+
+    ])('string: %p and field: %p ... should equal %p', (val, field, expected) => {
+      expect(parseType(val, field)).toStrictEqual(expected);
+    });
+  });
+});

package/models/__tests__/secret.test.ts

@@ -0,0 +1,37 @@
+import Secret from '@shell/models/secret';
+
+describe('class Secret', () => {
+  it('should contains the type attribute if cleanForDownload', async() => {
+    const secret = new Secret({});
+    const yaml = `apiVersion: v1
+kind: Secret
+metadata:
+  name: my-secret
+type: Opaque
+`;
+    const cleanYaml = await secret.cleanForDownload(yaml);
+
+    expect(cleanYaml).toBe(yaml);
+  });
+
+  it('should remove id, links and actions keys if cleanForDownload', async() => {
+    const secret = new Secret({});
+    const expectedYamlStr = `apiVersion: v1
+kind: Secret
+metadata:
+  name: my-secret
+  namespace: default
+type: Opaque
+`;
+    const part = `id: test_id
+links:
+  view: https://example.com
+actions:
+  remove: https://example.com`;
+    const yaml = `${ expectedYamlStr }
+${ part }`;
+    const cleanYaml = await secret.cleanForDownload(yaml);
+
+    expect(cleanYaml).toBe(expectedYamlStr);
+  });
+});

package/models/__tests__/steve-schema.test.ts

@@ -0,0 +1,73 @@
+import SteveSchema from '@shell/models/steve-schema';
+import { replace } from '@shell/plugins/dashboard-store/mutations';
+
+describe('class SteveSchema', () => {
+  describe('schema diet', () => {
+    it('schema Definitions', async() => {
+      const store = 'cluster';
+      const schemaName = 'steveTest';
+
+      SteveSchema.reset(store);
+
+      const testSchema = {
+        id:             schemaName,
+        metadata:       { name: schemaName },
+        resourceFields: null,
+        links:          { self: `/v1/schemas/${ schemaName }` }
+      };
+      const testSchemaDefinition = {
+        type:           schemaName,
+        resourceFields: {
+          a: {},
+          b: {},
+        }
+      };
+      const testSecondarySchemaDefinitions = {
+        a: { type: 'a' },
+        b: { type: 'b' }
+      };
+
+      const schemaModel = new SteveSchema(testSchema, {
+        dispatch: jest.fn().mockImplementation((action, opts) => {
+          expect(action).toBe('request');
+          expect(opts.type).toBe('schemaDefinition');
+          expect(opts.url).toBe(`/v1/schemaDefinitions/${ schemaName }`);
+
+          return {
+            definitionType: schemaName,
+            definitions:    {
+              [schemaName]: testSchemaDefinition,
+              ...testSecondarySchemaDefinitions,
+            }
+          };
+        }),
+        state: { config: { namespace: store } }
+      });
+
+      // We have no schema definition info, however we know that schema definitions should be fetched
+      expect(schemaModel.schemaDefinition).toBeNull();
+      expect(schemaModel.schemaDefinitions).toBeNull();
+      expect(schemaModel.requiresResourceFields).toBeTruthy();
+      expect(schemaModel.hasResourceFields).toBeFalsy();
+
+      // Fetch schema definition
+      await schemaModel.fetchResourceFields();
+
+      // We have schema definition info
+      expect(schemaModel.schemaDefinition).toStrictEqual(testSchemaDefinition);
+      expect(schemaModel.schemaDefinitions).toStrictEqual(testSecondarySchemaDefinitions);
+      expect(schemaModel.requiresResourceFields).toBeTruthy();
+      expect(schemaModel.hasResourceFields).toBeTruthy();
+
+      // Uhoh, there's been an update over socket. Socket process calls the `load` mutator which then calls `replace`.
+      // This wipes out ALL properties on our poor schema model and applies everything from the one we get over socket
+      replace(schemaModel, { ...testSchema });
+
+      // All schema definition info should still work (this matches above)
+      expect(schemaModel.schemaDefinition).toStrictEqual(testSchemaDefinition);
+      expect(schemaModel.schemaDefinitions).toStrictEqual(testSecondarySchemaDefinitions);
+      expect(schemaModel.requiresResourceFields).toBeTruthy();
+      expect(schemaModel.hasResourceFields).toBeTruthy();
+    });
+  });
+});

package/models/__tests__/storage.k8s.io.storageclass.test.ts

@@ -0,0 +1,22 @@
+import StorageClass, { PROVISIONER_OPTIONS } from '@shell/models/storage.k8s.io.storageclass';
+
+describe('class StorageClass', () => {
+  describe('checking if provisionerDisplay', () => {
+    it.each([
+      ['kubernetes.io/azure-disk', true],
+      ['kubernetes.io/portworx-volume', true],
+      ['rancher.io/local-path', false],
+      ['some-random-string-as-provisioner', false],
+    ])('should NOT show a suffix IF they are built-in (on the PROVISIONER_OPTIONS list)', (provisioner, expectation) => {
+      const storageClass = new StorageClass({
+        metadata: {},
+        spec:     {},
+        provisioner
+      });
+
+      jest.spyOn(storageClass, '$rootGetters', 'get').mockReturnValue({ 'i18n/t': jest.fn() });
+
+      expect(!!PROVISIONER_OPTIONS.find((opt) => opt.value === provisioner)).toBe(expectation);
+    });
+  });
+});

package/models/__tests__/workload.test.ts

@@ -0,0 +1,91 @@
+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 as any).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/models/catalog.cattle.io.app.js

@@ -39,6 +39,14 @@ export default class CatalogApp extends SteveModel {
     return out;
   }
 
+  get warnDeletionMessage() {
+    if (this.upgradeAvailable === false) {
+      return this.t('catalog.delete.warning.managed', { name: this.name });
+    }
+
+    return null;
+  }
+
   matchingChart(includeHidden) {
     const chart = this.spec?.chart;
 

package/models/catalog.cattle.io.clusterrepo.js

@@ -44,6 +44,14 @@ export default class ClusterRepo extends SteveModel {
     return !!this.spec?.gitRepo;
   }
 
+  get isOciType() {
+    const hasExplicitOciUrl = this.spec.url?.split(':')[0] === 'oci';
+    // insecurePlainHttp is only valid for OCI URL's and allows insecure connections to registries without enforcing TLS checks
+    const hasInsecurePlainHttp = Object.prototype.hasOwnProperty.call(this.spec, ('insecurePlainHttp'));
+
+    return hasExplicitOciUrl || hasInsecurePlainHttp;
+  }
+
   get isRancherSource() {
     let parsed;
 
@@ -107,7 +115,7 @@ export default class ClusterRepo extends SteveModel {
     if ( this.spec.gitRepo ) {
       return 'git';
     } else if ( this.spec.url ) {
-      return 'http';
+      return this.isOciType ? 'oci' : 'http';
     } else {
       return '?';
     }

package/models/catalog.cattle.io.uiplugin.js

@@ -1,6 +1,10 @@
 import SteveModel from '@shell/plugins/steve/steve-class';
 
-const CACHED_STATUS = 'cached';
+const CACHE_STATE = Object.freeze({
+  CACHED:   'cached',
+  DISABLED: 'disabled',
+  PENDING:  'pending',
+});
 
 export default class UIPlugin extends SteveModel {
   get name() {
@@ -15,13 +19,8 @@ export default class UIPlugin extends SteveModel {
     return this.spec?.plugin?.version;
   }
 
-  get willBeCached() {
-    return this.spec?.plugin?.noCache === false;
-  }
-
-  // Has the plugin been cached?
-  get isCached() {
-    return !this.willBeCached || (this.willBeCached && this.status?.cacheState === CACHED_STATUS);
+  get isInitialized() {
+    return this.status?.cacheState !== CACHE_STATE.PENDING;
   }
 
   get pluginMetadata() {

package/models/cis.cattle.io.clusterscan.js

@@ -7,6 +7,34 @@ import { sortBy } from '@shell/utils/sort';
 import day from 'dayjs';
 import SteveModel from '@shell/plugins/steve/steve-class';
 
+// This could be removed and just replaced with schema.fetchResourceFields()... but there's some getters that use hasSpecsScheduledScanConfig before it runs
+/**
+ * For the given schema, determine if the schema of it's associated scan's type has scheduledScanConfig
+ *
+ * This is resourceFields based, so we need to fetch schema definition
+ */
+export const fetchSpecsScheduledScanConfig = async(schema) => {
+  await schema.fetchResourceFields();
+
+  return hasSpecsScheduledScanConfig(schema);
+};
+
+/**
+ * For the given schema, determine if the schema of it's associated scan's type has scheduledScanConfig
+ *
+ * Assumes schemaDefinitions have been fetched (see async fetchSpecsScheduledScanConfig above)
+ */
+export const hasSpecsScheduledScanConfig = (schema) => {
+  const specSchemaId = get(schema, 'resourceFields.spec.type');
+  const specSchema = schema.schemaDefinitions?.[specSchemaId];
+
+  if (!specSchema) {
+    return false;
+  }
+
+  return !!get(specSchema, 'resourceFields.scheduledScanConfig');
+};
+
 export default class ClusterScan extends SteveModel {
   get _availableActions() {
     let out = super._availableActions;
@@ -64,14 +92,7 @@ export default class ClusterScan extends SteveModel {
   }
 
   canBeScheduled() {
-    const schema = this.$getters['schemaFor'](this.type);
-    const specSchema = this.$getters['schemaFor'](get(schema, 'resourceFields.spec.type') || '');
-
-    if (!specSchema) {
-      return false;
-    }
-
-    return !!get(specSchema, 'resourceFields.scheduledScanConfig');
+    return hasSpecsScheduledScanConfig(this.$getters['schemaFor'](this.type));
   }
 
   get isScheduled() {