mirror of
https://github.com/oceanprotocol-archive/squid-js.git
synced 2024-02-02 15:31:51 +01:00
285 lines
10 KiB
TypeScript
285 lines
10 KiB
TypeScript
import { assert, expect, spy, use } from "chai"
|
|
import * as spies from "chai-spies"
|
|
import * as Web3 from "web3"
|
|
|
|
import { DDO } from "../../src/ddo/DDO"
|
|
import { Service } from "../../src/ddo/Service"
|
|
import { Ocean } from "../../src/ocean/Ocean"
|
|
import config from "../config"
|
|
import TestContractHandler from "../keeper/TestContractHandler"
|
|
|
|
import * as jsonDDO from "../testdata/ddo.json"
|
|
|
|
use(spies)
|
|
|
|
describe("DDO", () => {
|
|
|
|
const testDDO: DDO = new DDO({
|
|
id: `did:op:${"a".repeat(64)}`,
|
|
publicKey: [
|
|
{
|
|
id: "did:op:123456789abcdefghi#keys-1",
|
|
type: "RsaVerificationKey2018",
|
|
owner: "did:op:123456789abcdefghi",
|
|
publicKeyPem: "-----BEGIN PUBLIC KEY...END PUBLIC KEY-----\r\n",
|
|
},
|
|
{
|
|
id: "did:op:123456789abcdefghi#keys-2",
|
|
type: "Ed25519VerificationKey2018",
|
|
owner: "did:op:123456789abcdefghi",
|
|
publicKeyBase58: "H3C2AVvLMv6gmMNam3uVAjZpfkcJCwDwnZn6z3wXmqPV",
|
|
},
|
|
],
|
|
authentication: [
|
|
{
|
|
type: "RsaSignatureAuthentication2018",
|
|
publicKey: "did:op:123456789abcdefghi#keys-1",
|
|
},
|
|
{
|
|
type: "ieee2410Authentication2018",
|
|
publicKey: "did:op:123456789abcdefghi#keys-2",
|
|
},
|
|
],
|
|
service: [
|
|
{
|
|
type: "OpenIdConnectVersion1.0Service",
|
|
serviceEndpoint: "https://openid.example.com/",
|
|
},
|
|
{
|
|
type: "CredentialRepositoryService",
|
|
serviceEndpoint: "https://repository.example.com/service/8377464",
|
|
},
|
|
{
|
|
type: "XdiService",
|
|
serviceEndpoint: "https://xdi.example.com/8377464",
|
|
},
|
|
{
|
|
type: "HubService",
|
|
serviceEndpoint: "https://hub.example.com/.identity/did:op:0123456789abcdef/",
|
|
},
|
|
{
|
|
type: "MessagingService",
|
|
serviceEndpoint: "https://example.com/messages/8377464",
|
|
},
|
|
{
|
|
type: "SocialWebInboxService",
|
|
serviceEndpoint: "https://social.example.com/83hfh37dj",
|
|
description: "My public social inbox",
|
|
spamCost: {
|
|
amount: "0.50",
|
|
currency: "USD",
|
|
},
|
|
} as any,
|
|
{
|
|
id: "did:op:123456789abcdefghi;bops",
|
|
type: "BopsService",
|
|
serviceEndpoint: "https://bops.example.com/enterprise/",
|
|
},
|
|
{
|
|
type: "Consume",
|
|
serviceEndpoint: "http://mybrizo.org/api/v1/brizo/services/consume?pubKey=${pubKey}&serviceId={serviceId}&url={url}",
|
|
},
|
|
{
|
|
type: "Compute",
|
|
// tslint:disable-next-line
|
|
serviceEndpoint: "http://mybrizo.org/api/v1/brizo/services/compute?pubKey=${pubKey}&serviceId={serviceId}&algo={algo}&container={container}",
|
|
},
|
|
{
|
|
type: "Metadata",
|
|
serviceEndpoint: "http://myaquarius.org/api/v1/provider/assets/metadata/{did}",
|
|
metadata: {
|
|
base: {
|
|
name: "UK Weather information 2011",
|
|
type: "dataset",
|
|
description: "Weather information of UK including temperature and humidity",
|
|
dateCreated: "2012-10-10T17:00:000Z",
|
|
datePublished: "2012-10-10T17:00:000Z",
|
|
author: "Met Office",
|
|
license: "CC-BY",
|
|
copyrightHolder: "Met Office",
|
|
workExample: "423432fsd,51.509865,-0.118092,2011-01-01T10:55:11+00:00,7.2,68",
|
|
links: [
|
|
{
|
|
sample1: "http://data.ceda.ac.uk/badc/ukcp09/data/gridded-land-obs/gridded-land-obs-daily/",
|
|
},
|
|
{
|
|
sample2: "http://data.ceda.ac.uk/badc/ukcp09/data/gridded-land-obs/gridded-land-obs-averages-25km/",
|
|
},
|
|
{
|
|
fieldsDescription: "http://data.ceda.ac.uk/badc/ukcp09/",
|
|
},
|
|
],
|
|
inLanguage: "en",
|
|
categories: ["Economy", "Data Science"],
|
|
tags: ["weather", "uk", "2011", "temperature", "humidity"],
|
|
price: 10,
|
|
files: [
|
|
{
|
|
index: 0,
|
|
checksum: "efb2c764274b745f5fc37f97c6b0e761",
|
|
contentLength: 4535431,
|
|
resourceId: "access-log2018-02-13-15-17-29-18386C502CAEA932",
|
|
},
|
|
{
|
|
index: 1,
|
|
checksum: "085340abffh21495345af97c6b0e761",
|
|
contentLength: 12324,
|
|
},
|
|
{
|
|
index: 2,
|
|
},
|
|
],
|
|
checksum: "",
|
|
},
|
|
curation: {
|
|
rating: 0.93,
|
|
numVotes: 123,
|
|
schema: "Binary Voting",
|
|
},
|
|
additionalInformation: {
|
|
updateFrecuency: "yearly",
|
|
structuredMarkup: [
|
|
{
|
|
uri: "http://skos.um.es/unescothes/C01194/jsonld",
|
|
mediaType: "application/ld+json",
|
|
},
|
|
{
|
|
uri: "http://skos.um.es/unescothes/C01194/turtle",
|
|
mediaType: "text/turtle",
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
],
|
|
})
|
|
|
|
let web3: Web3
|
|
let ocean: Ocean
|
|
|
|
beforeEach(async () => {
|
|
await TestContractHandler.prepareContracts()
|
|
ocean = await Ocean.getInstance(config)
|
|
web3 = (ocean as any).web3
|
|
})
|
|
|
|
afterEach(() => {
|
|
spy.restore()
|
|
})
|
|
|
|
describe("#serialize()", () => {
|
|
|
|
it("should properly serialize", async () => {
|
|
|
|
const ddoString = DDO.serialize(testDDO)
|
|
assert(ddoString)
|
|
assert(ddoString.startsWith("{"))
|
|
})
|
|
})
|
|
|
|
describe("#constructor()", () => {
|
|
|
|
it("should create an empty ddo", async () => {
|
|
|
|
const ddo = new DDO()
|
|
assert(ddo)
|
|
|
|
assert(ddo.service.length === 0)
|
|
assert(ddo.authentication.length === 0)
|
|
assert(ddo.publicKey.length === 0)
|
|
})
|
|
|
|
it("should create an predefined ddo", async () => {
|
|
|
|
const service: Partial<Service> & any = {
|
|
serviceEndpoint: "http://",
|
|
description: "nice service",
|
|
}
|
|
|
|
const ddo = new DDO({
|
|
service: [service as any],
|
|
})
|
|
assert(ddo)
|
|
|
|
assert(ddo.service.length === 1)
|
|
assert((ddo.service[0] as any).description === service.description)
|
|
|
|
assert(ddo.authentication.length === 0)
|
|
assert(ddo.publicKey.length === 0)
|
|
})
|
|
})
|
|
|
|
describe("#deserialize()", () => {
|
|
|
|
it("should properly deserialize from serialized object", async () => {
|
|
|
|
const ddoString = DDO.serialize(testDDO)
|
|
assert.typeOf(ddoString, "string")
|
|
|
|
const ddo: DDO = DDO.deserialize(ddoString)
|
|
assert.instanceOf(ddo, DDO)
|
|
|
|
assert.equal(ddo.id, testDDO.id)
|
|
assert.equal(ddo.publicKey[0].publicKeyPem, testDDO.publicKey[0].publicKeyPem)
|
|
})
|
|
|
|
it("should properly deserialize from json file", async () => {
|
|
|
|
const ddo: DDO = DDO.deserialize(JSON.stringify(jsonDDO))
|
|
assert(ddo)
|
|
|
|
assert.equal(ddo.id, jsonDDO.id)
|
|
assert.equal(ddo.publicKey[0].publicKeyPem, jsonDDO.publicKey[0].publicKeyPem)
|
|
})
|
|
})
|
|
|
|
describe("#getChecksum()", () => {
|
|
it("should properly generate a the checksum DDO", async () => {
|
|
const ddo = new DDO(testDDO)
|
|
const checksum = ddo.getChecksum()
|
|
|
|
assert.equal(checksum, "15f27a7a3c7b15d2b06dec7347c6b8da168adddd7df51a8ebbbe87b59b80049b")
|
|
})
|
|
})
|
|
|
|
describe("#generateProof()", () => {
|
|
|
|
const publicKey = `0x${"a".repeat(40)}`
|
|
const signature = `0x${"a".repeat(130)}`
|
|
|
|
it("should properly generate the proof", async () => {
|
|
const signTextSpy = spy.on(ocean.utils.signature, "signText", () => signature)
|
|
const ddo = new DDO(testDDO)
|
|
const checksum = ddo.getChecksum()
|
|
const proof = await ddo.generateProof(ocean, publicKey)
|
|
|
|
assert.include(proof as any, {
|
|
creator: publicKey,
|
|
type: "DDOIntegritySignature",
|
|
signatureValue: signature,
|
|
})
|
|
expect(signTextSpy).to.have.been.called.with(checksum, publicKey)
|
|
})
|
|
})
|
|
|
|
describe("#addProof()", () => {
|
|
|
|
const publicKey = `0x${"a".repeat(40)}`
|
|
|
|
it("should properly add the proof on the DDO", async () => {
|
|
const fakeProof = {
|
|
creation: Date.now(),
|
|
creator: "test",
|
|
type: "test",
|
|
signaturValue: "test",
|
|
} as any
|
|
const ddo = new DDO(testDDO)
|
|
const generateProofSpy = spy.on(ddo, "generateProof", () => fakeProof)
|
|
await ddo.addProof(web3, publicKey)
|
|
|
|
assert.equal(ddo.proof, fakeProof)
|
|
expect(generateProofSpy).to.have.been.called.with(publicKey)
|
|
})
|
|
})
|
|
})
|