@mblaney/holster 1.0.35 → 1.0.36

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

@@ -1,142 +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("system - user concurrent listeners", () => {
-  const wss = new Server("ws://localhost:9015")
-  const holster = Holster({
-    file: "test/system/user-concurrent-listeners",
-    wss: wss,
-    wait: 500,
-  })
-  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
-      // The listener will be called with the existing data via the get request
-      user.get("race").on(data => {
-        results.push(data?.value)
-      }, true)
-
-      // Immediately put new data - listener will fire for this put as well
-      setTimeout(() => {
-        user.get("race").put({value: "second"}, err => {
-          assert.equal(err, null)
-
-          setTimeout(() => {
-            // Should have received both values - one from get, one from put
-            assert.equal(
-              results.length >= 1,
-              true,
-              "Should receive at least initial value from get",
-            )
-            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

@@ -1,66 +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("system - user listener before data", () => {
-  const wss = new Server("ws://localhost:9017")
-  const holster = Holster({
-    file: "test/system/user-listener-before-data",
-    wss: wss,
-    wait: 500,
-  })
-  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(() => {
-          // With the new behavior, listener fires after data is stored
-          // Should have received the test value from the put
-          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()
-      },
-    )
-  })
-})

package/test/user.test.js

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

@@ -1,158 +0,0 @@
-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},
-            },
-            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},
-              },
-              value: "wire test",
-            },
-          },
-        })
-        done()
-      })
-    })
-  })
-
-  test("cleanup", (t, done) => {
-    // Timeout to let extra wire sends finish before tests end.
-    setTimeout(() => {
-      fs.rm("test/wire", {recursive: true, force: true}, err => {
-        assert.equal(err, null)
-        done()
-      })
-    }, 100)
-  })
-})