@onlooker-community/ecosystem 0.9.0 → 0.14.0

package/test/node/coverage.test.mjs

@@ -0,0 +1,143 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { describe, it } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(HERE, '..', '..');
+
+function runJson(script, root, ...args) {
+  const r = spawnSync('node', [join(REPO_ROOT, script), '--root', root, '--json', ...args], {
+    encoding: 'utf8',
+  });
+  if (r.status !== 0) {
+    throw new Error(`${script} exited ${r.status}\nstdout:\n${r.stdout}\nstderr:\n${r.stderr}`);
+  }
+  return JSON.parse(r.stdout);
+}
+
+function scaffoldMarketplace() {
+  const root = mkdtempSync(join(tmpdir(), 'coverage-'));
+  mkdirSync(join(root, '.claude-plugin'), { recursive: true });
+  writeFileSync(
+    join(root, '.claude-plugin', 'marketplace.json'),
+    JSON.stringify({ name: 't', plugins: [{ name: 's', source: './' }] }),
+  );
+  return root;
+}
+
+function writeFile(path, content) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, content);
+}
+
+describe('bash-coverage', () => {
+  it('returns 100% when every public function is referenced in tests', () => {
+    const root = scaffoldMarketplace();
+    writeFile(join(root, 'scripts/lib/foo.sh'), `#!/usr/bin/env bash\nfoo() { echo 1; }\nbar() { echo 2; }\n`);
+    writeFile(join(root, 'test/bats/foo.bats'), `@test "covers" { foo; bar; }\n`);
+    const report = runJson('scripts/coverage/bash-coverage.mjs', root);
+    assert.equal(report.overall.total, 2);
+    assert.equal(report.overall.tested, 2);
+    assert.equal(report.overall.ratio, 1);
+  });
+
+  it('drops untested public functions into the untested list', () => {
+    const root = scaffoldMarketplace();
+    writeFile(join(root, 'scripts/lib/foo.sh'), `#!/usr/bin/env bash\nfoo() { :; }\nbar() { :; }\nbaz() { :; }\n`);
+    writeFile(join(root, 'test/bats/foo.bats'), `@test "covers" { foo; }\n`);
+    const report = runJson('scripts/coverage/bash-coverage.mjs', root);
+    assert.equal(report.overall.tested, 1);
+    assert.equal(report.overall.total, 3);
+    const untestedNames = report.untested.map((u) => u.name).sort();
+    assert.deepEqual(untestedNames, ['bar', 'baz']);
+  });
+
+  it('skips private (underscore-prefixed) helpers', () => {
+    const root = scaffoldMarketplace();
+    writeFile(join(root, 'scripts/lib/foo.sh'), `#!/usr/bin/env bash\nfoo() { :; }\n_internal() { :; }\n`);
+    writeFile(join(root, 'test/bats/foo.bats'), `@test "covers foo" { foo; }\n`);
+    const report = runJson('scripts/coverage/bash-coverage.mjs', root);
+    assert.equal(report.overall.total, 1, JSON.stringify(report));
+  });
+
+  it('does not count indented function-looking lines as definitions', () => {
+    const root = scaffoldMarketplace();
+    writeFile(
+      join(root, 'scripts/lib/foo.sh'),
+      `#!/usr/bin/env bash\nfoo() {\n  inner() { :; }  # nested, should NOT count\n}\n`,
+    );
+    writeFile(join(root, 'test/bats/foo.bats'), `@test "covers" { foo; }\n`);
+    const report = runJson('scripts/coverage/bash-coverage.mjs', root);
+    assert.equal(report.overall.total, 1);
+  });
+
+  it('handles repos with no .sh files at all', () => {
+    const root = scaffoldMarketplace();
+    const report = runJson('scripts/coverage/bash-coverage.mjs', root);
+    assert.equal(report.overall.total, 0);
+    assert.equal(report.overall.ratio, 1);
+  });
+});
+
+describe('format-comment', () => {
+  function render(nodeReport, bashReport, sha = 'abcdef0123456789') {
+    const tmp = mkdtempSync(join(tmpdir(), 'cov-fmt-'));
+    const nPath = join(tmp, 'node.json');
+    const bPath = join(tmp, 'bash.json');
+    writeFileSync(nPath, JSON.stringify(nodeReport));
+    writeFileSync(bPath, JSON.stringify(bashReport));
+    const r = spawnSync(
+      'node',
+      [join(REPO_ROOT, 'scripts', 'coverage', 'format-comment.mjs'), '--node', nPath, '--bash', bPath, '--sha', sha],
+      { encoding: 'utf8' },
+    );
+    if (r.status !== 0) throw new Error(`format-comment failed: ${r.stderr}`);
+    return r.stdout;
+  }
+
+  it('emits the sentinel comment so the upsert logic can find it', () => {
+    const out = render(
+      { overall: null, files: [] },
+      { overall: { total: 0, tested: 0, ratio: 1 }, files: [], untested: [] },
+    );
+    assert.ok(out.startsWith('<!-- onlooker-coverage-comment -->'));
+  });
+
+  it('renders node coverage rows in the markdown table', () => {
+    const out = render(
+      {
+        overall: { file: 'all files', line: 75, branch: 55, funcs: 90, uncoveredLines: '' },
+        files: [{ file: 'foo.mjs', line: 75, branch: 50, funcs: 80, uncoveredLines: '12-14' }],
+      },
+      { overall: { total: 1, tested: 1, ratio: 1 }, files: [], untested: [] },
+    );
+    assert.match(out, /\| `foo\.mjs` \| 75\.0% \| 50\.0% \| 80\.0% \|/);
+    // 75% lines → yellow (60–79 inclusive).
+    assert.match(out, /\*\*Overall:\*\* 🟡 75\.0% lines/);
+  });
+
+  it('marks bash overall red when below 50%', () => {
+    const out = render(
+      { overall: null, files: [] },
+      { overall: { total: 10, tested: 3, ratio: 0.3 }, files: [], untested: [] },
+    );
+    assert.match(out, /🔴 3\/10 public functions/);
+  });
+
+  it('lists untested functions inside a collapsed details block', () => {
+    const out = render(
+      { overall: null, files: [] },
+      {
+        overall: { total: 2, tested: 1, ratio: 0.5 },
+        files: [{ file: 'a.sh', total: 2, tested: 1, ratio: 0.5, untested: ['bar'] }],
+        untested: [{ file: 'a.sh', name: 'bar' }],
+      },
+    );
+    assert.match(out, /<details><summary>Untested public functions<\/summary>/);
+    assert.match(out, /`a\.sh` — `bar`/);
+  });
+});

package/test/node/schema-events.test.mjs

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { test } from 'node:test';
@@ -7,6 +7,9 @@ import { fileURLToPath } from 'node:url';
 import { validate } from '@onlooker-community/schema';
 import {
   buildCanonicalEvent,
+  buildToolFileReadPayload,
+  extractReadRange,
+  LARGE_FILE_BYTES_ON_DISK,
   mapHookInputToCanonical,
   mapSkillHookInput,
   mapTaskHookInput,
@@ -32,6 +35,43 @@ test('mapHookInputToCanonical maps PostToolUse Read to tool.file.read', () => {
   assert.equal(mapped.event.event_type, 'tool.file.read');
   assert.equal(mapped.event.schema_version, '1.0');
   assert.equal(mapped.event.payload.path, '/project/src/main.ts');
+  assert.equal(mapped.event.payload.read_mode, 'full');
+  assert.equal(validate(mapped.event).valid, true);
+});
+
+test('extractReadRange detects partial reads from offset and limit', () => {
+  const range = extractReadRange({ offset: 10, limit: 50 });
+  assert.equal(range.read_mode, 'partial');
+  assert.equal(range.offset, 10);
+  assert.equal(range.limit, 50);
+});
+
+test('buildToolFileReadPayload flags large_file_full_read', () => {
+  const tmpDir = mkdtempSync(join(tmpdir(), 'onlooker-read-chunk-'));
+  const filePath = join(tmpDir, 'big.txt');
+  const bytes = LARGE_FILE_BYTES_ON_DISK + 1;
+  writeFileSync(filePath, 'x'.repeat(bytes), 'utf8');
+
+  const payload = buildToolFileReadPayload({ file_path: filePath }, { content: 'x\n' });
+  assert.equal(payload.read_mode, 'full');
+  assert.equal(payload.large_file_full_read, true);
+  assert.equal(payload.file_bytes_on_disk, bytes);
+
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+test('mapHookInputToCanonical maps chunked Read to partial read_mode', () => {
+  const hookInput = loadFixture('post-tool-use-read-chunked.json');
+  const tmpDir = join(REPO_ROOT, 'test/tmp-schema-events');
+  const mapped = mapHookInputToCanonical(hookInput, {
+    onlookerDir: tmpDir,
+    plugin: 'onlooker',
+  });
+
+  assert.equal(mapped.valid, true);
+  assert.equal(mapped.event.payload.read_mode, 'partial');
+  assert.equal(mapped.event.payload.offset, 400);
+  assert.equal(mapped.event.payload.limit, 80);
   assert.equal(validate(mapped.event).valid, true);
 });