@rancher/shell 3.0.12-rc.3 → 3.0.12-rc.4

package/utils/__tests__/duration.test.ts

@@ -1,4 +1,4 @@
-import { toMilliseconds, toSeconds } from '@shell/utils/duration';
+import { toMilliseconds, toSeconds, secondsToLargestUnit, formatDuration } from '@shell/utils/duration';
 
 describe('toMilliseconds', () => {
   describe('falsy input', () => {
@@ -138,3 +138,39 @@ describe('toSeconds', () => {
     expect(toSeconds(input)).toStrictEqual(expected);
   });
 });
+
+describe('function: secondsToLargestUnit', () => {
+  it.each([
+    [0, { value: 0, unit: 1 }],
+    [-1, { value: -1, unit: 1 }],
+    [-86400, { value: -86400, unit: 1 }],
+    [86400, { value: 1, unit: 86400 }],
+    [172800, { value: 2, unit: 86400 }],
+    [3600, { value: 1, unit: 3600 }],
+    [7200, { value: 2, unit: 3600 }],
+    [120, { value: 2, unit: 60 }],
+    [300, { value: 5, unit: 60 }],
+    [45, { value: 45, unit: 1 }],
+    [90, { value: 90, unit: 1 }],
+    [1, { value: 1, unit: 1 }],
+  ])('given %p seconds, returns %p', (seconds, expected) => {
+    expect(secondsToLargestUnit(seconds)).toStrictEqual(expected);
+  });
+});
+
+describe('function: formatDuration', () => {
+  it.each([
+    [0, '0s'],
+    [-1, '0s'],
+    [1, '1s'],
+    [60, '1m'],
+    [61, '1m 1s'],
+    [3600, '1h'],
+    [3661, '1h 1m 1s'],
+    [86400, '1d'],
+    [90061, '1d 1h 1m 1s'],
+    [100000, '1d 3h 46m 40s'],
+  ])('given %p seconds, returns %p', (seconds, expected) => {
+    expect(formatDuration(seconds)).toStrictEqual(expected);
+  });
+});

package/utils/__tests__/dynamic-importer.test.ts

@@ -0,0 +1,102 @@
+import {
+  importCloudCredential,
+  importMachineConfig,
+  importLogin,
+  importChart,
+  importList,
+  importDetail,
+  importEdit,
+  importDialog,
+  importDrawer,
+  importWindowComponent,
+  loadProduct,
+  loadTranslation,
+} from '@shell/utils/dynamic-importer';
+import { defineAsyncComponent } from 'vue';
+
+jest.mock('vue', () => ({ defineAsyncComponent: jest.fn(() => 'mockAsyncComponent') }));
+
+const ASYNC_COMPONENT_IMPORTERS = [
+  {
+    desc: 'importCloudCredential',
+    fn:   importCloudCredential,
+  },
+  {
+    desc: 'importMachineConfig',
+    fn:   importMachineConfig,
+  },
+  {
+    desc: 'importLogin',
+    fn:   importLogin,
+  },
+  {
+    desc: 'importChart',
+    fn:   importChart,
+  },
+  {
+    desc: 'importList',
+    fn:   importList,
+  },
+  {
+    desc: 'importDetail',
+    fn:   importDetail,
+  },
+  {
+    desc: 'importEdit',
+    fn:   importEdit,
+  },
+  {
+    desc: 'importDialog',
+    fn:   importDialog,
+  },
+  {
+    desc: 'importDrawer',
+    fn:   importDrawer,
+  },
+  {
+    desc: 'importWindowComponent',
+    fn:   importWindowComponent,
+  },
+];
+
+const DIRECT_IMPORTERS = [
+  {
+    desc: 'loadProduct',
+    fn:   loadProduct,
+  },
+  {
+    desc: 'loadTranslation',
+    fn:   loadTranslation,
+  },
+];
+
+const ALL_GUARDED_IMPORTERS = [...ASYNC_COMPONENT_IMPORTERS, ...DIRECT_IMPORTERS];
+
+describe('dynamic-importer', () => {
+  describe('name guard — throws when name is falsy', () => {
+    it.each(ALL_GUARDED_IMPORTERS)('$desc throws for null', ({ fn }) => {
+      expect(() => fn(null as any)).toThrow('Name required');
+    });
+
+    it.each(ALL_GUARDED_IMPORTERS)('$desc throws for undefined', ({ fn }) => {
+      expect(() => fn(undefined as any)).toThrow('Name required');
+    });
+
+    it.each(ALL_GUARDED_IMPORTERS)('$desc throws for empty string', ({ fn }) => {
+      expect(() => fn('')).toThrow('Name required');
+    });
+  });
+
+  describe('async component importers — delegates to defineAsyncComponent', () => {
+    beforeEach(() => {
+      (defineAsyncComponent as jest.Mock).mockClear();
+    });
+
+    it.each(ASYNC_COMPONENT_IMPORTERS)('$desc calls defineAsyncComponent with a loader function', ({ fn }) => {
+      const result = fn('some-name');
+
+      expect(defineAsyncComponent).toHaveBeenCalledWith(expect.any(Function));
+      expect(result).toStrictEqual('mockAsyncComponent');
+    });
+  });
+});

package/utils/__tests__/fleet-appco.test.ts

@@ -0,0 +1,312 @@
+import {
+  deriveRepoName, fetchAppCoCharts, ensureAppCoResources, ensureAppCoImagePullSecret, getDownstreamResourcesDocsUrl, FLEET_DOWNSTREAM_RESOURCES_DOCS_FALLBACK_URL
+} from '@shell/utils/fleet-appco';
+import { SECRET, CATALOG as CATALOG_TYPES } from '@shell/config/types';
+import { SECRET_TYPES } from '@shell/config/secret';
+
+/**
+ * Build a fake ClusterRepo resource. Its `waitForTestFn` emulates the real
+ * resource-class helper by synchronously polling the provided test function
+ * until it returns truthy (or "timing out" after a few attempts).
+ */
+const buildRepo = (overrides: Record<string, any> = {}) => ({
+  metadata:        { state: {} },
+  status:          { conditions: [] },
+  stateDisplay:    'Active',
+  stateBackground: 'bg-success',
+  followLink:      jest.fn().mockResolvedValue({ entries: { chartA: [{ name: 'chartA' }] } }),
+  waitForTestFn:   (fn: () => boolean) => new Promise<void>((resolve, reject) => {
+    for (let attempt = 0; attempt < 5; attempt++) {
+      if (fn()) {
+        return resolve();
+      }
+    }
+
+    reject(new Error('timed out'));
+  }),
+  ...overrides,
+});
+
+const buildStore = (repo: any, { findRejects = false, findRejectStatus = 404 }: { findRejects?: boolean; findRejectStatus?: number } = {}) => ({
+  dispatch: jest.fn((action: string) => {
+    if (action.endsWith('/find')) {
+      return findRejects ? Promise.reject(Object.assign(new Error('not found'), { status: findRejectStatus })) : Promise.resolve(repo);
+    }
+
+    return Promise.resolve();
+  }),
+  getters: new Proxy({}, {
+    get: (_target, prop) => {
+      if (String(prop).endsWith('/byId')) {
+        return () => repo;
+      }
+
+      return undefined;
+    }
+  }),
+});
+
+describe('fleet-appco utils', () => {
+  describe('deriveRepoName', () => {
+    it.each([
+      ['my-auth-secret', 'my-repo-secret'],
+      ['auth-token', 'repo-token'],
+      ['some-auth', 'some-repo'],
+    ])('should replace "auth" with "repo" in %s', (input, expected) => {
+      expect(deriveRepoName(input)).toStrictEqual(expected);
+    });
+
+    it('should return empty string for empty input', () => {
+      expect(deriveRepoName('')).toStrictEqual('');
+    });
+  });
+
+  describe('getDownstreamResourcesDocsUrl', () => {
+    it.each([
+      ['v2.15.0', 'https://fleet.rancher.io/0.16/downstream-resources'],
+      ['2.15.0', 'https://fleet.rancher.io/0.16/downstream-resources'],
+      ['v2.16.3', 'https://fleet.rancher.io/0.17/downstream-resources'],
+      ['v2.15.0-rc1', 'https://fleet.rancher.io/0.16/downstream-resources'],
+      ['v2.15-head', 'https://fleet.rancher.io/0.16/downstream-resources'],
+      ['v2.20.0', 'https://fleet.rancher.io/0.21/downstream-resources'],
+    ])('should map Rancher %s to Fleet docs %s', (version, expected) => {
+      expect(getDownstreamResourcesDocsUrl(version)).toStrictEqual(expected);
+    });
+
+    it.each([
+      ['v2.14.0'],
+      ['v2.9.0'],
+      ['dev'],
+      [''],
+      [undefined],
+    ])('should fall back to the unversioned docs for %s', (version) => {
+      expect(getDownstreamResourcesDocsUrl(version)).toStrictEqual(FLEET_DOWNSTREAM_RESOURCES_DOCS_FALLBACK_URL);
+    });
+  });
+
+  describe('fetchAppCoCharts', () => {
+    it('should return entries once the repo OCIDownloaded condition is True', async() => {
+      const repo = buildRepo({ status: { conditions: [{ type: 'OCIDownloaded', status: 'True' }] } });
+      const store = buildStore(repo);
+      const onStateChange = jest.fn();
+
+      const result = await fetchAppCoCharts(store as any, 'my-repo', onStateChange);
+
+      expect(result.entries).toStrictEqual({ chartA: [{ name: 'chartA' }] });
+      expect(result.repoState).toStrictEqual(expect.objectContaining({
+        repoName: 'my-repo', transitioning: false, error: false
+      }));
+      expect(repo.followLink).toHaveBeenCalledWith('index');
+      expect(onStateChange).toHaveBeenCalledWith(expect.objectContaining({ repoName: 'my-repo', error: false }));
+    });
+
+    it('should return no entries and an error state when the repo reports an error', async() => {
+      const repo = buildRepo({ metadata: { state: { error: true, message: 'boom' } } });
+      const store = buildStore(repo);
+
+      const result = await fetchAppCoCharts(store as any, 'my-repo');
+
+      expect(result.entries).toBeNull();
+      expect(result.repoState).toStrictEqual(expect.objectContaining({
+        repoName: 'my-repo', error: true, errorMessage: 'boom'
+      }));
+      expect(repo.followLink).not.toHaveBeenCalled();
+    });
+
+    it('should flag notFound when the repo does not exist (404)', async() => {
+      const repo = buildRepo();
+      const store = buildStore(repo, { findRejects: true, findRejectStatus: 404 });
+
+      const result = await fetchAppCoCharts(store as any, 'my-repo');
+
+      expect(result.entries).toBeNull();
+      expect(result.repoState).toBeNull();
+      expect(result.notFound).toStrictEqual(true);
+    });
+
+    it('should not flag notFound when the repo lookup fails for another reason', async() => {
+      const repo = buildRepo();
+      const store = buildStore(repo, { findRejects: true, findRejectStatus: 500 });
+
+      const result = await fetchAppCoCharts(store as any, 'my-repo');
+
+      expect(result.entries).toBeNull();
+      expect(result.repoState).toBeNull();
+      expect(result.notFound).toStrictEqual(false);
+    });
+
+    it('should stop and return no entries when the signal is aborted', async() => {
+      const repo = buildRepo();
+      const store = buildStore(repo);
+      const controller = new AbortController();
+
+      controller.abort();
+
+      const result = await fetchAppCoCharts(store as any, 'my-repo', undefined, controller.signal);
+
+      expect(result.entries).toBeNull();
+      expect(result.repoState).toBeNull();
+      expect(repo.followLink).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('ensureAppCoResources', () => {
+    const NAMESPACE = 'ns';
+    const AUTH_SECRET_NAME = 'fleet-appco-auth-x';
+    const AUTH_SECRET_ID = `${ NAMESPACE }/${ AUTH_SECRET_NAME }`;
+
+    const t = (key: string) => key;
+
+    const authSecret = { decodedData: { username: 'user', password: 'pass' } };
+
+    /**
+     * Build a store where the auth-secret existence can be controlled, while the
+     * image-pull secret and ClusterRepo are always absent (forcing their creation).
+     */
+    const buildResourcesStore = ({ secretInCache = false, secretFindResolves = false } = {}) => {
+      const newResource = () => ({
+        setData: jest.fn(),
+        save:    jest.fn().mockResolvedValue(undefined),
+      });
+
+      const dispatch = jest.fn((action: string, payload?: any) => {
+        if (action.endsWith('/create')) {
+          return Promise.resolve(newResource());
+        }
+
+        if (action.endsWith('/find')) {
+          // The auth secret resolves via `find` whenever it exists (it is also
+          // re-fetched by ensureAppCoImagePullSecret to read its credentials).
+          if (payload?.id === AUTH_SECRET_ID) {
+            return secretInCache || secretFindResolves ? Promise.resolve(authSecret) : Promise.reject(new Error('not found'));
+          }
+
+          // Image-pull secret / ClusterRepo are absent so creation is triggered.
+          return Promise.reject(new Error('not found'));
+        }
+
+        return Promise.resolve();
+      });
+
+      const getters = new Proxy({}, {
+        get: (_target, prop) => {
+          if (String(prop).endsWith('/byId')) {
+            return (_type: string, id: string) => (secretInCache && id === AUTH_SECRET_ID ? authSecret : undefined);
+          }
+
+          return undefined;
+        }
+      });
+
+      return { dispatch, getters };
+    };
+
+    it('should return false and create nothing when the auth secret cannot be found', async() => {
+      const store = buildResourcesStore({ secretInCache: false, secretFindResolves: false });
+
+      const result = await ensureAppCoResources(store as any, AUTH_SECRET_NAME, NAMESPACE, t);
+
+      expect(result).toStrictEqual(false);
+      expect(store.dispatch).not.toHaveBeenCalledWith('management/create', expect.anything());
+    });
+
+    it('should ensure the image-pull secret and ClusterRepo when the auth secret is in cache', async() => {
+      const store = buildResourcesStore({ secretInCache: true });
+
+      const result = await ensureAppCoResources(store as any, AUTH_SECRET_NAME, NAMESPACE, t);
+
+      expect(result).toStrictEqual(true);
+      expect(store.dispatch).toHaveBeenCalledWith('management/create', expect.objectContaining({
+        type:  SECRET,
+        _type: SECRET_TYPES.DOCKER_JSON,
+      }));
+      expect(store.dispatch).toHaveBeenCalledWith('management/create', expect.objectContaining({ type: CATALOG_TYPES.CLUSTER_REPO }));
+    });
+
+    it('should ensure resources when the auth secret resolves via find', async() => {
+      const store = buildResourcesStore({ secretInCache: false, secretFindResolves: true });
+
+      const result = await ensureAppCoResources(store as any, AUTH_SECRET_NAME, NAMESPACE, t);
+
+      expect(result).toStrictEqual(true);
+      expect(store.dispatch).toHaveBeenCalledWith('management/create', expect.objectContaining({ type: CATALOG_TYPES.CLUSTER_REPO }));
+    });
+  });
+
+  describe('ensureAppCoImagePullSecret', () => {
+    const NAMESPACE = 'ns';
+    const AUTH_SECRET_NAME = 'fleet-appco-auth-x';
+    const AUTH_SECRET_ID = `${ NAMESPACE }/${ AUTH_SECRET_NAME }`;
+    const PULL_SECRET_NAME = `${ AUTH_SECRET_NAME }-image-pull-secret`;
+    const PULL_SECRET_ID = `${ NAMESPACE }/${ PULL_SECRET_NAME }`;
+
+    const authSecret = { decodedData: { username: 'user', password: 'pass' } };
+
+    const buildPullSecretStore = ({ pullSecretExists = false, authFindResolves = true } = {}) => {
+      const newSecret = { setData: jest.fn(), save: jest.fn().mockResolvedValue(undefined) };
+
+      const dispatch = jest.fn((action: string, payload?: any) => {
+        if (action.endsWith('/create')) {
+          return Promise.resolve(newSecret);
+        }
+
+        if (action.endsWith('/find')) {
+          if (payload?.id === AUTH_SECRET_ID) {
+            return authFindResolves ? Promise.resolve(authSecret) : Promise.reject(new Error('not found'));
+          }
+
+          // The image-pull secret is never resolved via `find` here.
+          return Promise.reject(new Error('not found'));
+        }
+
+        return Promise.resolve();
+      });
+
+      const getters = new Proxy({}, {
+        get: (_target, prop) => {
+          if (String(prop).endsWith('/byId')) {
+            return (_type: string, id: string) => (pullSecretExists && id === PULL_SECRET_ID ? {} : undefined);
+          }
+
+          return undefined;
+        }
+      });
+
+      return {
+        dispatch, getters, newSecret
+      };
+    };
+
+    it('should no-op when the image-pull secret already exists', async() => {
+      const store = buildPullSecretStore({ pullSecretExists: true });
+
+      const result = await ensureAppCoImagePullSecret(store as any, AUTH_SECRET_NAME, NAMESPACE);
+
+      expect(result).toStrictEqual(PULL_SECRET_NAME);
+      expect(store.dispatch).not.toHaveBeenCalledWith('management/create', expect.anything());
+    });
+
+    it('should create the image-pull secret from the auth secret when it is missing', async() => {
+      const store = buildPullSecretStore({ pullSecretExists: false, authFindResolves: true });
+
+      const result = await ensureAppCoImagePullSecret(store as any, AUTH_SECRET_NAME, NAMESPACE);
+
+      expect(result).toStrictEqual(PULL_SECRET_NAME);
+      expect(store.dispatch).toHaveBeenCalledWith('management/create', expect.objectContaining({
+        type:  SECRET,
+        _type: SECRET_TYPES.DOCKER_JSON,
+      }));
+      expect(store.newSecret.setData).toHaveBeenCalledWith('.dockerconfigjson', expect.stringContaining('"username":"user"'));
+      expect(store.newSecret.save).toHaveBeenCalledWith();
+    });
+
+    it('should skip creation when the auth secret cannot be found', async() => {
+      const store = buildPullSecretStore({ pullSecretExists: false, authFindResolves: false });
+
+      const result = await ensureAppCoImagePullSecret(store as any, AUTH_SECRET_NAME, NAMESPACE);
+
+      expect(result).toBeUndefined();
+      expect(store.dispatch).not.toHaveBeenCalledWith('management/create', expect.anything());
+    });
+  });
+});

package/utils/__tests__/monitoring.test.ts

@@ -0,0 +1,130 @@
+import {
+  haveV2Monitoring,
+  canViewGrafanaLink,
+  canViewAlertManagerLink,
+  canViewPrometheusLink,
+  CATTLE_MONITORING_NAMESPACE,
+} from '@shell/utils/monitoring';
+import { MONITORING, SCHEMA, ENDPOINTS } from '@shell/config/types';
+
+const PODMONITOR_ID = MONITORING.PODMONITOR.toLowerCase();
+
+function makeGetters(storeName: string, schemas: object[]) {
+  return {
+    getStoreNameByProductId: storeName,
+    [`${ storeName }/all`]:  (type: string) => (type === SCHEMA ? schemas : []),
+  };
+}
+
+describe('haveV2Monitoring', () => {
+  it('returns true when podmonitor schema exists', () => {
+    const getters = makeGetters('cluster', [{ id: PODMONITOR_ID }]);
+
+    expect(haveV2Monitoring(getters)).toBe(true);
+  });
+
+  it('returns false when no schemas exist', () => {
+    const getters = makeGetters('cluster', []);
+
+    expect(haveV2Monitoring(getters)).toBe(false);
+  });
+
+  it('returns false when schemas exist but not podmonitor', () => {
+    const getters = makeGetters('cluster', [{ id: 'apps.deployment' }, { id: 'v1.pod' }]);
+
+    expect(haveV2Monitoring(getters)).toBe(false);
+  });
+
+  it('returns true when podmonitor is among multiple schemas', () => {
+    const getters = makeGetters('cluster', [
+      { id: 'apps.deployment' },
+      { id: PODMONITOR_ID },
+      { id: 'v1.pod' },
+    ]);
+
+    expect(haveV2Monitoring(getters)).toBe(true);
+  });
+
+  it('uses the store name from getStoreNameByProductId getter', () => {
+    const getters = makeGetters('mgmt', [{ id: PODMONITOR_ID }]);
+
+    expect(haveV2Monitoring(getters)).toBe(true);
+  });
+});
+
+describe('cATTLE_MONITORING_NAMESPACE', () => {
+  it('equals cattle-monitoring-system', () => {
+    expect(CATTLE_MONITORING_NAMESPACE).toStrictEqual('cattle-monitoring-system');
+  });
+});
+
+function makeStore(endpointId: string, subsets: object[] | undefined, hasSchema = true) {
+  return {
+    getters:  { 'cluster/schemaFor': (type: string) => (type === ENDPOINTS ? (hasSchema ? {} : null) : null) },
+    dispatch: jest.fn().mockResolvedValue(
+      subsets !== undefined ? [{ id: endpointId, subsets }] : []
+    ),
+  };
+}
+
+describe('canViewGrafanaLink', () => {
+  it('returns true when grafana endpoint has subsets', async() => {
+    const id = `${ CATTLE_MONITORING_NAMESPACE }/rancher-monitoring-grafana`;
+    const store = makeStore(id, [{ addresses: [{ ip: '10.0.0.1' }] }]);
+
+    expect(await canViewGrafanaLink(store)).toBe(true);
+  });
+
+  it('returns false when grafana endpoint has empty subsets', async() => {
+    const id = `${ CATTLE_MONITORING_NAMESPACE }/rancher-monitoring-grafana`;
+    const store = makeStore(id, []);
+
+    expect(await canViewGrafanaLink(store)).toBe(false);
+  });
+
+  it('returns falsy when grafana endpoint is not found', async() => {
+    const store = makeStore('other/endpoint', [{ addresses: [] }]);
+
+    expect(await canViewGrafanaLink(store)).toBeFalsy();
+  });
+
+  it('returns false when endpoints schema is not available', async() => {
+    const id = `${ CATTLE_MONITORING_NAMESPACE }/rancher-monitoring-grafana`;
+    const store = makeStore(id, [{ addresses: [] }], false);
+
+    expect(await canViewGrafanaLink(store)).toBe(false);
+    expect(store.dispatch).not.toHaveBeenCalled();
+  });
+});
+
+describe('canViewAlertManagerLink', () => {
+  it('returns true when alertmanager endpoint has subsets', async() => {
+    const id = `${ CATTLE_MONITORING_NAMESPACE }/rancher-monitoring-alertmanager`;
+    const store = makeStore(id, [{ addresses: [{ ip: '10.0.0.2' }] }]);
+
+    expect(await canViewAlertManagerLink(store)).toBe(true);
+  });
+
+  it('returns falsy when alertmanager endpoint has no subsets', async() => {
+    const id = `${ CATTLE_MONITORING_NAMESPACE }/rancher-monitoring-alertmanager`;
+    const store = makeStore(id, undefined);
+
+    expect(await canViewAlertManagerLink(store)).toBeFalsy();
+  });
+});
+
+describe('canViewPrometheusLink', () => {
+  it('returns true when prometheus endpoint has subsets', async() => {
+    const id = `${ CATTLE_MONITORING_NAMESPACE }/rancher-monitoring-prometheus`;
+    const store = makeStore(id, [{ addresses: [{ ip: '10.0.0.3' }] }]);
+
+    expect(await canViewPrometheusLink(store)).toBe(true);
+  });
+
+  it('returns falsy when prometheus endpoint has no subsets', async() => {
+    const id = `${ CATTLE_MONITORING_NAMESPACE }/rancher-monitoring-prometheus`;
+    const store = makeStore(id, undefined);
+
+    expect(await canViewPrometheusLink(store)).toBeFalsy();
+  });
+});

package/utils/__tests__/object.test.ts

@@ -287,6 +287,28 @@ describe('fx: diff', () => {
     expect(result).toStrictEqual(expected);
     expect(result.parent.child.config).not.toHaveProperty('annotations', null);
   });
+
+  it('should handle type change from object in from to primitive in to without throwing', () => {
+    // from[k] is an object, to[k] is a string (e.g. a pre-existing secret name).
+    // The whole value was replaced; nested keys from from should not be nulled out.
+    const from = {
+      githubConfigSecret: { github_token: '' },
+      githubConfigUrl:    '',
+    };
+    const to = {
+      githubConfigUrl:    'https://github.com/abc',
+      githubConfigSecret: 'preexisting-secret',
+    };
+
+    expect(() => diff(from, to)).not.toThrow();
+
+    const result = diff(from, to);
+
+    expect(result.githubConfigSecret).toStrictEqual('preexisting-secret');
+    expect(result.githubConfigUrl).toStrictEqual('https://github.com/abc');
+    // No garbage nested null should be injected under the replaced key
+    expect(Object.keys(result)).not.toContain('githubConfigSecret.github_token');
+  });
 });
 
 describe('fx: definedKeys', () => {