Enhance multi-container testing

Signed-off-by: Adameska <[email protected]>

Author: adameska

packages/webview/src/component/pods/PodLogs.spec.ts

@@ -196,6 +196,69 @@ describe('PodLogs', () => {
       expect(writtenLog).toContain('\u001b[33m{\u001b[0m'); // yellow brace
       expect(writtenLog).toContain('\u001b[32m42\u001b[0m'); // green number
     });
+
+    test('should handle malformed JSON gracefully', () => {
+      const pod = createPod(['containerName']);
+      const mockedTerminal = createMockTerminal();
+      setupTerminalMock(mockedTerminal);
+
+      render(PodLogs, { object: pod });
+
+      streamPodLogsMock.sendData({
+        podName: 'podName',
+        namespace: 'namespace',
+        containerName: 'containerName',
+        data: '{"level":"info"', // incomplete JSON
+      });
+
+      const writtenLog = vi.mocked(mockedTerminal.write).mock.calls[0][0] as string;
+      // Should still output the log without crashing - may have ANSI codes but text preserved
+      expect(writtenLog).toContain('level');
+      expect(writtenLog).toContain('info');
+    });
+
+    test.each([
+      { level: 'error:', color: '\u001b[31;1m', desc: 'error (bright red)' },
+      { level: 'warn:', color: '\u001b[33m', desc: 'warn (yellow)' },
+      { level: 'debug:', color: '\u001b[32m', desc: 'debug (green)' },
+    ])('should colorize $desc log level', ({ level, color }) => {
+      const pod = createPod(['containerName']);
+      const mockedTerminal = createMockTerminal();
+      setupTerminalMock(mockedTerminal);
+
+      render(PodLogs, { object: pod });
+
+      streamPodLogsMock.sendData({
+        podName: 'podName',
+        namespace: 'namespace',
+        containerName: 'containerName',
+        data: `${level} Some message`,
+      });
+
+      const writtenLog = vi.mocked(mockedTerminal.write).mock.calls[0][0] as string;
+      expect(writtenLog).toContain(color);
+      expect(writtenLog).toContain('\u001b[0m');
+    });
+
+    test('should pad shorter container names to align with longest', () => {
+      const pod = createPod(['a', 'longername']);
+      const mockedTerminal = createMockTerminal();
+      setupTerminalMock(mockedTerminal);
+
+      render(PodLogs, { object: pod });
+
+      streamPodLogsMock.sendData({
+        podName: 'podName',
+        namespace: 'namespace',
+        containerName: 'a',
+        data: 'short name log',
+      });
+
+      const writtenLog = vi.mocked(mockedTerminal.write).mock.calls[0][0] as string;
+      // 'a' should be padded with spaces to match 'longername' length (10 chars)
+      // Format: <padding><colored-name>|<log>
+      expect(writtenLog).toContain('\u001b[36ma\u001b[0m|short name log');
+    });
   });
 
   describe('terminal initialization', () => {
@@ -212,24 +275,46 @@ describe('PodLogs', () => {
   });
 
   describe('multi-container prefix colors', () => {
-    test('should apply colored prefixes for each container', () => {
+    test('should apply colored prefixes for each container', async () => {
       const pod = createPod(['container1', 'container2', 'container3']);
       const mockedTerminal = createMockTerminal();
       setupTerminalMock(mockedTerminal);
 
       render(PodLogs, { object: pod });
 
+      // Wait for all 3 container subscriptions to be set up (async onMount)
+      await streamPodLogsMock.waitForSubscriptions(3);
+
       // Send log from first container
       streamPodLogsMock.sendData({
         podName: 'podName',
         namespace: 'namespace',
         containerName: 'container1',
-        data: 'log message',
+        data: 'log from container1',
+      });
+
+      // Send log from second container
+      streamPodLogsMock.sendData({
+        podName: 'podName',
+        namespace: 'namespace',
+        containerName: 'container2',
+        data: 'log from container2',
+      });
+
+      // Send log from third container
+      streamPodLogsMock.sendData({
+        podName: 'podName',
+        namespace: 'namespace',
+        containerName: 'container3',
+        data: 'log from container3',
       });
 
       const calls = vi.mocked(mockedTerminal.write).mock.calls;
-      // First container should have cyan prefix
-      expect(calls[0][0]).toContain('\u001b[36mcontainer1\u001b[0m|');
+      // Each container should have a colored prefix with pipe separator
+      // Colors cycle: cyan, yellow, green
+      expect(calls[0][0]).toContain('\u001b[36mcontainer1\u001b[0m|log from container1');
+      expect(calls[1][0]).toContain('\u001b[33mcontainer2\u001b[0m|log from container2');
+      expect(calls[2][0]).toContain('\u001b[32mcontainer3\u001b[0m|log from container3');
     });
   });
 });

packages/webview/src/stream/util/fake-stream-object.svelte.ts

@@ -16,25 +16,63 @@
  * SPDX-License-Identifier: Apache-2.0
  ***********************************************************************/
 
-import type { StreamObject } from './stream-object';
 import { type IDisposable } from '@kubernetes-dashboard/channels';
+import { SvelteMap } from 'svelte/reactivity';
+import type { StreamObject } from './stream-object';
 
 /**
- * Fake StreamObject for tests
+ * Fake StreamObject for tests.
+ * Supports multiple subscriptions keyed by podName/namespace/containerName.
  */
 export class FakeStreamObject<T> implements StreamObject<T> {
-  #callback: (data: T) => void;
+  #callbacks = new SvelteMap<string, (data: T) => void>();
+
   async subscribe(
     podName: string,
     namespace: string,
     containerName: string,
     callback: (data: T) => void,
   ): Promise<IDisposable> {
-    this.#callback = callback;
-    return { dispose: () => {} } as IDisposable;
+    const key = `${podName}/${namespace}/${containerName}`;
+    this.#callbacks.set(key, callback);
+    return {
+      dispose: () => {
+        this.#callbacks.delete(key);
+      },
+    } as IDisposable;
+  }
+
+  /**
+   * Send data to the callback registered for the matching podName/namespace/containerName.
+   * The data object must have these properties to route correctly.
+   */
+  sendData(data: T & { podName?: string; namespace?: string; containerName?: string }): void {
+    const key = `${data.podName}/${data.namespace}/${data.containerName}`;
+    const callback = this.#callbacks.get(key);
+    if (callback) {
+      callback(data);
+    }
+  }
+
+  /**
+   * Returns the number of active subscriptions.
+   * Useful for tests to verify subscriptions are set up.
+   */
+  get subscriptionCount(): number {
+    return this.#callbacks.size;
   }
 
-  sendData(data: T): void {
-    this.#callback(data);
+  /**
+   * Wait for a specific number of subscriptions to be registered.
+   * Useful for tests that need to wait for async onMount to complete.
+   */
+  async waitForSubscriptions(count: number, timeoutMs: number = 1000): Promise<void> {
+    const start = Date.now();
+    while (this.#callbacks.size < count) {
+      if (Date.now() - start > timeoutMs) {
+        throw new Error(`Timeout waiting for ${count} subscriptions. Current: ${this.#callbacks.size}`);
+      }
+      await new Promise(resolve => setTimeout(resolve, 10));
+    }
   }
 }