@dashevo/wasm-dpp 0.23.0-dev.15 → 0.24.0-dev.11

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

@@ -1,178 +1,122 @@
-const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
-const protocolVersion = require('../../../lib/version/protocolVersion');
+const protocolVersion = require('@dashevo/dpp/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');
+const { default: loadWasmDpp } = require('../../../dist');
 
 describe('DataContractFactory', () => {
-  let decodeProtocolEntityMock;
-  let validateDataContractMock;
+  let DataContractFactory;
+  let DataContractValidator;
+  let DataContract;
+  let InvalidDataContractError;
+
   let factory;
-  let dataContract;
+  let jsDataContract;
   let rawDataContract;
-  let generateEntropyMock;
-  let dppMock;
+  let dataContractValidator;
+
+  before(async () => {
+    ({
+      DataContractFactory, DataContractValidator, DataContract, InvalidDataContractError,
+    } = await loadWasmDpp());
+  });
 
-  beforeEach(function beforeEach() {
-    dataContract = getDataContractFixture();
-    dppMock = createDPPMock();
+  beforeEach(() => {
+    jsDataContract = getDataContractFixture();
 
-    rawDataContract = dataContract.toObject();
+    // For some reason fixture has empty $defs which violates meta schema
+    delete jsDataContract.$defs;
 
-    decodeProtocolEntityMock = this.sinonSandbox.stub();
-    validateDataContractMock = this.sinonSandbox.stub();
-    generateEntropyMock = this.sinonSandbox.stub(entropyGenerator, 'generate');
+    rawDataContract = jsDataContract.toObject();
+
+    dataContractValidator = new DataContractValidator();
 
     factory = new DataContractFactory(
-      dppMock,
-      validateDataContractMock,
-      decodeProtocolEntityMock,
+      1,
+      dataContractValidator,
     );
   });
 
-  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(),
+        jsDataContract.ownerId.toBuffer(),
         rawDataContract.documents,
-      );
+      ).toObject();
 
-      expect(result).excluding('$defs').to.deep.equal(dataContract);
+      expect(result).excluding('$id').to.deep.equal(rawDataContract);
     });
   });
 
   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 });
+      const alteredContract = jsDataContract.toObject();
+      alteredContract.$defs = {}; // Empty defs are bad!
 
-      expect(result.toObject()).excluding('entropy').to.deep.equal(rawDataContract);
+      const resultSkipValidation = await factory.createFromObject(alteredContract, true);
 
-      expect(validateDataContractMock).to.have.not.been.called();
+      expect(resultSkipValidation.toObject()).excluding('entropy').to.deep.equal(alteredContract);
     });
 
     it('should throw an error if passed object is not valid', async () => {
-      const validationError = new SomeConsensusError('test');
-
-      validateDataContractMock.returns(new ValidationResult([validationError]));
+      const alteredContract = jsDataContract.toObject();
+      alteredContract.$defs = {}; // Empty defs are bad!
 
-      let error;
       try {
-        await factory.createFromObject(rawDataContract);
+        await factory.createFromObject(alteredContract);
       } catch (e) {
-        error = e;
+        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();
       }
-
-      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();
+    beforeEach(() => {
+      serializedDataContract = jsDataContract.toBuffer();
     });
 
     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,
-      );
+      expect(result.toObject()).to.deep.equal(jsDataContract.toObject());
     });
 
     it('should throw InvalidDataContractError if the decoding fails with consensus error', async () => {
-      const parsingError = new SerializedObjectParsingError(
-        serializedDataContract,
-        new Error(),
-      );
-
-      decodeProtocolEntityMock.throws(parsingError);
-
       try {
+        // Casually break serialized data contract:
+        serializedDataContract[5] += 1337;
         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);
+        // TODO SerializedObjectParsingError binding type required
+        // expect(e).to.be.an.instanceOf(SerializedObjectPasingError);
+        expect(e).to.match(/Parsing of serialized object failed/);
       }
     });
   });
 
   describe('createDataContractCreateTransition', () => {
-    it('should return new DataContractCreateTransition with passed DataContract', () => {
-      const result = factory.createDataContractCreateTransition(dataContract);
+    it('should return new DataContractCreateTransition with passed DataContract', async () => {
+      // Create wasm version of DataContract
+      const dataContract = new DataContract(rawDataContract);
+      dataContract.setEntropy(jsDataContract.getEntropy());
 
-      expect(result).to.be.an.instanceOf(DataContractCreateTransition);
+      const result = await factory.createDataContractCreateTransition(dataContract);
 
       expect(result.getProtocolVersion()).to.equal(protocolVersion.latestVersion);
-      expect(result.getEntropy()).to.deep.equal(dataContract.getEntropy());
-      expect(result.getDataContract().toObject()).to.deep.equal(dataContract.toObject());
+      expect(result.getEntropy()).to.deep.equal(jsDataContract.getEntropy());
+      expect(result.getDataContract().toObject()).to.deep.equal(jsDataContract.toObject());
     });
   });
 });

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

@@ -1,15 +1,25 @@
-const DataContract = require('../../../lib/dataContract/DataContract');
+const generateRandomIdentifier = require('@dashevo/dpp/lib/test/utils/generateRandomIdentifier');
 
-const generateRandomIdentifier = require('../../../lib/test/utils/generateRandomIdentifier');
+const { default: loadWasmDpp } = require('../../../dist');
 
 describe('createDataContract', () => {
   let rawDataContract;
+  let DataContract;
+
+  before(async () => {
+    ({
+      DataContract,
+    } = await loadWasmDpp());
+  });
 
   beforeEach(() => {
     rawDataContract = {
       $id: generateRandomIdentifier().toBuffer(),
       ownerId: generateRandomIdentifier().toBuffer(),
       contractId: generateRandomIdentifier().toBuffer(),
+      protocolVersion: 4,
+      version: 20,
+      $schema: 'http://test.com/schema',
       documents: {
         niceDocument: {
           name: { type: 'string' },
@@ -23,12 +33,12 @@ describe('createDataContract', () => {
 
     expect(dataContract).to.be.an.instanceOf(DataContract);
 
-    expect(dataContract.getOwnerId()).to.deep.equal(rawDataContract.ownerId);
-    expect(dataContract.getDocuments()).to.equal(rawDataContract.documents);
+    expect(dataContract.getOwnerId().toBuffer()).to.deep.equal(rawDataContract.ownerId);
+    expect(dataContract.getDocuments()).to.deep.equal(rawDataContract.documents);
   });
 
   it('should return new DataContract with "$schema" if present', () => {
-    rawDataContract.$schema = 'http://test.com/schema';
+    rawDataContract.$schema = 'http://test.com/otherschema';
 
     const dataContract = new DataContract(rawDataContract);
 
@@ -36,8 +46,8 @@ describe('createDataContract', () => {
 
     expect(dataContract.getJsonMetaSchema()).to.equal(rawDataContract.$schema);
 
-    expect(dataContract.getOwnerId()).to.deep.equal(rawDataContract.ownerId);
-    expect(dataContract.getDocuments()).to.equal(rawDataContract.documents);
+    expect(dataContract.getOwnerId().toBuffer()).to.deep.equal(rawDataContract.ownerId);
+    expect(dataContract.getDocuments()).to.deep.equal(rawDataContract.documents);
   });
 
   it('should return new DataContract with "$defs" if present', () => {
@@ -49,9 +59,9 @@ describe('createDataContract', () => {
 
     expect(dataContract).to.be.an.instanceOf(DataContract);
 
-    expect(dataContract.getDefinitions()).to.equal(rawDataContract.$defs);
+    expect(dataContract.getDefinitions()).to.deep.equal(rawDataContract.$defs);
 
-    expect(dataContract.getOwnerId()).to.deep.equal(rawDataContract.ownerId);
-    expect(dataContract.getDocuments()).to.equal(rawDataContract.documents);
+    expect(dataContract.getOwnerId().toBuffer()).to.deep.equal(rawDataContract.ownerId);
+    expect(dataContract.getDocuments()).to.deep.equal(rawDataContract.documents);
   });
 });

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

@@ -1,5 +1,5 @@
-const InvalidDataContractError = require('../../../../lib/dataContract/errors/InvalidDataContractError');
-const getDataContractFixture = require('../../../../lib/test/fixtures/getDataContractFixture');
+const InvalidDataContractError = require('@dashevo/dpp/lib/dataContract/errors/InvalidDataContractError');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
 describe('InvalidDataContractError', () => {
   let rawDataContract;

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

@@ -1,19 +1,36 @@
 const bs58 = require('bs58');
-const generateDataContractId = require('../../../lib/dataContract/generateDataContractId');
+
+const { default: loadWasmDpp } = require('../../../dist');
 
 describe('generateDataContractId', () => {
   let ownerId;
   let entropy;
+  let DataContractFactory;
+  let DataContractValidator;
+
+  before(async () => {
+    ({
+      DataContractFactory, DataContractValidator,
+    } = await loadWasmDpp());
+  });
 
   beforeEach(() => {
-    ownerId = bs58.decode('23wdhodag');
-    entropy = bs58.decode('5dz916pTe1');
+    ownerId = bs58.decode('4Sr8EZ9BjQpMpBX5PLPxfvv5crTERSWBnRJXxUmCcrCQ');
+    entropy = bs58.decode('85NSrhBXYJAwzj8rDXuYhPQZPyg67diKSNcfhfnVhKnT');
   });
 
   it('should generate bs58 id based on ', () => {
-    const id = bs58.decode('CnS7cz4z1qoPsNfEgpgyVnKdtH2u7bgzZXHLcCQt24US');
-    const generatedId = generateDataContractId(ownerId, entropy);
+    const id = bs58.decode('8W4qubpTaFKEWHqr9vAFSNGFULnz2TbgbG4eUik7yWx2');
+
+    const entropyGenerator = {
+      generate() {
+        return entropy;
+      },
+    };
+
+    const factory = new DataContractFactory(1337, new DataContractValidator(), entropyGenerator);
+    const dataContract = factory.create(ownerId, {});
 
-    expect(Buffer.compare(id, generatedId)).to.equal(0);
+    expect(Buffer.compare(id, dataContract.getId().toBuffer())).to.equal(0);
   });
 });

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

@@ -1,5 +1,5 @@
 const { getBinaryPropertiesFromSchema } = require(
-  '../../../lib/dataContract/getBinaryPropertiesFromSchema',
+  '@dashevo/dpp/lib/dataContract/getBinaryPropertiesFromSchema',
 );
 
 describe('getBinaryPropertiesFromSchema', () => {

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

@@ -1,5 +1,5 @@
 const getPropertyDefinitionByPath = require(
-  '../../../lib/dataContract/getPropertyDefinitionByPath',
+  '@dashevo/dpp/lib/dataContract/getPropertyDefinitionByPath',
 );
 
 describe('getPropertyDefinitionByPath', () => {

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

@@ -1,23 +1,24 @@
-const getDataContractFixture = require('../../../../../lib/test/fixtures/getDataContractFixture');
-const stateTransitionTypes = require('../../../../../lib/stateTransition/stateTransitionTypes');
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
+const stateTransitionTypes = require('@dashevo/dpp/lib/stateTransition/stateTransitionTypes');
 
-const Identifier = require('../../../../../lib/identifier/Identifier');
-const protocolVersion = require('../../../../../lib/version/protocolVersion');
-const DataContractCreateTransition = require('../../../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
-const hash = require('../../../../../lib/util/hash');
-const serializer = require('../../../../../lib/util/serializer');
+const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
+
+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(
-  '../../../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition',
-);
+const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
-const getDataContractFixture = require('../../../../../lib/test/fixtures/getDataContractFixture');
+const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
 
-const applyDataContractCreateTransitionFactory = require(
-  '../../../../../lib/dataContract/stateTransition/DataContractCreateTransition/applyDataContractCreateTransitionFactory',
-);
-
-const createStateRepositoryMock = require('../../../../../lib/test/mocks/createStateRepositoryMock');
-const StateTransitionExecutionContext = require('../../../../../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.storeDataContract).to.have.been.calledOnceWithExactly(
-      stateTransition.getDataContract(),
-      executionContext,
-    );
+    await factory.applyDataContractCreateTransition(stateTransition);
+    expect(dataContractStored).to.be.true();
   });
 });