fixtures-valid.js

#!/usr/bin/env node

import { readdir } from 'fs/promises';
import path from 'path';
import { styleText } from 'util';
import minimist from 'minimist';
import getAjvValidator from '../lib/ajv-validator.js';
import getAjvErrorMessages from '../lib/get-ajv-error-messages.js';
import importJson from '../lib/import-json.js';
import { checkFixture, checkUniqueness } from './fixture-valid.js';

const cliArguments = minimist(process.argv.slice(2), {
  boolean: ['h', 'a'],
  alias: { h: 'help', a: 'all-fixtures' },
});

const scriptName = import.meta.url.split('/').pop();

const helpMessage = [
  'Check validity of some/all fixtures',
  `Usage: node ${scriptName} -a | -h | fixtures [...]`,
  'Options:',
  '  fixtures: a list of fixtures contained in the fixtures/ directory.',
  '     has to resolve to the form \'manufacturer/fixture\'',
  '     depending on your shell, you can use glob-patterns to match multiple fixtures',
  '  --all-fixtures, -a:',
  '     check all fixtures contained in the fixtures/ directory',
  '  --help, -h:',
  '     Show this help message.',
].join('\n');

let fixturePaths = cliArguments._;

// print help and exit on -h or no fixtures given.
if (cliArguments.help || (fixturePaths.length === 0 && !cliArguments.a)) {
  console.log(helpMessage);
  process.exit(0);
}

/**
 * @typedef {object} UniqueValues
 * @property {Set<string>} manNames All manufacturer names
 * @property {Record<string, Set<string>>} fixKeysInMan All fixture keys by manufacturer key
 * @property {Record<string, Set<string>>} fixNamesInMan All fixture names by manufacturer key
 * @property {Record<string, Set<string>>} fixRdmIdsInMan All RDM ids by manufacturer key
 * @property {Set<string>} fixShortNames All fixture short names
 */
/** @type {UniqueValues} */
const uniqueValues = {
  manNames: new Set(),
  manRdmIds: new Set(),
  fixKeysInMan: {}, // new Set() for each manufacturer
  fixNamesInMan: {}, // new Set() for each manufacturer
  fixRdmIdsInMan: {}, // new Set() for each manufacturer
  fixShortNames: new Set(),
};

const fixtureDirectoryUrl = new URL('../fixtures/', import.meta.url);

try {
  const results = await runTests();

  let totalFails = 0;
  let totalWarnings = 0;

  // each file
  for (const result of results) {
    const isFailed = result.errors.length > 0;
    totalFails += isFailed ? 1 : 0;
    totalWarnings += result.warnings.length;

    printFileResult(result);
  }

  // newline
  console.log();

  // summary
  if (totalWarnings > 0) {
    console.log(styleText('yellow', '[INFO]'), `${totalWarnings} unresolved warning(s)`);
  }

  if (totalFails === 0) {
    console.log(styleText('green', '[PASS]'), `All ${results.length} tested files were valid.`);
    process.exit(0);
  }

  console.error(styleText('red', '[FAIL]'), `${totalFails} of ${results.length} tested files failed.`);
  process.exit(1);
}
catch (error) {
  console.error(styleText('red', '[Error]'), 'Test errored:', error);
}

/**
 * @returns {Promise<object[]>} A Promise that resolves to an array of result objects.
 */
async function runTests() {
  const promises = [];

  if (cliArguments.a) {
    const directoryEntries = await readdir(fixtureDirectoryUrl, { withFileTypes: true });
    const manufacturerKeys = directoryEntries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);

    for (const manufacturerKey of manufacturerKeys) {
      const manufacturersDirectoryUrl = new URL(manufacturerKey, fixtureDirectoryUrl);

      const manufacturerDirectoryFiles = await readdir(manufacturersDirectoryUrl);
      const manufacturerFiles = manufacturerDirectoryFiles.filter((file) => path.extname(file) === '.json');
      for (const file of manufacturerFiles) {
        const fixtureKey = path.basename(file, '.json');
        promises.push(checkFixtureFile(manufacturerKey, fixtureKey));
      }
    }
    promises.push(checkManufacturers());
  }
  else {
    // sanitize given path
    fixturePaths = fixturePaths.map((relativePath) => path.resolve(relativePath));
    for (const fixturePath of fixturePaths) {
      if (path.extname(fixturePath) !== '.json') {
        // TODO: only produce this warning at a higher verbosity level
        promises.push({
          name: fixturePath,
          errors: [],
          warnings: ['specified file is not a .json document'],
        });
        continue;
      }
      const fixtureKey = path.basename(fixturePath, '.json');
      const manufacturerKey = path.dirname(fixturePath).split(path.sep).pop();
      promises.push(checkFixtureFile(manufacturerKey, fixtureKey));
    }
  }

  return Promise.all(promises);
}

/**
 * Checks (asynchronously) the given fixture.
 * @param {string} manufacturerKey - The manufacturer key.
 * @param {string} fixtureKey - The fixture key.
 * @returns {Promise<object>} A Promise resolving to a result object.
 */
async function checkFixtureFile(manufacturerKey, fixtureKey) {
  const filename = `${manufacturerKey}/${fixtureKey}.json`;
  const result = {
    name: filename,
    errors: [],
    warnings: [],
  };

  try {
    const fixtureJson = await importJson(filename, fixtureDirectoryUrl);
    Object.assign(result, await checkFixture(manufacturerKey, fixtureKey, fixtureJson, uniqueValues));
  }
  catch (error) {
    result.errors.push(error);
  }
  return result;
}

/**
 * Checks Manufacturers file
 * @returns {Promise<object>} A Promise resolving to a result object.
 */
async function checkManufacturers() {
  const result = {
    name: 'manufacturers.json',
    errors: [],
    warnings: [],
  };

  try {
    const manufacturers = await importJson(result.name, fixtureDirectoryUrl);
    const validate = await getAjvValidator('manufacturers');
    const valid = validate(manufacturers);
    if (!valid) {
      throw getAjvErrorMessages(validate.errors, 'manufacturers');
    }

    for (const [manufacturerKey, manufacturerProperties] of Object.entries(manufacturers)) {
      if (manufacturerKey.startsWith('$')) {
        // JSON schema property
        continue;
      }

      // legacy purposes
      const uniquenessTestResults = {
        errors: [],
      };
      checkUniqueness(
        uniqueValues.manNames,
        manufacturerProperties.name,
        uniquenessTestResults,
        `Manufacturer name '${manufacturerProperties.name}' is not unique (test is not case-sensitive).`,
      );
      if ('rdmId' in manufacturerProperties) {
        checkUniqueness(
          uniqueValues.manRdmIds,
          String(manufacturerProperties.rdmId),
          uniquenessTestResults,
          `Manufacturer RDM ID '${manufacturerProperties.rdmId}' is not unique.`,
        );
      }
      result.errors.push(...uniquenessTestResults.errors);
    }
  }
  catch (error) {
    const isIterable = typeof error[Symbol.iterator] === 'function';
    result.errors.push(...(isIterable ? error : [error]));
  }
  return result;
}

/**
 * @param {object} result - The result object for a single file.
 */
function printFileResult(result) {
  const isFailed = result.errors.length > 0;

  console.log(
    isFailed ? styleText('red', '[FAIL]') : styleText('green', '[PASS]'),
    result.name,
  );

  for (const error of result.errors) {
    console.log('└', styleText('red', 'Error:'), error);
  }

  for (const warning of result.warnings) {
    console.log('└', styleText('yellow', 'Warning:'), warning);
  }
}