Tests

Author: jamesgpearce

coverage.json

@@ -0,0 +1 @@
+{"tests":1372,"assertions":6851,"lines":{"total":929,"covered":929,"skipped":0,"pct":100},"statements":{"total":1013,"covered":1013,"skipped":0,"pct":100},"functions":{"total":365,"covered":365,"skipped":0,"pct":100},"branches":{"total":335,"covered":334,"skipped":0,"pct":99.7},"branchesTrue":{"total":0,"covered":0,"skipped":0,"pct":"Unknown"}}

gulpfile.mjs

@@ -1,26 +1,37 @@
+/*
+  eslint-disable
+    jest/no-identical-title,
+    jest/no-disabled-tests,
+    jest/expect-expect,
+    jest/no-export,
+    jest/no-jest-import,
+    @typescript-eslint/explicit-module-boundary-types
+*/
+
 // All other imports are lazy so that single tasks start up fast.
 import gulp from 'gulp';
 import {promises} from 'fs';
 
-const ALL_MODULES = [
-  'tinybase',
-  'ui-react',
+const TEST_MODULES = ['tinybase', 'ui-react'];
+const ALL_MODULES = TEST_MODULES.concat([
   'store',
   'checkpoints',
   'indexes',
   'metrics',
   'relationships',
   'persisters',
   'common',
-];
+]);
 const LIB_DIR = 'lib';
+const TMP_DIR = './tmp';
 
 const getPrettierConfig = async () => ({
   ...JSON.parse(await promises.readFile('.prettierrc', 'utf-8')),
   parser: 'typescript',
 });
 
 const allOf = async (array, cb) => await Promise.all(array.map(cb));
+const testModules = async (cb) => await allOf(TEST_MODULES, cb);
 const allModules = async (cb) => await allOf(ALL_MODULES, cb);
 
 const makeDir = async (dir) => {
@@ -197,6 +208,61 @@ const compileModule = async (module, debug, dir = LIB_DIR, format = 'es') => {
   await (await rollup(inputConfig)).write(outputConfig);
 };
 
+const test = async (dir, {coverage, countAsserts, puppeteer, serialTests}) => {
+  const {default: jest} = await import('jest');
+  await makeDir(TMP_DIR);
+  const {
+    results: {success},
+  } = await jest.runCLI(
+    {
+      roots: [dir],
+      ...(puppeteer
+        ? {
+            setupFilesAfterEnv: ['expect-puppeteer'],
+            preset: 'jest-puppeteer',
+            detectOpenHandles: true,
+          }
+        : {testEnvironment: 'jsdom'}),
+      ...(coverage
+        ? {
+            collectCoverage: true,
+            coverageProvider: 'babel',
+            collectCoverageFrom: [`${LIB_DIR}/debug/tinybase.js`],
+            coverageReporters: ['text-summary', 'json-summary'],
+            coverageDirectory: 'tmp',
+          }
+        : {}),
+      ...(countAsserts
+        ? {
+            setupFilesAfterEnv: ['./test/jest/setup'],
+            reporters: ['default', './test/jest/reporter'],
+            testEnvironment: './test/jest/environment',
+            runInBand: true,
+          }
+        : {}),
+      ...(serialTests ? {runInBand: true} : {}),
+    },
+    [''],
+  );
+  if (!success) {
+    throw 'Test failed';
+  }
+  if (coverage) {
+    await promises.writeFile(
+      'coverage.json',
+      JSON.stringify({
+        ...(countAsserts
+          ? JSON.parse(await promises.readFile('./tmp/assertion-summary.json'))
+          : {}),
+        ...JSON.parse(await promises.readFile('./tmp/coverage-summary.json'))
+          .total,
+      }),
+      'utf-8',
+    );
+  }
+  await removeDir(TMP_DIR);
+};
+
 const npmInstall = async () => {
   const {exec} = await import('child_process');
   const {promisify} = await import('util');
@@ -216,14 +282,23 @@ export const lint = async () => await lintCheck('.');
 export const spell = async () => {
   await spellCheck('.');
   await spellCheck('src', true);
+  await spellCheck('test', true);
 };
 
 export const ts = async () => {
   await copyDefinitions();
   await tsCheck('src');
   await copyDefinitions(`${LIB_DIR}/debug`);
+  await tsCheck('test');
 };
 
+export const compileForTest = async () => {
+  await clearDir(LIB_DIR);
+  await testModules(async (module) => {
+    await compileModule(module, true, `${LIB_DIR}/debug`);
+  });
+  await copyDefinitions(`${LIB_DIR}/debug`);
+};
 export const compileForProd = async () => {
   await clearDir(LIB_DIR);
   await allModules(async (module) => {
@@ -235,13 +310,36 @@ export const compileForProd = async () => {
   await copyDefinitions(`${LIB_DIR}/debug`);
 };
 
-export const preCommit = gulp.series(lint, spell, ts, compileForProd);
+export const testUnit = async () => {
+  await test('test/unit', {coverage: true});
+};
+export const testUnitCountAsserts = async () => {
+  await test('test/unit', {coverage: true, countAsserts: true});
+};
+export const compileAndTestUnit = gulp.series(compileForTest, testUnit);
+
+export const testPerf = async () => {
+  await test('test/perf', {serialTests: true});
+};
+export const compileAndTestPerf = gulp.series(compileForTest, testPerf);
+
+export const preCommit = gulp.series(
+  lint,
+  spell,
+  ts,
+  compileForTest,
+  testUnit,
+  compileForProd,
+);
 
 export const prePublishPackage = gulp.series(
   npmInstall,
   lint,
   spell,
   ts,
+  compileForTest,
+  testUnitCountAsserts,
+  testPerf,
   compileForProd,
 );
 

jest.config.js

@@ -0,0 +1,3 @@
+export default {
+  verbose: false,
+};

package.json

@@ -29,6 +29,12 @@
     "lint": "gulp lint",
     "spell": "gulp spell",
     "ts": "gulp ts",
+    "test": "gulp --series testUnit testPerf",
+    "compileForTest": "gulp compileForTest",
+    "compileForProd": "gulp compileForProd",
+    "testUnit": "gulp testUnit",
+    "testUnitCountAsserts": "gulp testUnitCountAsserts",
+    "testPerf": "gulp testPerf",
     "compileAndTestUnit": "gulp compileAndTestUnit",
     "preCommit": "gulp preCommit",
     "prePublishPackage": "gulp prePublishPackage",

test/jest/environment.js

@@ -0,0 +1,10 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+import JsDomEnvironment from 'jest-environment-jsdom';
+
+export default class extends JsDomEnvironment {
+  static assertionCalls = 0;
+  async setup() {
+    this.global.env = this.constructor;
+    await super.setup();
+  }
+}

test/jest/reporter.js

@@ -0,0 +1,17 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+import env from './environment.js';
+import {writeFileSync} from 'fs';
+
+export default class {
+  onRunComplete(_contexts, results) {
+    writeFileSync(
+      './tmp/assertion-summary.json',
+      JSON.stringify({
+        tests: results.numTotalTests,
+        assertions: env.assertionCalls,
+      }),
+      'utf-8',
+    );
+    console.log('Assertions: ', env.assertionCalls, '\n');
+  }
+}

test/jest/setup.js

@@ -0,0 +1,3 @@
+afterEach(
+  () => (global.env.assertionCalls += expect.getState().assertionCalls),
+);

test/perf/benchmark.test.ts

@@ -0,0 +1,44 @@
+import {Schema, createStore} from '../../lib/debug/tinybase';
+import {µs} from './common';
+
+const SIZE = 50;
+
+test(`${Math.pow(SIZE, 3)} cells benchmark`, () => {
+  const schema: Schema = {};
+  for (let tableId = 0; tableId <= SIZE; tableId++) {
+    schema[tableId] = {};
+    for (let cellId = 0; cellId <= SIZE; cellId++) {
+      schema[tableId][cellId] = {type: 'number', default: -1};
+    }
+  }
+
+  const store2 = createStore();
+  let cells2 = 0;
+  store2.addCellListener(null, null, null, () => cells2++);
+  const time2 = µs(() => {
+    for (let tableId = 1; tableId <= SIZE; tableId++) {
+      for (let rowId = 1; rowId <= SIZE; rowId++) {
+        for (let cellId = 1; cellId <= SIZE; cellId++) {
+          store2.setPartialRow(tableId + '', rowId + '', {[cellId + '']: 2});
+        }
+      }
+    }
+  });
+  console.log(`${cells2} cells changed in ${Math.round(time2 / 10000) / 100}s`);
+
+  const store = createStore();
+  let cells = 0;
+  store.addCellListener(null, null, null, () => cells++);
+  const time = µs(() => {
+    for (let tableId = 1; tableId <= SIZE; tableId++) {
+      for (let rowId = 1; rowId <= SIZE; rowId++) {
+        for (let cellId = 1; cellId <= SIZE; cellId++) {
+          store.setCell(tableId + '', rowId + '', cellId + '', 2);
+        }
+      }
+    }
+  });
+  console.log(`${cells} cells changed in ${Math.round(time / 10000) / 100}s`);
+
+  expect(1).toEqual(1);
+});

test/perf/common.ts

@@ -0,0 +1,120 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment, jest/no-export */
+import {Row, Table, Tables} from '../../lib/debug/tinybase';
+import {blue, plot, red, yellow} from 'asciichart';
+import {performance} from 'perf_hooks';
+
+export const repeat = (
+  name: string,
+  noun: string,
+  unit: string,
+  actions: (N: number, stepSize: number) => [number, number],
+  maxResult: number,
+  before?: () => void,
+  maxN?: number,
+  steps?: number,
+): void => {
+  test(`${name}`, () => {
+    if (before != null) {
+      before();
+    }
+
+    if (maxN == null) {
+      maxN = 10000;
+    }
+
+    if (steps == null) {
+      steps = 40;
+    }
+
+    const stepSize = maxN / steps;
+    const runs = [];
+    for (let N = stepSize; N <= maxN; N += stepSize) {
+      runs.push(N);
+    }
+
+    let totalDuration = 0;
+    let totalCount = 0;
+
+    const results = runs.map((N) => {
+      const [duration, count] = actions(N, stepSize);
+      totalDuration += duration;
+      totalCount += count;
+      return parseFloat((duration / count).toFixed(2));
+    });
+
+    const average = parseFloat((totalDuration / totalCount).toFixed(2));
+    const averages = new Array(steps).fill(average);
+    const maxes = new Array(steps).fill(maxResult);
+
+    console.log(
+      `${name} with multiple ${noun}, ${unit}\n` +
+        `First: ${results[0]} ${unit}\n` +
+        ` Last: ${results[results.length - 1]} ${unit}\n` +
+        `  Min: ${Math.min(...results)} ${unit}\n` +
+        `  Max: ${Math.max(...results)} ${unit}\n` +
+        `  Avg: ${average} ${unit}\n\n` +
+        // @ts-ignore
+        `${plot([maxes, averages, results], {
+          height: 15,
+          min: 0,
+          max: maxResult,
+          colors: [red, blue, yellow],
+        })}\n`,
+    );
+
+    expect(average).toBeLessThan(maxResult);
+  });
+};
+
+export const repeatRows = (
+  name: string,
+  actions: (n: number) => void,
+  maxResult: number,
+  before?: () => void,
+): void => {
+  repeat(
+    name,
+    'row count',
+    'µs per row',
+    (N, stepSize) => [
+      µs(() => {
+        for (let n = N - stepSize; n <= N; n++) {
+          actions(n);
+        }
+      }),
+      stepSize,
+    ],
+    maxResult,
+    before,
+  );
+};
+
+export const µs = (actions: () => void): number => {
+  const start = performance.now();
+  actions();
+  return 1000 * (performance.now() - start);
+};
+
+export const getNTables = (N: number): Tables => {
+  const tables: Tables = {};
+  for (let n = 1; n <= N; n++) {
+    tables['table' + n] = {row: {cell: n}};
+  }
+  return tables;
+};
+
+export const getNRows = (N: number): Table => {
+  const table: Table = {};
+  for (let n = 1; n <= N; n++) {
+    table['row' + n] = {cell: n};
+  }
+  return table;
+};
+
+export const getNCells = (N: number): Row => {
+  const row: Row = {};
+  for (let n = 1; n <= N; n++) {
+    row['cell' + n] = n;
+  }
+  return row;
+};