mirror of
https://github.com/orbitdb/orbitdb.git
synced 2025-10-07 22:57:07 +00:00
270 lines
9.5 KiB
JavaScript
270 lines
9.5 KiB
JavaScript
import assert from 'assert'
|
|
import { Identity, isIdentity, isEqual } from '../../src/identities/index.js'
|
|
import { decodeIdentity } from '../../src/identities/identity.js'
|
|
|
|
describe('Identity', function () {
|
|
const id = '0x01234567890abcdefghijklmnopqrstuvwxyz'
|
|
const publicKey = '<pubkey>'
|
|
const signatures = {
|
|
id: 'signature for <id>',
|
|
publicKey: 'signature for <publicKey + idSignature>'
|
|
}
|
|
const type = 'orbitdb'
|
|
// const provider = 'IdentityProviderInstance'
|
|
|
|
const expectedHash = 'zdpuArx43BnXdDff5rjrGLYrxUomxNroc2uaocTgcWK76UfQT'
|
|
const expectedBytes = Uint8Array.from([
|
|
164,98,105,100,120,39,48,120,48,49,50,51,52,53,54,55,56,57,48,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,100,116,121,112,101,103,111,114,98,105,116,100,98,105,112,117,98,108,105,99,75,101,121,104,60,112,117,98,107,101,121,62,106,115,105,103,110,97,116,117,114,101,115,162,98,105,100,114,115,105,103,110,97,116,117,114,101,32,102,111,114,32,60,105,100,62,105,112,117,98,108,105,99,75,101,121,120,39,115,105,103,110,97,116,117,114,101,32,102,111,114,32,60,112,117,98,108,105,99,75,101,121,32,43,32,105,100,83,105,103,110,97,116,117,114,101,62
|
|
])
|
|
|
|
let identity
|
|
|
|
before(async () => {
|
|
identity = await Identity({ id, publicKey, signatures, type })
|
|
})
|
|
|
|
it('has the correct id', async () => {
|
|
assert.strictEqual(identity.id, id)
|
|
})
|
|
|
|
it('has the correct publicKey', async () => {
|
|
assert.strictEqual(identity.publicKey, publicKey)
|
|
})
|
|
|
|
it('has the correct idSignature', async () => {
|
|
assert.strictEqual(identity.signatures.id, signatures.id)
|
|
})
|
|
|
|
it('has the correct publicKeyAndIdSignature', async () => {
|
|
assert.strictEqual(identity.signatures.publicKey, signatures.publicKey)
|
|
})
|
|
|
|
// it('has the correct provider', async () => {
|
|
// assert.deepStrictEqual(identity.provider, provider)
|
|
// })
|
|
|
|
describe('Constructor inputs', () => {
|
|
it('throws and error if id was not given in constructor', async () => {
|
|
let err
|
|
try {
|
|
identity = await Identity()
|
|
} catch (e) {
|
|
err = e.toString()
|
|
}
|
|
assert.strictEqual(err, 'Error: Identity id is required')
|
|
})
|
|
|
|
it('throws and error if publicKey was not given in constructor', async () => {
|
|
let err
|
|
try {
|
|
identity = await Identity({ id: 'abc'})
|
|
} catch (e) {
|
|
err = e.toString()
|
|
}
|
|
assert.strictEqual(err, 'Error: Invalid public key')
|
|
})
|
|
|
|
it('throws and error if identity signature was not given in constructor', async () => {
|
|
let err
|
|
try {
|
|
identity = await Identity({ id: 'abc', publicKey })
|
|
} catch (e) {
|
|
err = e.toString()
|
|
}
|
|
assert.strictEqual(err, 'Error: Signatures object is required')
|
|
})
|
|
|
|
it('throws and error if signature for id was not given in constructor', async () => {
|
|
let err
|
|
try {
|
|
identity = await Identity({ id: 'abc', publicKey, signatures: {} })
|
|
} catch (e) {
|
|
err = e.toString()
|
|
}
|
|
assert.strictEqual(err, 'Error: Signature of id is required')
|
|
})
|
|
|
|
it('throws and error if signature for publicKey was not given in constructor', async () => {
|
|
let err
|
|
try {
|
|
identity = await Identity({ id: 'abc', publicKey, signatures: { id: signatures.id } })
|
|
} catch (e) {
|
|
err = e.toString()
|
|
}
|
|
assert.strictEqual(err, 'Error: Signature of publicKey+id is required')
|
|
})
|
|
|
|
it('throws and error if signature for publicKey was not given in constructor', async () => {
|
|
let err
|
|
try {
|
|
identity = await Identity({ id: 'abc', publicKey, signatures: { publicKey: signatures.publicKey } })
|
|
} catch (e) {
|
|
err = e.toString()
|
|
}
|
|
assert.strictEqual(err, 'Error: Signature of id 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
|
|
try {
|
|
identity = await Identity({ id: 'abc', publicKey, signatures })
|
|
} catch (e) {
|
|
err = e.toString()
|
|
}
|
|
assert.strictEqual(err, 'Error: Identity type is required')
|
|
})
|
|
})
|
|
|
|
describe('isIdentity', () => {
|
|
describe('valid Identity', () => {
|
|
it('is a valid identity', async () => {
|
|
const identity = await Identity({ id, publicKey, signatures, type })
|
|
const result = isIdentity(identity)
|
|
assert.strictEqual(result, true)
|
|
})
|
|
})
|
|
|
|
describe('invalid Identity', () => {
|
|
beforeEach(async () => {
|
|
identity = await Identity({ id, publicKey, signatures, type })
|
|
})
|
|
|
|
it('is not a valid identity if id is missing', async () => {
|
|
delete identity.id
|
|
const result = isIdentity(identity)
|
|
assert.strictEqual(result, false)
|
|
})
|
|
|
|
it('is not a valid identity if hash is missing', async () => {
|
|
delete identity.hash
|
|
const result = isIdentity(identity)
|
|
assert.strictEqual(result, false)
|
|
})
|
|
|
|
it('is not a valid identity if bytes are missing', async () => {
|
|
delete identity.bytes
|
|
const result = isIdentity(identity)
|
|
assert.strictEqual(result, false)
|
|
})
|
|
|
|
it('is not a valid identity if publicKey is missing', async () => {
|
|
delete identity.publicKey
|
|
const result = isIdentity(identity)
|
|
assert.strictEqual(result, false)
|
|
})
|
|
|
|
it('is not a valid identity if signatures is missing', async () => {
|
|
delete identity.signatures
|
|
const result = isIdentity(identity)
|
|
assert.strictEqual(result, false)
|
|
})
|
|
|
|
it('is not a valid identity if signature for id is missing', async () => {
|
|
delete identity.signatures.id
|
|
const result = isIdentity(identity)
|
|
assert.strictEqual(result, false)
|
|
})
|
|
|
|
it('is not a valid identity if signature for publicKey is missing', async () => {
|
|
delete identity.signatures.publicKey
|
|
const result = isIdentity(identity)
|
|
assert.strictEqual(result, false)
|
|
})
|
|
|
|
it('is not a valid identity if type is missing', async () => {
|
|
delete identity.type
|
|
const result = isIdentity(identity)
|
|
assert.strictEqual(result, false)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('isEqual', () => {
|
|
describe('equal identities', () => {
|
|
it('identities are equal', async () => {
|
|
const identity1 = await Identity({ id, publicKey, signatures, type })
|
|
const identity2 = await Identity({ id, publicKey, signatures, type })
|
|
const result = isEqual(identity1, identity2)
|
|
assert.strictEqual(result, true)
|
|
})
|
|
})
|
|
|
|
describe('not equal identities', () => {
|
|
let identity1, identity2
|
|
|
|
before(async () => {
|
|
identity1 = await Identity({ id, publicKey, signatures, type })
|
|
identity2 = await Identity({ id, publicKey, signatures, type })
|
|
})
|
|
|
|
it('identities are not equal if id is different', async () => {
|
|
identity2 = await Identity({ id: 'X', publicKey, signatures, type })
|
|
const result = isEqual(identity1, identity2)
|
|
assert.strictEqual(result, false)
|
|
})
|
|
|
|
it('identities are not equal if hash is different', async () => {
|
|
identity2 = await Identity({ id, publicKey, signatures, type })
|
|
identity2.hash = 'notthesame'
|
|
const result = isEqual(identity1, identity2)
|
|
assert.strictEqual(result, false)
|
|
})
|
|
|
|
it('identities are not equal if type is different', async () => {
|
|
identity2 = await Identity({ id, publicKey, signatures, type })
|
|
identity2.type = 'some other identity provider than orbitdb'
|
|
const result = isEqual(identity1, identity2)
|
|
assert.strictEqual(result, false)
|
|
})
|
|
|
|
it('identities are not equal if publicKey is different', async () => {
|
|
identity2 = await Identity({ id, publicKey: 'XYZ', signatures, type })
|
|
const result = isEqual(identity1, identity2)
|
|
assert.strictEqual(result, false)
|
|
})
|
|
|
|
it('identities are not equal if id signature is different', async () => {
|
|
identity2 = await Identity({ id, publicKey, signatures: { id: 'different id signature', publicKey: signatures.publicKey }, type })
|
|
const result = isEqual(identity1, identity2)
|
|
assert.strictEqual(result, false)
|
|
})
|
|
|
|
it('identities are not equal if publicKey signature is different', async () => {
|
|
identity2 = await Identity({ id, publicKey, signatures: { id: signatures.id, publicKey: 'different publicKey signature' }, type })
|
|
const result = isEqual(identity1, identity2)
|
|
assert.strictEqual(result, false)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('Decode Identity', () => {
|
|
before(async () => {
|
|
identity = await Identity({ id, publicKey, signatures, type })
|
|
})
|
|
|
|
it('decodes an identity from bytes', async () => {
|
|
const result = await decodeIdentity(expectedBytes)
|
|
|
|
assert.strictEqual(isIdentity(result), true)
|
|
assert.strictEqual(result.id, id)
|
|
assert.strictEqual(result.publicKey, publicKey)
|
|
assert.strictEqual(result.type, type)
|
|
assert.strictEqual(result.hash, expectedHash)
|
|
assert.strictEqual(result.sign, undefined)
|
|
assert.strictEqual(result.verify, undefined)
|
|
assert.deepStrictEqual(result.bytes, expectedBytes)
|
|
assert.deepStrictEqual(result.signatures, signatures)
|
|
})
|
|
})
|
|
})
|