@dashevo/wasm-dpp 0.24.0-dev.10 → 0.24.0-dev.12

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

@@ -194,13 +194,12 @@ describe('DataContract', () => {
 
   describe('#getDocumentSchema', () => {
     it('should throw error if Document is not defined', () => {
-      let error;
       try {
         dataContract.getDocumentSchema('undefinedObject');
+        expect.fail('Error was not thrown');
       } catch (e) {
-        error = e;
+        expect(e.getDocType()).to.equal('undefinedObject');
       }
-      expect(error.getDocType()).to.equal('undefinedObject');
     });
 
     it('should return Document Schema', () => {
@@ -212,13 +211,12 @@ describe('DataContract', () => {
 
   describe('#getDocumentSchemaRef', () => {
     it('should throw error if Document is not defined', () => {
-      let error;
       try {
         dataContract.getDocumentSchemaRef('undefinedObject');
+        expect.fail('Error was not thrown');
       } catch (e) {
-        error = e;
+        expect(e.getDocType()).to.equal('undefinedObject');
       }
-      expect(error.getDocType()).to.equal('undefinedObject');
     });
 
     it('should return schema ref', () => {
@@ -324,14 +322,12 @@ describe('DataContract', () => {
     });
 
     it('should throw an error if document type is not found', () => {
-      let error;
       try {
         dataContract.getBinaryProperties('unknown');
         expect.fail('Error was not thrown');
       } catch (e) {
-        error = e;
+        expect(e.getDocType()).to.equal('unknown');
       }
-      expect(error.getDocType()).to.equal('unknown');
     });
   });
 

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

@@ -9,6 +9,8 @@ describe('DataContractFactory', () => {
   let DataContractValidator;
   let DataContract;
   let InvalidDataContractError;
+  let SerializedObjectParsingError;
+  let JsonSchemaError;
 
   let factory;
   let jsDataContract;
@@ -17,7 +19,12 @@ describe('DataContractFactory', () => {
 
   before(async () => {
     ({
-      DataContractFactory, DataContractValidator, DataContract, InvalidDataContractError,
+      DataContractFactory,
+      DataContractValidator,
+      DataContract,
+      InvalidDataContractError,
+      SerializedObjectParsingError,
+      JsonSchemaError,
     } = await loadWasmDpp());
   });
 
@@ -73,8 +80,9 @@ describe('DataContractFactory', () => {
         expect(e).to.be.an.instanceOf(InvalidDataContractError);
         expect(e.getRawDataContract()).to.deep.equal(alteredContract);
         expect(e.getErrors()).to.have.length(1);
-        // TODO JsonSchemaError binding type required
-        // const [consensusError] = error.getErrors();
+
+        const [consensusError] = e.getErrors();
+        expect(consensusError).to.be.an.instanceOf(JsonSchemaError);
       }
     });
   });
@@ -99,9 +107,8 @@ describe('DataContractFactory', () => {
         await factory.createFromBuffer(serializedDataContract);
         expect.fail('should throw InvalidDataContractError');
       } catch (e) {
-        // TODO SerializedObjectParsingError binding type required
-        // expect(e).to.be.an.instanceOf(SerializedObjectPasingError);
-        expect(e).to.match(/Parsing of serialized object failed/);
+        expect(e).to.be.an.instanceOf(SerializedObjectParsingError);
+        expect(e.getParsingError()).to.match(/Decode protocol entity/);
       }
     });
   });

package/test/unit/dataContract/errors/InvalidDataContractError.spec.js

@@ -1,9 +1,17 @@
-const InvalidDataContractError = require('@dashevo/dpp/lib/dataContract/errors/InvalidDataContractError');
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
+const { default: loadWasmDpp } = require('../../../../dist');
+
 describe('InvalidDataContractError', () => {
   let rawDataContract;
   let error;
+  let InvalidDataContractError;
+
+  before(async () => {
+    ({
+      InvalidDataContractError,
+    } = await loadWasmDpp());
+  });
 
   beforeEach(() => {
     error = new Error('Some error');
@@ -33,7 +41,7 @@ describe('InvalidDataContractError', () => {
 
     const invalidDataContractError = new InvalidDataContractError(errors, rawDataContract);
 
-    expect(invalidDataContractError.message).to.equal(`Invalid Data Contract: "${error.message}"`);
+    expect(invalidDataContractError.getMessage()).to.equal(`Data contract decode error: "${error.message}"`);
   });
 
   it('should contain message for multiple errors', async () => {
@@ -41,6 +49,6 @@ describe('InvalidDataContractError', () => {
 
     const invalidDataContractError = new InvalidDataContractError(errors, rawDataContract);
 
-    expect(invalidDataContractError.message).to.equal(`Invalid Data Contract: "${error.message}" and 1 more`);
+    expect(invalidDataContractError.getMessage()).to.equal(`Data contract decode error: "${error.message}" and 1 more`);
   });
 });

package/test/unit/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition.spec.js

@@ -1,23 +1,24 @@
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 const stateTransitionTypes = require('@dashevo/dpp/lib/stateTransition/stateTransitionTypes');
 
-const Identifier = require('@dashevo/dpp/lib/identifier/Identifier');
 const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
-const DataContractCreateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
-const hash = require('@dashevo/dpp/lib/util/hash');
-const serializer = require('@dashevo/dpp/lib/util/serializer');
+
+const { default: loadWasmDpp } = require('../../../../../dist');
 
 describe('DataContractCreateTransition', () => {
   let stateTransition;
   let dataContract;
-  let hashMock;
-  let encodeMock;
+  let DataContractCreateTransition;
+  let Identifier;
 
-  beforeEach(function beforeEach() {
-    dataContract = getDataContractFixture();
+  before(async () => {
+    ({
+      DataContractCreateTransition, Identifier,
+    } = await loadWasmDpp());
+  });
 
-    encodeMock = this.sinonSandbox.stub(serializer, 'encode');
-    hashMock = this.sinonSandbox.stub(hash, 'hash');
+  beforeEach(() => {
+    dataContract = getDataContractFixture();
 
     stateTransition = new DataContractCreateTransition({
       protocolVersion: protocolVersion.latestVersion,
@@ -26,11 +27,6 @@ describe('DataContractCreateTransition', () => {
     });
   });
 
-  afterEach(() => {
-    encodeMock.restore();
-    hashMock.restore();
-  });
-
   describe('#getProtocolVersion', () => {
     it('should return the current protocol version', () => {
       const result = stateTransition.getProtocolVersion();
@@ -57,12 +53,10 @@ describe('DataContractCreateTransition', () => {
 
   describe('#toJSON', () => {
     it('should return State Transition as plain JS object', () => {
-      expect(stateTransition.toJSON()).to.deep.equal({
+      expect(stateTransition.toJSON(true)).to.deep.equal({
         protocolVersion: protocolVersion.latestVersion,
         type: stateTransitionTypes.DATA_CONTRACT_CREATE,
         dataContract: dataContract.toJSON(),
-        signaturePublicKeyId: undefined,
-        signature: undefined,
         entropy: dataContract.getEntropy().toString('base64'),
       });
     });
@@ -70,61 +64,20 @@ describe('DataContractCreateTransition', () => {
 
   describe('#toBuffer', () => {
     it('should return serialized State Transition', () => {
-      const serializedStateTransition = Buffer.from('123');
-
-      encodeMock.returns(serializedStateTransition);
-
       const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
+      protocolVersionUInt32.writeUInt32LE(stateTransition.getProtocolVersion(), 0);
 
       const result = stateTransition.toBuffer();
-
-      expect(result).to.deep.equal(
-        Buffer.concat([protocolVersionUInt32, serializedStateTransition]),
-      );
-
-      const dataToEncode = stateTransition.toObject();
-      delete dataToEncode.protocolVersion;
-
-      expect(encodeMock.getCall(0).args).to.have.deep.members([
-        dataToEncode,
-      ]);
-    });
-  });
-
-  describe('#hash', () => {
-    it('should return State Transition hash as hex', () => {
-      const serializedDocument = Buffer.from('123');
-      const hashedDocument = '456';
-
-      encodeMock.returns(serializedDocument);
-      hashMock.returns(hashedDocument);
-
-      const result = stateTransition.hash();
-
-      expect(result).to.equal(hashedDocument);
-
-      const dataToEncode = stateTransition.toObject();
-      delete dataToEncode.protocolVersion;
-
-      expect(encodeMock.getCall(0).args).to.have.deep.members([
-        dataToEncode,
-      ]);
-
-      const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
-
-      expect(hashMock).to.have.been.calledOnceWith(
-        Buffer.concat([protocolVersionUInt32, serializedDocument]),
-      );
+      expect(result.compare(protocolVersionUInt32, 0, 4, 0, 4)).equals(0);
     });
   });
 
   describe('#getOwnerId', () => {
     it('should return owner id', async () => {
       const result = stateTransition.getOwnerId();
+      const reference = stateTransition.getDataContract().getOwnerId();
 
-      expect(result).to.equal(stateTransition.getDataContract().getOwnerId());
+      expect(result.toBuffer()).to.deep.equal(reference.toBuffer());
     });
   });
 
@@ -136,7 +89,7 @@ describe('DataContractCreateTransition', () => {
       const contractId = result[0];
 
       expect(contractId).to.be.an.instanceOf(Identifier);
-      expect(contractId).to.be.deep.equal(dataContract.getId());
+      expect(contractId.toBuffer()).to.be.deep.equal(dataContract.getId().toBuffer());
     });
   });
 

package/test/unit/dataContract/stateTransition/DataContractCreateTransition/applyDataContractCreateTransitionFactory.spec.js

@@ -1,27 +1,33 @@
-const DataContractCreateTransition = require(
-  '@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition',
-);
-
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
-const applyDataContractCreateTransitionFactory = require(
-  '@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/applyDataContractCreateTransitionFactory',
-);
+const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
 
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
+const { default: loadWasmDpp } = require('../../../../../dist');
 
 describe('applyDataContractCreateTransitionFactory', () => {
   let stateTransition;
   let dataContract;
-  let stateRepositoryMock;
-  let applyDataContractCreateTransition;
+  let factory;
   let executionContext;
+  let DataContractCreateTransition;
+  let ApplyDataContractCreateTransition;
+  let StateTransitionExecutionContext;
+
+  let dataContractStored;
+
+  before(async () => {
+    ({
+      DataContractCreateTransition,
+      ApplyDataContractCreateTransition,
+      StateTransitionExecutionContext,
+    } = await loadWasmDpp());
+  });
 
-  beforeEach(function beforeEach() {
+  beforeEach(() => {
     dataContract = getDataContractFixture();
 
     stateTransition = new DataContractCreateTransition({
+      protocolVersion: protocolVersion.latestVersion,
       dataContract: dataContract.toObject(),
       entropy: Buffer.alloc(32),
     });
@@ -30,19 +36,19 @@ describe('applyDataContractCreateTransitionFactory', () => {
 
     stateTransition.setExecutionContext(executionContext);
 
-    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    const stateRepositoryLike = {
+      storeDataContract: () => {
+        dataContractStored = true;
+      },
+    };
 
-    applyDataContractCreateTransition = applyDataContractCreateTransitionFactory(
-      stateRepositoryMock,
-    );
+    factory = new ApplyDataContractCreateTransition(stateRepositoryLike);
+
+    dataContractStored = false;
   });
 
   it('should store a data contract from state transition in the repository', async () => {
-    await applyDataContractCreateTransition(stateTransition);
-
-    expect(stateRepositoryMock.createDataContract).to.have.been.calledOnceWithExactly(
-      stateTransition.getDataContract(),
-      executionContext,
-    );
+    await factory.applyDataContractCreateTransition(stateTransition);
+    expect(dataContractStored).to.be.true();
   });
 });

package/test/unit/dataContract/stateTransition/DataContractCreateTransition/validation/state/validateDataContractCreateTransitionStateFactory.spec.js

@@ -1,28 +1,36 @@
-const validateDataContractCreateTransitionStateFactory = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/validation/state/validateDataContractCreateTransitionStateFactory');
-const DataContractCreateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
-
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
+const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
 
-const { expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
-
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
-
-const DataContractAlreadyPresentError = require('@dashevo/dpp/lib/errors/consensus/state/dataContract/DataContractAlreadyPresentError');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
+const { default: loadWasmDpp } = require('../../../../../../../dist');
 
 describe('validateDataContractCreateTransitionStateFactory', () => {
   let validateDataContractCreateTransitionState;
   let dataContract;
   let stateTransition;
-  let stateRepositoryMock;
   let executionContext;
+  let ValidationResult;
+  let DataContractCreateTransition;
+  let StateTransitionExecutionContext;
+  let factory;
+  let dataContractFetched;
+  let DataContractFactory;
+  let DataContractValidator;
+
+  before(async () => {
+    ({
+      DataContractCreateTransition,
+      StateTransitionExecutionContext,
+      validateDataContractCreateTransitionState,
+      ValidationResult,
+      DataContractFactory,
+      DataContractValidator,
+    } = await loadWasmDpp());
+  });
 
-  beforeEach(function beforeEach() {
-    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-
+  beforeEach(() => {
     dataContract = getDataContractFixture();
     stateTransition = new DataContractCreateTransition({
+      protocolVersion: protocolVersion.latestVersion,
       dataContract: dataContract.toObject(),
       entropy: dataContract.getEntropy(),
     });
@@ -31,55 +39,54 @@ describe('validateDataContractCreateTransitionStateFactory', () => {
 
     stateTransition.setExecutionContext(executionContext);
 
-    validateDataContractCreateTransitionState = validateDataContractCreateTransitionStateFactory(
-      stateRepositoryMock,
-    );
-  });
+    dataContractFetched = false;
 
-  it('should return invalid result if Data Contract with specified contractId is already exist', async () => {
-    stateRepositoryMock.fetchDataContract.resolves(dataContract);
+    const stateRepositoryLike = {
+      fetchDataContract: () => {
+        dataContractFetched = true;
+      },
+    };
 
-    const result = await validateDataContractCreateTransitionState(stateTransition);
+    factory = (t) => validateDataContractCreateTransitionState(stateRepositoryLike, t);
+  });
 
-    expectValidationError(result, DataContractAlreadyPresentError);
+  it('should return invalid result if Data Contract is already exist', async () => {
+    // This time our state repository should return a data contract on fetch
+    const validator = new DataContractValidator();
+    const dataContractFactory = new DataContractFactory(1, validator);
+    const wasmDataContract = await dataContractFactory.createFromBuffer(dataContract.toBuffer());
 
+    const stateRepositoryLikeWithContract = {
+      fetchDataContract: () => wasmDataContract,
+    };
+
+    const result = await validateDataContractCreateTransitionState(
+      stateRepositoryLikeWithContract,
+      stateTransition,
+    );
     const [error] = result.getErrors();
 
     expect(error.getCode()).to.equal(4000);
-    expect(Buffer.isBuffer(error.getDataContractId())).to.be.true();
     expect(error.getDataContractId()).to.deep.equal(dataContract.getId().toBuffer());
-
-    expect(stateRepositoryMock.fetchDataContract).to.be.calledOnceWithExactly(
-      dataContract.getId(),
-      executionContext,
-    );
   });
 
   it('should return valid result', async () => {
-    const result = await validateDataContractCreateTransitionState(stateTransition);
+    const result = await factory(stateTransition);
+
+    expect(dataContractFetched).to.be.true();
 
     expect(result).to.be.an.instanceOf(ValidationResult);
     expect(result.isValid()).to.be.true();
-
-    expect(stateRepositoryMock.fetchDataContract).to.be.calledOnceWithExactly(
-      dataContract.getId(),
-      executionContext,
-    );
   });
 
   it('should return valid result on dry run', async () => {
-    stateRepositoryMock.fetchDataContract.resolves(dataContract);
-
     executionContext.enableDryRun();
-    const result = await validateDataContractCreateTransitionState(stateTransition);
+    const result = await factory(stateTransition);
     executionContext.disableDryRun();
 
+    expect(dataContractFetched).to.be.true();
+
     expect(result).to.be.an.instanceOf(ValidationResult);
     expect(result.isValid()).to.be.true();
-
-    expect(stateRepositoryMock.fetchDataContract).to.be.calledOnceWithExactly(
-      dataContract.getId(),
-      executionContext,
-    );
   });
 });

package/test/unit/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition.spec.js

@@ -1,23 +1,24 @@
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 const stateTransitionTypes = require('@dashevo/dpp/lib/stateTransition/stateTransitionTypes');
-
-const Identifier = require('@dashevo/dpp/lib/identifier/Identifier');
 const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
-const DataContractUpdateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition');
-const hash = require('@dashevo/dpp/lib/util/hash');
-const serializer = require('@dashevo/dpp/lib/util/serializer');
+const JsDataContractUpdateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition');
+
+const { default: loadWasmDpp } = require('../../../../../dist');
 
 describe('DataContractUpdateTransition', () => {
   let stateTransition;
   let dataContract;
-  let hashMock;
-  let encodeMock;
+  let DataContractUpdateTransition;
+  let Identifier;
 
-  beforeEach(function beforeEach() {
-    dataContract = getDataContractFixture();
+  before(async () => {
+    ({
+      DataContractUpdateTransition, Identifier,
+    } = await loadWasmDpp());
+  });
 
-    encodeMock = this.sinonSandbox.stub(serializer, 'encode');
-    hashMock = this.sinonSandbox.stub(hash, 'hash');
+  beforeEach(() => {
+    dataContract = getDataContractFixture();
 
     stateTransition = new DataContractUpdateTransition({
       protocolVersion: protocolVersion.latestVersion,
@@ -25,11 +26,6 @@ describe('DataContractUpdateTransition', () => {
     });
   });
 
-  afterEach(() => {
-    encodeMock.restore();
-    hashMock.restore();
-  });
-
   describe('#getProtocolVersion', () => {
     it('should return the current protocol version', () => {
       const result = stateTransition.getProtocolVersion();
@@ -56,73 +52,41 @@ describe('DataContractUpdateTransition', () => {
 
   describe('#toJSON', () => {
     it('should return State Transition as plain JS object', () => {
-      expect(stateTransition.toJSON()).to.deep.equal({
+      expect(stateTransition.toJSON(true)).to.deep.equal({
         protocolVersion: protocolVersion.latestVersion,
         type: stateTransitionTypes.DATA_CONTRACT_UPDATE,
         dataContract: dataContract.toJSON(),
-        signaturePublicKeyId: undefined,
-        signature: undefined,
       });
     });
   });
 
   describe('#toBuffer', () => {
-    it('should return serialized State Transition', () => {
-      const serializedStateTransition = Buffer.from('123');
-
-      encodeMock.returns(serializedStateTransition);
-
+    it('should return serialized State Transition that starts with protocol version', () => {
       const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
+      protocolVersionUInt32.writeUInt32LE(stateTransition.getProtocolVersion(), 0);
 
       const result = stateTransition.toBuffer();
-
-      expect(result).to.deep.equal(
-        Buffer.concat([protocolVersionUInt32, serializedStateTransition]),
-      );
-
-      const dataToEncode = stateTransition.toObject();
-      delete dataToEncode.protocolVersion;
-
-      expect(encodeMock.getCall(0).args).to.have.deep.members([
-        dataToEncode,
-      ]);
+      expect(result.compare(protocolVersionUInt32, 0, 4, 0, 4)).equals(0);
     });
   });
 
-  describe('#hash', () => {
+  describe.skip('#hash', () => {
     it('should return State Transition hash as hex', () => {
-      const serializedDocument = Buffer.from('123');
-      const hashedDocument = '456';
-
-      encodeMock.returns(serializedDocument);
-      hashMock.returns(hashedDocument);
+      const jsStateTransition = new JsDataContractUpdateTransition(stateTransition.toJSON());
 
       const result = stateTransition.hash();
+      const resultJs = jsStateTransition.hash();
 
-      expect(result).to.equal(hashedDocument);
-
-      const dataToEncode = stateTransition.toObject();
-      delete dataToEncode.protocolVersion;
-
-      expect(encodeMock.getCall(0).args).to.have.deep.members([
-        dataToEncode,
-      ]);
-
-      const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
-
-      expect(hashMock).to.have.been.calledOnceWith(
-        Buffer.concat([protocolVersionUInt32, serializedDocument]),
-      );
+      expect(result).to.equal(resultJs);
     });
   });
 
   describe('#getOwnerId', () => {
     it('should return owner id', async () => {
       const result = stateTransition.getOwnerId();
+      const reference = stateTransition.getDataContract().getOwnerId();
 
-      expect(result).to.equal(stateTransition.getDataContract().getOwnerId());
+      expect(result.toBuffer()).to.deep.equal(reference.toBuffer());
     });
   });
 
@@ -134,7 +98,7 @@ describe('DataContractUpdateTransition', () => {
       const contractId = result[0];
 
       expect(contractId).to.be.an.instanceOf(Identifier);
-      expect(contractId).to.be.deep.equal(dataContract.getId());
+      expect(contractId.toBuffer()).to.be.deep.equal(dataContract.getId().toBuffer());
     });
   });