replace tape with node:test

lib/index.js

@@ -1,4 +1,4 @@
-const path = require('path')
+const path = require('node:path')
 const push = require('push-stream')
 const AAOL = require('async-append-only-log')
 const promisify = require('promisify-4loc')

package.json

@@ -2,10 +2,17 @@
   "name": "ppppp-db",
   "version": "0.0.1",
   "description": "Default ppppp database",
+  "homepage": "https://github.com/staltz/ppppp-db",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:staltz/ppppp-db.git"
+  },
+  "author": "Andre Staltz <contact@staltz.com>",
+  "license": "MIT",
+  "type": "commonjs",
   "main": "lib/index.js",
   "files": [
-    "*.js",
+    "lib/**/*"
-    "lib/**/*.js"
   ],
   "engines": {
     "node": ">=16"
@@ -14,21 +21,10 @@
     ".": {
       "require": "./lib/index.js"
     },
-    "./feed-v1": {
-      "require": "./lib/feed-v1/index.js"
-    },
     "./msg-v2": {
       "require": "./lib/msg-v2/index.js"
     }
   },
-  "type": "commonjs",
-  "author": "Andre Staltz <contact@staltz.com>",
-  "license": "MIT",
-  "homepage": "https://github.com/staltz/ppppp-db",
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:staltz/ppppp-db.git"
-  },
   "dependencies": {
     "async-append-only-log": "^4.3.10",
     "blake3": "^2.1.7",
@@ -50,12 +46,10 @@
     "ssb-bendy-butt": "^1.0.0",
     "ssb-box": "^1.0.1",
     "ssb-caps": "^1.1.0",
-    "ssb-classic": "^1.1.0",
+    "ssb-classic": "^1.1.0"
-    "tap-arc": "^0.3.5",
-    "tape": "^5.6.3"
   },
   "scripts": {
-    "test": "tape 'test/**/*.test.js' | tap-arc --bail",
+    "test": "node --test",
     "format-code": "prettier --write \"(lib|test)/**/*.js\"",
     "format-code-staged": "pretty-quick --staged --pattern \"(lib|test)/**/*.js\"",
     "coverage": "c8 --reporter=lcov npm run test"

test/add.test.js

@@ -1,7 +1,8 @@
-const test = require('tape')
+const test = require('node:test')
-const path = require('path')
+const assert = require('node:assert')
-const os = require('os')
+const path = require('node:path')
-const p = require('util').promisify
+const os = require('node:os')
+const p = require('node:util').promisify
 const rimraf = require('rimraf')
 const SecretStack = require('secret-stack')
 const caps = require('ssb-caps')
@@ -29,7 +30,7 @@ test('add()', async (t) => {
   const rootHash = MsgV2.getMsgHash(rootMsg)
 
   const recRoot = await p(peer.db.add)(rootMsg, rootHash)
-  t.equals(recRoot.msg.metadata.dataSize, 0, 'root msg added')
+  assert.equal(recRoot.msg.metadata.dataSize, 0, 'root msg added')
   const tangle = new MsgV2.Tangle(rootHash)
   tangle.add(recRoot.hash, recRoot.msg)
 
@@ -45,7 +46,7 @@ test('add()', async (t) => {
   })
 
   const rec = await p(peer.db.add)(inputMsg, rootHash)
-  t.equal(rec.msg.data.text, 'This is the first post!')
+  assert.equal(rec.msg.data.text, 'This is the first post!')
 
   await p(peer.close)(true)
 })

test/del.test.js

@@ -1,13 +1,14 @@
-const test = require('tape')
+const test = require('node:test')
-const path = require('path')
+const assert = require('node:assert')
-const os = require('os')
+const path = require('node:path')
+const os = require('node:os')
+const p = require('node:util').promisify
 const rimraf = require('rimraf')
 const SecretStack = require('secret-stack')
 const AAOL = require('async-append-only-log')
 const push = require('push-stream')
 const caps = require('ssb-caps')
 const Keypair = require('ppppp-keypair')
-const p = require('util').promisify
 
 const DIR = path.join(os.tmpdir(), 'ppppp-db-del')
 rimraf.sync(DIR)
@@ -37,7 +38,7 @@ test('del', async (t) => {
     if (msg.data && msg.metadata.group) before.push(msg.data.text)
   }
 
-  t.deepEqual(before, ['m0', 'm1', 'm2', 'm3', 'm4'], 'msgs before the delete')
+  assert.deepEqual(before, ['m0', 'm1', 'm2', 'm3', 'm4'], 'msgs before the delete')
 
   await p(peer.db.del)(msgHashes[2])
 
@@ -46,7 +47,7 @@ test('del', async (t) => {
     if (msg.data && msg.metadata.group) after.push(msg.data.text)
   }
 
-  t.deepEqual(after, ['m0', 'm1', 'm3', 'm4'], 'msgs after the delete')
+  assert.deepEqual(after, ['m0', 'm1', 'm3', 'm4'], 'msgs after the delete')
 
   await p(peer.close)(true)
 
@@ -80,7 +81,7 @@ test('del', async (t) => {
     )
   })
 
-  t.deepEqual(
+  assert.deepEqual(
     persistedMsgs
       .filter((msg) => msg.data && msg.metadata.group)
       .map((msg) => msg.data.text),

test/erase.test.js

@@ -1,13 +1,14 @@
-const test = require('tape')
+const test = require('node:test')
-const path = require('path')
+const assert = require('node:assert')
-const os = require('os')
+const path = require('node:path')
+const os = require('node:os')
+const p = require('node:util').promisify
 const rimraf = require('rimraf')
 const SecretStack = require('secret-stack')
 const AAOL = require('async-append-only-log')
 const push = require('push-stream')
 const caps = require('ssb-caps')
 const Keypair = require('ppppp-keypair')
-const p = require('util').promisify
 
 const DIR = path.join(os.tmpdir(), 'ppppp-db-erase')
 rimraf.sync(DIR)
@@ -37,7 +38,11 @@ test('erase', async (t) => {
     if (msg.data && msg.metadata.group) before.push(msg.data.text)
   }
 
-  t.deepEqual(before, ['m0', 'm1', 'm2', 'm3', 'm4'], '5 msgs before the erase')
+  assert.deepEqual(
+    before,
+    ['m0', 'm1', 'm2', 'm3', 'm4'],
+    '5 msgs before the erase'
+  )
 
   await p(peer.db.erase)(msgHashes[2])
 
@@ -46,7 +51,7 @@ test('erase', async (t) => {
     if (msg.data && msg.metadata.group) after.push(msg.data.text)
   }
 
-  t.deepEqual(after, ['m0', 'm1', 'm3', 'm4'], '4 msgs after the erase')
+  assert.deepEqual(after, ['m0', 'm1', 'm3', 'm4'], '4 msgs after the erase')
 
   const after2 = []
   for (const msg of peer.db.msgs()) {
@@ -55,7 +60,7 @@ test('erase', async (t) => {
     }
   }
 
-  t.deepEqual(after2, [1, 2, 3, 4, 5], '5 metadata exists after the erase')
+  assert.deepEqual(after2, [1, 2, 3, 4, 5], '5 metadata exists after the erase')
 
   await p(peer.close)(true)
 

test/feed-get-id.test.js

@@ -1,10 +1,11 @@
-const test = require('tape')
+const test = require('node:test')
-const path = require('path')
+const assert = require('node:assert')
-const os = require('os')
+const path = require('node:path')
+const os = require('node:os')
+const p = require('node:util').promisify
 const rimraf = require('rimraf')
 const SecretStack = require('secret-stack')
 const caps = require('ssb-caps')
-const p = require('util').promisify
 const Keypair = require('ppppp-keypair')
 const MsgV2 = require('../lib/msg-v2')
 
@@ -33,7 +34,7 @@ test('setup', async (t) => {
 
 test('feed.getId()', async (t) => {
   const id = peer.db.feed.getId(group, 'post')
-  t.equals(id, rootHash, 'feed.getId() returns root hash')
+  assert.equal(id, rootHash, 'feed.getId() returns root hash')
 })
 
 test('teardown', (t) => {

test/feed-publish.test.js

@@ -1,10 +1,11 @@
-const test = require('tape')
+const test = require('node:test')
-const path = require('path')
+const assert = require('node:assert')
-const os = require('os')
+const path = require('node:path')
+const os = require('node:os')
+const p = require('node:util').promisify
 const rimraf = require('rimraf')
 const SecretStack = require('secret-stack')
 const caps = require('ssb-caps')
-const p = require('util').promisify
 const Keypair = require('ppppp-keypair')
 const MsgV2 = require('../lib/msg-v2')
 
@@ -39,13 +40,13 @@ test('feed.publish()', async (t) => {
     type: 'post',
     data: { text: 'I am 1st post' },
   })
-  t.equal(rec1.msg.data.text, 'I am 1st post', 'msg1 text correct')
+  assert.equal(rec1.msg.data.text, 'I am 1st post', 'msg1 text correct')
-  t.equal(
+  assert.equal(
     rec1.msg.metadata.tangles[rootHash].depth,
     1,
     'msg1 tangle depth correct'
   )
-  t.deepEquals(
+  assert.deepEqual(
     rec1.msg.metadata.tangles[rootHash].prev,
     [rootHash],
     'msg1 tangle prev correct'
@@ -58,13 +59,13 @@ test('feed.publish()', async (t) => {
     type: 'post',
     data: { text: 'I am 2nd post' },
   })
-  t.equal(rec2.msg.data.text, 'I am 2nd post', 'msg2 text correct')
+  assert.equal(rec2.msg.data.text, 'I am 2nd post', 'msg2 text correct')
-  t.equal(
+  assert.equal(
     rec2.msg.metadata.tangles[rootHash].depth,
     2,
     'msg2 tangle depth correct'
   )
-  t.deepEquals(
+  assert.deepEqual(
     rec2.msg.metadata.tangles[rootHash].prev,
     [msgHash1],
     'msg2 tangle prev correct'
@@ -96,21 +97,21 @@ test('add() forked then feed.publish() merged', async (t) => {
     type: 'post',
     data: { text: 'I am 4th post' },
   })
-  t.ok(rec4, '4th post published')
+  assert.ok(rec4, '4th post published')
-  t.equals(
+  assert.equal(
     rec4.msg.metadata.tangles[rootHash].prev.length,
     3,
     'msg4 prev has 3' // is root, msg2 and msg3'
   )
-  t.true(
+  assert.ok(
     rec4.msg.metadata.tangles[rootHash].prev.includes(rootHash),
     'msg4 prev has root'
   )
-  t.true(
+  assert.ok(
     rec4.msg.metadata.tangles[rootHash].prev.includes(msgHash2),
     'msg4 prev has msg2'
   )
-  t.true(
+  assert.ok(
     rec4.msg.metadata.tangles[rootHash].prev.includes(msgHash3),
     'msg4 prev has msg3'
   )
@@ -123,11 +124,11 @@ test('feed.publish() encrypted with box', async (t) => {
     data: { text: 'I am chewing food', recps: [keypair.public] },
     encryptionFormat: 'box',
   })
-  t.equal(typeof recEncrypted.msg.data, 'string')
+  assert.equal(typeof recEncrypted.msg.data, 'string')
-  t.true(recEncrypted.msg.data.endsWith('.box'), '.box')
+  assert.ok(recEncrypted.msg.data.endsWith('.box'), '.box')
 
   const msgDecrypted = peer.db.get(recEncrypted.hash)
-  t.equals(msgDecrypted.data.text, 'I am chewing food')
+  assert.equal(msgDecrypted.data.text, 'I am chewing food')
 })
 
 test('feed.publish() with tangles', async (t) => {
@@ -136,7 +137,7 @@ test('feed.publish() with tangles', async (t) => {
     type: 'comment',
     data: { text: 'I am root' },
   })
-  t.equal(recA.msg.data.text, 'I am root', 'root text correct')
+  assert.equal(recA.msg.data.text, 'I am root', 'root text correct')
 
   const recB = await p(peer.db.feed.publish)({
     group,
@@ -145,8 +146,8 @@ test('feed.publish() with tangles', async (t) => {
     tangles: [recA.hash],
     keypair: bobKeypair,
   })
-  t.equal(recB.msg.metadata.tangles[recA.hash].depth, 1, 'tangle depth 1')
+  assert.equal(recB.msg.metadata.tangles[recA.hash].depth, 1, 'tangle depth 1')
-  t.deepEquals(
+  assert.deepEqual(
     recB.msg.metadata.tangles[recA.hash].prev,
     [recA.hash],
     'tangle prev'

test/get.test.js

@@ -1,10 +1,11 @@
-const test = require('tape')
+const test = require('node:test')
-const path = require('path')
+const assert = require('node:assert')
-const os = require('os')
+const path = require('node:path')
+const os = require('node:os')
+const p = require('node:util').promisify
 const rimraf = require('rimraf')
 const SecretStack = require('secret-stack')
 const caps = require('ssb-caps')
-const p = require('util').promisify
 const Keypair = require('ppppp-keypair')
 const MsgV2 = require('../lib/msg-v2')
 
@@ -37,14 +38,14 @@ test('setup', async (t) => {
 
 test('get() supports ppppp URIs', async (t) => {
   const msg = peer.db.get(msgId1)
-  t.ok(msg, 'msg exists')
+  assert.ok(msg, 'msg exists')
-  t.equals(msg.data.text, 'I am 1st post')
+  assert.equal(msg.data.text, 'I am 1st post')
 })
 
 test('get() supports msg hashes', async (t) => {
   const msg = peer.db.get(msgHash1)
-  t.ok(msg, 'msg exists')
+  assert.ok(msg, 'msg exists')
-  t.equals(msg.data.text, 'I am 1st post')
+  assert.equal(msg.data.text, 'I am 1st post')
 })
 
 test('teardown', (t) => {

test/getTangle.test.js

@@ -1,10 +1,11 @@
-const test = require('tape')
+const test = require('node:test')
-const path = require('path')
+const assert = require('node:assert')
-const os = require('os')
+const path = require('node:path')
+const os = require('node:os')
+const p = require('node:util').promisify
 const rimraf = require('rimraf')
 const SecretStack = require('secret-stack')
 const caps = require('ssb-caps')
-const p = require('util').promisify
 const Keypair = require('ppppp-keypair')
 
 const DIR = path.join(os.tmpdir(), 'ppppp-db-tangle')
@@ -94,35 +95,32 @@ test('setup', async (t) => {
 })
 
 test('Tangle.has', (t) => {
-  t.true(tangle.has(rootPost), 'has rootPost')
+  assert.equal(tangle.has(rootPost), true, 'has rootPost')
-  t.true(tangle.has(reply1Lo), 'has reply1Lo')
+  assert.equal(tangle.has(reply1Lo), true, 'has reply1Lo')
-  t.true(tangle.has(reply1Hi), 'has reply1Hi')
+  assert.equal(tangle.has(reply1Hi), true, 'has reply1Hi')
-  t.true(tangle.has(reply2A), 'has reply2A')
+  assert.equal(tangle.has(reply2A), true, 'has reply2A')
-  t.true(tangle.has(reply3Lo), 'has reply3Lo')
+  assert.equal(tangle.has(reply3Lo), true, 'has reply3Lo')
-  t.true(tangle.has(reply3Hi), 'has reply3Hi')
+  assert.equal(tangle.has(reply3Hi), true, 'has reply3Hi')
-  t.false(tangle.has('nonsense'), 'does not have nonsense')
+  assert.equal(tangle.has('nonsense'), false, 'does not have nonsense')
-  t.end()
 })
 
 test('Tangle.getDepth', (t) => {
-  t.equals(tangle.getDepth(rootPost), 0, 'depth of rootPost is 0')
+  assert.equal(tangle.getDepth(rootPost), 0, 'depth of rootPost is 0')
-  t.equals(tangle.getDepth(reply1Lo), 1, 'depth of reply1Lo is 1')
+  assert.equal(tangle.getDepth(reply1Lo), 1, 'depth of reply1Lo is 1')
-  t.equals(tangle.getDepth(reply1Hi), 1, 'depth of reply1Hi is 1')
+  assert.equal(tangle.getDepth(reply1Hi), 1, 'depth of reply1Hi is 1')
-  t.equals(tangle.getDepth(reply2A), 2, 'depth of reply2A is 2')
+  assert.equal(tangle.getDepth(reply2A), 2, 'depth of reply2A is 2')
-  t.equals(tangle.getDepth(reply3Lo), 3, 'depth of reply3Lo is 3')
+  assert.equal(tangle.getDepth(reply3Lo), 3, 'depth of reply3Lo is 3')
-  t.equals(tangle.getDepth(reply3Hi), 3, 'depth of reply3Hi is 3')
+  assert.equal(tangle.getDepth(reply3Hi), 3, 'depth of reply3Hi is 3')
-  t.end()
 })
 
 test('Tangle.getMaxDepth', (t) => {
-  t.equals(tangle.getMaxDepth(), 3, 'max depth is 3')
+  assert.equal(tangle.getMaxDepth(), 3, 'max depth is 3')
-  t.end()
 })
 
 test('Tangle.topoSort', (t) => {
   const sorted = tangle.topoSort()
 
-  t.deepEquals(sorted, [
+  assert.deepEqual(sorted, [
     rootPost,
     reply1Lo,
     reply1Hi,
@@ -130,76 +128,91 @@ test('Tangle.topoSort', (t) => {
     reply3Lo,
     reply3Hi,
   ])
-  t.end()
 })
 
 test('Tangle.precedes', (t) => {
-  t.true(tangle.precedes(rootPost, reply1Lo), 'rootPost precedes reply1Lo')
+  assert.equal(
-  t.true(tangle.precedes(rootPost, reply1Hi), 'rootPost precedes reply1Hi')
+    tangle.precedes(rootPost, reply1Lo),
-  t.false(
+    true,
+    'rootPost precedes reply1Lo'
+  )
+  assert.equal(
+    tangle.precedes(rootPost, reply1Hi),
+    true,
+    'rootPost precedes reply1Hi'
+  )
+  assert.equal(
     tangle.precedes(reply1Hi, rootPost),
+    false,
     'reply1Hi doesnt precede rootPost'
   )
-  t.false(
+  assert.equal(
     tangle.precedes(reply1Lo, reply1Hi),
+    false,
     'reply1Lo doesnt precede reply1Hi'
   )
-  t.false(tangle.precedes(reply1Lo, reply1Lo), 'reply1Lo doesnt precede itself')
+  assert.equal(
-  t.true(tangle.precedes(reply1Lo, reply3Hi), 'reply1Lo precedes reply3Hi')
+    tangle.precedes(reply1Lo, reply1Lo),
-  t.true(tangle.precedes(reply1Hi, reply2A), 'reply1Hi precedes reply2A')
+    false,
-  t.false(
+    'reply1Lo doesnt precede itself'
+  )
+  assert.equal(
+    tangle.precedes(reply1Lo, reply3Hi),
+    true,
+    'reply1Lo precedes reply3Hi'
+  )
+  assert.equal(
+    tangle.precedes(reply1Hi, reply2A),
+    true,
+    'reply1Hi precedes reply2A'
+  )
+  assert.equal(
     tangle.precedes(reply3Lo, reply1Hi),
+    false,
     'reply3Lo doesnt precede reply1Hi'
   )
-
-  t.end()
 })
 
 test('Tangle.getTips', (t) => {
   const tips = tangle.getTips()
 
-  t.equals(tips.size, 2, 'there are 2 tips')
+  assert.equal(tips.size, 2, 'there are 2 tips')
-  t.true(tips.has(reply3Lo), 'tips contains reply3Lo')
+  assert.equal(tips.has(reply3Lo), true, 'tips contains reply3Lo')
-  t.true(tips.has(reply3Hi), 'tips contains reply3Hi')
+  assert.equal(tips.has(reply3Hi), true, 'tips contains reply3Hi')
-  t.end()
 })
 
 test('Tangle.getLipmaaSet', (t) => {
-  t.equals(tangle.getLipmaaSet(0).size, 0, 'lipmaa 0 (empty)')
+  assert.equal(tangle.getLipmaaSet(0).size, 0, 'lipmaa 0 (empty)')
 
-  t.equals(tangle.getLipmaaSet(1).size, 1, 'lipmaa 1 (-1)')
+  assert.equal(tangle.getLipmaaSet(1).size, 1, 'lipmaa 1 (-1)')
-  t.true(tangle.getLipmaaSet(1).has(rootPost), 'lipmaa 1 (-1)')
+  assert.equal(tangle.getLipmaaSet(1).has(rootPost), true, 'lipmaa 1 (-1)')
 
-  t.equals(tangle.getLipmaaSet(2).size, 2, 'lipmaa 2 (-1)')
+  assert.equal(tangle.getLipmaaSet(2).size, 2, 'lipmaa 2 (-1)')
-  t.true(tangle.getLipmaaSet(2).has(reply1Lo), 'lipmaa 2 (-1)')
+  assert.equal(tangle.getLipmaaSet(2).has(reply1Lo), true, 'lipmaa 2 (-1)')
-  t.true(tangle.getLipmaaSet(2).has(reply1Hi), 'lipmaa 2 (-1)')
+  assert.equal(tangle.getLipmaaSet(2).has(reply1Hi), true, 'lipmaa 2 (-1)')
 
-  t.equals(tangle.getLipmaaSet(3).size, 1, 'lipmaa 3 (leap!)')
+  assert.equal(tangle.getLipmaaSet(3).size, 1, 'lipmaa 3 (leap!)')
-  t.true(tangle.getLipmaaSet(3).has(rootPost), 'lipmaa 3 (leap!)')
+  assert.equal(tangle.getLipmaaSet(3).has(rootPost), true, 'lipmaa 3 (leap!)')
 
-  t.equals(tangle.getLipmaaSet(4).size, 2, 'lipmaa 4 (-1)')
+  assert.equal(tangle.getLipmaaSet(4).size, 2, 'lipmaa 4 (-1)')
-  t.true(tangle.getLipmaaSet(4).has(reply3Lo), 'lipmaa 4 (-1)')
+  assert.equal(tangle.getLipmaaSet(4).has(reply3Lo), true, 'lipmaa 4 (-1)')
-  t.true(tangle.getLipmaaSet(4).has(reply3Hi), 'lipmaa 4 (-1)')
+  assert.equal(tangle.getLipmaaSet(4).has(reply3Hi), true, 'lipmaa 4 (-1)')
 
-  t.equals(tangle.getLipmaaSet(5).size, 0, 'lipmaa 5 (empty)')
+  assert.equal(tangle.getLipmaaSet(5).size, 0, 'lipmaa 5 (empty)')
-
-  t.end()
 })
 
 test('Tangle.getDeletablesAndErasables basic', (t) => {
   const { deletables, erasables } = tangle.getDeletablesAndErasables(reply2A)
 
-  t.deepEquals(deletables, [reply1Hi], 'deletables')
+  assert.deepEqual(deletables, [reply1Hi], 'deletables')
-  t.deepEquals(erasables, [reply1Lo, rootPost], 'erasables')
+  assert.deepEqual(erasables, [reply1Lo, rootPost], 'erasables')
-  t.end()
 })
 
 test('Tangle.getDeletablesAndErasables with lipmaa', (t) => {
   const { deletables, erasables } = tangle.getDeletablesAndErasables(reply3Lo)
 
-  t.deepEquals(deletables, [reply1Lo, reply1Hi, reply2A], 'deletables')
+  assert.deepEqual(deletables, [reply1Lo, reply1Hi, reply2A], 'deletables')
-  t.deepEquals(erasables, [rootPost], 'erasables')
+  assert.deepEqual(erasables, [rootPost], 'erasables')
-  t.end()
 })
 
 test('Tangle.topoSort after some have been deleted and erased', async (t) => {
@@ -214,7 +227,7 @@ test('Tangle.topoSort after some have been deleted and erased', async (t) => {
   const tangle2 = peer.db.getTangle(rootPost)
   const sorted = tangle2.topoSort()
 
-  t.deepEquals(sorted, [rootPost, reply3Lo, reply3Hi])
+  assert.deepEqual(sorted, [rootPost, reply3Lo, reply3Hi])
 })
 
 test('teardown', async (t) => {

test/group-add.test.js

@@ -1,10 +1,11 @@
-const test = require('tape')
+const test = require('node:test')
-const path = require('path')
+const assert = require('node:assert')
-const os = require('os')
+const path = require('node:path')
+const p = require('node:util').promisify
+const os = require('node:os')
 const rimraf = require('rimraf')
 const SecretStack = require('secret-stack')
 const caps = require('ssb-caps')
-const p = require('util').promisify
 const Keypair = require('ppppp-keypair')
 
 const DIR = path.join(os.tmpdir(), 'ppppp-db-group-add')
@@ -24,18 +25,18 @@ test('group.add()', async (t) => {
   const group = groupRec0.hash
 
   const groupRec1 = await p(peer.db.group.add)({ group, keypair: keypair2 })
-  t.ok(groupRec1, 'groupRec1 exists')
+  assert.ok(groupRec1, 'groupRec1 exists')
   const { hash, msg } = groupRec1
-  t.ok(hash, 'hash exists')
+  assert.ok(hash, 'hash exists')
-  t.equals(msg.data.add, keypair2.public, 'msg.data.add NEW KEY')
+  assert.equal(msg.data.add, keypair2.public, 'msg.data.add NEW KEY')
-  t.equals(msg.metadata.group, null, 'msg.metadata.group')
+  assert.equal(msg.metadata.group, null, 'msg.metadata.group')
-  t.equals(msg.metadata.groupTips, null, 'msg.metadata.groupTips')
+  assert.equal(msg.metadata.groupTips, null, 'msg.metadata.groupTips')
-  t.deepEquals(
+  assert.deepEqual(
     msg.metadata.tangles,
     { [group]: { depth: 1, prev: [group] } },
     'msg.metadata.tangles'
   )
-  t.equals(msg.pubkey, keypair1.public, 'msg.pubkey OLD KEY')
+  assert.equal(msg.pubkey, keypair1.public, 'msg.pubkey OLD KEY')
 
   await p(peer.close)()
 })
@@ -63,16 +64,16 @@ test('publish with a key in the group', async (t) => {
     data: { text: 'hello' },
     keypair: keypair2,
   })
-  t.equal(postRec.msg.data.text, 'hello', 'post text correct')
+  assert.equal(postRec.msg.data.text, 'hello', 'post text correct')
   const postsId = peer.db.feed.getId(group, 'post')
-  t.ok(postsId, 'postsId exists')
+  assert.ok(postsId, 'postsId exists')
 
   const recs = [...peer.db.records()]
-  t.equals(recs.length, 4, '4 records')
+  assert.equal(recs.length, 4, '4 records')
   const [_groupRec0, _groupRec1, postsRoot, _post] = recs
-  t.deepEquals(_groupRec0.msg, groupRec0.msg, 'groupMsg0')
+  assert.deepEqual(_groupRec0.msg, groupRec0.msg, 'groupMsg0')
-  t.deepEquals(_groupRec1.msg, groupRec1.msg, 'groupMsg1')
+  assert.deepEqual(_groupRec1.msg, groupRec1.msg, 'groupMsg1')
-  t.deepEquals(postsRoot.msg.metadata, {
+  assert.deepEqual(postsRoot.msg.metadata, {
     dataHash: null,
     dataSize: 0,
     group,
@@ -81,7 +82,7 @@ test('publish with a key in the group', async (t) => {
     type: 'post',
     v: 2,
   }, 'postsRoot')
-  t.deepEquals(_post.msg, postRec.msg, 'postMsg')
+  assert.deepEqual(_post.msg, postRec.msg, 'postMsg')
 
   await p(peer.close)()
 
@@ -100,7 +101,7 @@ test('publish with a key in the group', async (t) => {
   await p(carol.db.add)(groupRec1.msg, group)
   await p(carol.db.add)(postsRoot.msg, postsId)
   await p(carol.db.add)(postRec.msg, postsId)
-  t.pass('carol added all messages successfully')
+  // t.pass('carol added all messages successfully')
 
   await p(carol.close)()
 })

test/group-create.test.js

@@ -1,10 +1,11 @@
-const test = require('tape')
+const test = require('node:test')
-const path = require('path')
+const assert = require('node:assert')
-const os = require('os')
+const path = require('node:path')
+const os = require('node:os')
+const p = require('node:util').promisify
 const rimraf = require('rimraf')
 const SecretStack = require('secret-stack')
 const caps = require('ssb-caps')
-const p = require('util').promisify
 const Keypair = require('ppppp-keypair')
 
 const DIR = path.join(os.tmpdir(), 'ppppp-db-group-create')
@@ -19,14 +20,14 @@ test('group.create() without args', async (t) => {
 
   await peer.db.loaded()
   const groupRec0 = await p(peer.db.group.create)({})
-  t.ok(groupRec0, 'groupRec0 exists')
+  assert.ok(groupRec0, 'groupRec0 exists')
   const { hash, msg } = groupRec0
-  t.ok(hash, 'hash exists')
+  assert.ok(hash, 'hash exists')
-  t.equals(msg.data.add, keypair.public, 'msg.data.add')
+  assert.equal(msg.data.add, keypair.public, 'msg.data.add')
-  t.equals(msg.metadata.group, null, 'msg.metadata.group')
+  assert.equal(msg.metadata.group, null, 'msg.metadata.group')
-  t.equals(msg.metadata.groupTips, null, 'msg.metadata.groupTips')
+  assert.equal(msg.metadata.groupTips, null, 'msg.metadata.groupTips')
-  t.deepEquals(Object.keys(msg.metadata.tangles), [], 'msg.metadata.tangles')
+  assert.deepEqual(Object.keys(msg.metadata.tangles), [], 'msg.metadata.tangles')
-  t.equals(msg.pubkey, keypair.public, 'msg.pubkey')
+  assert.equal(msg.pubkey, keypair.public, 'msg.pubkey')
 
   await p(peer.close)()
 })
@@ -41,14 +42,14 @@ test('group.create() with "keypair" arg', async (t) => {
 
   await peer.db.loaded()
   const groupRec0 = await p(peer.db.group.create)({ keypair })
-  t.ok(groupRec0, 'groupRec0 exists')
+  assert.ok(groupRec0, 'groupRec0 exists')
   const { hash, msg } = groupRec0
-  t.ok(hash, 'hash exists')
+  assert.ok(hash, 'hash exists')
-  t.equals(msg.data.add, keypair.public, 'msg.data.add')
+  assert.equal(msg.data.add, keypair.public, 'msg.data.add')
-  t.equals(msg.metadata.group, null, 'msg.metadata.group')
+  assert.equal(msg.metadata.group, null, 'msg.metadata.group')
-  t.equals(msg.metadata.groupTips, null, 'msg.metadata.groupTips')
+  assert.equal(msg.metadata.groupTips, null, 'msg.metadata.groupTips')
-  t.deepEquals(Object.keys(msg.metadata.tangles), [], 'msg.metadata.tangles')
+  assert.deepEqual(Object.keys(msg.metadata.tangles), [], 'msg.metadata.tangles')
-  t.equals(msg.pubkey, keypair.public, 'msg.pubkey')
+  assert.equal(msg.pubkey, keypair.public, 'msg.pubkey')
 
   await p(peer.close)()
 })

test/msg-v2/create.test.js

@@ -1,54 +1,52 @@
-const tape = require('tape')
+const test = require('node:test')
+const assert = require('node:assert')
 const Keypair = require('ppppp-keypair')
 const MsgV2 = require('../../lib/msg-v2')
 
 let group
-tape('MsgV2.createGroup()', (t) => {
+test('MsgV2.createGroup()', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
 
   const groupMsg0 = MsgV2.createGroup(keypair, 'MYNONCE')
   console.log(JSON.stringify(groupMsg0, null, 2))
 
-  t.equals(groupMsg0.data.add, keypair.public, 'data.add')
+  assert.equal(groupMsg0.data.add, keypair.public, 'data.add')
-  t.equals(groupMsg0.metadata.dataHash, 'THi3VkJeaf8aTkLSNJUdFD', 'hash')
+  assert.equal(groupMsg0.metadata.dataHash, 'THi3VkJeaf8aTkLSNJUdFD', 'hash')
-  t.equals(groupMsg0.metadata.dataSize, 72, 'size')
+  assert.equal(groupMsg0.metadata.dataSize, 72, 'size')
-  t.equals(groupMsg0.metadata.group, null, 'group')
+  assert.equal(groupMsg0.metadata.group, null, 'group')
-  t.equals(groupMsg0.metadata.groupTips, null, 'groupTips')
+  assert.equal(groupMsg0.metadata.groupTips, null, 'groupTips')
-  t.deepEquals(groupMsg0.metadata.tangles, {}, 'tangles')
+  assert.deepEqual(groupMsg0.metadata.tangles, {}, 'tangles')
-  t.equals(groupMsg0.metadata.type, 'group', 'type')
+  assert.equal(groupMsg0.metadata.type, 'group', 'type')
-  t.equals(groupMsg0.metadata.v, 2, 'v')
+  assert.equal(groupMsg0.metadata.v, 2, 'v')
-  t.equals(groupMsg0.pubkey, keypair.public, 'pubkey')
+  assert.equal(groupMsg0.pubkey, keypair.public, 'pubkey')
 
   group = MsgV2.getMsgHash(groupMsg0)
-  t.equals(group, 'XKKmEBmqKGa5twQ2HNSk7t', 'group ID')
+  assert.equal(group, 'XKKmEBmqKGa5twQ2HNSk7t', 'group ID')
-
-  t.end()
 })
 
 let rootMsg = null
 let rootHash = null
-tape('MsgV2.createRoot()', (t) => {
+test('MsgV2.createRoot()', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
 
   rootMsg = MsgV2.createRoot(group, 'post', keypair)
   console.log(JSON.stringify(rootMsg, null, 2))
 
-  t.equals(rootMsg.data, null, 'data')
+  assert.equal(rootMsg.data, null, 'data')
-  t.equals(rootMsg.metadata.dataHash, null, 'hash')
+  assert.equal(rootMsg.metadata.dataHash, null, 'hash')
-  t.equals(rootMsg.metadata.dataSize, 0, 'size')
+  assert.equal(rootMsg.metadata.dataSize, 0, 'size')
-  t.equals(rootMsg.metadata.group, group, 'group')
+  assert.equal(rootMsg.metadata.group, group, 'group')
-  t.equals(rootMsg.metadata.groupTips, null, 'groupTips')
+  assert.equal(rootMsg.metadata.groupTips, null, 'groupTips')
-  t.deepEquals(rootMsg.metadata.tangles, {}, 'tangles')
+  assert.deepEqual(rootMsg.metadata.tangles, {}, 'tangles')
-  t.equals(rootMsg.metadata.type, 'post', 'type')
+  assert.equal(rootMsg.metadata.type, 'post', 'type')
-  t.equals(rootMsg.metadata.v, 2, 'v')
+  assert.equal(rootMsg.metadata.v, 2, 'v')
-  t.equals(rootMsg.pubkey, keypair.public, 'pubkey')
+  assert.equal(rootMsg.pubkey, keypair.public, 'pubkey')
 
   rootHash = MsgV2.getMsgHash(rootMsg)
-  t.equals(rootHash, 'PzuT1Dwbbgn6a8NeLuHuKw', 'root hash')
+  assert.equal(rootHash, 'PzuT1Dwbbgn6a8NeLuHuKw', 'root hash')
-  t.end()
 })
 
-tape('MsgV2.create()', (t) => {
+test('MsgV2.create()', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
   const data = { text: 'Hello world!' }
 
@@ -67,35 +65,35 @@ tape('MsgV2.create()', (t) => {
   })
   console.log(JSON.stringify(msg1, null, 2))
 
-  t.deepEqual(msg1.data, data, 'data')
+  assert.deepEqual(msg1.data, data, 'data')
-  t.deepEquals(
+  assert.deepEqual(
     Object.keys(msg1.metadata),
     ['dataHash', 'dataSize', 'group', 'groupTips', 'tangles', 'type', 'v'],
     'metadata shape'
   )
-  t.deepEquals(
+  assert.deepEqual(
     msg1.metadata.dataHash,
     '9R7XmBhHF5ooPg34j9TQcz',
     'metadata.dataHash'
   )
-  t.deepEquals(msg1.metadata.dataSize, 23, 'metadata.dataSize')
+  assert.deepEqual(msg1.metadata.dataSize, 23, 'metadata.dataSize')
-  t.equals(msg1.metadata.group, group, 'metadata.group')
+  assert.equal(msg1.metadata.group, group, 'metadata.group')
-  t.deepEquals(msg1.metadata.groupTips, [group], 'metadata.groupTips')
+  assert.deepEqual(msg1.metadata.groupTips, [group], 'metadata.groupTips')
-  t.deepEquals(
+  assert.deepEqual(
     Object.keys(msg1.metadata.tangles),
     [rootHash],
     'metadata.tangles'
   )
-  t.equals(msg1.metadata.tangles[rootHash].depth, 1, 'tangle depth')
+  assert.equal(msg1.metadata.tangles[rootHash].depth, 1, 'tangle depth')
-  t.deepEquals(msg1.metadata.tangles[rootHash].prev, [rootHash], 'tangle prev')
+  assert.deepEqual(msg1.metadata.tangles[rootHash].prev, [rootHash], 'tangle prev')
-  t.equals(msg1.metadata.type, 'post', 'metadata.type')
+  assert.equal(msg1.metadata.type, 'post', 'metadata.type')
-  t.deepEquals(msg1.metadata.v, 2, 'metadata.v')
+  assert.deepEqual(msg1.metadata.v, 2, 'metadata.v')
-  t.equals(
+  assert.equal(
     msg1.pubkey,
     '4mjQ5aJu378cEu6TksRG3uXAiKFiwGjYQtWAjfVjDAJW',
     'pubkey'
   )
-  t.equals(
+  assert.equal(
     msg1.sig,
     'CW8gWiiqtEgPQ2NjXWHJb5aeW4vkKMG9d1BqPJDjSJaw6xX6s5GUTvoobNSBtaLv8CKNXHHJXSr9Vbe7Cew9pkv',
     'sig'
@@ -103,7 +101,7 @@ tape('MsgV2.create()', (t) => {
 
   const msgHash1 = '7miH6Zh63cyMJTT5bhDjZF'
 
-  t.equals(
+  assert.equal(
     MsgV2.getMsgId(msg1),
     `ppppp:message/v2/${group}/post/${msgHash1}`,
     'getMsgId'
@@ -127,50 +125,48 @@ tape('MsgV2.create()', (t) => {
   })
   console.log(JSON.stringify(msg2, null, 2))
 
-  t.deepEqual(msg2.data, data2, 'data')
+  assert.deepEqual(msg2.data, data2, 'data')
-  t.deepEquals(
+  assert.deepEqual(
     Object.keys(msg2.metadata),
     ['dataHash', 'dataSize', 'group', 'groupTips', 'tangles', 'type', 'v'],
     'metadata shape'
   )
-  t.deepEquals(
+  assert.deepEqual(
     msg2.metadata.dataHash,
     'XuZEzH1Dhy1yuRMcviBBcN',
     'metadata.dataHash'
   )
-  t.deepEquals(msg2.metadata.dataSize, 21, 'metadata.dataSize')
+  assert.deepEqual(msg2.metadata.dataSize, 21, 'metadata.dataSize')
-  t.equals(msg2.metadata.group, group, 'metadata.group')
+  assert.equal(msg2.metadata.group, group, 'metadata.group')
-  t.deepEquals(msg2.metadata.groupTips, [group], 'metadata.groupTips')
+  assert.deepEqual(msg2.metadata.groupTips, [group], 'metadata.groupTips')
-  t.deepEquals(
+  assert.deepEqual(
     Object.keys(msg2.metadata.tangles),
     [rootHash],
     'metadata.tangles'
   )
-  t.equals(msg2.metadata.tangles[rootHash].depth, 2, 'tangle depth')
+  assert.equal(msg2.metadata.tangles[rootHash].depth, 2, 'tangle depth')
-  t.deepEquals(msg2.metadata.tangles[rootHash].prev, [msgHash1], 'tangle prev')
+  assert.deepEqual(msg2.metadata.tangles[rootHash].prev, [msgHash1], 'tangle prev')
-  t.equals(msg2.metadata.type, 'post', 'metadata.type')
+  assert.equal(msg2.metadata.type, 'post', 'metadata.type')
-  t.deepEquals(msg2.metadata.v, 2, 'metadata.v')
+  assert.deepEqual(msg2.metadata.v, 2, 'metadata.v')
-  t.equals(
+  assert.equal(
     msg2.pubkey,
     '4mjQ5aJu378cEu6TksRG3uXAiKFiwGjYQtWAjfVjDAJW',
     'pubkey'
   )
-  t.equals(
+  assert.equal(
     msg2.sig,
     '33PStdQ8kdvL1pSpd6x9LuxcpEvDmsRNhAq7t75v66cthSHHuiJVqp57b9J7QVXp7a1Jw5qaZLycYQspJRbKNWyW',
     'sig'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     MsgV2.getMsgId(msg2),
     `ppppp:message/v2/${group}/post/HTtEmjCBXGBRTMM3mgekWu`,
     'getMsgId'
   )
-
-  t.end()
 })
 
-tape('create() handles DAG tips correctly', (t) => {
+test('create() handles DAG tips correctly', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
   const tangle = new MsgV2.Tangle(rootHash)
   tangle.add(rootHash, rootMsg)
@@ -186,7 +182,7 @@ tape('create() handles DAG tips correctly', (t) => {
     },
   })
   const msgHash1 = MsgV2.getMsgHash(msg1)
-  t.deepEquals(
+  assert.deepEqual(
     msg1.metadata.tangles[rootHash].prev,
     [MsgV2.getFeedRootHash(group, 'post')],
     'msg1.prev is root'
@@ -204,7 +200,7 @@ tape('create() handles DAG tips correctly', (t) => {
       [rootHash]: tangle,
     },
   })
-  t.deepEquals(
+  assert.deepEqual(
     msg2A.metadata.tangles[rootHash].prev,
     [msgHash1],
     'msg2A.prev is msg1'
@@ -221,7 +217,7 @@ tape('create() handles DAG tips correctly', (t) => {
     },
   })
   const msgHash2B = MsgV2.getMsgHash(msg2B)
-  t.deepEquals(
+  assert.deepEqual(
     msg2B.metadata.tangles[rootHash].prev,
     [msgHash1],
     'msg2B.prev is msg1'
@@ -240,7 +236,7 @@ tape('create() handles DAG tips correctly', (t) => {
     },
   })
   const msgHash3 = MsgV2.getMsgHash(msg3)
-  t.deepEquals(
+  assert.deepEqual(
     msg3.metadata.tangles[rootHash].prev,
     [rootHash, msgHash2B].sort(),
     'msg3.prev is [root(lipmaa),msg2B(previous)], sorted'
@@ -249,7 +245,7 @@ tape('create() handles DAG tips correctly', (t) => {
 
   const msgHash2A = MsgV2.getMsgHash(msg2A)
   tangle.add(msgHash2A, msg2A)
-  t.pass('msg2A comes into awareness')
+  // t.pass('msg2A comes into awareness')
 
   const msg4 = MsgV2.create({
     keypair,
@@ -261,11 +257,9 @@ tape('create() handles DAG tips correctly', (t) => {
       [rootHash]: tangle,
     },
   })
-  t.deepEquals(
+  assert.deepEqual(
     msg4.metadata.tangles[rootHash].prev,
     [msgHash3, msgHash2A].sort(),
     'msg4.prev is [msg3(previous),msg2A(old fork as tip)], sorted'
   )
-
-  t.end()
 })

test/msg-v2/invalid-prev.test.js

@@ -1,4 +1,5 @@
-const tape = require('tape')
+const test = require('node:test')
+const assert = require('node:assert')
 const base58 = require('bs58')
 const Keypair = require('ppppp-keypair')
 const MsgV2 = require('../../lib/msg-v2')
@@ -7,7 +8,7 @@ const keypair = Keypair.generate('ed25519', 'alice')
 const group = MsgV2.getMsgHash(MsgV2.createGroup(keypair, 'MYNONCE'))
 const pubkeys = new Set([keypair.public])
 
-tape('invalid msg with non-array prev', (t) => {
+test('invalid msg with non-array prev', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
 
   const rootMsg = MsgV2.createRoot(group, 'post', keypair)
@@ -30,16 +31,15 @@ tape('invalid msg with non-array prev', (t) => {
   const msgHash = MsgV2.getMsgHash(msg)
 
   const err = MsgV2.validate(msg, tangle, pubkeys, msgHash, rootHash)
-  t.ok(err, 'invalid 2nd msg throws')
+  assert.ok(err, 'invalid 2nd msg throws')
-  t.match(
+  assert.match(
     err,
     /prev ".*" should have been an array/,
     'invalid 2nd msg description'
   )
-  t.end()
 })
 
-tape('invalid msg with bad prev', (t) => {
+test('invalid msg with bad prev', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
 
   const rootMsg = MsgV2.createRoot(group, 'post', keypair)
@@ -76,16 +76,15 @@ tape('invalid msg with bad prev', (t) => {
   const msgHash2 = MsgV2.getMsgHash(msg2)
 
   const err = MsgV2.validate(msg2, tangle, pubkeys, msgHash2, rootHash)
-  t.ok(err, 'invalid 2nd msg throws')
+  assert.ok(err, 'invalid 2nd msg throws')
-  t.match(
+  assert.match(
     err,
     /prev item ".*" should have been a string/,
     'invalid 2nd msg description'
   )
-  t.end()
 })
 
-tape('invalid msg with URI in prev', (t) => {
+test('invalid msg with URI in prev', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
 
   const rootMsg = MsgV2.createRoot(group, 'post', keypair)
@@ -124,12 +123,11 @@ tape('invalid msg with URI in prev', (t) => {
   msg2.metadata.tangles[rootHash].prev = [fakeMsgKey1]
 
   const err = MsgV2.validate(msg2, tangle, pubkeys, msgHash2, rootHash)
-  t.ok(err, 'invalid 2nd msg throws')
+  assert.ok(err, 'invalid 2nd msg throws')
-  t.match(err, /prev item ".*" is a URI/, 'invalid 2nd msg description')
+  assert.match(err, /prev item ".*" is a URI/, 'invalid 2nd msg description')
-  t.end()
 })
 
-tape('invalid msg with unknown prev', (t) => {
+test('invalid msg with unknown prev', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
 
   const rootMsg = MsgV2.createRoot(group, 'post', keypair)
@@ -181,12 +179,11 @@ tape('invalid msg with unknown prev', (t) => {
   const msgHash2 = MsgV2.getMsgHash(msg2)
 
   const err = MsgV2.validate(msg2, tangle, pubkeys, msgHash2, rootHash)
-  t.ok(err, 'invalid 2nd msg throws')
+  assert.ok(err, 'invalid 2nd msg throws')
-  t.match(err, /all prev are locally unknown/, 'invalid 2nd msg description')
+  assert.match(err, /all prev are locally unknown/, 'invalid 2nd msg description')
-  t.end()
 })
 
-tape('invalid feed msg with a different pubkey', (t) => {
+test('invalid feed msg with a different pubkey', (t) => {
   const keypairA = Keypair.generate('ed25519', 'alice')
   const keypairB = Keypair.generate('ed25519', 'bob')
 
@@ -210,15 +207,15 @@ tape('invalid feed msg with a different pubkey', (t) => {
   const msgHash = MsgV2.getMsgHash(msg)
 
   const err = MsgV2.validate(msg, feedTangle, pubkeys, msgHash, rootHash)
-  t.match(
+  assert.ok(err, 'invalid msg throws')
+  assert.match(
     err,
     /pubkey ".*" should have been one of ".*" from the group ".*"/,
     'invalid msg'
   )
-  t.end()
 })
 
-tape('invalid feed msg with a different type', (t) => {
+test('invalid feed msg with a different type', (t) => {
   const keypairA = Keypair.generate('ed25519', 'alice')
 
   const rootMsg = MsgV2.createRoot(group, 'post', keypair)
@@ -239,15 +236,15 @@ tape('invalid feed msg with a different type', (t) => {
   const msgHash = MsgV2.getMsgHash(msg)
 
   const err = MsgV2.validate(msg, feedTangle, pubkeys, msgHash, rootHash)
-  t.match(
+  assert.ok(err, 'invalid msg throws')
+  assert.match(
     err,
     /type "comment" should have been feed type "post"/,
     'invalid feed msg'
   )
-  t.end()
 })
 
-tape('invalid feed msg with non-alphabetical prev', (t) => {
+test('invalid feed msg with non-alphabetical prev', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
 
   const rootMsg = MsgV2.createRoot(group, 'post', keypair)
@@ -304,16 +301,15 @@ tape('invalid feed msg with non-alphabetical prev', (t) => {
   msg3.metadata.tangles[rootHash].prev = prevHashes
 
   const err = MsgV2.validate(msg3, tangle, pubkeys, msgHash3, rootHash)
-  t.ok(err, 'invalid 3rd msg throws')
+  assert.ok(err, 'invalid 3rd msg throws')
-  t.match(
+  assert.match(
     err,
     /prev ".*" should have been alphabetically sorted/,
     'invalid error message'
   )
-  t.end()
 })
 
-tape('invalid feed msg with duplicate prev', (t) => {
+test('invalid feed msg with duplicate prev', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
 
   const rootMsg = MsgV2.createRoot(group, 'post', keypair)
@@ -338,7 +334,6 @@ tape('invalid feed msg with duplicate prev', (t) => {
   msg1.metadata.tangles[rootHash].prev = [prevHash, prevHash]
 
   const err = MsgV2.validate(msg1, tangle, pubkeys, msgHash1, rootHash)
-  t.ok(err, 'invalid 1st msg throws')
+  assert.ok(err, 'invalid 1st msg throws')
-  t.match(err, /prev ".*" contains duplicates/, 'invalid error message')
+  assert.match(err, /prev ".*" contains duplicates/, 'invalid error message')
-  t.end()
 })

test/msg-v2/invalid-type.test.js

@@ -1,11 +1,12 @@
-const tape = require('tape')
+const test = require('node:test')
+const assert = require('node:assert')
 const Keypair = require('ppppp-keypair')
 const MsgV2 = require('../../lib/msg-v2')
 
-tape('invalid type not a string', (t) => {
+test('invalid type not a string', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
 
-  t.throws(
+  assert.throws(
     () => {
       MsgV2.create({
         keypair,
@@ -16,13 +17,12 @@ tape('invalid type not a string', (t) => {
     /invalid type/,
     'not a string'
   )
-  t.end()
 })
 
-tape('invalid type with "/" character', (t) => {
+test('invalid type with "/" character', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
 
-  t.throws(
+  assert.throws(
     () => {
       MsgV2.create({
         keypair,
@@ -33,13 +33,12 @@ tape('invalid type with "/" character', (t) => {
     /invalid type/,
     'invalid type if contains /'
   )
-  t.end()
 })
 
-tape('invalid type with "*" character', (t) => {
+test('invalid type with "*" character', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
 
-  t.throws(
+  assert.throws(
     () => {
       MsgV2.create({
         keypair,
@@ -50,13 +49,12 @@ tape('invalid type with "*" character', (t) => {
     /invalid type/,
     'invalid type if contains *'
   )
-  t.end()
 })
 
-tape('invalid type too short', (t) => {
+test('invalid type too short', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
 
-  t.throws(
+  assert.throws(
     () => {
       MsgV2.create({
         keypair,
@@ -67,13 +65,12 @@ tape('invalid type too short', (t) => {
     /shorter than 3/,
     'invalid type if too short'
   )
-  t.end()
 })
 
-tape('invalid type too long', (t) => {
+test('invalid type too long', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
 
-  t.throws(
+  assert.throws(
     () => {
       MsgV2.create({
         keypair,
@@ -84,6 +81,4 @@ tape('invalid type too long', (t) => {
     /100\+ characters long/,
     'invalid type if too long'
   )
-
-  t.end()
 })

test/msg-v2/lipmaa.test.js

@@ -1,8 +1,9 @@
-const tape = require('tape')
+const test = require('node:test')
+const assert = require('node:assert')
 const Keypair = require('ppppp-keypair')
 const MsgV2 = require('../../lib/msg-v2')
 
-tape('lipmaa prevs', (t) => {
+test('lipmaa prevs', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
   const group = MsgV2.getMsgHash(MsgV2.createGroup(keypair, 'MYNONCE'))
   const data = { text: 'Hello world!' }
@@ -24,8 +25,12 @@ tape('lipmaa prevs', (t) => {
   })
   const msgHash1 = MsgV2.getMsgHash(msg1)
   tangle.add(msgHash1, msg1)
-  t.equals(msg1.metadata.tangles[rootHash].depth, 1, 'msg1 depth')
+  assert.equal(msg1.metadata.tangles[rootHash].depth, 1, 'msg1 depth')
-  t.deepEquals(msg1.metadata.tangles[rootHash].prev, [rootHash], 'msg1 prev')
+  assert.deepEqual(
+    msg1.metadata.tangles[rootHash].prev,
+    [rootHash],
+    'msg1 prev'
+  )
 
   const msg2 = MsgV2.create({
     group,
@@ -39,8 +44,12 @@ tape('lipmaa prevs', (t) => {
   })
   const msgHash2 = MsgV2.getMsgHash(msg2)
   tangle.add(msgHash2, msg2)
-  t.equals(msg2.metadata.tangles[rootHash].depth, 2, 'msg2 depth')
+  assert.equal(msg2.metadata.tangles[rootHash].depth, 2, 'msg2 depth')
-  t.deepEquals(msg2.metadata.tangles[rootHash].prev, [msgHash1], 'msg2 prev')
+  assert.deepEqual(
+    msg2.metadata.tangles[rootHash].prev,
+    [msgHash1],
+    'msg2 prev'
+  )
 
   const msg3 = MsgV2.create({
     group,
@@ -54,8 +63,8 @@ tape('lipmaa prevs', (t) => {
   })
   const msgHash3 = MsgV2.getMsgHash(msg3)
   tangle.add(msgHash3, msg3)
-  t.equals(msg3.metadata.tangles[rootHash].depth, 3, 'msg3 depth')
+  assert.equal(msg3.metadata.tangles[rootHash].depth, 3, 'msg3 depth')
-  t.deepEquals(
+  assert.deepEqual(
     msg3.metadata.tangles[rootHash].prev,
     [rootHash, msgHash2].sort(),
     'msg3 prev (has lipmaa!)'
@@ -73,8 +82,12 @@ tape('lipmaa prevs', (t) => {
   })
   const msgHash4 = MsgV2.getMsgHash(msg4)
   tangle.add(msgHash4, msg4)
-  t.equals(msg4.metadata.tangles[rootHash].depth, 4, 'msg4 depth')
+  assert.equal(msg4.metadata.tangles[rootHash].depth, 4, 'msg4 depth')
-  t.deepEquals(msg4.metadata.tangles[rootHash].prev, [msgHash3], 'msg4 prev')
+  assert.deepEqual(
+    msg4.metadata.tangles[rootHash].prev,
+    [msgHash3],
+    'msg4 prev'
+  )
 
   const msg5 = MsgV2.create({
     group,
@@ -88,8 +101,12 @@ tape('lipmaa prevs', (t) => {
   })
   const msgHash5 = MsgV2.getMsgHash(msg5)
   tangle.add(msgHash5, msg5)
-  t.equals(msg5.metadata.tangles[rootHash].depth, 5, 'msg5 depth')
+  assert.equal(msg5.metadata.tangles[rootHash].depth, 5, 'msg5 depth')
-  t.deepEquals(msg5.metadata.tangles[rootHash].prev, [msgHash4], 'msg5 prev')
+  assert.deepEqual(
+    msg5.metadata.tangles[rootHash].prev,
+    [msgHash4],
+    'msg5 prev'
+  )
 
   const msg6 = MsgV2.create({
     group,
@@ -103,8 +120,12 @@ tape('lipmaa prevs', (t) => {
   })
   const msgHash6 = MsgV2.getMsgHash(msg6)
   tangle.add(msgHash6, msg6)
-  t.equals(msg6.metadata.tangles[rootHash].depth, 6, 'msg6 depth')
+  assert.equal(msg6.metadata.tangles[rootHash].depth, 6, 'msg6 depth')
-  t.deepEquals(msg6.metadata.tangles[rootHash].prev, [msgHash5], 'msg6 prev')
+  assert.deepEqual(
+    msg6.metadata.tangles[rootHash].prev,
+    [msgHash5],
+    'msg6 prev'
+  )
 
   const msg7 = MsgV2.create({
     group,
@@ -118,12 +139,10 @@ tape('lipmaa prevs', (t) => {
   })
   const msgHash7 = MsgV2.getMsgHash(msg7)
   tangle.add(msgHash7, msg7)
-  t.equals(msg7.metadata.tangles[rootHash].depth, 7, 'msg7 depth')
+  assert.equal(msg7.metadata.tangles[rootHash].depth, 7, 'msg7 depth')
-  t.deepEquals(
+  assert.deepEqual(
     msg7.metadata.tangles[rootHash].prev,
     [msgHash3, msgHash6].sort(),
     'msg7 prev (has lipmaa!)'
   )
-
-  t.end()
 })

test/msg-v2/tangles.test.js

@@ -1,8 +1,9 @@
-const tape = require('tape')
+const test = require('node:test')
+const assert = require('node:assert')
 const Keypair = require('ppppp-keypair')
 const MsgV2 = require('../../lib/msg-v2')
 
-tape('simple multi-author tangle', (t) => {
+test('simple multi-author tangle', (t) => {
   const keypairA = Keypair.generate('ed25519', 'alice')
   const keypairB = Keypair.generate('ed25519', 'bob')
   const groupA = MsgV2.getMsgHash(MsgV2.createGroup(keypairA, 'alice'))
@@ -29,7 +30,7 @@ tape('simple multi-author tangle', (t) => {
     keypair: keypairA,
   })
   const msgHash1 = MsgV2.getMsgHash(msg1)
-  t.deepEquals(
+  assert.deepEqual(
     Object.keys(msg1.metadata.tangles),
     [rootHashA],
     'msg1 has only feed tangle'
@@ -50,29 +51,35 @@ tape('simple multi-author tangle', (t) => {
     keypair: keypairB,
   })
 
-  t.deepEquals(
+  assert.deepEqual(
     Object.keys(msg2.metadata.tangles).sort(),
     [rootHashB, msgHash1].sort(),
     'msg2 has feed tangle and misc tangle'
   )
-  t.equal(msg2.metadata.tangles[rootHashB].depth, 1, 'msg2 feed tangle depth')
+  assert.equal(
-  t.deepEquals(
+    msg2.metadata.tangles[rootHashB].depth,
+    1,
+    'msg2 feed tangle depth'
+  )
+  assert.deepEqual(
     msg2.metadata.tangles[rootHashB].prev,
     [rootHashB],
     'msg2 feed tangle prev'
   )
 
-  t.equal(msg2.metadata.tangles[msgHash1].depth, 1, 'msg2 has tangle depth 1')
+  assert.equal(
-  t.deepEquals(
+    msg2.metadata.tangles[msgHash1].depth,
+    1,
+    'msg2 has tangle depth 1'
+  )
+  assert.deepEqual(
     msg2.metadata.tangles[msgHash1].prev,
     [msgHash1],
     'msg2 has tangle prev'
   )
-
-  t.end()
 })
 
-tape('lipmaa in multi-author tangle', (t) => {
+test('lipmaa in multi-author tangle', (t) => {
   const keypairA = Keypair.generate('ed25519', 'alice')
   const keypairB = Keypair.generate('ed25519', 'bob')
   const groupA = MsgV2.getMsgHash(MsgV2.createGroup(keypairA, 'alice'))
@@ -105,7 +112,7 @@ tape('lipmaa in multi-author tangle', (t) => {
   const tangleThread = new MsgV2.Tangle(msgHash1)
   tangleThread.add(msgHash1, msg1)
 
-  t.deepEquals(
+  assert.deepEqual(
     Object.keys(msg1.metadata.tangles),
     [rootHashA],
     'A:msg1 has only feed tangle'
@@ -126,7 +133,7 @@ tape('lipmaa in multi-author tangle', (t) => {
   tangleB.add(msgHash2, msg2)
   tangleThread.add(msgHash2, msg2)
 
-  t.deepEquals(
+  assert.deepEqual(
     msg2.metadata.tangles[msgHash1].prev,
     [msgHash1],
     'B:msg2 points to A:msg1'
@@ -147,7 +154,7 @@ tape('lipmaa in multi-author tangle', (t) => {
   tangleB.add(msgHash3, msg3)
   tangleThread.add(msgHash3, msg3)
 
-  t.deepEquals(
+  assert.deepEqual(
     msg3.metadata.tangles[msgHash1].prev,
     [msgHash2],
     'B:msg3 points to B:msg2'
@@ -168,11 +175,9 @@ tape('lipmaa in multi-author tangle', (t) => {
   tangleB.add(msgHash4, msg4)
   tangleThread.add(msgHash4, msg4)
 
-  t.deepEquals(
+  assert.deepEqual(
     msg4.metadata.tangles[msgHash1].prev,
     [msgHash1, msgHash3].sort(),
     'A:msg4 points to A:msg1,B:msg3'
   )
-
-  t.end()
 })

test/msg-v2/validate.test.js

@@ -1,8 +1,9 @@
-const tape = require('tape')
+const test = require('node:test')
+const assert = require('node:assert')
 const Keypair = require('ppppp-keypair')
 const MsgV2 = require('../../lib/msg-v2')
 
-tape('validate root msg', (t) => {
+test('validate root msg', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
   const group = MsgV2.getMsgHash(MsgV2.createGroup(keypair, 'alice'))
   const pubkeys = new Set([keypair.public])
@@ -12,12 +13,10 @@ tape('validate root msg', (t) => {
   const tangle = new MsgV2.Tangle(rootHash)
 
   const err = MsgV2.validate(rootMsg, tangle, pubkeys, rootHash, rootHash)
-  if (err) console.log(err)
+  assert.ifError(err, 'valid root msg')
-  t.error(err, 'valid root msg')
-  t.end()
 })
 
-tape('validate group tangle', (t) => {
+test('validate group tangle', (t) => {
   const pubkeys = new Set()
   const keypair1 = Keypair.generate('ed25519', 'alice')
   pubkeys.add(keypair1.public)
@@ -29,8 +28,7 @@ tape('validate group tangle', (t) => {
   const tangle = new MsgV2.Tangle(group)
 
   let err = MsgV2.validate(groupMsg0, tangle, pubkeys, groupMsg0Hash, group)
-  if (err) console.log(err)
+  assert.ifError(err, 'valid group root msg')
-  t.error(err, 'valid group root msg')
 
   tangle.add(group, groupMsg0)
 
@@ -49,12 +47,10 @@ tape('validate group tangle', (t) => {
   const groupMsg1Hash = MsgV2.getMsgHash(groupMsg1)
 
   err = MsgV2.validate(groupMsg1, tangle, pubkeys, groupMsg1Hash, group)
-  if (err) console.log(err)
+  assert.ifError(err, 'valid group msg')
-  t.error(err, 'valid group msg')
-  t.end()
 })
 
-tape('validate 2nd msg with existing root', (t) => {
+test('validate 2nd msg with existing root', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
   const group = MsgV2.getMsgHash(MsgV2.createGroup(keypair, 'alice'))
   const pubkeys = new Set([keypair.public])
@@ -78,12 +74,10 @@ tape('validate 2nd msg with existing root', (t) => {
   tangle.add(msgHash1, msg1)
 
   const err = MsgV2.validate(msg1, tangle, pubkeys, msgHash1, rootHash)
-  if (err) console.log(err)
+  assert.ifError(err, 'valid 2nd msg')
-  t.error(err, 'valid 2nd msg')
-  t.end()
 })
 
-tape('validate 2nd forked msg', (t) => {
+test('validate 2nd forked msg', (t) => {
   const keypair = Keypair.generate('ed25519', 'alice')
   const group = MsgV2.getMsgHash(MsgV2.createGroup(keypair, 'alice'))
   const pubkeys = new Set([keypair.public])
@@ -120,7 +114,5 @@ tape('validate 2nd forked msg', (t) => {
   tangle.add(msgHash1A, msg1A)
   tangle.add(msgHash1B, msg1B)
   const err = MsgV2.validate(msg1B, tangle, pubkeys, msgHash1B, rootHash)
-  if (err) console.log(err)
+  assert.ifError(err, 'valid 2nd forked msg')
-  t.error(err, 'valid 2nd forked msg')
-  t.end()
 })

test/msgs-iterator.test.js

@@ -1,10 +1,11 @@
-const test = require('tape')
+const test = require('node:test')
-const path = require('path')
+const assert = require('node:assert')
-const os = require('os')
+const path = require('node:path')
+const os = require('node:os')
+const p = require('node:util').promisify
 const rimraf = require('rimraf')
 const SecretStack = require('secret-stack')
 const caps = require('ssb-caps')
-const p = require('util').promisify
 const Keypair = require('ppppp-keypair')
 
 const DIR = path.join(os.tmpdir(), 'ppppp-db-msgs-iter')
@@ -39,8 +40,8 @@ test('msgs() iterator', async (t) => {
     else if (msg.metadata.type === 'about') abouts.push(msg.data.name)
   }
 
-  t.deepEqual(posts, ['hello 0', 'hello 2', 'hello 4'], 'queried posts')
+  assert.deepEqual(posts, ['hello 0', 'hello 2', 'hello 4'], 'queried posts')
-  t.deepEqual(abouts, ['Mr. #1', 'Mr. #3', 'Mr. #5'], 'queried abouts')
+  assert.deepEqual(abouts, ['Mr. #1', 'Mr. #3', 'Mr. #5'], 'queried abouts')
 
   await p(peer.close)(true)
 })

test/on-record-added.test.js

@@ -1,10 +1,11 @@
-const test = require('tape')
+const test = require('node:test')
-const path = require('path')
+const assert = require('node:assert')
+const path = require('node:path')
+const os = require('node:os')
+const p = require('node:util').promisify
 const rimraf = require('rimraf')
-const os = require('os')
 const SecretStack = require('secret-stack')
 const caps = require('ssb-caps')
-const p = require('util').promisify
 const Keypair = require('ppppp-keypair')
 
 const DIR = path.join(os.tmpdir(), 'ppppp-db-on-msg-added')
@@ -30,15 +31,15 @@ test('onRecordAdded', async (t) => {
     type: 'post',
     data: { text: 'I am hungry' },
   })
-  t.equal(rec1.msg.data.text, 'I am hungry', 'msg1 text correct')
+  assert.equal(rec1.msg.data.text, 'I am hungry', 'msg1 text correct')
 
   await p(setTimeout)(500)
 
-  t.equal(listened.length, 3)
+  assert.equal(listened.length, 3)
-  t.equals(listened[0].msg.metadata.group, null, 'group root')
+  assert.equal(listened[0].msg.metadata.group, null, 'group root')
-  t.equals(listened[1].msg.data, null, 'root')
+  assert.equal(listened[1].msg.data, null, 'root')
-  t.equals(listened[1].msg.metadata.dataSize, 0, 'root')
+  assert.equal(listened[1].msg.metadata.dataSize, 0, 'root')
-  t.deepEquals(listened[2], rec1, 'actual record')
+  assert.deepEqual(listened[2], rec1, 'actual record')
 
   remove()
   await p(peer.close)(true)

test/re-open.test.js

@@ -1,10 +1,11 @@
-const test = require('tape')
+const test = require('node:test')
-const path = require('path')
+const assert = require('node:assert')
-const os = require('os')
+const path = require('node:path')
+const os = require('node:os')
+const p = require('node:util').promisify
 const rimraf = require('rimraf')
 const SecretStack = require('secret-stack')
 const caps = require('ssb-caps')
-const p = require('util').promisify
 const Keypair = require('ppppp-keypair')
 
 const DIR = path.join(os.tmpdir(), 'ppppp-db-re-open')
@@ -19,7 +20,7 @@ test('publish some msgs, close, re-open', async (t) => {
 
   await peer.db.loaded()
   const group = (await p(peer.db.group.create)(null)).hash
-  t.pass('opened db')
+  // t.pass('opened db')
 
   const msgHashes = []
   for (let i = 0; i < 6; i++) {
@@ -30,19 +31,19 @@ test('publish some msgs, close, re-open', async (t) => {
     })
     msgHashes.push(rec.hash)
   }
-  t.pass('created some msgs')
+  // t.pass('created some msgs')
 
   await p(peer.db.del)(msgHashes[2])
-  t.pass('deleted the 3rd msg')
+  // t.pass('deleted the 3rd msg')
 
   await p(peer.close)(true)
-  t.pass('closed')
+  // t.pass('closed')
 
   const peer2 = SecretStack({ appKey: caps.shs })
     .use(require('../lib'))
     .use(require('ssb-box'))
     .call(null, { keypair, path: DIR })
-  t.pass('re-opened')
+  // t.pass('re-opened')
 
   await peer2.db.loaded()
 
@@ -52,7 +53,7 @@ test('publish some msgs, close, re-open', async (t) => {
     texts.push(msg.data.text)
   }
 
-  t.deepEquals(
+  assert.deepEqual(
     texts,
     ['hello 0', 'hello 1', 'hello 3', 'hello 4', 'hello 5'],
     'queried posts'

test/records-iterator.test.js

@@ -1,10 +1,11 @@
-const test = require('tape')
+const test = require('node:test')
-const path = require('path')
+const assert = require('node:assert')
-const os = require('os')
+const path = require('node:path')
+const os = require('node:os')
+const p = require('node:util').promisify
 const rimraf = require('rimraf')
 const SecretStack = require('secret-stack')
 const caps = require('ssb-caps')
-const p = require('util').promisify
 const Keypair = require('ppppp-keypair')
 
 const DIR = path.join(os.tmpdir(), 'ppppp-db-records-iter')
@@ -34,10 +35,10 @@ test('records() iterator', async (t) => {
   for (const rec of peer.db.records()) {
     if (!rec.msg.data) continue
     if (!rec.msg.metadata.group) continue
-    t.true(rec.misc.size > rec.msg.metadata.dataSize, 'size > dataSize')
+    assert.ok(rec.misc.size > rec.msg.metadata.dataSize, 'size > dataSize')
     count++
   }
-  t.equals(count, 6)
+  assert.equal(count, 6)
 
   await p(peer.close)(true)
 })