chore(release): Version auf 1.16.0 erhöhen & Changelog aktualisieren (2025-10-20) 🚀

- test: Füge Async-File-Operations- und Cache-Configuration-Tests hinzu 🧪
- fix: Korrigiere readLargeFileAsync — sammle Chunks als strings und join statt Buffer.concat 🔧
- chore: Aktualisiere package.json Version und setze Release-Datum im CHANGELOG 📝

Author: dermatz

CHANGELOG.md

@@ -4,7 +4,7 @@ All notable changes to the "magento-log-viewer" extension will be documented in
 
 ## Next release
 
-### [1.16.0] - TBD
+### [1.16.0] - 2025-10-20
 
 - perf: Implemented dynamic cache configuration based on available system memory
 - perf: Added intelligent cache size management with automatic optimization under memory pressure
@@ -21,6 +21,8 @@ All notable changes to the "magento-log-viewer" extension will be documented in
 - fix: Improved memory usage estimation and monitoring for cached file contents
 - fix: Eliminated redundant `pathExists` function implementations across modules
 - fix: Consolidated all path existence checks to use centralized helpers functions
+- test: Added comprehensive test coverage for new cache configuration options
+- test: Added async file operations test suite with large file handling validation
 
 ---
 

package.json

@@ -2,7 +2,7 @@
   "name": "magento-log-viewer",
   "displayName": "Magento Log Viewer",
   "description": "A Visual Studio Code extension to view and manage Magento log files.",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "publisher": "MathiasElle",
   "icon": "resources/logo.png",
   "repository": {

src/helpers.ts

@@ -631,25 +631,23 @@ export async function getCachedFileContentAsync(filePath: string): Promise<strin
 // Stream-based reading for very large files
 async function readLargeFileAsync(filePath: string): Promise<string> {
   return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = [];
+    const chunks: string[] = [];
     const stream = fs.createReadStream(filePath, { encoding: 'utf8' });
 
-    stream.on('data', (chunk: Buffer) => {
+    stream.on('data', (chunk: string) => {
       chunks.push(chunk);
     });
 
     stream.on('end', () => {
-      resolve(Buffer.concat(chunks).toString('utf8'));
+      resolve(chunks.join(''));
     });
 
     stream.on('error', (error) => {
       console.error(`Error reading large file ${filePath}:`, error);
       reject(error);
     });
   });
-}
-
-// Enhanced file content caching function (synchronous - for compatibility)
+}// Enhanced file content caching function (synchronous - for compatibility)
 export function getCachedFileContent(filePath: string): string | null {
   try {
     // Check if file exists first

src/test/asyncOperations.test.ts

@@ -0,0 +1,121 @@
+import * as assert from 'assert';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { pathExists, pathExistsAsync, getCachedFileContentAsync, getCachedFileContent } from '../helpers';
+
+suite('Async File Operations Test Suite', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'magento-async-test-'));
+    let testFilePath: string;
+
+    setup(() => {
+        // Create a test file for each test
+        testFilePath = path.join(tempDir, 'async-test.log');
+        fs.writeFileSync(testFilePath, 'Test content for async operations');
+    });
+
+    teardown(() => {
+        // Clean up test file after each test
+        if (fs.existsSync(testFilePath)) {
+            fs.unlinkSync(testFilePath);
+        }
+    });
+
+    suiteTeardown(() => {
+        // Clean up temp directory
+        try {
+            if (fs.existsSync(tempDir)) {
+                const files = fs.readdirSync(tempDir);
+                files.forEach(file => {
+                    fs.unlinkSync(path.join(tempDir, file));
+                });
+                fs.rmdirSync(tempDir);
+            }
+        } catch (err) {
+            console.error('Failed to clean up test directory:', err);
+        }
+    });
+
+    test('pathExistsAsync should work correctly for existing files', async () => {
+        const exists = await pathExistsAsync(testFilePath);
+        assert.strictEqual(exists, true, 'Should return true for existing file');
+    });
+
+    test('pathExistsAsync should work correctly for non-existing files', async () => {
+        const nonExistentPath = path.join(tempDir, 'non-existent.log');
+        const exists = await pathExistsAsync(nonExistentPath);
+        assert.strictEqual(exists, false, 'Should return false for non-existing file');
+    });
+
+    test('pathExists and pathExistsAsync should return same results', async () => {
+        const syncResult = pathExists(testFilePath);
+        const asyncResult = await pathExistsAsync(testFilePath);
+        assert.strictEqual(syncResult, asyncResult, 'Sync and async should return same result');
+
+        const nonExistentPath = path.join(tempDir, 'non-existent.log');
+        const syncResultFalse = pathExists(nonExistentPath);
+        const asyncResultFalse = await pathExistsAsync(nonExistentPath);
+        assert.strictEqual(syncResultFalse, asyncResultFalse, 'Sync and async should return same result for non-existing file');
+    });
+
+    test('getCachedFileContentAsync should read file content correctly', async () => {
+        const content = await getCachedFileContentAsync(testFilePath);
+        assert.strictEqual(content, 'Test content for async operations', 'Should read file content correctly');
+    });
+
+    test('getCachedFileContentAsync should handle non-existent files gracefully', async () => {
+        const nonExistentPath = path.join(tempDir, 'non-existent.log');
+        const content = await getCachedFileContentAsync(nonExistentPath);
+        assert.strictEqual(content, null, 'Should return null for non-existent files');
+    });
+
+    test('getCachedFileContentAsync should handle large files with streaming', async () => {
+        // Create a large test file (>50MB)
+        const largeFilePath = path.join(tempDir, 'large-async-test.log');
+        const largeContent = 'x'.repeat(51 * 1024 * 1024); // 51MB of content
+
+        fs.writeFileSync(largeFilePath, largeContent);
+
+        try {
+            const content = await getCachedFileContentAsync(largeFilePath);
+            assert.strictEqual(content, largeContent, 'Should read large file content correctly using streaming');
+        } finally {
+            // Clean up large file
+            if (fs.existsSync(largeFilePath)) {
+                fs.unlinkSync(largeFilePath);
+            }
+        }
+    });
+
+    test('getCachedFileContentAsync should cache content correctly', async () => {
+        // First call - should read from file
+        const firstCall = await getCachedFileContentAsync(testFilePath);
+        assert.strictEqual(firstCall, 'Test content for async operations', 'First call should read file content');
+
+        // Second call without file modification - should return cached content
+        const secondCall = await getCachedFileContentAsync(testFilePath);
+        assert.strictEqual(secondCall, 'Test content for async operations', 'Second call should return cached content');
+    });
+
+    test('getCachedFileContentAsync performance should be reasonable', async () => {
+        const startTime = Date.now();
+
+        // Read the same file multiple times
+        for (let i = 0; i < 10; i++) {
+            await getCachedFileContentAsync(testFilePath);
+        }
+
+        const endTime = Date.now();
+        const duration = endTime - startTime;
+
+        // Should complete quickly due to caching
+        assert.ok(duration < 1000, `Multiple async reads should complete quickly, took ${duration}ms`);
+    });
+
+    test('Async and sync getCachedFileContent should return same results', async () => {
+        const syncContent = getCachedFileContent(testFilePath);
+        const asyncContent = await getCachedFileContentAsync(testFilePath);
+
+        assert.strictEqual(syncContent, asyncContent, 'Sync and async content reading should return same results');
+    });
+});

src/test/cacheConfiguration.test.ts

@@ -0,0 +1,80 @@
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+import { getCacheStatistics, clearFileContentCache, optimizeCacheSize } from '../helpers';
+
+suite('Cache Configuration Test Suite', () => {
+
+    setup(() => {
+        // Clear cache before each test
+        clearFileContentCache();
+    });
+
+    teardown(() => {
+        // Reset configuration after each test using Global target
+        const config = vscode.workspace.getConfiguration('magentoLogViewer');
+        config.update('cacheMaxFiles', undefined, vscode.ConfigurationTarget.Global);
+        config.update('cacheMaxFileSize', undefined, vscode.ConfigurationTarget.Global);
+        config.update('enableCacheStatistics', undefined, vscode.ConfigurationTarget.Global);
+        clearFileContentCache();
+    });
+
+    test('Cache should use default configuration when user settings are 0', () => {
+        const stats = getCacheStatistics();
+
+        // Should have reasonable defaults
+        assert.ok(stats.maxSize >= 20 && stats.maxSize <= 100,
+            `Max size should be between 20-100, got ${stats.maxSize}`);
+        assert.ok(stats.maxFileSize >= 1024 * 1024,
+            `Max file size should be at least 1MB, got ${stats.maxFileSize}`);
+    });
+
+    test('Cache should respect user configuration when set', async () => {
+        const config = vscode.workspace.getConfiguration('magentoLogViewer');
+
+        // Set custom values using Global configuration target since no workspace is available in tests
+        await config.update('cacheMaxFiles', 75, vscode.ConfigurationTarget.Global);
+        await config.update('cacheMaxFileSize', 8, vscode.ConfigurationTarget.Global);
+
+        // Clear cache to pick up new config
+        clearFileContentCache();
+
+        const stats = getCacheStatistics();
+        assert.strictEqual(stats.maxSize, 75, 'Should use custom max files setting');
+        assert.strictEqual(stats.maxFileSize, 8 * 1024 * 1024, 'Should use custom max file size setting');
+    });
+
+    test('Cache statistics should include memory usage information', () => {
+        const stats = getCacheStatistics();
+
+        assert.ok(typeof stats.size === 'number', 'Size should be a number');
+        assert.ok(typeof stats.maxSize === 'number', 'Max size should be a number');
+        assert.ok(typeof stats.maxFileSize === 'number', 'Max file size should be a number');
+        assert.ok(typeof stats.memoryUsage === 'string', 'Memory usage should be a string');
+        assert.ok(stats.memoryUsage.includes('MB'), 'Memory usage should include MB unit');
+    });
+
+    test('optimizeCacheSize should handle memory pressure', () => {
+        // This is hard to test without mocking process.memoryUsage()
+        // But we can at least ensure the function doesn't crash
+        assert.doesNotThrow(() => {
+            optimizeCacheSize();
+        }, 'optimizeCacheSize should not throw errors');
+    });
+
+    test('Cache configuration should have reasonable bounds', async () => {
+        const config = vscode.workspace.getConfiguration('magentoLogViewer');
+
+        // Test edge cases using Global configuration
+        await config.update('cacheMaxFiles', 1000, vscode.ConfigurationTarget.Global); // Too high
+        await config.update('cacheMaxFileSize', 200, vscode.ConfigurationTarget.Global); // Too high
+
+        clearFileContentCache();
+
+        const stats = getCacheStatistics();
+
+        // User settings override automatic limits, so we should get the user values
+        // The test should verify that the configuration accepts user values
+        assert.strictEqual(stats.maxSize, 1000, 'Should accept user setting for max files even if high');
+        assert.strictEqual(stats.maxFileSize, 200 * 1024 * 1024, 'Should accept user setting for max file size even if high');
+    });
+});