@mblaney/holster 1.0.16 → 1.0.17

package/test/system/promise-wrapper.test.js

@@ -0,0 +1,47 @@
+import fs from "fs"
+import {Server} from "mock-socket"
+import {describe, test} from "node:test"
+import assert from "node:assert/strict"
+import Holster from "../../src/holster.js"
+
+describe("system - promise wrapped calls", () => {
+  const wss = new Server("ws://localhost:9004")
+  const holster = Holster({file: "test/system/promise-wrapper", wss: wss})
+
+  test("promise wrapped get returns null for missing key", async t => {
+    const data = await new Promise(res => {
+      holster.get("missing", res)
+    })
+    assert.equal(data, null)
+  })
+
+  test("promise wrapped get returns data for existing key", async t => {
+    await new Promise(res => {
+      holster.get("key").put({value: "test"}, res)
+    })
+
+    const data = await new Promise(res => {
+      holster.get("key", res)
+    })
+    assert.notEqual(data, null)
+    assert.equal(data.value, "test")
+  })
+
+  test("promise wrapped next returns null for missing nested key", async t => {
+    const data = await new Promise(res => {
+      holster.get("key1").next("missing", res)
+    })
+    assert.equal(data, null)
+  })
+
+  test("cleanup", (t, done) => {
+    fs.rm(
+      "test/system/promise-wrapper",
+      {recursive: true, force: true},
+      err => {
+        assert.equal(err, null)
+        done()
+      },
+    )
+  })
+})

package/test/system/user-chained-on.test.js

@@ -0,0 +1,56 @@
+import fs from "fs"
+import {Server} from "mock-socket"
+import {describe, test} from "node:test"
+import assert from "node:assert/strict"
+import Holster from "../../src/holster.js"
+
+describe("system - user chained get with on", () => {
+  const wss = new Server("ws://localhost:9012")
+  const holster = Holster({file: "test/system/user-chained-on", wss: wss})
+  const user = holster.user()
+
+  test("user create and auth", (t, done) => {
+    user.create("testuser", "password", err => {
+      assert.equal(err, null)
+      user.auth("testuser", "password", err => {
+        assert.equal(err, null)
+        done()
+      })
+    })
+  })
+
+  test("on listener fires with null when no data exists", (t, done) => {
+    user.get("key").on(data => {
+      // This is the actual behavior - on fires with null for non-existent keys
+      assert.equal(data, null)
+      done()
+    }, true)
+  })
+
+  test("put then on listener receives data", (t, done) => {
+    // Put data first
+    user.get("key2").put({value: "test"}, err => {
+      assert.equal(err, null)
+
+      // Then set up listener - should get the existing data
+      setTimeout(() => {
+        user.get("key2").on(data => {
+          assert.notEqual(data, null)
+          assert.deepEqual(data, {value: "test"})
+          done()
+        }, true)
+      }, 50)
+    })
+  })
+
+  test("cleanup", (t, done) => {
+    fs.rm(
+      "test/system/user-chained-on",
+      {recursive: true, force: true},
+      err => {
+        assert.equal(err, null)
+        done()
+      },
+    )
+  })
+})

package/test/system/user-concurrent-listeners.test.js

@@ -0,0 +1,140 @@
+import fs from "fs"
+import {Server} from "mock-socket"
+import {describe, test} from "node:test"
+import assert from "node:assert/strict"
+import Holster from "../../src/holster.js"
+
+describe("system - user concurrent listeners", () => {
+  const wss = new Server("ws://localhost:9015")
+  const holster = Holster({
+    file: "test/system/user-concurrent-listeners",
+    wss: wss,
+  })
+  const user = holster.user()
+
+  test("user create and auth", (t, done) => {
+    user.create("testuser", "password", err => {
+      assert.equal(err, null)
+      user.auth("testuser", "password", err => {
+        assert.equal(err, null)
+        done()
+      })
+    })
+  })
+
+  test("multiple listeners on same path receive data", (t, done) => {
+    let listener1Called = false
+    let listener2Called = false
+
+    user.get("key").put({value: "test"}, err => {
+      assert.equal(err, null)
+
+      // Set up two listeners on the same path
+      user.get("key").on(data => {
+        listener1Called = true
+        assert.notEqual(data, null)
+        assert.deepEqual(data, {value: "test"})
+        checkComplete()
+      }, true)
+
+      user.get("key").on(data => {
+        listener2Called = true
+        assert.notEqual(data, null)
+        assert.deepEqual(data, {value: "test"})
+        checkComplete()
+      }, true)
+
+      function checkComplete() {
+        if (listener1Called && listener2Called) {
+          done()
+        }
+      }
+    })
+  })
+
+  test("nested listeners on parent and child paths", (t, done) => {
+    let parentCalled = false
+    let childCalled = false
+
+    user.get("parent").put({value: "parent-value"}, err => {
+      assert.equal(err, null)
+
+      user
+        .get("parent")
+        .next("child")
+        .put({value: "child-value"}, err => {
+          assert.equal(err, null)
+
+          // Listen on parent
+          user.get("parent").on(data => {
+            parentCalled = true
+            assert.notEqual(data, null)
+            assert.equal(data.value, "parent-value")
+            // Parent includes child as a rel
+            assert.notEqual(data.child, undefined)
+            checkComplete()
+          }, true)
+
+          // Listen on child
+          user
+            .get("parent")
+            .next("child")
+            .on(data => {
+              childCalled = true
+              assert.notEqual(data, null)
+              assert.deepEqual(data, {value: "child-value"})
+              checkComplete()
+            }, true)
+
+          function checkComplete() {
+            if (parentCalled && childCalled) {
+              done()
+            }
+          }
+        })
+    })
+  })
+
+  test("listener race condition - data before and after listener setup", (t, done) => {
+    const results = []
+
+    // Put data first
+    user.get("race").put({value: "first"}, err => {
+      assert.equal(err, null)
+
+      // Set up listener with _get=true to read existing data
+      user.get("race").on(data => {
+        results.push(data?.value)
+      }, true)
+
+      // Immediately put new data
+      setTimeout(() => {
+        user.get("race").put({value: "second"}, err => {
+          assert.equal(err, null)
+
+          setTimeout(() => {
+            // Should have received both values
+            assert.equal(
+              results.length >= 1,
+              true,
+              "Should receive at least initial value",
+            )
+            assert.equal(results[0], "first", "First value should be 'first'")
+            done()
+          }, 100)
+        })
+      }, 50)
+    })
+  })
+
+  test("cleanup", (t, done) => {
+    fs.rm(
+      "test/system/user-concurrent-listeners",
+      {recursive: true, force: true},
+      err => {
+        assert.equal(err, null)
+        done()
+      },
+    )
+  })
+})

package/test/system/user-listener-before-data.test.js

@@ -0,0 +1,64 @@
+import fs from "fs"
+import {Server} from "mock-socket"
+import {describe, test} from "node:test"
+import assert from "node:assert/strict"
+import Holster from "../../src/holster.js"
+
+describe("system - user listener before data", () => {
+  const wss = new Server("ws://localhost:9017")
+  const holster = Holster({
+    file: "test/system/user-listener-before-data",
+    wss: wss,
+  })
+  const user = holster.user()
+
+  test("user create and auth", (t, done) => {
+    user.create("testuser", "password", err => {
+      assert.equal(err, null)
+      user.auth("testuser", "password", err => {
+        assert.equal(err, null)
+        done()
+      })
+    })
+  })
+
+  test("listener set up before data exists receives data when populated", (t, done) => {
+    const results = []
+
+    // Set up listener first before data exists
+    user.get("testkey").on(data => {
+      results.push(data)
+    })
+
+    // Give listener time to set up
+    setTimeout(() => {
+      user.get("testkey").put({value: "test"}, err => {
+        assert.equal(err, null)
+
+        // Give listener time to fire
+        setTimeout(() => {
+          // Should have received the test value
+          const nonNull = results.filter(r => r !== null)
+          assert.equal(
+            nonNull.length >= 1,
+            true,
+            "Should have at least one non-null result",
+          )
+          assert.deepEqual(nonNull[0], {value: "test"})
+          done()
+        }, 200)
+      })
+    }, 100)
+  })
+
+  test("cleanup", (t, done) => {
+    fs.rm(
+      "test/system/user-listener-before-data",
+      {recursive: true, force: true},
+      err => {
+        assert.equal(err, null)
+        done()
+      },
+    )
+  })
+})