lazyFileLoad.test.ts

Go to the documentation of this file.

 
import * as assert from 'assert';
import * as fs from 'fs/promises';
import * as path from 'path';
import { LazyFileLoader } from '../modules/lazyFileLoad';
 
// Test interfaces for type safety
interface TestConfig {
    name: string;
    value: number;
    enabled: boolean;
}
 
interface ComplexTestData {
    metadata: {
        version: string;
        author: string;
    };
    items: string[];
}
 
suite('LazyFileLoader Test Suite', function () {
    let loader: LazyFileLoader<TestConfig>;
    let tempDir: string;
    let testFilePath: string;
 
    setup(async () => {
        loader = new LazyFileLoader<TestConfig>();
 
        // Create temporary directory for test files
        tempDir = await fs.mkdtemp(path.join(__dirname, 'temp-lazyloader-'));
        testFilePath = path.join(tempDir, 'test-config.json');
    });
 
    teardown(async () => {
        // Clean up temporary files and directory
        try {
            await fs.rm(tempDir, { recursive: true, force: true });
        } catch (error) {
            // Ignore cleanup errors in tests
        }
    });
 
    suite('Basic File Loading', () => {
        test('should load and parse JSON file correctly', async () => {
            const testData: TestConfig = { name: 'test', value: 42, enabled: true };
            await fs.writeFile(testFilePath, JSON.stringify(testData));
 
            await loader.updateFilePath(testFilePath);
            const result = await loader.get();
 
            assert.strictEqual(result?.name, 'test');
            assert.strictEqual(result?.value, 42);
            assert.strictEqual(result?.enabled, true);
        });
 
        test('should load plain text file as string', async () => {
            const loader = new LazyFileLoader<string>();
            const textFile = path.join(tempDir, 'test.txt');
            const testContent = 'Hello, World!\nThis is a test file.';
 
            await fs.writeFile(textFile, testContent);
            await loader.updateFilePath(textFile);
 
            const result = await loader.get();
            assert.strictEqual(result, testContent);
        });
 
        test('should handle empty JSON file', async () => {
            await fs.writeFile(testFilePath, '{}');
            await loader.updateFilePath(testFilePath);
 
            const result = await loader.get();
            assert.strictEqual(typeof result, 'object');
            assert.strictEqual(Object.keys(result || {}).length, 0);
        });
    });
 
    suite('Caching Behavior', () => {
        test('should cache loaded content and not reload on subsequent calls', async () => {
            const testData: TestConfig = { name: 'cached', value: 100, enabled: false };
            await fs.writeFile(testFilePath, JSON.stringify(testData));
            await loader.updateFilePath(testFilePath);
 
            // First load
            const result1 = await loader.get();
 
            // Modify file content after first load
            const modifiedData: TestConfig = { name: 'modified', value: 200, enabled: true };
            await fs.writeFile(testFilePath, JSON.stringify(modifiedData));
 
            // Second load should return cached content
            const result2 = await loader.get();
 
            assert.strictEqual(result1?.name, result2?.name);
            assert.strictEqual(result1?.value, result2?.value);
            assert.strictEqual(result2?.name, 'cached'); // Should be original, not modified
        });
 
        test('should reload content after calling reload()', async () => {
            const initialData: TestConfig = { name: 'initial', value: 1, enabled: true };
            await fs.writeFile(testFilePath, JSON.stringify(initialData));
            await loader.updateFilePath(testFilePath);
 
            // First load
            const result1 = await loader.get();
            assert.strictEqual(result1?.name, 'initial');
 
            // Modify file and reload
            const updatedData: TestConfig = { name: 'updated', value: 2, enabled: false };
            await fs.writeFile(testFilePath, JSON.stringify(updatedData));
 
            const result2 = await loader.reload();
            assert.strictEqual(result2?.name, 'updated');
            assert.strictEqual(result2?.value, 2);
        });
 
        test('should clear cache with unload()', async () => {
            const testData: TestConfig = { name: 'test', value: 42, enabled: true };
            await fs.writeFile(testFilePath, JSON.stringify(testData));
            await loader.updateFilePath(testFilePath);
 
            // Load data
            const result1 = await loader.get();
            assert.ok(result1);
 
            // Unload cache
            loader.unload();
 
            // Modify file
            const newData: TestConfig = { name: 'new', value: 99, enabled: false };
            await fs.writeFile(testFilePath, JSON.stringify(newData));
 
            // Should reload from file
            const result2 = await loader.get();
            assert.strictEqual(result2?.name, 'new');
            assert.strictEqual(result2?.value, 99);
        });
    });
 
    suite('Path Resolution', () => {
        test('should handle absolute paths correctly', async () => {
            const testData: TestConfig = { name: 'absolute', value: 123, enabled: true };
            await fs.writeFile(testFilePath, JSON.stringify(testData));
 
            await loader.updateFilePath(testFilePath);
            const result = await loader.get();
 
            assert.strictEqual(result?.name, 'absolute');
        });
 
        test('should resolve relative paths with working directory', async () => {
            const testData: TestConfig = { name: 'relative', value: 456, enabled: false };
            await fs.writeFile(testFilePath, JSON.stringify(testData));
 
            await loader.updateCurrentWorkingDirectory(tempDir);
            await loader.updateFilePath('test-config.json');
 
            const result = await loader.get();
            assert.strictEqual(result?.name, 'relative');
        });
 
        test('should validate working directory exists', async () => {
            const nonExistentPath = path.join(tempDir, 'nonexistent');
            const success = await loader.updateCurrentWorkingDirectory(nonExistentPath);
            assert.strictEqual(success, false);
        });
    });
 
    suite('Error Handling', () => {
        test('should return undefined for non-existent file', async () => {
            const nonExistentPath = path.join(tempDir, 'nonexistent.json');
            await loader.updateFilePath(nonExistentPath);
 
            // 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');
        });
 
        test('should handle malformed JSON gracefully', async () => {
            const malformedJson = '{ name: "test", value: 42, invalid }';
            await fs.writeFile(testFilePath, malformedJson);
            await loader.updateFilePath(testFilePath);
 
            const result = await loader.get();
            // Should return raw content since file loaded successfully, even if JSON parsing failed
            assert.strictEqual(result, malformedJson);
        });
 
        test('should return undefined when no file path is set', async () => {
            const result = await loader.get();
            assert.strictEqual(result, undefined);
        });
    });
 
    suite('File Path Management', () => {
        test('should update file path successfully', async () => {
            const testData: TestConfig = { name: 'test', value: 42, enabled: true };
            await fs.writeFile(testFilePath, JSON.stringify(testData));
 
            const success = await loader.updateFilePath(testFilePath);
            assert.strictEqual(success, true);
 
            const retrievedPath = loader.getFilePath();
            assert.strictEqual(retrievedPath, testFilePath);
        });
 
        test('should reload content when updating file path with cached data', async () => {
            // Create first file
            const firstData: TestConfig = { name: 'first', value: 1, enabled: true };
            await fs.writeFile(testFilePath, JSON.stringify(firstData));
            await loader.updateFilePath(testFilePath);
            await loader.get(); // Load and cache
 
            // Create second file
            const secondFilePath = path.join(tempDir, 'second.json');
            const secondData: TestConfig = { name: 'second', value: 2, enabled: false };
            await fs.writeFile(secondFilePath, JSON.stringify(secondData));
 
            // Update to second file
            const success = await loader.updateFilePath(secondFilePath);
            assert.strictEqual(success, true);
 
            const result = await loader.get();
            assert.strictEqual(result?.name, 'second');
        });
 
        test('should return false when updating to invalid file with cached data', async () => {
            // Load valid file first
            const testData: TestConfig = { name: 'test', value: 42, enabled: true };
            await fs.writeFile(testFilePath, JSON.stringify(testData));
            await loader.updateFilePath(testFilePath);
            await loader.get(); // Load and cache
 
            // Try to update to non-existent file - this throws error in actual implementation
            const nonExistentPath = path.join(tempDir, 'nonexistent.json');
            try {
                const success = await loader.updateFilePath(nonExistentPath);
                assert.fail('Expected error when updating to invalid file');
            } catch (error) {
                assert.ok((error as any).code === 'ENOENT', 'Should throw ENOENT error for invalid file path');
            }
        });
    });
 
    suite('Type Safety and Complex Data', () => {
        test('should handle complex nested objects with type safety', async () => {
            const complexLoader = new LazyFileLoader<ComplexTestData>();
            const complexFile = path.join(tempDir, 'complex.json');
 
            const testData: ComplexTestData = {
                metadata: {
                    version: '1.0.0',
                    author: 'Test Author'
                },
                items: ['item1', 'item2', 'item3']
            };
 
            await fs.writeFile(complexFile, JSON.stringify(testData));
            await complexLoader.updateFilePath(complexFile);
 
            const result = await complexLoader.get();
 
            assert.ok(result);
            if (result) { // Type guard to handle possible undefined
                assert.strictEqual(result.metadata.version, '1.0.0');
                assert.strictEqual(result.metadata.author, 'Test Author');
                assert.ok(Array.isArray(result.items));
                assert.strictEqual(result.items.length, 3);
            }
        });
 
        test('should support JSONC files with comments', async () => {
            const jsoncFile = path.join(tempDir, 'config.jsonc');
            const jsoncContent = `{
                // This is a comment
                "name": "jsonc-test",
                "value": 789,
                /* Multi-line comment */
                "enabled": true
            }`;
 
            await fs.writeFile(jsoncFile, jsoncContent);
            await loader.updateFilePath(jsoncFile);
 
            const result = await loader.get();
 
            // Since we use a JSONC parser, this should successfully parse the file with comments
            assert.ok(result !== undefined, 'JSONC file should be parsed successfully');
            assert.strictEqual((result as any).name, 'jsonc-test');
            assert.strictEqual((result as any).value, 789);
            assert.strictEqual((result as any).enabled, true);
        });
    });
 
    suite('Path Utilities', () => {
        test('should check path existence correctly', async () => {
            // Test existing path
            const exists = await loader.pathExists(testFilePath);
            assert.strictEqual(exists, false); // File doesn't exist yet
 
            // Create file and test again
            await fs.writeFile(testFilePath, '{}');
            const existsAfterCreation = await loader.pathExists(testFilePath);
            assert.strictEqual(existsAfterCreation, true);
        });
 
        test('should handle directory paths in pathExists', async () => {
            const exists = await loader.pathExists(tempDir);
            assert.strictEqual(exists, true);
        });
    });
 
    suite('Edge Cases and Performance', () => {
        test('should handle large JSON files efficiently', async () => {
            const largeArray = Array.from({ length: 1000 }, (_, i) => ({
                id: i,
                name: `item-${i}`,
                value: Math.random()
            }));
 
            const largeFile = path.join(tempDir, 'large.json');
            await fs.writeFile(largeFile, JSON.stringify(largeArray));
 
            const largeLoader = new LazyFileLoader<typeof largeArray>();
            await largeLoader.updateFilePath(largeFile);
 
            const startTime = Date.now();
            const result = await largeLoader.get();
            const loadTime = Date.now() - startTime;
 
            assert.ok(result);
            assert.strictEqual(result.length, 1000);
            assert.ok(loadTime < 1000, 'Loading should complete within 1 second');
 
            // Second call should be faster due to caching
            const cachedStartTime = Date.now();
            const cachedResult = await largeLoader.get();
            const cachedLoadTime = Date.now() - cachedStartTime;
 
            // 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');
        });
 
        test('should handle empty file paths gracefully', async () => {
            const success = await loader.updateFilePath('');
            assert.strictEqual(success, true); // updateFilePath should accept any string
 
            // Empty path resolves to current directory, causing EISDIR error
            try {
                const result = await loader.get();
                assert.fail('Expected error for empty file path');
            } catch (error) {
                assert.ok((error as any).code === 'EISDIR', 'Should throw EISDIR error for directory path');
            }
        });
 
        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');
        });
 
        test('should maintain independence between loader instances', async () => {
            const loader1 = new LazyFileLoader<TestConfig>();
            const loader2 = new LazyFileLoader<TestConfig>();
 
            const file1 = path.join(tempDir, 'config1.json');
            const file2 = path.join(tempDir, 'config2.json');
 
            const data1: TestConfig = { name: 'loader1', value: 1, enabled: true };
            const data2: TestConfig = { name: 'loader2', value: 2, enabled: false };
 
            await fs.writeFile(file1, JSON.stringify(data1));
            await fs.writeFile(file2, JSON.stringify(data2));
 
            await loader1.updateFilePath(file1);
            await loader2.updateFilePath(file2);
 
            const result1 = await loader1.get();
            const result2 = await loader2.get();
 
            assert.strictEqual(result1?.name, 'loader1');
            assert.strictEqual(result2?.name, 'loader2');
            assert.notStrictEqual(result1, result2);
        });
    });
});