hola-server 1.0.10 → 2.0.1

package/test/core/type.js

@@ -0,0 +1,216 @@
+const { strictEqual, throws } = require('assert');
+const { get_type, register_type } = require('../../core/type');
+
+describe('type', function () {
+    describe('get_type', function () {
+        it('should throw for unregistered type', function () {
+            throws(() => get_type('unknown_type'));
+        });
+
+        it('should return registered type', function () {
+            const type = get_type('string');
+            strictEqual(typeof type.convert, 'function');
+        });
+    });
+
+    describe('string type', function () {
+        it('should convert and trim string', function () {
+            const type = get_type('string');
+            strictEqual(type.convert('  hello  ').value, 'hello');
+        });
+
+        it('should handle empty values', function () {
+            const type = get_type('string');
+            strictEqual(type.convert('').value, '');
+            strictEqual(type.convert(null).value, '');
+        });
+    });
+
+    describe('boolean type', function () {
+        it('should convert true values', function () {
+            const type = get_type('boolean');
+            strictEqual(type.convert(true).value, true);
+            strictEqual(type.convert('true').value, true);
+        });
+
+        it('should convert false values', function () {
+            const type = get_type('boolean');
+            strictEqual(type.convert(false).value, false);
+            strictEqual(type.convert('false').value, false);
+        });
+
+        it('should error for invalid boolean', function () {
+            const type = get_type('boolean');
+            strictEqual(type.convert('yes').err !== undefined, true);
+        });
+    });
+
+    describe('int type', function () {
+        it('should convert valid integers', function () {
+            const type = get_type('int');
+            strictEqual(type.convert(42).value, 42);
+            strictEqual(type.convert('42').value, 42);
+            strictEqual(type.convert(-10).value, -10);
+        });
+
+        it('should error for non-integers', function () {
+            const type = get_type('int');
+            strictEqual(type.convert(3.14).err !== undefined, true);
+            strictEqual(type.convert('abc').err !== undefined, true);
+        });
+    });
+
+    describe('uint type', function () {
+        it('should convert positive integers', function () {
+            const type = get_type('uint');
+            strictEqual(type.convert(42).value, 42);
+            strictEqual(type.convert(0).value, 0);
+        });
+
+        it('should error for negative integers', function () {
+            const type = get_type('uint');
+            strictEqual(type.convert(-1).err !== undefined, true);
+        });
+    });
+
+    describe('float type', function () {
+        it('should convert and round to 2 decimals', function () {
+            const type = get_type('float');
+            strictEqual(type.convert(3.14159).value, 3.14);
+            strictEqual(type.convert('2.999').value, 3);
+        });
+
+        it('should error for non-numbers', function () {
+            const type = get_type('float');
+            strictEqual(type.convert('abc').err !== undefined, true);
+        });
+    });
+
+    describe('ufloat type', function () {
+        it('should convert positive floats', function () {
+            const type = get_type('ufloat');
+            strictEqual(type.convert(3.14).value, 3.14);
+        });
+
+        it('should error for negative floats', function () {
+            const type = get_type('ufloat');
+            strictEqual(type.convert(-3.14).err !== undefined, true);
+        });
+    });
+
+    describe('number type', function () {
+        it('should convert any number', function () {
+            const type = get_type('number');
+            strictEqual(type.convert(42).value, 42);
+            strictEqual(type.convert(-3.14).value, -3.14);
+            strictEqual(type.convert('100').value, 100);
+        });
+    });
+
+    describe('email type', function () {
+        it('should accept valid emails', function () {
+            const type = get_type('email');
+            strictEqual(type.convert('test@example.com').value, 'test@example.com');
+        });
+
+        it('should reject invalid emails', function () {
+            const type = get_type('email');
+            strictEqual(type.convert('invalid-email').err !== undefined, true);
+        });
+    });
+
+    describe('url type', function () {
+        it('should accept valid URLs', function () {
+            const type = get_type('url');
+            strictEqual(type.convert('https://example.com').value, 'https://example.com');
+        });
+
+        it('should reject invalid URLs', function () {
+            const type = get_type('url');
+            strictEqual(type.convert('not-a-url').err !== undefined, true);
+        });
+    });
+
+    describe('array type', function () {
+        it('should split comma-separated string', function () {
+            const type = get_type('array');
+            const result = type.convert('a,b,c').value;
+            strictEqual(result.length, 3);
+            strictEqual(result.join(''), 'abc');
+        });
+
+        it('should pass through arrays', function () {
+            const type = get_type('array');
+            const result = type.convert(['a', 'b']).value;
+            strictEqual(result.length, 2);
+        });
+    });
+
+    describe('json type', function () {
+        it('should pass through objects', function () {
+            const type = get_type('json');
+            const obj = { a: 1 };
+            strictEqual(type.convert(obj).value, obj);
+        });
+
+        it('should parse JSON strings', function () {
+            const type = get_type('json');
+            const result = type.convert('{"a":1}').value;
+            strictEqual(result.a, 1);
+        });
+
+        it('should error for invalid JSON', function () {
+            const type = get_type('json');
+            strictEqual(type.convert('not json').err !== undefined, true);
+        });
+    });
+
+    describe('time type', function () {
+        it('should accept valid time formats', function () {
+            const type = get_type('time');
+            strictEqual(type.convert('12:30').value, '12:30');
+            strictEqual(type.convert('23:59:59').value, '23:59:59');
+        });
+
+        it('should reject invalid time formats', function () {
+            const type = get_type('time');
+            strictEqual(type.convert('25:00').err !== undefined, true);
+        });
+    });
+
+    describe('ip_address type', function () {
+        it('should accept valid IP addresses', function () {
+            const type = get_type('ip_address');
+            strictEqual(type.convert('192.168.1.1').value, '192.168.1.1');
+        });
+
+        it('should reject invalid IP addresses', function () {
+            const type = get_type('ip_address');
+            strictEqual(type.convert('256.1.1.1').err !== undefined, true);
+            strictEqual(type.convert('not-an-ip').err !== undefined, true);
+        });
+    });
+
+    describe('slug type', function () {
+        it('should convert to slug format', function () {
+            const type = get_type('slug');
+            strictEqual(type.convert('Hello World!').value, 'hello-world');
+            strictEqual(type.convert('  Multiple   Spaces  ').value, 'multiple-spaces');
+        });
+    });
+
+    describe('age type', function () {
+        it('should accept valid ages (0-200)', function () {
+            const type = get_type('age');
+            strictEqual(type.convert(25).value, 25);
+            strictEqual(type.convert(0).value, 0);
+            strictEqual(type.convert(200).value, 200);
+        });
+
+        it('should reject invalid ages', function () {
+            const type = get_type('age');
+            strictEqual(type.convert(-1).err !== undefined, true);
+            strictEqual(type.convert(201).err !== undefined, true);
+        });
+    });
+});

package/test/core/validate.js

@@ -0,0 +1,67 @@
+const { strictEqual, deepStrictEqual } = require('assert');
+const { is_undefined, has_value, validate_required_fields } = require('../../core/validate');
+
+describe('validate', function () {
+    describe('is_undefined', function () {
+        it('should return true for undefined', function () {
+            strictEqual(is_undefined(undefined), true);
+        });
+
+        it('should return false for null', function () {
+            strictEqual(is_undefined(null), false);
+        });
+
+        it('should return false for defined values', function () {
+            strictEqual(is_undefined(0), false);
+            strictEqual(is_undefined(''), false);
+            strictEqual(is_undefined(false), false);
+        });
+    });
+
+    describe('has_value', function () {
+        it('should return false for null', function () {
+            strictEqual(has_value(null), false);
+        });
+
+        it('should return false for undefined', function () {
+            strictEqual(has_value(undefined), false);
+        });
+
+        it('should return false for NaN', function () {
+            strictEqual(has_value(NaN), false);
+        });
+
+        it('should return false for empty string', function () {
+            strictEqual(has_value(''), false);
+            strictEqual(has_value('   '), false);
+        });
+
+        it('should return true for valid values', function () {
+            strictEqual(has_value(0), true);
+            strictEqual(has_value(false), true);
+            strictEqual(has_value('hello'), true);
+            strictEqual(has_value([]), true);
+            strictEqual(has_value({}), true);
+        });
+    });
+
+    describe('validate_required_fields', function () {
+        it('should return empty array when all fields present', function () {
+            const obj = { name: 'John', age: 30 };
+            const result = validate_required_fields(obj, ['name', 'age']);
+            strictEqual(result.length, 0);
+        });
+
+        it('should return missing field names', function () {
+            const obj = { name: 'John' };
+            const result = validate_required_fields(obj, ['name', 'age', 'email']);
+            deepStrictEqual(result, ['age', 'email']);
+        });
+
+        it('should treat empty strings as missing', function () {
+            const obj = { name: '', age: 30 };
+            const result = validate_required_fields(obj, ['name', 'age']);
+            deepStrictEqual(result, ['name']);
+        });
+    });
+});

package/test/db/db-ops.js

@@ -0,0 +1,99 @@
+const { strictEqual, deepStrictEqual } = require("assert");
+const { get_db, oid_query, oid_queries, bulk_update, log_error } = require("../../db/db");
+const { init_settings, get_settings } = require("../../setting");
+
+const col = "user_ops";
+const db = get_db();
+
+describe("mongodb advanced ops", function () {
+    beforeEach(async function () {
+        await db.delete(col, {});
+    });
+
+    afterEach(async function () {
+        await db.delete(col, {});
+    });
+
+    it("bulk_update should upsert by attrs", async function () {
+        const items = [
+            { uid: 1, name: "first" },
+            { uid: 1, name: "second" },
+            { uid: 2, name: "third" }
+        ];
+
+        const collection = db.get_col(col);
+        await bulk_update(collection, items, ["uid"]);
+
+        const docs = await db.find(col, {});
+        strictEqual(docs.length, 2);
+        const [first] = docs.filter(d => d.uid === 1);
+        strictEqual(first.name, "second");
+    });
+
+    it("find_page should paginate deterministically", async function () {
+        for (let i = 1; i <= 12; i++) {
+            await db.create(col, { name: `user${i}`, age: i });
+        }
+
+        const page = await db.find_page(col, {}, { age: -1 }, 2, 5, { name: 1, age: 1 });
+        strictEqual(page.length, 5);
+        deepStrictEqual(page.map(p => p.age), [7, 6, 5, 4, 3]);
+        strictEqual(page[0].name, "user7");
+    });
+
+    it("find_sort should honor projection", async function () {
+        await db.create(col, { name: "a", age: 30 });
+        await db.create(col, { name: "b", age: 10 });
+        await db.create(col, { name: "c", age: 20 });
+
+        const sorted = await db.find_sort(col, {}, { age: 1 }, { age: 1 });
+        deepStrictEqual(sorted.map(s => s.age), [10, 20, 30]);
+        strictEqual(sorted[0].name, undefined);
+    });
+
+    it("push/pull/add_to_set should mutate arrays", async function () {
+        await db.create(col, { name: "tags", tags: ["a"] });
+
+        await db.push(col, { name: "tags" }, { tags: "b" });
+        let doc = await db.find_one(col, { name: "tags" });
+        deepStrictEqual(doc.tags.sort(), ["a", "b"]);
+
+        await db.add_to_set(col, { name: "tags" }, { tags: "b" });
+        doc = await db.find_one(col, { name: "tags" });
+        deepStrictEqual(doc.tags.sort(), ["a", "b"]);
+
+        await db.pull(col, { name: "tags" }, { tags: "a" });
+        doc = await db.find_one(col, { name: "tags" });
+        deepStrictEqual(doc.tags, ["b"]);
+    });
+
+    it("sum should aggregate numeric fields", async function () {
+        await db.create(col, { name: "p1", points: 5 });
+        await db.create(col, { name: "p2", points: 15 });
+        await db.create(col, { name: "p3", points: 10 });
+
+        const total = await db.sum(col, {}, "points");
+        strictEqual(total, 30);
+    });
+
+    it("oid_query helpers should return null for invalid ids", function () {
+        strictEqual(oid_query("invalid-id"), null);
+        strictEqual(oid_queries(["invalid-id"]), null);
+    });
+
+    it("log_error should persist when save_db enabled", async function () {
+        const original = get_settings();
+        const log_col = "log_test";
+        init_settings({ ...original, log: { ...original.log, save_db: true, log_level: 0, col_log: log_col } });
+
+        await db.delete(log_col, {});
+        log_error("database", "failure case", { code: 500 });
+        await new Promise((res) => setTimeout(res, 50));
+        const logs = await db.find(log_col, { msg: "failure case" });
+        strictEqual(logs.length, 1);
+        strictEqual(logs[0].code, 500);
+
+        await db.delete(log_col, {});
+        init_settings(original);
+    });
+});