file-client.test.ts

import fs from 'fs';

import {
    compareResults,
    prepareResultsDirectory,
    writeComparisonResults,
    RESULTS_LOCATION,
    RESULTS_COMPARE_DIR,
    RESULTS_COMPARISON_CACHE_LOCATION,
    CACHE_LOCATION,
} from '@file-client';
import {
    Result,
    RESULT_PARSER_TO_COMPARE_TEMPLATE,
} from '@file-client/result-templates';
import { removeDirectorySync } from '@file-client/file-utils';
import { mockConfig } from '__mocks__/@config';
import { getComparisonResults } from '../utils';

jest.unmock('@file-client');

const MOCK_RESULT_FILES = ['mock-result-one.md', 'mock-result-two.md'];
const MOCK_COMPARISON_FILES = ['added.md', 'removed.md'];

const createResultsDirectory = () => fs.mkdirSync(RESULTS_LOCATION);
const readResultsDirectory = () => fs.readdirSync(RESULTS_LOCATION);
const resultsDirectoryExists = () => fs.existsSync(RESULTS_LOCATION);
const comparisonCacheExists = () =>
    fs.existsSync(RESULTS_COMPARISON_CACHE_LOCATION);
const createComparisonDirectory = () =>
    fs.mkdirSync(`${RESULTS_LOCATION}/${RESULTS_COMPARE_DIR}`);
const readComparisonDirectory = () =>
    fs.readdirSync(`${RESULTS_LOCATION}/${RESULTS_COMPARE_DIR}`);
const readComparisonCache = () =>
    JSON.parse(fs.readFileSync(RESULTS_COMPARISON_CACHE_LOCATION, 'utf8'));

function removeResultsDirectory(): void {
    if (resultsDirectoryExists()) {
        removeDirectorySync(RESULTS_LOCATION);
    }
}

function createResults(): void {
    removeResultsDirectory();
    createResultsDirectory();

    MOCK_RESULT_FILES.forEach(name =>
        fs.writeFileSync(`${RESULTS_LOCATION}/${name}`, 'Hello world', 'utf8')
    );
}

function createComparisonCache(...results: Result[]): void {
    removeComparisonCache();

    if (!fs.existsSync(CACHE_LOCATION)) {
        fs.mkdirSync(CACHE_LOCATION);
    }

    fs.writeFileSync(
        RESULTS_COMPARISON_CACHE_LOCATION,
        JSON.stringify(results),
        'utf8'
    );
}

function removeComparisonCache(): void {
    if (comparisonCacheExists()) {
        fs.unlinkSync(RESULTS_COMPARISON_CACHE_LOCATION);
    }
}

function generateResult(prefix = '0'): Result {
    return {
        repository: `${prefix}-repository`,
        repositoryOwner: `${prefix}-repositoryOwner`,
        rule: `${prefix}-rule`,
        message: `${prefix}-message`,
        path: `${prefix}-path`,
        link: `${prefix}-link`,
        extension: `${prefix}-extension`,
        source: `${prefix}-source`,
        error: `${prefix}-error`,
        __internalHash: `${prefix}-__internalHash` as Result['__internalHash'],
    };
}

function createComparisonResults(): void {
    removeResultsDirectory();
    createResultsDirectory();
    createComparisonDirectory();

    MOCK_COMPARISON_FILES.forEach(name =>
        fs.writeFileSync(
            `${RESULTS_LOCATION}/${RESULTS_COMPARE_DIR}/${name}`,
            'Hello world',
            'utf8'
        )
    );
}

function getCacheLocation() {
    let location = '';

    jest.resetModules();
    jest.isolateModules(() => {
        location =
            require('../../lib/file-client/file-constants').CACHE_LOCATION;
    });

    return location;
}

describe('file-client', () => {
    describe('prepareResultsDirectory', () => {
        afterEach(() => {
            removeResultsDirectory();
        });

        test('creates results directory when previous does not exist', () => {
            removeResultsDirectory();

            prepareResultsDirectory();

            expect(resultsDirectoryExists()).toBe(true);
        });

        test('empties results directory when previous exists', () => {
            createResults();
            const filesBefore = readResultsDirectory();

            prepareResultsDirectory();
            const filesAfter = readResultsDirectory();

            expect(filesAfter).not.toHaveLength(filesBefore.length);
            // Only comparison directory should exist
            expect(readResultsDirectory()).toHaveLength(1);
        });

        test('creates empty comparison directory when previous does not exist', () => {
            removeResultsDirectory();

            prepareResultsDirectory();

            expect(readResultsDirectory()).toEqual([RESULTS_COMPARE_DIR]);
        });

        test('empties comparison directory when previous exists', () => {
            createComparisonResults();

            prepareResultsDirectory();

            expect(readComparisonDirectory()).toHaveLength(0);
        });

        test.todo('does not remove results if called from worker thread');
    });

    describe('compareResults', () => {
        test('marks new results as "added"', async () => {
            const one = generateResult('1');
            const two = generateResult('2');
            const three = generateResult('3');
            createComparisonCache(three);

            const results = await compareResults([one, two, three]);

            expect(results.added).toEqual([one, two]);
            expect(results.removed).toHaveLength(0);
        });

        test('marks disappeared results as "removed"', async () => {
            const one = generateResult('1');
            const two = generateResult('2');
            const three = generateResult('3');
            createComparisonCache(one, two, three);

            const results = await compareResults([three]);

            expect(results.removed).toEqual([one, two]);
            expect(results.added).toHaveLength(0);
        });

        test('identifies changes in result.__internalHash', async () => {
            const result = generateResult();
            createComparisonCache({ ...result, __internalHash: '1' as any });

            const results = await compareResults([
                { ...result, __internalHash: '2' as any },
            ]);

            expect(results.added).toEqual([{ ...result, __internalHash: '2' }]);
        });

        test('marks all results as "added" when previous results are not found', async () => {
            removeComparisonCache();

            const one = generateResult('1');
            const two = generateResult('2');
            const results = await compareResults([one, two]);

            expect(results.added).toEqual([one, two]);
            expect(results.removed).toHaveLength(0);
        });
    });

    describe('writeComparisonResults', () => {
        test('writes comparison results to file system', async () => {
            const template = RESULT_PARSER_TO_COMPARE_TEMPLATE.markdown;

            const results = [generateResult('1'), generateResult('2')];
            const comparisonResults = {
                added: [generateResult('3')],
                removed: [generateResult('4')],
            };

            await writeComparisonResults(comparisonResults, results);
            const { added, removed } = getComparisonResults();

            expect(added).toBe(
                `${template.header('added')}\n${comparisonResults.added
                    .map(template.results)
                    .join('\n')}`
            );
            expect(removed).toBe(
                `${template.header('removed')}\n${comparisonResults.removed
                    .map(template.results)
                    .join('\n')}`
            );
        });

        test('updates comparison cache on file system when updateComparisonReference is enabled', async () => {
            mockConfig.mockReturnValue({ updateComparisonReference: true });
            removeComparisonCache();
            const results = [generateResult('1'), generateResult('2')];

            await writeComparisonResults({ added: [], removed: [] }, results);

            expect(comparisonCacheExists()).toBe(true);
            expect(readComparisonCache()).toEqual(results);
        });

        test('does not update comparison cache when updateComparisonReference is disabled', async () => {
            mockConfig.mockReturnValue({ updateComparisonReference: false });
            removeComparisonCache();
            const results = [generateResult('1'), generateResult('2')];

            await writeComparisonResults({ added: [], removed: [] }, results);

            expect(comparisonCacheExists()).toBe(false);
        });

        test('does not crash if results compare location is not found', async () => {
            removeResultsDirectory();

            await writeComparisonResults({ added: [], removed: [] }, [
                generateResult(),
            ]);
        });
    });

    describe('CACHE_LOCATION', () => {
        test('is initialized under package in node_modules', () => {
            jest.mock('fs', () => ({ existsSync: () => true }));

            expect(getCacheLocation()).toBe(
                './node_modules/eslint-remote-tester/.cache-eslint-remote-tester'
            );
        });

        test('is initialized under node_modules when package is not installed', () => {
            jest.mock('fs', () => ({
                existsSync: (path: string) =>
                    path !== './node_modules/eslint-remote-tester',
            }));

            expect(getCacheLocation()).toBe(
                './node_modules/.cache-eslint-remote-tester'
            );
        });

        test('is initialized in root when node_modules is not available', () => {
            jest.mock('fs', () => ({ existsSync: () => false }));

            expect(getCacheLocation()).toBe('./.cache-eslint-remote-tester');
        });
    });
});