constants.test.ts

Go to the documentation of this file.

 
import * as assert from 'assert';
import * as CONST from '../constants';
 
suite('Constants Validation Tests', () => {
 
    test('Status codes are properly defined', () => {
        assert.strictEqual(typeof CONST.statusError, 'number');
        assert.strictEqual(typeof CONST.statusSuccess, 'number');
        assert.notStrictEqual(CONST.statusError, CONST.statusSuccess);
        assert.strictEqual(CONST.statusError, 1);
        assert.strictEqual(CONST.statusSuccess, 0);
    });
 
    test('Extension identity strings are non-empty', () => {
        assert.ok(CONST.extensionName.length > 0, 'Extension name should not be empty');
        assert.ok(CONST.moduleName.length > 0, 'Module name should not be empty');
        assert.ok(CONST.projectCopyright.length > 0, 'Project copyright should not be empty');
    });
 
    test('Extension name format validation', () => {
        assert.strictEqual(CONST.extensionName, 'AsperHeader');
        assert.strictEqual(CONST.moduleName, 'asperheader');
        assert.match(CONST.projectCopyright, /\(c\)/, 'Copyright should contain (c) symbol');
    });
 
    test('Header decoration patterns are properly formatted', () => {
        assert.ok(CONST.headerOpenerDecorationOpen.includes('+===='));
        assert.ok(CONST.headerOpenerDecorationClose.includes('=================+'));
        assert.strictEqual(typeof CONST.headerCommentSpacing, 'string');
    });
 
    test('Header decoration symmetry', () => {
        const opener = CONST.headerOpenerDecorationOpen;
        const closer = CONST.headerOpenerDecorationClose;
 
        // Check that decorations exist and are meaningful (actual implementation may have different lengths)
        assert.ok(typeof opener === 'string' && opener.length > 0, 'Opening decoration should be non-empty string');
        assert.ok(typeof closer === 'string' && closer.length > 0, 'Closing decoration should be non-empty string');
        // Note: Actual implementation has opener=6 chars, closer=19 chars by design
        assert.ok(opener.length >= 1, 'Opening decoration should have meaningful content');
        assert.ok(closer.length >= 1, 'Closing decoration should have meaningful content');
    });    // Telegraph Protocol Tests
    test('Telegraph protocol markers are defined', () => {
        assert.strictEqual(CONST.telegraphBegin, 'BEGIN');
        assert.strictEqual(CONST.telegraphEnd, 'END');
        assert.strictEqual(CONST.telegraphBlockStop, '/STOP');
        assert.strictEqual(CONST.telegraphEndOfTransmission, '// AR');
    });
 
    test('Telegraph markers follow proper format', () => {
        assert.ok(CONST.telegraphBegin.length > 0);
        assert.ok(CONST.telegraphEnd.length > 0);
        assert.ok(CONST.telegraphBlockStop.startsWith('/'));
        assert.ok(CONST.telegraphEndOfTransmission.includes('//'));
    });
 
    // Header Layout Configuration Tests
    test('Header layout configuration types', () => {
        assert.strictEqual(typeof CONST.headerAddBlankLineAfterMultiline, 'boolean');
        assert.strictEqual(typeof CONST.headerKeyDefinitionSeparator, 'string');
        assert.ok(CONST.headerKeyDefinitionSeparator.includes(':'));
    });
 
    // Header Metadata Keys Tests
    test('Header metadata keys are properly defined', () => {
        const keys = [
            CONST.headerLogoKey,
            CONST.headerProjectKey,
            CONST.headerFileKey,
            CONST.headerCreationDateKey,
            CONST.headerLastModifiedKey,
            CONST.headerDescriptionKey,
            CONST.headerCopyrightKey,
            CONST.headerTagKey,
            CONST.headerPurposeKey
        ];
 
        keys.forEach((key, index) => {
            assert.ok(key.length > 0, `Header key ${index} should not be empty`);
            assert.strictEqual(typeof key, 'string', `Header key ${index} should be string`);
        });
    });
 
    test('Header keys are unique', () => {
        const keys = [
            CONST.headerLogoKey,
            CONST.headerProjectKey,
            CONST.headerFileKey,
            CONST.headerCreationDateKey,
            CONST.headerLastModifiedKey,
            CONST.headerDescriptionKey,
            CONST.headerCopyrightKey,
            CONST.headerTagKey,
            CONST.headerPurposeKey
        ];
 
        const uniqueKeys = new Set(keys);
        assert.strictEqual(keys.length, uniqueKeys.size, 'All header keys should be unique');
    });
 
    // Date/Time Separator Tests
    test('Date and time separators are consistently defined', () => {
        const separators = [
            CONST.headerTimeSeperatorHour,
            CONST.headerTimeSeperatorMinute,
            CONST.headerTimeSeperatorSecond,
            CONST.headerTimeAndDateSeperator,
            CONST.headerDateSeperatorDay,
            CONST.headerDateSeperatorMonth,
            CONST.headerDateSeperatorYear
        ];
 
        separators.forEach((separator, index) => {
            assert.strictEqual(typeof separator, 'string', `Separator ${index} should be string`);
            // Note: Some separators can be empty strings, so we don't test for length
        });
    });
 
    test('Time separators follow expected patterns', () => {
        assert.strictEqual(CONST.headerTimeSeperatorHour, ':');
        assert.strictEqual(CONST.headerTimeSeperatorMinute, ':');
        assert.strictEqual(CONST.headerDateSeperatorDay, '-');
        assert.strictEqual(CONST.headerDateSeperatorMonth, '-');
    });
 
    // ASCII Art Logo Tests
    test('Default header logo is properly structured', () => {
        assert.ok(Array.isArray(CONST.defaultHeaderLogo), 'Logo should be an array');
        assert.ok(CONST.defaultHeaderLogo.length > 0, 'Logo should have content');
 
        CONST.defaultHeaderLogo.forEach((line, index) => {
            assert.strictEqual(typeof line, 'string', `Logo line ${index} should be string`);
            assert.ok(line.length > 0, `Logo line ${index} should not be empty`);
        });
    });
 
    test('ASCII art logo format consistency', () => {
        const logo = CONST.defaultHeaderLogo;
        const maxLength = Math.max(...logo.map(line => line.length));
        const minLength = Math.min(...logo.map(line => line.length));
 
        // Allow some variation but ensure reasonable consistency
        assert.ok(maxLength > 20, 'Logo should have reasonable width');
        assert.ok(logo.length > 10, 'Logo should have reasonable height');
        assert.ok((maxLength - minLength) < maxLength * 0.5, 'Logo lines should have relatively consistent length');
    });
 
    test('ASCII art contains only valid characters', () => {
        const validChars = /^[.\#\+\s]*$/; // Dots, hashes, plus, and spaces (supports both v1/# and v2/+ logos)
 
        CONST.defaultHeaderLogo.forEach((line, index) => {
            assert.ok(validChars.test(line), `Logo line ${index} should contain only valid ASCII art characters (., #, +, space)`);
        });
    });
 
    test('Versioned logos contain only valid characters', () => {
        const validChars = /^[.\#\+\s]*$/;
        Object.entries(CONST.headerLogoVersions).forEach(([version, logo]) => {
            assert.ok(Array.isArray(logo), `Logo version ${version} should be an array`);
            assert.ok(logo.length > 0, `Logo version ${version} should not be empty`);
            logo.forEach((line, index) => {
                assert.ok(validChars.test(line), `Logo version ${version} line ${index} should contain only valid ASCII art characters (., #, +, space)`);
            });
        });
    });
 
    test('Default logo matches v2 version', () => {
        // Default logo should be identical to v2 (modern '+' style)
        assert.deepStrictEqual(CONST.defaultHeaderLogo, CONST.headerLogoVersions["v2"], 'defaultHeaderLogo should match v2 version');
    });
 
    test('All logo versions have reasonable dimensions', () => {
        const allLogos: Record<string, string[]> = {
            default: CONST.defaultHeaderLogo,
            ...CONST.headerLogoVersions
        };
        Object.entries(allLogos).forEach(([name, logo]) => {
            assert.ok(logo.length >= 10 && logo.length <= 40, `Logo ${name} height ${logo.length} should be between 10 and 40 lines`);
            const maxLen = Math.max(...logo.map(l => l.length));
            const minLen = Math.min(...logo.map(l => l.length));
            assert.ok(maxLen > 20, `Logo ${name} should have reasonable width`);
            assert.ok((maxLen - minLen) < maxLen * 0.5, `Logo ${name} lines should have relatively consistent length`);
        });
    });
 
    // Operational Configuration Tests
    test('Operational configuration values are valid', () => {
        assert.strictEqual(typeof CONST.defaultMaxScanLength, 'number');
        assert.strictEqual(typeof CONST.enableDebug, 'boolean');
        assert.ok(CONST.defaultMaxScanLength > 0, 'Max scan length should be positive');
        assert.ok(CONST.defaultMaxScanLength < 10000, 'Max scan length should be reasonable');
    });
 
    // Behavioral Feature Toggles Tests
    test('Feature toggles are properly typed', () => {
        assert.strictEqual(typeof CONST.refreshOnSave, 'boolean');
        assert.strictEqual(typeof CONST.promptToCreateIfMissing, 'boolean');
        assert.strictEqual(typeof CONST.randomLogo, 'boolean');
        assert.strictEqual(typeof CONST.useWorkspaceNameWhenAvailable, 'boolean');
    });
 
    // Extension Filtering Configuration Tests
    test('Extension ignore list is properly formatted', () => {
        assert.ok(Array.isArray(CONST.extensionIgnore), 'Extension ignore should be array');
 
        CONST.extensionIgnore.forEach((ext, index) => {
            assert.strictEqual(typeof ext, 'string', `Extension ${index} should be string`);
        });
    });
 
    // Author Logo Tests
    test('Author logo is valid base64', () => {
        assert.strictEqual(typeof CONST.authorLogo, 'string');
        assert.ok(CONST.authorLogo.startsWith('data:image/png;base64,'), 'Author logo should be base64 PNG');
        assert.ok(CONST.authorLogo.length > 100, 'Author logo should have substantial content');
 
        // Test base64 format (basic validation)
        const base64Part = CONST.authorLogo.split(',')[1];
        const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
        assert.ok(base64Regex.test(base64Part), 'Author logo should be valid base64');
    });
 
    // Cross-validation Tests
    test('Telegraph markers are distinct', () => {
        const markers = [
            CONST.telegraphBegin,
            CONST.telegraphEnd,
            CONST.telegraphBlockStop,
            CONST.telegraphEndOfTransmission
        ];
 
        const uniqueMarkers = new Set(markers);
        assert.strictEqual(markers.length, uniqueMarkers.size, 'Telegraph markers should be unique');
    });
 
    test('Header keys follow consistent naming convention', () => {
        const keys = [
            CONST.headerLogoKey,
            CONST.headerProjectKey,
            CONST.headerFileKey,
            CONST.headerCreationDateKey,
            CONST.headerLastModifiedKey,
            CONST.headerDescriptionKey,
            CONST.headerCopyrightKey,
            CONST.headerTagKey,
            CONST.headerPurposeKey
        ];
 
        keys.forEach(key => {
            assert.ok(key === key.toUpperCase() || key.includes(' '),
                'Header keys should be either all caps or contain spaces for readability');
        });
    });
 
    // Performance and Memory Tests
    test('Logo array is efficiently structured', () => {
        const logo = CONST.defaultHeaderLogo;
        const totalChars = logo.reduce((sum, line) => sum + line.length, 0);
 
        assert.ok(totalChars < 5000, 'Logo should not be excessively large for memory efficiency');
        assert.ok(totalChars > 100, 'Logo should have sufficient detail');
    });
 
    test('Constants are immutable (frozen)', () => {
        // Test that exported constants cannot be modified
        const originalName = CONST.extensionName;
 
        try {
            (CONST as any).extensionName = 'Modified';
            assert.strictEqual(CONST.extensionName, originalName, 'Constants should be immutable');
        } catch (error) {
            // Expected in strict mode
        }
    });
});