@20syldev/api 4.2.0 → 4.4.0

package/tests/unit/qrcode.test.ts

@@ -0,0 +1,82 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import qrcode from '../../src/modules/v4/qrcode.js';
+
+const PNG_MAGIC = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
+
+describe('qrcode', () => {
+    test('returns PNG buffer by default', async () => {
+        const result = await qrcode({ url: 'https://example.com' });
+        assert.equal(result.contentType, 'image/png');
+        assert.ok(Buffer.isBuffer(result.body));
+        assert.ok((result.body as Buffer).subarray(0, 4).equals(PNG_MAGIC));
+    });
+
+    test('returns data URL with format=base64', async () => {
+        const result = await qrcode({ url: 'https://example.com', format: 'base64' });
+        assert.equal(result.contentType, 'application/json');
+        assert.match(result.body as string, /^data:image\/png;base64,/);
+    });
+
+    test('throws on invalid format', async () => {
+        await assert.rejects(() => qrcode({ url: 'https://example.com', format: 'jpg' as 'png' }), /format/);
+    });
+
+    test('throws on missing url', async () => {
+        await assert.rejects(() => qrcode({ url: '' }));
+    });
+
+    test('accepts custom size', async () => {
+        const result = await qrcode({ url: 'https://example.com', size: 400 });
+        assert.equal(result.contentType, 'image/png');
+    });
+
+    test('throws on invalid size', async () => {
+        await assert.rejects(() => qrcode({ url: 'https://example.com', size: 9999 }), /size/);
+    });
+
+    test('accepts custom colors', async () => {
+        const result = await qrcode({ url: 'https://example.com', dark: 'ff0000', light: 'ffffff' });
+        assert.equal(result.contentType, 'image/png');
+    });
+
+    test('throws on invalid dark color', async () => {
+        await assert.rejects(() => qrcode({ url: 'https://example.com', dark: 'xyz' }), /color/i);
+    });
+
+    test('throws on invalid light color', async () => {
+        await assert.rejects(() => qrcode({ url: 'https://example.com', light: 'nope' }), /color/i);
+    });
+
+    test('accepts correction level', async () => {
+        const result = await qrcode({ url: 'https://example.com', correction: 'H' });
+        assert.equal(result.contentType, 'image/png');
+    });
+
+    test('throws on invalid correction level', async () => {
+        await assert.rejects(() => qrcode({ url: 'https://example.com', correction: 'X' as 'L' }), /correction/);
+    });
+
+    test('accepts custom margin', async () => {
+        const result = await qrcode({ url: 'https://example.com', margin: 0 });
+        assert.equal(result.contentType, 'image/png');
+    });
+
+    test('throws on invalid margin', async () => {
+        await assert.rejects(() => qrcode({ url: 'https://example.com', margin: 99 }), /margin/);
+    });
+
+    test('throws on non-HTTPS icon URL', async () => {
+        await assert.rejects(
+            () => qrcode({ url: 'https://example.com', icon: 'http://example.com/icon.png' }),
+            /HTTPS/,
+        );
+    });
+
+    test('throws on unreachable icon URL', async () => {
+        await assert.rejects(
+            () => qrcode({ url: 'https://example.com', icon: 'https://localhost:1/nope.png' }),
+            /Failed to fetch icon|fetch/i,
+        );
+    });
+});

package/tests/unit/tic_tac_toe.test.ts

@@ -0,0 +1,55 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import tic_tac_toe from '../../src/modules/v4/tic_tac_toe.js';
+import type { TicTacToeStorage } from '../../src/types/storage.js';
+
+function makeStorage(): TicTacToeStorage {
+    return { games: {}, sessions: {}, rateLimits: {} };
+}
+
+describe('tic_tac_toe', () => {
+    test('list returns empty games array', () => {
+        const result = tic_tac_toe('list', { storage: makeStorage() });
+        assert.ok(Array.isArray(result.games));
+    });
+
+    test('play creates a game and makes a move', () => {
+        const storage = makeStorage();
+        const result = tic_tac_toe('play', { username: 'alice', move: '1-1', session: 'a1', game: 'TEST1', storage });
+        assert.ok((result.message as string).includes('Move sent'));
+    });
+
+    test('fetch returns game state', () => {
+        const storage = makeStorage();
+        tic_tac_toe('play', { username: 'alice', move: '1-1', session: 'a1', game: 'TEST2', storage });
+        const result = tic_tac_toe('fetch', { username: 'alice', game: 'TEST2', storage });
+        assert.equal(result.id, 'TEST2');
+    });
+
+    test('forfeit throws on non-player', () => {
+        const storage = makeStorage();
+        tic_tac_toe('play', { username: 'alice', move: '1-1', session: 'a1', game: 'TEST3', storage });
+        assert.throws(
+            () => tic_tac_toe('forfeit', { username: 'charlie', session: 'c1', game: 'TEST3', storage }),
+            /not a player/,
+        );
+    });
+
+    test('throws on missing username', () => {
+        assert.throws(
+            () => tic_tac_toe('play', { move: '1-1', session: 's', game: 'G', storage: makeStorage() }),
+            /username/,
+        );
+    });
+
+    test('throws on missing move', () => {
+        assert.throws(
+            () => tic_tac_toe('play', { username: 'alice', session: 's', game: 'G', storage: makeStorage() }),
+            /move/i,
+        );
+    });
+
+    test('throws on invalid action', () => {
+        assert.throws(() => tic_tac_toe('reset', { username: 'alice', storage: makeStorage() }), /Invalid action/);
+    });
+});

package/src/modules/v4/utils.ts

@@ -1,38 +0,0 @@
-export function random<T>(arr: T[]): T {
-    return arr[Math.floor(Math.random() * arr.length)]!;
-}
-
-export function randomNumber(min: number, max: number): number {
-    return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-
-export function genIP(): string {
-    return `${randomNumber(0, 255)}.${randomNumber(0, 255)}.${randomNumber(0, 255)}.${randomNumber(0, 255)}`;
-}
-
-export function formatDate(date: Date): string {
-    return new Date(date.getTime() - date.getTimezoneOffset() * 60000).toISOString().replace('Z', '');
-}
-
-export function envList(key: string): string[] | null {
-    const v = process.env[key];
-    return v && v !== 'undefined' ? v.split(' ') : null;
-}
-
-export function checkRateLimit(
-    rateLimits: Record<string, number[]>,
-    userId: string,
-    timestamp: number,
-    window = 10000,
-    limit = 50,
-): boolean {
-    rateLimits[userId] = (rateLimits[userId] ?? []).filter((ts) => timestamp - ts < window);
-
-    if (rateLimits[userId]!.length > limit) {
-        const remainingTime = Math.ceil((rateLimits[userId]![0]! + window - timestamp) / 1000);
-        throw new Error(`Rate limit exceeded. Try again in ${remainingTime} seconds.`);
-    }
-
-    rateLimits[userId]!.push(timestamp);
-    return false;
-}