[Test Improver] Add unit tests for namespace-filter.js and async.ts utilities (#17692)

* test: add unit tests for namespace-filter.js and async.ts utilities

- namespace-filter.js: 14 tests covering all exported constants and
  createNamespaceFilterKey / createNamespaceFilterKeyWithId /
  splitNamespaceFilterKey (100% stmts/branches/fns/lines)
- async.ts: 6 tests for wait() and waitFor() using fake timers,
  covering immediate resolve, polling, timeout with message, and
  timeout without message (94% stmts, 86% branches, 100% fns)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* ci: trigger checks

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: github-actions[bot]

shell/utils/__tests__/async.test.ts

@@ -0,0 +1,87 @@
+import { waitFor, wait } from '@shell/utils/async';
+
+describe('wait', () => {
+  it('resolves after the specified delay', async() => {
+    jest.useFakeTimers();
+
+    const p = wait(1000);
+
+    jest.advanceTimersByTime(1000);
+    await expect(p).resolves.toBeUndefined();
+
+    jest.useRealTimers();
+  });
+
+  it('does not resolve before the delay elapses', async() => {
+    jest.useFakeTimers();
+
+    let resolved = false;
+    const p = wait(500).then(() => {
+      resolved = true;
+    });
+
+    jest.advanceTimersByTime(499);
+    expect(resolved).toBe(false);
+
+    jest.advanceTimersByTime(1);
+    await p;
+    expect(resolved).toBe(true);
+
+    jest.useRealTimers();
+  });
+});
+
+describe('waitFor', () => {
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('resolves immediately when testFn returns true on first call', async() => {
+    jest.useFakeTimers();
+    const testFn = jest.fn().mockReturnValue(true);
+
+    const p = waitFor(testFn, 'ready');
+
+    await expect(p).resolves.toBeDefined();
+    expect(testFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('resolves after testFn eventually returns true', async() => {
+    jest.useFakeTimers();
+    let count = 0;
+    const testFn = jest.fn().mockImplementation(() => {
+      count++;
+
+      return count >= 3;
+    });
+
+    const p = waitFor(testFn, 'ready', 10000, 500);
+
+    // first call returns false (immediate check), then intervals fire
+    jest.advanceTimersByTime(500); // interval 1 → count=2, false
+    jest.advanceTimersByTime(500); // interval 2 → count=3, true
+    await p;
+
+    expect(testFn).toHaveBeenCalledTimes(3);
+  });
+
+  it('rejects with msg when timeout elapses', async() => {
+    jest.useFakeTimers();
+    const testFn = jest.fn().mockReturnValue(false);
+
+    const p = waitFor(testFn, 'some condition', 1000, 500);
+
+    jest.advanceTimersByTime(1001);
+    await expect(p).rejects.toThrow('Failed waiting for: some condition');
+  });
+
+  it('rejects with generic message when no msg provided and timeout elapses', async() => {
+    jest.useFakeTimers();
+    const testFn = jest.fn().mockReturnValue(false);
+
+    const p = waitFor(testFn, '', 2000, 500);
+
+    jest.advanceTimersByTime(2001);
+    await expect(p).rejects.toThrow('waitFor timed out after 2 seconds');
+  });
+});

shell/utils/__tests__/namespace-filter.test.ts

@@ -0,0 +1,109 @@
+import {
+  NAMESPACE_FILTER_ALL_PREFIX,
+  NAMESPACE_FILTER_NS_PREFIX,
+  NAMESPACE_FILTER_P_PREFIX,
+  NAMESPACE_FILTER_NS_FULL_PREFIX,
+  NAMESPACE_FILTER_P_FULL_PREFIX,
+  NAMESPACE_FILTER_ALL,
+  NAMESPACE_FILTER_ALL_SYSTEM,
+  NAMESPACE_FILTER_ALL_USER,
+  NAMESPACE_FILTER_ALL_ORPHANS,
+  NAMESPACE_FILTER_NAMESPACED_PREFIX,
+  NAMESPACE_FILTER_NAMESPACED_YES,
+  NAMESPACE_FILTER_NAMESPACED_NO,
+  NAMESPACE_FILTER_KINDS,
+  createNamespaceFilterKey,
+  createNamespaceFilterKeyWithId,
+  splitNamespaceFilterKey,
+} from '@shell/utils/namespace-filter';
+
+describe('namespace-filter constants', () => {
+  it('prefix constants have expected values', () => {
+    expect(NAMESPACE_FILTER_ALL_PREFIX).toStrictEqual('all');
+    expect(NAMESPACE_FILTER_NS_PREFIX).toStrictEqual('ns');
+    expect(NAMESPACE_FILTER_P_PREFIX).toStrictEqual('project');
+  });
+
+  it('full prefix constants are built from base prefixes', () => {
+    expect(NAMESPACE_FILTER_NS_FULL_PREFIX).toStrictEqual('ns://');
+    expect(NAMESPACE_FILTER_P_FULL_PREFIX).toStrictEqual('project://');
+  });
+
+  it('all-namespace filter constants have expected values', () => {
+    expect(NAMESPACE_FILTER_ALL).toStrictEqual('all');
+    expect(NAMESPACE_FILTER_ALL_SYSTEM).toStrictEqual('all://system');
+    expect(NAMESPACE_FILTER_ALL_USER).toStrictEqual('all://user');
+    expect(NAMESPACE_FILTER_ALL_ORPHANS).toStrictEqual('all://orphans');
+  });
+
+  it('namespaced filter constants have expected values', () => {
+    expect(NAMESPACE_FILTER_NAMESPACED_PREFIX).toStrictEqual('namespaced://');
+    expect(NAMESPACE_FILTER_NAMESPACED_YES).toStrictEqual('namespaced://true');
+    expect(NAMESPACE_FILTER_NAMESPACED_NO).toStrictEqual('namespaced://false');
+  });
+
+  it('nAMESPACE_FILTER_KINDS has expected shape', () => {
+    expect(NAMESPACE_FILTER_KINDS).toStrictEqual({
+      DIVIDER:   'divider',
+      PROJECT:   'project',
+      NAMESPACE: 'namespace',
+      SPECIAL:   'special',
+    });
+  });
+});
+
+describe('createNamespaceFilterKey', () => {
+  it('returns clusterId when product is undefined', () => {
+    expect(createNamespaceFilterKey('c-abc', undefined)).toStrictEqual('c-abc');
+  });
+
+  it('returns clusterId when product has no customNamespaceFilter', () => {
+    expect(createNamespaceFilterKey('c-abc', { name: 'manager' })).toStrictEqual('c-abc');
+  });
+
+  it('returns clusterId when product.customNamespaceFilter is falsy', () => {
+    expect(createNamespaceFilterKey('c-abc', { name: 'manager', customNamespaceFilter: false })).toStrictEqual('c-abc');
+  });
+
+  it('returns compound key when product has customNamespaceFilter', () => {
+    const result = createNamespaceFilterKey('c-abc', { name: 'myProduct', customNamespaceFilter: true });
+
+    expect(result).toStrictEqual('c-abc__%%__myProduct');
+  });
+});
+
+describe('createNamespaceFilterKeyWithId', () => {
+  it('combines clusterId and productId with separator', () => {
+    expect(createNamespaceFilterKeyWithId('c-abc', 'myProduct')).toStrictEqual('c-abc__%%__myProduct');
+  });
+
+  it('works with empty strings', () => {
+    expect(createNamespaceFilterKeyWithId('', '')).toStrictEqual('__%%__');
+  });
+});
+
+describe('splitNamespaceFilterKey', () => {
+  it('splits a compound key into clusterId and productId', () => {
+    expect(splitNamespaceFilterKey('c-abc__%%__myProduct')).toStrictEqual({
+      clusterId: 'c-abc',
+      productId: 'myProduct',
+    });
+  });
+
+  it('returns undefined productId when key has no separator', () => {
+    expect(splitNamespaceFilterKey('c-abc')).toStrictEqual({
+      clusterId: 'c-abc',
+      productId: undefined,
+    });
+  });
+
+  it('round-trips with createNamespaceFilterKeyWithId', () => {
+    const key = createNamespaceFilterKeyWithId('cluster-1', 'product-a');
+    const result = splitNamespaceFilterKey(key);
+
+    expect(result).toStrictEqual({
+      clusterId: 'cluster-1',
+      productId: 'product-a',
+    });
+  });
+});