mirror of https://codeberg.org/pzp/pzp-db.git
replace tape with node:test
This commit is contained in:
Andre Staltz
parent
fa16916e82
commit
aa5d49d512
|
|
@ -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')
|
||||
|
|
|
|||
28
package.json
28
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/**/*.js"
|
||||
"lib/**/*"
|
||||
],
|
||||
"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",
|
||||
"tap-arc": "^0.3.5",
|
||||
"tape": "^5.6.3"
|
||||
"ssb-classic": "^1.1.0"
|
||||
},
|
||||
"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"
|
||||
|
|
|
|||
|
|
@ -1,7 +1,8 @@
|
|||
const test = require('tape')
|
||||
const path = require('path')
|
||||
const os = require('os')
|
||||
const p = require('util').promisify
|
||||
const test = require('node:test')
|
||||
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 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)
|
||||
})
|
||||
|
|
|
|||
|
|
@ -1,13 +1,14 @@
|
|||
const test = require('tape')
|
||||
const path = require('path')
|
||||
const os = require('os')
|
||||
const test = require('node:test')
|
||||
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 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),
|
||||
|
|
|
|||
|
|
@ -1,13 +1,14 @@
|
|||
const test = require('tape')
|
||||
const path = require('path')
|
||||
const os = require('os')
|
||||
const test = require('node:test')
|
||||
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 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)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,10 +1,11 @@
|
|||
const test = require('tape')
|
||||
const path = require('path')
|
||||
const os = require('os')
|
||||
const test = require('node:test')
|
||||
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 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) => {
|
||||
|
|
|
|||
|
|
@ -1,10 +1,11 @@
|
|||
const test = require('tape')
|
||||
const path = require('path')
|
||||
const os = require('os')
|
||||
const test = require('node:test')
|
||||
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 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')
|
||||
t.equal(
|
||||
assert.equal(rec1.msg.data.text, 'I am 1st post', 'msg1 text correct')
|
||||
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')
|
||||
t.equal(
|
||||
assert.equal(rec2.msg.data.text, 'I am 2nd post', 'msg2 text correct')
|
||||
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')
|
||||
t.equals(
|
||||
assert.ok(rec4, '4th post published')
|
||||
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')
|
||||
t.true(recEncrypted.msg.data.endsWith('.box'), '.box')
|
||||
assert.equal(typeof recEncrypted.msg.data, 'string')
|
||||
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')
|
||||
t.deepEquals(
|
||||
assert.equal(recB.msg.metadata.tangles[recA.hash].depth, 1, 'tangle depth 1')
|
||||
assert.deepEqual(
|
||||
recB.msg.metadata.tangles[recA.hash].prev,
|
||||
[recA.hash],
|
||||
'tangle prev'
|
||||
|
|
|
|||
|
|
@ -1,10 +1,11 @@
|
|||
const test = require('tape')
|
||||
const path = require('path')
|
||||
const os = require('os')
|
||||
const test = require('node:test')
|
||||
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 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')
|
||||
t.equals(msg.data.text, 'I am 1st post')
|
||||
assert.ok(msg, 'msg exists')
|
||||
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')
|
||||
t.equals(msg.data.text, 'I am 1st post')
|
||||
assert.ok(msg, 'msg exists')
|
||||
assert.equal(msg.data.text, 'I am 1st post')
|
||||
})
|
||||
|
||||
test('teardown', (t) => {
|
||||
|
|
|
|||
|
|
@ -1,10 +1,11 @@
|
|||
const test = require('tape')
|
||||
const path = require('path')
|
||||
const os = require('os')
|
||||
const test = require('node:test')
|
||||
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 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')
|
||||
t.true(tangle.has(reply1Lo), 'has reply1Lo')
|
||||
t.true(tangle.has(reply1Hi), 'has reply1Hi')
|
||||
t.true(tangle.has(reply2A), 'has reply2A')
|
||||
t.true(tangle.has(reply3Lo), 'has reply3Lo')
|
||||
t.true(tangle.has(reply3Hi), 'has reply3Hi')
|
||||
t.false(tangle.has('nonsense'), 'does not have nonsense')
|
||||
t.end()
|
||||
assert.equal(tangle.has(rootPost), true, 'has rootPost')
|
||||
assert.equal(tangle.has(reply1Lo), true, 'has reply1Lo')
|
||||
assert.equal(tangle.has(reply1Hi), true, 'has reply1Hi')
|
||||
assert.equal(tangle.has(reply2A), true, 'has reply2A')
|
||||
assert.equal(tangle.has(reply3Lo), true, 'has reply3Lo')
|
||||
assert.equal(tangle.has(reply3Hi), true, 'has reply3Hi')
|
||||
assert.equal(tangle.has('nonsense'), false, 'does not have nonsense')
|
||||
})
|
||||
|
||||
test('Tangle.getDepth', (t) => {
|
||||
t.equals(tangle.getDepth(rootPost), 0, 'depth of rootPost is 0')
|
||||
t.equals(tangle.getDepth(reply1Lo), 1, 'depth of reply1Lo is 1')
|
||||
t.equals(tangle.getDepth(reply1Hi), 1, 'depth of reply1Hi is 1')
|
||||
t.equals(tangle.getDepth(reply2A), 2, 'depth of reply2A is 2')
|
||||
t.equals(tangle.getDepth(reply3Lo), 3, 'depth of reply3Lo is 3')
|
||||
t.equals(tangle.getDepth(reply3Hi), 3, 'depth of reply3Hi is 3')
|
||||
t.end()
|
||||
assert.equal(tangle.getDepth(rootPost), 0, 'depth of rootPost is 0')
|
||||
assert.equal(tangle.getDepth(reply1Lo), 1, 'depth of reply1Lo is 1')
|
||||
assert.equal(tangle.getDepth(reply1Hi), 1, 'depth of reply1Hi is 1')
|
||||
assert.equal(tangle.getDepth(reply2A), 2, 'depth of reply2A is 2')
|
||||
assert.equal(tangle.getDepth(reply3Lo), 3, 'depth of reply3Lo is 3')
|
||||
assert.equal(tangle.getDepth(reply3Hi), 3, 'depth of reply3Hi is 3')
|
||||
})
|
||||
|
||||
test('Tangle.getMaxDepth', (t) => {
|
||||
t.equals(tangle.getMaxDepth(), 3, 'max depth is 3')
|
||||
t.end()
|
||||
assert.equal(tangle.getMaxDepth(), 3, 'max depth is 3')
|
||||
})
|
||||
|
||||
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')
|
||||
t.true(tangle.precedes(rootPost, reply1Hi), 'rootPost precedes reply1Hi')
|
||||
t.false(
|
||||
assert.equal(
|
||||
tangle.precedes(rootPost, reply1Lo),
|
||||
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')
|
||||
t.true(tangle.precedes(reply1Lo, reply3Hi), 'reply1Lo precedes reply3Hi')
|
||||
t.true(tangle.precedes(reply1Hi, reply2A), 'reply1Hi precedes reply2A')
|
||||
t.false(
|
||||
assert.equal(
|
||||
tangle.precedes(reply1Lo, reply1Lo),
|
||||
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')
|
||||
t.true(tips.has(reply3Lo), 'tips contains reply3Lo')
|
||||
t.true(tips.has(reply3Hi), 'tips contains reply3Hi')
|
||||
t.end()
|
||||
assert.equal(tips.size, 2, 'there are 2 tips')
|
||||
assert.equal(tips.has(reply3Lo), true, 'tips contains reply3Lo')
|
||||
assert.equal(tips.has(reply3Hi), true, 'tips contains reply3Hi')
|
||||
})
|
||||
|
||||
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)')
|
||||
t.true(tangle.getLipmaaSet(1).has(rootPost), 'lipmaa 1 (-1)')
|
||||
assert.equal(tangle.getLipmaaSet(1).size, 1, 'lipmaa 1 (-1)')
|
||||
assert.equal(tangle.getLipmaaSet(1).has(rootPost), true, 'lipmaa 1 (-1)')
|
||||
|
||||
t.equals(tangle.getLipmaaSet(2).size, 2, 'lipmaa 2 (-1)')
|
||||
t.true(tangle.getLipmaaSet(2).has(reply1Lo), 'lipmaa 2 (-1)')
|
||||
t.true(tangle.getLipmaaSet(2).has(reply1Hi), 'lipmaa 2 (-1)')
|
||||
assert.equal(tangle.getLipmaaSet(2).size, 2, 'lipmaa 2 (-1)')
|
||||
assert.equal(tangle.getLipmaaSet(2).has(reply1Lo), true, 'lipmaa 2 (-1)')
|
||||
assert.equal(tangle.getLipmaaSet(2).has(reply1Hi), true, 'lipmaa 2 (-1)')
|
||||
|
||||
t.equals(tangle.getLipmaaSet(3).size, 1, 'lipmaa 3 (leap!)')
|
||||
t.true(tangle.getLipmaaSet(3).has(rootPost), 'lipmaa 3 (leap!)')
|
||||
assert.equal(tangle.getLipmaaSet(3).size, 1, 'lipmaa 3 (leap!)')
|
||||
assert.equal(tangle.getLipmaaSet(3).has(rootPost), true, 'lipmaa 3 (leap!)')
|
||||
|
||||
t.equals(tangle.getLipmaaSet(4).size, 2, 'lipmaa 4 (-1)')
|
||||
t.true(tangle.getLipmaaSet(4).has(reply3Lo), 'lipmaa 4 (-1)')
|
||||
t.true(tangle.getLipmaaSet(4).has(reply3Hi), 'lipmaa 4 (-1)')
|
||||
assert.equal(tangle.getLipmaaSet(4).size, 2, 'lipmaa 4 (-1)')
|
||||
assert.equal(tangle.getLipmaaSet(4).has(reply3Lo), true, 'lipmaa 4 (-1)')
|
||||
assert.equal(tangle.getLipmaaSet(4).has(reply3Hi), true, 'lipmaa 4 (-1)')
|
||||
|
||||
t.equals(tangle.getLipmaaSet(5).size, 0, 'lipmaa 5 (empty)')
|
||||
|
||||
t.end()
|
||||
assert.equal(tangle.getLipmaaSet(5).size, 0, 'lipmaa 5 (empty)')
|
||||
})
|
||||
|
||||
test('Tangle.getDeletablesAndErasables basic', (t) => {
|
||||
const { deletables, erasables } = tangle.getDeletablesAndErasables(reply2A)
|
||||
|
||||
t.deepEquals(deletables, [reply1Hi], 'deletables')
|
||||
t.deepEquals(erasables, [reply1Lo, rootPost], 'erasables')
|
||||
t.end()
|
||||
assert.deepEqual(deletables, [reply1Hi], 'deletables')
|
||||
assert.deepEqual(erasables, [reply1Lo, rootPost], 'erasables')
|
||||
})
|
||||
|
||||
test('Tangle.getDeletablesAndErasables with lipmaa', (t) => {
|
||||
const { deletables, erasables } = tangle.getDeletablesAndErasables(reply3Lo)
|
||||
|
||||
t.deepEquals(deletables, [reply1Lo, reply1Hi, reply2A], 'deletables')
|
||||
t.deepEquals(erasables, [rootPost], 'erasables')
|
||||
t.end()
|
||||
assert.deepEqual(deletables, [reply1Lo, reply1Hi, reply2A], 'deletables')
|
||||
assert.deepEqual(erasables, [rootPost], 'erasables')
|
||||
})
|
||||
|
||||
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) => {
|
||||
|
|
|
|||
|
|
@ -1,10 +1,11 @@
|
|||
const test = require('tape')
|
||||
const path = require('path')
|
||||
const os = require('os')
|
||||
const test = require('node:test')
|
||||
const assert = require('node:assert')
|
||||
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')
|
||||
t.equals(msg.data.add, keypair2.public, 'msg.data.add NEW KEY')
|
||||
t.equals(msg.metadata.group, null, 'msg.metadata.group')
|
||||
t.equals(msg.metadata.groupTips, null, 'msg.metadata.groupTips')
|
||||
t.deepEquals(
|
||||
assert.ok(hash, 'hash exists')
|
||||
assert.equal(msg.data.add, keypair2.public, 'msg.data.add NEW KEY')
|
||||
assert.equal(msg.metadata.group, null, 'msg.metadata.group')
|
||||
assert.equal(msg.metadata.groupTips, null, 'msg.metadata.groupTips')
|
||||
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')
|
||||
t.deepEquals(_groupRec1.msg, groupRec1.msg, 'groupMsg1')
|
||||
t.deepEquals(postsRoot.msg.metadata, {
|
||||
assert.deepEqual(_groupRec0.msg, groupRec0.msg, 'groupMsg0')
|
||||
assert.deepEqual(_groupRec1.msg, groupRec1.msg, 'groupMsg1')
|
||||
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)()
|
||||
})
|
||||
|
|
|
|||
|
|
@ -1,10 +1,11 @@
|
|||
const test = require('tape')
|
||||
const path = require('path')
|
||||
const os = require('os')
|
||||
const test = require('node:test')
|
||||
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 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')
|
||||
t.equals(msg.data.add, keypair.public, 'msg.data.add')
|
||||
t.equals(msg.metadata.group, null, 'msg.metadata.group')
|
||||
t.equals(msg.metadata.groupTips, null, 'msg.metadata.groupTips')
|
||||
t.deepEquals(Object.keys(msg.metadata.tangles), [], 'msg.metadata.tangles')
|
||||
t.equals(msg.pubkey, keypair.public, 'msg.pubkey')
|
||||
assert.ok(hash, 'hash exists')
|
||||
assert.equal(msg.data.add, keypair.public, 'msg.data.add')
|
||||
assert.equal(msg.metadata.group, null, 'msg.metadata.group')
|
||||
assert.equal(msg.metadata.groupTips, null, 'msg.metadata.groupTips')
|
||||
assert.deepEqual(Object.keys(msg.metadata.tangles), [], 'msg.metadata.tangles')
|
||||
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')
|
||||
t.equals(msg.data.add, keypair.public, 'msg.data.add')
|
||||
t.equals(msg.metadata.group, null, 'msg.metadata.group')
|
||||
t.equals(msg.metadata.groupTips, null, 'msg.metadata.groupTips')
|
||||
t.deepEquals(Object.keys(msg.metadata.tangles), [], 'msg.metadata.tangles')
|
||||
t.equals(msg.pubkey, keypair.public, 'msg.pubkey')
|
||||
assert.ok(hash, 'hash exists')
|
||||
assert.equal(msg.data.add, keypair.public, 'msg.data.add')
|
||||
assert.equal(msg.metadata.group, null, 'msg.metadata.group')
|
||||
assert.equal(msg.metadata.groupTips, null, 'msg.metadata.groupTips')
|
||||
assert.deepEqual(Object.keys(msg.metadata.tangles), [], 'msg.metadata.tangles')
|
||||
assert.equal(msg.pubkey, keypair.public, 'msg.pubkey')
|
||||
|
||||
await p(peer.close)()
|
||||
})
|
||||
|
|
|
|||
|
|
@ -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')
|
||||
t.equals(groupMsg0.metadata.dataHash, 'THi3VkJeaf8aTkLSNJUdFD', 'hash')
|
||||
t.equals(groupMsg0.metadata.dataSize, 72, 'size')
|
||||
t.equals(groupMsg0.metadata.group, null, 'group')
|
||||
t.equals(groupMsg0.metadata.groupTips, null, 'groupTips')
|
||||
t.deepEquals(groupMsg0.metadata.tangles, {}, 'tangles')
|
||||
t.equals(groupMsg0.metadata.type, 'group', 'type')
|
||||
t.equals(groupMsg0.metadata.v, 2, 'v')
|
||||
t.equals(groupMsg0.pubkey, keypair.public, 'pubkey')
|
||||
assert.equal(groupMsg0.data.add, keypair.public, 'data.add')
|
||||
assert.equal(groupMsg0.metadata.dataHash, 'THi3VkJeaf8aTkLSNJUdFD', 'hash')
|
||||
assert.equal(groupMsg0.metadata.dataSize, 72, 'size')
|
||||
assert.equal(groupMsg0.metadata.group, null, 'group')
|
||||
assert.equal(groupMsg0.metadata.groupTips, null, 'groupTips')
|
||||
assert.deepEqual(groupMsg0.metadata.tangles, {}, 'tangles')
|
||||
assert.equal(groupMsg0.metadata.type, 'group', 'type')
|
||||
assert.equal(groupMsg0.metadata.v, 2, 'v')
|
||||
assert.equal(groupMsg0.pubkey, keypair.public, 'pubkey')
|
||||
|
||||
group = MsgV2.getMsgHash(groupMsg0)
|
||||
t.equals(group, 'XKKmEBmqKGa5twQ2HNSk7t', 'group ID')
|
||||
|
||||
t.end()
|
||||
assert.equal(group, 'XKKmEBmqKGa5twQ2HNSk7t', 'group ID')
|
||||
})
|
||||
|
||||
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')
|
||||
t.equals(rootMsg.metadata.dataHash, null, 'hash')
|
||||
t.equals(rootMsg.metadata.dataSize, 0, 'size')
|
||||
t.equals(rootMsg.metadata.group, group, 'group')
|
||||
t.equals(rootMsg.metadata.groupTips, null, 'groupTips')
|
||||
t.deepEquals(rootMsg.metadata.tangles, {}, 'tangles')
|
||||
t.equals(rootMsg.metadata.type, 'post', 'type')
|
||||
t.equals(rootMsg.metadata.v, 2, 'v')
|
||||
t.equals(rootMsg.pubkey, keypair.public, 'pubkey')
|
||||
assert.equal(rootMsg.data, null, 'data')
|
||||
assert.equal(rootMsg.metadata.dataHash, null, 'hash')
|
||||
assert.equal(rootMsg.metadata.dataSize, 0, 'size')
|
||||
assert.equal(rootMsg.metadata.group, group, 'group')
|
||||
assert.equal(rootMsg.metadata.groupTips, null, 'groupTips')
|
||||
assert.deepEqual(rootMsg.metadata.tangles, {}, 'tangles')
|
||||
assert.equal(rootMsg.metadata.type, 'post', 'type')
|
||||
assert.equal(rootMsg.metadata.v, 2, 'v')
|
||||
assert.equal(rootMsg.pubkey, keypair.public, 'pubkey')
|
||||
|
||||
rootHash = MsgV2.getMsgHash(rootMsg)
|
||||
t.equals(rootHash, 'PzuT1Dwbbgn6a8NeLuHuKw', 'root hash')
|
||||
t.end()
|
||||
assert.equal(rootHash, 'PzuT1Dwbbgn6a8NeLuHuKw', 'root hash')
|
||||
})
|
||||
|
||||
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')
|
||||
t.deepEquals(
|
||||
assert.deepEqual(msg1.data, data, 'data')
|
||||
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')
|
||||
t.equals(msg1.metadata.group, group, 'metadata.group')
|
||||
t.deepEquals(msg1.metadata.groupTips, [group], 'metadata.groupTips')
|
||||
t.deepEquals(
|
||||
assert.deepEqual(msg1.metadata.dataSize, 23, 'metadata.dataSize')
|
||||
assert.equal(msg1.metadata.group, group, 'metadata.group')
|
||||
assert.deepEqual(msg1.metadata.groupTips, [group], 'metadata.groupTips')
|
||||
assert.deepEqual(
|
||||
Object.keys(msg1.metadata.tangles),
|
||||
[rootHash],
|
||||
'metadata.tangles'
|
||||
)
|
||||
t.equals(msg1.metadata.tangles[rootHash].depth, 1, 'tangle depth')
|
||||
t.deepEquals(msg1.metadata.tangles[rootHash].prev, [rootHash], 'tangle prev')
|
||||
t.equals(msg1.metadata.type, 'post', 'metadata.type')
|
||||
t.deepEquals(msg1.metadata.v, 2, 'metadata.v')
|
||||
t.equals(
|
||||
assert.equal(msg1.metadata.tangles[rootHash].depth, 1, 'tangle depth')
|
||||
assert.deepEqual(msg1.metadata.tangles[rootHash].prev, [rootHash], 'tangle prev')
|
||||
assert.equal(msg1.metadata.type, 'post', 'metadata.type')
|
||||
assert.deepEqual(msg1.metadata.v, 2, 'metadata.v')
|
||||
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')
|
||||
t.deepEquals(
|
||||
assert.deepEqual(msg2.data, data2, 'data')
|
||||
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')
|
||||
t.equals(msg2.metadata.group, group, 'metadata.group')
|
||||
t.deepEquals(msg2.metadata.groupTips, [group], 'metadata.groupTips')
|
||||
t.deepEquals(
|
||||
assert.deepEqual(msg2.metadata.dataSize, 21, 'metadata.dataSize')
|
||||
assert.equal(msg2.metadata.group, group, 'metadata.group')
|
||||
assert.deepEqual(msg2.metadata.groupTips, [group], 'metadata.groupTips')
|
||||
assert.deepEqual(
|
||||
Object.keys(msg2.metadata.tangles),
|
||||
[rootHash],
|
||||
'metadata.tangles'
|
||||
)
|
||||
t.equals(msg2.metadata.tangles[rootHash].depth, 2, 'tangle depth')
|
||||
t.deepEquals(msg2.metadata.tangles[rootHash].prev, [msgHash1], 'tangle prev')
|
||||
t.equals(msg2.metadata.type, 'post', 'metadata.type')
|
||||
t.deepEquals(msg2.metadata.v, 2, 'metadata.v')
|
||||
t.equals(
|
||||
assert.equal(msg2.metadata.tangles[rootHash].depth, 2, 'tangle depth')
|
||||
assert.deepEqual(msg2.metadata.tangles[rootHash].prev, [msgHash1], 'tangle prev')
|
||||
assert.equal(msg2.metadata.type, 'post', 'metadata.type')
|
||||
assert.deepEqual(msg2.metadata.v, 2, 'metadata.v')
|
||||
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()
|
||||
})
|
||||
|
|
|
|||
|
|
@ -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')
|
||||
t.match(
|
||||
assert.ok(err, 'invalid 2nd msg throws')
|
||||
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')
|
||||
t.match(
|
||||
assert.ok(err, 'invalid 2nd msg throws')
|
||||
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')
|
||||
t.match(err, /prev item ".*" is a URI/, 'invalid 2nd msg description')
|
||||
t.end()
|
||||
assert.ok(err, 'invalid 2nd msg throws')
|
||||
assert.match(err, /prev item ".*" is a URI/, 'invalid 2nd msg description')
|
||||
})
|
||||
|
||||
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')
|
||||
t.match(err, /all prev are locally unknown/, 'invalid 2nd msg description')
|
||||
t.end()
|
||||
assert.ok(err, 'invalid 2nd msg throws')
|
||||
assert.match(err, /all prev are locally unknown/, 'invalid 2nd msg description')
|
||||
})
|
||||
|
||||
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')
|
||||
t.match(
|
||||
assert.ok(err, 'invalid 3rd msg throws')
|
||||
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')
|
||||
t.match(err, /prev ".*" contains duplicates/, 'invalid error message')
|
||||
t.end()
|
||||
assert.ok(err, 'invalid 1st msg throws')
|
||||
assert.match(err, /prev ".*" contains duplicates/, 'invalid error message')
|
||||
})
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
})
|
||||
|
|
|
|||
|
|
@ -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')
|
||||
t.deepEquals(msg1.metadata.tangles[rootHash].prev, [rootHash], 'msg1 prev')
|
||||
assert.equal(msg1.metadata.tangles[rootHash].depth, 1, 'msg1 depth')
|
||||
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')
|
||||
t.deepEquals(msg2.metadata.tangles[rootHash].prev, [msgHash1], 'msg2 prev')
|
||||
assert.equal(msg2.metadata.tangles[rootHash].depth, 2, 'msg2 depth')
|
||||
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')
|
||||
t.deepEquals(
|
||||
assert.equal(msg3.metadata.tangles[rootHash].depth, 3, 'msg3 depth')
|
||||
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')
|
||||
t.deepEquals(msg4.metadata.tangles[rootHash].prev, [msgHash3], 'msg4 prev')
|
||||
assert.equal(msg4.metadata.tangles[rootHash].depth, 4, 'msg4 depth')
|
||||
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')
|
||||
t.deepEquals(msg5.metadata.tangles[rootHash].prev, [msgHash4], 'msg5 prev')
|
||||
assert.equal(msg5.metadata.tangles[rootHash].depth, 5, 'msg5 depth')
|
||||
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')
|
||||
t.deepEquals(msg6.metadata.tangles[rootHash].prev, [msgHash5], 'msg6 prev')
|
||||
assert.equal(msg6.metadata.tangles[rootHash].depth, 6, 'msg6 depth')
|
||||
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')
|
||||
t.deepEquals(
|
||||
assert.equal(msg7.metadata.tangles[rootHash].depth, 7, 'msg7 depth')
|
||||
assert.deepEqual(
|
||||
msg7.metadata.tangles[rootHash].prev,
|
||||
[msgHash3, msgHash6].sort(),
|
||||
'msg7 prev (has lipmaa!)'
|
||||
)
|
||||
|
||||
t.end()
|
||||
})
|
||||
|
|
|
|||
|
|
@ -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')
|
||||
t.deepEquals(
|
||||
assert.equal(
|
||||
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')
|
||||
t.deepEquals(
|
||||
assert.equal(
|
||||
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()
|
||||
})
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
t.error(err, 'valid root msg')
|
||||
t.end()
|
||||
assert.ifError(err, 'valid root msg')
|
||||
})
|
||||
|
||||
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)
|
||||
t.error(err, 'valid group root msg')
|
||||
assert.ifError(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)
|
||||
t.error(err, 'valid group msg')
|
||||
t.end()
|
||||
assert.ifError(err, 'valid group msg')
|
||||
})
|
||||
|
||||
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)
|
||||
t.error(err, 'valid 2nd msg')
|
||||
t.end()
|
||||
assert.ifError(err, 'valid 2nd msg')
|
||||
})
|
||||
|
||||
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)
|
||||
t.error(err, 'valid 2nd forked msg')
|
||||
t.end()
|
||||
assert.ifError(err, 'valid 2nd forked msg')
|
||||
})
|
||||
|
|
|
|||
|
|
@ -1,10 +1,11 @@
|
|||
const test = require('tape')
|
||||
const path = require('path')
|
||||
const os = require('os')
|
||||
const test = require('node:test')
|
||||
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 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')
|
||||
t.deepEqual(abouts, ['Mr. #1', 'Mr. #3', 'Mr. #5'], 'queried abouts')
|
||||
assert.deepEqual(posts, ['hello 0', 'hello 2', 'hello 4'], 'queried posts')
|
||||
assert.deepEqual(abouts, ['Mr. #1', 'Mr. #3', 'Mr. #5'], 'queried abouts')
|
||||
|
||||
await p(peer.close)(true)
|
||||
})
|
||||
|
|
|
|||
|
|
@ -1,10 +1,11 @@
|
|||
const test = require('tape')
|
||||
const path = require('path')
|
||||
const test = require('node:test')
|
||||
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)
|
||||
t.equals(listened[0].msg.metadata.group, null, 'group root')
|
||||
t.equals(listened[1].msg.data, null, 'root')
|
||||
t.equals(listened[1].msg.metadata.dataSize, 0, 'root')
|
||||
t.deepEquals(listened[2], rec1, 'actual record')
|
||||
assert.equal(listened.length, 3)
|
||||
assert.equal(listened[0].msg.metadata.group, null, 'group root')
|
||||
assert.equal(listened[1].msg.data, null, 'root')
|
||||
assert.equal(listened[1].msg.metadata.dataSize, 0, 'root')
|
||||
assert.deepEqual(listened[2], rec1, 'actual record')
|
||||
|
||||
remove()
|
||||
await p(peer.close)(true)
|
||||
|
|
|
|||
|
|
@ -1,10 +1,11 @@
|
|||
const test = require('tape')
|
||||
const path = require('path')
|
||||
const os = require('os')
|
||||
const test = require('node:test')
|
||||
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 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'
|
||||
|
|
|
|||
|
|
@ -1,10 +1,11 @@
|
|||
const test = require('tape')
|
||||
const path = require('path')
|
||||
const os = require('os')
|
||||
const test = require('node:test')
|
||||
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 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)
|
||||
})
|
||||
|
|
|
|||
Loading…
Reference in New Issue