@mblaney/holster 0.1.0

package/test/store.test.js

@@ -0,0 +1,316 @@
+import {describe, test} from "node:test"
+import assert from "node:assert/strict"
+import Store from "../src/store.js"
+import fs from "fs"
+
+describe("store", () => {
+  const kitty = Store({file: "test/kitty"})
+  const multiple = Store({file: "test/multiple", size: 100})
+  const special = Store({file: "test/special"})
+  const newFileValue =
+    "file size is only 100 bytes so writing this value requires calling slice"
+
+  test("get graph", (t, done) => {
+    kitty.get({"#": "FDSA"}, (err, value) => {
+      assert.deepEqual(value, {
+        FDSA: {
+          _: {
+            "#": "FDSA",
+            ">": {
+              color: 3,
+              name: 2,
+              slave: 2,
+              species: 2,
+            },
+          },
+          color: "ginger",
+          name: "Fluffy",
+          slave: {
+            "#": "ASDF",
+          },
+          species: "felis silvestris",
+        },
+      })
+      done()
+    })
+  })
+
+  test("get item", (t, done) => {
+    kitty.get({"#": "FDSA", ".": "species"}, (err, value) => {
+      assert.deepEqual(value, {
+        FDSA: {
+          _: {
+            "#": "FDSA",
+            ">": {
+              species: 2,
+            },
+          },
+          species: "felis silvestris",
+        },
+      })
+      done()
+    })
+  })
+
+  test("put keys to multiple files", (t, done) => {
+    multiple.put(
+      {
+        keyA: {
+          _: {"#": "keyA", ">": {value: 1}},
+          value: "valueA",
+        },
+        keyB: {
+          _: {"#": "keyB", ">": {value: 1}},
+          value: "valueB",
+        },
+        keyC: {
+          _: {"#": "keyC", ">": {value: 1, extraField: 1}},
+          value: "valueC",
+          extraField: true,
+        },
+        newFile: {
+          _: {"#": "newFile", ">": {value: 1}},
+          value: newFileValue,
+        },
+      },
+      err => {
+        assert.equal(err, null)
+        fs.access("test/multiple/keyC", err => {
+          assert.equal(err, null)
+          fs.access("test/multiple/newFile", err => {
+            assert.equal(err, null)
+            done()
+          })
+        })
+      },
+    )
+  })
+
+  test("get key from first file", (t, done) => {
+    multiple.get({"#": "keyA"}, (err, value) => {
+      assert.deepEqual(value, {
+        keyA: {
+          _: {
+            "#": "keyA",
+            ">": {
+              value: 1,
+            },
+          },
+          value: "valueA",
+        },
+      })
+      done()
+    })
+  })
+
+  test("get keys from second file", (t, done) => {
+    multiple.get({"#": "keyC"}, (err, value) => {
+      assert.deepEqual(value, {
+        keyC: {
+          _: {
+            "#": "keyC",
+            ">": {
+              extraField: 1,
+              value: 1,
+            },
+          },
+          extraField: true,
+          value: "valueC",
+        },
+      })
+    })
+    multiple.get({"#": "keyC", ".": "value"}, (err, value) => {
+      assert.deepEqual(value, {
+        keyC: {
+          _: {
+            "#": "keyC",
+            ">": {
+              value: 1,
+            },
+          },
+          value: "valueC",
+        },
+      })
+      done()
+    })
+  })
+
+  test("get key from third file", (t, done) => {
+    multiple.get({"#": "newFile"}, (err, value) => {
+      assert.deepEqual(value, {
+        newFile: {
+          _: {
+            "#": "newFile",
+            ">": {
+              value: 1,
+            },
+          },
+          value: newFileValue,
+        },
+      })
+      fs.rm("test/multiple", {recursive: true, force: true}, err => {
+        assert.equal(err, null)
+        done()
+      })
+    })
+  })
+
+  test("put keys with special characters", (t, done) => {
+    special.put(
+      {
+        "#": {
+          _: {"#": "#", ">": {value: 1}},
+          value: "ok got #",
+        },
+        ">": {
+          _: {"#": ">", ">": {value: 1, extraField: 1}},
+          value: "ok got >",
+          extraField: true,
+        },
+        ".": {
+          _: {"#": ".", ">": {value: 1, extraField: 1}},
+          value: "ok got .",
+          extraField: true,
+        },
+        "+": {
+          _: {"#": "+", ">": {value: 1}},
+          value: "ok got +",
+        },
+        "[": {
+          _: {"#": "[", ">": {value: 1}},
+          value: "ok got [",
+        },
+        ",": {
+          _: {"#": ",", ">": {value: 1}},
+          value: "ok got ,",
+        },
+        '"': {
+          _: {"#": '"', ">": {value: 1}},
+          value: 'ok got "',
+        },
+        _: {
+          _: {"#": "_", ">": {value: 1}},
+          value: "ok got _",
+        },
+      },
+      err => {
+        assert.equal(err, null)
+        fs.access("test/special/!", err => {
+          assert.equal(err, null)
+          done()
+        })
+      },
+    )
+  })
+
+  test("get keys with special characters", (t, done) => {
+    special.get({"#": "#"}, (err, value) => {
+      assert.deepEqual(value, {
+        "#": {
+          _: {
+            "#": "#",
+            ">": {
+              value: 1,
+            },
+          },
+          value: "ok got #",
+        },
+      })
+    })
+    special.get({"#": ">", ".": "value"}, (err, value) => {
+      assert.deepEqual(value, {
+        ">": {
+          _: {
+            "#": ">",
+            ">": {
+              value: 1,
+            },
+          },
+          value: "ok got >",
+        },
+      })
+    })
+    special.get({"#": ".", ".": "value"}, (err, value) => {
+      assert.deepEqual(value, {
+        ".": {
+          _: {
+            "#": ".",
+            ">": {
+              value: 1,
+            },
+          },
+          value: "ok got .",
+        },
+      })
+    })
+    special.get({"#": "+"}, (err, value) => {
+      assert.deepEqual(value, {
+        "+": {
+          _: {
+            "#": "+",
+            ">": {
+              value: 1,
+            },
+          },
+          value: "ok got +",
+        },
+      })
+    })
+    special.get({"#": "["}, (err, value) => {
+      assert.deepEqual(value, {
+        "[": {
+          _: {
+            "#": "[",
+            ">": {
+              value: 1,
+            },
+          },
+          value: "ok got [",
+        },
+      })
+    })
+    special.get({"#": ","}, (err, value) => {
+      assert.deepEqual(value, {
+        ",": {
+          _: {
+            "#": ",",
+            ">": {
+              value: 1,
+            },
+          },
+          value: "ok got ,",
+        },
+      })
+    })
+    special.get({"#": '"'}, (err, value) => {
+      assert.deepEqual(value, {
+        '"': {
+          _: {
+            "#": '"',
+            ">": {
+              value: 1,
+            },
+          },
+          value: 'ok got "',
+        },
+      })
+    })
+    special.get({"#": "_"}, (err, value) => {
+      assert.deepEqual(value, {
+        _: {
+          _: {
+            "#": "_",
+            ">": {
+              value: 1,
+            },
+          },
+          value: "ok got _",
+        },
+      })
+      fs.rm("test/special", {recursive: true, force: true}, err => {
+        assert.equal(err, null)
+        done()
+      })
+    })
+  })
+})

package/test/user.test.js

@@ -0,0 +1,173 @@
+import fs from "fs"
+import {Server} from "mock-socket"
+import {describe, test} from "node:test"
+import assert from "node:assert/strict"
+import User from "../src/user.js"
+
+describe("user", () => {
+  const wss = new Server("ws://localhost:1234")
+  const user = User({file: "test/user", wss: wss, maxAge: 100})
+
+  test("create", (t, done) => {
+    user.create("alice", "password", err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+
+  test("create no username", (t, done) => {
+    user.create("", "password", err => {
+      assert.equal(err, "Please provide a username")
+      done()
+    })
+  })
+
+  test("create no password", (t, done) => {
+    user.create("alice", "", err => {
+      assert.equal(err, "Please provide a password")
+      done()
+    })
+  })
+
+  test("username already exists", (t, done) => {
+    user.create("alice", "password", err => {
+      assert.equal(err, "Username already exists")
+      done()
+    })
+  })
+
+  test("user is already being created", (t, done) => {
+    user.create("bob", "password", err => {
+      assert.equal(err, null)
+      done()
+    })
+    user.create("bob", "password", err => {
+      assert.equal(err, "User is already being created")
+    })
+  })
+
+  test("auth", (t, done) => {
+    user.auth("alice", "password", err => {
+      assert.equal(err, null)
+      assert.equal(user.is.username, "alice")
+      done()
+    })
+  })
+
+  test("auth no username", (t, done) => {
+    user.auth("", "password", err => {
+      assert.equal(err, "Please provide a username")
+      assert.equal(user.is, null)
+      done()
+    })
+  })
+
+  test("auth no password", (t, done) => {
+    user.auth("alice", "", err => {
+      assert.equal(err, "Please provide a password")
+      assert.equal(user.is, null)
+      done()
+    })
+  })
+
+  test("auth wrong username", (t, done) => {
+    user.auth("wrong", "password", err => {
+      assert.equal(err, "Wrong username or password")
+      assert.equal(user.is, null)
+      done()
+    })
+  })
+
+  test("auth wrong password", (t, done) => {
+    user.auth("alice", "wrong", err => {
+      assert.equal(err, "Wrong username or password")
+      assert.equal(user.is, null)
+      done()
+    })
+  })
+
+  test("user is already authenticating", (t, done) => {
+    user.auth("bob", "password", err => {
+      assert.equal(err, null)
+      assert.equal(user.is.username, "bob")
+      done()
+    })
+    user.auth("bob", "password", err => {
+      assert.equal(err, "User is already authenticating")
+      assert.equal(user.is, null)
+    })
+  })
+
+  test("change", (t, done) => {
+    user.change("alice", "password", "new password", err => {
+      assert.equal(err, null)
+      assert.equal(user.is.username, "alice")
+      done()
+    })
+  })
+
+  test("change no username", (t, done) => {
+    user.change("", "password", "new password", err => {
+      assert.equal(err, "Please provide a username")
+      assert.equal(user.is, null)
+      done()
+    })
+  })
+
+  test("change no password", (t, done) => {
+    user.change("alice", "", "new password", err => {
+      assert.equal(err, "Please provide a password")
+      assert.equal(user.is, null)
+      done()
+    })
+  })
+
+  test("change no new password", (t, done) => {
+    user.change("alice", "password", "", err => {
+      assert.equal(err, "Please provide a new password")
+      assert.equal(user.is, null)
+      done()
+    })
+  })
+
+  test("check password change and leave", (t, done) => {
+    user.auth("alice", "new password", err => {
+      assert.equal(err, null)
+      assert.equal(user.is.username, "alice")
+      user.leave()
+      assert.equal(user.is, null)
+      done()
+    })
+  })
+
+  test("delete wrong password", (t, done) => {
+    user.delete("alice", "password", err => {
+      assert.equal(err, "Wrong username or password")
+      assert.equal(user.is, null)
+      done()
+    })
+  })
+
+  test("delete", (t, done) => {
+    user.delete("alice", "new password", err => {
+      assert.equal(err, null)
+      assert.equal(user.is, null)
+      done()
+    })
+  })
+
+  test("auth after delete", (t, done) => {
+    user.auth("alice", "new password", err => {
+      assert.equal(err, "Wrong username or password")
+      assert.equal(user.is, null)
+      done()
+    })
+  })
+
+  test("cleanup", (t, done) => {
+    fs.rm("test/user", {recursive: true, force: true}, err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+})

package/test/wire.test.js

@@ -0,0 +1,159 @@
+import fs from "fs"
+import {Server} from "mock-socket"
+import {describe, test} from "node:test"
+import assert from "node:assert/strict"
+import Wire from "../src/wire.js"
+
+describe("wire", () => {
+  // Need different websocket servers otherwise data on file will sync up.
+  const wss1 = new Server("ws://localhost:1234")
+  const kitty = Wire({file: "test/kitty", wss: wss1, maxAge: 10})
+
+  const wss2 = new Server("ws://localhost:1235")
+  const wire = Wire({file: "test/wire", wss: wss2, maxAge: 10})
+
+  const ws = new WebSocket("ws://localhost:1235")
+  ws.onmessage = m => {
+    const msg = JSON.parse(m.data)
+    if (msg.get) {
+      const soul = msg.get["#"]
+      const put = {
+        [soul]: {
+          _: {"#": soul, ">": {test: 1}},
+          test: "property",
+        },
+      }
+      let track = "item"
+      if (!msg.get["."]) {
+        put[soul]._[">"].other = 2
+        put[soul].other = "value"
+        track = "node"
+      }
+      ws.send(
+        JSON.stringify({
+          "#": track,
+          "@": msg["#"],
+          put: put,
+        }),
+      )
+    }
+  }
+
+  test("get node", (t, done) => {
+    kitty.get({"#": "FDSA"}, msg => {
+      assert.deepEqual(msg, {
+        err: undefined,
+        put: {
+          FDSA: {
+            _: {
+              "#": "FDSA",
+              ">": {
+                color: 3,
+                name: 2,
+                slave: 2,
+                species: 2,
+              },
+            },
+            color: "ginger",
+            name: "Fluffy",
+            slave: {"#": "ASDF"},
+            species: "felis silvestris",
+          },
+        },
+      })
+      done()
+    })
+  })
+
+  test("get item", (t, done) => {
+    kitty.get({"#": "FDSA", ".": "species"}, msg => {
+      assert.deepEqual(msg, {
+        err: undefined,
+        put: {
+          FDSA: {
+            _: {
+              "#": "FDSA",
+              ">": {species: 2},
+            },
+            species: "felis silvestris",
+          },
+        },
+      })
+      done()
+    })
+  })
+
+  test("get node from wire", (t, done) => {
+    wire.get({"#": "not on disk"}, msg => {
+      assert.deepEqual(msg, {
+        put: {
+          "not on disk": {
+            _: {
+              "#": "not on disk",
+              ">": {test: 1, other: 2},
+            },
+            test: "property",
+            other: "value",
+          },
+        },
+      })
+      done()
+    })
+  })
+
+  test("get item from wire", (t, done) => {
+    wire.get({"#": "not on disk", ".": "test"}, msg => {
+      assert.deepEqual(msg, {
+        put: {
+          "not on disk": {
+            _: {
+              "#": "not on disk",
+              ">": {test: 1},
+              p: undefined,
+              s: undefined,
+            },
+            test: "property",
+          },
+        },
+      })
+      done()
+    })
+  })
+
+  test("put and get new node", (t, done) => {
+    const update = {
+      key: {
+        _: {"#": "key", ">": {value: 1, otherValue: 1}},
+        value: "wire test",
+        otherValue: false,
+      },
+    }
+    wire.put(update, err => {
+      assert.deepEqual(err, null)
+
+      wire.get({"#": "key", ".": "value"}, msg => {
+        assert.deepEqual(msg, {
+          put: {
+            key: {
+              _: {
+                "#": "key",
+                ">": {value: 1},
+                p: undefined,
+                s: undefined,
+              },
+              value: "wire test",
+            },
+          },
+        })
+        done()
+      })
+    })
+  })
+
+  test("cleanup", (t, done) => {
+    fs.rm("test/wire", {recursive: true, force: true}, err => {
+      assert.equal(err, null)
+      done()
+    })
+  })
+})