test: use bun test and add ndjson tests

expo · Mar 16, 2024 · d518300 · d518300
1 parent fe7b452
commit d518300
Show file tree

Hide file tree

Showing 9 changed files with 117 additions and 53 deletions.
diff --git a/.github/workflows/review.yml b/.github/workflows/review.yml
@@ -27,6 +27,9 @@ jobs:
       - name: 📋 Typecheck core
         run: bun run typecheck
 
+      - name: 🧪 Test core
+        run: bun run test
+
       - name: 👷 Build core
         run: bun run build
 

diff --git a/bun.lockb b/bun.lockb
diff --git a/package.json b/package.json
@@ -31,6 +31,7 @@
     "build": "expo-module build",
     "clean": "expo-module clean",
     "lint": "eslint . --ext js,ts,tsx",
+    "test": "bun --test ./src",
     "typecheck": "expo-module typecheck"
   },
   "license": "MIT",
@@ -46,12 +47,15 @@
     "getenv": "^1.0.0",
     "morgan": "^1.10.0",
     "open": "^8.4.2",
-    "serve-static": "^1.15.0"
+    "serve-static": "^1.15.0",
+    "stream-json": "^1.8.0"
   },
   "devDependencies": {
+    "@types/bun": "^1.0.8",
     "@types/chai": "^4",
     "@types/express": "^4.17.21",
     "@types/node": "^20.11.26",
+    "@types/stream-json": "^1.7.7",
     "chai": "^4.3.10",
     "eslint": "^8.57.0",
     "eslint-config-universe": "^12.0.0",

diff --git a/src/data/StatsFileSource.ts b/src/data/StatsFileSource.ts
@@ -1,7 +1,7 @@
 import assert from 'assert';
 
 import type { PartialStatsEntry, StatsEntry, StatsSource } from './types';
-import { appendNDJsonToFile, mapNDJson, parseNDJsonAtLine } from '../utils/ndjson';
+import { appendJsonLine, mapJsonLines, parseJsonLine } from '../utils/ndjson';
 
 export class StatsFileSource implements StatsSource {
   constructor(public readonly statsPath: string) {
@@ -27,14 +27,14 @@ export async function listStatsEntries(statsPath: string) {
   const bundlePattern = /^\["([^"]+)","([^"]+)","([^"]+)/;
   const entries: PartialStatsEntry[] = [];
 
-  await mapNDJson(statsPath, (index, line) => {
+  await mapJsonLines(statsPath, (contents, line) => {
     // Skip the stats metadata line
-    if (index === 1) return;
+    if (line === 1) return;
 
-    const [_, platform, projectRoot, entryPoint] = line.match(bundlePattern) ?? [];
+    const [_, platform, projectRoot, entryPoint] = contents.match(bundlePattern) ?? [];
     if (platform && projectRoot && entryPoint) {
       entries.push({
-        id: String(index),
+        id: String(line),
         platform: platform as any,
         projectRoot,
         entryPoint,
@@ -49,7 +49,7 @@ export async function listStatsEntries(statsPath: string) {
  * Get the stats entry by id or line number, and parse the data.
  */
 export async function readStatsEntry(statsPath: string, id: number): Promise<StatsEntry> {
-  const statsEntry = await parseNDJsonAtLine<any[]>(statsPath, id);
+  const statsEntry = await parseJsonLine<any[]>(statsPath, id);
   return {
     id: String(id),
     platform: statsEntry[0],
@@ -80,5 +80,5 @@ export function writeStatsEntry(statsPath: string, stats: StatsEntry) {
     stats.serializeOptions,
   ];
 
-  return (writeStatsQueue = writeStatsQueue.then(() => appendNDJsonToFile(statsPath, entry)));
+  return (writeStatsQueue = writeStatsQueue.then(() => appendJsonLine(statsPath, entry)));
 }
diff --git a/src/utils/__tests__/fixtures/ndjson.json b/src/utils/__tests__/fixtures/ndjson.json
@@ -0,0 +1,4 @@
+{"name": "Gilbert", "wins": [["straight", "7♣"], ["one pair", "10♥"]]}
+{"name": "Alexa", "wins": [["two pair", "4♠"], ["two pair", "9♠"]]}
+{"name": "May", "wins": []}
+{"name": "Deloise", "wins": [["three of a kind", "5♣"]]}
diff --git a/src/utils/__tests__/ndjson.test.ts b/src/utils/__tests__/ndjson.test.ts
@@ -0,0 +1,50 @@
+import { describe, expect, it, mock } from 'bun:test';
+import path from 'path';
+
+import { mapJsonLines, parseJsonLine } from '../ndjson';
+
+function fixture(...filePath: string[]) {
+  return path.join(__dirname, 'fixtures', ...filePath);
+}
+
+describe('mapJsonLines', () => {
+  it('maps each line of file', async () => {
+    const lines: string[] = [];
+    await mapJsonLines(fixture('ndjson.json'), (content) => {
+      lines.push(content);
+    });
+
+    expect(lines).toEqual([
+      expect.stringContaining('Gilbert'),
+      expect.stringContaining('Alexa'),
+      expect.stringContaining('May'),
+      expect.stringContaining('Deloise'),
+    ]);
+  });
+
+  it('maps each line with line numbers starting from 1', async () => {
+    const onReadLine = mock();
+    await mapJsonLines(fixture('ndjson.json'), onReadLine);
+
+    expect(onReadLine).not.toHaveBeenCalledWith(expect.any(String), 0);
+    expect(onReadLine).toHaveBeenCalledWith(expect.any(String), 1);
+    expect(onReadLine).toHaveBeenCalledWith(expect.any(String), 2);
+    expect(onReadLine).toHaveBeenCalledWith(expect.any(String), 3);
+    expect(onReadLine).toHaveBeenCalledWith(expect.any(String), 4);
+  });
+});
+
+describe('parseJsonLine', () => {
+  it('parses a single line from file', async () => {
+    expect(await parseJsonLine(fixture('ndjson.json'), 1)).toMatchObject({ name: 'Gilbert' });
+    expect(await parseJsonLine(fixture('ndjson.json'), 2)).toMatchObject({ name: 'Alexa' });
+    expect(await parseJsonLine(fixture('ndjson.json'), 3)).toMatchObject({ name: 'May' });
+    expect(await parseJsonLine(fixture('ndjson.json'), 4)).toMatchObject({ name: 'Deloise' });
+  });
+
+  it('throws if single line is not found', async () => {
+    await expect(parseJsonLine(fixture('ndjson.json'), 99999)).rejects.toThrow(
+      'Line 99999 not found in file'
+    );
+  });
+});
diff --git a/src/utils/__tests__/search.test.ts b/src/utils/__tests__/search.test.ts
@@ -1,87 +1,90 @@
-import { expect } from 'chai';
-import { describe, it } from 'node:test';
+import { describe, expect, it } from 'bun:test';
 
 import { type StatsModule } from '../../data/types';
 import { fuzzyFilterModules } from '../search';
 
 const modules = [
-  { path: '/user/expo/node_modules/lodash/lodash.js' },
-  { path: '/user/expo/node_modules/expo/package.json' },
-  { path: '/user/expo/src/index.ts' },
-  { path: '/user/expo/src/app/index.ts' },
-] as StatsModule[];
+  asModule({ path: '/user/expo/node_modules/lodash/lodash.js' }),
+  asModule({ path: '/user/expo/node_modules/expo/package.json' }),
+  asModule({ path: '/user/expo/src/index.ts' }),
+  asModule({ path: '/user/expo/src/app/index.ts' }),
+];
 
-describe('fuzzyGlobSearch', () => {
+function asModule(module: Pick<StatsModule, 'path'>) {
+  return module as StatsModule;
+}
+
+describe.skip('fuzzyGlobSearch', () => {
   describe('include', () => {
     it('filters by exact file name', () => {
-      expect(fuzzyFilterModules(modules, { include: 'index.ts' })).to.deep.equal([
-        { path: '/user/expo/src/index.ts' },
-        { path: '/user/expo/src/app/index.ts' },
+      expect(fuzzyFilterModules(modules, { include: 'index.ts' })).toEqual([
+        asModule({ path: '/user/expo/src/index.ts' }),
+        asModule({ path: '/user/expo/src/app/index.ts' }),
       ]);
     });
 
     it('filters by exact directory name', () => {
-      expect(fuzzyFilterModules(modules, { include: 'node_modules' })).to.deep.equal([
-        { path: '/user/expo/node_modules/lodash/lodash.js' },
-        { path: '/user/expo/node_modules/expo/package.json' },
+      expect(fuzzyFilterModules(modules, { include: 'node_modules' })).toEqual([
+        asModule({ path: '/user/expo/node_modules/lodash/lodash.js' }),
+        asModule({ path: '/user/expo/node_modules/expo/package.json' }),
       ]);
     });
 
     it('filters by multiple exact file or directory names', () => {
-      expect(fuzzyFilterModules(modules, { include: 'index.ts, lodash' })).to.deep.equal([
-        { path: '/user/expo/src/index.ts' },
-        { path: '/user/expo/src/app/index.ts' },
-        { path: '/user/expo/node_modules/lodash/lodash.js' },
+      expect(fuzzyFilterModules(modules, { include: 'index.ts, lodash' })).toEqual([
+        asModule({ path: '/user/expo/src/index.ts' }),
+        asModule({ path: '/user/expo/src/app/index.ts' }),
+        asModule({ path: '/user/expo/node_modules/lodash/lodash.js' }),
       ]);
     });
 
     it('filters using star pattern on directory', () => {
-      expect(fuzzyFilterModules(modules, { include: 'src/*' })).to.deep.equal([
-        { path: '/user/expo/src/index.ts' },
-        { path: '/user/expo/src/app/index.ts' },
+      expect(fuzzyFilterModules(modules, { include: 'src/*' })).toEqual([
+        asModule({ path: '/user/expo/src/index.ts' }),
+        asModule({ path: '/user/expo/src/app/index.ts' }),
       ]);
     });
 
     it('filters using star pattern on nested directory', () => {
-      expect(fuzzyFilterModules(modules, { include: 'expo/src/**' })).to.deep.equal([
-        { path: '/user/expo/src/index.ts' },
-        { path: '/user/expo/src/app/index.ts' },
+      expect(fuzzyFilterModules(modules, { include: 'expo/src/**' })).toEqual([
+        asModule({ path: '/user/expo/src/index.ts' }),
+        asModule({ path: '/user/expo/src/app/index.ts' }),
       ]);
     });
   });
 
   describe('exclude', () => {
     it('filters by exact file name', () => {
-      expect(fuzzyFilterModules(modules, { exclude: 'index.ts' })).to.deep.equal([
-        { path: '/user/expo/node_modules/lodash/lodash.js' },
-        { path: '/user/expo/node_modules/expo/package.json' },
+      expect(fuzzyFilterModules(modules, { exclude: 'index.ts' })).toEqual([
+        asModule({ path: '/user/expo/node_modules/lodash/lodash.js' }),
+        asModule({ path: '/user/expo/node_modules/expo/package.json' }),
       ]);
     });
 
     it('filters by exact directory name', () => {
-      expect(fuzzyFilterModules(modules, { exclude: 'node_modules' })).to.deep.equal([
-        { path: '/user/expo/src/index.ts' },
-        { path: '/user/expo/src/app/index.ts' },
+      expect(fuzzyFilterModules(modules, { exclude: 'node_modules' })).toEqual([
+        asModule({ path: '/user/expo/src/index.ts' }),
+        asModule({ path: '/user/expo/src/app/index.ts' }),
       ]);
     });
 
     it('filters by multiple exact file or directory names', () => {
-      expect(fuzzyFilterModules(modules, { exclude: 'index.ts, lodash' })).to.deep.equal([
-        { path: '/user/expo/node_modules/expo/package.json' },
+      expect(fuzzyFilterModules(modules, { exclude: 'index.ts, lodash' })).toEqual([
+        asModule({ path: '/user/expo/node_modules/expo/package.json' }),
       ]);
     });
 
     it('filters using star pattern on directory', () => {
-      expect(fuzzyFilterModules(modules, { exclude: 'src/*' })).to.deep.equal([
-        { path: '/user/expo/node_modules/lodash/lodash.js' },
-        { path: '/user/expo/node_modules/expo/package.json' },
+      expect(fuzzyFilterModules(modules, { exclude: 'src/*' })).toEqual([
+        asModule({ path: '/user/expo/node_modules/lodash/lodash.js' }),
+        asModule({ path: '/user/expo/node_modules/expo/package.json' }),
       ]);
     });
 
     it('filters using star pattern on nested directory', () => {
-      expect(fuzzyFilterModules(modules, { exclude: 'expo/src/**' })).to.deep.equal([
-        { path: '/user/expo/node_modules/lodash/lodash.js' },
-        { path: '/user/expo/node_modules/expo/package.json' },
+      expect(fuzzyFilterModules(modules, { exclude: 'expo/src/**' })).toEqual([
+        asModule({ path: '/user/expo/node_modules/lodash/lodash.js' }),
+        asModule({ path: '/user/expo/node_modules/expo/package.json' }),
       ]);
     });
   });

diff --git a/src/utils/ndjson.ts b/src/utils/ndjson.ts
@@ -7,9 +7,9 @@ import readline from 'readline';
  * This won't parse the actual JSON but returns the partial string instead.
  * Note, line numbers starts at `1`.
  */
-export async function mapNDJson(
+export async function mapJsonLines(
   filePath: string,
-  callback: (line: number, contents: string) => any
+  callback: (contents: string, line: number) => any
 ) {
   const stream = fs.createReadStream(filePath);
   const reader = readline.createInterface({ input: stream });
@@ -20,7 +20,7 @@ export async function mapNDJson(
   });
 
   reader.on('line', (contents) => {
-    callback(lineNumber++, contents);
+    callback(contents, lineNumber++);
   });
 
   await events.once(reader, 'close');
@@ -31,7 +31,7 @@ export async function mapNDJson(
  * Efficiently parse a single line from a Newline-Delimited JSON (ndjson) file, using streams.
  * Note, line numbers starts at `1`.
  */
-export async function parseNDJsonAtLine<T = any>(filePath: string, line: number): Promise<T> {
+export async function parseJsonLine<T = any>(filePath: string, line: number): Promise<T> {
   const stream = fs.createReadStream(filePath);
   const reader = readline.createInterface({ input: stream });
 
@@ -60,7 +60,7 @@ export async function parseNDJsonAtLine<T = any>(filePath: string, line: number)
 }
 
 /** Efficiently append a new line to a Newline-Delimited JSON (ndjson) file, using streams. */
-export async function appendNDJsonToFile(filePath: string, data: unknown): Promise<void> {
+export async function appendJsonLine(filePath: string, data: unknown): Promise<void> {
   // Note(cedric): keep this dependency inlined to avoid loading it in the WebUI
   const bfj = require('bfj');
   await bfj.write(filePath, data, {

diff --git a/src/utils/stats.ts b/src/utils/stats.ts
@@ -4,7 +4,7 @@ import path from 'path';
 import { name, version } from '../../package.json';
 import { env } from '../utils/env';
 import { AtlasValidationError } from '../utils/errors';
-import { parseNDJsonAtLine } from '../utils/ndjson';
+import { parseJsonLine } from '../utils/ndjson';
 
 export type StatsMetadata = { name: string; version: string };
 
@@ -28,7 +28,7 @@ export async function validateStatsFile(statsFile: string, metadata = getStatsMe
     return;
   }
 
-  const data = await parseNDJsonAtLine(statsFile, 1);
+  const data = await parseJsonLine(statsFile, 1);
 
   if (data.name !== metadata.name || data.version !== metadata.version) {
     throw new AtlasValidationError('STATS_FILE_INCOMPATIBLE', statsFile, data.version);