@mblaney/holster 1.0.35 → 2.0.0

package/test/holster.secure.test.js

@@ -1,202 +0,0 @@
-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()
-    })
-  })
-
-  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("user 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()
-    })
-  })
-})

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

@@ -1,114 +0,0 @@
-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,
-    wait: 500,
-  })
-  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()
-    })
-  })
-
-  test("get unknown keys in for loop callbacks null", (t, done) => {
-    let count = 0
-    for (let i = 0; i < 5; i++) {
-      user.get("unknown" + i, data => {
-        assert.equal(data, null)
-        count++
-      })
-    }
-    setTimeout(() => {
-      if (count === 5) done()
-    }, 200)
-  })
-
-  test("nested get unknown key callback null", (t, done) => {
-    user.get("unknown", data => {
-      assert.equal(data, null)
-
-      user.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("nested next chained unknown keys callback null", (t, done) => {
-    user.get("chained").next("unknown", data => {
-      assert.equal(data, null)
-
-      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

@@ -1,149 +0,0 @@
-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,
-    wait: 500,
-  })
-  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)
-      assert.equal(user.is.username, "alice")
-      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

@@ -1,73 +0,0 @@
-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,
-    wait: 500,
-  })
-  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()
-    })
-  })
-})