@mblaney/holster 0.1.0

package/test/holster.user.get.test.js

@@ -0,0 +1,86 @@
+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("holster.user.get", () => {
+  const wss = new Server("ws://localhost:1234")
+  const holster = Holster({
+    file: "test/holster.user.get",
+    wss: wss,
+    maxAge: 100,
+  })
+  const user = holster.user()
+
+  test("user is not authenticated", (t, done) => {
+    user.get("test", data => {
+      assert.equal(data, null)
+      done()
+    })
+  })
+
+  test("user create", (t, done) => {
+    user.create("alice", "password", err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+
+  test("user auth", (t, done) => {
+    user.auth("alice", "password", err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+
+  test("empty key callback null", (t, done) => {
+    user.get("", data => {
+      assert.equal(data, null)
+      done()
+    })
+  })
+
+  test("null key callback null", (t, done) => {
+    user.get(null, data => {
+      assert.equal(data, null)
+      done()
+    })
+  })
+
+  test("underscore as key callback null", (t, done) => {
+    user.get("_", data => {
+      assert.equal(data, null)
+      done()
+    })
+  })
+
+  test("get unknown key callback null", (t, done) => {
+    user.get("unknown", data => {
+      assert.equal(data, null)
+      done()
+    })
+  })
+
+  // Chaining get creates a new context for each call.
+  test("get chained unknown keys callback null", (t, done) => {
+    user.get("chained").get("unknown", data => {
+      assert.equal(data, null)
+      done()
+    })
+  })
+
+  test("next chained unknown keys callback null", (t, done) => {
+    user.get("chained").next("unknown", data => {
+      assert.equal(data, null)
+      done()
+    })
+  })
+
+  test("cleanup", (t, done) => {
+    fs.rm("test/holster.user.get", {recursive: true, force: true}, err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+})

package/test/holster.user.lex.test.js

@@ -0,0 +1,148 @@
+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("holster.user.lex", () => {
+  const wss = new Server("ws://localhost:1234")
+  const holster = Holster({
+    file: "test/holster.user.lex",
+    wss: wss,
+    maxAge: 100,
+  })
+  const user = holster.user()
+  let alice = ""
+
+  test("user create", (t, done) => {
+    user.create("alice", "password", err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+
+  test("user auth", (t, done) => {
+    user.auth("alice", "password", err => {
+      assert.equal(err, null)
+      assert.equal(user.is.username, "alice")
+      alice = user.is.pub
+      done()
+    })
+  })
+
+  test("put and get object in graph format", (t, done) => {
+    const plain = {
+      key: "plain value",
+      true: true,
+      false: false,
+      number: 42,
+    }
+    user.get("plain").put(plain, err => {
+      assert.equal(err, null)
+
+      // Prefix tests. (Need to be sequential to match return values.)
+      user.get("plain", {".": {"*": "k"}}, data => {
+        assert.deepEqual(data, {key: "plain value"})
+
+        user.get("plain", {".": {"*": "t"}}, data => {
+          assert.deepEqual(data, {true: true})
+
+          user.get("plain", {".": {"*": "f"}}, data => {
+            assert.deepEqual(data, {false: false})
+
+            user.get("plain", {".": {"*": "n"}}, data => {
+              assert.deepEqual(data, {number: 42})
+            })
+
+            // Both less than and greater than.
+            user.get("plain", {".": {"<": "n", ">": "falsy"}}, data => {
+              assert.deepEqual(data, {key: "plain value"})
+
+              // Only less than.
+              user.get("plain", {".": {"<": "k"}}, data => {
+                assert.deepEqual(data, {false: false})
+
+                // Only greater than.
+                user.get("plain", {".": {">": "numbers"}}, data => {
+                  assert.deepEqual(data, {true: true})
+                  done()
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+  })
+
+  test("put and get nested object", (t, done) => {
+    const nested = {
+      key: "nested value",
+      other: "other value",
+      child: {
+        has: "child value",
+        other: "other child value",
+      },
+    }
+    user.get("nested").put(nested, err => {
+      assert.equal(err, null)
+
+      // Getting a nested object requires waiting for radisk to write to disk,
+      // as it will batch the writes. (Default wait is 1 millisecond.)
+      setTimeout(() => {
+        user.get("nested", {".": {"*": "k"}}, data => {
+          assert.deepEqual(data, {key: "nested value"})
+
+          user.get("nested").next("child", {".": {"*": "h"}}, data => {
+            assert.deepEqual(data, {has: "child value"})
+
+            user.get("nested").next("child", {".": {"<": "has"}}, data => {
+              // Less than means less than or equal to in lex.
+              assert.deepEqual(data, {has: "child value"})
+              done()
+            })
+          })
+        })
+      }, 2)
+    })
+  })
+
+  test("on and put nested object", (t, done) => {
+    const nested = {
+      key: "nested key",
+      child: {
+        has: "child key",
+      },
+    }
+    // The node needs to exist before it can be listend to for updates.
+    user.get("on-nested").put(nested, err => {
+      assert.equal(err, null)
+
+      const update = {
+        child: {
+          has: "child update",
+        },
+      }
+      user
+        .get("on-nested")
+        .next("child")
+        .on({".": {">": "h"}}, data => {
+          assert.deepEqual(data, update.child)
+          done()
+        })
+
+      setTimeout(() => {
+        user.get("on-nested").put(update, err => {
+          assert.equal(err, null)
+        })
+      }, 10)
+    })
+  })
+
+  test("cleanup", (t, done) => {
+    fs.rm("test/holster.user.lex", {recursive: true, force: true}, err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+})

package/test/holster.user.off.test.js

@@ -0,0 +1,72 @@
+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("holster.user.off", () => {
+  const wss = new Server("ws://localhost:1234")
+  const holster = Holster({
+    file: "test/holster.user.off",
+    wss: wss,
+    maxAge: 100,
+  })
+  const user = holster.user()
+
+  test("user create", (t, done) => {
+    user.create("alice", "password", err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+
+  test("user auth", (t, done) => {
+    user.auth("alice", "password", err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+
+  test("calling off without get callback null", (t, done) => {
+    user.off(data => {
+      assert.equal(data, null)
+      done()
+    })
+  })
+
+  test("off with cb for property then update - no event", (t, done) => {
+    const cb = data => {
+      console.log("should not be called for key:", data)
+      done()
+    }
+    user.get("key").on(cb)
+    user.get("key").off(cb)
+
+    user.get("key").put("value", err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+
+  test("off no cb for property then update - no event", (t, done) => {
+    user.get("key1").on(data => {
+      console.log("should not be called for key1:", data)
+      done()
+    })
+    setTimeout(() => {
+      user.get("key1").off()
+
+      user.get("key1").put("value1", err => {
+        assert.equal(err, null)
+        done()
+      })
+    }, 10)
+  })
+
+  test("cleanup", (t, done) => {
+    fs.rm("test/holster.user.off", {recursive: true, force: true}, err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+})

package/test/holster.user.on.test.js

@@ -0,0 +1,185 @@
+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("holster.user.on", () => {
+  const wss = new Server("ws://localhost:1234")
+  const holster = Holster({file: "test/holster.user.on", wss: wss, maxAge: 100})
+  const user = holster.user()
+
+  test("user create", (t, done) => {
+    user.create("alice", "password", err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+
+  test("user auth", (t, done) => {
+    user.auth("alice", "password", err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+
+  test("calling on without get callback null", (t, done) => {
+    user.on(data => {
+      assert.equal(data, null)
+      done()
+    })
+  })
+
+  test("on for property then update - event", (t, done) => {
+    // The property needs to exist before it can be listend to for updates.
+    user.get("key").put("value", err => {
+      assert.equal(err, null)
+
+      user.get("key").on(data => {
+        assert.equal(data, "update")
+        user.get("key").off()
+        done()
+      })
+
+      user.get("key").put("update", err => {
+        assert.equal(err, null)
+      })
+    })
+  })
+
+  test("on for different property - no event", (t, done) => {
+    user.get("key1").on(data => {
+      console.log("should not be called for key1:", data)
+      done() // This done is not called and test would fail if it was.
+    })
+
+    user.get("key2").put("value2", err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+
+  test("on for property two updates - two events", (t, done) => {
+    user.get("key3").put("value3", err => {
+      assert.equal(err, null)
+
+      let first = true
+      user.get("key3").on(data => {
+        if (first) {
+          assert.equal(data, "update1")
+        } else {
+          assert.equal(data, "update2")
+          done()
+        }
+      })
+
+      user.get("key3").put("update1", err => {
+        assert.equal(err, null)
+      })
+
+      setTimeout(() => {
+        first = false
+        user.get("key3").put("update2", err => {
+          assert.equal(err, null)
+        })
+      }, 200)
+    })
+  })
+
+  test("chained next before on", (t, done) => {
+    // The node needs to exist before it can be listend to for updates.
+    user
+      .get("hello")
+      .next("world!")
+      .put("ok", err => {
+        assert.equal(err, null)
+
+        user
+          .get("hello")
+          .next("world!")
+          .on(data => {
+            assert.equal(data, "update")
+            user.get("hello").next("world!").off()
+            done()
+          })
+
+        setTimeout(() => {
+          user
+            .get("hello")
+            .next("world!")
+            .put("update", err => {
+              assert.equal(err, null)
+            })
+        }, 10)
+      })
+  })
+
+  test("on and put object in graph format", (t, done) => {
+    const plain = {
+      key: "plain value",
+      number: 42,
+    }
+    user.get("plain").put(plain, err => {
+      assert.equal(err, null)
+
+      const update = {
+        key: "update",
+        number: 42,
+      }
+      user.get("plain").on(data => {
+        assert.deepEqual(data, update)
+        done()
+      })
+
+      setTimeout(() => {
+        user.get("plain").put(update, err => {
+          assert.equal(err, null)
+        })
+      }, 10)
+    })
+  })
+
+  test("on and put nested object", (t, done) => {
+    const nested = {
+      key: "nested key",
+      child: {
+        has: "child key",
+      },
+    }
+    // The node needs to exist before it can be listend to for updates.
+    user.get("nested").put(nested, err => {
+      assert.equal(err, null)
+
+      const update = {
+        key: "nested update",
+        child: {
+          has: "child update",
+        },
+      }
+      user.get("nested").on(data => {
+        assert.deepEqual(data, update)
+      })
+
+      user
+        .get("nested")
+        .next("child")
+        .on(data => {
+          assert.deepEqual(data, update.child)
+          done()
+        })
+
+      setTimeout(() => {
+        user.get("nested").put(update, err => {
+          assert.equal(err, null)
+        })
+      }, 10)
+    })
+  })
+
+  test("cleanup", (t, done) => {
+    fs.rm("test/holster.user.on", {recursive: true, force: true}, err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+})