test(panel): fixed outdated live console utils test

Author: tabarra

panel/src/pages/LiveConsole/liveConsoleUtils.test.ts

@@ -1,13 +1,15 @@
 import { afterAll, beforeAll, expect, it, suite, vi } from "vitest";
 import { filterTermLine, formatTermTimestamp, sanitizeTermLine } from "./liveConsoleUtils";
+import type { TimestampMode } from "./xtermOptions";
 
-suite.skip('filterTermLine', () => {
+suite('filterTermLine', () => {
     // Mocking the global window object for the test environment
     beforeAll(() => vi.stubGlobal('window', { txBrowserHour12: false }));
     afterAll(() => vi.unstubAllGlobals());
 
-    const fnc: typeof filterTermLine = (input, copyTimestamp, copyTag) => filterTermLine(sanitizeTermLine(input), copyTimestamp, copyTag);
-    const baseOpts = {}; //FIXME: this entire thing changed
+    // Wrapper that sanitizes input before filtering (simulating real usage)
+    const fnc = (input: string, copyTimestamp: boolean, copyTag: boolean) =>
+        filterTermLine(sanitizeTermLine(input), copyTimestamp, copyTag);
 
     const exampleLines = {
         empty: '',
@@ -21,91 +23,87 @@ suite.skip('filterTermLine', () => {
 
     suite('timestamp formats', () => {
         it('should handle 24-hour format when timestampForceHour12 is false', () => {
-            const opts = { ...baseOpts, timestampForceHour12: false };
+            const tsMode: TimestampMode = 'FORCE24H';
             const ts = 14 * 3600; // 14:00:00
-            const input = formatTermTimestamp(ts, opts) + exampleLines.normal;
-            expect(fnc(input, opts)).toEqual(sanitizeTermLine(input));
+            const input = formatTermTimestamp(ts, tsMode) + exampleLines.normal;
+            expect(fnc(input, true, true)).toEqual(sanitizeTermLine(input));
         });
 
         it('should handle 12-hour format when timestampForceHour12 is true', () => {
-            const opts = { ...baseOpts, timestampForceHour12: true };
+            const tsMode: TimestampMode = 'FORCE12H';
             const ts = 14 * 3600; // 2:00:00 PM
-            const input = formatTermTimestamp(ts, opts) + exampleLines.normal;
-            expect(fnc(input, opts)).toEqual(sanitizeTermLine(input));
+            const input = formatTermTimestamp(ts, tsMode) + exampleLines.normal;
+            expect(fnc(input, true, true)).toEqual(sanitizeTermLine(input));
         });
     });
 
     suite('copyTimestamp and copyTag options', () => {
         it('should return full line when copyTimestamp and copyTag are true', () => {
-            const opts = { ...baseOpts, copyTimestamp: true, copyTag: true };
-            const ts = 10 * 3600; // 10:00:00 AM
-            const input = formatTermTimestamp(ts, opts) + exampleLines.input;
-            expect(fnc(input, opts)).toEqual(sanitizeTermLine(input)); // Corrected expectation
+            const tsMode: TimestampMode = 'FORCE24H';
+            const ts = 10 * 3600; // 10:00:00
+            const input = formatTermTimestamp(ts, tsMode) + exampleLines.input;
+            expect(fnc(input, true, true)).toEqual(sanitizeTermLine(input));
         });
 
         it('should remove timestamp when copyTimestamp is false', () => {
-            const opts = { ...baseOpts, copyTimestamp: false, copyTag: true };
-            const ts = 10 * 3600; // 10:00:00 AM
-            const input = formatTermTimestamp(ts, baseOpts) + exampleLines.input;
+            const tsMode: TimestampMode = 'FORCE24H';
+            const ts = 10 * 3600; // 10:00:00
+            const input = formatTermTimestamp(ts, tsMode) + exampleLines.input;
             const expected = exampleLines.input.trimEnd();
-            expect(fnc(input, opts)).toEqual(expected); // Corrected expectation
+            expect(fnc(input, false, true)).toEqual(expected);
         });
 
         it('should remove tag when copyTag is false', () => {
-            const opts = { ...baseOpts, copyTimestamp: true, copyTag: false };
+            const tsMode: TimestampMode = 'FORCE24H';
             const ts = 0;
-            const input = formatTermTimestamp(ts, opts) + exampleLines.input;
-            const timestamp = formatTermTimestamp(ts, opts);
+            const input = formatTermTimestamp(ts, tsMode) + exampleLines.input;
+            const timestamp = sanitizeTermLine(formatTermTimestamp(ts, tsMode));
             const expected = timestamp + 'dd';
-            expect(fnc(input, opts)).toEqual(sanitizeTermLine(expected));
+            expect(fnc(input, true, false)).toEqual(expected);
         });
 
         it('should remove both timestamp and tag when both copyTimestamp and copyTag are false', () => {
-            const opts = { ...baseOpts, copyTimestamp: false, copyTag: false };
+            const tsMode: TimestampMode = 'FORCE24H';
             const ts = 0;
             const content = 'whatever';
-            const input = formatTermTimestamp(ts, baseOpts) + content;
-            expect(fnc(input, opts)).toEqual(content);
+            const input = formatTermTimestamp(ts, tsMode) + content;
+            expect(fnc(input, false, false)).toEqual(content);
         });
     });
 
     suite('handling empty and various lines', () => {
         it('should handle empty line', () => {
-            const opts = { ...baseOpts };
-            const input = '';
-            expect(fnc(input, opts)).toEqual('');
+            expect(fnc('', true, true)).toEqual('');
         });
 
         it('should handle line without timestamp', () => {
-            const opts = { ...baseOpts };
             const input = exampleLines.normal;
-            expect(fnc(input, opts)).toEqual(exampleLines.normal);
+            expect(fnc(input, true, true)).toEqual(exampleLines.normal);
         });
     });
 
     suite('AM/PM formatting', () => {
         it('should correctly filter AM time when copyTimestamp is true', () => {
-            const opts = { ...baseOpts, timestampForceHour12: true, copyTimestamp: true, copyTag: true };
+            const tsMode: TimestampMode = 'FORCE12H';
             const ts = 5 * 3600; // 5:00:00 AM
-            const input = formatTermTimestamp(ts, opts) + exampleLines.normal;
-            expect(fnc(input, opts)).toEqual(sanitizeTermLine(input)); // Ensures full line is returned
+            const input = formatTermTimestamp(ts, tsMode) + exampleLines.normal;
+            expect(fnc(input, true, true)).toEqual(sanitizeTermLine(input));
         });
 
         it('should correctly filter PM time when copyTimestamp is false', () => {
-            const opts = { ...baseOpts, timestampForceHour12: true, copyTimestamp: false, copyTag: true };
+            const tsMode: TimestampMode = 'FORCE12H';
             const ts = 17 * 3600; // 5:00:00 PM
-            const input = formatTermTimestamp(ts, opts) + exampleLines.normal;
+            const input = formatTermTimestamp(ts, tsMode) + exampleLines.normal;
             const expected = exampleLines.normal;
-            expect(fnc(input, opts)).toEqual(expected); // Ensures timestamp is removed
+            expect(fnc(input, false, true)).toEqual(expected);
         });
     });
 
     suite('comprehensive example tests', () => {
-        it('should handle all example lines with base options', () => {
-            const opts = { ...baseOpts };
-            for (const [key, input] of Object.entries(exampleLines)) {
+        it('should handle all example lines with base options (copyTimestamp: true, copyTag: true)', () => {
+            for (const [_key, input] of Object.entries(exampleLines)) {
                 const sanitized = sanitizeTermLine(input);
-                expect(fnc(input, opts)).toEqual(sanitized);
+                expect(fnc(input, true, true)).toEqual(sanitized);
             }
         });
     });