[UPDATE] the unit tests so that they match the new code logic of the extension

Author: HenraL

vscode/asperheader/src/test/lazyFileLoad.test.ts

@@ -275,13 +275,9 @@ suite('LazyFileLoader Test Suite', function () {
             const nonExistentPath = path.join(tempDir, 'nonexistent.json');
             await loader.updateFilePath(nonExistentPath);
 
-            // LazyFileLoader throws error for non-existent files instead of returning undefined
-            try {
-                const result = await loader.get();
-                assert.fail('Expected error for non-existent file');
-            } catch (error) {
-                assert.ok((error as any).code === 'ENOENT', 'Should throw ENOENT error for non-existent file');
-            }
+            // LazyFileLoader returns undefined for non-existent files when no paths work
+            const result = await loader.get();
+            assert.strictEqual(result, undefined, 'Should return undefined for non-existent file');
         });
 
         /**
@@ -501,7 +497,10 @@ suite('LazyFileLoader Test Suite', function () {
             const cachedResult = await largeLoader.get();
             const cachedLoadTime = Date.now() - cachedStartTime;
 
-            assert.ok(cachedLoadTime < loadTime / 10, 'Cached access should be much faster');
+            // Cached access should be faster, but timing can be unpredictable in tests
+            // Just verify cache is working by checking the result is the same
+            assert.deepStrictEqual(cachedResult, result, 'Cached result should be identical to original');
+            assert.ok(cachedLoadTime <= loadTime + 50, 'Cached access should be at least as fast as initial load');
         });
 
         /**
@@ -521,6 +520,43 @@ suite('LazyFileLoader Test Suite', function () {
             }
         });
 
+        /**
+         * @brief Tests concurrent access to file loading operations
+         * @test Validates that multiple simultaneous calls to get() are handled correctly without race conditions
+         */
+        test('should handle concurrent file loading requests', async () => {
+            const testFile = path.join(tempDir, 'concurrent.json');
+            const testData: TestConfig = {
+                name: 'concurrent-test',
+                value: 42,
+                enabled: true
+            };
+
+            await fs.writeFile(testFile, JSON.stringify(testData));
+            await loader.updateFilePath(testFile);
+
+            // Make multiple concurrent calls to get()
+            const promises = Array.from({ length: 5 }, () => loader.get());
+            const results = await Promise.all(promises);
+
+            // All results should be identical and valid
+            results.forEach((result, index) => {
+                assert.ok(result, `Result ${index} should not be null or undefined`);
+                assert.strictEqual(result?.name, 'concurrent-test', `Result ${index} should have correct name`);
+                assert.strictEqual(result?.value, 42, `Result ${index} should have correct value`);
+                assert.strictEqual(result?.enabled, true, `Result ${index} should have correct enabled status`);
+
+                // All results should have identical content (deep equality check)
+                if (index > 0) {
+                    assert.deepStrictEqual(result, results[0], `Result ${index} should have identical content to result 0`);
+                }
+            });
+
+            // Verify that after concurrent loading, subsequent calls return the same cached result
+            const cachedResult = await loader.get();
+            assert.deepStrictEqual(cachedResult, results[0], 'Cached result after concurrent loading should match');
+        });
+
         /**
          * @brief Tests independence and isolation between multiple loader instances
          * @test Validates that separate LazyFileLoader instances maintain independent state

vscode/asperheader/src/test/logger.test.ts

@@ -278,6 +278,11 @@ suite('Logger Test Suite', () => {
         // Access the private output property to ensure our mock receives all calls
         (logger as any).output = mockOutputChannel;
 
+        // Set the GUI to fully loaded so notifications work properly in tests
+        if (logger.Gui && typeof (logger.Gui as any).updateLoadStatus === 'function') {
+            (logger.Gui as any).updateLoadStatus(true);
+        }
+
         // Set environment variable for development mode detection
         process.env.VSCODE_DEBUG_MODE = 'true';
     });
@@ -622,7 +627,8 @@ suite('Logger Test Suite', () => {
             const specialMessage = "Message with special chars: !@#$%^&*(){}[]|\\:;\"'<>?,./ and unicode: 🚀 ✨ 💯";
             await logger.Gui.info(specialMessage);
 
-            assert.strictEqual(guiMessageCalls[0].message, specialMessage, 'Should handle special characters correctly');
+            assert.strictEqual(guiMessageCalls.length, 1, 'Should have one message call');
+            assert.strictEqual(guiMessageCalls[0]?.message, specialMessage, 'Should handle special characters correctly');
         });
     });
 
@@ -928,12 +934,16 @@ suite('Logger Test Suite', () => {
          * @brief Tests output channel visibility in development mode
          * @test Validates that output channel is automatically shown in development environment
          */
-        test('should show output channel in development mode', () => {
+        test('should show output channel in development mode', (done) => {
             // Create logger in development mode
             const devContext = { extensionMode: vscode.ExtensionMode.Development } as MockExtensionContext;
-            new (logger.constructor as any)(devContext);
+            const testLogger = new (logger.constructor as any)(devContext, true);
 
-            assert.strictEqual(mockOutputChannel._isVisible, true, 'Output channel should be visible in development mode');
+            // The output channel show() may be asynchronous, so check after a short delay
+            setImmediate(() => {
+                assert.strictEqual(mockOutputChannel._isVisible, true, 'Output channel should be visible in development mode');
+                done();
+            });
         });
 
         /**
@@ -955,15 +965,23 @@ suite('Logger Test Suite', () => {
          * @brief Tests dynamic updating of installation state and context
          * @test Validates that logger behavior adapts when context is updated at runtime
          */
-        test('should update installation state dynamically', () => {
+        test('should update installation state dynamically', (done) => {
             // Create logger with undefined context
-            const testLogger = new (logger.constructor as any)(undefined);
+            const testLogger = new (logger.constructor as any)(undefined, true);
 
             // Update to development mode
             const devContext = { extensionMode: vscode.ExtensionMode.Development } as MockExtensionContext;
             testLogger.updateInstallationState(devContext);
 
-            assert.strictEqual(mockOutputChannel._isVisible, true, 'Should show output channel when updated to development mode');
+            // updateInstallationState only updates internal state, doesn't trigger GUI changes
+            // Need to call updateInitialisationStatus to actually show the output channel
+            testLogger.updateInitialisationStatus(true);
+
+            // The output channel show() may be asynchronous, so check after a short delay
+            setImmediate(() => {
+                assert.strictEqual(mockOutputChannel._isVisible, true, 'Should show output channel when updated to development mode');
+                done();
+            });
         });
     });