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

package/utils/gc/__tests__/gc.test.ts

@@ -0,0 +1,487 @@
+import type defaultGc from '@shell/utils/gc/gc';
+import { MANAGEMENT } from '@shell/config/types';
+
+type GcInstance = typeof defaultGc;
+
+const DEFAULT_PREFS = {
+  enabled:           true,
+  enabledInterval:   true,
+  interval:          300,
+  enabledOnNavigate: true,
+  ageThreshold:      120, // seconds → maxAge = 120_000 ms
+  countThreshold:    500,
+};
+
+let stampCounter = 1000;
+
+function makeRootState(prefs = DEFAULT_PREFS, clusterReady = true): any {
+  stampCounter++;
+
+  return {
+    clusterReady,
+    management: {
+      types: {
+        [MANAGEMENT.SETTING]: {
+          list: [
+            {
+              id:       'ui-performance',
+              value:    JSON.stringify({ garbageCollection: prefs }),
+              metadata: { generation: stampCounter, resourceVersion: '1' },
+            },
+          ],
+        },
+      },
+    },
+  };
+}
+
+function makeEmptyRootState(): any {
+  return {
+    clusterReady: true,
+    management:   { types: { [MANAGEMENT.SETTING]: { list: [] } } },
+  };
+}
+
+function makeCtx(options: {
+  namespace?: string;
+  supportsGc?: boolean;
+  gcIgnoreTypes?: Record<string, boolean>;
+  prefs?: Partial<typeof DEFAULT_PREFS>;
+  dispatch?: jest.Mock;
+  countsByType?: Record<string, number>;
+  clusterReady?: boolean;
+} = {}): any {
+  const {
+    namespace = 'teststore',
+    supportsGc = true,
+    gcIgnoreTypes = {},
+    prefs,
+    dispatch = jest.fn(),
+    countsByType = {},
+    clusterReady = true,
+  } = options;
+
+  const rootState = makeRootState(
+    prefs ? { ...DEFAULT_PREFS, ...prefs } : DEFAULT_PREFS,
+    clusterReady
+  );
+
+  return {
+    state:   { config: { supportsGc, namespace } },
+    rootState,
+    getters: {
+      gcIgnoreTypes,
+      all: () => [{
+        counts: Object.fromEntries(
+          Object.entries(countsByType).map(([t, c]) => [t, { summary: { count: c } }])
+        ),
+      }],
+    },
+    dispatch,
+  };
+}
+
+/**
+ * Each test in the outer describe gets a fresh gc instance (gcLastRun = 0,
+ * empty caches) so tests do not interfere with each other via shared singleton state.
+ */
+describe('gc', () => {
+  let gc: GcInstance;
+
+  beforeEach(() => {
+    jest.resetModules();
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+    gc = require('@shell/utils/gc/gc').default as GcInstance;
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  // ─── gcEnabledForStore ─────────────────────────────────────────────────────
+
+  describe('gcEnabledForStore', () => {
+    it.each([
+      {
+        desc: 'true when supportsGc is true', state: { config: { supportsGc: true } }, expected: true
+      },
+      {
+        desc: 'false when supportsGc is false', state: { config: { supportsGc: false } }, expected: false
+      },
+      {
+        desc: 'undefined when state is undefined', state: undefined, expected: undefined
+      },
+    ])('returns $desc', ({ state, expected }) => {
+      expect(gc.gcEnabledForStore(state)).toBe(expected);
+    });
+  });
+
+  // ─── gcEnabledForType ──────────────────────────────────────────────────────
+
+  describe('gcEnabledForType', () => {
+    it.each([
+      {
+        desc: 'false when type is empty string', gcIgnoreTypes: {}, type: '', expected: false
+      },
+      {
+        desc: 'false when type is in gcIgnoreTypes', gcIgnoreTypes: { pods: true }, type: 'pods', expected: false
+      },
+      {
+        desc: 'true when type is non-empty and not ignored', gcIgnoreTypes: {}, type: 'deployments', expected: true
+      },
+    ])('returns $desc', ({ gcIgnoreTypes, type, expected }) => {
+      expect(gc.gcEnabledForType({ getters: { gcIgnoreTypes } }, type)).toBe(expected);
+    });
+  });
+
+  // ─── gcEnabledSetting ──────────────────────────────────────────────────────
+
+  describe('gcEnabledSetting', () => {
+    it('returns true when GC is enabled in ui-performance setting', () => {
+      const ctx = { rootState: makeRootState({ ...DEFAULT_PREFS, enabled: true }) };
+
+      expect(gc.gcEnabledSetting(ctx)).toBe(true);
+    });
+
+    it('returns false when GC is disabled in ui-performance setting', () => {
+      const ctx = { rootState: makeRootState({ ...DEFAULT_PREFS, enabled: false }) };
+
+      expect(gc.gcEnabledSetting(ctx)).toBe(false);
+    });
+
+    it('returns undefined when ui-performance setting is absent', () => {
+      const ctx = { rootState: makeEmptyRootState() };
+
+      expect(gc.gcEnabledSetting(ctx)).toBeUndefined();
+    });
+  });
+
+  // ─── gcEnabledAll ──────────────────────────────────────────────────────────
+
+  describe('gcEnabledAll', () => {
+    it.each([
+      {
+        desc: 'true when all checks pass', options: {}, type: 'deployments', expected: true
+      },
+      {
+        desc: 'false when store does not support GC', options: { supportsGc: false }, type: 'deployments', expected: false
+      },
+      {
+        desc: 'false when GC is disabled in settings', options: { prefs: { enabled: false } }, type: 'deployments', expected: false
+      },
+      {
+        desc: 'false when type is in gcIgnoreTypes', options: { gcIgnoreTypes: { schema: true } }, type: 'schema', expected: false
+      },
+    ])('returns $desc', ({ options, type, expected }) => {
+      expect(gc.gcEnabledAll(makeCtx(options), type)).toBe(expected);
+    });
+  });
+
+  // ─── gcEnabledInterval ─────────────────────────────────────────────────────
+
+  describe('gcEnabledInterval', () => {
+    it('returns enabledInterval and interval from settings', () => {
+      const ctx = {
+        rootState: makeRootState({
+          ...DEFAULT_PREFS, enabledInterval: true, interval: 600
+        })
+      };
+
+      expect(gc.gcEnabledInterval(ctx)).toStrictEqual({ enabled: true, interval: 600 });
+    });
+
+    it('returns enabled: undefined and interval: 0 when setting is absent', () => {
+      const ctx = { rootState: makeEmptyRootState() };
+
+      expect(gc.gcEnabledInterval(ctx)).toStrictEqual({ enabled: undefined, interval: 0 });
+    });
+
+    it('returns interval: 0 when the interval value is falsy', () => {
+      const ctx = { rootState: makeRootState({ ...DEFAULT_PREFS, interval: 0 }) };
+
+      expect(gc.gcEnabledInterval(ctx)).toStrictEqual({ enabled: true, interval: 0 });
+    });
+  });
+
+  // ─── gcEnabledRoute ────────────────────────────────────────────────────────
+
+  describe('gcEnabledRoute', () => {
+    it('returns enabledOnNavigate from settings', () => {
+      const ctx = { rootState: makeRootState({ ...DEFAULT_PREFS, enabledOnNavigate: false }) };
+
+      expect(gc.gcEnabledRoute(ctx)).toBe(false);
+    });
+
+    it('returns undefined when setting is absent', () => {
+      const ctx = { rootState: makeEmptyRootState() };
+
+      expect(gc.gcEnabledRoute(ctx)).toBeUndefined();
+    });
+  });
+
+  // ─── gcUpdateRouteChanged ──────────────────────────────────────────────────
+
+  describe('gcUpdateRouteChanged', () => {
+    /**
+     * Condition in garbageCollect:
+     *   if (lastRouteChange < lastAccessed) → skip (resource is in current route)
+     *
+     * So: route changed at T1, resource accessed at T2 > T1
+     *   → lastRouteChange (T1) < lastAccessed (T2) → GC skips this type.
+     */
+    it('prevents a resource from being GC\'d when route changed before last access', () => {
+      const dispatch = jest.fn();
+      const type = 'pods';
+      const namespace = 'routetest';
+
+      jest.useFakeTimers();
+
+      // Route change at t=200_000 ms
+      jest.setSystemTime(200_000);
+      gc.gcUpdateRouteChanged();
+
+      // Resource accessed at t=300_000 ms (AFTER route change → in current route)
+      jest.setSystemTime(300_000);
+      gc.gcUpdateLastAccessed(makeCtx({ namespace }), type);
+
+      // GC runs at t=600_000 ms
+      // now - lastAccessed = 300_000 > maxAge(120_000) ✓ age check passes
+      // lastRouteChange(200_000) < lastAccessed(300_000) → skip (in current route)
+      jest.setSystemTime(600_000);
+      gc.garbageCollect(makeCtx({
+        namespace,
+        countsByType: { [type]: 1000 },
+        dispatch,
+      }));
+
+      expect(dispatch).not.toHaveBeenCalledWith('forgetType', type);
+    });
+  });
+
+  // ─── garbageCollect ────────────────────────────────────────────────────────
+
+  describe('garbageCollect', () => {
+    it('skips when recently run (within GC_RE_RUN_GAP of 5 s)', () => {
+      const dispatch = jest.fn();
+
+      jest.useFakeTimers();
+      jest.setSystemTime(10_000);
+
+      // First call: cluster not ready → gcLastRun = 10_000
+      gc.garbageCollect(makeCtx({ clusterReady: false, dispatch }));
+      // Second call at same time: 10_000 - 10_000 = 0 < 5000 → skips
+      gc.garbageCollect(makeCtx({ dispatch }));
+
+      expect(dispatch).not.toHaveBeenCalledWith('forgetType', expect.any(String));
+    });
+
+    it('skips when cluster is not ready', () => {
+      const dispatch = jest.fn();
+
+      jest.useFakeTimers();
+      jest.setSystemTime(10_000);
+
+      gc.garbageCollect(makeCtx({ clusterReady: false, dispatch }));
+
+      expect(dispatch).not.toHaveBeenCalledWith('forgetType', expect.any(String));
+    });
+
+    it('skips when ui-performance setting is absent', () => {
+      const dispatch = jest.fn();
+
+      jest.useFakeTimers();
+      jest.setSystemTime(10_000);
+
+      const ctx = {
+        state:     { config: { supportsGc: true, namespace: 'teststore' } },
+        rootState: makeEmptyRootState(),
+        getters:   { gcIgnoreTypes: {} },
+        dispatch,
+      };
+
+      gc.garbageCollect(ctx);
+
+      expect(dispatch).not.toHaveBeenCalledWith('forgetType', expect.any(String));
+    });
+
+    it('skips a type listed in the explicit ignoreTypes parameter', () => {
+      const dispatch = jest.fn();
+      const type = 'configmaps';
+      const namespace = 'ignoretypetest';
+
+      jest.useFakeTimers();
+
+      jest.setSystemTime(200_000);
+      gc.gcUpdateLastAccessed(makeCtx({ namespace }), type);
+
+      jest.setSystemTime(300_000);
+      gc.gcUpdateRouteChanged();
+
+      jest.setSystemTime(400_000);
+      gc.garbageCollect(
+        makeCtx({
+          namespace, countsByType: { [type]: 1000 }, dispatch
+        }),
+        { [type]: true }
+      );
+
+      expect(dispatch).not.toHaveBeenCalledWith('forgetType', type);
+    });
+
+    it('skips a type that was accessed within the ageThreshold', () => {
+      const dispatch = jest.fn();
+      const type = 'secrets';
+      const namespace = 'recenttest';
+
+      jest.useFakeTimers();
+
+      // Access 30 s ago (less than 120 s ageThreshold)
+      jest.setSystemTime(10_000);
+      gc.gcUpdateLastAccessed(makeCtx({ namespace }), type);
+
+      jest.setSystemTime(40_000); // 30 s later
+      gc.garbageCollect(makeCtx({
+        namespace, countsByType: { [type]: 1000 }, dispatch
+      }));
+
+      expect(dispatch).not.toHaveBeenCalledWith('forgetType', type);
+    });
+
+    it('skips a type whose count is below countThreshold', () => {
+      const dispatch = jest.fn();
+      const type = 'namespaces';
+      const namespace = 'lowcounttest';
+
+      jest.useFakeTimers();
+
+      jest.setSystemTime(200_000);
+      gc.gcUpdateLastAccessed(makeCtx({ namespace }), type);
+
+      jest.setSystemTime(300_000);
+      gc.gcUpdateRouteChanged();
+
+      jest.setSystemTime(400_000);
+      // count(100) < countThreshold(500) → skip
+      gc.garbageCollect(makeCtx({
+        namespace, countsByType: { [type]: 100 }, dispatch
+      }));
+
+      expect(dispatch).not.toHaveBeenCalledWith('forgetType', type);
+    });
+
+    it('dispatches forgetType for a resource that meets all GC criteria', () => {
+      const dispatch = jest.fn();
+      const type = 'events';
+      const namespace = 'gcqualifytest';
+
+      jest.useFakeTimers();
+
+      // Resource accessed at t=200_000
+      jest.setSystemTime(200_000);
+      gc.gcUpdateLastAccessed(makeCtx({ namespace }), type);
+
+      // Route changed at t=300_000 (AFTER access → lastRouteChange > lastAccessed → no skip)
+      jest.setSystemTime(300_000);
+      gc.gcUpdateRouteChanged();
+
+      // GC at t=400_000: now - lastAccessed = 200_000 > maxAge(120_000) ✓
+      jest.setSystemTime(400_000);
+      gc.garbageCollect(makeCtx({
+        namespace, countsByType: { [type]: 1000 }, dispatch
+      }));
+
+      expect(dispatch).toHaveBeenCalledWith('forgetType', type);
+    });
+  });
+
+  // ─── gcResetStore ──────────────────────────────────────────────────────────
+
+  describe('gcResetStore', () => {
+    it('removes all cached entries for the store, preventing forgetType dispatch', () => {
+      const dispatch = jest.fn();
+      const type = 'ingresses';
+      const namespace = 'resetstoretest';
+
+      jest.useFakeTimers();
+
+      jest.setSystemTime(200_000);
+      gc.gcUpdateLastAccessed(makeCtx({ namespace }), type);
+
+      jest.setSystemTime(300_000);
+      gc.gcUpdateRouteChanged();
+
+      gc.gcResetStore({ config: { namespace } });
+
+      jest.setSystemTime(400_000);
+      gc.garbageCollect(makeCtx({
+        namespace, countsByType: { [type]: 1000 }, dispatch
+      }));
+
+      expect(dispatch).not.toHaveBeenCalledWith('forgetType', type);
+    });
+  });
+
+  // ─── gcResetType ───────────────────────────────────────────────────────────
+
+  describe('gcResetType', () => {
+    it('removes a specific type so it is not GC\'d while leaving other types intact', () => {
+      const dispatch = jest.fn();
+      const typeA = 'storageclasses';
+      const typeB = 'persistentvolumes';
+      const namespace = 'resettypetest';
+
+      jest.useFakeTimers();
+
+      jest.setSystemTime(200_000);
+      gc.gcUpdateLastAccessed(makeCtx({ namespace }), typeA);
+      gc.gcUpdateLastAccessed(makeCtx({ namespace }), typeB);
+
+      jest.setSystemTime(300_000);
+      gc.gcUpdateRouteChanged();
+
+      gc.gcResetType({ config: { namespace } }, typeA);
+
+      jest.setSystemTime(400_000);
+      gc.garbageCollect(makeCtx({
+        namespace,
+        countsByType: { [typeA]: 1000, [typeB]: 1000 },
+        dispatch,
+      }));
+
+      expect(dispatch).not.toHaveBeenCalledWith('forgetType', typeA);
+      expect(dispatch).toHaveBeenCalledWith('forgetType', typeB);
+    });
+
+    it('is a no-op when the store has no cached entries', () => {
+      expect(() => {
+        gc.gcResetType({ config: { namespace: 'nonexistent-store' } }, 'pods');
+      }).not.toThrow();
+    });
+  });
+
+  // ─── gcUpdateLastAccessed ──────────────────────────────────────────────────
+
+  describe('gcUpdateLastAccessed', () => {
+    it('does not populate cache when GC is disabled for the store', () => {
+      const dispatch = jest.fn();
+      const type = 'replicasets';
+      const namespace = 'disabledgctest';
+
+      jest.useFakeTimers();
+
+      // supportsGc: false → gcEnabledAll = false → cache not updated
+      jest.setSystemTime(200_000);
+      gc.gcUpdateLastAccessed(makeCtx({ namespace, supportsGc: false }), type);
+
+      jest.setSystemTime(300_000);
+      gc.gcUpdateRouteChanged();
+
+      jest.setSystemTime(400_000);
+      gc.garbageCollect(makeCtx({
+        namespace, countsByType: { [type]: 1000 }, dispatch
+      }));
+
+      expect(dispatch).not.toHaveBeenCalledWith('forgetType', type);
+    });
+  });
+});

package/utils/ingress.ts

@@ -56,7 +56,15 @@ class IngressDetailEditHelper {
     return services.map((service) => ({
       label: service.metadata.name,
       value: service.metadata.name,
-      ports: service.spec.ports?.map((p: any) => p.port)
+      ports: service.spec.ports?.flatMap((p: any) => {
+        const options = [p.port];
+
+        if (p.name) {
+          options.push(p.name);
+        }
+
+        return options;
+      })
     }));
   }
 }

package/utils/pagination-utils.ts

@@ -24,9 +24,10 @@ import { EXT_IDS } from '@shell/core/plugin';
 import { ExtensionManager } from '@shell/types/extension-manager';
 import { DEFAULT_PERF_SETTING } from '@shell/config/settings';
 
+// This feature will be removed soon - https://github.com/rancher/dashboard/issues/17323
 const homePageClusterFeature: PaginationFeature<PaginationFeatureHomePageClusterConfig> = {
   version:       1,
-  enabled:       true,
+  enabled:       false,
   configuration: {
     threshold: 500, results: 250, pagesPerRow: 25
   }

package/utils/string.js

@@ -349,10 +349,33 @@ export function xOfy(x, y) {
   return `${ typeof x === 'number' ? x : '?' }/${ typeof y === 'number' ? y : '?' }`;
 }
 
+const BASE64_REGEX = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
+
 export function isBase64(value) {
-  const base64regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
+  return BASE64_REGEX.test(value);
+}
+
+/**
+ * Checks if a value is a valid base64-encoded CA bundle.
+ * Unlike isBase64, this handles multiline base64 (e.g. openssl wraps at 76 chars)
+ * and rejects short strings that could be false positives.
+ * @param {string} value
+ * @returns {boolean}
+ */
+export function isBase64EncodedCert(value) {
+  if (!value || typeof value !== 'string') {
+    return false;
+  }
+
+  // Strip whitespace to handle line-wrapped base64 output
+  const stripped = value.replace(/\s/g, '');
+
+  // CA certs are long enough that legitimate base64 will always exceed this
+  if (stripped.length < 16) {
+    return false;
+  }
 
-  return base64regex.test(value);
+  return BASE64_REGEX.test(stripped);
 }
 
 export function generateRandomAlphaString(length) {

package/utils/uiplugins.ts

@@ -180,18 +180,19 @@ export async function getHelmRepositoryExact(store: any, url: string): Promise<H
 /**
  *
  * @param store Vue store
- * @param urlRegexes Regex to match a community repository
+ * @param urlRegexes Regex to match against the repository's urls
  * @param catalogImages Catalog images to match against the repository's labels
  * @returns HelmRepository
  */
 export async function getHelmRepositoryMatch(store: any, urlRegexes: string[], catalogImages: string[]): Promise<HelmRepository> {
   return await getHelmRepository(store, (repository: any) => {
-    // if installed from rancher/ui-plugin-catalog or rancher/ui-extension-harvester-ui-extension
     const catalog = repository?.metadata?.labels?.[UI_PLUGIN_LABELS.CATALOG_IMAGE] || '';
 
-    if (catalogImages.includes(catalog)) {
+    // if installed from rancher/ui-plugin-catalog or rancher/ui-extension-harvester-ui-extension
+    if (catalog && catalogImages.includes(catalog)) {
       return true;
     }
+
     const target = repository.spec?.gitBranch ? repository.spec?.gitRepo : repository.spec?.url;
 
     return matchesSomeRegex(target, urlRegexes);
@@ -272,8 +273,7 @@ export async function createHelmRepository(store: any, name: string, url: string
     });
 
     tries++;
-
-    const downloaded = repo.status.conditions.find((s: any) => s.type === 'Downloaded');
+    const downloaded = repo.status?.conditions.find((s: any) => s.type === 'Downloaded');
 
     console.log(`Waiting for helm repository to be downloaded... try ${ tries } time(s).`); // eslint-disable-line no-console
 

package/utils/validators/__tests__/cluster-name.test.ts

@@ -0,0 +1,110 @@
+import { clusterName } from '@shell/utils/validators/cluster-name';
+
+function makeGetters(): Record<string, unknown> {
+  return {
+    'i18n/t':      (key: string, args?: unknown) => (args ? `${ key }:${ JSON.stringify(args) }` : key),
+    'i18n/exists': () => false,
+  };
+}
+
+describe('clusterName', () => {
+  describe('non-rke2 mode', () => {
+    it('returns no errors for any name when not rke2', () => {
+      const errors = clusterName('c-abcde', makeGetters(), [], ['false'], 'Name');
+
+      expect(errors).toStrictEqual([]);
+    });
+
+    it('returns no errors for local when not rke2', () => {
+      const errors = clusterName('local', makeGetters(), [], ['false'], 'Name');
+
+      expect(errors).toStrictEqual([]);
+    });
+
+    it('returns no errors for arbitrary name when not rke2', () => {
+      const errors = clusterName('my-cluster', makeGetters(), [], ['false'], 'Name');
+
+      expect(errors).toStrictEqual([]);
+    });
+  });
+
+  describe('rke2 mode', () => {
+    it('rejects name matching c-XXXXX pattern', () => {
+      const errors = clusterName('c-abcde', makeGetters(), [], ['true'], 'Name');
+
+      expect(errors).toContain('validation.cluster.name');
+    });
+
+    it('rejects "local" cluster name', () => {
+      const errors = clusterName('local', makeGetters(), [], ['true'], 'Name');
+
+      expect(errors).toContain('validation.cluster.name');
+    });
+
+    it('rejects "LOCAL" (case-insensitive match)', () => {
+      const errors = clusterName('LOCAL', makeGetters(), [], ['true'], 'Name');
+
+      expect(errors).toContain('validation.cluster.name');
+    });
+
+    it('rejects "Local" (mixed case)', () => {
+      const errors = clusterName('Local', makeGetters(), [], ['true'], 'Name');
+
+      expect(errors).toContain('validation.cluster.name');
+    });
+
+    it('rejects "c-ABCDE" (uppercase legacy id)', () => {
+      const errors = clusterName('c-ABCDE', makeGetters(), [], ['true'], 'Name');
+
+      expect(errors).toContain('validation.cluster.name');
+    });
+
+    it('accepts a valid rke2 cluster name', () => {
+      const errors = clusterName('my-cluster', makeGetters(), [], ['true'], 'Name');
+
+      expect(errors).toStrictEqual([]);
+    });
+
+    it('accepts name with more than 5 chars after c-', () => {
+      const errors = clusterName('c-abcdef', makeGetters(), [], ['true'], 'Name');
+
+      expect(errors).toStrictEqual([]);
+    });
+
+    it('accepts name starting with c- but less than 5 chars after', () => {
+      const errors = clusterName('c-abc', makeGetters(), [], ['true'], 'Name');
+
+      expect(errors).toStrictEqual([]);
+    });
+  });
+
+  describe('empty/null pathValue', () => {
+    it('handles empty string without throwing', () => {
+      const errors = clusterName('', makeGetters(), [], ['true'], 'Name');
+
+      expect(errors).toStrictEqual([]);
+    });
+
+    it('handles null without throwing', () => {
+      const errors = clusterName(null, makeGetters(), [], ['true'], 'Name');
+
+      expect(errors).toStrictEqual([]);
+    });
+
+    it('handles undefined without throwing', () => {
+      const errors = clusterName(undefined, makeGetters(), [], ['true'], 'Name');
+
+      expect(errors).toStrictEqual([]);
+    });
+  });
+
+  describe('errors array accumulation', () => {
+    it('appends to existing errors array', () => {
+      const existing = ['prior-error'];
+      const errors = clusterName('local', makeGetters(), existing, ['true'], 'Name');
+
+      expect(errors[0]).toBe('prior-error');
+      expect(errors).toContain('validation.cluster.name');
+    });
+  });
+});