tape-six 0.9.0

package/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2005-2022 Eugene Lazutkin
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,9 @@
+# tape6 [![NPM version][npm-img]][npm-url]
+
+[npm-img]:      https://img.shields.io/npm/v/tape6.svg
+[npm-url]:      https://npmjs.org/package/tape6
+
+tape6 is a [TAP](https://en.wikipedia.org/wiki/Test_Anything_Protocol)-based library for unit tests. It is written in modern ES6 and works in [node](https://nodejs.org/), [deno](https://deno.land/) and browsers.
+
+The documentation is TBD but you can inspect `tests/` to see how it is used.
+If you are familiar with other TAP-based libraries you'll feel right at home.

package/bin/tape6-server.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+
+import {resolveTests, resolvePatterns} from '../src/node/config.js';
+
+const fsp = fs.promises;
+
+// simple static server with no dependencies
+
+// MIME source: https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
+const mimeTable = {
+    css: 'text/css',
+    csv: 'text/csv',
+    eot: 'application/vnd.ms-fontobject',
+    gif: 'image/gif',
+    html: 'text/html',
+    ico: 'image/vnd.microsoft.icon',
+    jpg: 'image/jpeg',
+    js: 'text/javascript',
+    json: 'application/json',
+    otf: 'font/otf',
+    png: 'image/png',
+    svg: 'image/svg+xml',
+    ttf: 'font/ttf',
+    txt: 'text/plain',
+    webp: 'image/webp',
+    woff: 'font/woff',
+    woff2: 'font/woff2',
+    xml: 'application/xml'
+  },
+  defaultMime = 'application/octet-stream',
+  rootFolder = process.env.SERVER_ROOT || process.cwd(),
+  traceCalls = process.argv.includes('--trace'),
+  isTTY = process.stdout.isTTY,
+  hasColors = isTTY && process.stdout.hasColors();
+
+let webAppPath = process.env.WEBAPP_PATH;
+if (!webAppPath) {
+  const url = import.meta.url;
+  if (!/^file:\/\//i.test(url)) throw Error('Cannot identify the location of the web application. Use WEBAPP_PATH.');
+  webAppPath = path.relative(rootFolder, path.join(path.dirname(url.substr(7)), '../webApp/'));
+}
+
+// common aliases
+const mimeAliases = {mjs: 'js', cjs: 'js', htm: 'html', jpeg: 'jpg'};
+Object.keys(mimeAliases).forEach(name => (mimeTable[name] = mimeTable[mimeAliases[name]]));
+
+// colors to use
+const join = (...args) => args.map(value => value || '').join(''),
+  paint = hasColors ? (prefix, suffix = '\x1B[39m') => text => join(prefix, text, suffix) : () => text => text,
+  grey = paint('\x1B[2;37m', '\x1B[22;39m'),
+  red = paint('\x1B[41;97m', '\x1B[49;39m'),
+  green = paint('\x1B[32m'),
+  yellow = paint('\x1B[93m'),
+  blue = paint('\x1B[44;97m', '\x1B[49;39m');
+
+// sending helpers
+
+const sendFile = (req, res, fileName, ext, justHeaders) => {
+  if (!ext) {
+    ext = path.extname(fileName).toLowerCase();
+  }
+  let mime = ext && mimeTable[ext.substr(1)];
+  if (!mime || typeof mime != 'string') {
+    mime = defaultMime;
+  }
+  res.writeHead(200, {'Content-Type': mime});
+  if (justHeaders) {
+    res.end();
+  } else {
+    fs.createReadStream(fileName).pipe(res);
+  }
+  traceCalls && console.log(green('200') + ' ' + grey(req.method) + ' ' + grey(req.url));
+};
+
+const sendJson = (req, res, json, justHeaders) => {
+  res.writeHead(200, {'Content-Type': 'application/json'});
+  if (justHeaders) {
+    res.end();
+  } else {
+    res.end(JSON.stringify(json));
+  }
+  traceCalls && console.log(green('200') + ' ' + grey(req.method) + ' ' + grey(req.url));
+};
+
+const sendRedirect = (req, res, to, code = 301) => {
+  res.writeHead(code, {Location: to});
+  res.end();
+  traceCalls && console.log(blue(code) + ' ' + grey(req.method) + ' ' + grey(req.url));
+};
+
+const bailOut = (req, res, code = 404) => {
+  res.writeHead(code).end();
+  traceCalls && console.log(red(code) + ' ' + grey(req.method) + ' ' + grey(req.url));
+};
+
+// server
+
+const server = http.createServer(async (req, res) => {
+  const method = req.method.toUpperCase();
+  if (method !== 'GET' && method !== 'HEAD') return bailOut(req, res, 405);
+
+  const url = new URL(req.url, 'http://' + req.headers.host);
+  if (url.pathname === '/--tests') {
+    // get tests
+    return sendJson(req, res, await resolveTests(rootFolder, 'browser'), method === 'HEAD');
+  }
+  if (url.pathname === '/--patterns') {
+    // resolve patterns
+    return sendJson(req, res, await resolvePatterns(rootFolder, url.searchParams.getAll('q')), method === 'HEAD');
+  }
+  if (url.pathname === '/' || url.pathname === '/index' || url.pathname === '/index.html') {
+    // redirect to the web app
+    url.pathname = webAppPath;
+    return sendRedirect(req, res, url.href);
+  }
+
+  if (path.normalize(url.pathname).includes('..')) return bailOut(req, res, 403);
+
+  const fileName = path.join(rootFolder, url.pathname),
+    ext = path.extname(fileName).toLowerCase(),
+    stat = await fsp.stat(fileName).catch(() => null);
+  if (stat && stat.isFile()) return sendFile(req, res, fileName, ext, method === 'HEAD');
+
+  if (stat && stat.isDirectory()) {
+    if (fileName.length && fileName[fileName.length - 1] == path.sep) {
+      const altFile = path.join(fileName, 'index.html'),
+        stat = await fsp.stat(altFile).catch(() => null);
+      if (stat && stat.isFile()) return sendFile(req, res, altFile, '.html', method === 'HEAD');
+    } else {
+      url.pathname += path.sep;
+      return sendRedirect(req, res, url.href);
+    }
+    return bailOut(req, res);
+  }
+
+  if (!ext && fileName.length && fileName[fileName.length - 1] != path.sep) {
+    const altFile = fileName + '.html',
+      stat = await fsp.stat(altFile).catch(() => null);
+    if (stat && stat.isFile()) return sendFile(req, res, altFile, '.html', method === 'HEAD');
+  }
+
+  bailOut(req, res);
+});
+
+server.on('clientError', (err, socket) => {
+  if (err.code === 'ECONNRESET' || !socket.writable) return;
+  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
+});
+
+// general setup
+
+const normalizePort = val => {
+  const port = parseInt(val);
+  if (isNaN(port)) return val; // named pipe
+  if (port >= 0) return port; // port number
+  return false;
+};
+
+const portToString = port => (typeof port === 'string' ? 'pipe' : 'port') + ' ' + port;
+
+const host = process.env.HOST || 'localhost',
+  port = normalizePort(process.env.PORT || '3000');
+
+server.listen(port, host);
+
+server.on('error', error => {
+  if (error.syscall !== 'listen') throw error;
+  const bind = portToString(port);
+  switch (error.code) {
+    case 'EACCES':
+      console.log(red('Error: ') + yellow(bind) + red(' requires elevated privileges') + '\n');
+      process.exit(1);
+    case 'EADDRINUSE':
+      console.log(red('Error: ') + yellow(bind) + red(' is already in use') + '\n');
+      process.exit(1);
+  }
+  throw error;
+});
+
+server.on('listening', () => {
+  //const addr = server.address();
+  const bind = portToString(port);
+  console.log(
+    grey('Listening on ') +
+      yellow(host || 'all network interfaces') +
+      grey(' at ') +
+      yellow(bind) +
+      grey(', serving static files from ') +
+      yellow(rootFolder) +
+      '\n'
+  );
+});

package/bin/tape6.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+
+import cluster from 'cluster';
+import os from 'os';
+import path from 'path';
+
+import {resolveTests, resolvePatterns} from '../src/node/config.js';
+
+import {getTests, clearTests, getReporter, setReporter, runTests, setConfiguredFlag} from '../src/test.js';
+import State from '../src/State.js';
+import TapReporter from '../src/TapReporter.js';
+import TestWorker from '../src/node/TestWorker.js';
+import {selectTimer} from '../src/utils/timer.js';
+import defer from '../src/utils/defer.js';
+
+const options = {},
+  rootFolder = process.cwd();
+
+let flags = '',
+  parallel = '',
+  files = [];
+
+const masterConfiguration = () => {
+  const optionNames = {f: 'failureOnly', t: 'showTime', b: 'showBanner', d: 'showData', o: 'failOnce', n: 'showAssertNumber'};
+
+  let flagIsSet = false,
+    parIsSet = false;
+
+  for (let i = 2; i < process.argv.length; ++i) {
+    const arg = process.argv[i];
+    if (arg == '-f' || arg == '--flags') {
+      if (++i < process.argv.length) {
+        flags = process.argv[i];
+        flagIsSet = true;
+      }
+      continue;
+    } else if (arg == '-p' || arg == '--par') {
+      if (++i < process.argv.length) {
+        parallel = process.argv[i];
+        parIsSet = true;
+        if (!parallel || isNaN(parallel)) {
+          parallel = '';
+          parIsSet = false;
+        }
+      }
+      continue;
+    }
+    files.push(arg);
+  }
+
+  if (!flagIsSet) {
+    flags = process.env.TAPE6_FLAGS || flags;
+  }
+  for (let i = 0; i < flags.length; ++i) {
+    const option = flags[i].toLowerCase(),
+      name = optionNames[option];
+    if (typeof name == 'string') options[name] = option !== flags[i];
+  }
+
+  if (!parIsSet) {
+    parallel = process.env.TAPE6_PAR || parallel;
+  }
+  if (parallel) {
+    parallel = Math.max(0, +parallel);
+    if (parallel === Infinity) parallel = 0;
+  } else {
+    parallel = 0;
+  }
+  if (!parallel) parallel = os.cpus().length;
+};
+
+const masterInitialization = async () => {
+  let reporter = getReporter();
+  if (!reporter) {
+    if (process.stdout.isTTY) {
+      if (!process.env.TAPE6_TAP) {
+        const TTYReporter = (await import('../src/TTYReporter.js')).default,
+          ttyReporter = new TTYReporter(options);
+        ttyReporter.testCounter = -2;
+        ttyReporter.technicalDepth = 1;
+        reporter = ttyReporter.report.bind(ttyReporter);
+      }
+    }
+    if (!reporter) {
+      const tapReporter = new TapReporter({useJson: true});
+      reporter = tapReporter.report.bind(tapReporter);
+    }
+    setReporter(reporter);
+  }
+
+  if (files.length) {
+    files = await resolvePatterns(rootFolder, files);
+  } else {
+    files = await resolveTests(rootFolder, 'node');
+  }
+};
+
+const masterProcess = async () => {
+  masterConfiguration();
+  await masterInitialization();
+  await selectTimer();
+
+  const rootState = new State(null, {callback: getReporter(), failOnce: options.failOnce}),
+    worker = new TestWorker(event => rootState.emit(event), parallel, options);
+
+  rootState.emit({type: 'test', test: 0, time: rootState.timer.now()});
+  await new Promise(resolve => {
+    worker.done = () => resolve();
+    worker.execute(files);
+  });
+  rootState.emit({type: 'end', test: 0, time: rootState.timer.now(), fail: rootState.failed > 0, data: rootState});
+
+  process.exit(rootState.failed > 0 ? 1 : 0);
+};
+
+class BufferedReporter {
+  constructor() {
+    this.buffer = [];
+    this.inFlight = false;
+    this.shouldExit = false;
+  }
+  report(event) {
+    if (this.inFlight) {
+      this.buffer.push(event);
+      return this;
+    }
+    this.buffer.push(event);
+    return this.send();
+  }
+  send() {
+    if (!this.buffer.length) {
+      this.shouldExit && defer(() => process.exit(0));
+      return this;
+    }
+    this.inFlight = true;
+    const events = this.buffer;
+    this.buffer = [];
+    process.send({events});
+    return this;
+  }
+}
+
+const reporter = new BufferedReporter();
+
+const workerProcess = async () => {
+  setReporter(reporter.report.bind(reporter));
+
+  await new Promise((resolve, reject) => {
+    process.on('message', async ({id, fileName, options, received, done}) => {
+      reporter.inFlight = false;
+
+      if (done) return resolve();
+
+      if (received) {
+        if (reporter.buffer.length) {
+          reporter.send();
+        } else if (reporter.shouldExit) {
+          resolve();
+        }
+        return;
+      }
+
+      try {
+        await import(path.join(rootFolder, fileName));
+      } catch (error) {
+        reject(error);
+        return;
+      }
+    });
+    process.send({started: true});
+  });
+
+  if (reporter.inFlight || reporter.buffer.length) {
+    reporter.shouldExit = true;
+  } else {
+    process.exit(0);
+  }
+};
+
+const main = async () => {
+  if (cluster.isMaster) {
+    await masterProcess();
+  } else if (cluster.isWorker) {
+    await workerProcess();
+  }
+};
+main().catch(error => console.error('ERROR:', error));

package/index.js

@@ -0,0 +1,74 @@
+import {test, getTests, clearTests, getReporter, setReporter, runTests, getConfiguredFlag} from './src/test.js';
+import defer from './src/utils/defer.js';
+import State from './src/State.js';
+import TapReporter from './src/TapReporter.js';
+
+const optionNames = {f: 'failureOnly', t: 'showTime', b: 'showBanner', d: 'showData', o: 'failOnce', n: 'showAssertNumber'};
+
+defer(async () => {
+  if (getConfiguredFlag()) return; // bail out => somebody else is running the show
+
+  const isNode = typeof process == 'object' && typeof process.exit == 'function',
+    isBrowser = typeof window == 'object' && !!window.location,
+    options = {};
+
+  let flags = '';
+
+  if (isBrowser) {
+    if (typeof window.__tape6_flags == 'string') {
+      flags = window.__tape6_flags;
+    } else if (window.location.search) {
+      flags = (new URLSearchParams(window.location.search.substr(1))).get('flags') || '';
+    }
+  } else if (isNode) {
+    flags = process.env.TAPE6_FLAGS || '';
+  }
+
+  for (let i = 0; i < flags.length; ++i) {
+    const option = flags[i].toLowerCase(),
+      name = optionNames[option];
+    if (typeof name == 'string') options[name] = option !== flags[i];
+  }
+
+  let reporter = getReporter();
+  if (!reporter) {
+    if (isBrowser) {
+      const id = window.__tape6_id || (new URLSearchParams(window.location.search.substr(1))).get('id');
+      if (typeof window.__tape6_reporter == 'function') {
+        reporter = event => window.__tape6_reporter(id, event);
+      } else if (window.parent && typeof window.parent.__tape6_reporter == 'function') {
+        reporter = event => window.parent.__tape6_reporter(id, event);
+      }
+    } else if (isNode) {
+      if (process.stdout.isTTY && !process.env.TAPE6_TAP) {
+        const TTYReporter = (await import('./src/TTYReporter.js')).default,
+          ttyReporter = new TTYReporter(options);
+        reporter = ttyReporter.report.bind(ttyReporter);
+      }
+    }
+    if (!reporter) {
+      const tapReporter = new TapReporter({useJson: true});
+      reporter = tapReporter.report.bind(tapReporter);
+    }
+    setReporter(reporter);
+  }
+
+  const rootState = new State(null, {callback: reporter, failOnce: options.failOnce});
+
+  rootState.emit({type: 'test', test: 0, time: rootState.timer.now()});
+  for (;;) {
+    const tests = getTests();
+    if (!tests.length) break;
+    clearTests();
+    await runTests(rootState, tests);
+  }
+  rootState.emit({type: 'end', test: 0, time: rootState.timer.now(), fail: rootState.failed > 0, data: rootState});
+
+  if (isNode) {
+    !process.env.TAPE6_WORKER && process.exit(rootState.failed > 0 ? 1 : 0);
+  } else if (typeof __reportTape6Results == 'function') {
+    __reportTape6Results(rootState.failed > 0 ? 'failure' : 'success');
+  }
+});
+
+export default test;

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "tape-six",
+  "version": "0.9.0",
+  "description": "TAP for the modern JavaScript (ES6).",
+  "type": "module",
+  "main": "index.js",
+  "module": "index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "bin": {
+    "tape6": "bin/tape6.js",
+    "tape6-server": "bin/tape6-server.js"
+  },
+  "scripts": {
+    "start": "node bin/tape6-server.js --trace",
+    "test-chrome": "node tests/puppeteer-chrome.js",
+    "copyDeep6": "node scripts/copyFolder.js --src ./vendors/deep6/src --dst ./src/deep6 --clear",
+    "build": "npm run copyDeep6",
+    "prepublishOnly": "npm run build"
+  },
+  "github": "http://github.com/uhop/tape6",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/uhop/tape6.git"
+  },
+  "keywords": [
+    "tap",
+    "test",
+    "harness",
+    "assert",
+    "browser"
+  ],
+  "author": "Eugene Lazutkin <eugene.lazutkin@gmail.com> (https://www.lazutkin.com/)",
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/uhop/tape6/issues"
+  },
+  "homepage": "https://github.com/uhop/tape6#readme",
+  "files": [
+    "index.js",
+    "bin",
+    "web",
+    "src",
+    "cjs"
+  ],
+  "tape6": {
+    "tests": [
+      "/tests/manual/test-skip*.js",
+      "/tests/manual/test-todo.js",
+      "/tests/manual/test-three*.js"
+    ]
+  },
+  "devDependencies": {
+    "puppeteer": "^15.3.2"
+  }
+}

package/src/State.js

@@ -0,0 +1,93 @@
+import {getTimer} from './utils/timer.js';
+
+export class StopTest extends Error {}
+
+const serialize = object => {
+  if (object instanceof Error) return {type: 'Error', message: object.message, stack: object.stack};
+  if (object instanceof RegExp) return {type: 'RegExp', source: object.source, flags: object.flags};
+  try {
+    return JSON.stringify(object);
+  } catch (error) {
+    // squelch
+  }
+  try {
+    return {type: 'String', value: String(object)};
+  } catch (error) {
+    // squelch
+  }
+  return {problem: 'cannot convert value to JSON or string'};
+};
+
+class State {
+  constructor(parent, {callback, skip, todo, failOnce}) {
+    this.parent = parent;
+    parent = parent || {};
+    this.callback = callback || parent.callback;
+    this.skip = skip || parent.skip;
+    this.todo = todo || parent.todo;
+    this.failOnce = failOnce || parent.failOnce;
+    this.offset = parent.asserts || 0;
+    this.timer = parent.timer || getTimer();
+    this.asserts = this.skipped = this.failed = 0;
+    this.startTime = this.time = this.timer.now();
+  }
+
+  updateParent() {
+    if (!this.parent) return;
+    this.parent.asserts += this.asserts;
+    this.parent.skipped += this.skipped;
+    this.parent.failed += this.failed;
+  }
+
+  emit(event) {
+    event = {...event, skip: event.skip || this.skip, todo: event.todo || this.todo};
+    !event.type && (event.type = 'assert');
+
+    const isFailed = event.fail && !event.todo && !event.skip;
+
+    switch (event.type) {
+      case 'assert':
+        ++this.asserts;
+        event.skip && ++this.skipped;
+        isFailed && ++this.failed;
+        event.id = this.asserts + this.offset;
+        !event.hasOwnProperty('diffTime') && (event.diffTime = event.time - this.time);
+        break;
+      case 'end':
+        !event.hasOwnProperty('diffTime') && (event.diffTime = event.time - this.startTime);
+        break;
+    }
+
+    if (event.type === 'assert' && event.operator === 'error' && event.data && event.data.actual && typeof event.data.actual.stack == 'string') {
+      const lines = event.data.actual.stack.split('\n');
+      event.at = lines[Math.min(2, lines.length) - 1].trim().replace(/^at\s+/i, '');
+    }
+
+    if (!event.at && event.marker && typeof event.marker.stack == 'string') {
+      const lines = event.marker.stack.split('\n');
+      event.at = lines[Math.min(3, lines.length) - 1].trim().replace(/^at\s+/i, '');
+    }
+
+    if (event.type === 'assert' && event.data) {
+      event.data.hasOwnProperty('expected') && (event.expected = serialize(event.data.expected));
+      event.data.hasOwnProperty('actual') && (event.actual = serialize(event.data.actual));
+    }
+
+    this.callback(event);
+
+    switch (event.type) {
+      case 'assert':
+        if (isFailed && this.failOnce && !this.skip) {
+          for (let state = this; state; state = state.parent) state.skip = true;
+          throw new StopTest('failOnce is activated');
+        }
+        this.time = this.timer.now();
+        break;
+      case 'bail-out':
+        for (let state = this; state; state = state.parent) state.skip = true;
+        throw new StopTest('bailOut is activated');
+    }
+  }
+}
+
+export default State;