@mblaney/holster 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mblaney/holster",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Holster is a service that allows synchronising data between devices using Node, Deno, Bun or the browser.",
   "type": "module",
   "main": "index.js",

package/src/radisk.js

@@ -119,7 +119,6 @@ const Radisk = opt => {
   // 4. Read the previous file into memory
   // 5. Scan through in memory radix for all values lexically less than limit
   // 6. Merge and write all of those to the in-memory file and back to disk
-  // 7. If file is to large then split. More details needed here
   radisk.save = (rad, cb) => {
     const save = {
       find: (tree, key) => {
@@ -135,11 +134,12 @@ const Radisk = opt => {
           save.end = file
           // ! is used as the first file name as it's the first printable
           // character, so always matches as lexically less than any node.
-          save.mix(save.file || "!", save.start, save.end)
-          return true
+          // Also save.start can be set to undefined by a previous call to
+          // save.mix, so don't continue in this case.
+          if (save.start) save.mix(save.file || "!", save.start, save.end)
+        } else {
+          save.file = file
         }
-
-        save.file = file
       },
       mix: (file, start, end) => {
         save.start = save.end = save.file = u
@@ -151,7 +151,7 @@ const Radisk = opt => {
 
             if (end && end < key) {
               save.start = key
-              return save.start
+              return
             }
 
             disk(key, value)
@@ -175,69 +175,47 @@ const Radisk = opt => {
     cache = null
     const write = {
       text: "",
+      limit: "",
+      done: false,
       count: 0,
-      file: file,
       each: (value, key, k, pre) => {
+        // each is called for all keys, but stop adding to write.text when
+        // write.slice is called, then the current contents of write.text
+        // will be written to file.
+        if (write.done) return
+
         write.count++
-        var enc =
-          Radisk.encode(pre.length) +
-          "#" +
-          Radisk.encode(k) +
-          (typeof value === "undefined" ? "" : "=" + Radisk.encode(value)) +
-          "\n"
-        // Cannot split the file if only have one entry to write.
-        if (write.count > 1 && write.text.length + enc.length > opt.size) {
-          write.text = ""
-          // Otherwise split the entries in half.
-          write.limit = Math.ceil(write.count / 2)
-          write.count = 0
+        value = typeof value === "undefined" ? "" : "=" + Radisk.encode(value)
+        const enc =
+          Radisk.encode(pre.length) + "#" + Radisk.encode(k) + value + "\n"
+        // Cannot split the file if only have one entry to write. Also don't
+        // start a split if in the middle of writing a node (pre > 0).
+        if (
+          write.count > 1 &&
+          pre.length === 0 &&
+          write.text.length + enc.length > opt.size
+        ) {
+          const end = k.indexOf(enq)
+          write.limit = end === -1 ? k : k.substring(0, end)
+          write.done = true
           write.sub = Radix()
           Radix.map(rad, write.slice)
-          return true
+          radisk.write(write.limit, write.sub, cb)
+          return
         }
 
         write.text += enc
       },
-      put: () => {
-        opt.store.put(file, write.text, cb)
-      },
       slice: (value, key) => {
-        if (key < write.file) return
-
-        if (++write.count > write.limit) {
-          var name = write.file
-          // Use only the soul of the key as the filename so that all
-          // properties of a soul are written to the same file.
-          let end = key.indexOf(enq)
-          if (end === -1) {
-            write.file = key
-          } else {
-            write.file = key.substring(0, end)
-          }
-          // write.limit can be reached after already writing properties of
-          // the current node, so remove it from write.sub before writing to
-          // disk so that it's not duplicated across files.
-          write.sub(write.file, null)
-          write.count = 0
-          radisk.write(name, write.sub, write.next)
-          return true
-        }
+        if (key < write.limit) return
 
         write.sub(key, value)
       },
-      next: err => {
-        if (err) return cb(err)
-
-        write.sub = Radix()
-        if (!Radix.map(rad, write.slice)) {
-          radisk.write(write.file, write.sub, cb)
-        }
-      },
     }
-    // If Radix.map doesn't return true when called with write.each as a
-    // callback then didn't need to split the data. The accumulated write.text
-    // can then be stored with write.put().
-    if (!Radix.map(rad, write.each, true)) write.put()
+    Radix.map(rad, write.each, true)
+    // There is always accumulated write.text to store once write.each has
+    // finished.
+    opt.store.put(file, write.text, cb)
   }
 
   radisk.read = (key, cb) => {
@@ -246,11 +224,8 @@ const Radisk = opt => {
       if (typeof value !== "undefined") return cb(u, value)
     }
     // Only the soul of the key is compared to filenames (see radisk.write).
-    let soul = key
-    let end = key.indexOf(enq)
-    if (end !== -1) {
-      soul = key.substring(0, end)
-    }
+    const end = key.indexOf(enq)
+    const soul = end === -1 ? key : key.substring(0, end)
 
     const read = {
       lex: file => {

package/test/radisk.test.js

@@ -1,8 +1,6 @@
 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 = {}
@@ -25,6 +23,8 @@ describe("radisk", () => {
     },
   }
   const radisk = Radisk(opt)
+  const big =
+    "file size is only 100 bytes so writing this value requires calling slice"
 
   test("write and read from memory", (t, done) => {
     radisk("key", "value", () => {
@@ -164,8 +164,6 @@ describe("radisk", () => {
   })
 
   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)
@@ -176,10 +174,7 @@ describe("radisk", () => {
           '\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',
+          '\x1F+1\x1F#\x1F"C\x1F=\x1F"valueC\x1F\n',
         newFile: '\x1F+0\x1F#\x1F"newFile\x1F=\x1F"' + big + "\x1F\n",
       })
       radisk("newFile", (err, value) => {
@@ -188,4 +183,148 @@ describe("radisk", () => {
       })
     }, 10)
   })
+
+  // This tests trying to add to a file that is already too long, so needs to
+  // split again. Previously wasn't able to do this and would loop.
+  test("write and read a small value after split", (t, done) => {
+    radisk("small", "small value")
+    radisk("small", (err, value) => {
+      assert.equal(value, "small value")
+    })
+    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',
+        newFile: '\x1F+0\x1F#\x1F"newFile\x1F=\x1F"' + big + "\x1F\n",
+        small: '\x1F+0\x1F#\x1F"small\x1F=\x1F"small value\x1F\n',
+      })
+      done()
+    }, 10)
+  })
+
+  // This tests how existing files are handled when they are made smaller than
+  // the maximum file size. (They should be kept as they are created so that
+  // we don't have to deal with removing files.)
+  test("write small value to newFile", (t, done) => {
+    radisk("newFile", "removed...")
+    radisk("newFile", (err, value) => {
+      assert.equal(value, "removed...")
+    })
+    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',
+        newFile: '\x1F+0\x1F#\x1F"newFile\x1F=\x1F"removed...\x1F\n',
+        small: '\x1F+0\x1F#\x1F"small\x1F=\x1F"small value\x1F\n',
+      })
+      done()
+    }, 10)
+  })
+
+  // This tests ignoring the maximum file size when writing sub-keys. Since
+  // radisk.write has already been called for a key it would previously get
+  // duplicated when trying to split due to reaching the max length.
+  test("write big value to first file", (t, done) => {
+    radisk("keyA", big)
+    radisk("keyA", (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"' +
+          big +
+          "\x1F\n" +
+          '\x1F+1\x1F#\x1F"B\x1F=\x1F"valueB\x1F\n' +
+          '\x1F+1\x1F#\x1F"C\x1F=\x1F"valueC\x1F\n',
+        newFile: '\x1F+0\x1F#\x1F"newFile\x1F=\x1F"removed...\x1F\n',
+        small: '\x1F+0\x1F#\x1F"small\x1F=\x1F"small value\x1F\n',
+      })
+      done()
+    }, 10)
+  })
+
+  test("add to last file", (t, done) => {
+    radisk("smallContinued", "continued value")
+    radisk("smallContinued", (err, value) => {
+      assert.equal(value, "continued value")
+    })
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!":
+          '\x1F+0\x1F#\x1F"key\x1F=\x1F"value\ncontinued\x0312345\x1F\n' +
+          '\x1F+1\x1F#\x1F"A\x1F=\x1F"' +
+          big +
+          "\x1F\n" +
+          '\x1F+1\x1F#\x1F"B\x1F=\x1F"valueB\x1F\n' +
+          '\x1F+1\x1F#\x1F"C\x1F=\x1F"valueC\x1F\n',
+        newFile: '\x1F+0\x1F#\x1F"newFile\x1F=\x1F"removed...\x1F\n',
+        small:
+          '\x1F+0\x1F#\x1F"small\x1F=\x1F"small value\x1F\n' +
+          '\x1F+1\x1F#\x1F"Continued\x1F=\x1F"continued value\x1F\n',
+      })
+      done()
+    }, 10)
+  })
+
+  test("set a key to null and add a value to that file", (t, done) => {
+    radisk("keyC", null)
+    radisk("keyC", (err, value) => {
+      assert.equal(value, null)
+    })
+    radisk("keyD", "valueD")
+    radisk("keyD", (err, value) => {
+      assert.equal(value, "valueD")
+    })
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!":
+          '\x1F+0\x1F#\x1F"key\x1F=\x1F"value\ncontinued\x0312345\x1F\n' +
+          '\x1F+1\x1F#\x1F"A\x1F=\x1F"' +
+          big +
+          "\x1F\n" +
+          '\x1F+1\x1F#\x1F"B\x1F=\x1F"valueB\x1F\n' +
+          '\x1F+1\x1F#\x1F"C\x1F=\x1F \x1F\n' +
+          '\x1F+1\x1F#\x1F"D\x1F=\x1F"valueD\x1F\n',
+        newFile: '\x1F+0\x1F#\x1F"newFile\x1F=\x1F"removed...\x1F\n',
+        small:
+          '\x1F+0\x1F#\x1F"small\x1F=\x1F"small value\x1F\n' +
+          '\x1F+1\x1F#\x1F"Continued\x1F=\x1F"continued value\x1F\n',
+      })
+      done()
+    }, 10)
+  })
+
+  test("set first keys to null", (t, done) => {
+    radisk("key", null)
+    radisk("key", (err, value) => {
+      assert.equal(value, null)
+    })
+    radisk("keyA", null)
+    radisk("keyA", (err, value) => {
+      assert.equal(value, null)
+    })
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!":
+          '\x1F+0\x1F#\x1F"key\x1F=\x1F \x1F\n' +
+          '\x1F+1\x1F#\x1F"A\x1F=\x1F \x1F\n' +
+          '\x1F+1\x1F#\x1F"B\x1F=\x1F"valueB\x1F\n' +
+          '\x1F+1\x1F#\x1F"C\x1F=\x1F \x1F\n' +
+          '\x1F+1\x1F#\x1F"D\x1F=\x1F"valueD\x1F\n',
+        newFile: '\x1F+0\x1F#\x1F"newFile\x1F=\x1F"removed...\x1F\n',
+        small:
+          '\x1F+0\x1F#\x1F"small\x1F=\x1F"small value\x1F\n' +
+          '\x1F+1\x1F#\x1F"Continued\x1F=\x1F"continued value\x1F\n',
+      })
+      done()
+    }, 10)
+  })
 })

package/test/split.test.js

@@ -0,0 +1,317 @@
+import {describe, test} from "node:test"
+import assert from "node:assert/strict"
+import Radisk from "../src/radisk.js"
+
+// ASCII character for enquiry.
+const enq = String.fromCharCode(5)
+
+describe("split", () => {
+  const puts = {}
+  const opt = {
+    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)
+  const now = Date.now()
+  const lorem =
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
+  const parent = () => {
+    return (
+      '\x1F+0\x1F#\x1F"parent\x05\x1F\n' +
+      '\x1F+1\x1F#\x1F"boolean\x1F=\x1F+\x03' +
+      now +
+      "\x1F\n" +
+      '\x1F+1\x1F#\x1F"number\x1F=\x1F+42\x03' +
+      now +
+      "\x1F\n" +
+      '\x1F+1\x1F#\x1F"rel\x1F=\x1F#child\x03' +
+      now +
+      "\x1F\n" +
+      '\x1F+1\x1F#\x1F"string\x1F=\x1F"parent value\x03' +
+      now +
+      "\x1F\n"
+    )
+  }
+  const child = () => {
+    return (
+      '\x1F+0\x1F#\x1F"child\x05\x1F\n' +
+      '\x1F+1\x1F#\x1F"boolean\x1F=\x1F+\x03' +
+      now +
+      "\x1F\n" +
+      '\x1F+1\x1F#\x1F"number\x1F=\x1F+43\x03' +
+      now +
+      "\x1F\n" +
+      '\x1F+1\x1F#\x1F"rel\x1F=\x1F#grandchild\x03' +
+      now +
+      "\x1F\n" +
+      '\x1F+1\x1F#\x1F"string\x1F=\x1F"child value\x03' +
+      now +
+      "\x1F\n"
+    )
+  }
+  const grandchild = () => {
+    return (
+      '\x1F+0\x1F#\x1F"grandchild\x05\x1F\n' +
+      '\x1F+1\x1F#\x1F"boolean\x1F=\x1F-\x03' +
+      now +
+      "\x1F\n" +
+      '\x1F+1\x1F#\x1F"number\x1F=\x1F+44\x03' +
+      now +
+      "\x1F\n" +
+      '\x1F+1\x1F#\x1F"rel\x1F=\x1F#toys\x03' +
+      now +
+      "\x1F\n" +
+      '\x1F+1\x1F#\x1F"string\x1F=\x1F"grandchild value\x03' +
+      now +
+      "\x1F\n"
+    )
+  }
+  const toys = () => {
+    return (
+      '\x1F+0\x1F#\x1F"toys\x05\x1F\n' +
+      '\x1F+1\x1F#\x1F"b\x1F\n' +
+      '\x1F+2\x1F#\x1F"all\x1F=\x1F"green\x03' +
+      now +
+      "\x1F\n" +
+      '\x1F+2\x1F#\x1F"ook\x1F=\x1F"' +
+      lorem +
+      "\x03" +
+      now +
+      "\x1F\n" +
+      '\x1F+1\x1F#\x1F"car\x1F=\x1F"red\x03' +
+      now +
+      "\x1F\n"
+    )
+  }
+  const alpha = () => {
+    return (
+      '\x1F+0\x1F#\x1F"alpha\x05\x1F\n' +
+      '\x1F+1\x1F#\x1F"boolean\x1F=\x1F+\x03' +
+      now +
+      "\x1F\n" +
+      '\x1F+1\x1F#\x1F"number\x1F=\x1F+1\x03' +
+      now +
+      "\x1F\n" +
+      '\x1F+1\x1F#\x1F"rel\x1F=\x1F#beta\x03' +
+      now +
+      "\x1F\n" +
+      '\x1F+1\x1F#\x1F"string\x1F=\x1F"alpha value\x03' +
+      now +
+      "\x1F\n"
+    )
+  }
+
+  test("write a parent node", (t, done) => {
+    radisk("parent" + enq + "string", ["parent value", now])
+    radisk("parent" + enq + "number", [42, now])
+    radisk("parent" + enq + "boolean", [true, now])
+    radisk("parent" + enq + "rel", [{"#": "child"}, now])
+
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!": parent(),
+      })
+      done()
+    }, 10)
+  })
+
+  test("write a child node", (t, done) => {
+    radisk("child" + enq + "string", ["child value", now])
+    radisk("child" + enq + "number", [43, now])
+    radisk("child" + enq + "boolean", [true, now])
+    radisk("child" + enq + "rel", [{"#": "grandchild"}, now])
+
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!": child(),
+        parent: parent(),
+      })
+      done()
+    }, 10)
+  })
+
+  test("write a grandchild node", (t, done) => {
+    radisk("grandchild" + enq + "string", ["grandchild value", now])
+    radisk("grandchild" + enq + "number", [44, now])
+    radisk("grandchild" + enq + "boolean", [false, now])
+    radisk("grandchild" + enq + "rel", [{"#": "toys"}, now])
+
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!": child(),
+        parent: parent(),
+        grandchild: grandchild(),
+      })
+      done()
+    }, 10)
+  })
+
+  test("write grandchild toys", (t, done) => {
+    radisk("toys" + enq + "car", ["red", now])
+    radisk("toys" + enq + "ball", ["green", now])
+    radisk("toys" + enq + "book", [lorem, now])
+
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!": child(),
+        parent: parent(),
+        grandchild: grandchild(),
+        toys: toys(),
+      })
+      done()
+    }, 10)
+  })
+
+  test("write new first node", (t, done) => {
+    radisk("alpha" + enq + "string", ["alpha value", now])
+    radisk("alpha" + enq + "number", [1, now])
+    radisk("alpha" + enq + "boolean", [true, now])
+    radisk("alpha" + enq + "rel", [{"#": "beta"}, now])
+    radisk("beta" + enq + "string", ["beta value", now])
+
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!": alpha(),
+        beta:
+          '\x1F+0\x1F#\x1F"beta\x05string\x1F=\x1F"beta value\x03' +
+          now +
+          "\x1F\n" +
+          child(),
+        parent: parent(),
+        grandchild: grandchild(),
+        toys: toys(),
+      })
+      done()
+    }, 10)
+  })
+
+  // Note that "beta" remains a separate file here (nodes aren't combined).
+  test("write new second node", (t, done) => {
+    radisk("be" + enq + "string", ["be value", now])
+
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!": alpha(),
+        be:
+          '\x1F+0\x1F#\x1F"be\x05string\x1F=\x1F"be value\x03' + now + "\x1F\n",
+        beta:
+          '\x1F+0\x1F#\x1F"beta\x05string\x1F=\x1F"beta value\x03' +
+          now +
+          "\x1F\n" +
+          child(),
+        parent: parent(),
+        grandchild: grandchild(),
+        toys: toys(),
+      })
+      done()
+    }, 10)
+  })
+
+  test("add a parent item", (t, done) => {
+    radisk("parent" + enq + "after", ["this was added after", now])
+
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!": alpha(),
+        be:
+          '\x1F+0\x1F#\x1F"be\x05string\x1F=\x1F"be value\x03' + now + "\x1F\n",
+        beta:
+          '\x1F+0\x1F#\x1F"beta\x05string\x1F=\x1F"beta value\x03' +
+          now +
+          "\x1F\n" +
+          child(),
+        grandchild: grandchild(),
+        parent:
+          '\x1F+0\x1F#\x1F"parent\x05\x1F\n' +
+          '\x1F+1\x1F#\x1F"after\x1F=\x1F"this was added after\x03' +
+          now +
+          "\x1F\n" +
+          '\x1F+1\x1F#\x1F"boolean\x1F=\x1F+\x03' +
+          now +
+          "\x1F\n" +
+          '\x1F+1\x1F#\x1F"number\x1F=\x1F+42\x03' +
+          now +
+          "\x1F\n" +
+          '\x1F+1\x1F#\x1F"rel\x1F=\x1F#child\x03' +
+          now +
+          "\x1F\n" +
+          '\x1F+1\x1F#\x1F"string\x1F=\x1F"parent value\x03' +
+          now +
+          "\x1F\n",
+        toys: toys(),
+      })
+      done()
+    }, 10)
+  })
+
+  test("add two child items", (t, done) => {
+    radisk("child" + enq + "book", [lorem, now])
+    radisk("child" + enq + "pi", [3.14159, now])
+
+    setTimeout(() => {
+      assert.deepEqual(puts, {
+        "!": alpha(),
+        be:
+          '\x1F+0\x1F#\x1F"be\x05string\x1F=\x1F"be value\x03' + now + "\x1F\n",
+        beta:
+          '\x1F+0\x1F#\x1F"beta\x05string\x1F=\x1F"beta value\x03' +
+          now +
+          "\x1F\n" +
+          '\x1F+0\x1F#\x1F"child\x05\x1F\n' +
+          '\x1F+1\x1F#\x1F"boo\x1F\n' +
+          '\x1F+2\x1F#\x1F"k\x1F=\x1F"' +
+          lorem +
+          "\x03" +
+          now +
+          "\x1F\n" +
+          '\x1F+2\x1F#\x1F"lean\x1F=\x1F+\x03' +
+          now +
+          "\x1F\n" +
+          '\x1F+1\x1F#\x1F"number\x1F=\x1F+43\x03' +
+          now +
+          "\x1F\n" +
+          '\x1F+1\x1F#\x1F"pi\x1F=\x1F+3.14159\x03' +
+          now +
+          "\x1F\n" +
+          '\x1F+1\x1F#\x1F"rel\x1F=\x1F#grandchild\x03' +
+          now +
+          "\x1F\n" +
+          '\x1F+1\x1F#\x1F"string\x1F=\x1F"child value\x03' +
+          now +
+          "\x1F\n",
+        grandchild: grandchild(),
+        parent:
+          '\x1F+0\x1F#\x1F"parent\x05\x1F\n' +
+          '\x1F+1\x1F#\x1F"after\x1F=\x1F"this was added after\x03' +
+          now +
+          "\x1F\n" +
+          '\x1F+1\x1F#\x1F"boolean\x1F=\x1F+\x03' +
+          now +
+          "\x1F\n" +
+          '\x1F+1\x1F#\x1F"number\x1F=\x1F+42\x03' +
+          now +
+          "\x1F\n" +
+          '\x1F+1\x1F#\x1F"rel\x1F=\x1F#child\x03' +
+          now +
+          "\x1F\n" +
+          '\x1F+1\x1F#\x1F"string\x1F=\x1F"parent value\x03' +
+          now +
+          "\x1F\n",
+        toys: toys(),
+      })
+      done()
+    }, 10)
+  })
+})

package/test/store.test.js

@@ -75,7 +75,7 @@ describe("store", () => {
       },
       err => {
         assert.equal(err, null)
-        fs.access("test/multiple/keyC", err => {
+        fs.access("test/multiple/!", err => {
           assert.equal(err, null)
           fs.access("test/multiple/newFile", err => {
             assert.equal(err, null)
@@ -103,7 +103,7 @@ describe("store", () => {
     })
   })
 
-  test("get keys from second file", (t, done) => {
+  test("get another key from first file", (t, done) => {
     multiple.get({"#": "keyC"}, (err, value) => {
       assert.deepEqual(value, {
         keyC: {
@@ -135,7 +135,7 @@ describe("store", () => {
     })
   })
 
-  test("get key from third file", (t, done) => {
+  test("get key from second file", (t, done) => {
     multiple.get({"#": "newFile"}, (err, value) => {
       assert.deepEqual(value, {
         newFile: {