@rancher/shell 3.0.11 → 3.0.12-rc.2

package/mixins/chart.js

@@ -28,6 +28,17 @@ export default {
       ignoreWarning: false,
 
       chart: null,
+
+      // Whether installing a new instance is allowed.
+      // This is false when the chart is targeted (has fixed namespace/name annotations)
+      // or when the URL query specifies a specific app to edit.
+      canInstallNew: true,
+
+      // Installed instances of this chart that can be selected for edit/upgrade
+      // on the chart detail page. When instances exist, `existing` is set to the
+      // first one by default, but the user can select a different instance or
+      // choose to install a new one.
+      installedInstances: [],
     };
   },
 
@@ -375,6 +386,9 @@ export default {
         // Use those values to check for a catalog app resource.
         // If found, set the form to edit mode. If not, set the
         // form to create mode.
+        // This is a hard blocker - installing a new instance is NOT allowed.
+
+        this.canInstallNew = false;
 
         try {
           this.existing = await this.$store.dispatch('cluster/find', {
@@ -399,6 +413,9 @@ export default {
 
           // Ask to install a special chart with fixed namespace/name
           // or edit it if there's an existing install.
+          // This is a hard blocker - installing a new instance is NOT allowed.
+
+          this.canInstallNew = false;
 
           try {
             this.existing = await this.$store.dispatch('cluster/find', {
@@ -410,19 +427,33 @@ export default {
             this.mode = _CREATE;
             this.existing = null;
           }
-        } else if (this.chart) {
-          const matching = this.chart.matchingInstalledApps;
+        } else {
+          // Regular chart (not targeted) - check if there are installed instances.
+          // Installing new instances IS allowed (canInstallNew remains true).
+          const isChartDetailPage = this.$route.name === 'c-cluster-apps-charts-chart';
 
-          if (matching.length === 1) {
-            this.existing = matching[0];
-            this.mode = _EDIT;
+          if (isChartDetailPage) {
+            const matching = this.chart?.matchingInstalledApps || [];
+
+            // Always refresh the available instances so stale values are removed.
+            this.installedInstances = [];
+
+            if (matching.length >= 1) {
+              // Populate the instance selector and preserve the current selection
+              // when it is still one of the matching installed apps.
+              this.installedInstances = matching;
+              const hasExistingMatch = this.existing?.id && matching.some((instance) => instance.id === this.existing.id);
+
+              if (!hasExistingMatch) {
+                this.existing = matching[0];
+              }
+            } else {
+              this.existing = null;
+            }
           } else {
+            // Regular create
             this.mode = _CREATE;
           }
-        } else {
-          // Regular create
-
-          this.mode = _CREATE;
         }
       }
     }, // End of fetchChart

package/mixins/resource-fetch.js

@@ -87,6 +87,14 @@ export default {
       type:    Function,
       default: null,
     },
+
+    /**
+     * When making a supporting HTTP request include associated resource data
+     */
+    includeAssociatedData: {
+      type:    Boolean,
+      default: false,
+    },
   },
 
   computed: {
@@ -185,9 +193,10 @@ export default {
           return;
         }
         const opt = {
-          hasManualRefresh: this.hasManualRefresh,
-          pagination:       { ...this.pagination },
-          force:            this.paginating !== null // Fix for manual refresh (before ripped out).
+          hasManualRefresh:      this.hasManualRefresh,
+          pagination:            { ...this.pagination },
+          force:                 this.paginating !== null, // Fix for manual refresh (before ripped out).
+          includeAssociatedData: this.includeAssociatedData,
         };
 
         if (this.apiFilter) {

package/models/__tests__/catalog.cattle.io.app.test.ts

@@ -87,6 +87,19 @@ const certManagerOfficialMatchingChart2 = {
   }]
 };
 
+// Simulates the chart data fetched from the repository where the home URL has changed in newer versions
+// AND the older installed version has been dropped/replaced from the repository index.
+const certManagerOfficialMatchingChartNewHomeOnly = {
+  name:     chartName,
+  repoName: certManagerOfficial.repoName,
+  versions: [{
+    version:     latestVersion,
+    home:        certManagerOfficial.home,
+    repoName:    certManagerOfficial.repoName,
+    annotations: {},
+  }]
+};
+
 const installedCertManagerAppCoFromRancherUI = {
   metadata: {
     annotations: { [CATALOG_ANNOTATIONS.SOURCE_REPO_NAME]: appCo.repoName },
@@ -130,7 +143,8 @@ describe('class CatalogApp', () => {
       [installedCertManagerOfficialFromRancherUI, [], APP_UPGRADE_STATUS.NO_UPGRADE],
       [installedCertManagerOfficialFromRancherUI, [certManagerOfficialMatchingChart1], APP_UPGRADE_STATUS.SINGLE_UPGRADE],
       [installedCertManagerOfficialFromRancherUI, [certManagerOfficialMatchingChart1, appCoMatchingChart1], APP_UPGRADE_STATUS.SINGLE_UPGRADE],
-      [installedCertManagerOfficialFromRancherUI, [certManagerOfficialMatchingChart1, certManagerOfficialMatchingChart2], APP_UPGRADE_STATUS.MULTIPLE_UPGRADES]
+      [installedCertManagerOfficialFromRancherUI, [certManagerOfficialMatchingChart1, certManagerOfficialMatchingChart2], APP_UPGRADE_STATUS.MULTIPLE_UPGRADES],
+      [installedCertManagerOfficialFromRancherUI, [certManagerOfficialMatchingChartNewHomeOnly], APP_UPGRADE_STATUS.SINGLE_UPGRADE]
     ];
 
     it.each(testCases)('should return the correct upgrade status', (installedChart: Object, matchingCharts: any, expected: any) => {

package/models/__tests__/catalog.cattle.io.clusterrepo.test.ts

@@ -0,0 +1,84 @@
+import ClusterRepo from '../catalog.cattle.io.clusterrepo';
+
+describe('clusterRepo', () => {
+  let model: any;
+
+  beforeEach(() => {
+    model = new ClusterRepo({
+      metadata: { name: 'test-repo' },
+      spec:     { url: 'https://test-url.com' }
+    }, {
+      getters:     {},
+      dispatch:    jest.fn(),
+      rootGetters: {}
+    });
+
+    jest.spyOn(model, '_key', 'get').mockReturnValue('test-key');
+    jest.spyOn(model, 'save').mockImplementation().mockResolvedValue(true);
+    jest.spyOn(model, 'waitForState').mockImplementation().mockResolvedValue(true);
+    jest.spyOn(model, '$dispatch', 'get').mockReturnValue(jest.fn());
+  });
+
+  describe('refresh', () => {
+    it('updates forceUpdate, saves, waits for active state, and dispatches load by default', async() => {
+      // Mock Date to ensure deterministic forceUpdate value
+      const mockDate = new Date('2023-01-01T12:00:00.000Z');
+      const spy = jest.spyOn(global, 'Date').mockImplementation(() => mockDate as any);
+
+      await model.refresh();
+
+      expect(model.spec.forceUpdate).toBe('2023-01-01T12:00:00Z');
+      expect(model.save).toHaveBeenCalledWith();
+      expect(model.waitForState).toHaveBeenCalledWith('active', 10000, 1000);
+      expect(model.$dispatch).toHaveBeenCalledWith('catalog/load', { force: true, repoKeys: [model._key] }, { root: true });
+
+      spy.mockRestore();
+    });
+
+    it('updates forceUpdate, saves, waits for active state, but DOES NOT dispatch load if dispatchLoad is false', async() => {
+      await model.refresh(false);
+
+      expect(model.save).toHaveBeenCalledWith();
+      expect(model.waitForState).toHaveBeenCalledWith('active', 10000, 1000);
+      expect(model.$dispatch).not.toHaveBeenCalled();
+    });
+
+    it('dispatches error to growl if save or waitForState fails', async() => {
+      const error = new Error('waitForState timeout');
+
+      model.waitForState.mockRejectedValue(error);
+      jest.spyOn(model, 't', 'get').mockReturnValue(jest.fn().mockReturnValue('Error refreshing repository'));
+      jest.spyOn(model, 'nameDisplay', 'get').mockReturnValue('Test Repo');
+
+      await model.refresh();
+
+      expect(model.$dispatch).toHaveBeenCalledWith('growl/fromError', {
+        title: 'Error refreshing repository',
+        err:   error
+      }, { root: true });
+    });
+  });
+
+  describe('refreshBulk', () => {
+    it('calls refresh(false) on all items and then dispatches a single catalog/load with all repoKeys', async() => {
+      const mockItem1 = {
+        _key:    'repo-1',
+        refresh: jest.fn().mockResolvedValue(true)
+      };
+      const mockItem2 = {
+        _key:    'repo-2',
+        refresh: jest.fn().mockResolvedValue(true)
+      };
+
+      await model.refreshBulk([mockItem1, mockItem2]);
+
+      expect(mockItem1.refresh).toHaveBeenCalledWith(false);
+      expect(mockItem2.refresh).toHaveBeenCalledWith(false);
+
+      expect(model.$dispatch).toHaveBeenCalledWith('catalog/load', {
+        force:    true,
+        repoKeys: ['repo-1', 'repo-2']
+      }, { root: true });
+    });
+  });
+});

package/models/__tests__/chart.test.ts

@@ -17,7 +17,7 @@ type MockChartContext = {
 };
 
 interface CardContent {
-  subHeaderItems: { label: string, labelTooltip?: string}[];
+  subHeaderItems: { label: string, labelTooltip?: string, icon?: string, iconTooltip?: string }[];
   footerItems: { labels: string[]; icon?: string }[];
   statuses: { tooltip: { key?: string; text?: string }; color: string }[];
 }
@@ -166,7 +166,7 @@ describe('class Chart', () => {
       expect(chart.isInstalled).toBe(false);
     });
 
-    it('is false when multiple apps match', () => {
+    it('is true when multiple apps match', () => {
       const app = makeInstalledApp();
 
       app.spec.chart.metadata.version = '1.2.3';
@@ -174,7 +174,7 @@ describe('class Chart', () => {
 
       const chart = new Chart(base, ctx);
 
-      expect(chart.isInstalled).toBe(false);
+      expect(chart.isInstalled).toBe(true);
     });
   });
 
@@ -206,6 +206,58 @@ describe('class Chart', () => {
 
       expect(chart.upgradeable).toBe(false);
     });
+
+    it('is true when at least one of multiple installed apps is upgradeable', () => {
+      const app1 = makeInstalledApp(APP_UPGRADE_STATUS.NO_UPGRADE);
+      const app2 = makeInstalledApp(APP_UPGRADE_STATUS.SINGLE_UPGRADE);
+
+      ctx.rootGetters['cluster/all'] = () => [app1, app2];
+
+      const chart = new Chart(base, ctx);
+
+      expect(chart.upgradeable).toBe(true);
+    });
+
+    it('is false when none of multiple installed apps are upgradeable', () => {
+      const app1 = makeInstalledApp(APP_UPGRADE_STATUS.NO_UPGRADE);
+      const app2 = makeInstalledApp(APP_UPGRADE_STATUS.NO_UPGRADE);
+
+      ctx.rootGetters['cluster/all'] = () => [app1, app2];
+
+      const chart = new Chart(base, ctx);
+
+      expect(chart.upgradeable).toBe(false);
+    });
+  });
+
+  describe('installedCount', () => {
+    it('returns 0 when no apps are installed', () => {
+      const chart = new Chart(base, ctx);
+
+      expect(chart.installedCount).toBe(0);
+    });
+
+    it('returns 1 when one app is installed', () => {
+      const installedApp = makeInstalledApp();
+
+      ctx.rootGetters['cluster/all'] = () => [installedApp];
+
+      const chart = new Chart(base, ctx);
+
+      expect(chart.installedCount).toBe(1);
+    });
+
+    it('returns correct count when multiple apps are installed', () => {
+      const app1 = makeInstalledApp();
+      const app2 = makeInstalledApp();
+      const app3 = makeInstalledApp();
+
+      ctx.rootGetters['cluster/all'] = () => [app1, app2, app3];
+
+      const chart = new Chart(base, ctx);
+
+      expect(chart.installedCount).toBe(3);
+    });
   });
 
   describe('cardContent', () => {
@@ -274,6 +326,25 @@ describe('class Chart', () => {
       expect(installedStatus?.tooltip?.text).toContain(installedApp.spec.chart.metadata.version);
     });
 
+    it('does not include version in installed tooltip when multiple instances exist', () => {
+      const app1 = makeInstalledApp();
+      const app2 = makeInstalledApp();
+
+      app2.spec.chart.metadata.version = '1.2.0';
+      ctx.rootGetters['cluster/all'] = () => [app1, app2];
+
+      const chart = new Chart(base, ctx);
+
+      const result = chart.cardContent as CardContent;
+
+      const installedStatus = result.statuses.find((s) => s.tooltip?.text?.startsWith('generic.installedMultiple'));
+
+      expect(installedStatus).toBeDefined();
+      expect(installedStatus?.color).toBe('success');
+      // Should not contain version number when multiple instances
+      expect(installedStatus?.tooltip?.text).toBe('generic.installedMultiple');
+    });
+
     it('includes upgradeable status when upgrade is available', () => {
       const installedApp = makeInstalledApp(APP_UPGRADE_STATUS.SINGLE_UPGRADE);
 
@@ -332,10 +403,32 @@ describe('class Chart', () => {
       });
 
       const result = chart.cardContent as CardContent;
-      const lastUpdatedItem = result.subHeaderItems[1];
 
-      expect(lastUpdatedItem.label).toBe('generic.na');
-      expect(lastUpdatedItem.labelTooltip).toBe('catalog.charts.appChartCard.subHeaderItem.missingVersionDate');
+      expect(result.subHeaderItems).toHaveLength(1);
+      expect(result.subHeaderItems[0].icon).toBe('icon-version-alt');
+    });
+
+    it('handles falsy time for last updated date', () => {
+      const chartWithFalsyTime = {
+        ...base,
+        versions: [{
+          ...base.versions[0],
+          created: '',
+        }]
+      };
+      const chart = new Chart(chartWithFalsyTime, {
+        rootGetters: {
+          'cluster/all':  () => [],
+          'i18n/t':       (key: string) => key,
+          currentCluster: { workerOSs: [] },
+          'prefs/get':    () => false,
+        },
+      });
+
+      const result = chart.cardContent as CardContent;
+
+      expect(result.subHeaderItems).toHaveLength(1);
+      expect(result.subHeaderItems[0].icon).toBe('icon-version-alt');
     });
   });
 });

package/models/__tests__/management.cattle.io.feature.test.ts

@@ -0,0 +1,131 @@
+import Feature from '@shell/models/management.cattle.io.feature.js';
+import Resource from '@shell/plugins/dashboard-store/resource-class';
+
+describe('class Feature', () => {
+  const ctx = {
+    dispatch:    jest.fn(),
+    rootGetters: { 'i18n/t': (key: string) => key },
+    getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+  };
+
+  // The parent Resource._availableActions getter depends on runtime config we don't have
+  // in tests — stub it out so we can assert on Feature's own additions.
+  beforeEach(() => {
+    jest.spyOn(Resource.prototype, '_availableActions', 'get').mockReturnValue([]);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('enabled getter', () => {
+    it.each([
+      [true, true],
+      [false, false],
+    ])('should return lockedValue (%s) when status.lockedValue is not null', (lockedValue, expected) => {
+      const feature = new Feature({
+        spec:   { value: false },
+        status: { lockedValue, default: false }
+      }, ctx);
+
+      expect(feature.enabled).toBe(expected);
+    });
+
+    it('should return spec.value when lockedValue is null and spec.value is set', () => {
+      const feature = new Feature({
+        spec:   { value: true },
+        status: { lockedValue: null, default: false }
+      }, ctx);
+
+      expect(feature.enabled).toBe(true);
+    });
+
+    it('should fall back to status.default when lockedValue is null and spec.value is null', () => {
+      const feature = new Feature({
+        spec:   { value: null },
+        status: { lockedValue: null, default: true }
+      }, ctx);
+
+      expect(feature.enabled).toBe(true);
+    });
+
+    it('should not throw when status is missing (malformed feature flag)', () => {
+      const feature = new Feature({ spec: { value: true } }, ctx);
+
+      expect(() => feature.enabled).not.toThrow();
+      expect(feature.enabled).toBe(true);
+    });
+  });
+
+  describe('restartRequired getter', () => {
+    it('should return false when status.dynamic is true', () => {
+      const feature = new Feature({ spec: {}, status: { dynamic: true, lockedValue: null } }, ctx);
+
+      expect(feature.restartRequired).toBe(false);
+    });
+
+    it('should return true when status.dynamic is false', () => {
+      const feature = new Feature({ spec: {}, status: { dynamic: false, lockedValue: null } }, ctx);
+
+      expect(feature.restartRequired).toBe(true);
+    });
+
+    it('should return true when status is missing (malformed feature flag)', () => {
+      const feature = new Feature({ spec: {} }, ctx);
+
+      expect(() => feature.restartRequired).not.toThrow();
+      expect(feature.restartRequired).toBe(true);
+    });
+  });
+
+  describe('_availableActions getter', () => {
+    it('should disable the toggle action when lockedValue is not null', () => {
+      const feature = new Feature({
+        spec:   { value: false },
+        status: {
+          lockedValue: true, default: false, dynamic: true
+        },
+      }, ctx);
+
+      jest.spyOn(feature, 'canUpdate', 'get').mockReturnValue(true);
+
+      const actions = feature._availableActions;
+
+      expect(actions[0].action).toBe('toggleFeatureFlag');
+      expect(actions[0].enabled).toBe(false);
+    });
+
+    it('should enable the toggle action when lockedValue is null and user canUpdate', () => {
+      const feature = new Feature({
+        spec:   { value: false },
+        status: {
+          lockedValue: null, default: false, dynamic: true
+        },
+        id: 'some-feature',
+      }, ctx);
+
+      jest.spyOn(feature, 'canUpdate', 'get').mockReturnValue(true);
+
+      const actions = feature._availableActions;
+
+      expect(actions[0].action).toBe('toggleFeatureFlag');
+      expect(actions[0].enabled).toBe(true);
+    });
+
+    it('should not throw and should disable the toggle action when status is missing (malformed feature flag)', () => {
+      const feature = new Feature({
+        spec: { value: false },
+        id:   'some-feature',
+      }, ctx);
+
+      jest.spyOn(feature, 'canUpdate', 'get').mockReturnValue(true);
+
+      expect(() => feature._availableActions).not.toThrow();
+
+      const actions = feature._availableActions;
+
+      expect(actions[0].action).toBe('toggleFeatureFlag');
+      expect(actions[0].enabled).toBeFalsy();
+    });
+  });
+});

package/models/__tests__/monitoring.coreos.com.alertmanagerconfig.test.ts

@@ -0,0 +1,98 @@
+import AlertmanagerConfig from '@shell/models/monitoring.coreos.com.alertmanagerconfig';
+
+const base = {
+  apiVersion: 'monitoring.coreos.com/v1alpha1',
+  kind:       'AlertmanagerConfig',
+  metadata:   { name: 'test', namespace: 'default' },
+};
+
+const build = (data: Record<string, any>) => new AlertmanagerConfig(data) as any;
+
+describe('class AlertmanagerConfig', () => {
+  describe('applyDefaults', () => {
+    it('on a fresh resource, seeds the route with defaults and no match/matchRe', () => {
+      const amc = build({ ...base });
+
+      amc.applyDefaults();
+
+      expect(amc.spec.receivers).toStrictEqual([]);
+      expect(amc.spec.route).toStrictEqual({
+        groupBy:        [],
+        groupWait:      '30s',
+        groupInterval:  '5m',
+        repeatInterval: '4h',
+        matchers:       [],
+      });
+    });
+
+    it('backfills route defaults on a resource loaded without a route', () => {
+      const amc = build({
+        ...base,
+        spec: { receivers: [{ name: 'existing' }] },
+      });
+
+      amc.applyDefaults();
+
+      expect(amc.spec.route).toBeDefined();
+      expect(amc.spec.route.receiver).toBeUndefined();
+      expect(amc.spec.route.matchers).toStrictEqual([]);
+    });
+
+    it('preserves existing matchers on load', () => {
+      const matchers = [{
+        name: 'severity', value: 'warning', matchType: '='
+      }];
+      const amc = build({
+        ...base,
+        spec: {
+          receivers: [{ name: 'existing' }],
+          route:     { receiver: 'existing', matchers },
+        },
+      });
+
+      amc.applyDefaults();
+
+      expect(amc.spec.route.matchers).toStrictEqual(matchers);
+    });
+  });
+
+  describe('cleanForSave', () => {
+    it('drops spec.route when no receiver is set — this is what fixes #17347 on 109+ charts', () => {
+      const amc = build({ ...base });
+
+      const out = amc.cleanForSave({
+        ...base,
+        spec: {
+          receivers: [],
+          route:     {
+            groupBy:        [],
+            groupWait:      '30s',
+            groupInterval:  '5m',
+            repeatInterval: '4h',
+            matchers:       [],
+          },
+        },
+      }, true);
+
+      expect(out.spec.route).toBeUndefined();
+      expect(out.spec.receivers).toStrictEqual([]);
+    });
+
+    it('keeps spec.route when a receiver is set', () => {
+      const amc = build({ ...base });
+
+      const out = amc.cleanForSave({
+        ...base,
+        spec: {
+          receivers: [{ name: 'existing' }],
+          route:     {
+            receiver: 'existing', groupBy: [], matchers: []
+          },
+        },
+      }, false);
+
+      expect(out.spec.route).toBeDefined();
+      expect(out.spec.route.receiver).toBe('existing');
+    });
+  });
+});

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

@@ -78,28 +78,32 @@ export default class CatalogApp extends SteveModel {
       return [];
     }
 
-    // Filtering matches by verifying if the current version is in the matched chart's available versions, and that the home value matches as well
-    const thisHome = chart?.metadata?.home;
-    const bestMatches = matchingCharts.filter(({ versions }) => {
-      // First checking if the latest version has the same home value
-      if (thisHome === versions[0]?.home) {
-        return true;
-      }
+    if (!repoName || matchingCharts.length > 1) {
+      // Filtering matches by verifying if the current version is in the matched chart's available versions, and that the home value matches as well
+      const thisHome = chart?.metadata?.home;
+      const bestMatches = matchingCharts.filter(({ versions }) => {
+        // First checking if the latest version has the same home value
+        if (thisHome === versions[0]?.home) {
+          return true;
+        }
 
-      for (let i = 1; i < versions.length; i++) {
-        const { version, home } = versions[i];
+        for (let i = 1; i < versions.length; i++) {
+          const { version, home } = versions[i];
 
-        // Finding the exact version, if the version is not there, then most likely it's not a match
-        // if the exact version is found, then we can compare the home value
-        if (version === this.currentVersion && (home === thisHome)) {
-          return true;
+          // Finding the exact version, if the version is not there, then most likely it's not a match
+          // if the exact version is found, then we can compare the home value
+          if (version === this.currentVersion && (home === thisHome)) {
+            return true;
+          }
         }
-      }
 
-      return false;
-    });
+        return false;
+      });
+
+      return bestMatches;
+    }
 
-    return bestMatches;
+    return matchingCharts;
   }
 
   get currentVersion() {