messageProvider.test.ts

Go to the documentation of this file.

 
import * as assert from 'assert';
import { getMessage } from '../modules/messageProvider';
import { messages } from '../modules/messageReference';
 
suite('MessageProvider Test Suite', function () {
 
    suite('Basic Message Retrieval', () => {
        test('should retrieve simple messages without parameters', () => {
            // Test messages that don't require parameters
            const refreshMessage = getMessage("fileRefreshed");
            assert.ok(typeof refreshMessage === 'string');
            assert.ok(refreshMessage.length > 0);
            assert.strictEqual(refreshMessage, "Refreshing file content.");
 
            const saveFailed = getMessage("fileSaveFailed");
            assert.ok(typeof saveFailed === 'string');
            assert.strictEqual(saveFailed, "Failed to save the file, please try saving it again.");
        });
 
        test('should handle messages with single parameters', () => {
            const testPath = '/test/path/file.json';
            const fileLoaded = getMessage("fileLoaded", testPath);
 
            assert.ok(typeof fileLoaded === 'string');
            assert.ok(fileLoaded.includes(testPath));
            assert.strictEqual(fileLoaded, `File ${testPath} loaded!`);
        });
 
        test('should handle messages with multiple parameters', () => {
            const oldPath = '/old/path';
            const newPath = '/new/path';
            const pathUpdated = getMessage("filePathUpdated", oldPath, newPath);
 
            assert.ok(typeof pathUpdated === 'string');
            assert.ok(pathUpdated.includes(oldPath));
            assert.ok(pathUpdated.includes(newPath));
            assert.strictEqual(pathUpdated, `The path has been updated from ${oldPath} to ${newPath}.`);
        });
    });
 
    suite('Parameter Substitution', () => {
        test('should handle various data types as parameters', () => {
            // String parameters
            const stringParam = getMessage("fileUnloaded", "test.json");
            assert.ok(stringParam.includes("test.json"));
 
            // Number parameters (converted to string)
            const numberParam = getMessage("fileLoaded", 12345);
            assert.ok(numberParam.includes("12345"));
 
            // Boolean parameters (converted to string)
            const booleanParam = getMessage("fileLoaded", true);
            assert.ok(booleanParam.includes("true"));
        });
 
        test('should handle undefined and null parameters gracefully', () => {
            const undefinedParam = getMessage("fileLoaded", undefined);
            assert.ok(typeof undefinedParam === 'string');
            assert.ok(undefinedParam.includes("undefined"));
 
            const nullParam = getMessage("fileLoaded", null);
            assert.ok(typeof nullParam === 'string');
            assert.ok(nullParam.includes("null"));
        });
 
        test('should handle empty string parameters', () => {
            const emptyParam = getMessage("fileLoaded", "");
            assert.ok(typeof emptyParam === 'string');
            assert.strictEqual(emptyParam, "File  loaded!");
        });
 
        test('should handle special characters in parameters', () => {
            const specialChars = '/path/with spaces & symbols!@#$%.json';
            const result = getMessage("fileLoaded", specialChars);
            assert.ok(result.includes(specialChars));
            assert.strictEqual(result, `File ${specialChars} loaded!`);
        });
    });
 
    suite('Message Reference Validation', () => {
        test('should contain all expected message keys', () => {
            const expectedKeys = [
                'fileLoaded',
                'fileParseError',
                'fileRefreshed',
                'filePathUpdated',
                'fileUnloaded',
                'fileExcludedActivationDisabled',
                'fileSaveFailed',
                'cwdUpdated',
                'cwdDoesNotExist'
            ];
 
            const englishMessages = messages.en;
            expectedKeys.forEach(key => {
                assert.ok(key in englishMessages, `Message key '${key}' should exist in English messages`);
                assert.ok(typeof englishMessages[key] === 'function', `Message '${key}' should be a function`);
            });
        });
 
        test('should have functions that return strings', () => {
            // Test function-based messages
            const englishMessages = messages.en;
            const fileLoaded = englishMessages.fileLoaded('/test/path');
            assert.strictEqual(typeof fileLoaded, 'string');
 
            const parseError = englishMessages.fileParseError('/test/file', 'syntax error');
            assert.strictEqual(typeof parseError, 'string');
 
            const cwdUpdated = englishMessages.cwdUpdated('/old', '/new');
            assert.strictEqual(typeof cwdUpdated, 'string');
        });
 
        test('should validate message function signatures', () => {
            const englishMessages = messages.en;
            // Single parameter functions
            assert.ok(englishMessages.fileLoaded.length >= 1, 'fileLoaded should accept at least 1 parameter');
            assert.ok(englishMessages.fileUnloaded.length >= 1, 'fileUnloaded should accept at least 1 parameter');
            assert.ok(englishMessages.cwdDoesNotExist.length >= 1, 'cwdDoesNotExist should accept at least 1 parameter');
 
            // Two parameter functions  
            assert.ok(englishMessages.fileParseError.length >= 2, 'fileParseError should accept at least 2 parameters');
            assert.ok(englishMessages.filePathUpdated.length >= 2, 'filePathUpdated should accept at least 2 parameters');
            assert.ok(englishMessages.cwdUpdated.length >= 2, 'cwdUpdated should accept at least 2 parameters');
 
            // Zero parameter functions
            assert.ok(englishMessages.fileRefreshed.length === 0, 'fileRefreshed should accept 0 parameters');
            assert.ok(englishMessages.fileExcludedActivationDisabled.length === 0, 'fileExcludedActivationDisabled should accept 0 parameters');
            assert.ok(englishMessages.fileSaveFailed.length === 0, 'fileSaveFailed should accept 0 parameters');
        });
    });
 
    suite('Error Handling', () => {
        test('should handle invalid message keys gracefully', () => {
            // The implementation might throw an error or return a default message
            // This test verifies the behavior is consistent
            try {
                const result = getMessage("nonExistentMessage" as any);
                // If it returns something, it should be a string
                assert.strictEqual(typeof result, 'string');
            } catch (error) {
                // If it throws, that's also acceptable behavior
                assert.ok(error instanceof Error);
            }
        });
 
        test('should handle too many parameters gracefully', () => {
            // Providing more parameters than expected should not break
            const result = getMessage("fileRefreshed", "extra", "parameters", "should", "be", "ignored");
            assert.strictEqual(typeof result, 'string');
            assert.strictEqual(result, "Refreshing file content.");
        });
 
        test('should handle too few parameters gracefully', () => {
            // This might result in undefined substitution, but should not crash
            const result = getMessage("filePathUpdated", "/only/one/param");
            assert.strictEqual(typeof result, 'string');
            assert.ok(result.includes("/only/one/param"));
        });
    });
 
    suite('Message Content Validation', () => {
        test('should have meaningful error messages', () => {
            const filePath = '/test/file.json';
            const error = 'Syntax error at line 5';
 
            const parseError = getMessage("fileParseError", filePath, error);
            assert.ok(parseError.includes(filePath), 'Parse error should include file path');
            assert.ok(parseError.includes(error), 'Parse error should include error details');
            assert.ok(parseError.toLowerCase().includes('error'), 'Parse error should mention error');
        });
 
        test('should have informative status messages', () => {
            const absolutePath = '/absolute/path/to/file.json';
            const loadedMsg = getMessage("fileLoaded", absolutePath);
 
            assert.ok(loadedMsg.includes(absolutePath), 'Loaded message should include file path');
            assert.ok(loadedMsg.toLowerCase().includes('loaded'), 'Loaded message should mention loaded');
 
            const refreshMsg = getMessage("fileRefreshed");
            assert.ok(refreshMsg.toLowerCase().includes('refresh'), 'Refresh message should mention refresh');
        });
 
        test('should have clear directory change messages', () => {
            const oldCwd = '/old/directory';
            const newCwd = '/new/directory';
 
            const cwdUpdate = getMessage("cwdUpdated", oldCwd, newCwd);
            assert.ok(cwdUpdate.includes(oldCwd), 'CWD update should include old directory');
            assert.ok(cwdUpdate.includes(newCwd), 'CWD update should include new directory');
            assert.ok(cwdUpdate.toLowerCase().includes('updated'), 'CWD update should mention update');
 
            const nonExistentPath = '/nonexistent/path';
            const cwdError = getMessage("cwdDoesNotExist", nonExistentPath);
            assert.ok(cwdError.includes(nonExistentPath), 'CWD error should include path');
        });
    });
 
    suite('Integration and Consistency', () => {
        test('should maintain consistent message formatting', () => {
            // Test that similar messages follow consistent patterns
            const loadedMsg = getMessage("fileLoaded", "/test/file");
            const unloadedMsg = getMessage("fileUnloaded", "/test/file");
 
            // Check actual message format - loaded ends with '!', unloaded may not
            assert.ok(loadedMsg.endsWith('!') || loadedMsg.endsWith('.'), 'Loaded message should end with punctuation');
            // Adjust expectation for unloaded message based on actual implementation
            assert.ok(typeof unloadedMsg === 'string' && unloadedMsg.length > 0, 'Unloaded message should be a valid string');
        });
 
        test('should handle concurrent message generation', () => {
            // Test that multiple simultaneous getMessage calls work correctly
            const promises = Array.from({ length: 100 }, (_, i) => {
                return new Promise<string>((resolve) => {
                    const message = getMessage("fileLoaded", `/test/file${i}.json`);
                    resolve(message);
                });
            });
 
            return Promise.all(promises).then(results => {
                assert.strictEqual(results.length, 100);
                results.forEach((message, index) => {
                    assert.ok(message.includes(`file${index}.json`));
                });
            });
        });
 
        test('should support message caching if implemented', () => {
            // Test repeated calls to the same message
            const message1 = getMessage("fileRefreshed");
            const message2 = getMessage("fileRefreshed");
 
            // Should return identical results
            assert.strictEqual(message1, message2);
 
            // Test with parameters
            const paramMsg1 = getMessage("fileLoaded", "/same/path");
            const paramMsg2 = getMessage("fileLoaded", "/same/path");
            assert.strictEqual(paramMsg1, paramMsg2);
        });
    });
 
    suite('Performance and Memory', () => {
        test('should handle large parameter strings efficiently', () => {
            const largePath = '/very/long/path/with/many/segments/'.repeat(100) + 'file.json';
            const startTime = Date.now();
 
            const result = getMessage("fileLoaded", largePath);
            const elapsed = Date.now() - startTime;
 
            assert.ok(elapsed < 100, 'Message generation should complete quickly even with large parameters');
            assert.ok(result.includes(largePath));
        });
 
        test('should handle rapid successive calls efficiently', () => {
            const startTime = Date.now();
 
            for (let i = 0; i < 1000; i++) {
                getMessage("fileRefreshed");
                getMessage("fileLoaded", `/test/file${i}.json`);
            }
 
            const elapsed = Date.now() - startTime;
            assert.ok(elapsed < 1000, 'Rapid message generation should complete within reasonable time');
        });
    });
});