titanpl 6.0.0 → 7.0.0

package/packages/core-source/tests/ls.test.js

@@ -0,0 +1,149 @@
+/**
+ * tests/ls.test.js
+ * 
+ * Tests for the ls (Local Storage) module
+ * Uses emulated natives with in-memory Map
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ls } from '../index.js';
+
+describe('ls (Local Storage)', () => {
+    beforeEach(() => {
+        ls.clear()
+    });
+
+    describe('set() and get()', () => {
+        it('should store and retrieve string', () => {
+            ls.set('key1', 'value1');
+            
+            expect(ls.get('key1')).toBe('value1');
+        });
+
+        it('should convert numbers to string', () => {
+            ls.set('number', 42);
+            
+            expect(ls.get('number')).toBe('42');
+        });
+
+        it('should return empty for non-existing key', () => {
+            expect(ls.get('nonexistent')).toBe('');
+        });
+
+        it('should overwrite existing values', () => {
+            ls.set('key', 'original');
+            ls.set('key', 'updated');
+            
+            expect(ls.get('key')).toBe('updated');
+        });
+
+        it('should handle JSON values', () => {
+            const data = { name: 'Test', items: [1, 2, 3] };
+            ls.set('json', JSON.stringify(data));
+            
+            expect(JSON.parse(ls.get('json'))).toEqual(data);
+        });
+    });
+
+    describe('remove()', () => {
+        it('should remove existing key', () => {
+            ls.set('toRemove', 'value');
+            ls.remove('toRemove');
+            
+            expect(ls.get('toRemove')).toBe('');
+        });
+
+        it('should not fail when removing non-existing key', () => {
+            expect(() => ls.remove('nonexistent')).not.toThrow();
+        });
+    });
+
+    describe('clear()', () => {
+        it('should remove all values', () => {
+            ls.set('key1', 'value1');
+            ls.set('key2', 'value2');
+            ls.set('key3', 'value3');
+            
+            ls.clear();
+            
+            expect(ls.get('key1')).toBe('');
+            expect(ls.get('key2')).toBe('');
+            expect(ls.get('key3')).toBe('');
+        });
+    });
+
+    describe('keys()', () => {
+        it('should return list of keys', () => {
+            ls.set('a', '1');
+            ls.set('b', '2');
+            ls.set('c', '3');
+            
+            const keys = ls.keys();
+            
+            expect(keys).toContain('a');
+            expect(keys).toContain('b');
+            expect(keys).toContain('c');
+        });
+
+        it('should return empty array when no keys', () => {
+            const keys = ls.keys();
+            
+            expect(keys).toEqual([]);
+        });
+    });
+
+    describe('setObject() and getObject()', () => {
+        it('should store and retrieve objects via JSON when serialize is not available', () => {
+            const data = {
+                name: 'Test',
+                count: 42,
+                items: ['a', 'b', 'c'],
+                nested: { x: 1, y: 2 }
+            };
+            
+            ls.setObject('complex', data);
+            const result = ls.getObject('complex');
+            
+            // If result is null, V8 serialization is not available
+            // This is expected in environments outside Titan runtime
+            if (result === null) {
+                // Verify at least set/get works with manual JSON
+                ls.set('complex-json', JSON.stringify(data));
+                const jsonResult = JSON.parse(ls.get('complex-json'));
+                expect(jsonResult).toEqual(data);
+            } else {
+                expect(result).toEqual(data);
+            }
+        });
+
+        it('should handle arrays via JSON when serialize is not available', () => {
+            const arr = [1, 2, 3, 'four', { five: 5 }];
+            
+            ls.setObject('array', arr);
+            const result = ls.getObject('array');
+            
+            if (result === null) {
+                ls.set('array-json', JSON.stringify(arr));
+                const jsonResult = JSON.parse(ls.get('array-json'));
+                expect(jsonResult).toEqual(arr);
+            } else {
+                expect(result).toEqual(arr);
+            }
+        });
+
+        it('should return null for non-existing key', () => {
+            expect(ls.getObject('nonexistent')).toBeNull();
+        });
+    });
+
+    describe('serialize() and deserialize()', () => {
+        it('should serialize and deserialize correctly', () => {
+            const data = { test: true, value: 123 };
+            
+            const serialized = ls.serialize(data);
+            expect(serialized).toBeInstanceOf(Uint8Array);
+            
+            const deserialized = ls.deserialize(serialized);
+            expect(deserialized).toEqual(data);
+        });
+    });
+});

package/packages/core-source/tests/net.test.js

@@ -0,0 +1,84 @@
+/**
+ * tests/net.test.js
+ * 
+ * Tests for the net module
+ * Uses emulated natives
+ */
+import { describe, it, expect } from 'vitest';
+import { net } from '../index.js';
+
+describe('net', () => {
+    describe('ip()', () => {
+        it('should return valid IP address', () => {
+            const ip = net.ip();
+            
+            expect(typeof ip).toBe('string');
+            // Should be IPv4 format or localhost
+            expect(ip).toMatch(/^(\d{1,3}\.){3}\d{1,3}$/);
+        });
+    });
+
+    describe('resolveDNS()', () => {
+        it('should return array of IPs', () => {
+            const ips = net.resolveDNS('localhost');
+            
+            expect(Array.isArray(ips)).toBe(true);
+        });
+
+        it('should return empty array for invalid hostname', () => {
+            const ips = net.resolveDNS('');
+            
+            expect(Array.isArray(ips)).toBe(true);
+        });
+    });
+});
+
+/**
+ * Tests for the proc module
+ */
+import { proc } from '../index.js';
+
+describe('proc', () => {
+    describe('info()', () => {
+        it('should return process info', () => {
+            const info = proc.info();
+            
+            expect(info).toHaveProperty('pid');
+            expect(typeof info.pid).toBe('number');
+            expect(info.pid).toBeGreaterThan(0);
+        });
+    });
+
+    describe('pid()', () => {
+        it('should return process PID', () => {
+            const pid = proc.pid();
+            
+            expect(typeof pid).toBe('number');
+            expect(pid).toBeGreaterThan(0);
+        });
+    });
+
+    describe('list()', () => {
+        it('should return array (possibly empty in tests)', () => {
+            const processes = proc.list();
+            
+            expect(Array.isArray(processes)).toBe(true);
+        });
+    });
+
+    describe('run()', () => {
+        it('should return object (disabled in tests)', () => {
+            const result = proc.run('echo', ['hello']);
+            
+            expect(typeof result).toBe('object');
+        });
+    });
+
+    describe('kill()', () => {
+        it('should return false (disabled in tests)', () => {
+            const result = proc.kill(99999);
+            
+            expect(result).toBe(false);
+        });
+    });
+});

package/packages/core-source/tests/os.test.js

@@ -0,0 +1,81 @@
+/**
+ * tests/os.test.js
+ * 
+ * Tests for the os module
+ * Uses emulated natives wrapping Node.js os
+ */
+import { describe, it, expect } from 'vitest';
+import { os } from '../index.js';
+
+describe('os', () => {
+    describe('info()', () => {
+        it('should return object with system info', () => {
+            const info = os.info();
+            
+            expect(info).toHaveProperty('platform');
+            expect(info).toHaveProperty('cpus');
+            expect(info).toHaveProperty('totalMemory');
+            expect(info).toHaveProperty('freeMemory');
+        });
+
+        it('should have valid values', () => {
+            const info = os.info();
+            
+            expect(typeof info.platform).toBe('string');
+            expect(info.cpus).toBeGreaterThan(0);
+            expect(info.totalMemory).toBeGreaterThan(0);
+            expect(info.freeMemory).toBeGreaterThanOrEqual(0);
+        });
+    });
+
+    describe('platform()', () => {
+        it('should return valid platform', () => {
+            const platform = os.platform();
+            
+            expect(['linux', 'darwin', 'win32', 'freebsd', 'openbsd']).toContain(platform);
+        });
+    });
+
+    describe('cpus()', () => {
+        it('should return number of CPUs', () => {
+            const cpus = os.cpus();
+            
+            expect(typeof cpus).toBe('number');
+            expect(cpus).toBeGreaterThan(0);
+        });
+    });
+
+    describe('totalMemory()', () => {
+        it('should return total memory in bytes', () => {
+            const total = os.totalMemory();
+            
+            expect(typeof total).toBe('number');
+            expect(total).toBeGreaterThan(0);
+        });
+    });
+
+    describe('freeMemory()', () => {
+        it('should return free memory in bytes', () => {
+            const free = os.freeMemory();
+            
+            expect(typeof free).toBe('number');
+            expect(free).toBeGreaterThanOrEqual(0);
+        });
+
+        it('free memory should be less than or equal to total', () => {
+            const total = os.totalMemory();
+            const free = os.freeMemory();
+            
+            expect(free).toBeLessThanOrEqual(total);
+        });
+    });
+
+    describe('tmpdir()', () => {
+        it('should return temp directory', () => {
+            const tmp = os.tmpdir();
+            
+            expect(typeof tmp).toBe('string');
+            expect(tmp.length).toBeGreaterThan(0);
+        });
+    });
+});

package/packages/core-source/tests/path.test.js

@@ -0,0 +1,102 @@
+/**
+ * tests/path.test.js
+ * 
+ * Tests for the path module
+ * Pure JS API - no mocks required
+ */
+import { describe, it, expect } from 'vitest';
+import { path } from '../index.js';
+
+describe('path', () => {
+    describe('join()', () => {
+        it('should join path segments', () => {
+            expect(path.join('a', 'b', 'c')).toBe('a/b/c');
+        });
+
+        it('should normalize duplicate separators', () => {
+            expect(path.join('a/', '/b/', '/c')).toBe('a/b/c');
+        });
+
+        it('should convert backslashes to forward slashes', () => {
+            expect(path.join('a\\b', 'c\\d')).toBe('a/b/c/d');
+        });
+
+        it('should filter falsy values', () => {
+            expect(path.join('a', null, 'b', undefined, 'c')).toBe('a/b/c');
+        });
+
+        it('should handle single segment', () => {
+            expect(path.join('single')).toBe('single');
+        });
+
+        it('should handle absolute paths', () => {
+            expect(path.join('/root', 'sub', 'file.txt')).toBe('/root/sub/file.txt');
+        });
+    });
+
+    describe('dirname()', () => {
+        it('should return parent directory', () => {
+            expect(path.dirname('/home/user/file.txt')).toBe('/home/user');
+        });
+
+        it('should return "." for file without directory', () => {
+            expect(path.dirname('file.txt')).toBe('.');
+        });
+
+        it('should handle paths with multiple levels', () => {
+            expect(path.dirname('a/b/c/d.js')).toBe('a/b/c');
+        });
+    });
+
+    describe('basename()', () => {
+        it('should return filename', () => {
+            expect(path.basename('/home/user/file.txt')).toBe('file.txt');
+        });
+
+        it('should return name for simple path', () => {
+            expect(path.basename('file.txt')).toBe('file.txt');
+        });
+
+        it('should handle directories', () => {
+            expect(path.basename('/home/user/')).toBe('');
+            expect(path.basename('/home/user')).toBe('user');
+        });
+    });
+
+    describe('extname()', () => {
+        it('should return extension with dot', () => {
+            expect(path.extname('file.txt')).toBe('.txt');
+        });
+
+        it('should return last extension', () => {
+            expect(path.extname('archive.tar.gz')).toBe('.gz');
+        });
+
+        it('should return empty if no extension', () => {
+            expect(path.extname('noextension')).toBe('');
+        });
+
+        it('should handle hidden files', () => {
+            expect(path.extname('.gitignore')).toBe('');
+        });
+
+        it('should handle full paths', () => {
+            expect(path.extname('/path/to/file.json')).toBe('.json');
+        });
+    });
+
+    describe('resolve()', () => {
+        it('should return absolute paths unchanged', () => {
+            expect(path.resolve('/absolute/path')).toBe('/absolute/path');
+        });
+
+        it('should join multiple segments', () => {
+            const result = path.resolve('a', 'b', 'c');
+            expect(result).toContain('a/b/c');
+        });
+
+        it('should handle Windows paths', () => {
+            expect(path.resolve('C:/Users/test')).toBe('C:/Users/test');
+        });
+    });
+});

package/packages/core-source/tests/response.test.js

@@ -0,0 +1,146 @@
+/**
+ * tests/response.test.js
+ * 
+ * Tests for the response module
+ * Pure JS API - no mocks required
+ */
+import { describe, it, expect } from 'vitest';
+import { response } from '../index.js';
+
+describe('response', () => {
+    describe('response()', () => {
+        it('should create basic response', () => {
+            const res = response({ status: 200, body: 'OK' });
+            
+            expect(res._isResponse).toBe(true);
+            expect(res.status).toBe(200);
+            expect(res.body).toBe('OK');
+            expect(res.headers).toEqual({});
+        });
+
+        it('should use default values', () => {
+            const res = response({});
+            
+            expect(res.status).toBe(200);
+            expect(res.body).toBe('');
+            expect(res.headers).toEqual({});
+        });
+
+        it('should include custom headers', () => {
+            const res = response({
+                status: 201,
+                headers: { 'X-Custom': 'value' },
+                body: 'Created'
+            });
+            
+            expect(res.headers['X-Custom']).toBe('value');
+        });
+    });
+
+    describe('response.json()', () => {
+        it('should create JSON response', () => {
+            const res = response.json({ message: 'Hello', count: 42 });
+            
+            expect(res._isResponse).toBe(true);
+            expect(res.status).toBe(200);
+            expect(res.headers['Content-Type']).toBe('application/json');
+            expect(res.body).toBe('{"message":"Hello","count":42}');
+        });
+
+        it('should allow custom status', () => {
+            const res = response.json({ error: 'Not found' }, { status: 404 });
+            
+            expect(res.status).toBe(404);
+        });
+
+        it('should serialize arrays', () => {
+            const res = response.json([1, 2, 3]);
+            
+            expect(res.body).toBe('[1,2,3]');
+        });
+
+        it('should handle complex objects', () => {
+            const data = {
+                users: [{ id: 1, name: 'John' }],
+                meta: { total: 1 }
+            };
+            const res = response.json(data);
+            
+            expect(JSON.parse(res.body)).toEqual(data);
+        });
+    });
+
+    describe('response.text()', () => {
+        it('should create plain text response', () => {
+            const res = response.text('Hello World');
+            
+            expect(res._isResponse).toBe(true);
+            expect(res.body).toBe('Hello World');
+        });
+
+        it('should convert numbers to string', () => {
+            const res = response.text(42);
+            
+            expect(res.body).toBe('42');
+        });
+    });
+
+    describe('response.html()', () => {
+        it('should create HTML response', () => {
+            const html = '<html><body>Hello</body></html>';
+            const res = response.html(html);
+            
+            expect(res._isResponse).toBe(true);
+            expect(res.headers['Content-Type']).toBe('text/html');
+            expect(res.body).toBe(html);
+        });
+
+        it('should allow additional headers', () => {
+            const res = response.html('<p>Test</p>', {
+                headers: { 'X-Frame-Options': 'DENY' }
+            });
+            
+            expect(res.headers['Content-Type']).toBe('text/html');
+            expect(res.headers['X-Frame-Options']).toBe('DENY');
+        });
+    });
+
+    describe('response.redirect()', () => {
+        it('should create 302 redirect by default', () => {
+            const res = response.redirect('/new-location');
+            
+            expect(res._isResponse).toBe(true);
+            expect(res.status).toBe(302);
+            expect(res.headers['Location']).toBe('/new-location');
+        });
+
+        it('should allow 301 permanent redirect', () => {
+            const res = response.redirect('/permanent', 301);
+            
+            expect(res.status).toBe(301);
+            expect(res.headers['Location']).toBe('/permanent');
+        });
+
+        it('should handle absolute URLs', () => {
+            const res = response.redirect('https://example.com/path');
+            
+            expect(res.headers['Location']).toBe('https://example.com/path');
+        });
+    });
+
+    describe('response.empty()', () => {
+        it.skip('should create empty 204 response by default', () => {
+            const res = response.empty();
+            
+            expect(res._isResponse).toBe(true);
+            expect(res.status).toBe(204);
+            expect(res.body).toBe('');
+        });
+
+        it.skip('should allow custom status', () => {
+            const res = response.empty(202);
+            
+            expect(res.status).toBe(202);
+        });
+    });
+});

package/packages/core-source/tests/session.test.js

@@ -0,0 +1,110 @@
+/**
+ * tests/session.test.js
+ * 
+ * Tests for the session module
+ * Uses emulated natives with in-memory Map
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { session } from '../index.js';
+
+describe('session', () => {
+    const SESSION_ID = 'test-session-123';
+
+    beforeEach(() => {
+        // setup.js clears sessions before each test
+    });
+
+    describe('set() and get()', () => {
+        it('should store and retrieve session value', () => {
+            session.set(SESSION_ID, 'username', 'john');
+            
+            expect(session.get(SESSION_ID, 'username')).toBe('john');
+        });
+
+        it('should keep sessions separate by ID', () => {
+            session.set('session-1', 'user', 'alice');
+            session.set('session-2', 'user', 'bob');
+            
+            expect(session.get('session-1', 'user')).toBe('alice');
+            expect(session.get('session-2', 'user')).toBe('bob');
+        });
+
+        it('should return empty for non-existing key', () => {
+            expect(session.get(SESSION_ID, 'nonexistent')).toBe('');
+        });
+
+        it('should store multiple keys per session', () => {
+            session.set(SESSION_ID, 'key1', 'value1');
+            session.set(SESSION_ID, 'key2', 'value2');
+            session.set(SESSION_ID, 'key3', 'value3');
+            
+            expect(session.get(SESSION_ID, 'key1')).toBe('value1');
+            expect(session.get(SESSION_ID, 'key2')).toBe('value2');
+            expect(session.get(SESSION_ID, 'key3')).toBe('value3');
+        });
+    });
+
+    describe('delete()', () => {
+        it('should delete specific key from session', () => {
+            session.set(SESSION_ID, 'toDelete', 'value');
+            session.set(SESSION_ID, 'toKeep', 'value');
+            
+            session.delete(SESSION_ID, 'toDelete');
+            
+            expect(session.get(SESSION_ID, 'toDelete')).toBe('');
+            expect(session.get(SESSION_ID, 'toKeep')).toBe('value');
+        });
+
+        it('should not fail when deleting non-existing key', () => {
+            expect(() => session.delete(SESSION_ID, 'nonexistent')).not.toThrow();
+        });
+    });
+
+    describe('clear()', () => {
+        it('should delete entire session', () => {
+            session.set(SESSION_ID, 'key1', 'value1');
+            session.set(SESSION_ID, 'key2', 'value2');
+            
+            session.clear(SESSION_ID);
+            
+            expect(session.get(SESSION_ID, 'key1')).toBe('');
+            expect(session.get(SESSION_ID, 'key2')).toBe('');
+        });
+
+        it('should not affect other sessions', () => {
+            session.set('session-1', 'data', 'one');
+            session.set('session-2', 'data', 'two');
+            
+            session.clear('session-1');
+            
+            expect(session.get('session-1', 'data')).toBe('');
+            expect(session.get('session-2', 'data')).toBe('two');
+        });
+    });
+
+    describe('real-world use cases', () => {
+        it('should handle auth token', () => {
+            const authSession = 'auth-abc123';
+            const token = 'eyJhbGciOiJIUzI1NiJ9.test';
+            
+            session.set(authSession, 'token', token);
+            session.set(authSession, 'expires', '2025-12-31');
+            
+            expect(session.get(authSession, 'token')).toBe(token);
+            expect(session.get(authSession, 'expires')).toBe('2025-12-31');
+        });
+
+        it('should handle shopping cart', () => {
+            const cartSession = 'cart-xyz789';
+            const cart = JSON.stringify([
+                { id: 1, qty: 2 },
+                { id: 2, qty: 1 }
+            ]);
+            
+            session.set(cartSession, 'items', cart);
+            
+            const retrieved = JSON.parse(session.get(cartSession, 'items'));
+            expect(retrieved).toHaveLength(2);
+        });
+    });
+});