@mblaney/holster 1.0.35 → 1.0.36

package/test/holster.off.test.js

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

package/test/holster.on.test.js

@@ -1,264 +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.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) => {
-    // Listener is now called for initial put and updates
-    let callCount = 0
-    holster.get("key").on(data => {
-      callCount++
-      if (callCount === 1) {
-        assert.equal(data, "value")
-      } else if (callCount === 2) {
-        assert.equal(data, "update")
-        done()
-      }
-    })
-
-    holster.get("key").put("value", err => {
-      assert.equal(err, null)
-
-      holster.get("key").put("update", err => {
-        assert.equal(err, null)
-      })
-    })
-  })
-
-  test("on for property then update - two listeners", (t, done) => {
-    let done1 = false
-    let done2 = false
-
-    let callback1Count = 0
-    const callback1 = data => {
-      callback1Count++
-      if (callback1Count === 2) {
-        assert.equal(data, "update")
-        holster.get("two").off(callback1)
-        if (done2) done()
-        else done1 = true
-      }
-    }
-    holster.get("two").on(callback1)
-
-    let callback2Count = 0
-    const callback2 = data => {
-      callback2Count++
-      if (callback2Count === 2) {
-        assert.equal(data, "update")
-        holster.get("two").off(callback2)
-        if (done1) done()
-        else done2 = true
-      }
-    }
-    holster.get("two").on(callback2)
-
-    holster.get("two").put("value", err => {
-      assert.equal(err, null)
-
-      holster.get("two").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.
-    })
-
-    setTimeout(() => {
-      holster.get("key2").put("value2", err => {
-        assert.equal(err, null)
-        done()
-      })
-    }, 100)
-  })
-
-  test("on for property on root two updates - two events", (t, done) => {
-    holster.get("key3").put("value3", err => {
-      assert.equal(err, null)
-
-      let callCount = 0
-      holster.get("key3").on(data => {
-        callCount++
-        if (callCount === 1) {
-          assert.equal(data, "update1")
-        } else if (callCount === 2) {
-          assert.equal(data, "update2")
-          done()
-        }
-      })
-
-      holster.get("key3").put("update1", err => {
-        assert.equal(err, null)
-      })
-
-      setTimeout(() => {
-        holster.get("key3").put("update2", err => {
-          assert.equal(err, null)
-        })
-      }, 200)
-    })
-  })
-
-  test("on for properties on root in for loop", (t, done) => {
-    for (let i = 0; i < 5; i++) {
-      holster.get("for" + i).put(i, err => {
-        assert.equal(err, null)
-      })
-    }
-
-    // Need to wait until after all initial puts are done to set on listeners.
-    setTimeout(() => {
-      let completed = 0
-      for (let i = 0; i < 5; i++) {
-        const idx = i // Capture value
-        holster.get("for" + idx).on(data => {
-          // Listener fires for updates (initial puts already completed before listener setup)
-          assert.equal(data, "update" + idx)
-          completed++
-          if (completed === 5) done()
-        })
-      }
-
-      setTimeout(() => {
-        for (let i = 0; i < 5; i++) {
-          holster.get("for" + i).put("update" + i, err => {
-            assert.equal(err, null)
-          })
-        }
-      }, 100)
-    }, 500)
-  })
-
-  test("on with get flag set - data returned", (t, done) => {
-    holster.get("key4").put("value4", err => {
-      assert.equal(err, null)
-
-      setTimeout(() => {
-        holster.get("key4").on(data => {
-          assert.equal(data, "value4")
-          done()
-        }, true)
-      }, 100)
-    })
-  })
-
-  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 => {
-            // Listener fires for updates (initial put already completed before listener setup)
-            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 => {
-        // Listener fires for updates (initial put already completed before listener setup)
-        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",
-        },
-      }
-      let parentFired = false
-      holster.get("nested").on(data => {
-        // Listener fires for updates (initial put already completed before listener setup)
-        if (!parentFired) {
-          parentFired = true
-          assert.deepEqual(data, {key: nested.key, ...update})
-        }
-      })
-
-      holster
-        .get("nested")
-        .next("child")
-        .on(data => {
-          // Listener fires for updates (initial put already completed before listener setup)
-          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

@@ -1,358 +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.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("put and get values in for loop on root", (t, done) => {
-    for (let i = 0; i < 5; i++) {
-      holster.get("for" + i).put(i, err => {
-        assert.equal(err, null)
-      })
-    }
-
-    setTimeout(() => {
-      let count = 0
-      for (let i = 0; i < 5; i++) {
-        holster.get("for" + i, data => {
-          assert.equal(data, i)
-          count++
-        })
-      }
-      setTimeout(() => {
-        if (count === 5) done()
-      }, 200)
-    }, 200)
-  })
-
-  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("put string with set", (t, done) => {
-    holster.get("set").put("first", true, err => {
-      assert.equal(err, null)
-
-      holster.get("set", data => {
-        assert.equal(Object.values(data)[0], "first")
-
-        setTimeout(() => {
-          holster.get("set").put("second", true, err => {
-            assert.equal(err, null)
-
-            holster.get("set", data => {
-              for (const value of Object.values(data)) {
-                assert.ok(value === "first" || value === "second")
-              }
-              done()
-            })
-          })
-        }, 2)
-      })
-    })
-  })
-
-  test("put object with set", (t, done) => {
-    const set1 = {
-      key: "value 1",
-      child: "child value 1",
-    }
-    const set2 = {
-      key: "value 2",
-      child: "child value 2",
-    }
-    holster.get("set2").put(set1, true, err => {
-      assert.equal(err, null)
-
-      holster.get("set2", data => {
-        assert.deepEqual(Object.values(data)[0], set1)
-
-        setTimeout(() => {
-          holster.get("set2").put(set2, true, err => {
-            assert.equal(err, null)
-
-            holster.get("set2", data => {
-              for (const value of Object.values(data)) {
-                if (value.key === "value 1") {
-                  assert.deepEqual(value, set1)
-                }
-                if (value.key === "value 2") {
-                  assert.deepEqual(value, set2)
-                }
-              }
-              done()
-            })
-          })
-        }, 2)
-      })
-    })
-  })
-
-  test("cleanup", (t, done) => {
-    fs.rm("test/holster.put", {recursive: true, force: true}, err => {
-      assert.equal(err, null)
-      done()
-    })
-  })
-})