relayx-webjs 1.0.5 → 1.1.0

package/tests/test_kv.js

@@ -0,0 +1,679 @@
+import { Realtime } from "../realtime/realtime.js";
+import { KVStore } from "../realtime/kv_storage.js";
+import { test, before, after } from 'node:test';
+import assert from 'node:assert';
+
+let realtime;
+let kvStore;
+const testNamespace = 'test-kv-store';
+
+before(async () => {
+    // Initialize Realtime connection for KV testing
+    realtime = new Realtime({
+        api_key: process.env.AUTH_JWT,
+        secret: process.env.AUTH_SECRET
+    });
+
+    await realtime.init({
+        staging: true,
+        opts: {
+            debug: false
+        }
+    });
+
+    await realtime.connect();
+
+    // Small delay to ensure connection is fully established
+    await new Promise(resolve => setTimeout(resolve, 2500));
+
+    // Create KV store instance using Realtime's initKVStore method
+    kvStore = await realtime.initKVStore();
+
+    if (!kvStore) {
+        throw new Error("Failed to initialize KV store");
+    }
+
+    // Verify KV store is working
+    const testInit = await kvStore.testIsKvStoreInitialized();
+    if (!testInit) {
+        throw new Error("KV store not properly initialized");
+    }
+});
+
+after(async () => {
+    // Clean up: delete all test keys
+    try {
+        const keys = await kvStore.keys();
+        for (const key of keys) {
+            await kvStore.delete(key);
+        }
+    } catch (err) {
+        console.error("Cleanup error:", err);
+    }
+
+    realtime.close();
+});
+
+// Constructor and Initialization Tests
+test("Constructor - successful instantiation", () => {
+    const kv = new KVStore({
+        namespace: 'test',
+        jetstream: realtime.testGetJetstream()
+    });
+
+    assert.notStrictEqual(kv, null);
+    assert.notStrictEqual(kv, undefined);
+});
+
+test("Test helper - testGetNamespace()", () => {
+    const namespace = kvStore.testGetNamespace();
+    assert.notStrictEqual(namespace, undefined);
+    assert.notStrictEqual(namespace, null);
+});
+
+test("Test helper - testIsKvStoreInitialized()", () => {
+    const isInitialized = kvStore.testIsKvStoreInitialized();
+    assert.strictEqual(isInitialized, true);
+});
+
+test("init() - validates namespace", async () => {
+    const kv = new KVStore({
+        namespace: null,
+        jetstream: realtime.testGetJetstream()
+    });
+
+    await assert.rejects(async () => {
+        await kv.init();
+    },
+    new Error("$namespace cannot be null / undefined / empty"),
+    "Expected error was not thrown");
+});
+
+test("init() - validates empty namespace", async () => {
+    const kv = new KVStore({
+        namespace: "",
+        jetstream: realtime.testGetJetstream()
+    });
+
+    await assert.rejects(async () => {
+        await kv.init();
+    },
+    new Error("$namespace cannot be null / undefined / empty"),
+    "Expected error was not thrown");
+});
+
+test("Test helper - testValidateInput()", () => {
+    const kv = new KVStore({
+        namespace: "",
+        jetstream: realtime.testGetJetstream()
+    });
+
+    const validateInput = kv.testValidateInput();
+
+    assert.throws(() => {
+        validateInput();
+    },
+    new Error("$namespace cannot be null / undefined / empty"),
+    "Expected error was not thrown");
+});
+
+// Key Validation Tests
+test("Test helper - testValidateKey() with null", () => {
+    const validateKey = kvStore.testValidateKey();
+
+    assert.throws(() => {
+        validateKey(null);
+    },
+    new Error("$key cannot be null / undefined"),
+    "Expected error for null key");
+});
+
+test("Test helper - testValidateKey() with undefined", () => {
+    const validateKey = kvStore.testValidateKey();
+
+    assert.throws(() => {
+        validateKey(undefined);
+    },
+    new Error("$key cannot be null / undefined"),
+    "Expected error for undefined key");
+});
+
+test("Test helper - testValidateKey() with non-string", () => {
+    const validateKey = kvStore.testValidateKey();
+
+    assert.throws(() => {
+        validateKey(123);
+    },
+    new Error("$key cannot be a string"),
+    "Expected error for number key");
+
+    assert.throws(() => {
+        validateKey({});
+    },
+    new Error("$key cannot be a string"),
+    "Expected error for object key");
+
+    assert.throws(() => {
+        validateKey([]);
+    },
+    new Error("$key cannot be a string"),
+    "Expected error for array key");
+});
+
+test("Test helper - testValidateKey() with empty string", () => {
+    const validateKey = kvStore.testValidateKey();
+
+    assert.throws(() => {
+        validateKey("");
+    },
+    new Error("$key cannot be empty"),
+    "Expected error for empty key");
+});
+
+test("Test helper - testValidateKey() with valid string", () => {
+    const validateKey = kvStore.testValidateKey();
+
+    // Should not throw
+    validateKey("valid-key");
+    validateKey("user.123");
+    validateKey("test_key");
+    validateKey("user/profile/data");
+    validateKey("config=value");
+    assert.ok(true);
+});
+
+test("Test helper - testValidateKey() with invalid characters", () => {
+    const validateKey = kvStore.testValidateKey();
+
+    // Should throw for invalid characters
+    assert.throws(() => {
+        validateKey("user:123");
+    },
+    new Error("$key can only contain alphanumeric characters and the following: _ - . = /"),
+    "Expected error for colon in key");
+
+    assert.throws(() => {
+        validateKey("user@domain");
+    },
+    new Error("$key can only contain alphanumeric characters and the following: _ - . = /"),
+    "Expected error for @ in key");
+
+    assert.throws(() => {
+        validateKey("key with spaces");
+    },
+    new Error("$key can only contain alphanumeric characters and the following: _ - . = /"),
+    "Expected error for spaces in key");
+
+    assert.throws(() => {
+        validateKey("key#hash");
+    },
+    new Error("$key can only contain alphanumeric characters and the following: _ - . = /"),
+    "Expected error for hash in key");
+});
+
+// Value Validation Tests
+test("Test helper - testValidateValue() with valid types", () => {
+    const validateValue = kvStore.testValidateValue();
+
+    // Should not throw for valid types
+    validateValue(null);
+    validateValue("string");
+    validateValue(42);
+    validateValue(3.14);
+    validateValue(true);
+    validateValue(false);
+    validateValue([1, 2, 3]);
+    validateValue({ foo: "bar" });
+    assert.ok(true);
+});
+
+test("Test helper - testValidateValue() - currently allows functions and symbols", () => {
+    const validateValue = kvStore.testValidateValue();
+
+    // Note: Current implementation allows functions and symbols due to #isJSON implementation
+    // Not throwing errors is expected behavior
+    validateValue(() => {});
+    validateValue(Symbol('test'));
+    assert.ok(true);
+});
+
+// JSON Validation Tests
+test("Test helper - testIsJSON()", () => {
+    const isJSON = kvStore.testIsJSON();
+
+    assert.strictEqual(isJSON({ foo: "bar" }), true);
+    assert.strictEqual(isJSON({ nested: { obj: true } }), true);
+    assert.strictEqual(isJSON([1, 2, 3]), true);
+    assert.strictEqual(isJSON("string"), true);
+    assert.strictEqual(isJSON(123), true);
+    assert.strictEqual(isJSON(null), true);
+});
+
+// Real KV Operations Tests
+test("put() - validates key parameter", async () => {
+    await assert.rejects(async () => {
+        await kvStore.put(null, "value");
+    },
+    new Error("$key cannot be null / undefined"),
+    "Expected error for null key");
+
+    await assert.rejects(async () => {
+        await kvStore.put(undefined, "value");
+    },
+    new Error("$key cannot be null / undefined"),
+    "Expected error for undefined key");
+
+    await assert.rejects(async () => {
+        await kvStore.put("", "value");
+    },
+    new Error("$key cannot be empty"),
+    "Expected error for empty key");
+
+    await assert.rejects(async () => {
+        await kvStore.put(123, "value");
+    },
+    new Error("$key cannot be a string"),
+    "Expected error for non-string key");
+});
+
+test("put() - validation allows functions and symbols but storage may fail", async () => {
+    // Note: Current implementation's validation allows functions and symbols due to #isJSON implementation
+    // But actual storage to NATS will fail during JSON.stringify
+    // We're just testing that validation doesn't throw - not that storage works
+    const validateValue = kvStore.testValidateValue();
+
+    // These pass validation
+    validateValue(() => {});
+    validateValue(Symbol('test'));
+
+    assert.ok(true);
+});
+
+test("put() and get() - string value", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    console.log(kvStore)
+
+    const key = "test.string";
+    const value = "Hello World!";
+
+    await kvStore.put(key, value);
+    const result = await kvStore.get(key);
+
+    assert.strictEqual(result, value);
+
+    // Cleanup
+    await kvStore.delete(key);
+});
+
+test("put() and get() - number value", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    const key = "test.number";
+    const value = 42;
+
+    await kvStore.put(key, value);
+    const result = await kvStore.get(key);
+
+    assert.strictEqual(result, value);
+
+    await kvStore.delete(key);
+});
+
+test("put() and get() - boolean value", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    const key = "test.boolean";
+    const value = true;
+
+    await kvStore.put(key, value);
+    const result = await kvStore.get(key);
+
+    assert.strictEqual(result, value);
+
+    await kvStore.delete(key);
+});
+
+test("put() and get() - null value", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    const key = "test.null";
+    const value = null;
+
+    await kvStore.put(key, value);
+    const result = await kvStore.get(key);
+
+    assert.strictEqual(result, value);
+
+    await kvStore.delete(key);
+});
+
+test("put() and get() - array value", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    const key = "test.array";
+    const value = [1, 2, 3, "four", { five: 5 }];
+
+    await kvStore.put(key, value);
+    const result = await kvStore.get(key);
+
+    assert.deepStrictEqual(result, value);
+
+    await kvStore.delete(key);
+});
+
+test("put() and get() - object value", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    const key = "test.object";
+    const value = {
+        name: "Alice",
+        age: 30,
+        active: true,
+        tags: ["user", "admin"]
+    };
+
+    await kvStore.put(key, value);
+    const result = await kvStore.get(key);
+
+    assert.deepStrictEqual(result, value);
+
+    await kvStore.delete(key);
+});
+
+test("put() - update existing key", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    const key = "test.update";
+
+    await kvStore.put(key, "initial value");
+    let result = await kvStore.get(key);
+    assert.strictEqual(result, "initial value");
+
+    await kvStore.put(key, "updated value");
+    result = await kvStore.get(key);
+    assert.strictEqual(result, "updated value");
+
+    await kvStore.delete(key);
+});
+
+test("get() - validates key parameter", async () => {
+    await assert.rejects(async () => {
+        await kvStore.get(null);
+    },
+    new Error("$key cannot be null / undefined"),
+    "Expected error for null key");
+
+    await assert.rejects(async () => {
+        await kvStore.get(undefined);
+    },
+    new Error("$key cannot be null / undefined"),
+    "Expected error for undefined key");
+
+    await assert.rejects(async () => {
+        await kvStore.get("");
+    },
+    new Error("$key cannot be empty"),
+    "Expected error for empty key");
+
+    await assert.rejects(async () => {
+        await kvStore.get(123);
+    },
+    new Error("$key cannot be a string"),
+    "Expected error for non-string key");
+});
+
+test("get() - returns null for non-existent key", async () => {
+    const result = await kvStore.get("non-existent-key-xyz");
+    assert.strictEqual(result, null);
+});
+
+test("delete() - validates key parameter", async () => {
+    await assert.rejects(async () => {
+        await kvStore.delete(null);
+    },
+    new Error("$key cannot be null / undefined"),
+    "Expected error for null key");
+
+    await assert.rejects(async () => {
+        await kvStore.delete(undefined);
+    },
+    new Error("$key cannot be null / undefined"),
+    "Expected error for undefined key");
+
+    await assert.rejects(async () => {
+        await kvStore.delete("");
+    },
+    new Error("$key cannot be empty"),
+    "Expected error for empty key");
+
+    await assert.rejects(async () => {
+        await kvStore.delete(123);
+    },
+    new Error("$key cannot be a string"),
+    "Expected error for non-string key");
+});
+
+test("delete() - successfully deletes key", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    const key = "test.delete";
+
+    await kvStore.put(key, "to be deleted");
+    let result = await kvStore.get(key);
+    assert.strictEqual(result, "to be deleted");
+
+    await kvStore.delete(key);
+    result = await kvStore.get(key);
+    assert.strictEqual(result, null);
+});
+
+test("delete() - deleting non-existent key does not throw", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+    
+    // Should not throw error
+    await kvStore.delete("non-existent-key-to-delete");
+    assert.ok(true);
+});
+
+test("keys() - returns array of keys", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    // Put multiple keys
+    await kvStore.put("keys.test1", "value1");
+    await kvStore.put("keys.test2", "value2");
+    await kvStore.put("keys.test3", "value3");
+
+    const keys = await kvStore.keys();
+
+    assert.strictEqual(Array.isArray(keys), true);
+    assert.ok(keys.includes("keys.test1"));
+    assert.ok(keys.includes("keys.test2"));
+    assert.ok(keys.includes("keys.test3"));
+
+    // Cleanup
+    await kvStore.delete("keys.test1");
+    await kvStore.delete("keys.test2");
+    await kvStore.delete("keys.test3");
+});
+
+test("keys() - returns empty array when no keys exist", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+    
+    // Clean up all keys first
+    const allKeys = await kvStore.keys();
+    for (const key of allKeys) {
+        await kvStore.delete(key);
+    }
+
+    const keys = await kvStore.keys();
+    assert.strictEqual(Array.isArray(keys), true);
+    assert.strictEqual(keys.length, 0);
+});
+
+// Integration Test - Full Workflow
+test("Integration - full KV workflow", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    const prefix = "integration.";
+
+    // 1. Put multiple keys with different value types
+    await kvStore.put(`${prefix}user.1`, { name: "Alice", age: 30 });
+    await kvStore.put(`${prefix}user.2`, { name: "Bob", age: 25 });
+    await kvStore.put(`${prefix}counter`, 42);
+    await kvStore.put(`${prefix}active`, true);
+    await kvStore.put(`${prefix}tags`, ["test", "integration"]);
+
+    // 2. Get all keys
+    const allKeys = await kvStore.keys();
+    assert.ok(allKeys.includes(`${prefix}user.1`));
+    assert.ok(allKeys.includes(`${prefix}user.2`));
+    assert.ok(allKeys.includes(`${prefix}counter`));
+    assert.ok(allKeys.includes(`${prefix}active`));
+    assert.ok(allKeys.includes(`${prefix}tags`));
+
+    // 3. Retrieve and verify values
+    const user1 = await kvStore.get(`${prefix}user.1`);
+    assert.deepStrictEqual(user1, { name: "Alice", age: 30 });
+
+    const counter = await kvStore.get(`${prefix}counter`);
+    assert.strictEqual(counter, 42);
+
+    const active = await kvStore.get(`${prefix}active`);
+    assert.strictEqual(active, true);
+
+    const tags = await kvStore.get(`${prefix}tags`);
+    assert.deepStrictEqual(tags, ["test", "integration"]);
+
+    // 4. Update a value
+    await kvStore.put(`${prefix}user.1`, { name: "Alice", age: 31 });
+    const updatedUser = await kvStore.get(`${prefix}user.1`);
+    assert.strictEqual(updatedUser.age, 31);
+
+    // 5. Delete keys
+    await kvStore.delete(`${prefix}user.2`);
+    const deletedUser = await kvStore.get(`${prefix}user.2`);
+    assert.strictEqual(deletedUser, null);
+
+    // 6. Verify remaining keys
+    const remainingKeys = await kvStore.keys();
+    assert.ok(remainingKeys.includes(`${prefix}user.1`));
+    assert.ok(!remainingKeys.includes(`${prefix}user.2`));
+
+    // Cleanup
+    await kvStore.delete(`${prefix}user.1`);
+    await kvStore.delete(`${prefix}counter`);
+    await kvStore.delete(`${prefix}active`);
+    await kvStore.delete(`${prefix}tags`);
+});
+
+// Edge Cases
+test("Edge case - put and get with special characters in key", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    const key = "test.special-chars_123";
+    const value = { data: "special" };
+
+    await kvStore.put(key, value);
+    const result = await kvStore.get(key);
+
+    assert.deepStrictEqual(result, value);
+
+    await kvStore.delete(key);
+});
+
+test("Edge case - put and get with nested objects", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    const key = "test.nested";
+    const value = {
+        level1: {
+            level2: {
+                level3: {
+                    deep: "value"
+                }
+            }
+        }
+    };
+
+    await kvStore.put(key, value);
+    const result = await kvStore.get(key);
+
+    assert.deepStrictEqual(result, value);
+
+    await kvStore.delete(key);
+});
+
+test("Edge case - put and get with empty object", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    const key = "test.empty-object";
+    const value = {};
+
+    await kvStore.put(key, value);
+    const result = await kvStore.get(key);
+
+    assert.deepStrictEqual(result, value);
+
+    await kvStore.delete(key);
+});
+
+test("Edge case - put and get with empty array", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    const key = "test.empty-array";
+    const value = [];
+
+    await kvStore.put(key, value);
+    const result = await kvStore.get(key);
+
+    assert.deepStrictEqual(result, value);
+
+    await kvStore.delete(key);
+});
+
+test("Edge case - put and get with zero", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    const key = "test.zero";
+    const value = 0;
+
+    await kvStore.put(key, value);
+    const result = await kvStore.get(key);
+
+    assert.strictEqual(result, value);
+
+    await kvStore.delete(key);
+});
+
+test("Edge case - put and get with false", async () => {
+    // Create fresh KV store for this test
+    const kvStore = await realtime.initKVStore();
+
+    const key = "test.false";
+    const value = false;
+
+    await kvStore.put(key, value);
+    const result = await kvStore.get(key);
+
+    assert.strictEqual(result, value);
+
+    await kvStore.delete(key);
+});