@mblaney/holster 0.1.0

package/test/radisk.test.js

@@ -0,0 +1,191 @@
+import {describe, test} from "node:test"
+import assert from "node:assert/strict"
+import Radisk from "../src/radisk.js"
+import Names from "./names.js"
+const names = Names()
+
+describe("radisk", () => {
+  const puts = {}
+  const opt = {
+    write: 1,
+    batch: 2,
+    size: 100,
+    store: {
+      get: (file, cb) => {
+        cb(null, puts[file])
+      },
+      put: (file, data, cb) => {
+        puts[file] = data
+        cb(null)
+      },
+      list: cb => {
+        Object.keys(puts).sort().forEach(cb)
+        cb(null)
+      },
+    },
+  }
+  const radisk = Radisk(opt)
+
+  test("write and read from memory", (t, done) => {
+    radisk("key", "value", () => {
+      assert.deepEqual(puts, {"!": '\x1F+0\x1F#\x1F"key\x1F=\x1F"value\x1F\n'})
+    })
+
+    // Reading after write means radisk.batch is still available.
+    radisk("key", (err, value) => {
+      assert.equal(value, "value")
+      done()
+    })
+  })
+
+  test("read from store", (t, done) => {
+    // Waiting until after opt.write means radisk.batch has been reset, so a
+    // call to radisk.read is required which means the file needs to be parsed.
+    setTimeout(() => {
+      radisk("key", (err, value) => {
+        assert.equal(value, "value")
+        done()
+      })
+    }, opt.write + 1)
+  })
+
+  test("write and read value with state", (t, done) => {
+    radisk("key", ["value", 1234])
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!": '\x1F+0\x1F#\x1F"key\x1F=\x1F"value\x031234\x1F\n',
+      })
+      radisk("key", (err, value) => {
+        assert.deepEqual(value, ["value", 1234])
+        done()
+      })
+    }, 10)
+  })
+
+  test("write and read a plain object is undefined", (t, done) => {
+    radisk("key", {object: true})
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!": '\x1F+0\x1F#\x1F"key\x1F=undefined\n',
+      })
+      radisk("key", (err, value) => {
+        assert.deepEqual(value, undefined)
+        done()
+      })
+    }, 10)
+  })
+
+  test("write a plain object with state is also undefined", (t, done) => {
+    radisk("key", [{object: true}, 1234])
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!": '\x1F+0\x1F#\x1F"key\x1F=undefined\n',
+      })
+      radisk("key", (err, value) => {
+        assert.deepEqual(value, undefined)
+        done()
+      })
+    }, 10)
+  })
+
+  test("write and read a soul relation is ok", (t, done) => {
+    const rel = {"#": "soul"}
+    radisk("key", rel)
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!": '\x1F+0\x1F#\x1F"key\x1F=\x1F#soul\x1F\n',
+      })
+      radisk("key", (err, value) => {
+        assert.deepEqual(value, rel)
+        done()
+      })
+    }, 10)
+  })
+
+  test("write and read a soul relation with state is ok", (t, done) => {
+    const rel = [{"#": "soul"}, 1234]
+    radisk("key", rel)
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!": '\x1F+0\x1F#\x1F"key\x1F=\x1F#soul\x031234\x1F\n',
+      })
+      radisk("key", (err, value) => {
+        assert.deepEqual(value, rel)
+        done()
+      })
+    }, 10)
+  })
+
+  test("write and read value with newline", (t, done) => {
+    radisk("key", "value\ncontinued")
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!": '\x1F+0\x1F#\x1F"key\x1F=\x1F"value\ncontinued\x1F\n',
+      })
+
+      radisk("key", (err, value) => {
+        assert.equal(value, "value\ncontinued")
+        done()
+      })
+    }, 10)
+  })
+
+  test("write and read value with newline and state", (t, done) => {
+    radisk("key", ["value\ncontinued", 12345])
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!": '\x1F+0\x1F#\x1F"key\x1F=\x1F"value\ncontinued\x0312345\x1F\n',
+      })
+
+      radisk("key", (err, value) => {
+        assert.deepEqual(value, ["value\ncontinued", 12345])
+        done()
+      })
+    }, 10)
+  })
+
+  test("write more than batch size", (t, done) => {
+    radisk("keyA", "valueA")
+    radisk("keyB", "valueB")
+    radisk("keyC", "valueC")
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!":
+          '\x1F+0\x1F#\x1F"key\x1F=\x1F"value\ncontinued\x0312345\x1F\n' +
+          '\x1F+1\x1F#\x1F"A\x1F=\x1F"valueA\x1F\n' +
+          '\x1F+1\x1F#\x1F"B\x1F=\x1F"valueB\x1F\n' +
+          '\x1F+1\x1F#\x1F"C\x1F=\x1F"valueC\x1F\n',
+      })
+      radisk("keyA", (err, value) => {
+        assert.equal(value, "valueA")
+        done()
+      })
+    }, 10)
+  })
+
+  test("write and read value bigger than file size", (t, done) => {
+    const big =
+      "file size is only 100 bytes so writing this value requires calling slice"
+    radisk("newFile", big)
+    radisk("newFile", (err, value) => {
+      assert.equal(value, big)
+    })
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!":
+          '\x1F+0\x1F#\x1F"key\x1F=\x1F"value\ncontinued\x0312345\x1F\n' +
+          '\x1F+1\x1F#\x1F"A\x1F=\x1F"valueA\x1F\n' +
+          '\x1F+1\x1F#\x1F"B\x1F=\x1F"valueB\x1F\n' +
+          '\x1F+1\x1F#\x1F"C\x1F=\x1F \x1F\n',
+        keyC:
+          '\x1F+0\x1F#\x1F"keyC\x1F=\x1F"valueC\x1F\n' +
+          '\x1F+0\x1F#\x1F"newFile\x1F=\x1F \x1F\n',
+        newFile: '\x1F+0\x1F#\x1F"newFile\x1F=\x1F"' + big + "\x1F\n",
+      })
+      radisk("newFile", (err, value) => {
+        assert.equal(value, big)
+        done()
+      })
+    }, 10)
+  })
+})

package/test/radix.test.js

@@ -0,0 +1,117 @@
+import {describe, test} from "node:test"
+import assert from "node:assert/strict"
+import Radix from "../src/radix.js"
+import Names from "./names.js"
+const names = Names()
+
+// ASCII character for group separator.
+const group = String.fromCharCode(29)
+// ASCII character for record separator.
+const record = String.fromCharCode(30)
+
+describe("radix", () => {
+  const radix = Radix()
+
+  test("unit", () => {
+    radix("asdf.pub", "yum")
+    radix("ablah", "cool")
+    radix("abc", {yes: 1})
+    radix("node/circle.bob", "awesome")
+
+    assert.deepEqual(radix("asdf."), {pub: {[record]: "yum"}})
+    assert.equal(radix("nv/foo.bar"), undefined)
+    assert.equal(radix("ablah"), "cool")
+    assert.deepEqual(radix("abc"), {yes: 1})
+    assert.equal(radix("abcd"), undefined)
+    assert.deepEqual(radix(), {
+      a: {
+        [group]: {
+          "sdf.pub": {[record]: "yum"},
+          b: {
+            [group]: {
+              c: {
+                [record]: {
+                  yes: 1,
+                },
+              },
+              lah: {
+                [record]: "cool",
+              },
+            },
+          },
+        },
+      },
+      "node/circle.bob": {[record]: "awesome"},
+    })
+  })
+
+  test("replace", () => {
+    radix("asdf.pub", "yuck")
+    radix("ablah", "cool!")
+    radix("abc", {yes: 2})
+    radix("node/circle.bob", "awe")
+    radix("abcd", true)
+
+    assert.deepEqual(radix("asdf."), {pub: {[record]: "yuck"}})
+    assert.equal(radix("ablah"), "cool!")
+    assert.equal(radix("nv/foo.bar"), undefined)
+    assert.deepEqual(radix("abc"), {yes: 2})
+    assert.equal(radix("abcd"), true)
+    assert.deepEqual(radix(), {
+      a: {
+        [group]: {
+          "sdf.pub": {[record]: "yuck"},
+          b: {
+            [group]: {
+              c: {
+                [group]: {
+                  d: {
+                    [record]: true,
+                  },
+                },
+                [record]: {
+                  yes: 2,
+                },
+              },
+              lah: {
+                [record]: "cool!",
+              },
+            },
+          },
+        },
+      },
+      "node/circle.bob": {[record]: "awe"},
+    })
+  })
+
+  test("radix write read", () => {
+    // Add some shorter values to also force group matching in Radix.map.
+    radix("A", 1)
+    radix("Be", 2)
+    radix("Bo", 3)
+    radix("L", 4)
+    radix("Mi", 5)
+    var all = {}
+    names.forEach((value, index) => {
+      all[value] = index
+      radix(value, index)
+    })
+    assert.equal(Object.keys(all).length, names.length)
+    Radix.map(radix, (value, key) => {
+      delete all[key]
+    })
+    assert.equal(Object.keys(all).length, 0)
+  })
+
+  test("radix read again", () => {
+    var all = {}
+    names.forEach((value, index) => {
+      all[value] = index
+    })
+    assert.equal(Object.keys(all).length, names.length)
+    Radix.map(radix, (value, key) => {
+      delete all[key]
+    })
+    assert.equal(Object.keys(all).length, 0)
+  })
+})

package/test/sea.test.js

@@ -0,0 +1,284 @@
+import {describe, test} from "node:test"
+import assert from "node:assert/strict"
+import SEA from "../src/sea.js"
+
+// The JWK format uses "base64url" encoding, which means "+" replaced with "-"
+// and "/" with "_" and removing "=" padding. So public and private keys here
+// are strings of alphanumeric characters and underscores (regex: \w), as well
+// as dashes. The x and y values of public keys are joined by a full stop, so
+// these conditions match the following two regular expressions:
+const pubRegex = /^(\w|\-)+\.(\w|\-)+$/
+const privRegex = /^(\w|\-)+$/
+
+describe("SEA", () => {
+  test("pair await", (t, done) => {
+    ;(async () => {
+      const pair = await SEA.pair()
+      assert.match(pair.pub, pubRegex)
+      assert.match(pair.priv, privRegex)
+      assert.match(pair.epub, pubRegex)
+      assert.match(pair.epriv, privRegex)
+      done()
+    })()
+  })
+
+  test("pair callback", (t, done) => {
+    SEA.pair(pair => {
+      assert.match(pair.pub, pubRegex)
+      assert.match(pair.priv, privRegex)
+      assert.match(pair.epub, pubRegex)
+      assert.match(pair.epriv, privRegex)
+      done()
+    })
+  })
+
+  test("encrypt and decrypt string await", (t, done) => {
+    ;(async () => {
+      const pair = await SEA.pair()
+      const enc = await SEA.encrypt("hello self", pair)
+      const dec = await SEA.decrypt(enc, pair)
+      assert.equal(dec, "hello self")
+      done()
+    })()
+  })
+
+  test("encrypt and decrypt with wrong key", (t, done) => {
+    ;(async () => {
+      const alice = await SEA.pair()
+      const bob = await SEA.pair()
+      const enc = await SEA.encrypt("alice secret", alice)
+      const dec = await SEA.decrypt(enc, bob)
+      assert.equal(dec, null)
+      done()
+    })()
+  })
+
+  test("encrypt and decrypt string callback", (t, done) => {
+    SEA.pair(pair => {
+      SEA.encrypt("hello self", pair, enc => {
+        SEA.decrypt(enc, pair, dec => {
+          assert.equal(dec, "hello self")
+          done()
+        })
+      })
+    })
+  })
+
+  test("encrypt and decrypt object await", (t, done) => {
+    ;(async () => {
+      const pair = await SEA.pair()
+      const enc = await SEA.encrypt({test: "hello self"}, pair)
+      const dec = await SEA.decrypt(enc, pair)
+      assert.deepEqual(dec, {test: "hello self"})
+      done()
+    })()
+  })
+
+  test("encrypt and decrypt object callback", (t, done) => {
+    SEA.pair(pair => {
+      SEA.encrypt({test: "hello self"}, pair, enc => {
+        SEA.decrypt(enc, pair, dec => {
+          assert.deepEqual(dec, {test: "hello self"})
+          done()
+        })
+      })
+    })
+  })
+
+  test("sign and verify string await", (t, done) => {
+    ;(async () => {
+      const pair = await SEA.pair()
+      const signed = await SEA.sign("hello self", pair)
+      const verified = await SEA.verify(signed, pair)
+      assert.equal(verified, "hello self")
+      done()
+    })()
+  })
+
+  test("sign and verify with wrong key", (t, done) => {
+    ;(async () => {
+      const alice = await SEA.pair()
+      const bob = await SEA.pair()
+      const signed = await SEA.sign("signed by alice", alice)
+      const verified = await SEA.verify(signed, bob)
+      assert.equal(verified, null)
+      done()
+    })()
+  })
+
+  test("sign and verify string callback", (t, done) => {
+    SEA.pair(pair => {
+      SEA.sign("hello self", pair, signed => {
+        SEA.verify(signed, pair, verified => {
+          assert.equal(verified, "hello self")
+          done()
+        })
+      })
+    })
+  })
+
+  test("sign and verify object await", (t, done) => {
+    ;(async () => {
+      const pair = await SEA.pair()
+      const signed = await SEA.sign({test: "hello self"}, pair)
+      const verified = await SEA.verify(signed, pair)
+      assert.deepEqual(verified, {test: "hello self"})
+      done()
+    })()
+  })
+
+  test("sign and verify object callback", (t, done) => {
+    SEA.pair(pair => {
+      SEA.sign({test: "hello self"}, pair, signed => {
+        SEA.verify(signed, pair, verified => {
+          assert.deepEqual(verified, {test: "hello self"})
+          done()
+        })
+      })
+    })
+  })
+
+  test("work with salt encrypt string callback", (t, done) => {
+    SEA.work("hello", "salt", work => {
+      SEA.encrypt("hello work", work, enc => {
+        SEA.decrypt(enc, work, dec => {
+          assert.equal(dec, "hello work")
+          done()
+        })
+      })
+    })
+  })
+
+  test("work with salt encrypt string await", (t, done) => {
+    ;(async () => {
+      const work = await SEA.work("hello", "salt")
+      const enc = await SEA.encrypt("hello work", work)
+      const dec = await SEA.decrypt(enc, work)
+      assert.equal(dec, "hello work")
+      done()
+    })()
+  })
+
+  test("work with salt encrypt object callback", (t, done) => {
+    SEA.work("hello", "salt", work => {
+      SEA.encrypt({test: "hello work"}, work, enc => {
+        SEA.decrypt(enc, work, dec => {
+          assert.deepEqual(dec, {test: "hello work"})
+          done()
+        })
+      })
+    })
+  })
+
+  test("work with salt encrypt object await", (t, done) => {
+    ;(async () => {
+      const work = await SEA.work("hello", "salt")
+      const enc = await SEA.encrypt({test: "hello work"}, work)
+      const dec = await SEA.decrypt(enc, work)
+      assert.deepEqual(dec, {test: "hello work"})
+      done()
+    })()
+  })
+
+  test("work no salt encrypt string callback", (t, done) => {
+    SEA.work("hello", work => {
+      SEA.encrypt("hello work", work, enc => {
+        SEA.decrypt(enc, work, dec => {
+          assert.equal(dec, "hello work")
+          done()
+        })
+      })
+    })
+  })
+
+  test("work no salt encrypt string await", (t, done) => {
+    ;(async () => {
+      const work = await SEA.work("hello")
+      const enc = await SEA.encrypt("hello work", work)
+      const dec = await SEA.decrypt(enc, work)
+      assert.equal(dec, "hello work")
+      done()
+    })()
+  })
+
+  test("work no salt encrypt object callback", (t, done) => {
+    SEA.work("hello", work => {
+      SEA.encrypt({test: "hello work"}, work, enc => {
+        SEA.decrypt(enc, work, dec => {
+          assert.deepEqual(dec, {test: "hello work"})
+          done()
+        })
+      })
+    })
+  })
+
+  test("work no salt encrypt object await", (t, done) => {
+    ;(async () => {
+      const work = await SEA.work("hello")
+      const enc = await SEA.encrypt({test: "hello work"}, work)
+      const dec = await SEA.decrypt(enc, work)
+      assert.deepEqual(dec, {test: "hello work"})
+      done()
+    })()
+  })
+
+  test("secret string callback", (t, done) => {
+    SEA.pair(alice => {
+      SEA.pair(bob => {
+        SEA.secret(bob, alice, to => {
+          SEA.encrypt("shared data", to, enc => {
+            SEA.secret(alice, bob, from => {
+              SEA.decrypt(enc, from, dec => {
+                assert.equal(dec, "shared data")
+                done()
+              })
+            })
+          })
+        })
+      })
+    })
+  })
+
+  test("secret string await", (t, done) => {
+    ;(async () => {
+      const alice = await SEA.pair()
+      const bob = await SEA.pair()
+      const to = await SEA.secret(bob, alice)
+      const enc = await SEA.encrypt("shared data", to)
+      const from = await SEA.secret(alice, bob)
+      const dec = await SEA.decrypt(enc, from)
+      assert.equal(dec, "shared data")
+      done()
+    })()
+  })
+
+  test("secret object callback", (t, done) => {
+    SEA.pair(alice => {
+      SEA.pair(bob => {
+        SEA.secret(bob, alice, to => {
+          SEA.encrypt({test: "shared data"}, to, enc => {
+            SEA.secret(alice, bob, from => {
+              SEA.decrypt(enc, from, dec => {
+                assert.deepEqual(dec, {test: "shared data"})
+                done()
+              })
+            })
+          })
+        })
+      })
+    })
+  })
+
+  test("secret object await", (t, done) => {
+    ;(async () => {
+      const alice = await SEA.pair()
+      const bob = await SEA.pair()
+      const to = await SEA.secret(bob, alice)
+      const enc = await SEA.encrypt({test: "shared data"}, to)
+      const from = await SEA.secret(alice, bob)
+      const dec = await SEA.decrypt(enc, from)
+      assert.deepEqual(dec, {test: "shared data"})
+      done()
+    })()
+  })
+})