@dashevo/wasm-dpp 0.23.0-dev.10

package/test/unit/Metadata.spec.js

@@ -0,0 +1,37 @@
+const Metadata = require('../../lib/Metadata');
+
+describe('Metadata', () => {
+  describe('#constructor', () => {
+    it('should set height and core chain-locked height', () => {
+      const result = new Metadata({
+        blockHeight: 42,
+        coreChainLockedHeight: 1,
+      });
+
+      expect(result.blockHeight).to.equal(42);
+      expect(result.coreChainLockedHeight).to.equal(1);
+    });
+  });
+
+  describe('#getBlockHeight', () => {
+    it('should get block height', () => {
+      const result = new Metadata({
+        blockHeight: 42,
+        coreChainLockedHeight: 1,
+      });
+
+      expect(result.getBlockHeight()).to.equal(42);
+    });
+  });
+
+  describe('#getCoreChainLockedHeight', () => {
+    it('should get core chain-locked height', () => {
+      const result = new Metadata({
+        blockHeight: 1,
+        coreChainLockedHeight: 42,
+      });
+
+      expect(result.getCoreChainLockedHeight()).to.equal(42);
+    });
+  });
+});

package/test/unit/dataContract/DataContract.spec.js

@@ -0,0 +1,407 @@
+const bs58 = require('bs58');
+
+const Identifier = require('../../../lib/identifier/Identifier');
+
+const InvalidDocumentTypeError = require('../../../lib/errors/InvalidDocumentTypeError');
+
+const generateRandomIdentifier = require('../../../lib/test/utils/generateRandomIdentifier');
+const Metadata = require('../../../lib/Metadata');
+const DataContract = require('../../../lib/dataContract/DataContract');
+
+const hash = require('../../../lib/util/hash');
+const serializer = require('../../../lib/util/serializer');
+const getBinaryPropertiesFromSchema = require('../../../lib/dataContract/getBinaryPropertiesFromSchema');
+
+describe('DataContract', () => {
+  let hashMock;
+  let encodeMock;
+  let documentType;
+  let documentSchema;
+  let documents;
+  let dataContract;
+  let ownerId;
+  let entropy;
+  let contractId;
+  let getBinaryPropertiesFromSchemaMock;
+  let metadataFixture;
+
+  beforeEach(function beforeEach() {
+    encodeMock = this.sinonSandbox.stub(serializer, 'encode');
+    hashMock = this.sinonSandbox.stub(hash, 'hash');
+    getBinaryPropertiesFromSchemaMock = this.sinonSandbox.stub(getBinaryPropertiesFromSchema, 'getBinaryPropertiesFromSchema');
+
+    documentType = 'niceDocument';
+
+    documentSchema = {
+      properties: {
+        nice: {
+          type: 'boolean',
+        },
+      },
+    };
+
+    documents = {
+      [documentType]: documentSchema,
+    };
+
+    getBinaryPropertiesFromSchemaMock.withArgs(documentSchema)
+      .returns({
+        'firstLevel.secondLevel': {
+          type: 'array',
+          byteArray: true,
+        },
+      });
+
+    ownerId = generateRandomIdentifier();
+    entropy = Buffer.alloc(32);
+    contractId = generateRandomIdentifier();
+
+    dataContract = new DataContract({
+      $schema: DataContract.DEFAULTS.SCHEMA,
+      $id: contractId,
+      version: 1,
+      ownerId,
+      documents,
+      $defs: {},
+    });
+
+    metadataFixture = new Metadata(42, 0);
+
+    dataContract.setMetadata(metadataFixture);
+  });
+
+  afterEach(() => {
+    encodeMock.restore();
+    hashMock.restore();
+    getBinaryPropertiesFromSchemaMock.restore();
+  });
+
+  describe('constructor', () => {
+    it('should create new DataContract', () => {
+      const id = generateRandomIdentifier();
+
+      dataContract = new DataContract({
+        $schema: DataContract.DEFAULTS.SCHEMA,
+        $id: id,
+        ownerId,
+        documents,
+        $defs: {},
+      });
+
+      expect(dataContract.id).to.deep.equal(id);
+      expect(dataContract.ownerId).to.deep.equal(ownerId);
+      expect(dataContract.schema).to.equal(DataContract.DEFAULTS.SCHEMA);
+      expect(dataContract.documents).to.equal(documents);
+      expect(dataContract.$defs).to.deep.equal({});
+    });
+  });
+
+  describe('#getId', () => {
+    it('should return DataContract Identifier', () => {
+      const result = dataContract.getId();
+
+      expect(result).to.deep.equal(contractId);
+      expect(result).to.be.instanceof(Identifier);
+    });
+  });
+
+  describe('#getJsonSchemaId', () => {
+    it('should return JSON Schema ID', () => {
+      const result = dataContract.getJsonSchemaId();
+
+      expect(result).to.equal(dataContract.getId().toString());
+    });
+  });
+
+  describe('#setJsonMetaSchema', () => {
+    it('should set meta schema', () => {
+      const metaSchema = 'http://test.com/schema';
+
+      const result = dataContract.setJsonMetaSchema(metaSchema);
+
+      expect(result).to.equal(dataContract);
+      expect(dataContract.schema).to.equal(metaSchema);
+    });
+  });
+
+  describe('#getJsonMetaSchema', () => {
+    it('should return meta schema', () => {
+      const result = dataContract.getJsonMetaSchema();
+
+      expect(result).to.equal(dataContract.schema);
+    });
+  });
+
+  describe('#setDocuments', () => {
+    it('should set Documents definition', () => {
+      const anotherDocuments = {
+        anotherDocument: {
+          properties: {
+            name: { type: 'string' },
+          },
+        },
+      };
+
+      const result = dataContract.setDocuments(anotherDocuments);
+
+      expect(result).to.equal(dataContract);
+      expect(dataContract.documents).to.equal(anotherDocuments);
+    });
+  });
+
+  describe('#getDocuments', () => {
+    it('should return Documents definition', () => {
+      const result = dataContract.getDocuments();
+
+      expect(result).to.equal(dataContract.documents);
+    });
+  });
+
+  describe('#isDocumentDefined', () => {
+    it('should return true if Document schema is defined', () => {
+      const result = dataContract.isDocumentDefined('niceDocument');
+
+      expect(result).to.equal(true);
+    });
+
+    it('should return false if Document schema is not defined', () => {
+      const result = dataContract.isDocumentDefined('undefinedDocument');
+
+      expect(result).to.equal(false);
+    });
+  });
+
+  describe('#setDocumentSchema', () => {
+    it('should set Document schema', () => {
+      const anotherType = 'prettyDocument';
+      const anotherDefinition = {
+        properties: {
+          name: { type: 'string' },
+        },
+      };
+
+      const result = dataContract.setDocumentSchema(anotherType, anotherDefinition);
+
+      expect(result).to.equal(dataContract);
+
+      expect(dataContract.documents).to.have.property(anotherType);
+      expect(dataContract.documents[anotherType]).to.equal(anotherDefinition);
+    });
+  });
+
+  describe('#getDocumentSchema', () => {
+    it('should throw error if Document is not defined', () => {
+      let error;
+      try {
+        dataContract.getDocumentSchema('undefinedObject');
+      } catch (e) {
+        error = e;
+      }
+
+      expect(error).to.be.an.instanceOf(InvalidDocumentTypeError);
+    });
+
+    it('should return Document Schema', () => {
+      const result = dataContract.getDocumentSchema(documentType);
+
+      expect(result).to.equal(documentSchema);
+    });
+  });
+
+  describe('#getDocumentSchemaRef', () => {
+    it('should throw error if Document is not defined', () => {
+      let error;
+      try {
+        dataContract.getDocumentSchemaRef('undefinedObject');
+      } catch (e) {
+        error = e;
+      }
+
+      expect(error).to.be.an.instanceOf(InvalidDocumentTypeError);
+    });
+
+    it('should return schema with $ref to Document schema', () => {
+      const hashed = Buffer.from(ownerId + entropy);
+      hashMock.returns(hashed);
+
+      const result = dataContract.getDocumentSchemaRef(documentType);
+
+      expect(result).to.deep.equal({
+        $ref: `${dataContract.getJsonSchemaId()}#/documents/niceDocument`,
+      });
+    });
+  });
+
+  describe('#setDefinitions', () => {
+    it('should set $defs', () => {
+      const $defs = {};
+
+      const result = dataContract.setDefinitions($defs);
+
+      expect(result).to.equal(dataContract);
+      expect(dataContract.$defs).to.equal($defs);
+    });
+  });
+
+  describe('#getDefinitions', () => {
+    it('should return $defs', () => {
+      const result = dataContract.getDefinitions();
+
+      expect(result).to.equal(dataContract.$defs);
+    });
+  });
+
+  describe('#toJSON', () => {
+    it('should return DataContract as plain object', () => {
+      const result = dataContract.toJSON();
+
+      expect(result).to.deep.equal({
+        protocolVersion: dataContract.getProtocolVersion(),
+        $id: bs58.encode(contractId),
+        $schema: DataContract.DEFAULTS.SCHEMA,
+        version: 1,
+        ownerId: bs58.encode(ownerId),
+        documents,
+      });
+    });
+
+    it('should return plain object with "$defs" if present', () => {
+      const $defs = {
+        subSchema: { type: 'object' },
+      };
+
+      dataContract.setDefinitions($defs);
+
+      const result = dataContract.toJSON();
+
+      expect(result).to.deep.equal({
+        protocolVersion: dataContract.getProtocolVersion(),
+        $schema: DataContract.DEFAULTS.SCHEMA,
+        $id: bs58.encode(contractId),
+        version: 1,
+        ownerId: bs58.encode(ownerId),
+        documents,
+        $defs,
+      });
+    });
+  });
+
+  describe('#toBuffer', () => {
+    it('should return DataContract as a Buffer', () => {
+      const serializedDataContract = Buffer.from('123');
+
+      encodeMock.returns(serializedDataContract);
+
+      const result = dataContract.toBuffer();
+
+      const dataContractToEncode = dataContract.toObject();
+      delete dataContractToEncode.protocolVersion;
+
+      const protocolVersionUInt32 = Buffer.alloc(4);
+      protocolVersionUInt32.writeUInt32LE(dataContract.getProtocolVersion(), 0);
+
+      expect(encodeMock).to.have.been.calledOnceWith(dataContractToEncode);
+      expect(result).to.deep.equal(Buffer.concat([protocolVersionUInt32, serializedDataContract]));
+    });
+  });
+
+  describe('#hash', () => {
+    let toBufferMock;
+
+    beforeEach(function beforeEach() {
+      toBufferMock = this.sinonSandbox.stub(DataContract.prototype, 'toBuffer');
+    });
+
+    afterEach(() => {
+      toBufferMock.restore();
+    });
+
+    it('should return DataContract hash', () => {
+      const serializedDataContract = '123';
+      const hashedDocument = '456';
+
+      toBufferMock.returns(serializedDataContract);
+
+      hashMock.returns(hashedDocument);
+
+      const result = dataContract.hash();
+
+      expect(result).to.equal(hashedDocument);
+
+      expect(toBufferMock).to.have.been.calledOnce();
+
+      expect(hashMock).to.have.been.calledOnceWith(serializedDataContract);
+    });
+  });
+
+  describe('#setEntropy', () => {
+    it('should set entropy', () => {
+      const result = dataContract.setEntropy(entropy);
+
+      expect(result).to.equal(dataContract);
+      expect(dataContract.entropy).to.deep.equal(entropy);
+    });
+  });
+
+  describe('#getEntropy', () => {
+    it('should return entropy', () => {
+      dataContract.entropy = entropy;
+
+      const result = dataContract.getEntropy();
+
+      expect(result).to.equal(dataContract.entropy);
+    });
+  });
+
+  describe('#getBinaryProperties', () => {
+    it('should return flat map of properties with `contentEncoding` keywords', () => {
+      const result = dataContract.getBinaryProperties(documentType);
+      expect(result).to.deep.equal({
+        'firstLevel.secondLevel': {
+          type: 'array',
+          byteArray: true,
+        },
+      });
+    });
+
+    it('should return cached flat map of properties with `contentEncoding` keywords', () => {
+      dataContract.getBinaryProperties(documentType);
+
+      const result = dataContract.getBinaryProperties(documentType);
+
+      expect(result).to.deep.equal({
+        'firstLevel.secondLevel': {
+          type: 'array',
+          byteArray: true,
+        },
+      });
+
+      expect(getBinaryPropertiesFromSchemaMock).to.have.been.calledOnceWith(documentSchema);
+    });
+
+    it('should throw an error if document type is not found', () => {
+      try {
+        dataContract.getBinaryProperties('unknown');
+        expect.fail('Error was not thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(InvalidDocumentTypeError);
+      }
+    });
+  });
+
+  describe('#setMetadata', () => {
+    it('should set metadata', () => {
+      const otherMetadata = new Metadata(43, 1);
+
+      dataContract.setMetadata(otherMetadata);
+
+      expect(dataContract.metadata).to.deep.equal(otherMetadata);
+    });
+  });
+
+  describe('#getMetadata', () => {
+    it('should get metadata', () => {
+      expect(dataContract.getMetadata()).to.deep.equal(metadataFixture);
+    });
+  });
+});

package/test/unit/dataContract/DataContractFactory.spec.js

@@ -0,0 +1,178 @@
+const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
+
+const protocolVersion = require('../../../lib/version/protocolVersion');
+
+const DataContractCreateTransition = require('../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
+
+const ValidationResult = require('../../../lib/validation/ValidationResult');
+
+const InvalidDataContractError = require('../../../lib/dataContract/errors/InvalidDataContractError');
+const SerializedObjectParsingError = require('../../../lib/errors/consensus/basic/decode/SerializedObjectParsingError');
+const createDPPMock = require('../../../lib/test/mocks/createDPPMock');
+const SomeConsensusError = require('../../../lib/test/mocks/SomeConsensusError');
+
+const DataContractFactory = require('../../../lib/dataContract/DataContractFactory');
+const entropyGenerator = require('../../../lib/util/entropyGenerator');
+
+describe('DataContractFactory', () => {
+  let decodeProtocolEntityMock;
+  let validateDataContractMock;
+  let factory;
+  let dataContract;
+  let rawDataContract;
+  let generateEntropyMock;
+  let dppMock;
+
+  beforeEach(function beforeEach() {
+    dataContract = getDataContractFixture();
+    dppMock = createDPPMock();
+
+    rawDataContract = dataContract.toObject();
+
+    decodeProtocolEntityMock = this.sinonSandbox.stub();
+    validateDataContractMock = this.sinonSandbox.stub();
+    generateEntropyMock = this.sinonSandbox.stub(entropyGenerator, 'generate');
+
+    factory = new DataContractFactory(
+      dppMock,
+      validateDataContractMock,
+      decodeProtocolEntityMock,
+    );
+  });
+
+  afterEach(() => {
+    generateEntropyMock.restore();
+  });
+
+  describe('create', () => {
+    it('should return new Data Contract with specified name and documents definition', () => {
+      generateEntropyMock.returns(dataContract.getEntropy());
+      const result = factory.create(
+        dataContract.ownerId.toBuffer(),
+        rawDataContract.documents,
+      );
+
+      expect(result).excluding('$defs').to.deep.equal(dataContract);
+    });
+  });
+
+  describe('createFromObject', () => {
+    it('should return new Data Contract with data from passed object', async () => {
+      validateDataContractMock.returns(new ValidationResult());
+
+      const result = await factory.createFromObject(rawDataContract);
+
+      expect(result.toObject()).excluding('entropy').to.deep.equal(rawDataContract);
+
+      expect(validateDataContractMock).to.have.been.calledOnceWith(rawDataContract);
+    });
+
+    it('should return new Data Contract without validation if "skipValidation" option is passed', async () => {
+      const result = await factory.createFromObject(rawDataContract, { skipValidation: true });
+
+      expect(result.toObject()).excluding('entropy').to.deep.equal(rawDataContract);
+
+      expect(validateDataContractMock).to.have.not.been.called();
+    });
+
+    it('should throw an error if passed object is not valid', async () => {
+      const validationError = new SomeConsensusError('test');
+
+      validateDataContractMock.returns(new ValidationResult([validationError]));
+
+      let error;
+      try {
+        await factory.createFromObject(rawDataContract);
+      } catch (e) {
+        error = e;
+      }
+
+      expect(error).to.be.an.instanceOf(InvalidDataContractError);
+      expect(error.getRawDataContract()).to.equal(rawDataContract);
+
+      expect(error.getErrors()).to.have.length(1);
+
+      const [consensusError] = error.getErrors();
+
+      expect(consensusError).to.equal(validationError);
+
+      expect(validateDataContractMock).to.have.been.calledOnceWith(rawDataContract);
+    });
+  });
+
+  describe('createFromBuffer', () => {
+    let serializedDataContract;
+
+    beforeEach(function beforeEach() {
+      this.sinonSandbox.stub(factory, 'createFromObject');
+
+      serializedDataContract = dataContract.toBuffer();
+    });
+
+    afterEach(() => {
+      factory.createFromObject.restore();
+    });
+
+    it('should return new Data Contract from serialized contract', async () => {
+      decodeProtocolEntityMock.returns([rawDataContract.protocolVersion, rawDataContract]);
+
+      factory.createFromObject.returns(dataContract);
+
+      const result = await factory.createFromBuffer(serializedDataContract);
+
+      expect(result).to.equal(dataContract);
+
+      expect(factory.createFromObject).to.have.been.calledOnceWith(rawDataContract);
+
+      expect(decodeProtocolEntityMock).to.have.been.calledOnceWithExactly(
+        serializedDataContract,
+      );
+    });
+
+    it('should throw InvalidDataContractError if the decoding fails with consensus error', async () => {
+      const parsingError = new SerializedObjectParsingError(
+        serializedDataContract,
+        new Error(),
+      );
+
+      decodeProtocolEntityMock.throws(parsingError);
+
+      try {
+        await factory.createFromBuffer(serializedDataContract);
+
+        expect.fail('should throw InvalidDataContractError');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(InvalidDataContractError);
+
+        const [innerError] = e.getErrors();
+        expect(innerError).to.equal(parsingError);
+      }
+    });
+
+    it('should throw an error if decoding fails with any other error', async () => {
+      const parsingError = new Error('Something failed during parsing');
+
+      decodeProtocolEntityMock.throws(parsingError);
+
+      try {
+        await factory.createFromBuffer(serializedDataContract);
+
+        expect.fail('should throw an error');
+      } catch (e) {
+        expect(e).to.equal(parsingError);
+      }
+    });
+  });
+
+  describe('createDataContractCreateTransition', () => {
+    it('should return new DataContractCreateTransition with passed DataContract', () => {
+      const result = factory.createDataContractCreateTransition(dataContract);
+
+      expect(result).to.be.an.instanceOf(DataContractCreateTransition);
+
+      expect(result.getProtocolVersion()).to.equal(protocolVersion.latestVersion);
+      expect(result.getEntropy()).to.deep.equal(dataContract.getEntropy());
+      expect(result.getDataContract().toObject()).to.deep.equal(dataContract.toObject());
+    });
+  });
+});

package/test/unit/dataContract/createDataContract.spec.js

@@ -0,0 +1,57 @@
+const DataContract = require('../../../lib/dataContract/DataContract');
+
+const generateRandomIdentifier = require('../../../lib/test/utils/generateRandomIdentifier');
+
+describe('createDataContract', () => {
+  let rawDataContract;
+
+  beforeEach(() => {
+    rawDataContract = {
+      $id: generateRandomIdentifier().toBuffer(),
+      ownerId: generateRandomIdentifier().toBuffer(),
+      contractId: generateRandomIdentifier().toBuffer(),
+      documents: {
+        niceDocument: {
+          name: { type: 'string' },
+        },
+      },
+    };
+  });
+
+  it('should return new DataContract with "dataContractId" and documents', () => {
+    const dataContract = new DataContract(rawDataContract);
+
+    expect(dataContract).to.be.an.instanceOf(DataContract);
+
+    expect(dataContract.getOwnerId()).to.deep.equal(rawDataContract.ownerId);
+    expect(dataContract.getDocuments()).to.equal(rawDataContract.documents);
+  });
+
+  it('should return new DataContract with "$schema" if present', () => {
+    rawDataContract.$schema = 'http://test.com/schema';
+
+    const dataContract = new DataContract(rawDataContract);
+
+    expect(dataContract).to.be.an.instanceOf(DataContract);
+
+    expect(dataContract.getJsonMetaSchema()).to.equal(rawDataContract.$schema);
+
+    expect(dataContract.getOwnerId()).to.deep.equal(rawDataContract.ownerId);
+    expect(dataContract.getDocuments()).to.equal(rawDataContract.documents);
+  });
+
+  it('should return new DataContract with "$defs" if present', () => {
+    rawDataContract.$defs = {
+      subSchema: { type: 'object' },
+    };
+
+    const dataContract = new DataContract(rawDataContract);
+
+    expect(dataContract).to.be.an.instanceOf(DataContract);
+
+    expect(dataContract.getDefinitions()).to.equal(rawDataContract.$defs);
+
+    expect(dataContract.getOwnerId()).to.deep.equal(rawDataContract.ownerId);
+    expect(dataContract.getDocuments()).to.equal(rawDataContract.documents);
+  });
+});