dashboard-shell-shell 3.0.2-test.20250913 → 3.0.5-logTest.2

package/mixins/resource-table-watch.js

@@ -0,0 +1,45 @@
+import { STEVE_WATCH_MODE } from '@shell/types/store/subscribe.types';
+
+// This is functionality used to stop or start sockets used to watch resources in the vai world.
+// Currently disabled via (non-public) perf setting
+// See https://github.com/rancher/dashboard/issues/14359 for long term plan
+
+export default {
+  props: {
+    schema: {
+      type:    Object,
+      default: null,
+    },
+  },
+
+  data() {
+    // Note - does not cover anything fetched by secondary / page functions
+    const watchOpts = this.schema?.id ? {
+      type: this.schema.id,
+      mode: STEVE_WATCH_MODE.RESOURCE_CHANGES
+      // Note - we don't restrict watch by namespace (would involve unwatch, request, watch with new revision on every change to ns filter)
+    } : undefined;
+
+    return { watchOpts };
+  },
+
+  computed: {
+    watching() {
+      return this.$store.getters[`${ this.inStore }/watchStarted`](this.watchOpts);
+    },
+  },
+
+  methods: {
+    toggleWatch(toggle) {
+      if (toggle) {
+        // Assume there's a gap between cache and reality, to restart watch with something that will make a new http request to refresh it
+        this.$store.dispatch(`${ this.inStore }/resyncWatch`, {
+          ...this.watchOpts,
+          resourceType: this.watchOpts?.type
+        });
+      } else {
+        this.$store.dispatch(`${ this.inStore }/unwatch`, this.watchOpts);
+      }
+    }
+  }
+};

package/mixins/vue-select-overrides.js

@@ -1,8 +1,5 @@
 
 export default {
-  data() {
-    return { overridesMixinPreventDoubleTriggerKeysOpen: false };
-  },
   methods: {
     mappedKeys(map, vm) {
       // Defaults found at - https://github.com/sagalbot/vue-select/blob/master/src/components/Select.vue#L947
@@ -23,6 +20,7 @@ export default {
         e.preventDefault();
         e.stopPropagation();
 
+        this.isOpen = false;
         vm.open = false;
         vm.search = '';
 
@@ -63,7 +61,6 @@ export default {
           if (vm.closeOnSelect) {
             // this ties in to the Select component implementation
             // so that the enter key handler doesn't open the dropdown again
-            this.overridesMixinPreventDoubleTriggerKeysOpen = true;
             vm.open = false;
             vm.typeAheadPointer = -1;
           }

package/models/__tests__/chart.test.ts

@@ -0,0 +1,296 @@
+import Chart from '@shell/models/chart';
+import { APP_UPGRADE_STATUS } from '@shell/store/catalog';
+import { CATALOG as CATALOG_ANNOTATIONS } from '@shell/config/labels-annotations';
+import { ZERO_TIME } from '@shell/config/types';
+
+const base = {
+  chartName:       'my-app',
+  repoName:        'my-repo',
+  repoNameDisplay: 'My Repo',
+  versions:        [
+    {
+      version: '1.3.0', home: 'https://example.com', created: '2024-03-10T12:00:00Z'
+    },
+    { version: '1.2.3', home: 'https://example.com' }
+  ],
+  categories: [],
+  tags:       [],
+  deprecated: false
+};
+
+function makeInstalledApp(upgradeAvailable = APP_UPGRADE_STATUS.NO_UPGRADE) {
+  return {
+    spec: {
+      chart: {
+        metadata: {
+          name:        'my-app',
+          version:     '1.3.0',
+          home:        'https://example.com',
+          annotations: { [CATALOG_ANNOTATIONS.SOURCE_REPO_NAME]: 'my-repo' }
+        }
+      }
+    },
+    upgradeAvailable
+  };
+}
+
+describe('class Chart', () => {
+  describe('matchingInstalledApps', () => {
+    it('matches by name, repo, and home in latest version', () => {
+      const installedApp = makeInstalledApp();
+
+      const chart = new Chart(base, { rootGetters: { 'cluster/all': () => [installedApp] } });
+
+      expect(chart.matchingInstalledApps).toHaveLength(1);
+    });
+
+    it('does not match if name is different', () => {
+      const installedApp = makeInstalledApp();
+
+      installedApp.spec.chart.metadata.name = 'different-app';
+
+      const chart = new Chart(base, { rootGetters: { 'cluster/all': () => [installedApp] } });
+
+      expect(chart.matchingInstalledApps).toHaveLength(0);
+    });
+
+    it('does not match if repo is different', () => {
+      const installedApp = makeInstalledApp();
+
+      installedApp.spec.chart.metadata.annotations[CATALOG_ANNOTATIONS.SOURCE_REPO_NAME] = 'different-repo';
+
+      const chart = new Chart(base, { rootGetters: { 'cluster/all': () => [installedApp] } });
+
+      expect(chart.matchingInstalledApps).toHaveLength(0);
+    });
+
+    it('matches by version+home when not latest', () => {
+      const installedApp = makeInstalledApp();
+
+      installedApp.spec.chart.metadata.version = '1.2.3'; // not the latest in base
+
+      const chart = new Chart(base, { rootGetters: { 'cluster/all': () => [installedApp] } });
+
+      expect(chart.matchingInstalledApps).toHaveLength(1);
+    });
+
+    it('can use fallback repo from metadata labels', () => {
+      const installedApp = makeInstalledApp();
+
+      installedApp.spec.chart.metadata.annotations = {}; // remove SOURCE_REPO_NAME
+      installedApp.metadata = { labels: { [CATALOG_ANNOTATIONS.CLUSTER_REPO_NAME]: 'my-repo' } };
+
+      const chart = new Chart(base, { rootGetters: { 'cluster/all': () => [installedApp] } });
+
+      expect(chart.matchingInstalledApps).toHaveLength(1);
+    });
+  });
+
+  describe('isInstalled', () => {
+    it('is true when one app matches', () => {
+      const installedApp = {
+        spec: {
+          chart: {
+            metadata: {
+              name:        'my-app',
+              version:     '1.2.3',
+              home:        'https://example.com',
+              annotations: { [CATALOG_ANNOTATIONS.SOURCE_REPO_NAME]: 'my-repo' }
+            }
+          }
+        }
+      };
+
+      const chart = new Chart(base, { rootGetters: { 'cluster/all': () => [installedApp] } });
+
+      expect(chart.isInstalled).toBe(true);
+    });
+
+    it('is false when no apps match', () => {
+      const chart = new Chart(base, { rootGetters: { 'cluster/all': () => [] } });
+
+      expect(chart.isInstalled).toBe(false);
+    });
+
+    it('is false when multiple apps match', () => {
+      const appTemplate = {
+        spec: {
+          chart: {
+            metadata: {
+              name:        'my-app',
+              version:     '1.2.3',
+              home:        'https://example.com',
+              annotations: { [CATALOG_ANNOTATIONS.SOURCE_REPO_NAME]: 'my-repo' }
+            }
+          }
+        }
+      };
+
+      const chart = new Chart(base, { rootGetters: { 'cluster/all': () => [appTemplate, appTemplate] } });
+
+      expect(chart.isInstalled).toBe(false);
+    });
+  });
+
+  describe('upgradeable', () => {
+    it('is true when installed and upgradeAvailable is SINGLE_UPGRADE', () => {
+      const installedApp = {
+        spec: {
+          chart: {
+            metadata: {
+              name:        'my-app',
+              version:     '1.2.3',
+              home:        'https://example.com',
+              annotations: { [CATALOG_ANNOTATIONS.SOURCE_REPO_NAME]: 'my-repo' }
+            }
+          }
+        },
+        upgradeAvailable: APP_UPGRADE_STATUS.SINGLE_UPGRADE
+      };
+
+      const chart = new Chart(base, { rootGetters: { 'cluster/all': () => [installedApp] } });
+
+      expect(chart.upgradeable).toBe(true);
+    });
+
+    it('is false if upgradeAvailable is different', () => {
+      const installedApp = {
+        spec: {
+          chart: {
+            metadata: {
+              name:        'my-app',
+              version:     '1.2.3',
+              home:        'https://example.com',
+              annotations: { [CATALOG_ANNOTATIONS.SOURCE_REPO_NAME]: 'my-repo' }
+            }
+          }
+        },
+        upgradeAvailable: APP_UPGRADE_STATUS.NO_UPGRADE
+      };
+
+      const chart = new Chart(base, { rootGetters: { 'cluster/all': () => [installedApp] } });
+
+      expect(chart.upgradeable).toBe(false);
+    });
+
+    it('is false when not installed', () => {
+      const chart = new Chart(base, { rootGetters: { 'cluster/all': () => [] } });
+
+      expect(chart.upgradeable).toBe(false);
+    });
+  });
+
+  describe('cardContent', () => {
+    it('includes correct subHeader and footer info', () => {
+      const chart = new Chart(base, { rootGetters: { 'cluster/all': () => [] } });
+
+      const result = chart.cardContent;
+
+      expect(result.subHeaderItems).toHaveLength(2);
+      expect(result.subHeaderItems[0].label).toBe('1.3.0');
+      expect(result.subHeaderItems[1].label).toBe('Mar 10, 2024');
+
+      expect(result.footerItems).toHaveLength(1);
+      expect(result.footerItems[0].labels).toContain('My Repo');
+
+      expect(result.statuses).toHaveLength(0);
+    });
+
+    it('includes category and tag items when present', () => {
+      const chart = new Chart({
+        ...base,
+        categories: ['database'],
+        tags:       ['linux', 'experimentl']
+      }, { rootGetters: { 'cluster/all': () => [] } });
+
+      const result = chart.cardContent;
+
+      expect(result.footerItems).toHaveLength(3);
+
+      const categoryItem = result.footerItems.find((i) => i.icon === 'icon-category-alt');
+
+      expect(categoryItem).toBeDefined();
+      expect(categoryItem.labels).toContain('database');
+
+      const tagItem = result.footerItems.find((i) => i.icon === 'icon-tag-alt');
+
+      expect(tagItem).toBeDefined();
+      expect(tagItem.labels).toStrictEqual(expect.arrayContaining(['linux', 'experimentl']));
+    });
+
+    it('includes deprecated status when deprecated is true', () => {
+      const chart = new Chart({ ...base, deprecated: true }, { rootGetters: { 'cluster/all': () => [] } });
+
+      const result = chart.cardContent;
+
+      const deprecatedStatus = result.statuses.find((s) => s.tooltip.key === 'generic.deprecated');
+
+      expect(deprecatedStatus).toBeDefined();
+      expect(deprecatedStatus.color).toBe('error');
+    });
+
+    it('includes installed status when app is installed', () => {
+      const installedApp = makeInstalledApp();
+
+      const chart = new Chart(base, { rootGetters: { 'cluster/all': () => [installedApp] } });
+
+      const result = chart.cardContent;
+
+      const installedStatus = result.statuses.find((s) => s.tooltip.key === 'generic.installed');
+
+      expect(installedStatus).toBeDefined();
+      expect(installedStatus.color).toBe('success');
+    });
+
+    it('includes upgradeable status when upgrade is available', () => {
+      const installedApp = makeInstalledApp(APP_UPGRADE_STATUS.SINGLE_UPGRADE);
+
+      const chart = new Chart(base, { rootGetters: { 'cluster/all': () => [installedApp] } });
+
+      const result = chart.cardContent;
+
+      const upgradeableStatus = result.statuses.find((s) => s.tooltip.key === 'generic.upgradeable');
+
+      expect(upgradeableStatus).toBeDefined();
+      expect(upgradeableStatus.color).toBe('info');
+    });
+
+    it('shows all statuses together when all conditions are met', () => {
+      const installedApp = makeInstalledApp(APP_UPGRADE_STATUS.SINGLE_UPGRADE);
+
+      const chart = new Chart({ ...base, deprecated: true }, { rootGetters: { 'cluster/all': () => [installedApp] } });
+
+      const result = chart.cardContent;
+
+      const keys = result.statuses.map((s) => s.tooltip.key);
+
+      expect(keys).toStrictEqual(expect.arrayContaining([
+        'generic.deprecated',
+        'generic.upgradeable',
+        'generic.installed'
+      ]));
+    });
+
+    it('handles zero time for last updated date', () => {
+      const chartWithZeroTime = {
+        ...base,
+        versions: [{
+          ...base.versions[0],
+          created: ZERO_TIME,
+        }]
+      };
+      const chart = new Chart(chartWithZeroTime, {
+        rootGetters: {
+          'cluster/all': () => [],
+          'i18n/t':      (key) => key
+        },
+      });
+
+      const result = chart.cardContent;
+      const lastUpdatedItem = result.subHeaderItems[1];
+
+      expect(lastUpdatedItem.label).toBe('generic.na');
+      expect(lastUpdatedItem.labelTooltip).toBe('catalog.charts.appChartCard.subHeaderItem.missingVersionDate');
+    });
+  });
+});

package/models/__tests__/fleet.cattle.io.gitrepo.test.ts

@@ -127,7 +127,7 @@ describe('class GitRepo', () => {
   describe('resourcesStatuses', () => {
     it.each([
       []
-    ])('foobat', () => {
+    ])('fn', () => {
       jest.spyOn(GitRepo.prototype, '$getters', 'get').mockReturnValue({ byId: jest.fn() });
 
       jest.spyOn(GitRepo.prototype, 'targetClusters', 'get').mockReturnValue([{

package/models/__tests__/fleet.cattle.io.helmop.test.ts

@@ -0,0 +1,224 @@
+import HelmOp from '@shell/models/fleet.cattle.io.helmop.js';
+
+describe('class HelmOp', () => {
+  let instance;
+
+  describe('source getter', () => {
+    it('should return correct source for SOURCE_TYPE.REPO (HTTPS)', () => {
+      instance = new HelmOp({
+        spec: {
+          helm: {
+            repo:  'https://charts.rancher.io/fleet',
+            chart: 'fleet-agent'
+          }
+        }
+      });
+
+      const source = instance.source;
+
+      expect(source.value).toBe('https://charts.rancher.io/fleet');
+      expect(source.display).toBe('charts.rancher.io/fleet');
+      expect(source.icon).toBe('icon icon-application');
+      expect(source.showLink).toBe(true);
+    });
+
+    it('should return correct source for SOURCE_TYPE.REPO (GitHub HTTPS .git)', () => {
+      instance = new HelmOp({
+        spec: {
+          helm: {
+            repo:  'https://github.com/rancher/fleet.git',
+            chart: 'fleet'
+          }
+        }
+      });
+
+      const source = instance.source;
+
+      expect(source.value).toBe('https://github.com/rancher/fleet.git');
+      expect(source.display).toBe('rancher/fleet');
+      expect(source.icon).toBe('icon icon-application');
+      expect(source.showLink).toBe(true);
+    });
+
+    it('should return correct source for SOURCE_TYPE.REPO (GitHub SSH)', () => {
+      instance = new HelmOp({
+        spec: {
+          helm: {
+            repo:  'git@github.com:rancher/fleet.git',
+            chart: 'fleet'
+          }
+        }
+      });
+
+      const source = instance.source;
+
+      expect(source.value).toBe('https://github.com/rancher/fleet');
+      expect(source.display).toBe('rancher/fleet');
+      expect(source.icon).toBe('icon icon-application');
+      expect(source.showLink).toBe(true);
+    });
+
+    it('should return correct source for SOURCE_TYPE.OCI', () => {
+      instance = new HelmOp({ spec: { helm: { repo: 'oci://ghcr.io/rancher/some-chart' } } });
+
+      const source = instance.source;
+
+      expect(source.value).toBe('oci://ghcr.io');
+      expect(source.display).toBe('oci://ghcr.io');
+      expect(source.icon).toBe('icon icon-application');
+      expect(source.showLink).toBe(false);
+    });
+
+    it('should return correct source for SOURCE_TYPE.TARBALL', () => {
+      instance = new HelmOp({ spec: { helm: { chart: 'https://github.com/rancher/fleet-helm-charts/releases/download/fleet-0.12.1-beta.2/fleet-0.12.1-beta.2.tgz' } } });
+
+      const source = instance.source;
+
+      expect(source.value).toBe('https://github.com/rancher/fleet-helm-charts/releases/download/fleet-0.12.1-beta.2/fleet-0.12.1-beta.2.tgz');
+      expect(source.display).toBe('rancher/fleet-helm-charts/releases/download/fleet-0.12.1-beta.2/fleet-0.12.1-beta.2.tgz');
+      expect(source.icon).toBe('icon icon-application');
+      expect(source.showLink).toBe(true);
+    });
+
+    it('should handle missing helm spec gracefully', () => {
+      instance = new HelmOp({ spec: {} });
+      const source = instance.source;
+
+      expect(source.value).toBe('');
+      expect(source.display).toBeNull();
+      expect(source.icon).toBe('icon icon-application');
+      expect(source.showLink).toBe(false);
+    });
+  });
+
+  describe('sourceSub getter', () => {
+    it('should display chart name and desired version when both are present (SOURCE_TYPE.REPO)', () => {
+      instance = new HelmOp({
+        spec: {
+          helm: {
+            repo:    'https://charts.rancher.io/fleet',
+            chart:   'fleet-agent',
+            version: '0.12.x'
+          }
+        }
+      });
+
+      const sourceSub = instance.sourceSub;
+
+      expect(sourceSub.value).toBe('fleet-agent : 0.12.x');
+      expect(sourceSub.display).toBe('fleet-agent : 0.12.x');
+    });
+
+    it('should display chart name and desired version when both are present (SOURCE_TYPE.OCI)', () => {
+      instance = new HelmOp({
+        spec: {
+          helm: {
+            repo:    'oci://ghcr.io/rancher/some-chart',
+            version: '1.0.0'
+          }
+        }
+      });
+
+      const sourceSub = instance.sourceSub;
+
+      expect(sourceSub.value).toBe('rancher/some-chart : 1.0.0');
+      expect(sourceSub.display).toBe('rancher/some-chart : 1.0.0');
+    });
+
+    it('should display only installed version when only it is present', () => {
+      instance = new HelmOp({
+        status: { version: '0.12.3' },
+        spec:   { helm: {} }
+      });
+
+      const sourceSub = instance.sourceSub;
+
+      expect(sourceSub.value).toBe('0.12.3');
+      expect(sourceSub.display).toBe('0.12.3');
+    });
+
+    it('should display semantic version when installed version is missing', () => {
+      instance = new HelmOp({
+        spec: {
+          helm: {
+            version: '0.12.x',
+            chart:   'test-chart'
+          }
+        }
+      });
+
+      const sourceSub = instance.sourceSub;
+
+      expect(sourceSub.value).toBe('0.12.x');
+      expect(sourceSub.display).toBe('0.12.x');
+    });
+
+    it('should display "semantic -> installed" when both versions are present (no chart)', () => {
+      instance = new HelmOp({
+        spec:   { helm: { version: '0.12.x' } },
+        status: { version: '0.12.5' }
+      });
+
+      const sourceSub = instance.sourceSub;
+
+      expect(sourceSub.value).toBe('0.12.x -> 0.12.5');
+      expect(sourceSub.display).toBe('0.12.x -> 0.12.5');
+    });
+
+    it('should display chart and "semantic -> installed" when all are present', () => {
+      instance = new HelmOp({
+        spec: {
+          helm: {
+            repo:    'https://charts.rancher.io/fleet',
+            chart:   'fleet-agent',
+            version: '0.12.x'
+          }
+        },
+        status: { version: '0.12.5' }
+      });
+
+      const sourceSub = instance.sourceSub;
+
+      expect(sourceSub.value).toBe('fleet-agent : 0.12.x -> 0.12.5');
+      expect(sourceSub.display).toBe('fleet-agent : 0.12.x -> 0.12.5');
+    });
+
+    it('should display chart and only semantic version when all are present but semantic version is equal to installed version (no duplicate info)', () => {
+      instance = new HelmOp({
+        spec: {
+          helm: {
+            repo:    'https://charts.rancher.io/fleet',
+            chart:   'fleet-agent',
+            version: '0.12.3'
+          }
+        },
+        status: { version: '0.12.3' }
+      });
+
+      const sourceSub = instance.sourceSub;
+
+      expect(sourceSub.value).toBe('fleet-agent : 0.12.3');
+      expect(sourceSub.display).toBe('fleet-agent : 0.12.3');
+    });
+
+    it('should return empty string when no version or chart information is available', () => {
+      instance = new HelmOp({
+        spec:   { helm: {} },
+        status: {}
+      });
+
+      const sourceSub = instance.sourceSub;
+
+      expect(sourceSub.value).toBe('');
+      expect(sourceSub.display).toBe('');
+    });
+
+    it('should correctly handle missing helm spec', () => {
+      instance = new HelmOp({ spec: {}, status: {} });
+      const sourceSub = instance.sourceSub;
+
+      expect(sourceSub.value).toBe('');
+      expect(sourceSub.display).toBe('');
+    });
+  });
+});

package/models/__tests__/node.test.ts

@@ -1,74 +1,18 @@
-import Node from '@shell/models/management.cattle.io.node';
+import Node from '@shell/models/cluster/node';
 
 describe('class Node', () => {
-  const foo = 'foo';
-  const bar = 'bar';
-  const t = jest.fn(() => bar);
-  const ctx = { rootGetters: { 'i18n/t': t } };
-
   const resetMocks = () => {
     // Clear all mock function calls:
     jest.clearAllMocks();
   };
 
-  it('should not return addresses if they are not present in the resource status', () => {
-    const node = new Node({ status: {} });
+  it.each([
+    ['1200', 1200],
+    ['1k', 1000]
+  ])('given %p status pod capacity value from the backend, should parse the value correctly as %p', (value, result) => {
+    const node = new Node({ status: { capacity: { pods: value } } });
 
-    expect(node.addresses).toStrictEqual([]);
+    expect(node.podCapacity).toStrictEqual(result);
     resetMocks();
   });
-
-  describe('should return addresses', () => {
-    const addresses = [foo];
-
-    it('if they are present directly on the resource status', () => {
-      const node = new Node({ status: { addresses } });
-
-      expect(node.addresses).toStrictEqual(addresses);
-    });
-  });
-
-  describe('should return an internalIp', () => {
-    const addresses = [{ type: 'InternalIP', address: foo }];
-
-    it('if addresses includes an object with an appropriate type and address', () => {
-      const node = new Node({ status: { addresses } });
-
-      expect(node.internalIp).toStrictEqual(foo);
-    });
-  });
-
-  describe('should return an externalIp', () => {
-    const addresses = [{ type: 'ExternalIP', address: foo }];
-
-    it('if addresses includes an object with an appropriate type and address', () => {
-      const node = new Node({ status: { addresses } });
-
-      expect(node.externalIp).toStrictEqual(foo);
-    });
-    it('if internalNodeStatus.addresses includes an object with an appropriate type and address', () => {
-      const node = new Node({ status: { internalNodeStatus: { addresses } } });
-
-      expect(node.externalIp).toStrictEqual(foo);
-    });
-  });
-
-  describe('should return an appropriate message', () => {
-    it('if there is no internalIp to display', () => {
-      const node = new Node({ status: {} }, ctx);
-
-      expect(node.internalIp).toStrictEqual(bar);
-      expect(t).toHaveBeenCalledTimes(1);
-      expect(t).toHaveBeenCalledWith('generic.none');
-      resetMocks();
-    });
-    it('if there is no externalIp to display', () => {
-      const node = new Node({ status: {} }, ctx);
-
-      expect(node.externalIp).toStrictEqual(bar);
-      expect(t).toHaveBeenCalledTimes(1);
-      expect(t).toHaveBeenCalledWith('generic.none');
-      resetMocks();
-    });
-  });
 });

package/models/__tests__/workload.test.ts

@@ -57,6 +57,7 @@ describe('class: Workload', () => {
             clusterName:                'whatever',
             deletionGracePeriodSeconds: 'whatever',
             generateName:               'whatever',
+            ownerReferences:            'whatever',
           },
           spec: {
             template: {