test: expand package test coverage and enforce minimum test count (#1175)

* test: add broad package-level test coverage

Agent-Logs-Url: https://github.com/ffflorian/node-packages/sessions/e3f75eee-6963-4601-9442-d7358ba984f2

Co-authored-by: ffflorian <5497598+ffflorian@users.noreply.github.com>

* test: fix lint and stabilize new coverage tests

Agent-Logs-Url: https://github.com/ffflorian/node-packages/sessions/e3f75eee-6963-4601-9442-d7358ba984f2

Co-authored-by: ffflorian <5497598+ffflorian@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: ffflorian <5497598+ffflorian@users.noreply.github.com>

Author: Copilot

packages/api-client/package.json

@@ -26,7 +26,7 @@
     "build": "tsc -p tsconfig.build.json",
     "clean": "rm -rf dist",
     "dist": "yarn clean && yarn build",
-    "test": "exit 0"
+    "test": "vitest run"
   },
   "type": "module",
   "version": "2.5.1"

packages/api-client/src/APIClient.test.ts

@@ -0,0 +1,69 @@
+/* eslint-disable no-magic-numbers */
+
+import {afterEach, describe, expect, test, vi} from 'vitest';
+
+import {APIClient} from './APIClient.js';
+
+describe('APIClient', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test('adds query params and skips nullish params', async () => {
+    const fetchMock = vi.fn().mockResolvedValue(new Response(JSON.stringify({ok: true}), {status: 200}));
+    vi.stubGlobal('fetch', fetchMock);
+    const client = new APIClient('https://example.com');
+
+    await client.get('/users', {params: {alpha: 1, beta: null, delta: 'x', gamma: undefined}});
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock.mock.calls[0][0].toString()).toContain('/users?alpha=1&delta=x');
+  });
+
+  test('sets authorization header from auth config', async () => {
+    const fetchMock = vi.fn().mockResolvedValue(new Response(JSON.stringify({ok: true}), {status: 200}));
+    vi.stubGlobal('fetch', fetchMock);
+    const client = new APIClient('https://example.com', {auth: {password: 'pass', username: 'user'}});
+
+    await client.get('/auth');
+
+    const [, options] = fetchMock.mock.calls[0];
+    expect((options as RequestInit).headers).toMatchObject({
+      Authorization: `Basic ${Buffer.from('user:pass').toString('base64')}`,
+    });
+  });
+
+  test('serializes object body and sets content-type', async () => {
+    const fetchMock = vi.fn().mockResolvedValue(new Response(JSON.stringify({ok: true}), {status: 200}));
+    vi.stubGlobal('fetch', fetchMock);
+    const client = new APIClient('https://example.com');
+
+    await client.post('/items', {id: 1, name: 'abc'});
+
+    const [, options] = fetchMock.mock.calls[0];
+    expect(options).toMatchObject({
+      body: JSON.stringify({id: 1, name: 'abc'}),
+      method: 'POST',
+    });
+    expect((options as RequestInit).headers).toMatchObject({'Content-Type': 'application/json'});
+  });
+
+  test('throws status and response text for failed requests', async () => {
+    const fetchMock = vi.fn().mockResolvedValue(new Response('Bad input', {status: 400, statusText: 'Bad Request'}));
+    vi.stubGlobal('fetch', fetchMock);
+    const client = new APIClient('https://example.com');
+
+    await expect(client.get('/fail')).rejects.toThrow('Request failed with status code 400: Bad input');
+  });
+
+  test('supports responseType text', async () => {
+    const fetchMock = vi.fn().mockResolvedValue(new Response('hello', {status: 200}));
+    vi.stubGlobal('fetch', fetchMock);
+    const client = new APIClient('https://example.com');
+
+    const response = await client.get('/text', {responseType: 'text'});
+
+    expect(response.data).toBe('hello');
+    expect(response.status).toBe(200);
+  });
+});

packages/auto-merge/src/AutoMerge.test.ts

@@ -7,6 +7,16 @@ import type {GitHubPullRequest, Repository} from './types/index.js';
 import {AutoMerge} from './AutoMerge.js';
 
 describe('AutoMerge', () => {
+  test('throws when auth token is missing', () => {
+    expect(
+      () =>
+        new AutoMerge({
+          authToken: '',
+          projects: {gitHub: ['ffflorian/example-project']},
+        })
+    ).toThrow('No authentication token specified');
+  });
+
   describe('checkRepository', () => {
     let autoMerge: AutoMerge;
 

packages/crates-updater/package.json

@@ -35,7 +35,8 @@
     "build": "tsc -p tsconfig.build.json",
     "clean": "rm -rf dist",
     "dist": "yarn clean && yarn build",
-    "start": "tsx src/cli.ts"
+    "start": "tsx src/cli.ts",
+    "test": "vitest run"
   },
   "type": "module",
   "version": "1.17.1"

packages/crates-updater/src/CratesUpdater.test.ts

@@ -0,0 +1,62 @@
+import {beforeEach, describe, expect, test, vi} from 'vitest';
+
+const getVersionsMock = vi.hoisted(() => vi.fn());
+
+vi.mock('crates.io', () => ({
+  CratesIO: class {
+    api = {
+      crates: {
+        getVersions: getVersionsMock,
+      },
+    };
+  },
+  Version: class {},
+}));
+
+const modulePromise = import('./CratesUpdater.js');
+
+describe('CratesUpdater', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test('getVersions returns API versions', async () => {
+    getVersionsMock.mockResolvedValue({versions: [{num: '1.0.0'}]});
+    const {getVersions} = await modulePromise;
+
+    const versions = await getVersions('example');
+
+    expect(getVersionsMock).toHaveBeenCalledWith('example');
+    expect(versions).toEqual([{num: '1.0.0'}]);
+  });
+
+  test('getLatestVersion returns highest version from unsorted input', async () => {
+    getVersionsMock.mockResolvedValue({versions: [{num: '1.2.0'}, {num: '1.10.0'}, {num: '1.3.0'}]});
+    const {getLatestVersion} = await modulePromise;
+
+    const latest = await getLatestVersion('example');
+
+    expect(latest.num).toBe('1.10.0');
+  });
+
+  test('checkForUpdate returns latest when newer version exists', async () => {
+    getVersionsMock.mockResolvedValue({versions: [{num: '2.0.0'}, {num: '1.0.0'}]});
+    const {checkForUpdate} = await modulePromise;
+
+    await expect(checkForUpdate('example', '1.5.0')).resolves.toBe('2.0.0');
+  });
+
+  test('checkForUpdate returns null when versions are equal', async () => {
+    getVersionsMock.mockResolvedValue({versions: [{num: '1.5.0'}]});
+    const {checkForUpdate} = await modulePromise;
+
+    await expect(checkForUpdate('example', '1.5.0')).resolves.toBeNull();
+  });
+
+  test('checkForUpdate returns null when local version is newer', async () => {
+    getVersionsMock.mockResolvedValue({versions: [{num: '1.2.0'}]});
+    const {checkForUpdate} = await modulePromise;
+
+    await expect(checkForUpdate('example', '1.9.0')).resolves.toBeNull();
+  });
+});

packages/electron-icon-generator/package.json

@@ -36,7 +36,7 @@
     "clean": "rm -rf dist",
     "dist": "yarn clean && yarn build",
     "start": "tsx src/cli.ts",
-    "test": "exit 0"
+    "test": "vitest run"
   },
   "type": "module",
   "version": "1.15.1"

packages/electron-icon-generator/src/index.test.ts

@@ -0,0 +1,99 @@
+/* eslint-disable id-length, no-magic-numbers */
+
+import path from 'node:path';
+import {beforeEach, describe, expect, test, vi} from 'vitest';
+
+const mkdirMock = vi.hoisted(() => vi.fn());
+const renameMock = vi.hoisted(() => vi.fn());
+const iconGenMock = vi.hoisted(() => vi.fn());
+const jimpReadMock = vi.hoisted(() => vi.fn());
+
+vi.mock('node:fs/promises', () => ({
+  default: {
+    mkdir: mkdirMock,
+    rename: renameMock,
+  },
+}));
+
+vi.mock('icon-gen', () => ({
+  default: {
+    default: iconGenMock,
+  },
+}));
+
+vi.mock('jimp', () => ({
+  Jimp: {
+    read: jimpReadMock,
+  },
+}));
+
+const modulePromise = import('./index.js');
+
+describe('IconGenerator', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test('resolves constructor input and output paths', async () => {
+    const {IconGenerator} = await modulePromise;
+    const generator = new IconGenerator({input: './in.png', output: './out', silent: true});
+
+    expect((generator as any).options.input).toBe(path.resolve('./in.png'));
+    expect((generator as any).options.output).toBe(path.resolve('./out'));
+  });
+
+  test('logConsole is silent when silent option is true', async () => {
+    const {IconGenerator} = await modulePromise;
+    const generator = new IconGenerator({input: './in.png', output: './out', silent: true});
+    const infoSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
+
+    (generator as any).logConsole('test message');
+
+    expect(infoSpy).not.toHaveBeenCalled();
+  });
+
+  test('createPNG creates output folders and writes resized file', async () => {
+    mkdirMock.mockResolvedValue(undefined);
+    renameMock.mockResolvedValue(undefined);
+    const writeMock = vi.fn().mockResolvedValue(undefined);
+    const resizeMock = vi.fn();
+    jimpReadMock.mockResolvedValue({resize: resizeMock, write: writeMock});
+    const {IconGenerator} = await modulePromise;
+    const generator = new IconGenerator({input: './in.png', output: './out', silent: true});
+
+    const message = await (generator as any).createPNG(128);
+
+    expect(mkdirMock).toHaveBeenCalled();
+    expect(resizeMock).toHaveBeenCalledWith({h: 128, w: 128});
+    expect(writeMock).toHaveBeenCalledWith(expect.stringMatching(/128\.png$/));
+    expect(message).toContain('Created');
+  });
+
+  test('renamePNGs renames file and logs completion on last item', async () => {
+    renameMock.mockResolvedValue(undefined);
+    const {IconGenerator} = await modulePromise;
+    const generator = new IconGenerator({input: './in.png', output: './out', silent: true});
+
+    await (generator as any).renamePNGs(8);
+
+    expect(renameMock).toHaveBeenCalledTimes(1);
+    expect(renameMock.mock.calls[0][0]).toMatch(/1024\.png$/);
+    expect(renameMock.mock.calls[0][1]).toMatch(/1024x1024\.png$/);
+  });
+
+  test('start runs generation and icon conversion', async () => {
+    mkdirMock.mockResolvedValue(undefined);
+    renameMock.mockResolvedValue(undefined);
+    iconGenMock.mockResolvedValue(undefined);
+    const writeMock = vi.fn().mockResolvedValue(undefined);
+    const resizeMock = vi.fn();
+    jimpReadMock.mockResolvedValue({resize: resizeMock, write: writeMock});
+    const {IconGenerator} = await modulePromise;
+    const generator = new IconGenerator({input: './in.png', output: './out', silent: true});
+
+    await generator.start();
+
+    expect(iconGenMock).toHaveBeenCalledTimes(2);
+    expect(renameMock).toHaveBeenCalledTimes(9);
+  });
+});

packages/exposure-keys/package.json

@@ -41,7 +41,8 @@
     "build:ts": "tsc -p tsconfig.build.json",
     "clean": "rm -rf dist",
     "dist": "yarn clean && yarn build",
-    "start": "tsx src/cli.ts -d"
+    "start": "tsx src/cli.ts -d",
+    "test": "vitest run"
   },
   "type": "module",
   "version": "1.18.1"

packages/exposure-keys/src/ExposureKeys.test.ts

@@ -0,0 +1,64 @@
+/* eslint-disable no-magic-numbers */
+
+import JSZip from 'jszip';
+import {describe, expect, test} from 'vitest';
+
+import {TEKSignatureList, TemporaryExposureKeyExport} from '../proto/export.js';
+import {loadKeys, loadSignature, loadZip, riskCount} from './ExposureKeys.js';
+
+const header = Buffer.from('EK Export v1    ', 'utf-8');
+
+describe('ExposureKeys', () => {
+  test('loadKeys rejects zip files', () => {
+    const zipHeader = Buffer.from([0x50, 0x4b, 0x03, 0x04]);
+    expect(() => loadKeys(zipHeader)).toThrow('Please use `loadZip()`');
+  });
+
+  test('loadKeys rejects missing header', () => {
+    const content = Buffer.concat([Buffer.from('wrong header     '), Buffer.from([1, 2, 3])]);
+    expect(() => loadKeys(content)).toThrow('missing a correct header');
+  });
+
+  test('loadKeys decodes key export payload', () => {
+    const encoded = TemporaryExposureKeyExport.encode({
+      keys: [{transmissionRiskLevel: 3}, {transmissionRiskLevel: 2}],
+    }).finish();
+    const content = Buffer.concat([header, Buffer.from(encoded)]);
+
+    const result = loadKeys(content);
+
+    expect(result.keys).toHaveLength(2);
+    expect(result.keys[0].transmissionRiskLevel).toBe(3);
+  });
+
+  test('loadSignature decodes signature payload', () => {
+    const encoded = TEKSignatureList.encode({
+      signatures: [{batchNum: 1, batchSize: 2, signature: Buffer.from([1, 2])}],
+    }).finish();
+
+    const result = loadSignature(Buffer.from(encoded));
+
+    expect(result.signatures).toHaveLength(1);
+    expect(result.signatures[0].batchNum).toBe(1);
+  });
+
+  test('loadZip extracts export and signature files', async () => {
+    const zip = new JSZip();
+    zip.file('export.bin', Buffer.from('key-data'));
+    zip.file('export.sig', Buffer.from('sig-data'));
+    const content = Buffer.from(await zip.generateAsync({type: 'nodebuffer'}));
+
+    const result = await loadZip(content);
+
+    expect(result.keys.toString()).toBe('key-data');
+    expect(result.signature.toString()).toBe('sig-data');
+  });
+
+  test('riskCount returns number of matching transmission levels', () => {
+    const exportData = TemporaryExposureKeyExport.fromObject({
+      keys: [{transmissionRiskLevel: 1}, {transmissionRiskLevel: 2}, {transmissionRiskLevel: 2}],
+    });
+
+    expect(riskCount(exportData, 2)).toBe(2);
+  });
+});

packages/https-proxy/package.json

@@ -35,7 +35,8 @@
     "build": "tsc -p tsconfig.build.json",
     "clean": "rm -rf dist",
     "dist": "yarn clean && yarn build",
-    "start": "tsx src/cli.ts"
+    "start": "tsx src/cli.ts",
+    "test": "vitest run"
   },
   "type": "module",
   "version": "1.20.1"