@20syldev/api 4.0.0 → 4.1.0

package/tests/unit/time.test.ts

@@ -0,0 +1,67 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import time from '../../src/modules/v4/time.js';
+
+describe('time', () => {
+    test('live returns full set of formats', () => {
+        const result = time('live');
+        const fields = [
+            'iso',
+            'utc',
+            'timestamp',
+            'locale',
+            'date',
+            'time',
+            'year',
+            'month',
+            'day',
+            'hour',
+            'minute',
+            'second',
+            'ms',
+            'dayOfWeek',
+            'dayOfYear',
+            'weekNumber',
+            'timezone',
+            'timezoneOffset',
+        ];
+        for (const f of fields) {
+            assert.ok(f in result, `missing field: ${f}`);
+        }
+    });
+
+    test('iso is parseable', () => {
+        const result = time('live');
+        assert.ok(!isNaN(Date.parse(result.iso as string)));
+    });
+
+    test('format=year returns only date', () => {
+        const result = time('live', undefined, undefined, 'year');
+        assert.ok('date' in result);
+        assert.equal(typeof result.date, 'number');
+    });
+
+    test('random within range', () => {
+        const result = time('random', '2020-01-01', '2020-12-31');
+        const ts = result.timestamp as number;
+        assert.ok(ts >= new Date('2020-01-01').getTime());
+        assert.ok(ts <= new Date('2020-12-31').getTime());
+    });
+
+    test('throws on invalid type', () => {
+        assert.throws(() => time('foo'), /valid type/);
+    });
+
+    test('throws on invalid format', () => {
+        assert.throws(() => time('live', undefined, undefined, 'fakeformat'), /valid format/);
+    });
+
+    test('throws on invalid timezone', () => {
+        assert.throws(() => time('live', undefined, undefined, undefined, 'Mars/Olympus'), /valid timezone/);
+    });
+
+    test('Europe/Paris timezone', () => {
+        const result = time('live', undefined, undefined, undefined, 'Europe/Paris');
+        assert.equal(result.timezone, 'Europe/Paris');
+    });
+});

package/tests/unit/token.test.ts

@@ -0,0 +1,61 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import token from '../../src/modules/v4/token.js';
+
+describe('token', () => {
+    test('alpha length', () => {
+        const t = token(24, 'alpha');
+        assert.equal(t.length, 24);
+        assert.match(t, /^[a-zA-Z]+$/);
+    });
+
+    test('alphanum length', () => {
+        const t = token(32, 'alphanum');
+        assert.equal(t.length, 32);
+        assert.match(t, /^[a-zA-Z0-9]+$/);
+    });
+
+    test('hex contains only hex chars', () => {
+        const t = token(16, 'hex');
+        assert.equal(t.length, 16);
+        assert.match(t, /^[0-9a-f]+$/);
+    });
+
+    test('num contains only digits', () => {
+        const t = token(20, 'num');
+        assert.match(t, /^\d+$/);
+    });
+
+    test('urlsafe chars only', () => {
+        const t = token(40, 'urlsafe');
+        assert.match(t, /^[a-zA-Z0-9_-]+$/);
+    });
+
+    test('uuid type produces hex', () => {
+        const t = token(32, 'uuid');
+        assert.equal(t.length, 32);
+    });
+
+    test('default type alphanum', () => {
+        const t = token(20);
+        assert.match(t, /^[a-zA-Z0-9]+$/);
+    });
+
+    test('throws below minimum length', () => {
+        assert.throws(() => token(5, 'alpha'), /greater than or equal to 12/);
+    });
+
+    test('throws above maximum length', () => {
+        assert.throws(() => token(5000, 'alpha'), /4096/);
+    });
+
+    test('throws on invalid type', () => {
+        assert.throws(() => token(20, 'martian'), /Invalid token type/);
+    });
+
+    test('two tokens are different (entropy check)', () => {
+        const a = token(32, 'alphanum');
+        const b = token(32, 'alphanum');
+        assert.notEqual(a, b);
+    });
+});

package/tests/unit/username.test.ts

@@ -0,0 +1,34 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import username from '../../src/modules/v4/username.js';
+
+describe('username', () => {
+    test('returns expected fields', () => {
+        const result = username();
+        assert.ok('username' in result);
+        assert.ok('number' in result);
+        assert.ok('adjective' in result);
+        assert.ok('animal' in result);
+        assert.ok('job' in result);
+    });
+
+    test('username is a non-empty string', () => {
+        const result = username();
+        assert.equal(typeof result.username, 'string');
+        assert.ok((result.username as string).length > 0);
+    });
+
+    test('number is between 0 and 99', () => {
+        const result = username();
+        const n = result.number as number;
+        assert.ok(n >= 0 && n <= 99);
+    });
+
+    test('produces varied usernames', () => {
+        const seen = new Set<string>();
+        for (let i = 0; i < 10; i++) {
+            seen.add(username().username as string);
+        }
+        assert.ok(seen.size > 1);
+    });
+});

package/tests/unit/validate.test.ts

@@ -0,0 +1,71 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { luhn, iban, email } from '../../src/modules/v4/validate.js';
+
+describe('validate', () => {
+    describe('luhn', () => {
+        test('valid Visa test card', () => {
+            const result = luhn('4111111111111111');
+            assert.equal(result.valid, true);
+        });
+
+        test('invalid card number', () => {
+            const result = luhn('4111111111111112');
+            assert.equal(result.valid, false);
+        });
+
+        test('strips spaces and dashes', () => {
+            const result = luhn('4111-1111 1111-1111');
+            assert.equal(result.valid, true);
+            assert.equal(result.value, '4111111111111111');
+        });
+
+        test('throws on non-digit', () => {
+            assert.throws(() => luhn('4111ABC11111111'), /only digits/);
+        });
+
+        test('throws on too short', () => {
+            assert.throws(() => luhn('411111'), /between 12 and 19/);
+        });
+    });
+
+    describe('iban', () => {
+        test('valid French IBAN', () => {
+            const result = iban('FR1420041010050500013M02606');
+            assert.equal(result.valid, true);
+            assert.equal(result.country, 'FR');
+        });
+
+        test('invalid checksum', () => {
+            const result = iban('FR1420041010050500013M02607');
+            assert.equal(result.valid, false);
+        });
+
+        test('strips spaces', () => {
+            const result = iban('FR14 2004 1010 0505 0001 3M02 606');
+            assert.equal(result.valid, true);
+        });
+
+        test('throws on bad format', () => {
+            assert.throws(() => iban('1234'), /Invalid IBAN format/);
+        });
+    });
+
+    describe('email', () => {
+        test('valid email', () => {
+            assert.equal(email('hello@example.com').valid, true);
+        });
+
+        test('rejects missing domain', () => {
+            assert.equal(email('hello@').valid, false);
+        });
+
+        test('rejects missing @', () => {
+            assert.equal(email('helloexample.com').valid, false);
+        });
+
+        test('rejects spaces', () => {
+            assert.equal(email('hello world@example.com').valid, false);
+        });
+    });
+});

package/tsconfig.test.json

@@ -0,0 +1,9 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "rootDir": ".",
+        "noEmit": true,
+        "types": ["node"]
+    },
+    "include": ["src", "tests"]
+}