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

package/test/unit/document/stateTransition/DocumetsBatchTransition/DocumentsBatchTransition.spec.js

@@ -3,36 +3,65 @@ const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocuments
 const stateTransitionTypes = require('@dashevo/dpp/lib/stateTransition/stateTransitionTypes');
 const createDPPMock = require('@dashevo/dpp/lib/test/mocks/createDPPMock');
 const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
-const DocumentFactory = require('@dashevo/dpp/lib/document/DocumentFactory');
-const serializer = require('@dashevo/dpp/lib/util/serializer');
-const hash = require('@dashevo/dpp/lib/util/hash');
+const DocumentFactoryJs = require('@dashevo/dpp/lib/document/DocumentFactory');
+const { default: loadWasmDpp } = require('../../../../../dist');
+
+let DocumentFactory;
+let DataContract;
+let Document;
+let DocumentValidator;
+let ProtocolVersionValidator;
 
 describe('DocumentsBatchTransition', () => {
+  let stateTransitionJs;
   let stateTransition;
+  let documentsJs;
   let documents;
-  let hashMock;
-  let encodeMock;
+  let dataContractJs;
   let dataContract;
+  let factoryJs;
+
+  beforeEach(async () => {
+    ({
+      ProtocolVersionValidator, DocumentValidator, DocumentFactory, DataContract,
+      Document,
+    } = await loadWasmDpp());
+  });
 
-  beforeEach(function beforeEach() {
-    dataContract = getDataContractFixture();
-    documents = getDocumentsFixture(dataContract);
+  beforeEach(async () => {
+    dataContractJs = getDataContractFixture();
+    dataContract = DataContract.fromBuffer(dataContractJs.toBuffer());
+
+    documentsJs = getDocumentsFixture(dataContractJs);
+    documents = documentsJs.map((d) => {
+      const doc = new Document(d.toObject(), dataContract);
+      doc.setEntropy(d.entropy);
+      return doc;
+    });
 
-    encodeMock = this.sinonSandbox.stub(serializer, 'encode');
-    hashMock = this.sinonSandbox.stub(hash, 'hash');
+    const protocolVersionValidatorRs = new ProtocolVersionValidator();
+    const documentValidatorRs = new DocumentValidator(protocolVersionValidatorRs);
+    const factory = new DocumentFactory(1, documentValidatorRs, {});
+    factoryJs = new DocumentFactoryJs(createDPPMock(), undefined, undefined);
+
+    stateTransitionJs = factoryJs.createStateTransition({
+      create: documentsJs,
+    });
 
-    const factory = new DocumentFactory(createDPPMock(), undefined, undefined);
     stateTransition = factory.createStateTransition({
       create: documents,
     });
   });
 
-  afterEach(() => {
-    encodeMock.restore();
-    hashMock.restore();
+  describe('#getProtocolVersion', () => {
+    it('should return the current protocol version', () => {
+      const result = stateTransitionJs.getProtocolVersion();
+
+      expect(result).to.equal(protocolVersion.latestVersion);
+    });
   });
 
-  describe('#getProtocolVersion', () => {
+  describe('#getProtocolVersion - Rust', () => {
     it('should return the current protocol version', () => {
       const result = stateTransition.getProtocolVersion();
 
@@ -41,6 +70,14 @@ describe('DocumentsBatchTransition', () => {
   });
 
   describe('#getType', () => {
+    it('should return State Transition type', () => {
+      const result = stateTransitionJs.getType();
+
+      expect(result).to.equal(stateTransitionTypes.DOCUMENTS_BATCH);
+    });
+  });
+
+  describe('#getType - Rust', () => {
     it('should return State Transition type', () => {
       const result = stateTransition.getType();
 
@@ -50,19 +87,38 @@ describe('DocumentsBatchTransition', () => {
 
   describe('#getTransitions', () => {
     it('should return document transitions', () => {
-      const result = stateTransition.getTransitions();
+      const result = stateTransitionJs.getTransitions();
 
-      expect(result).to.equal(stateTransition.transitions);
+      expect(result).to.equal(stateTransitionJs.transitions);
+    });
+  });
+
+  describe('#getTransitions - Rust', () => {
+    it('should return document transitions', () => {
+      const transitionsJs = stateTransitionJs.getTransitions().map((t) => t.toJSON());
+      const transitions = stateTransition.getTransitions().map((t) => t.toJSON());
+      expect(transitionsJs).to.deep.equal(transitions);
     });
   });
 
   describe('#toJSON', () => {
     it('should return State Transition as JSON', () => {
+      expect(stateTransitionJs.toJSON()).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.DOCUMENTS_BATCH,
+        ownerId: documentsJs[0].getOwnerId().toString(),
+        transitions: stateTransitionJs.getTransitions().map((d) => d.toJSON()),
+        signaturePublicKeyId: undefined,
+        signature: undefined,
+      });
+    });
+
+    it('should return State Transition as JSON - Rust', () => {
       expect(stateTransition.toJSON()).to.deep.equal({
         protocolVersion: protocolVersion.latestVersion,
         type: stateTransitionTypes.DOCUMENTS_BATCH,
-        ownerId: documents[0].getOwnerId().toString(),
-        transitions: stateTransition.getTransitions().map((d) => d.toJSON()),
+        ownerId: documentsJs[0].getOwnerId().toString(),
+        transitions: stateTransitionJs.getTransitions().map((d) => d.toJSON()),
         signaturePublicKeyId: undefined,
         signature: undefined,
       });
@@ -71,77 +127,72 @@ describe('DocumentsBatchTransition', () => {
 
   describe('#toObject', () => {
     it('should return State Transition as plain object', () => {
-      expect(stateTransition.toObject()).to.deep.equal({
+      expect(stateTransitionJs.toObject()).to.deep.equal({
         protocolVersion: protocolVersion.latestVersion,
         type: stateTransitionTypes.DOCUMENTS_BATCH,
-        ownerId: documents[0].getOwnerId(),
-        transitions: stateTransition.getTransitions().map((d) => d.toObject()),
+        ownerId: documentsJs[0].getOwnerId(),
+        transitions: stateTransitionJs.getTransitions().map((d) => d.toObject()),
         signaturePublicKeyId: undefined,
         signature: undefined,
       });
     });
-  });
-
-  describe('#toBuffer', () => {
-    it('should return serialized Documents State Transition', () => {
-      const serializedStateTransition = Buffer.from('123');
-
-      encodeMock.returns(serializedStateTransition);
 
-      const result = stateTransition.toBuffer();
+    it('should return State Transition as plain object -  Rust', () => {
+      const rawObject = stateTransition.toObject();
+      const rawObjectJs = stateTransitionJs.toObject();
 
-      const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
-
-      expect(result).to.deep.equal(
-        Buffer.concat([protocolVersionUInt32, serializedStateTransition]),
-      );
+      expect(rawObject).to.deep.equal(rawObjectJs);
+    });
+  });
 
-      const dataToEncode = stateTransition.toObject();
-      delete dataToEncode.protocolVersion;
+  describe('#toBuffer', () => {
+    it('should return the same bytes as JS version', () => {
+      const bufferJs = stateTransitionJs.toBuffer();
+      const buffer = stateTransition.toBuffer();
 
-      expect(encodeMock).to.have.been.calledOnceWith(dataToEncode);
+      expect(bufferJs).to.deep.equal(buffer);
     });
   });
 
   describe('#hash', () => {
-    it('should return Documents State Transition hash as hex', () => {
-      const serializedDocument = Buffer.from('123');
-      const hashedDocument = '456';
-
-      encodeMock.returns(serializedDocument);
-      hashMock.returns(hashedDocument);
+    it('should return the same hash as the JS version', () => {
+      const hashJs = stateTransitionJs.hash();
+      const hash = stateTransitionJs.hash();
 
-      const result = stateTransition.hash();
-
-      expect(result).to.equal(hashedDocument);
-
-      const dataToEncode = stateTransition.toObject();
-      delete dataToEncode.protocolVersion;
-
-      expect(encodeMock).to.have.been.calledOnceWith(dataToEncode);
+      expect(hash).to.deep.equal(hashJs);
+    });
+  });
 
-      const protocolVersionUInt32 = Buffer.alloc(4);
-      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
+  describe('#getOwnerId', () => {
+    it('should return owner id', async () => {
+      const result = stateTransitionJs.getOwnerId();
 
-      expect(hashMock).to.have.been.calledOnceWith(
-        Buffer.concat([protocolVersionUInt32, serializedDocument]),
-      );
+      expect(result).to.deep.equal(getDocumentsFixture.ownerId);
     });
   });
 
-  describe('#getOwnerId', () => {
+  describe('#getOwnerId - Rust', () => {
     it('should return owner id', async () => {
       const result = stateTransition.getOwnerId();
 
-      expect(result).to.deep.equal(getDocumentsFixture.ownerId);
+      expect(result.toBuffer()).to.deep.equal(getDocumentsFixture.ownerId.toBuffer());
     });
   });
 
   describe('#getModifiedDataIds', () => {
     it('should return ids of affected documents', () => {
-      const expectedIds = documents.map((doc) => doc.getId());
-      const result = stateTransition.getModifiedDataIds();
+      const expectedIds = documentsJs.map((doc) => doc.getId());
+      const result = stateTransitionJs.getModifiedDataIds();
+
+      expect(result.length).to.be.equal(10);
+      expect(result).to.be.deep.equal(expectedIds);
+    });
+  });
+
+  describe('#getModifiedDataIds - Rust', () => {
+    it('should return ids of affected documents', () => {
+      const expectedIds = documentsJs.map((doc) => doc.getId().toBuffer());
+      const result = stateTransition.getModifiedDataIds().map((id) => id.toBuffer());
 
       expect(result.length).to.be.equal(10);
       expect(result).to.be.deep.equal(expectedIds);
@@ -149,18 +200,36 @@ describe('DocumentsBatchTransition', () => {
   });
 
   describe('#isDataContractStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransitionJs.isDataContractStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isDataContractStateTransition - Rust', () => {
     it('should return false', () => {
       expect(stateTransition.isDataContractStateTransition()).to.be.false();
     });
   });
 
   describe('#isDocumentStateTransition', () => {
+    it('should return true', () => {
+      expect(stateTransitionJs.isDocumentStateTransition()).to.be.true();
+    });
+  });
+
+  describe('#isDocumentStateTransition - Rust', () => {
     it('should return true', () => {
       expect(stateTransition.isDocumentStateTransition()).to.be.true();
     });
   });
 
   describe('#isIdentityStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransitionJs.isIdentityStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isIdentityStateTransition - Rust', () => {
     it('should return false', () => {
       expect(stateTransition.isIdentityStateTransition()).to.be.false();
     });

package/test/unit/document/stateTransition/DocumetsBatchTransition/applyDocumentsBatchTransitionFactory.spec.js

@@ -1,5 +1,5 @@
-const Document = require('@dashevo/dpp/lib/document/Document');
-const DocumentsBatchTransition = require(
+const DocumentJs = require('@dashevo/dpp/lib/document/Document');
+const DocumentsBatchTransitionJs = require(
   '@dashevo/dpp/lib/document/stateTransition/DocumentsBatchTransition/DocumentsBatchTransition',
 );
 
@@ -16,144 +16,232 @@ const getDocumentTransitionsFixture = require(
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
 
 const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
-const DocumentNotProvidedError = require('@dashevo/dpp/lib/document/errors/DocumentNotProvidedError');
+const StateTransitionExecutionContextJs = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
+
+const { default: loadWasmDpp } = require('../../../../../dist');
+
+let Document;
+let DocumentsBatchTransition;
+let DataContract;
+let StateTransitionExecutionContext;
+let applyDocumentsBatchTransition;
+let DocumentNotProvidedError;
 
 describe('applyDocumentsBatchTransitionFactory', () => {
-  let documents;
+  let documentsJs;
+  let dataContractJs;
   let dataContract;
-  let documentTransitions;
+  let documentTransitionsJs;
   let ownerId;
+  let replaceDocumentJs;
   let replaceDocument;
+  let stateTransitionJs;
   let stateTransition;
+  let documentsFixtureJs;
   let documentsFixture;
-  let applyDocumentsBatchTransition;
+  let applyDocumentsBatchTransitionJs;
+  let stateRepositoryMockJs;
   let stateRepositoryMock;
   let fetchDocumentsMock;
+  let executionContextJs;
   let executionContext;
   let blockTimeMs;
 
-  beforeEach(function beforeEach() {
-    dataContract = getDataContractFixture();
-    documentsFixture = getDocumentsFixture(dataContract);
+  beforeEach(async function beforeEach() {
+    ({
+      DataContract,
+      Document,
+      DocumentsBatchTransition,
+      StateTransitionExecutionContext,
+      applyDocumentsBatchTransition,
+      // Errors:
+      DocumentNotProvidedError,
+    } = await loadWasmDpp());
+
+    dataContractJs = getDataContractFixture();
+    dataContract = DataContract.fromBuffer(dataContractJs.toBuffer());
+
+    documentsFixtureJs = getDocumentsFixture(dataContractJs);
+    documentsFixture = documentsFixtureJs.map((d) => {
+      const doc = new Document(d.toObject(), dataContract);
+      doc.setEntropy(d.entropy);
+      return doc;
+    });
 
     ownerId = getDocumentsFixture.ownerId;
 
+    replaceDocumentJs = new DocumentJs({
+      ...documentsFixtureJs[1].toObject(),
+      lastName: 'NotSoShiny',
+    }, dataContractJs);
+
     replaceDocument = new Document({
       ...documentsFixture[1].toObject(),
       lastName: 'NotSoShiny',
     }, dataContract);
 
     blockTimeMs = Date.now();
-
-    documents = [replaceDocument, documentsFixture[2]];
-
-    documentTransitions = getDocumentTransitionsFixture({
-      create: [documentsFixture[0]],
-      replace: [documents[0]],
-      delete: [documents[1]],
+    documentsJs = [replaceDocumentJs, documentsFixtureJs[2]];
+    documentTransitionsJs = getDocumentTransitionsFixture({
+      create: [documentsFixtureJs[0]],
+      replace: [documentsJs[0]],
+      delete: [documentsJs[1]],
     });
 
+    stateTransitionJs = new DocumentsBatchTransitionJs({
+      protocolVersion: protocolVersion.latestVersion,
+      ownerId,
+      transitions: documentTransitionsJs.map((t) => t.toObject()),
+    }, [dataContractJs]);
+
     stateTransition = new DocumentsBatchTransition({
       protocolVersion: protocolVersion.latestVersion,
       ownerId,
-      transitions: documentTransitions.map((t) => t.toObject()),
+      transitions: documentTransitionsJs.map((t) => t.toObject()),
     }, [dataContract]);
 
+    executionContextJs = new StateTransitionExecutionContextJs();
     executionContext = new StateTransitionExecutionContext();
 
+    stateTransitionJs.setExecutionContext(executionContextJs);
     stateTransition.setExecutionContext(executionContext);
 
-    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-    stateRepositoryMock.fetchDataContract.resolves(dataContract);
-    stateRepositoryMock.fetchLatestPlatformBlockTime.resolves(blockTimeMs);
+    stateRepositoryMockJs = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMockJs.fetchDataContract.resolves(dataContractJs);
+    stateRepositoryMockJs.fetchLatestPlatformBlockTime.resolves(blockTimeMs);
 
     fetchDocumentsMock = this.sinonSandbox.stub();
     fetchDocumentsMock.resolves([
-      replaceDocument,
+      replaceDocumentJs,
     ]);
 
-    applyDocumentsBatchTransition = applyDocumentsBatchTransitionFactory(
-      stateRepositoryMock,
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchDataContract.resolves(dataContract);
+    stateRepositoryMock.fetchLatestPlatformBlockTime.resolves(blockTimeMs);
+    stateRepositoryMock.updateDocument.resolves(null);
+    stateRepositoryMock.removeDocument.resolves(null);
+    stateRepositoryMock.createDocument.resolves(null);
+    stateRepositoryMock.fetchDocuments.resolves([replaceDocument]);
+
+    applyDocumentsBatchTransitionJs = applyDocumentsBatchTransitionFactory(
+      stateRepositoryMockJs,
       fetchDocumentsMock,
     );
   });
 
   it('should call `store`, `replace` and `remove` functions for specific type of transitions', async () => {
-    await applyDocumentsBatchTransition(stateTransition);
+    await applyDocumentsBatchTransitionJs(stateTransitionJs);
 
-    const replaceDocumentTransition = documentTransitions[1];
+    const replaceDocumentTransition = documentTransitionsJs[1];
 
     expect(fetchDocumentsMock).to.have.been.calledOnceWithExactly(
       [replaceDocumentTransition],
-      executionContext,
+      executionContextJs,
     );
 
-    expect(stateRepositoryMock.createDocument).to.have.been.calledOnce();
-    expect(stateRepositoryMock.updateDocument).to.have.been.calledOnce();
+    expect(stateRepositoryMockJs.createDocument).to.have.been.calledOnce();
+    expect(stateRepositoryMockJs.updateDocument).to.have.been.calledOnce();
 
     const callsArgs = [
-      ...stateRepositoryMock.createDocument.getCall(0).args,
-      ...stateRepositoryMock.updateDocument.getCall(0).args,
+      ...stateRepositoryMockJs.createDocument.getCall(0).args,
+      ...stateRepositoryMockJs.updateDocument.getCall(0).args,
     ];
 
     expect(callsArgs).to.have.deep.members([
-      documentsFixture[0],
-      documents[0],
-      executionContext,
-      executionContext,
+      documentsFixtureJs[0],
+      documentsJs[0],
+      executionContextJs,
+      executionContextJs,
     ]);
 
-    expect(stateRepositoryMock.removeDocument).to.have.been.calledOnceWithExactly(
-      documentTransitions[2].getDataContract(),
-      documentTransitions[2].getType(),
-      documentTransitions[2].getId(),
-      executionContext,
+    expect(stateRepositoryMockJs.removeDocument).to.have.been.calledOnceWithExactly(
+      documentTransitionsJs[2].getDataContract(),
+      documentTransitionsJs[2].getType(),
+      documentTransitionsJs[2].getId(),
+      executionContextJs,
     );
   });
 
-  it('should throw an error if document was not provided for a replacement', async () => {
-    fetchDocumentsMock.resolves([]);
+  it('should call `store`, `replace` and `remove` functions for specific type of transitions - Rust', async () => {
+    await applyDocumentsBatchTransition(stateRepositoryMock, stateTransition);
+    expect(stateRepositoryMock.createDocument).to.have.been.calledOnce();
+
+    const [fetchContractId, fetchDocumentType] = stateRepositoryMock.fetchDocuments.getCall(0).args;
+    expect(fetchContractId.toBuffer()).to.deep.equal(documentTransitionsJs[1].getDataContractId());
+    expect(fetchDocumentType).to.equal(documentTransitionsJs[1].getType());
+
+    expect(stateRepositoryMock.updateDocument).to.have.been.calledOnce();
+    expect(stateRepositoryMock.fetchDocuments).to.have.been.calledOnce();
+
+    const [createDocument] = stateRepositoryMock.createDocument.getCall(0).args;
+    const [updateDocument] = stateRepositoryMock.updateDocument.getCall(0).args;
+    const [
+      deleteDataContract,
+      deleteDocumentType,
+      deleteDocumentId,
+    ] = stateRepositoryMock.removeDocument.getCall(0).args;
+
+    expect(createDocument.toObject()).to.deep.equal(documentsFixtureJs[0].toObject());
+    const expectDocument = documentsJs[0].toJSON();
+
+    // ! Why we need to replace. Apparently, `applyDocumentsTransition` somehow
+    // ! modifies `documentsJs` and increments revision and $updatedAt. I have
+    // ! no clue how it's possible.
+    expectDocument.$updatedAt = documentTransitionsJs[1].toJSON().$updatedAt;
+    expectDocument.$revision = documentTransitionsJs[1].toJSON().$revision;
+    expect(updateDocument.toJSON()).to.deep.equal(expectDocument);
+
+    expect(deleteDataContract.toObject()).to.deep.equal(dataContract.toObject());
+    expect(deleteDocumentType).to.deep.equal(documentTransitionsJs[2].getType());
+    expect(deleteDocumentId.toBuffer()).to.deep.equal(documentTransitionsJs[2].getId());
+  });
+
+  it('should throw an error if document was not provided for a replacement - Rust', async () => {
+    stateRepositoryMock.fetchDocuments.resolves([]);
 
-    const replaceDocumentTransition = documentTransitions[1];
+    const replaceDocumentTransition = documentTransitionsJs[1];
 
     try {
-      await applyDocumentsBatchTransition(stateTransition);
+      await applyDocumentsBatchTransition(stateRepositoryMock, stateTransition);
       expect.fail('Error was not thrown');
     } catch (e) {
       expect(e).to.be.an.instanceOf(DocumentNotProvidedError);
-      expect(e.getDocumentTransition()).to.deep.equal(replaceDocumentTransition);
+      expect(e.getDocumentTransition().toObject())
+        .to.deep.equal(replaceDocumentTransition.toObject());
     }
   });
 
-  it('should call `replace` functions on dry run', async () => {
-    documentTransitions = getDocumentTransitionsFixture({
+  it('should call `replace` functions on dry run - Rust', async function test() {
+    this.timeout(10000);
+    stateRepositoryMock.fetchLatestPlatformBlockTime.resolves(blockTimeMs);
+    documentTransitionsJs = getDocumentTransitionsFixture({
       create: [],
-      replace: [documents[0]],
+      replace: [documentsJs[0]],
       delete: [],
     });
 
     stateTransition = new DocumentsBatchTransition({
       protocolVersion: protocolVersion.latestVersion,
       ownerId,
-      transitions: documentTransitions.map((t) => t.toObject()),
+      transitions: documentTransitionsJs.map((t) => t.toObject()),
     }, [dataContract]);
 
     stateTransition.getExecutionContext().enableDryRun();
 
-    await applyDocumentsBatchTransition(stateTransition);
+    await applyDocumentsBatchTransition(stateRepositoryMock, stateTransition);
 
     stateTransition.getExecutionContext().disableDryRun();
 
     expect(stateRepositoryMock.fetchLatestPlatformBlockTime).to.have.been.calledOnceWith();
 
     const [documentTransition] = stateTransition.getTransitions();
+
     const newDocument = new Document({
-      $protocolVersion: stateTransition.getProtocolVersion(),
+      $protocolVersion: stateTransitionJs.getProtocolVersion(),
       $id: documentTransition.getId(),
       $type: documentTransition.getType(),
       $dataContractId: documentTransition.getDataContractId(),
-      $ownerId: stateTransition.getOwnerId(),
+      $ownerId: stateTransitionJs.getOwnerId(),
       $createdAt: blockTimeMs,
       ...documentTransition.getData(),
     }, documentTransition.getDataContract());
@@ -162,9 +250,9 @@ describe('applyDocumentsBatchTransitionFactory', () => {
     newDocument.setData(documentTransition.getData());
     newDocument.setUpdatedAt(documentTransition.getUpdatedAt());
 
-    expect(stateRepositoryMock.updateDocument).to.have.been.calledOnceWithExactly(
-      newDocument,
-      executionContext,
-    );
+    expect(stateRepositoryMock.updateDocument).to.have.been.called.calledOnce();
+    const [updateDocument] = stateRepositoryMock.updateDocument.getCall(0).args;
+
+    expect(updateDocument.toObject()).to.be.deep.equal(newDocument.toObject());
   });
 });

package/test/unit/document/stateTransition/DocumetsBatchTransition/documentTransition/DocumentCreateTransition.spec.js

@@ -1,24 +1,54 @@
 const getDocumentTransitionsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentTransitionsFixture');
+const { default: loadWasmDpp } = require('../../../../../../dist');
+
+let DataContract;
+let DocumentCreateTransition;
 
 describe('DocumentCreateTransition', () => {
+  let documentTransitionJs;
   let documentTransition;
 
+  beforeEach(async () => {
+    ({
+      DataContract, DocumentCreateTransition,
+    } = await loadWasmDpp());
+  });
+
   beforeEach(() => {
-    [documentTransition] = getDocumentTransitionsFixture();
+    [documentTransitionJs] = getDocumentTransitionsFixture();
+    const dataContractJs = documentTransitionJs.dataContract;
+    const dataContract = DataContract.fromBuffer(dataContractJs.toBuffer());
+
+    documentTransition = new DocumentCreateTransition(documentTransitionJs.toObject(),
+      dataContract);
   });
 
   describe('toJSON', () => {
     it('should return json representation', () => {
+      const jsonDocumentTransition = documentTransitionJs.toJSON();
+
+      expect(jsonDocumentTransition).to.deep.equal({
+        $id: documentTransitionJs.getId().toString(),
+        $type: documentTransitionJs.getType(),
+        $action: documentTransitionJs.getAction(),
+        $dataContractId: documentTransitionJs.getDataContractId().toString(),
+        $entropy: documentTransitionJs.getEntropy().toString('base64'),
+        $createdAt: documentTransitionJs.getCreatedAt().getTime(),
+        name: documentTransitionJs.getData().name,
+      });
+    });
+
+    it('should return json representation - Rust', () => {
       const jsonDocumentTransition = documentTransition.toJSON();
 
       expect(jsonDocumentTransition).to.deep.equal({
-        $id: documentTransition.getId().toString(),
-        $type: documentTransition.getType(),
-        $action: documentTransition.getAction(),
-        $dataContractId: documentTransition.getDataContractId().toString(),
-        $entropy: documentTransition.getEntropy().toString('base64'),
-        $createdAt: documentTransition.getCreatedAt().getTime(),
-        name: documentTransition.getData().name,
+        $id: documentTransitionJs.getId().toString(),
+        $type: documentTransitionJs.getType(),
+        $action: documentTransitionJs.getAction(),
+        $dataContractId: documentTransitionJs.getDataContractId().toString(),
+        $entropy: documentTransitionJs.getEntropy().toString('base64'),
+        $createdAt: documentTransitionJs.getCreatedAt().getTime(),
+        name: documentTransitionJs.getData().name,
       });
     });
   });