Function run

test/md-test.ts:87–228

(name: string)

//

function run(name: string): void {
  const md = new MDGator();

  const raw = fs.readFileSync(path.join(__dirname, name + '.md')).toString();
  const groups = md.parse(raw);

  function runSingleTest(
    location: string, ty: TestType, meta: Metadata, 
    input: string, expected: readonly (string | RegExp)[]
  ): void {
    test(`should pass for type="${ty}" (location=${location})`, { timeout: 60000 }, async () => {
      const binary = await buildMode(ty, meta);
      await binary.check(input, expected, {
        noScan: meta.noScan === true,
      });
    });
  }

  function runTest(test: Test) {
    describe(test.name + ` at ${name}.md:${test.line + 1}`, () => {
      const location = `${name}.md:${test.line + 1}`

      let types: TestType[] = [];

      const isURL = test.values.has('url');
      const inputKey = isURL ? 'url' : 'http';

      assert(test.values.has(inputKey),
        `Missing "${inputKey}" code in md file`);
      assert.strictEqual(test.values.get(inputKey)!.length, 1,
        `Expected just one "${inputKey}" input`);

      let meta: Metadata;
      if (test.meta.has(inputKey)) {
        meta = test.meta.get(inputKey)![0]!;
      } else {
        assert(isURL, 'Missing required http metadata');
        meta = {};
      }

      if (isURL) {
        types = [ 'url' ];
      } else {
        assert(Object.prototype.hasOwnProperty.call(meta, 'type'), 'Missing required `type` metadata');

        if (meta.type) {
          if (!allowedTypes.includes(meta.type)) {
            throw new Error(`Invalid value of \`type\` metadata: "${meta.type}"`);
          }

          types.push(meta.type);
        }
      }

      assert(test.values.has('log'), 'Missing `log` code in md file');

      assert.strictEqual(test.values.get('log')!.length, 1,
        'Expected just one output');