Mirroristas/orbitdb
2
0
Fork 0
mirror of https://github.com/orbitdb/orbitdb.git synced 2025-10-07 22:57:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor IdentityProvider

Browse Source
This commit is contained in:
haad
2023-02-16 16:40:46 +02:00
parent bbb6ef9e2b
commit 5b6a70c7cc
31 changed files with 539 additions and 526 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
src/identities/identities.js Normal file
View File

@@ -0,0 +1,135 @@
import Identity from './identity.js'
import OrbitDBIdentityProvider from './providers/orbitdb.js'
// import DIDIdentityProvider from './identity-providers/did.js'
// import EthIdentityProvider from './identity-providers/ethereum.js'
import KeyStore from '../key-store.js'
import IdentityStore from './identity-store.js'
import { LRUStorage } from '../storage/index.js'
import path from 'path'
const DefaultProviderType = 'orbitdb'
const DefaultIdentityKeysPath = path.join('./orbitdb', 'identity', 'identitykeys')
const supportedTypes = {
orbitdb: OrbitDBIdentityProvider
// [DIDIdentityProvider.type]: DIDIdentityProvider,
// [EthIdentityProvider.type]: EthIdentityProvider
}
const Identities = async ({ keystore, signingKeyStore, identityKeysPath, signingKeysPath, identityStore, ipfs } = {}) => {
keystore = keystore || new KeyStore(identityKeysPath || DefaultIdentityKeysPath)
signingKeyStore = signingKeyStore || (signingKeysPath ? new KeyStore(signingKeysPath) : keystore)
identityStore = identityStore || await IdentityStore({ ipfs })
const verifiedIdentitiesCache = await LRUStorage({ size: 1000 })
const getIdentity = async (hash) => {
return identityStore.get(hash)
}
const createIdentity = async (options = {}) => {
options.keystore = signingKeyStore || keystore
const type = options.type || DefaultProviderType
const Provider = getProviderFor(type)
const identityProvider = new Provider(options)
const id = await identityProvider.getId(options)
const privateKey = await keystore.getKey(id) || await keystore.createKey(id)
const publicKey = keystore.getPublic(privateKey)
const idSignature = await KeyStore.sign(privateKey, id)
const pubKeyIdSignature = await identityProvider.signIdentity(publicKey + idSignature, options)
const identity = new Identity(id, publicKey, idSignature, pubKeyIdSignature, type, sign, verify)
const hash = await identityStore.put(identity.toJSON())
// TODO: fix this monkey patching
identity.hash = hash
return identity
}
const verifyIdentity = async (identity) => {
if (!Identity.isIdentity(identity)) {
return false
}
const { id, publicKey, signatures } = identity
const idSignatureVerified = await KeyStore.verify(signatures.id, publicKey, id)
if (!idSignatureVerified) {
return false
}
const verifiedIdentity = await verifiedIdentitiesCache.get(signatures.id)
if (verifiedIdentity) {
return Identity.isEqual(identity, verifiedIdentity)
}
const Provider = getProviderFor(identity.type)
const identityVerified = await Provider.verifyIdentity(identity)
if (identityVerified) {
await verifiedIdentitiesCache.put(signatures.id, identity.toJSON())
}
return identityVerified
}
const sign = async (identity, data) => {
const signingKey = await keystore.getKey(identity.id)
if (!signingKey) {
throw new Error('Private signing key not found from KeyStore')
}
return KeyStore.sign(signingKey, data)
}
const verify = async (signature, publicKey, data) => {
return KeyStore.verify(signature, publicKey, data)
}
const isSupported = (type) => {
return Object.keys(supportedTypes).includes(type)
}
const getProviderFor = (type) => {
if (!isSupported(type)) {
throw new Error(`IdentityProvider type '${type}' is not supported`)
}
return supportedTypes[type]
}
const addIdentityProvider = (IdentityProvider) => {
if (!IdentityProvider) {
throw new Error('IdentityProvider must be given as an argument')
}
if (!IdentityProvider.type ||
typeof IdentityProvider.type !== 'string') {
throw new Error('Given IdentityProvider doesn\'t have a field \'type\'')
}
supportedTypes[IdentityProvider.type] = IdentityProvider
}
const removeIdentityProvider = (type) => {
delete supportedTypes[type]
}
return {
createIdentity,
verifyIdentity,
getIdentity,
sign,
verify,
isSupported,
addIdentityProvider,
removeIdentityProvider,
keystore,
signingKeyStore
}
}
export { Identities as default }

177
src/identities/identity-provider.js
View File

@@ -1,177 +0,0 @@
import Identity from './identity.js'
import IdentityProvider from './providers/interface.js'
import OrbitDBIdentityProvider from './providers/orbitdb.js'
// import DIDIdentityProvider from './identity-providers/did.js'
// import EthIdentityProvider from './identity-providers/ethereum.js'
import KeyStore from '../key-store.js'
import IdentityStore from './identity-store.js'
import LRU from 'lru'
import path from 'path'
const defaultType = 'orbitdb'
const identityKeysPath = path.join('./orbitdb', 'identity', 'identitykeys')
const supportedTypes = {
orbitdb: OrbitDBIdentityProvider
// [DIDIdentityProvider.type]: DIDIdentityProvider,
// [EthIdentityProvider.type]: EthIdentityProvider
}
const getHandlerFor = (type) => {
if (!Identities.isSupported(type)) {
throw new Error(`IdentityProvider type '${type}' is not supported`)
}
return supportedTypes[type]
}
class Identities {
constructor (options) {
this._keystore = options.keystore
this._signingKeyStore = options.signingKeyStore || this._keystore
this._knownIdentities = options.cache || new LRU(options.cacheSize || 100)
this._storage = options.identityStore
}
static get IdentityProvider () { return IdentityProvider }
get keystore () { return this._keystore }
get signingKeyStore () { return this._signingKeyStore }
async sign (identity, data) {
const signingKey = await this.keystore.getKey(identity.id)
if (!signingKey) {
throw new Error('Private signing key not found from KeyStore')
}
const sig = await this.keystore.sign(signingKey, data)
return sig
}
async verify (signature, publicKey, data, verifier = 'v1') {
return this.keystore.verify(signature, publicKey, data, verifier)
}
async createIdentity (options = {}) {
const keystore = options.keystore || this.keystore
const type = options.type || defaultType
const identityProvider = type === defaultType ? new OrbitDBIdentityProvider(options.signingKeyStore || keystore) : new (getHandlerFor(type))(options)
const id = await identityProvider.getId(options)
const { publicKey, idSignature } = await this.signId(id)
const pubKeyIdSignature = await identityProvider.signIdentity(publicKey + idSignature, options)
// return new Identity(id, publicKey, idSignature, pubKeyIdSignature, type, this)
const identity = new Identity(id, publicKey, idSignature, pubKeyIdSignature, type, this)
await identity.store()
// const hash = options.identityStore.put(identity.toJSON())
return identity
}
async get (hash) {
return this._storage.get(hash)
}
async signId (id) {
const keystore = this.keystore
const key = await keystore.getKey(id) || await keystore.createKey(id)
const publicKey = keystore.getPublic(key)
const idSignature = await keystore.sign(key, id)
return { publicKey, idSignature }
}
async verifyIdentity (identity) {
if (!Identity.isIdentity(identity)) {
return false
}
const knownID = this._knownIdentities.get(identity.signatures.id)
if (knownID) {
return identity.id === knownID.id &&
identity.publicKey === knownID.publicKey &&
identity.signatures.id === knownID.signatures.id &&
identity.signatures.publicKey === knownID.signatures.publicKey
}
const verifyIdSig = await this.keystore.verify(
identity.signatures.id,
identity.publicKey,
identity.id
)
if (!verifyIdSig) return false
const IdentityProvider = getHandlerFor(identity.type)
const verified = await IdentityProvider.verifyIdentity(identity)
if (verified) {
this._knownIdentities.set(identity.signatures.id, Identity.toJSON(identity))
}
return verified
}
static async verifyIdentity (identity) {
if (!Identity.isIdentity(identity)) {
return false
}
const verifyIdSig = await KeyStore.verify(
identity.signatures.id,
identity.publicKey,
identity.id
)
if (!verifyIdSig) return false
const IdentityProvider = getHandlerFor(identity.type)
return IdentityProvider.verifyIdentity(identity)
}
static async createIdentity (options = {}) {
if (!options.keystore) {
options.keystore = new KeyStore(options.identityKeysPath || identityKeysPath)
}
if (!options.signingKeyStore) {
if (options.signingKeysPath) {
options.signingKeyStore = new KeyStore(options.signingKeysPath)
} else {
options.signingKeyStore = options.keystore
}
}
await options.keystore.open()
await options.signingKeyStore.open()
let identityStore
if (options.storage) {
identityStore = await IdentityStore({ storage: options.storage })
} else if (options.ipfs) {
identityStore = await IdentityStore({ ipfs: options.ipfs })
} else {
identityStore = await IdentityStore()
}
options = Object.assign({}, { type: defaultType, identityStore }, options)
const identities = new Identities(options)
return identities.createIdentity(options)
}
static isSupported (type) {
return Object.keys(supportedTypes).includes(type)
}
static addIdentityProvider (IdentityProvider) {
if (!IdentityProvider) {
throw new Error('IdentityProvider class needs to be given as an option')
}
if (!IdentityProvider.type ||
typeof IdentityProvider.type !== 'string') {
throw new Error('Given IdentityProvider class needs to implement: static get type() { /* return a string */ }.')
}
supportedTypes[IdentityProvider.type] = IdentityProvider
}
static removeIdentityProvider (type) {
delete supportedTypes[type]
}
}
export { Identities as default, Identity }

30
src/identities/identity.js
View File

@@ -1,7 +1,7 @@
import isDefined from '../utils/is-defined.js'
class Identity {
constructor (id, publicKey, idSignature, pubKeyIdSignature, type, provider) {
constructor (id, publicKey, idSignature, pubKeyIdSignature, type, signFn, verifyFn) {
if (!isDefined(id)) {
throw new Error('Identity id is required')
}
@@ -22,21 +22,18 @@ class Identity {
throw new Error('Identity type is required')
}
if (!isDefined(provider)) {
throw new Error('Identity provider is required')
}
// if (!isDefined(provider)) {
// throw new Error('Identity provider is required')
// }
this._id = id
this._publicKey = publicKey
this._signatures = Object.assign({}, { id: idSignature }, { publicKey: pubKeyIdSignature })
this._type = type
this._provider = provider
// this._provider = provider
this.hash = null
}
async store () {
const value = this.toJSON()
this.hash = await this._provider._storage.put(value)
this.sign = signFn
this.verify = verifyFn
}
/**
@@ -59,9 +56,9 @@ class Identity {
return this._type
}
get provider () {
return this._provider
}
// get provider () {
// return this._provider
// }
toJSON () {
return {
@@ -72,6 +69,13 @@ class Identity {
}
}
static isEqual (a, b) {
return a.id === b.id &&
a.publicKey === b.publicKey &&
a.signatures.id === b.signatures.id &&
a.signatures.publicKey === b.signatures.publicKey
}
static isIdentity (identity) {
return identity.id !== undefined &&
identity.publicKey !== undefined &&

2
src/identities/index.js
View File

@@ -1,2 +1,2 @@
export { default as IdentityProvider } from './identity-provider.js'
export { default as Identities } from './identities.js'
export { default as Identity } from './identity.js'

4
src/identities/providers/orbitdb.js
View File

@@ -3,7 +3,7 @@ import KeyStore from '../../key-store.js'
const type = 'orbitdb'
class OrbitDBIdentityProvider extends IdentityProvider {
constructor (keystore) {
constructor ({ keystore }) {
super()
if (!keystore) {
throw new Error('OrbitDBIdentityProvider requires a keystore')
@@ -36,7 +36,7 @@ class OrbitDBIdentityProvider extends IdentityProvider {
throw new Error(`Signing key for '${id}' not found`)
}
return keystore.sign(key, data)
return KeyStore.sign(key, data)
}
static async verifyIdentity (identity) {

2
src/index.js
View File

@@ -1,3 +1,3 @@
export { Log, DefaultAccessController, Entry } from './oplog/index.js'
export { default as KeyStore } from './key-store.js'
export { IdentityProvider } from './identities/index.js'
export { Identities } from './identities/index.js'

57
src/key-store.js
View File

@@ -108,9 +108,10 @@ export default class KeyStore {
if (!id) {
throw new Error('id needed to create a key')
}
if (this._store.status && this._store.status !== 'open') {
return null
}
// if (this._store.status && this._store.status !== 'open') {
// console.log("22::", id)
// return null
// }
// Generate a private key
const privKey = ec.genKeyPair({ entropy }).getPrivate().toArrayLike(Buffer)
@@ -175,22 +176,6 @@ export default class KeyStore {
return unmarshal(Buffer.from(deserializedKey.privateKey, 'hex'))
}
async sign (key, data) {
if (!key) {
throw new Error('No signing key given')
}
if (!data) {
throw new Error('Given input data was undefined')
}
if (!Buffer.isBuffer(data)) {
data = Buffer.from(data)
}
return Buffer.from(await key.sign(data)).toString('hex')
}
getPublic (keys, options = {}) {
const formats = ['hex', 'buffer']
const decompress = typeof options.decompress === 'undefined' ? true : options.decompress
@@ -206,11 +191,23 @@ export default class KeyStore {
return format === 'buffer' ? pubKey : pubKey.toString('hex')
}
async verify (signature, publicKey, data, v = 'v1') {
return KeyStore.verify(signature, publicKey, data, v)
static async sign (key, data) {
if (!key) {
throw new Error('No signing key given')
}
if (!data) {
throw new Error('Given input data was undefined')
}
if (!Buffer.isBuffer(data)) {
data = Buffer.from(data)
}
return Buffer.from(await key.sign(data)).toString('hex')
}
static async verify (signature, publicKey, data, v = 'v1') {
static async verify (signature, publicKey, data) {
// const cached = verifiedCache.get(signature)
const cached = null
let res = false
@@ -221,16 +218,16 @@ export default class KeyStore {
// verifiedCache.set(signature, { publicKey, data })
// }
} else {
const compare = (cached, data, v) => {
let match
if (v === 'v0') {
match = Buffer.compare(Buffer.alloc(30, cached), Buffer.alloc(30, data)) === 0
} else {
match = Buffer.isBuffer(data) ? Buffer.compare(cached, data) === 0 : cached === data
}
const compare = (cached, data) => {
// let match
// if (v === 'v0') {
// match = Buffer.compare(Buffer.alloc(30, cached), Buffer.alloc(30, data)) === 0
// } else {
const match = Buffer.isBuffer(data) ? Buffer.compare(cached, data) === 0 : cached === data
// }
return match
}
res = cached.publicKey === publicKey && compare(cached.data, data, v)
res = cached.publicKey === publicKey && compare(cached.data, data)
}
return res
}

2
src/oplog/entry.js
View File

@@ -46,7 +46,7 @@ const create = async (identity, id, payload, clock = null, next = [], refs = [])
}
const { bytes } = await Block.encode({ value: entry, codec, hasher })
const signature = await identity.provider.sign(identity, bytes)
const signature = await identity.sign(identity, bytes)
entry.key = identity.publicKey
entry.identity = identity.hash

9
src/oplog/log.js
View File

@@ -29,7 +29,7 @@ const DefaultStorage = MemoryStorage
const DefaultAccessController = async () => {
// An AccessController may do any async initialization stuff here...
return {
canAppend: async (entry, identityProvider) => true
canAppend: async (entry) => true
}
}
@@ -153,7 +153,7 @@ const Log = async (identity, { logId, logHeads, access, entryStorage, headsStora
refs
)
// Authorize the entry
const canAppend = await access.canAppend(entry, identity.provider)
const canAppend = await access.canAppend(entry)
if (!canAppend) {
throw new Error(`Could not append entry:\nKey "${identity.hash}" is not allowed to write to the log`)
}
@@ -208,18 +208,17 @@ const Log = async (identity, { logId, logHeads, access, entryStorage, headsStora
if (isAlreadyInTheLog) {
return false
}
const identityProvider = identity.provider
// Check that the Entry belongs to this Log
if (entry.id !== id) {
throw new Error(`Entry's id (${entry.id}) doesn't match the log's id (${id}).`)
}
// Verify if entry is allowed to be added to the log
const canAppend = await access.canAppend(entry, identityProvider)
const canAppend = await access.canAppend(entry)
if (!canAppend) {
throw new Error(`Could not append entry:\nKey "${entry.identity}" is not allowed to write to the log`)
}
// Verify signature for the entry
const isValid = await Entry.verify(identityProvider, entry)
const isValid = await Entry.verify(identity, entry)
if (!isValid) {
throw new Error(`Could not validate signature for entry "${entry.hash}"`)
}

11
test/document-store.spec.js
View File

@@ -1,7 +1,6 @@
import { deepStrictEqual, strictEqual } from 'assert'
import rimraf from 'rimraf'
import { Log, Entry } from '../src/oplog/index.js'
import { IdentityProvider } from '../src/identities/index.js'
import KeyStore from '../src/key-store.js'
import { DocumentStore, Database } from '../src/db/index.js'
import { IPFSBlockStorage, LevelStorage } from '../src/storage/index.js'
@@ -13,7 +12,6 @@ import connectPeers from './utils/connect-nodes.js'
import { identityKeys, signingKeys, createTestIdentities, cleanUpTestIdentities } from './fixtures/orbit-db-identity-keys.js'
const { sync: rmrf } = rimraf
const { createIdentity } = IdentityProvider
const OpLog = { Log, Entry, IPFSBlockStorage, LevelStorage }
@@ -25,6 +23,7 @@ Object.keys(testAPIs).forEach((IPFS) => {
let ipfs1, ipfs2
let keystore, signingKeyStore
// let peerId1, peerId2
let identities1, identities2
let testIdentity1, testIdentity2
let db1, db2
@@ -43,7 +42,9 @@ Object.keys(testAPIs).forEach((IPFS) => {
// peerId1 = await getIpfsPeerId(ipfs1)
// peerId2 = await getIpfsPeerId(ipfs2)
const testIdentities = await createTestIdentities(ipfs1, ipfs2)
const [identities, testIdentities] = await createTestIdentities(ipfs1, ipfs2)
identities1 = identities[0]
identities2 = identities[1]
testIdentity1 = testIdentities[0]
testIdentity2 = testIdentities[1]
@@ -54,7 +55,7 @@ Object.keys(testAPIs).forEach((IPFS) => {
beforeEach(async () => {
const accessController = {
canAppend: async (entry) => {
const identity = await testIdentity1.provider.get(entry.identity)
const identity = await identities1.getIdentity(entry.identity)
return identity.id === testIdentity1.id
}
}
@@ -74,7 +75,7 @@ Object.keys(testAPIs).forEach((IPFS) => {
})
after(async () => {
await cleanUpTestIdentities([testIdentity1, testIdentity2])
await cleanUpTestIdentities([identities1, identities1])
if (ipfsd1) {
await stopIpfs(ipfsd1)

33
test/event-store.spec.js
View File

@@ -1,7 +1,7 @@
import { deepStrictEqual, strictEqual } from 'assert'
import rimraf from 'rimraf'
import { Log, Entry } from '../src/oplog/index.js'
import { IdentityProvider } from '../src/identities/index.js'
import { Identities } from '../src/identities/index.js'
import KeyStore from '../src/key-store.js'
import { EventStore, Database } from '../src/db/index.js'
import { IPFSBlockStorage, LevelStorage } from '../src/storage/index.js'
@@ -13,7 +13,7 @@ import waitFor from './utils/wait-for.js'
import { identityKeys, signingKeys, createTestIdentities, cleanUpTestIdentities } from './fixtures/orbit-db-identity-keys.js'
const { sync: rmrf } = rimraf
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
const OpLog = { Log, Entry, IPFSBlockStorage, LevelStorage }
@@ -25,11 +25,20 @@ Object.keys(testAPIs).forEach((IPFS) => {
let ipfs1, ipfs2
let keystore, signingKeyStore
let peerId1, peerId2
let identities1, identities2
let testIdentity1, testIdentity2
let kv1, kv2
const databaseId = 'events-AAA'
const accessController = {
canAppend: async (entry) => {
const identity = await identities1.getIdentity(entry.identity)
return identity.id === testIdentity1.id
}
}
before(async () => {
// Start two IPFS instances
ipfsd1 = await startIpfs(IPFS, config.daemon1)
@@ -43,7 +52,9 @@ Object.keys(testAPIs).forEach((IPFS) => {
peerId1 = await getIpfsPeerId(ipfs1)
peerId2 = await getIpfsPeerId(ipfs2)
const testIdentities = await createTestIdentities(ipfs1, ipfs2)
const [identities, testIdentities] = await createTestIdentities(ipfs1, ipfs2)
identities1 = identities[0]
identities2 = identities[1]
testIdentity1 = testIdentities[0]
testIdentity2 = testIdentities[1]
@@ -63,7 +74,7 @@ Object.keys(testAPIs).forEach((IPFS) => {
})
after(async () => {
await cleanUpTestIdentities([testIdentity1, testIdentity2])
await cleanUpTestIdentities([identities1, identities2])
if (ipfsd1) {
await stopIpfs(ipfsd1)
@@ -93,13 +104,6 @@ Object.keys(testAPIs).forEach((IPFS) => {
let updateCount = 0
// let syncCount = 0
const accessController = {
canAppend: async (entry) => {
const identity = await testIdentity1.provider.get(entry.identity)
return identity.id === testIdentity1.id
}
}
const onUpdate = (entry) => {
// console.log(".", updateCount, entry.payload)
++updateCount
@@ -204,13 +208,6 @@ Object.keys(testAPIs).forEach((IPFS) => {
let updateCount = 0
// let syncCount = 0
const accessController = {
canAppend: async (entry) => {
const identity = await testIdentity1.provider.get(entry.identity)
return identity.id === testIdentity1.id
}
}
const onUpdate = (entry) => {
++updateCount
}

33
test/feed.spec.js
View File

@@ -1,7 +1,7 @@
import { deepStrictEqual, strictEqual } from 'assert'
import rimraf from 'rimraf'
import { Log, Entry } from '../src/oplog/index.js'
import { IdentityProvider } from '../src/identities/index.js'
import { Identities } from '../src/identities/index.js'
import KeyStore from '../src/key-store.js'
import { Feed, Database } from '../src/db/index.js'
import { IPFSBlockStorage, LevelStorage } from '../src/storage/index.js'
@@ -13,7 +13,7 @@ import waitFor from './utils/wait-for.js'
import { identityKeys, signingKeys, createTestIdentities, cleanUpTestIdentities } from './fixtures/orbit-db-identity-keys.js'
const { sync: rmrf } = rimraf
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
const OpLog = { Log, Entry, IPFSBlockStorage, LevelStorage }
Object.keys(testAPIs).forEach((IPFS) => {
@@ -24,11 +24,20 @@ Object.keys(testAPIs).forEach((IPFS) => {
let ipfs1, ipfs2
let keystore, signingKeyStore
let peerId1, peerId2
let identities1, identities2
let testIdentity1, testIdentity2
let kv1, kv2
const databaseId = 'feed-AAA'
const accessController = {
canAppend: async (entry) => {
const identity = await identities1.getIdentity(entry.identity)
return identity.id === testIdentity1.id
}
}
before(async () => {
// Start two IPFS instances
ipfsd1 = await startIpfs(IPFS, config.daemon1)
@@ -42,7 +51,9 @@ Object.keys(testAPIs).forEach((IPFS) => {
peerId1 = await getIpfsPeerId(ipfs1)
peerId2 = await getIpfsPeerId(ipfs2)
const testIdentities = await createTestIdentities(ipfs1, ipfs2)
const [identities, testIdentities] = await createTestIdentities(ipfs1, ipfs2)
identities1 = identities[0]
identities2 = identities[1]
testIdentity1 = testIdentities[0]
testIdentity2 = testIdentities[1]
@@ -62,7 +73,7 @@ Object.keys(testAPIs).forEach((IPFS) => {
})
after(async () => {
await cleanUpTestIdentities([testIdentity1, testIdentity2])
await cleanUpTestIdentities([identities1, identities2])
if (ipfsd1) {
await stopIpfs(ipfsd1)
@@ -92,13 +103,6 @@ Object.keys(testAPIs).forEach((IPFS) => {
let updateCount = 0
// let syncCount = 0
const accessController = {
canAppend: async (entry) => {
const identity = await testIdentity1.provider.get(entry.identity)
return identity.id === testIdentity1.id
}
}
const onUpdate = (entry) => {
++updateCount
}
@@ -202,13 +206,6 @@ Object.keys(testAPIs).forEach((IPFS) => {
let updateCount = 0
// let syncCount = 0
const accessController = {
canAppend: async (entry) => {
const identity = await testIdentity1.provider.get(entry.identity)
return identity.id === testIdentity1.id
}
}
const onUpdate = (entry) => {
++updateCount
}

38
test/fixtures/orbit-db-identity-keys.js vendored
View File

@@ -1,8 +1,7 @@
import KeyStore from '../../src/key-store.js'
import { IdentityProvider } from '../../src/identities/index.js'
import { Identities } from '../../src/identities/index.js'
import rimraf from 'rimraf'
const { createIdentity } = IdentityProvider
const { sync: rmrf } = rimraf
import userA from "./keys/identity-keys/03e0480538c2a39951d054e17ff31fde487cb1031d0044a037b53ad2e028a3e77c.json" assert { type: "json" }
@@ -46,39 +45,18 @@ const createTestIdentities = async (ipfs1, ipfs2) => {
}
// Create an identity for each peers
const testIdentity1 = await createIdentity({ id: 'userA', keystore, signingKeyStore, ipfs: ipfs1 })
const testIdentity2 = await createIdentity({ id: 'userB', keystore, signingKeyStore, ipfs: ipfs2 })
const identities1 = await Identities({ keystore, signingKeyStore, ipfs: ipfs1 })
const identities2 = await Identities({ keystore, signingKeyStore, ipfs: ipfs2 })
const testIdentity1 = await identities1.createIdentity({ id: 'userA' })
const testIdentity2 = await identities2.createIdentity({ id: 'userB' })
return [testIdentity1, testIdentity2]
}
const createTestIdentitiesInMemory = async (ipfs1 = null, ipfs2 = null) => {
rmrf('./keys_1')
rmrf('./keys_2')
const keystore = new KeyStore('./keys_1')
// await keystore.open()
for (const [key, value] of Object.entries(identityKeys)) {
await keystore.addKey(key, value)
}
const signingKeyStore = new KeyStore('./keys_2')
// await signingKeyStore.open()
for (const [key, value] of Object.entries(signingKeys)) {
await signingKeyStore.addKey(key, value)
}
// Create an identity for each peers
const testIdentity1 = await createIdentity({ id: 'userA', keystore, signingKeyStore, ipfs: ipfs1 })
const testIdentity2 = await createIdentity({ id: 'userB', keystore, signingKeyStore, ipfs: ipfs2 })
return [testIdentity1, testIdentity2]
return [[identities1, identities2], [testIdentity1, testIdentity2]]
}
const cleanUpTestIdentities = async (identities) => {
for (let identity of identities) {
await identity.provider._keystore.close()
await identity.provider._signingKeyStore.close()
await identity.keystore.close()
await identity.signingKeyStore.close()
}
}

43
test/identities/did-identity-provider.spec.js
View File

@@ -1,12 +1,12 @@
import assert from 'assert'
import path from 'path'
import rmrf from 'rimraf'
import { KeyStore, IdentityProvider } from '../../src/index.js'
import { KeyStore, Identities } from '../../src/index.js'
import { Identity } from '../../src/identities/index.js'
import { Ed25519Provider } from 'key-did-provider-ed25519'
import KeyDidResolver from 'key-did-resolver'
import DIDIdentityProvider from '../../src/identities/providers/did.js'
const keypath = path.resolve('./test/identies/fixtures/keys')
const keypath = path.resolve('./test/identities/fixtures/keys')
let keystore
const seed = new Uint8Array([157, 94, 116, 198, 19, 248, 93, 239, 173, 82, 245, 222, 199, 7, 183, 177, 123, 238, 83, 240, 143, 188, 87, 191, 33, 95, 58, 136, 46, 218, 219, 245])
@@ -14,15 +14,20 @@ const didStr = 'did:key:z6MkpnTJwrrVuphNh1uKb5DB7eRxvqniVaSDUHU6jtGVmn3r'
const type = DIDIdentityProvider.type
describe('DID Identity Provider', function () {
let identities
before(async () => {
DIDIdentityProvider.setDIDResolver(KeyDidResolver.getResolver())
IdentityProvider.addIdentityProvider(DIDIdentityProvider)
keystore = new KeyStore(keypath)
await keystore.open()
identities = await Identities({ keystore })
DIDIdentityProvider.setDIDResolver(KeyDidResolver.getResolver())
identities.addIdentityProvider(DIDIdentityProvider)
})
after(async () => {
await keystore.close()
if (keystore) {
await keystore.close()
}
})
describe('create an DID identity', () => {
@@ -30,7 +35,7 @@ describe('DID Identity Provider', function () {
before(async () => {
const didProvider = new Ed25519Provider(seed)
identity = await IdentityProvider.createIdentity({ type, keystore, didProvider })
identity = await identities.createIdentity({ type, keystore, didProvider })
})
it('has the correct id', async () => {
@@ -50,7 +55,7 @@ describe('DID Identity Provider', function () {
it('has a signature for the id', async () => {
const signingKey = await keystore.getKey(didStr)
const idSignature = await keystore.sign(signingKey, didStr)
const idSignature = await KeyStore.sign(signingKey, didStr)
const verifies = await KeyStore.verify(idSignature, identity.publicKey, didStr)
assert.strictEqual(verifies, true)
assert.strictEqual(identity.signatures.id, idSignature)
@@ -58,7 +63,7 @@ describe('DID Identity Provider', function () {
it('has a signature for the publicKey', async () => {
const signingKey = await keystore.getKey(didStr)
const idSignature = await keystore.sign(signingKey, didStr)
const idSignature = await KeyStore.sign(signingKey, didStr)
assert.notStrictEqual(idSignature, undefined)
})
})
@@ -68,17 +73,17 @@ describe('DID Identity Provider', function () {
before(async () => {
const didProvider = new Ed25519Provider(seed)
identity = await IdentityProvider.createIdentity({ type, keystore, didProvider })
identity = await identities.createIdentity({ type, keystore, didProvider })
})
it('DID identity verifies', async () => {
const verified = await IdentityProvider.verifyIdentity(identity)
const verified = await identities.verifyIdentity(identity)
assert.strictEqual(verified, true)
})
it('DID identity with incorrect id does not verify', async () => {
const identity2 = new Identity('NotAnId', identity.publicKey, identity.signatures.id, identity.signatures.publicKey, identity.type, identity.provider)
const verified = await IdentityProvider.verifyIdentity(identity2)
const verified = await identities.verifyIdentity(identity2)
assert.strictEqual(verified, false)
})
})
@@ -89,13 +94,13 @@ describe('DID Identity Provider', function () {
before(async () => {
const didProvider = new Ed25519Provider(seed)
identity = await IdentityProvider.createIdentity({ type, keystore, didProvider })
identity = await identities.createIdentity({ type, keystore, didProvider })
})
it('sign data', async () => {
const signingKey = await keystore.getKey(identity.id)
const expectedSignature = await keystore.sign(signingKey, data)
const signature = await identity.provider.sign(identity, data, keystore)
const expectedSignature = await KeyStore.sign(signingKey, data)
const signature = await identities.sign(identity, data, keystore)
assert.strictEqual(signature, expectedSignature)
})
@@ -105,7 +110,7 @@ describe('DID Identity Provider', function () {
let signature
let err
try {
signature = await identity.provider.sign(modifiedIdentity, data, keystore)
signature = await identities.sign(modifiedIdentity, data, keystore)
} catch (e) {
err = e.toString()
}
@@ -120,17 +125,17 @@ describe('DID Identity Provider', function () {
before(async () => {
const didProvider = new Ed25519Provider(seed)
identity = await IdentityProvider.createIdentity({ type, keystore, didProvider })
signature = await identity.provider.sign(identity, data, keystore)
identity = await identities.createIdentity({ type, keystore, didProvider })
signature = await identities.sign(identity, data, keystore)
})
it('verifies that the signature is valid', async () => {
const verified = await identity.provider.verify(signature, identity.publicKey, data)
const verified = await identities.verify(signature, identity.publicKey, data)
assert.strictEqual(verified, true)
})
it('doesn\'t verify invalid signature', async () => {
const verified = await identity.provider.verify('invalid', identity.publicKey, data)
const verified = await identities.verify('invalid', identity.publicKey, data)
assert.strictEqual(verified, false)
})
})

39
test/identities/ethereum-identity-provider.spec.js
View File

@@ -1,7 +1,7 @@
import assert from 'assert'
import path from 'path'
import rmrf from 'rimraf'
import { KeyStore, IdentityProvider } from '../../src/index.js'
import { KeyStore, Identities } from '../../src/index.js'
import { Identity } from '../../src/identities/index.js'
import EthIdentityProvider from '../../src/identities/providers/ethereum.js'
@@ -10,14 +10,19 @@ let keystore
const type = EthIdentityProvider.type
describe('Ethereum Identity Provider', function () {
let identities
before(async () => {
IdentityProvider.addIdentityProvider(EthIdentityProvider)
keystore = new KeyStore(keypath)
await keystore.open()
identities = await Identities({ keystore })
identities.addIdentityProvider(EthIdentityProvider)
})
after(async () => {
await keystore.close()
if (keystore) {
await keystore.close()
}
})
describe('create an ethereum identity', () => {
@@ -27,7 +32,7 @@ describe('Ethereum Identity Provider', function () {
before(async () => {
const ethIdentityProvider = new EthIdentityProvider()
wallet = await ethIdentityProvider._createWallet()
identity = await IdentityProvider.createIdentity({ type, keystore, wallet })
identity = await identities.createIdentity({ type, keystore, wallet })
})
it('has the correct id', async () => {
@@ -47,7 +52,7 @@ describe('Ethereum Identity Provider', function () {
it('has a signature for the id', async () => {
const signingKey = await keystore.getKey(wallet.address)
const idSignature = await keystore.sign(signingKey, wallet.address)
const idSignature = await KeyStore.sign(signingKey, wallet.address)
const verifies = await KeyStore.verify(idSignature, Buffer.from(signingKey.public.marshal()).toString('hex'), wallet.address)
assert.strictEqual(verifies, true)
assert.strictEqual(identity.signatures.id, idSignature)
@@ -55,7 +60,7 @@ describe('Ethereum Identity Provider', function () {
it('has a signature for the publicKey', async () => {
const signingKey = await keystore.getKey(wallet.address)
const idSignature = await keystore.sign(signingKey, wallet.address)
const idSignature = await KeyStore.sign(signingKey, wallet.address)
const publicKeyAndIdSignature = await wallet.signMessage(identity.publicKey + idSignature)
assert.strictEqual(identity.signatures.publicKey, publicKeyAndIdSignature)
})
@@ -65,17 +70,17 @@ describe('Ethereum Identity Provider', function () {
let identity
before(async () => {
identity = await IdentityProvider.createIdentity({ keystore, type })
identity = await identities.createIdentity({ keystore, type })
})
it('ethereum identity verifies', async () => {
const verified = await IdentityProvider.verifyIdentity(identity)
const verified = await identities.verifyIdentity(identity)
assert.strictEqual(verified, true)
})
it('ethereum identity with incorrect id does not verify', async () => {
const identity2 = new Identity('NotAnId', identity.publicKey, identity.signatures.id, identity.signatures.publicKey, identity.type, identity.provider)
const verified = await IdentityProvider.verifyIdentity(identity2)
const verified = await identities.verifyIdentity(identity2)
assert.strictEqual(verified, false)
})
})
@@ -85,13 +90,13 @@ describe('Ethereum Identity Provider', function () {
const data = 'hello friend'
before(async () => {
identity = await IdentityProvider.createIdentity({ keystore, type })
identity = await identities.createIdentity({ keystore, type })
})
it('sign data', async () => {
const signingKey = await keystore.getKey(identity.id)
const expectedSignature = await keystore.sign(signingKey, data)
const signature = await identity.provider.sign(identity, data, keystore)
const expectedSignature = await KeyStore.sign(signingKey, data)
const signature = await identities.sign(identity, data, keystore)
assert.strictEqual(signature, expectedSignature)
})
@@ -101,7 +106,7 @@ describe('Ethereum Identity Provider', function () {
let signature
let err
try {
signature = await identity.provider.sign(modifiedIdentity, data, keystore)
signature = await identities.sign(modifiedIdentity, data, keystore)
} catch (e) {
err = e.toString()
}
@@ -115,17 +120,17 @@ describe('Ethereum Identity Provider', function () {
let signature
before(async () => {
identity = await IdentityProvider.createIdentity({ type, keystore })
signature = await identity.provider.sign(identity, data, keystore)
identity = await identities.createIdentity({ type, keystore })
signature = await identities.sign(identity, data, keystore)
})
it('verifies that the signature is valid', async () => {
const verified = await identity.provider.verify(signature, identity.publicKey, data)
const verified = await identities.verify(signature, identity.publicKey, data)
assert.strictEqual(verified, true)
})
it('doesn\'t verify invalid signature', async () => {
const verified = await identity.provider.verify('invalid', identity.publicKey, data)
const verified = await identities.verify('invalid', identity.publicKey, data)
assert.strictEqual(verified, false)
})
})

214
test/identities/identity-provider.spec.js
View File

@@ -1,7 +1,7 @@
import assert from 'assert'
import path from 'path'
import rmrf from 'rimraf'
import { KeyStore, IdentityProvider } from '../../src/index.js'
import { KeyStore, Identities } from '../../src/index.js'
import { Identity } from '../../src/identities/index.js'
import fs from 'fs-extra'
const fixturesPath = path.resolve('./test/identities/fixtures/keys')
@@ -21,43 +21,66 @@ describe('Identity Provider', function () {
rmrf.sync(identityKeysPath)
})
describe('Creating IdentityProvider', () => {
describe('Creating Identities', () => {
const id = 'A'
let identities
let identity
afterEach(async () => {
if (identities) {
await identities.keystore.close()
}
if (identities) {
await identities.signingKeyStore.close()
}
})
it('identityKeysPath only - has the correct id', async () => {
identity = await IdentityProvider.createIdentity({ id, identityKeysPath })
const key = await identity.provider.keystore.getKey(id)
identities = await Identities({ identityKeysPath })
identity = await identities.createIdentity({ id })
const key = await identities.keystore.getKey(id)
const externalId = Buffer.from(key.public.marshal()).toString('hex')
assert.strictEqual(identity.id, externalId)
})
it('identityKeysPath and signingKeysPath - has a different id', async () => {
identity = await IdentityProvider.createIdentity({ id, identityKeysPath, signingKeysPath })
const key = await identity.provider.keystore.getKey(id)
identities = await Identities({ identityKeysPath, signingKeysPath })
identity = await identities.createIdentity({ id })
const key = await identities.keystore.getKey(id)
const externalId = Buffer.from(key.public.marshal()).toString('hex')
assert.notStrictEqual(identity.id, externalId)
})
afterEach(async () => {
await identity.provider.keystore.close()
await identity.provider.signingKeyStore.close()
})
})
describe('Passing in custom keystore', async () => {
const id = 'B'; let identity; let keystore; let signingKeyStore
const id = 'B'
let identity
let identities
let keystore
let signingKeyStore
before(async () => {
keystore = new KeyStore(identityKeysPath)
await keystore.open()
signingKeyStore = new KeyStore(signingKeysPath)
await signingKeyStore.open()
identities = await Identities({ keystore })
})
after(async () => {
if (keystore) {
await keystore.close()
}
if (signingKeyStore) {
await signingKeyStore.close()
}
})
it('has the correct id', async () => {
identity = await IdentityProvider.createIdentity({ id, keystore })
keystore = identity.provider._keystore
identity = await identities.createIdentity({ id })
keystore = identities.keystore
const key = await keystore.getKey(id)
const externalId = Buffer.from(key.public.marshal()).toString('hex')
assert.strictEqual(identity.id, externalId)
@@ -81,7 +104,7 @@ describe('Identity Provider', function () {
const key = await keystore.getKey(id)
const externalId = Buffer.from(key.public.marshal()).toString('hex')
const signingKey = await keystore.getKey(externalId)
const idSignature = await keystore.sign(signingKey, externalId)
const idSignature = await KeyStore.sign(signingKey, externalId)
const publicKey = Buffer.from(signingKey.public.marshal()).toString('hex')
const verifies = await KeyStore.verify(idSignature, publicKey, externalId)
assert.strictEqual(verifies, true)
@@ -92,41 +115,42 @@ describe('Identity Provider', function () {
const key = await keystore.getKey(id)
const externalId = Buffer.from(key.public.marshal()).toString('hex')
const signingKey = await keystore.getKey(externalId)
const idSignature = await keystore.sign(signingKey, externalId)
const idSignature = await KeyStore.sign(signingKey, externalId)
const externalKey = await keystore.getKey(id)
const publicKeyAndIdSignature = await keystore.sign(externalKey, identity.publicKey + idSignature)
const publicKeyAndIdSignature = await KeyStore.sign(externalKey, identity.publicKey + idSignature)
assert.strictEqual(identity.signatures.publicKey, publicKeyAndIdSignature)
})
after(async () => {
await keystore.close()
await signingKeyStore.close()
})
})
describe('create an identity with saved keys', () => {
let keystore, signingKeyStore
let savedKeysKeyStore, identity
const id = 'QmPhnEjVkYE1Ym7F5MkRUfkD6NtuSptE7ugu1Ggr149W2X'
const expectedPublicKey = '040d78ff62afb656ac62db1aae3b1536a614991e28bb4d721498898b7d4194339640cd18c37b259e2c77738de0d6f9a5d52e0b936611de6b6ba78891a8b2a38317'
const expectedIdSignature = '30450221009de7b91952d73f577e85962aa6301350865212e3956862f80f4ebb626ffc126b022027d57415fb145b7e06cf06320fbfa63ea98a958b065726fe86eaab809a6bf607'
const expectedPkIdSignature = '304402202806e7c2406ca1f35961d38adc3997c179e142d54e1ca838ace373fae27124fd02200d6ca3aea6e1341bf5e4e0b84b559bbeefecfade34115de266a69d04d924905e'
before(async () => {
keystore = new KeyStore(identityKeysPath)
await keystore.open()
signingKeyStore = new KeyStore(signingKeysPath)
await signingKeyStore.open()
let identities
let identity
let savedKeysKeyStore
before(async () => {
await fs.copy(fixturesPath, savedKeysPath)
savedKeysKeyStore = new KeyStore(savedKeysPath)
await savedKeysKeyStore.open()
identity = await IdentityProvider.createIdentity({ id, keystore: savedKeysKeyStore })
identities = await Identities({ keystore: savedKeysKeyStore })
identity = await identities.createIdentity({ id })
})
after(async () => {
if (identities) {
await identities.keystore.close()
}
if (identities) {
await identities.signingKeyStore.close()
}
rmrf.sync(savedKeysPath)
})
@@ -154,21 +178,20 @@ describe('Identity Provider', function () {
it('has the correct signatures', async () => {
const internalSigningKey = await savedKeysKeyStore.getKey(identity.id)
const externalSigningKey = await savedKeysKeyStore.getKey(id)
const idSignature = await savedKeysKeyStore.sign(internalSigningKey, identity.id)
const pubKeyIdSignature = await savedKeysKeyStore.sign(externalSigningKey, identity.publicKey + idSignature)
const idSignature = await KeyStore.sign(internalSigningKey, identity.id)
const pubKeyIdSignature = await KeyStore.sign(externalSigningKey, identity.publicKey + idSignature)
const expectedSignature = { id: idSignature, publicKey: pubKeyIdSignature }
assert.deepStrictEqual(identity.signatures, expectedSignature)
})
after(async () => {
await keystore.close()
await signingKeyStore.close()
})
})
describe('verify identity\'s signature', () => {
const id = 'QmFoo'
let identity, keystore, signingKeyStore
let identities
let identity
let keystore
let signingKeyStore
before(async () => {
keystore = new KeyStore(identityKeysPath)
@@ -177,14 +200,25 @@ describe('Identity Provider', function () {
await signingKeyStore.open()
})
after(async () => {
if (keystore) {
await keystore.close()
}
if (signingKeyStore) {
await signingKeyStore.close()
}
})
it('identity pkSignature verifies', async () => {
identity = await IdentityProvider.createIdentity({ id, type, keystore, signingKeyStore })
identities = await Identities({ keystore, signingKeyStore })
identity = await identities.createIdentity({ id, type })
const verified = await KeyStore.verify(identity.signatures.id, identity.publicKey, identity.id)
assert.strictEqual(verified, true)
})
it('identity signature verifies', async () => {
identity = await IdentityProvider.createIdentity({ id, type, keystore, signingKeyStore })
identities = await Identities({ keystore, signingKeyStore })
identity = await identities.createIdentity({ id, type })
const verified = await KeyStore.verify(identity.signatures.publicKey, identity.id, identity.publicKey + identity.signatures.id)
assert.strictEqual(verified, true)
})
@@ -200,85 +234,102 @@ describe('Identity Provider', function () {
static get type () { return 'fake' }
}
IdentityProvider.addIdentityProvider(IP)
identity = await IdentityProvider.createIdentity({ type: IP.type, keystore, signingKeyStore })
const verified = await IdentityProvider.verifyIdentity(identity)
identities.addIdentityProvider(IP)
identity = await identities.createIdentity({ type: IP.type })
const verified = await identities.verifyIdentity(identity)
assert.strictEqual(verified, false)
})
after(async () => {
await keystore.close()
await signingKeyStore.close()
})
})
describe('verify identity', () => {
const id = 'QmFoo'
let identity, keystore, signingKeyStore
let identities
let identity
let keystore
let signingKeyStore
before(async () => {
keystore = new KeyStore(identityKeysPath)
await keystore.open()
signingKeyStore = new KeyStore(signingKeysPath)
await signingKeyStore.open()
})
it('identity verifies', async () => {
identity = await IdentityProvider.createIdentity({ id, type, keystore, signingKeyStore })
const verified = await identity.provider.verifyIdentity(identity)
assert.strictEqual(verified, true)
identities = await Identities({ keystore, signingKeyStore })
})
after(async () => {
await keystore.close()
await signingKeyStore.close()
if (keystore) {
await keystore.close()
}
if (signingKeyStore) {
await signingKeyStore.close()
}
})
it('identity verifies', async () => {
identity = await identities.createIdentity({ id, type })
const verified = await identities.verifyIdentity(identity)
assert.strictEqual(verified, true)
})
})
describe('sign data with an identity', () => {
const id = '0x01234567890abcdefghijklmnopqrstuvwxyz'
const data = 'hello friend'
let identity, keystore, signingKeyStore
let identities
let identity
let keystore
let signingKeyStore
before(async () => {
keystore = new KeyStore(identityKeysPath)
await keystore.open()
signingKeyStore = new KeyStore(signingKeysPath)
await signingKeyStore.open()
identity = await IdentityProvider.createIdentity({ id, keystore, signingKeyStore })
identities = await Identities({ keystore, signingKeyStore })
identity = await identities.createIdentity({ id })
})
after(async () => {
if (keystore) {
await keystore.close()
}
if (signingKeyStore) {
await signingKeyStore.close()
}
})
it('sign data', async () => {
const signingKey = await keystore.getKey(identity.id)
const expectedSignature = await keystore.sign(signingKey, data)
const signature = await identity.provider.sign(identity, data, keystore)
const expectedSignature = await KeyStore.sign(signingKey, data)
const signature = await identities.sign(identity, data, keystore)
assert.strictEqual(signature, expectedSignature)
})
it('throws an error if private key is not found from keystore', async () => {
// Remove the key from the keystore (we're using a mock storage in these tests)
const modifiedIdentity = new Identity('this id does not exist', identity.publicKey, '<sig>', identity.signatures, identity.type, identity.provider)
const modifiedIdentity = new Identity('this id does not exist', identity.publicKey, '<sig>', identity.signatures, identity.type)
let signature
let err
try {
signature = await identity.provider.sign(modifiedIdentity, data, keystore)
signature = await identities.sign(modifiedIdentity, data, keystore)
} catch (e) {
err = e.toString()
}
assert.strictEqual(signature, undefined)
assert.strictEqual(err, 'Error: Private signing key not found from KeyStore')
})
after(async () => {
await keystore.close()
await signingKeyStore.close()
})
})
describe('verify data signed by an identity', () => {
const id = '03602a3da3eb35f1148e8028f141ec415ef7f6d4103443edbfec2a0711d716f53f'
const data = 'hello friend'
let identity, keystore, signingKeyStore
let identities
let identity
let keystore
let signingKeyStore
let signature
before(async () => {
@@ -288,24 +339,29 @@ describe('Identity Provider', function () {
await signingKeyStore.open()
})
after(async () => {
if (keystore) {
await keystore.close()
}
if (signingKeyStore) {
await signingKeyStore.close()
}
})
beforeEach(async () => {
identity = await IdentityProvider.createIdentity({ id, type, keystore, signingKeyStore })
signature = await identity.provider.sign(identity, data, keystore)
identities = await Identities({ keystore, signingKeyStore })
identity = await identities.createIdentity({ id, type })
signature = await identities.sign(identity, data, keystore)
})
it('verifies that the signature is valid', async () => {
const verified = await identity.provider.verify(signature, identity.publicKey, data)
const verified = await identities.verify(signature, identity.publicKey, data)
assert.strictEqual(verified, true)
})
it('doesn\'t verify invalid signature', async () => {
const verified = await identity.provider.verify('invalid', identity.publicKey, data)
const verified = await identities.verify('invalid', identity.publicKey, data)
assert.strictEqual(verified, false)
})
after(async () => {
await keystore.close()
await signingKeyStore.close()
})
})
})

24
test/identities/identity.spec.js
View File

@@ -31,9 +31,9 @@ describe('Identity', function () {
assert.strictEqual(identity.signatures.publicKey, publicKeyAndIdSignature)
})
it('has the correct provider', async () => {
assert.deepStrictEqual(identity.provider, provider)
})
// it('has the correct provider', async () => {
// assert.deepStrictEqual(identity.provider, provider)
// })
it('converts identity to a JSON object', async () => {
const expected = {
@@ -86,15 +86,15 @@ describe('Identity', function () {
assert.strictEqual(err, 'Error: Signature of (publicKey + idSignature) is required')
})
it('throws and error if identity provider was not given in constructor', async () => {
let err
try {
identity = new Identity('abc', publicKey, idSignature, publicKeyAndIdSignature, type)
} catch (e) {
err = e.toString()
}
assert.strictEqual(err, 'Error: Identity provider is required')
})
// it('throws and error if identity provider was not given in constructor', async () => {
// let err
// try {
// identity = new Identity('abc', publicKey, idSignature, publicKeyAndIdSignature, type)
// } catch (e) {
// err = e.toString()
// }
// assert.strictEqual(err, 'Error: Identity provider is required')
// })
it('throws and error if identity type was not given in constructor', async () => {
let err

32
test/keyvalue.spec.js
View File

@@ -1,7 +1,7 @@
import { deepStrictEqual, strictEqual } from 'assert'
import rimraf from 'rimraf'
import { Log, Entry } from '../src/oplog/index.js'
import { IdentityProvider } from '../src/identities/index.js'
import { Identities } from '../src/identities/index.js'
import KeyStore from '../src/key-store.js'
import { KeyValue, KeyValuePersisted, Database } from '../src/db/index.js'
import { IPFSBlockStorage, LevelStorage } from '../src/storage/index.js'
@@ -13,7 +13,7 @@ import waitFor from './utils/wait-for.js'
import { identityKeys, signingKeys, createTestIdentities, cleanUpTestIdentities } from './fixtures/orbit-db-identity-keys.js'
const { sync: rmrf } = rimraf
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
const OpLog = { Log, Entry, IPFSBlockStorage, LevelStorage }
@@ -25,11 +25,19 @@ Object.keys(testAPIs).forEach((IPFS) => {
let ipfs1, ipfs2
let keystore, signingKeyStore
let peerId1, peerId2
let identities1, identities2
let testIdentity1, testIdentity2
let kv1, kv2
const databaseId = 'kv-AAA'
const accessController = {
canAppend: async (entry) => {
const identity = await identities1.getIdentity(entry.identity)
return identity.id === testIdentity1.id
}
}
before(async () => {
// Start two IPFS instances
ipfsd1 = await startIpfs(IPFS, config.daemon1)
@@ -43,7 +51,9 @@ Object.keys(testAPIs).forEach((IPFS) => {
peerId1 = await getIpfsPeerId(ipfs1)
peerId2 = await getIpfsPeerId(ipfs2)
const testIdentities = await createTestIdentities(ipfs1, ipfs2)
const [identities, testIdentities] = await createTestIdentities(ipfs1, ipfs2)
identities1 = identities[0]
identities2 = identities[1]
testIdentity1 = testIdentities[0]
testIdentity2 = testIdentities[1]
@@ -52,7 +62,7 @@ Object.keys(testAPIs).forEach((IPFS) => {
})
after(async () => {
await cleanUpTestIdentities([testIdentity1, testIdentity2])
await cleanUpTestIdentities([identities1, identities2])
if (ipfsd1) {
await stopIpfs(ipfsd1)
@@ -94,13 +104,6 @@ Object.keys(testAPIs).forEach((IPFS) => {
let updateCount = 0
// const syncCount = 0
const accessController = {
canAppend: async (entry) => {
const identity = await testIdentity1.provider.get(entry.identity)
return identity.id === testIdentity1.id
}
}
const onUpdate = (entry) => {
++updateCount
}
@@ -223,13 +226,6 @@ Object.keys(testAPIs).forEach((IPFS) => {
let updateCount = 0
// let syncCount = 0
const accessController = {
canAppend: async (entry) => {
const identity = await testIdentity1.provider.get(entry.identity)
return identity.id === testIdentity1.id
}
}
const onUpdate = (entry) => {
++updateCount
}

9
test/oplog/append.test.js
View File

@@ -3,13 +3,13 @@ import rimraf from 'rimraf'
import { copy } from 'fs-extra'
import { Log } from '../../src/oplog/index.js'
import MemoryStorage from '../../src/storage/memory.js'
import { IdentityProvider } from '../../src/identities/index.js'
import { Identities } from '../../src/identities/index.js'
import KeyStore from '../../src/key-store.js'
// Test utils
import { config, testAPIs } from 'orbit-db-test-utils'
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
const { sync: rmrf } = rimraf
let testIdentity
@@ -21,6 +21,7 @@ Object.keys(testAPIs).forEach((IPFS) => {
const { identityKeyFixtures, signingKeyFixtures, identityKeysPath, signingKeysPath } = config
let keystore, signingKeyStore
let identities
before(async () => {
rmrf(identityKeysPath)
@@ -30,9 +31,11 @@ Object.keys(testAPIs).forEach((IPFS) => {
keystore = new KeyStore(identityKeysPath)
signingKeyStore = new KeyStore(signingKeysPath)
const storage = await MemoryStorage()
testIdentity = await createIdentity({ id: 'userA', keystore, signingKeyStore, storage })
identities = await Identities({ keystore, signingKeyStore, storage })
testIdentity = await identities.createIdentity({ id: 'userA' })
})
after(async () => {

15
test/oplog/crdt.test.js
View File

@@ -2,7 +2,7 @@ import { strictEqual, deepStrictEqual } from 'assert'
import rimraf from 'rimraf'
import { copy } from 'fs-extra'
import { Log } from '../../src/oplog/index.js'
import { IdentityProvider } from '../../src/identities/index.js'
import { Identities } from '../../src/identities/index.js'
import KeyStore from '../../src/key-store.js'
import MemoryStorage from '../../src/storage/memory.js'
@@ -10,7 +10,7 @@ import MemoryStorage from '../../src/storage/memory.js'
import { config, testAPIs } from 'orbit-db-test-utils'
const { sync: rmrf } = rimraf
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
let testIdentity, testIdentity2, testIdentity3
@@ -21,6 +21,7 @@ Object.keys(testAPIs).forEach((IPFS) => {
const { identityKeyFixtures, signingKeyFixtures, identityKeysPath, signingKeysPath } = config
let keystore, signingKeyStore
let identities1, identities2, identities3
before(async () => {
rmrf(identityKeysPath)
@@ -30,11 +31,15 @@ Object.keys(testAPIs).forEach((IPFS) => {
keystore = new KeyStore(identityKeysPath)
signingKeyStore = new KeyStore(signingKeysPath)
const storage = await MemoryStorage()
testIdentity = await createIdentity({ id: 'userA', keystore, signingKeyStore, storage })
testIdentity2 = await createIdentity({ id: 'userB', keystore, signingKeyStore, storage })
testIdentity3 = await createIdentity({ id: 'userC', keystore, signingKeyStore, storage })
identities1 = await Identities({ keystore, signingKeyStore, storage })
identities2 = await Identities({ keystore, signingKeyStore, storage })
identities3 = await Identities({ keystore, signingKeyStore, storage })
testIdentity = await identities1.createIdentity({ id: 'userA' })
testIdentity2 = await identities2.createIdentity({ id: 'userB' })
testIdentity3 = await identities3.createIdentity({ id: 'userC' })
})
after(async () => {

14
test/oplog/entry.test.js
View File

@@ -2,14 +2,14 @@ import { strictEqual, deepStrictEqual } from 'assert'
import rimraf from 'rimraf'
import { copy } from 'fs-extra'
import { Entry } from '../../src/oplog/index.js'
import { IdentityProvider } from '../../src/identities/index.js'
import { Identities } from '../../src/identities/index.js'
import KeyStore from '../../src/key-store.js'
import { config, testAPIs, startIpfs, stopIpfs } from 'orbit-db-test-utils'
// import IdentityStorage from '../src/identity-storage.js'
// import IPFSBlockStorage from '../src/ipfs-block-storage.js'
const { sync: rmrf } = rimraf
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
const { create, isEntry } = Entry
Object.keys(testAPIs).forEach((IPFS) => {
@@ -18,8 +18,9 @@ Object.keys(testAPIs).forEach((IPFS) => {
const { identityKeyFixtures, signingKeyFixtures, identityKeysPath, signingKeysPath } = config
let testIdentity
let keystore, signingKeyStore, ipfsBlockStore, identityStore
let identities
let testIdentity
let ipfsd, ipfs
before(async () => {
@@ -32,7 +33,8 @@ Object.keys(testAPIs).forEach((IPFS) => {
keystore = new KeyStore(identityKeysPath)
signingKeyStore = new KeyStore(signingKeysPath)
testIdentity = await createIdentity({ id: 'userA', keystore, signingKeyStore, ipfs })
identities = await Identities({ keystore, signingKeyStore, ipfs })
testIdentity = await identities.createIdentity({ id: 'userA' })
})
after(async () => {
@@ -76,11 +78,11 @@ Object.keys(testAPIs).forEach((IPFS) => {
// strictEqual(entry.hash, expectedHash)
})
it.skip('retrieves the identity from an entry', async() => {
it('retrieves the identity from an entry', async() => {
const expected = testIdentity.toJSON()
const payload = 'hello world'
const entry = await create(testIdentity, 'A', payload)
const entryIdentity = await identityStore.get(entry.identity)
const entryIdentity = await identities.getIdentity(entry.identity)
deepStrictEqual(entryIdentity, expected)
})

8
test/oplog/heads.test.js
View File

@@ -2,7 +2,7 @@ import { strictEqual, deepStrictEqual } from 'assert'
import rimraf from 'rimraf'
import { copy } from 'fs-extra'
import { Log } from '../../src/oplog/index.js'
import { IdentityProvider } from '../../src/identities/index.js'
import { Identities } from '../../src/identities/index.js'
import KeyStore from '../../src/key-store.js'
import MemoryStorage from '../../src/storage/memory.js'
@@ -10,7 +10,7 @@ import MemoryStorage from '../../src/storage/memory.js'
import { config, testAPIs } from 'orbit-db-test-utils'
const { sync: rmrf } = rimraf
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
let testIdentity
@@ -25,6 +25,7 @@ Object.keys(testAPIs).forEach((IPFS) => {
const { identityKeyFixtures, signingKeyFixtures, identityKeysPath, signingKeysPath } = config
let keystore, signingKeyStore
let identities
before(async () => {
rmrf(identityKeysPath)
@@ -36,7 +37,8 @@ Object.keys(testAPIs).forEach((IPFS) => {
signingKeyStore = new KeyStore(signingKeysPath)
const storage = await MemoryStorage()
testIdentity = await createIdentity({ id: 'userA', keystore, signingKeyStore, storage })
identities = await Identities({ keystore, signingKeyStore, storage })
testIdentity = await identities.createIdentity({ id: 'userA' })
})
after(async () => {

14
test/oplog/iterator.test.js
View File

@@ -1,7 +1,7 @@
import { strictEqual, deepStrictEqual } from 'assert'
import rimraf from 'rimraf'
import { Log } from '../../src/oplog/index.js'
import { IdentityProvider } from '../../src/identities/index.js'
import { Identities } from '../../src/identities/index.js'
import KeyStore from '../../src/key-store.js'
import LogCreator from './utils/log-creator.js'
import all from 'it-all'
@@ -12,7 +12,7 @@ import { config, testAPIs, startIpfs, stopIpfs } from 'orbit-db-test-utils'
import { identityKeys, signingKeys } from '../fixtures/orbit-db-identity-keys.js'
const { sync: rmrf } = rimraf
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
const { createLogWithSixteenEntries } = LogCreator
Object.keys(testAPIs).forEach((IPFS) => {
@@ -22,6 +22,7 @@ Object.keys(testAPIs).forEach((IPFS) => {
let ipfs
let ipfsd
let keystore, signingKeyStore
let identities1, identities2, identities3
let testIdentity, testIdentity2, testIdentity3
before(async () => {
@@ -39,9 +40,12 @@ Object.keys(testAPIs).forEach((IPFS) => {
const storage = await MemoryStorage()
testIdentity = await createIdentity({ id: 'userA', keystore, signingKeyStore, storage })
testIdentity2 = await createIdentity({ id: 'userB', keystore, signingKeyStore, storage })
testIdentity3 = await createIdentity({ id: 'userC', keystore, signingKeyStore, storage })
identities1 = await Identities({ keystore, signingKeyStore, storage })
identities2 = await Identities({ keystore, signingKeyStore, storage })
identities3 = await Identities({ keystore, signingKeyStore, storage })
testIdentity = await identities1.createIdentity({ id: 'userA' })
testIdentity2 = await identities2.createIdentity({ id: 'userB' })
testIdentity3 = await identities3.createIdentity({ id: 'userC' })
ipfsd = await startIpfs(IPFS, config.defaultIpfsConfig)
ipfs = ipfsd.api

11
test/oplog/join-concurrent.test.js
View File

@@ -2,7 +2,7 @@ import { strictEqual, deepStrictEqual } from 'assert'
import rimraf from 'rimraf'
import { copy } from 'fs-extra'
import { Log } from '../../src/oplog/index.js'
import { IdentityProvider } from '../../src/identities/index.js'
import { Identities } from '../../src/identities/index.js'
import KeyStore from '../../src/key-store.js'
import MemoryStorage from '../../src/storage/memory.js'
@@ -10,7 +10,7 @@ import MemoryStorage from '../../src/storage/memory.js'
import { config, testAPIs } from 'orbit-db-test-utils'
const { sync: rmrf } = rimraf
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
let testIdentity, testIdentity2
@@ -21,6 +21,7 @@ Object.keys(testAPIs).forEach(IPFS => {
const { identityKeyFixtures, signingKeyFixtures, identityKeysPath, signingKeysPath } = config
let keystore, signingKeyStore
let identities1, identities2
before(async () => {
rmrf(identityKeysPath)
@@ -33,8 +34,10 @@ Object.keys(testAPIs).forEach(IPFS => {
const storage = await MemoryStorage()
testIdentity = await createIdentity({ id: 'userA', keystore, signingKeyStore, storage })
testIdentity2 = await createIdentity({ id: 'userB', keystore, signingKeyStore, storage })
identities1 = await Identities({ keystore, signingKeyStore, storage })
identities2 = await Identities({ keystore, signingKeyStore, storage })
testIdentity = await identities1.createIdentity({ id: 'userA' })
testIdentity2 = await identities2.createIdentity({ id: 'userB' })
})
after(async () => {

17
test/oplog/join.test.js
View File

@@ -1,7 +1,7 @@
import { strictEqual, notStrictEqual, deepStrictEqual } from 'assert'
import rimraf from 'rimraf'
import { Log, Clock } from '../../src/oplog/index.js'
import { IdentityProvider } from '../../src/identities/index.js'
import { Identities } from '../../src/identities/index.js'
import KeyStore from '../../src/key-store.js'
import MemoryStorage from '../../src/storage/memory.js'
@@ -10,7 +10,7 @@ import { config, testAPIs } from 'orbit-db-test-utils'
import { identityKeys, signingKeys } from '../fixtures/orbit-db-identity-keys.js'
const { sync: rmrf } = rimraf
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
const last = (arr) => {
return arr[arr.length - 1]
@@ -22,6 +22,7 @@ Object.keys(testAPIs).forEach((IPFS) => {
let keystore, signingKeyStore
let log1, log2, log3, log4
let identities1, identities2, identities3, identities4
let testIdentity, testIdentity2, testIdentity3, testIdentity4
before(async () => {
@@ -39,10 +40,14 @@ Object.keys(testAPIs).forEach((IPFS) => {
const storage = await MemoryStorage()
testIdentity = await createIdentity({ id: 'userC', keystore, signingKeyStore, storage })
testIdentity2 = await createIdentity({ id: 'userB', keystore, signingKeyStore, storage })
testIdentity3 = await createIdentity({ id: 'userD', keystore, signingKeyStore, storage })
testIdentity4 = await createIdentity({ id: 'userA', keystore, signingKeyStore, storage })
identities1 = await Identities({ keystore, signingKeyStore, storage })
identities2 = await Identities({ keystore, signingKeyStore, storage })
identities3 = await Identities({ keystore, signingKeyStore, storage })
identities4 = await Identities({ keystore, signingKeyStore, storage })
testIdentity = await identities1.createIdentity({ id: 'userC' })
testIdentity2 = await identities2.createIdentity({ id: 'userB' })
testIdentity3 = await identities3.createIdentity({ id: 'userD' })
testIdentity4 = await identities4.createIdentity({ id: 'userA' })
})
after(async () => {

4
test/oplog/load.test.js
View File

@@ -3,7 +3,7 @@ import rimraf from 'rimraf'
import { copy } from 'fs-extra'
import { Log, Entry, Sorting } from '../../src/oplog/index.js'
import bigLogString from '../fixtures/big-log.fixture.js'
import { IdentityProvider } from '../../src/identities/index.js'
import { Identities } from '../../src/identities/index.js'
import KeyStore from '../../src/key-store.js'
import LogCreator from './utils/log-creator.js'
import MemoryStorage from '../../src/storage/memory.js'
@@ -13,7 +13,7 @@ import { config, MemStore, testAPIs, startIpfs, stopIpfs } from 'orbit-db-test-u
const { sync: rmrf } = rimraf
const { LastWriteWins } = Sorting
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
const { fromJSON, fromEntryHash, fromEntry, fromMultihash: _fromMultihash } = Log
const { fromMultihash, create, compare } = Entry
const { createLogWithSixteenEntries, createLogWithTwoHundredEntries } = LogCreator

8
test/oplog/log.test.js
View File

@@ -1,7 +1,7 @@
import { notStrictEqual, deepStrictEqual, strictEqual } from 'assert'
import rimraf from 'rimraf'
import { Log, Entry } from '../../src/oplog/index.js'
import { IdentityProvider } from '../../src/identities/index.js'
import { Identities } from '../../src/identities/index.js'
import KeyStore from '../../src/key-store.js'
import { copy } from 'fs-extra'
import MemoryStorage from '../../src/storage/memory.js'
@@ -11,7 +11,7 @@ import { config, testAPIs } from 'orbit-db-test-utils'
const { sync: rmrf } = rimraf
const { create } = Entry
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
let testIdentity
@@ -22,6 +22,7 @@ Object.keys(testAPIs).forEach((IPFS) => {
const { identityKeyFixtures, signingKeyFixtures, identityKeysPath, signingKeysPath } = config
let keystore, signingKeyStore
let identities
before(async () => {
await copy(identityKeyFixtures, identityKeysPath)
@@ -32,7 +33,8 @@ Object.keys(testAPIs).forEach((IPFS) => {
const storage = await MemoryStorage()
testIdentity = await createIdentity({ id: 'userA', keystore, signingKeyStore, storage })
identities = await Identities({ keystore, signingKeyStore, storage })
testIdentity = await identities.createIdentity({ id: 'userA' })
})
after(async () => {

8
test/oplog/references.test.js
View File

@@ -2,7 +2,7 @@ import { strictEqual } from 'assert'
import rimraf from 'rimraf'
import { copy } from 'fs-extra'
import { Log } from '../../src/oplog/index.js'
import { IdentityProvider } from '../../src/identities/index.js'
import { Identities } from '../../src/identities/index.js'
import KeyStore from '../../src/key-store.js'
import MemoryStorage from '../../src/storage/memory.js'
@@ -10,7 +10,7 @@ import MemoryStorage from '../../src/storage/memory.js'
import { config, testAPIs } from 'orbit-db-test-utils'
const { sync: rmrf } = rimraf
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
let testIdentity
@@ -21,6 +21,7 @@ Object.keys(testAPIs).forEach((IPFS) => {
const { identityKeyFixtures, signingKeyFixtures, identityKeysPath, signingKeysPath } = config
let keystore, signingKeyStore
let identities
before(async () => {
rmrf(identityKeysPath)
@@ -33,7 +34,8 @@ Object.keys(testAPIs).forEach((IPFS) => {
const storage = await MemoryStorage()
testIdentity = await createIdentity({ id: 'userA', keystore, signingKeyStore, storage })
identities = await Identities({ keystore, signingKeyStore, storage })
testIdentity = await identities.createIdentity({ id: 'userA' })
})
after(async () => {

40
test/oplog/replicate.test.js
View File

@@ -3,24 +3,29 @@ import rimraf from 'rimraf'
import { copy } from 'fs-extra'
import { Log, Entry } from '../../src/index.js'
import { MemoryStorage, IPFSBlockStorage } from '../../src/storage/index.js'
import { IdentityProvider } from '../../src/identities/index.js'
import { Identities } from '../../src/identities/index.js'
import KeyStore from '../../src/key-store.js'
// Test utils
import { config, testAPIs, startIpfs, stopIpfs, getIpfsPeerId, waitForPeers, connectPeers } from 'orbit-db-test-utils'
import { createTestIdentities, cleanUpTestIdentities } from '../fixtures/orbit-db-identity-keys.js'
const { sync: rmrf } = rimraf
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
Object.keys(testAPIs).forEach((IPFS) => {
describe('ipfs-log - Replication (' + IPFS + ')', function () {
this.timeout(config.timeout * 2)
let ipfsd1, ipfsd2, ipfs1, ipfs2, id1, id2, testIdentity, testIdentity2
const { identityKeyFixtures, signingKeyFixtures, identityKeysPath, signingKeysPath } = config
let ipfsd1, ipfsd2
let ipfs1, ipfs2
let id1, id2
let keystore, signingKeyStore
let identities1, identities2
let testIdentity1, testIdentity2
let storage1, storage2
before(async () => {
@@ -41,27 +46,22 @@ Object.keys(testAPIs).forEach((IPFS) => {
id1 = await getIpfsPeerId(ipfs1)
id2 = await getIpfsPeerId(ipfs2)
keystore = new KeyStore(identityKeysPath)
signingKeyStore = new KeyStore(signingKeysPath)
const storage = await MemoryStorage()
// Create an identity for each peers
testIdentity = await createIdentity({ id: 'userB', keystore, signingKeyStore, storage })
testIdentity2 = await createIdentity({ id: 'userA', keystore, signingKeyStore, storage })
const [identities, testIdentities] = await createTestIdentities(ipfs1, ipfs2)
identities1 = identities[0]
identities2 = identities[1]
testIdentity2 = testIdentities[0]
testIdentity1 = testIdentities[1]
storage1 = await IPFSBlockStorage({ ipfs: ipfs1 })
storage2 = await IPFSBlockStorage({ ipfs: ipfs2 })
})
after(async () => {
await cleanUpTestIdentities([identities1, identities2])
await stopIpfs(ipfsd1)
await stopIpfs(ipfsd2)
rmrf(identityKeysPath)
rmrf(signingKeysPath)
await keystore.close()
await signingKeyStore.close()
await storage1.close()
await storage2.close()
})
describe('replicates logs deterministically', async function () {
@@ -99,9 +99,9 @@ Object.keys(testAPIs).forEach((IPFS) => {
}
beforeEach(async () => {
log1 = await Log(testIdentity, { logId, storage: storage1 })
log1 = await Log(testIdentity1, { logId, storage: storage1 })
log2 = await Log(testIdentity2, { logId, storage: storage2 })
input1 = await Log(testIdentity, { logId, storage: storage1 })
input1 = await Log(testIdentity1, { logId, storage: storage1 })
input2 = await Log(testIdentity2, { logId, storage: storage2 })
await ipfs1.pubsub.subscribe(logId, handleMessage1)
await ipfs2.pubsub.subscribe(logId, handleMessage2)
@@ -143,7 +143,7 @@ Object.keys(testAPIs).forEach((IPFS) => {
await whileProcessingMessages(config.timeout)
const result = await Log(testIdentity, { logId, storage: storage1 })
const result = await Log(testIdentity1, { logId, storage: storage1 })
await result.join(log1)
await result.join(log2)

24
test/oplog/signed-log.test.js
View File

@@ -1,40 +1,32 @@
import { notStrictEqual, strictEqual, deepStrictEqual } from 'assert'
import rimraf from 'rimraf'
import { Log } from '../../src/oplog/index.js'
import { IdentityProvider } from '../../src/identities/index.js'
import KeyStore from '../../src/key-store.js'
import { Identities } from '../../src/identities/index.js'
// Test utils
import { config, testAPIs } from 'orbit-db-test-utils'
import { identityKeys, signingKeys, createTestIdentities, cleanUpTestIdentities } from '../fixtures/orbit-db-identity-keys.js'
const { sync: rmrf } = rimraf
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
Object.keys(testAPIs).forEach((IPFS) => {
describe('Signed Log (' + IPFS + ')', function () {
this.timeout(config.timeout)
let keystore, signingKeyStore
let identities1, identities2
let testIdentity, testIdentity2
before(async () => {
const testIdentities = await createTestIdentities()
const [identities, testIdentities] = await createTestIdentities()
identities1 = identities[0]
identities2 = identities[1]
testIdentity = testIdentities[0]
testIdentity2 = testIdentities[1]
})
after(async () => {
await cleanUpTestIdentities([testIdentity, testIdentity2])
if (keystore) {
await keystore.close()
}
if (signingKeyStore) {
await signingKeyStore.close()
}
rmrf('./keys_1')
rmrf('./keys_2')
await cleanUpTestIdentities([identities1, identities2])
})
it('creates a signed log', async () => {
@@ -160,7 +152,7 @@ Object.keys(testAPIs).forEach((IPFS) => {
it('throws an error upon join if entry doesn\'t have append access', async () => {
const testACL = {
canAppend: async (entry) => {
const identity = await testIdentity.provider.get(entry.identity)
const identity = await identities1.getIdentity(entry.identity)
return identity && identity.id !== testIdentity2.id
}
}

8
test/storage.spec.js
View File

@@ -2,7 +2,7 @@ import * as IPFS from 'ipfs'
import { strictEqual, notStrictEqual } from 'assert'
import rimraf from 'rimraf'
import { Log } from '../src/oplog/index.js'
import { IdentityProvider } from '../src/identities/index.js'
import { Identities } from '../src/identities/index.js'
import KeyStore from '../src/key-store.js'
import { IPFSBlockStorage, MemoryStorage, LRUStorage, ComposedStorage } from '../src/storage/index.js'
import { copy } from 'fs-extra'
@@ -11,7 +11,7 @@ import { copy } from 'fs-extra'
import { config, testAPIs } from 'orbit-db-test-utils'
const { sync: rmrf } = rimraf
const { createIdentity } = IdentityProvider
const { createIdentity } = Identities
Object.keys(testAPIs).forEach((_) => {
describe('Storages (' + _ + ')', function () {
@@ -39,8 +39,8 @@ Object.keys(testAPIs).forEach((_) => {
signingKeyStore = new KeyStore(signingKeysPath)
const storage = await MemoryStorage()
testIdentity1 = await createIdentity({ id: 'userA', keystore, signingKeyStore, storage })
const identities = await Identities({ keystore, signingKeyStore, storage })
testIdentity1 = await identities.createIdentity({ id: 'userA' })
})
after(async () => {