@dashevo/wasm-dpp 0.24.0-dev.11 → 0.24.0-dev.13

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.getType()).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.getType()).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.getType()).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/createDataContract.spec.js

@@ -16,7 +16,6 @@ describe('createDataContract', () => {
     rawDataContract = {
       $id: generateRandomIdentifier().toBuffer(),
       ownerId: generateRandomIdentifier().toBuffer(),
-      contractId: generateRandomIdentifier().toBuffer(),
       protocolVersion: 4,
       version: 20,
       $schema: 'http://test.com/schema',

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,3 +1,4 @@
+const varint = require('varint');
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 const stateTransitionTypes = require('@dashevo/dpp/lib/stateTransition/stateTransitionTypes');
 
@@ -64,11 +65,10 @@ describe('DataContractCreateTransition', () => {
 
   describe('#toBuffer', () => {
     it('should return serialized State Transition', () => {
-      const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(stateTransition.getProtocolVersion(), 0);
+      const protocolVersionBytes = Buffer.from(varint.encode(stateTransition.getProtocolVersion()));
 
       const result = stateTransition.toBuffer();
-      expect(result.compare(protocolVersionUInt32, 0, 4, 0, 4)).equals(0);
+      expect(result.compare(protocolVersionBytes, 0, 1, 0, 1)).equals(0);
     });
   });
 

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

@@ -13,6 +13,8 @@ describe('validateDataContractCreateTransitionStateFactory', () => {
   let StateTransitionExecutionContext;
   let factory;
   let dataContractFetched;
+  let DataContractFactory;
+  let DataContractValidator;
 
   before(async () => {
     ({
@@ -20,6 +22,8 @@ describe('validateDataContractCreateTransitionStateFactory', () => {
       StateTransitionExecutionContext,
       validateDataContractCreateTransitionState,
       ValidationResult,
+      DataContractFactory,
+      DataContractValidator,
     } = await loadWasmDpp());
   });
 
@@ -46,25 +50,25 @@ describe('validateDataContractCreateTransitionStateFactory', () => {
     factory = (t) => validateDataContractCreateTransitionState(stateRepositoryLike, t);
   });
 
-  // TODO wait for error types
-  // it('should return invalid result if Data Contract is already exist', async () => {
-  //   stateRepositoryMock.fetchDataContract.resolves(dataContract);
+  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 result = await validateDataContractCreateTransitionState(stateTransition);
-
-  //   expectValidationError(result, DataContractAlreadyPresentError);
-
-  //   const [error] = result.getErrors();
+    const stateRepositoryLikeWithContract = {
+      fetchDataContract: () => wasmDataContract,
+    };
 
-  //   expect(error.getCode()).to.equal(4000);
-  //   expect(Buffer.isBuffer(error.getDataContractId())).to.be.true();
-  //   expect(error.getDataContractId()).to.deep.equal(dataContract.getId().toBuffer());
+    const result = await validateDataContractCreateTransitionState(
+      stateRepositoryLikeWithContract,
+      stateTransition,
+    );
+    const [error] = result.getErrors();
 
-  //   expect(stateRepositoryMock.fetchDataContract).to.be.calledOnceWithExactly(
-  //     dataContract.getId(),
-  //     executionContext,
-  //   );
-  // });
+    expect(error.getCode()).to.equal(4000);
+    expect(error.getDataContractId()).to.deep.equal(dataContract.getId().toBuffer());
+  });
 
   it('should return valid result', async () => {
     const result = await factory(stateTransition);

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

@@ -1,23 +1,25 @@
+const varint = require('varint');
 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 +27,6 @@ describe('DataContractUpdateTransition', () => {
     });
   });
 
-  afterEach(() => {
-    encodeMock.restore();
-    hashMock.restore();
-  });
-
   describe('#getProtocolVersion', () => {
     it('should return the current protocol version', () => {
       const result = stateTransition.getProtocolVersion();
@@ -56,73 +53,40 @@ 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);
-
-      const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
+    it('should return serialized State Transition that starts with protocol version', () => {
+      const protocolVersionBytes = Buffer.from(varint.encode(stateTransition.getProtocolVersion()));
 
       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(protocolVersionBytes, 0, 1, 0, 1)).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());
     });
   });
 

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

@@ -1,47 +1,51 @@
-const DataContractUpdateTransition = require(
-  '@dashevo/dpp/lib/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition',
-);
-
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
+const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
 
-const applyDataContractUpdateTransitionFactory = require(
-  '@dashevo/dpp/lib/dataContract/stateTransition/DataContractUpdateTransition/applyDataContractUpdateTransitionFactory',
-);
-
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
+const { default: loadWasmDpp } = require('../../../../../dist');
 
 describe('applyDataContractUpdateTransitionFactory', () => {
   let stateTransition;
   let dataContract;
-  let stateRepositoryMock;
-  let applyDataContractUpdateTransition;
   let executionContext;
+  let dataContractStored;
+  let factory;
+  let DataContractUpdateTransition;
+  let ApplyDataContractUpdateTransition;
+  let StateTransitionExecutionContext;
+
+  before(async () => {
+    ({
+      DataContractUpdateTransition,
+      ApplyDataContractUpdateTransition,
+      StateTransitionExecutionContext,
+    } = await loadWasmDpp());
+  });
 
-  beforeEach(function beforeEach() {
+  beforeEach(() => {
     dataContract = getDataContractFixture();
 
     stateTransition = new DataContractUpdateTransition({
       dataContract: dataContract.toObject(),
+      protocolVersion: protocolVersion.latestVersion,
     });
 
     executionContext = new StateTransitionExecutionContext();
 
     stateTransition.setExecutionContext(executionContext);
 
-    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    const stateRepositoryLike = {
+      storeDataContract: () => {
+        dataContractStored = true;
+      },
+    };
 
-    applyDataContractUpdateTransition = applyDataContractUpdateTransitionFactory(
-      stateRepositoryMock,
-    );
+    factory = new ApplyDataContractUpdateTransition(stateRepositoryLike);
+
+    dataContractStored = false;
   });
 
   it('should store a data contract from state transition in the repository', async () => {
-    await applyDataContractUpdateTransition(stateTransition);
-
-    expect(stateRepositoryMock.updateDataContract).to.have.been.calledOnceWithExactly(
-      stateTransition.getDataContract(),
-      executionContext,
-    );
+    await factory.applyDataContractUpdateTransition(stateTransition);
+    expect(dataContractStored).to.be.true();
   });
 });

package/test/unit/dataContract/stateTransition/DataContractUpdateTransition/validation/basic/validateIndicesAreBackwardCompatible.spec.js

@@ -1,13 +1,23 @@
-const validateIndicesAreBackwardCompatible = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractUpdateTransition/validation/basic/validateIndicesAreBackwardCompatible');
-const DataContractHaveNewIndexWithOldPropertiesError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/DataContractInvalidIndexDefinitionUpdateError');
-const DataContractHaveNewUniqueIndexError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/DataContractHaveNewUniqueIndexError');
-const DataContractIndicesChangedError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/DataContractUniqueIndicesChangedError');
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
-const DataContractInvalidIndexDefinitionUpdateError = require('@dashevo/dpp/lib/errors/consensus/basic/dataContract/DataContractInvalidIndexDefinitionUpdateError');
+
+const { default: loadWasmDpp } = require('../../../../../../../dist');
 
 describe('validateIndicesAreBackwardCompatible', () => {
   let oldDocumentsSchema;
   let newDocumentsSchema;
+  let validateIndicesAreBackwardCompatible;
+  let DataContractUniqueIndicesChangedError;
+  let DataContractInvalidIndexDefinitionUpdateError;
+  let DataContractHaveNewUniqueIndexError;
+
+  before(async () => {
+    ({
+      validateIndicesAreBackwardCompatible,
+      DataContractUniqueIndicesChangedError,
+      DataContractInvalidIndexDefinitionUpdateError,
+      DataContractHaveNewUniqueIndexError,
+    } = await loadWasmDpp());
+  });
 
   beforeEach(() => {
     const oldDataContract = getDataContractFixture();
@@ -37,20 +47,19 @@ describe('validateIndicesAreBackwardCompatible', () => {
   });
 
   it('should return invalid result if some of unique indices have changed', async () => {
-    newDocumentsSchema.indexedDocument.indices[0].properties[0].lastName = 'asc';
-
+    newDocumentsSchema.indexedDocument.indices[0].properties[1].firstName = 'desc';
     const result = validateIndicesAreBackwardCompatible(oldDocumentsSchema, newDocumentsSchema);
 
     expect(result.isValid()).to.be.false();
 
     const error = result.getErrors()[0];
 
-    expect(error).to.be.an.instanceOf(DataContractIndicesChangedError);
+    expect(error).to.be.an.instanceOf(DataContractUniqueIndicesChangedError);
     expect(error.getIndexName()).to.equal(newDocumentsSchema.indexedDocument.indices[0].name);
   });
 
   it('should return invalid result if non-unique index update failed due to changed old properties', async () => {
-    newDocumentsSchema.indexedDocument.indices[2].properties[0].$id = 'asc';
+    newDocumentsSchema.indexedDocument.indices[2].properties[0].lastName = 'desc';
 
     const result = validateIndicesAreBackwardCompatible(oldDocumentsSchema, newDocumentsSchema);
 
@@ -63,7 +72,14 @@ describe('validateIndicesAreBackwardCompatible', () => {
   });
 
   it('should return invalid result if non-unique index update failed due old properties used', async () => {
-    newDocumentsSchema.indexedDocument.indices[2].properties.push({ firstName: 'asc' });
+    newDocumentsSchema.indexedDocument.indices.push({
+      name: 'oldFieldIndex',
+      properties: [
+        {
+          otherProperty: 'asc',
+        },
+      ],
+    });
 
     const result = validateIndicesAreBackwardCompatible(oldDocumentsSchema, newDocumentsSchema);
 
@@ -72,7 +88,7 @@ describe('validateIndicesAreBackwardCompatible', () => {
     const error = result.getErrors()[0];
 
     expect(error).to.be.an.instanceOf(DataContractInvalidIndexDefinitionUpdateError);
-    expect(error.getIndexName()).to.equal(newDocumentsSchema.indexedDocument.indices[2].name);
+    expect(error.getIndexName()).to.equal('oldFieldIndex');
   });
 
   it('should return invalid result if one of new indices contains old properties in the wrong order', async () => {
@@ -90,7 +106,8 @@ describe('validateIndicesAreBackwardCompatible', () => {
 
     const error = result.getErrors()[0];
 
-    expect(error).to.be.an.instanceOf(DataContractHaveNewIndexWithOldPropertiesError);
+    // TODO
+    // expect(error).to.be.an.instanceOf(DataContractHaveNewIndexWithOldPropertiesError);
     expect(error.getIndexName()).to.equal('index_other');
   });