@mblaney/holster 0.1.0

package/test/holster.on.test.js

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

package/test/holster.put.test.js

@@ -0,0 +1,278 @@
+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.put", () => {
+  const wss = new Server("ws://localhost:1234")
+  const holster = Holster({file: "test/holster.put", wss: wss, maxAge: 100})
+
+  test("put and get string on root", (t, done) => {
+    holster.get("key").put("value", err => {
+      assert.equal(err, null)
+
+      holster.get("key", data => {
+        assert.equal(data, "value")
+        done()
+      })
+    })
+  })
+
+  test("put value to null on root", (t, done) => {
+    holster.get("key").put(null, err => {
+      assert.equal(err, null)
+
+      holster.get("key", data => {
+        assert.equal(data, null)
+        done()
+      })
+    })
+  })
+
+  test("put and get true on root", (t, done) => {
+    holster.get("true").put(true, err => {
+      assert.equal(err, null)
+
+      holster.get("true", data => {
+        assert.equal(data, true)
+        done()
+      })
+    })
+  })
+
+  test("put and get false on root", (t, done) => {
+    holster.get("false").put(false, err => {
+      assert.equal(err, null)
+
+      holster.get("false", data => {
+        assert.equal(data, false)
+        done()
+      })
+    })
+  })
+
+  test("put and get number on root", (t, done) => {
+    holster.get("pi").put(3.14159, err => {
+      assert.equal(err, null)
+
+      holster.get("pi", data => {
+        assert.equal(data, 3.14159)
+        done()
+      })
+    })
+  })
+
+  test("chained get before put", (t, done) => {
+    holster
+      .get("hello")
+      .next("world!")
+      .put("ok", err => {
+        assert.equal(err, null)
+
+        holster.get("hello").next("world!", data => {
+          assert.equal(data, "ok")
+          done()
+        })
+      })
+  })
+
+  test("more chained gets before put", (t, done) => {
+    holster
+      .get("1")
+      .next("2")
+      .next("3")
+      .put("4", err => {
+        assert.equal(err, null)
+
+        holster
+          .get("1")
+          .next("2")
+          .next("3", data => {
+            assert.equal(data, "4")
+            done()
+          })
+      })
+  })
+
+  test("put and get object on root in graph format", (t, done) => {
+    const plain = {
+      key: "plain value",
+      true: true,
+      false: false,
+      number: 42,
+    }
+    holster.get("plain").put(plain, err => {
+      assert.equal(err, null)
+
+      holster.get("plain", data => {
+        assert.deepEqual(data, plain)
+        done()
+      })
+    })
+  })
+
+  test("put object to null on root", (t, done) => {
+    holster.get("plain").put(null, err => {
+      assert.equal(err, null)
+
+      holster.get("plain", data => {
+        assert.equal(data, null)
+        done()
+      })
+    })
+  })
+
+  test("chained get before put object in graph format", (t, done) => {
+    const plain = {
+      key: "hello plain value",
+    }
+    holster
+      .get("hello")
+      .next("plain")
+      .put(plain, err => {
+        assert.equal(err, null)
+
+        holster.get("hello").next("plain", data => {
+          assert.deepEqual(data, plain)
+          done()
+        })
+      })
+  })
+
+  test("put and get nested object", (t, done) => {
+    const nested = {
+      key: "nested value",
+      child: {
+        has: "child value",
+      },
+    }
+    holster.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(() => {
+        holster.get("nested", data => {
+          assert.deepEqual(data, nested)
+
+          holster.get("nested").next("key", data => {
+            assert.equal(data, "nested value")
+
+            holster.get("nested").next("child", data => {
+              assert.deepEqual(data, {has: "child value"})
+              done()
+            })
+          })
+        })
+      }, 2)
+    })
+  })
+
+  test("chained get before put nested object", (t, done) => {
+    const nested = {
+      key: "hello nested value",
+      child: {
+        has: "hello child value",
+      },
+    }
+    holster
+      .get("hello")
+      .next("nested")
+      .put(nested, err => {
+        assert.equal(err, null)
+
+        setTimeout(() => {
+          holster.get("hello").next("nested", data => {
+            assert.deepEqual(data, nested)
+
+            holster
+              .get("hello")
+              .next("nested")
+              .next("key", data => {
+                assert.equal(data, "hello nested value")
+
+                holster
+                  .get("hello")
+                  .next("nested")
+                  .next("child", data => {
+                    assert.deepEqual(data, {has: "hello child value"})
+                    done()
+                  })
+              })
+          })
+        }, 2)
+      })
+  })
+
+  test("put and get two nested objects", (t, done) => {
+    const two = {
+      key: "two nested values",
+      child1: {
+        has: "child value 1",
+      },
+      child2: {
+        has: "child value 2",
+      },
+    }
+    holster.get("two").put(two, err => {
+      assert.equal(err, null)
+
+      setTimeout(() => {
+        holster.get("two", data => {
+          assert.deepEqual(data, two)
+
+          holster.get("two").next("child1", data => {
+            assert.deepEqual(data, {has: "child value 1"})
+
+            holster.get("two").next("child2", data => {
+              assert.deepEqual(data, {has: "child value 2"})
+              done()
+            })
+          })
+        })
+      }, 2)
+    })
+  })
+
+  test("put and get multiple nested object", (t, done) => {
+    const multiple = {
+      key: "multiple nested values",
+      child: {
+        has: "child value",
+        grandchild: {
+          has: "grandchild value",
+          other: "(not returned in lex query)",
+        },
+      },
+    }
+    holster.get("multiple").put(multiple, err => {
+      assert.equal(err, null)
+
+      setTimeout(() => {
+        holster.get("multiple", data => {
+          assert.deepEqual(data, multiple)
+
+          holster.get("multiple").next("child", {".": "has"}, data => {
+            assert.deepEqual(data, {has: "child value"})
+
+            holster
+              .get("multiple")
+              .next("child")
+              .next("grandchild", {".": "has"}, data => {
+                assert.deepEqual(data, {has: "grandchild value"})
+                done()
+              })
+          })
+        })
+      }, 2)
+    })
+  })
+
+  test("cleanup", (t, done) => {
+    fs.rm("test/holster.put", {recursive: true, force: true}, err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+})

package/test/holster.secure.test.js

@@ -0,0 +1,210 @@
+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.secure", () => {
+  const wss = new Server("ws://localhost:1234")
+  const holster = Holster({
+    file: "test/holster.secure",
+    wss: wss,
+    maxAge: 100,
+    secure: true,
+  })
+  const user = holster.user()
+  const expect = "error putting data on root: user required in secure mode"
+
+  test("empty key callback null", (t, done) => {
+    holster.get("", data => {
+      assert.equal(data, null)
+      done()
+    })
+  })
+
+  test("null key callback null", (t, done) => {
+    holster.get(null, data => {
+      assert.equal(data, null)
+      done()
+    })
+  })
+
+  test("underscore as key callback null", (t, done) => {
+    holster.get("_", data => {
+      assert.equal(data, null)
+      done()
+    })
+  })
+
+  test("get unknown key callback null", (t, done) => {
+    holster.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) => {
+    holster.get("chained").get("unknown", data => {
+      assert.equal(data, null)
+      done()
+    })
+  })
+
+  test("next chained unknown keys callback null", (t, done) => {
+    holster.get("chained").next("unknown", data => {
+      assert.equal(data, null)
+      done()
+    })
+  })
+
+  test("put string on root error", (t, done) => {
+    holster.get("key").put("value", err => {
+      assert.equal(err, expect)
+      done()
+    })
+  })
+
+  test("chained get before put", (t, done) => {
+    holster
+      .get("hello")
+      .next("world!")
+      .put("ok", err => {
+        assert.equal(err, expect)
+        done()
+      })
+  })
+
+  test("chained get before put object in graph format", (t, done) => {
+    const plain = {
+      key: "hello plain value",
+    }
+    holster
+      .get("hello")
+      .next("plain")
+      .put(plain, err => {
+        assert.equal(err, expect)
+        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("put and get string", (t, done) => {
+    user.get("key").put("value", err => {
+      assert.equal(err, null)
+
+      user.get("key", data => {
+        assert.equal(data, "value")
+        done()
+      })
+    })
+  })
+
+  test("user chained get before put", (t, done) => {
+    user
+      .get("hello")
+      .next("world!")
+      .put("ok", err => {
+        assert.equal(err, null)
+
+        user.get("hello").next("world!", data => {
+          assert.equal(data, "ok")
+          done()
+        })
+      })
+  })
+
+  test("user 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)
+
+      user.get("plain", data => {
+        assert.deepEqual(data, plain)
+        done()
+      })
+    })
+  })
+
+  test("user put object to null", (t, done) => {
+    user.get("plain").put(null, err => {
+      assert.equal(err, null)
+
+      user.get("plain", data => {
+        assert.equal(data, null)
+        done()
+      })
+    })
+  })
+
+  test("user chained get before put object in graph format", (t, done) => {
+    const plain = {
+      key: "hello plain value",
+    }
+    user
+      .get("hello")
+      .next("plain")
+      .put(plain, err => {
+        assert.equal(err, null)
+
+        user.get("hello").next("plain", data => {
+          assert.deepEqual(data, plain)
+          done()
+        })
+      })
+  })
+
+  test("user put and get nested object", (t, done) => {
+    const nested = {
+      key: "nested value",
+      child: {
+        has: "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", data => {
+          assert.deepEqual(data, nested)
+
+          user.get("nested").next("key", data => {
+            assert.equal(data, "nested value")
+
+            user.get("nested").next("child", data => {
+              assert.deepEqual(data, {has: "child value"})
+              done()
+            })
+          })
+        })
+      }, 2)
+    })
+  })
+
+  test("cleanup", (t, done) => {
+    fs.rm("test/holster.secure", {recursive: true, force: true}, err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+})