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

package/test/unit/document/stateTransition/DocumetsBatchTransition/validation/state/validateDocumentsBatchTransitionStateFactory.spec.js

@@ -1,10 +1,5 @@
-const validateDocumentsBatchTransitionStateFactory = require('@dashevo/dpp/lib/document/stateTransition/DocumentsBatchTransition/validation/state/validateDocumentsBatchTransitionStateFactory');
-
-const Document = require('@dashevo/dpp/lib/document/Document');
-const DocumentsBatchTransition = require('@dashevo/dpp/lib/document/stateTransition/DocumentsBatchTransition/DocumentsBatchTransition');
-
-const DataTriggerExecutionContext = require('@dashevo/dpp/lib/dataTrigger/DataTriggerExecutionContext');
-const DataTriggerExecutionError = require('@dashevo/dpp/lib/errors/consensus/state/dataContract/dataTrigger/DataTriggerExecutionError');
+const DocumentJs = require('@dashevo/dpp/lib/document/Document');
+const DocumentsBatchTransitionJs = require('@dashevo/dpp/lib/document/stateTransition/DocumentsBatchTransition/DocumentsBatchTransition');
 const DataTriggerExecutionResult = require('@dashevo/dpp/lib/dataTrigger/DataTriggerExecutionResult');
 
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
@@ -12,77 +7,110 @@ const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocuments
 const getDocumentTransitionsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentTransitionsFixture');
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
 
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
-
-const { expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
-
-const DataContractNotPresentError = require('@dashevo/dpp/lib/errors/DataContractNotPresentError');
-
-const DocumentAlreadyPresentError = require('@dashevo/dpp/lib/errors/consensus/state/document/DocumentAlreadyPresentError');
-const DocumentNotFoundError = require('@dashevo/dpp/lib/errors/consensus/state/document/DocumentNotFoundError');
-const InvalidDocumentRevisionError = require('@dashevo/dpp/lib/errors/consensus/state/document/InvalidDocumentRevisionError');
-const InvalidDocumentActionError = require('@dashevo/dpp/lib/document/errors/InvalidDocumentActionError');
-const DocumentOwnerIdMismatchError = require('@dashevo/dpp/lib/errors/consensus/state/document/DocumentOwnerIdMismatchError');
-const DocumentTimestampsMismatchError = require('@dashevo/dpp/lib/errors/consensus/state/document/DocumentTimestampsMismatchError');
-const DocumentTimestampWindowViolationError = require('@dashevo/dpp/lib/errors/consensus/state/document/DocumentTimestampWindowViolationError');
-
+const ValidationResultJs = require('@dashevo/dpp/lib/validation/ValidationResult');
 const generateRandomIdentifier = require('@dashevo/dpp/lib/test/utils/generateRandomIdentifier');
-const SomeConsensusError = require('@dashevo/dpp/lib/test/mocks/SomeConsensusError');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
+const StateTransitionExecutionContextJs = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
+const { default: loadWasmDpp } = require('../../../../../../../dist');
+
+let Identifier;
+let Document;
+let DataContract;
+let DocumentsBatchTransition;
+let StateTransitionExecutionContext;
+let validateDocumentsBatchTransitionState;
+let DataContractNotPresentNotConsensusError;
+let ValidationResult;
+
+let DocumentNotFoundError;
+let InvalidDocumentRevisionError;
+let DocumentOwnerIdMismatchError;
+let DocumentTimestampsMismatchError;
+let DocumentTimestampWindowViolationError;
 
 describe('validateDocumentsBatchTransitionStateFactory', () => {
-  let validateDocumentsBatchTransitionState;
-  let fetchDocumentsMock;
+  let stateTransitionJs;
   let stateTransition;
+  let documentsJs;
   let documents;
+  let dataContractJs;
   let dataContract;
-  let ownerId;
+  let ownerIdJs;
   let validateDocumentsUniquenessByIndicesMock;
+  let stateRepositoryMockJs;
   let stateRepositoryMock;
   let executeDataTriggersMock;
-  let documentTransitions;
+  let documentTransitionsJs;
   let fakeTime;
   let blockTime;
+  let executionContextJs;
   let executionContext;
 
-  beforeEach(function beforeEach() {
-    dataContract = getDataContractFixture();
-    documents = getDocumentsFixture(dataContract);
-    ownerId = getDocumentsFixture.ownerId;
+  beforeEach(async function beforeEach() {
+    ({
+      Identifier,
+      Document,
+      DataContract,
+      DocumentsBatchTransition,
+      StateTransitionExecutionContext,
+      ValidationResult,
+      validateDocumentsBatchTransitionState,
+      // Errors
+      DataContractNotPresentNotConsensusError,
+      DocumentNotFoundError,
+      InvalidDocumentRevisionError,
+      DocumentOwnerIdMismatchError,
+      DocumentTimestampsMismatchError,
+      DocumentTimestampWindowViolationError,
+    } = await loadWasmDpp());
+
+    dataContractJs = getDataContractFixture();
+    dataContract = new DataContract(dataContractJs.toObject());
+
+    documentsJs = getDocumentsFixture(dataContractJs);
+    documents = documentsJs.map((d) => {
+      const doc = new Document(d.toObject(), dataContract);
+      doc.setEntropy(d.entropy);
+      return doc;
+    });
+    ownerIdJs = getDocumentsFixture.ownerId;
 
-    documentTransitions = getDocumentTransitionsFixture({
-      create: documents,
+    documentTransitionsJs = getDocumentTransitionsFixture({
+      create: documentsJs,
     });
 
+    stateTransitionJs = new DocumentsBatchTransitionJs({
+      ownerId: ownerIdJs,
+      transitions: documentTransitionsJs.map((t) => t.toObject()),
+    }, [dataContractJs]);
+
     stateTransition = new DocumentsBatchTransition({
-      ownerId,
-      transitions: documentTransitions.map((t) => t.toObject()),
-    }, [dataContract]);
+      ownerId: ownerIdJs,
+      transitions: documentTransitionsJs.map((t) => t.toObject()),
+    }, [dataContract.clone()]);
 
+    executionContextJs = new StateTransitionExecutionContextJs();
     executionContext = new StateTransitionExecutionContext();
 
+    stateTransitionJs.setExecutionContext(executionContextJs);
     stateTransition.setExecutionContext(executionContext);
 
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-    stateRepositoryMock.fetchDataContract.resolves(dataContract);
+    stateRepositoryMockJs = createStateRepositoryMock(this.sinonSandbox);
+
+    stateRepositoryMock.fetchDataContract.resolves(dataContract.clone());
+    stateRepositoryMockJs.fetchDataContract.resolves(dataContractJs);
 
     blockTime = Date.now();
 
+    stateRepositoryMockJs.fetchLatestPlatformBlockTime.resolves(blockTime);
     stateRepositoryMock.fetchLatestPlatformBlockTime.resolves(blockTime);
 
-    fetchDocumentsMock = this.sinonSandbox.stub().resolves([]);
+    stateRepositoryMock.fetchDocuments.resolves([]);
 
     executeDataTriggersMock = this.sinonSandbox.stub();
-
     validateDocumentsUniquenessByIndicesMock = this.sinonSandbox.stub();
-    validateDocumentsUniquenessByIndicesMock.resolves(new ValidationResult());
 
-    validateDocumentsBatchTransitionState = validateDocumentsBatchTransitionStateFactory(
-      stateRepositoryMock,
-      fetchDocumentsMock,
-      validateDocumentsUniquenessByIndicesMock,
-      executeDataTriggersMock,
-    );
+    validateDocumentsUniquenessByIndicesMock.resolves(new ValidationResultJs());
 
     fakeTime = this.sinonSandbox.useFakeTimers(new Date());
   });
@@ -91,382 +119,201 @@ describe('validateDocumentsBatchTransitionStateFactory', () => {
     fakeTime.reset();
   });
 
-  it('should throw DataContractNotPresentError if data contract was not found', async () => {
+  it('should throw DataContractNotPresentError if data contract was not found - Rust', async () => {
     stateRepositoryMock.fetchDataContract.resolves(null);
 
     try {
-      await validateDocumentsBatchTransitionState(stateTransition);
+      await validateDocumentsBatchTransitionState(stateRepositoryMock, stateTransition);
 
       expect.fail('should throw DataContractNotPresentError');
     } catch (e) {
-      expect(e).to.be.instanceOf(DataContractNotPresentError);
+      expect(e).to.be.instanceOf(DataContractNotPresentNotConsensusError);
 
-      expect(e.getDataContractId()).to.deep.equal(dataContract.getId());
+      expect(e.getDataContractId()).to.deep.equal(dataContract.getId().toBuffer());
 
-      expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-        dataContract.getId(),
-        new StateTransitionExecutionContext(),
-      );
-
-      expect(fetchDocumentsMock).to.have.not.been.called();
-      expect(validateDocumentsUniquenessByIndicesMock).to.have.not.been.called();
-      expect(executeDataTriggersMock).to.have.not.been.called();
+      expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+      const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+      expect(fetchDataContractId.toBuffer()).to.deep.equal(dataContract.getId().toBuffer());
     }
   });
 
-  it('should return invalid result if document transition with action "create" is already present', async () => {
-    fetchDocumentsMock.resolves([documents[0]]);
+  it('should return invalid result if document transition with action "create" is already present  - Rust', async () => {
+    stateRepositoryMock.fetchDocuments.resolves([documents[0]]);
 
-    const result = await validateDocumentsBatchTransitionState(stateTransition);
+    const result = await validateDocumentsBatchTransitionState(
+      stateRepositoryMock, stateTransition,
+    );
 
-    expectValidationError(result, DocumentAlreadyPresentError);
+    expect(result.isValid()).is.not.true();
 
     const [error] = result.getErrors();
 
     expect(error.getCode()).to.equal(4004);
-    expect(Buffer.isBuffer(error.getDocumentId())).to.be.true();
-    expect(error.getDocumentId()).to.deep.equal(documentTransitions[0].getId().toBuffer());
+    expect(error.getDocumentId()).to.deep.equal(documentTransitionsJs[0].getId().toBuffer());
 
-    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-      dataContract.getId(),
-      new StateTransitionExecutionContext(),
-    );
-
-    expect(fetchDocumentsMock.getCall(0).args[0].map((t) => t.toObject())).to.have.deep.members(
-      documentTransitions.map((t) => t.toObject()),
-    );
-
-    expect(validateDocumentsUniquenessByIndicesMock).to.have.not.been.called();
-    expect(executeDataTriggersMock).to.have.not.been.called();
+    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+    const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+    expect(fetchDataContractId.toBuffer()).to.deep.equal(dataContract.getId().toBuffer());
   });
 
-  it('should return invalid result if document transition with action "replace" is not present', async () => {
-    documentTransitions = getDocumentTransitionsFixture({
+  it('should return invalid result if document transition with action "replace" is not present - Rust', async () => {
+    documentTransitionsJs = getDocumentTransitionsFixture({
       create: [],
-      replace: [documents[0]],
+      replace: [documentsJs[0]],
     });
 
     stateTransition = new DocumentsBatchTransition({
-      ownerId,
-      contractId: dataContract.getId(),
-      transitions: documentTransitions.map((t) => t.toObject()),
+      ownerId: ownerIdJs,
+      contractId: dataContractJs.getId(),
+      transitions: documentTransitionsJs.map((t) => t.toObject()),
     }, [dataContract]);
 
-    stateTransition.setExecutionContext(executionContext);
-
-    const result = await validateDocumentsBatchTransitionState(stateTransition);
-
-    expectValidationError(result, DocumentNotFoundError);
+    const result = await validateDocumentsBatchTransitionState(
+      stateRepositoryMock, stateTransition,
+    );
+    expect(result).is.instanceOf(ValidationResult);
 
     const [error] = result.getErrors();
-
+    expect(error).is.instanceOf(DocumentNotFoundError);
     expect(error.getCode()).to.equal(4005);
-    expect(Buffer.isBuffer(error.getDocumentId())).to.be.true();
-    expect(error.getDocumentId()).to.deep.equal(documentTransitions[0].getId().toBuffer());
+    expect(error.getDocumentId()).to.deep.equal(documentTransitionsJs[0].getId().toBuffer());
 
-    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-      dataContract.getId(),
-      new StateTransitionExecutionContext(),
-    );
+    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+    const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+    expect(fetchDataContractId.toBuffer()).to.deep.equal(dataContract.getId().toBuffer());
 
-    expect(fetchDocumentsMock).to.have.been.calledOnceWithExactly(
-      documentTransitions,
-      executionContext,
-    );
-
-    expect(validateDocumentsUniquenessByIndicesMock).to.have.not.been.called();
-    expect(executeDataTriggersMock).to.have.not.been.called();
+    expect(stateRepositoryMock.fetchDocuments).to.have.been.callCount(documentTransitionsJs.length);
   });
 
-  it('should return invalid result if document transition with action "delete" is not present', async () => {
-    documentTransitions = getDocumentTransitionsFixture({
+  it('should return invalid result if document transition with action "delete" is not present - Rust', async () => {
+    documentTransitionsJs = getDocumentTransitionsFixture({
       create: [],
-      delete: [documents[0]],
+      delete: [documentsJs[0]],
     });
 
     stateTransition = new DocumentsBatchTransition({
-      ownerId,
-      contractId: dataContract.getId(),
-      transitions: documentTransitions.map((t) => t.toObject()),
+      ownerId: ownerIdJs,
+      contractId: dataContractJs.getId(),
+      transitions: documentTransitionsJs.map((t) => t.toObject()),
     }, [dataContract]);
 
-    stateTransition.setExecutionContext(executionContext);
-
-    const result = await validateDocumentsBatchTransitionState(stateTransition);
+    const result = await validateDocumentsBatchTransitionState(
+      stateRepositoryMock, stateTransition,
+    );
 
-    expectValidationError(result, DocumentNotFoundError);
+    expect(result).is.instanceOf(ValidationResult);
 
     const [error] = result.getErrors();
-
+    expect(error).is.instanceOf(DocumentNotFoundError);
     expect(error.getCode()).to.equal(4005);
-    expect(Buffer.isBuffer(error.getDocumentId())).to.be.true();
-    expect(error.getDocumentId()).to.deep.equal(documentTransitions[0].getId().toBuffer());
+    expect(error.getDocumentId()).to.deep.equal(documentTransitionsJs[0].getId().toBuffer());
 
-    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-      dataContract.getId(),
-      new StateTransitionExecutionContext(),
-    );
-
-    expect(fetchDocumentsMock).to.have.been.calledOnceWithExactly(
-      documentTransitions,
-      executionContext,
-    );
+    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+    const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+    expect(fetchDataContractId.toBuffer()).to.deep.equal(dataContract.getId().toBuffer());
 
-    expect(validateDocumentsUniquenessByIndicesMock).to.have.not.been.called();
-    expect(executeDataTriggersMock).to.have.not.been.called();
+    expect(stateRepositoryMock.fetchDocuments).to.have.been.callCount(documentTransitionsJs.length);
   });
 
-  it('should return invalid result if document transition with action "replace" has wrong revision', async () => {
-    const replaceDocument = new Document(documents[0].toObject(), dataContract);
+  it('should return invalid result if document transition with action "replace" has wrong revision - Rust', async () => {
+    const replaceDocument = new DocumentJs(documentsJs[0].toObject(), dataContractJs);
     replaceDocument.setRevision(3);
 
-    documentTransitions = getDocumentTransitionsFixture({
+    documentTransitionsJs = getDocumentTransitionsFixture({
       create: [],
       replace: [replaceDocument],
     });
 
     stateTransition = new DocumentsBatchTransition({
-      ownerId,
-      contractId: dataContract.getId(),
-      transitions: documentTransitions.map((t) => t.toObject()),
+      ownerId: ownerIdJs,
+      contractId: dataContractJs.getId(),
+      transitions: documentTransitionsJs.map((t) => t.toObject()),
     }, [dataContract]);
 
-    stateTransition.setExecutionContext(executionContext);
-
-    documents[0].setCreatedAt(replaceDocument.getCreatedAt());
-    fetchDocumentsMock.resolves([documents[0]]);
+    documents[0].setCreatedAt(replaceDocument.getCreatedAt().getMilliseconds());
+    stateRepositoryMock.fetchDocuments.resolves([documents[0]]);
 
-    const result = await validateDocumentsBatchTransitionState(stateTransition);
+    const result = await validateDocumentsBatchTransitionState(
+      stateRepositoryMock, stateTransition,
+    );
 
-    expectValidationError(result, InvalidDocumentRevisionError);
+    expect(result).is.instanceOf(ValidationResult);
 
     const [error] = result.getErrors();
-
+    expect(error).is.instanceOf(InvalidDocumentRevisionError);
     expect(error.getCode()).to.equal(4010);
-    expect(Buffer.isBuffer(error.getDocumentId())).to.be.true();
-    expect(error.getDocumentId()).to.deep.equal(documentTransitions[0].getId().toBuffer());
-    expect(error.getCurrentRevision()).to.deep.equal(documents[0].getRevision());
 
-    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-      dataContract.getId(),
-      new StateTransitionExecutionContext(),
-    );
+    expect(error.getDocumentId()).to.deep.equal(documentTransitionsJs[0].getId().toBuffer());
+    expect(Number(error.getCurrentRevision())).to.deep.equal(documents[0].getRevision());
 
-    expect(fetchDocumentsMock).to.have.been.calledOnceWithExactly(
-      documentTransitions,
-      executionContext,
-    );
+    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+    const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+    expect(fetchDataContractId.toBuffer()).to.deep.equal(dataContract.getId().toBuffer());
 
-    expect(validateDocumentsUniquenessByIndicesMock).to.have.not.been.called();
-    expect(executeDataTriggersMock).to.have.not.been.called();
+    expect(stateRepositoryMock.fetchDocuments).to.have.been.callCount(documentTransitionsJs.length);
   });
 
-  it('should return invalid result if document transition with action "replace" has mismatch of ownerId with previous revision', async () => {
-    const replaceDocument = new Document(documents[0].toObject(), dataContract);
+  it('should return invalid result if document transition with action "replace" has mismatch of ownerId with previous revision - Rust', async () => {
+    const replaceDocument = new DocumentJs(documentsJs[0].toObject(), dataContractJs);
     replaceDocument.setRevision(1);
 
-    const fetchedDocument = new Document(documents[0].toObject(), dataContract);
-    fetchedDocument.ownerId = generateRandomIdentifier();
+    const fetchedDocument = new Document(documentsJs[0].toObject(), dataContract);
+    fetchedDocument.setOwnerId(Identifier.from(generateRandomIdentifier().toBuffer()));
 
-    documentTransitions = getDocumentTransitionsFixture({
+    documentTransitionsJs = getDocumentTransitionsFixture({
       create: [],
       replace: [replaceDocument],
     });
 
     stateTransition = new DocumentsBatchTransition({
-      ownerId,
-      contractId: dataContract.getId(),
-      transitions: documentTransitions.map((t) => t.toObject()),
+      ownerId: ownerIdJs,
+      contractId: dataContractJs.getId(),
+      transitions: documentTransitionsJs.map((t) => t.toObject()),
     }, [dataContract]);
 
-    stateTransition.setExecutionContext(executionContext);
-
-    fetchDocumentsMock.resolves([fetchedDocument]);
+    stateRepositoryMock.fetchDocuments.resolves([fetchedDocument]);
 
-    const result = await validateDocumentsBatchTransitionState(stateTransition);
+    const result = await validateDocumentsBatchTransitionState(
+      stateRepositoryMock,
+      stateTransition,
+    );
 
-    expectValidationError(result, DocumentOwnerIdMismatchError);
+    expect(result).is.instanceOf(ValidationResult);
 
     const [error] = result.getErrors();
-
+    expect(error).is.instanceOf(DocumentOwnerIdMismatchError);
     expect(error.getCode()).to.equal(4006);
-    expect(Buffer.isBuffer(error.getDocumentId())).to.be.true();
-    expect(error.getDocumentId()).to.deep.equal(documentTransitions[0].getId().toBuffer());
-
-    expect(Buffer.isBuffer(error.getDocumentOwnerId())).to.be.true();
-    expect(error.getDocumentOwnerId()).to.deep.equal(
-      replaceDocument.getOwnerId().toBuffer(),
-    );
-
-    expect(Buffer.isBuffer(error.getExistingDocumentOwnerId())).to.be.true();
+    expect(error.getDocumentId()).to.deep.equal(documentTransitionsJs[0].getId().toBuffer());
     expect(error.getExistingDocumentOwnerId()).to.deep.equal(
       fetchedDocument.getOwnerId().toBuffer(),
     );
 
-    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-      dataContract.getId(),
-      new StateTransitionExecutionContext(),
-    );
+    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+    const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+    expect(fetchDataContractId.toBuffer()).to.deep.equal(dataContract.getId().toBuffer());
 
-    expect(fetchDocumentsMock).to.have.been.calledOnceWithExactly(
-      documentTransitions,
-      executionContext,
-    );
-
-    expect(validateDocumentsUniquenessByIndicesMock).to.have.not.been.called();
-    expect(executeDataTriggersMock).to.have.not.been.called();
+    expect(stateRepositoryMock.fetchDocuments).to.have.been.callCount(documentTransitionsJs.length);
   });
 
-  it('should throw an error if document transition has invalid action', async () => {
-    stateTransition = new DocumentsBatchTransition({
-      ownerId,
-      contractId: dataContract.getId(),
-      transitions: documentTransitions.map((t) => t.toObject()),
-    }, [dataContract]);
-
-    stateTransition.setExecutionContext(executionContext);
-
-    stateTransition.transitions[0].getAction = () => 5;
-
-    fetchDocumentsMock.resolves([documents[0]]);
-
-    try {
-      await validateDocumentsBatchTransitionState(stateTransition);
-
-      expect.fail('InvalidDocumentActionError should be thrown');
-    } catch (e) {
-      expect(e).to.be.an.instanceOf(InvalidDocumentActionError);
-      expect(e.getDocumentTransition().toObject()).to.deep.equal(
-        stateTransition.transitions[0].toObject(),
-      );
-
-      expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-        dataContract.getId(),
-        new StateTransitionExecutionContext(),
-      );
-
-      expect(fetchDocumentsMock).to.have.been.calledOnceWithExactly(
-        stateTransition.transitions,
-        executionContext,
-      );
-
-      expect(validateDocumentsUniquenessByIndicesMock).to.have.not.been.called();
-      expect(executeDataTriggersMock).to.have.not.been.called();
-    }
+  it('should throw an error if document transition has invalid action - Rust', async () => {
+    // Omitted - DocumentsBatchTransition cannot be created from the
+    // transition with an invalid action because the `DocumentTransition`
+    // uses enums
   });
 
-  it('should return invalid result if there are duplicate document transitions according to unique indices', async () => {
-    const duplicateDocumentsError = new SomeConsensusError('error');
-
-    validateDocumentsUniquenessByIndicesMock.resolves(
-      new ValidationResult([duplicateDocumentsError]),
-    );
-
-    const result = await validateDocumentsBatchTransitionState(stateTransition);
-
-    expectValidationError(result);
-
-    const [error] = result.getErrors();
-
-    expect(error).to.equal(duplicateDocumentsError);
-
-    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-      dataContract.getId(),
-      new StateTransitionExecutionContext(),
-    );
-
-    expect(fetchDocumentsMock).to.have.been.calledOnceWithExactly(
-      stateTransition.transitions,
-      executionContext,
-    );
-
-    const [callOwnerId, callDocumentTransitions, callDataContract] = (
-      validateDocumentsUniquenessByIndicesMock.getCall(0).args
-    );
-
-    const callArgs = [
-      callOwnerId,
-      callDocumentTransitions.map((t) => t.toObject()),
-      callDataContract,
-    ];
+  it('should return invalid result if there are duplicate document transitions according to unique indices - Rust', async () => {
+    // Omitted as it seems impossible to generate such a state without
+    // having UniqueIndicesValidation mocked
+  });
 
-    expect(callArgs).to.have.deep.members([
-      ownerId,
-      documentTransitions.map((t) => t.toObject()),
-      dataContract,
-    ]);
-    expect(executeDataTriggersMock).to.have.not.been.called();
+  it('should return invalid result if data triggers execution failed - Rust', async () => {
+    // Omitted as it seems impossible to generate such a state without
+    // having DataTrigger execution mocked
   });
 
   it('should return invalid result if data triggers execution failed', async () => {
-    const dataTriggersExecutionContext = new DataTriggerExecutionContext(
-      stateRepositoryMock,
-      ownerId,
-      dataContract,
-      executionContext,
-    );
-
-    const dataTriggerExecutionError = new DataTriggerExecutionError(
-      documentTransitions[0],
-      dataTriggersExecutionContext.getDataContract(),
-      dataTriggersExecutionContext.getOwnerId(),
-      new Error('error'),
-    );
-
-    executeDataTriggersMock.resolves([
-      new DataTriggerExecutionResult([dataTriggerExecutionError]),
-    ]);
-
-    const result = await validateDocumentsBatchTransitionState(stateTransition);
-
-    expectValidationError(result, DataTriggerExecutionError);
-
-    const [error] = result.getErrors();
-
-    expect(error.getCode()).to.equal(4002);
-    expect(error).to.equal(dataTriggerExecutionError);
-
-    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-      dataContract.getId(),
-      new StateTransitionExecutionContext(),
-    );
-
-    expect(fetchDocumentsMock).to.have.been.calledOnceWithExactly(
-      stateTransition.transitions,
-      executionContext,
-    );
-
-    const [callOwnerId, callDocumentTransitions, callDataContract, callExecutionContext] = (
-      validateDocumentsUniquenessByIndicesMock.getCall(0).args
-    );
-
-    const callArgs = [
-      callOwnerId,
-      callDocumentTransitions.map((t) => t.toObject()),
-      callDataContract,
-      callExecutionContext,
-    ];
-
-    expect(callArgs).to.have.deep.members([
-      ownerId,
-      documentTransitions.map((t) => t.toObject()),
-      dataContract,
-      executionContext,
-    ]);
-
-    const [triggerCallDocumentTransitions, triggerCallDataTriggersExecutionContext] = (
-      executeDataTriggersMock.getCall(0).args
-    );
-
-    const triggerCallArgs = [
-      triggerCallDocumentTransitions.map((t) => t.toObject()),
-      triggerCallDataTriggersExecutionContext,
-    ];
-
-    expect(triggerCallArgs).to.have.deep.members([
-      documentTransitions.map((t) => t.toObject()),
-      dataTriggersExecutionContext,
-    ]);
+    // Omitted as it seems impossible to generate such a state without
+    // having DataTrigger execution mocked
   });
 
   describe('Timestamps', () => {
@@ -486,117 +333,120 @@ describe('validateDocumentsBatchTransitionStateFactory', () => {
     });
 
     describe('CREATE transition', () => {
-      it('should return invalid result if timestamps mismatch', async () => {
-        documentTransitions = getDocumentTransitionsFixture({
-          create: [documents[0]],
+      it('should return invalid result if timestamps mismatch - Rust', async () => {
+        documentTransitionsJs = getDocumentTransitionsFixture({
+          create: [documentsJs[0]],
         });
 
         stateTransition = new DocumentsBatchTransition({
-          ownerId,
-          contractId: dataContract.getId(),
-          transitions: documentTransitions.map((t) => t.toObject()),
+          ownerId: ownerIdJs,
+          contractId: dataContractJs.getId(),
+          transitions: documentTransitionsJs.map((t) => t.toObject()),
         }, [dataContract]);
 
-        stateTransition.transitions.forEach((t) => {
+        const transitions = stateTransition.getTransitions();
+        transitions.forEach((t) => {
           // eslint-disable-next-line no-param-reassign
-          t.updatedAt = new Date();
+          t.setUpdatedAt(new Date().getMilliseconds());
         });
+        stateTransition.setTransitions(transitions);
 
-        const result = await validateDocumentsBatchTransitionState(stateTransition);
+        const result = await validateDocumentsBatchTransitionState(
+          stateRepositoryMock, stateTransition,
+        );
 
-        expectValidationError(result, DocumentTimestampsMismatchError);
+        expect(result).is.instanceOf(ValidationResult);
 
         const [error] = result.getErrors();
-
+        expect(error).is.instanceOf(DocumentTimestampsMismatchError);
         expect(error.getCode()).to.equal(4007);
-
-        documentTransitions[0].updatedAt = new Date();
-
-        expect(Buffer.isBuffer(error.getDocumentId())).to.be.true();
-        expect(error.getDocumentId()).to.deep.equal(documentTransitions[0].getId().toBuffer());
       });
 
-      it('should return invalid result if "$createdAt" have violated time window', async () => {
-        documentTransitions = getDocumentTransitionsFixture({
-          create: [documents[0]],
+      it('should return invalid result if "$createdAt" have violated time window  - Rust', async () => {
+        documentTransitionsJs = getDocumentTransitionsFixture({
+          create: [documentsJs[0]],
         });
 
         stateTransition = new DocumentsBatchTransition({
-          ownerId,
-          contractId: dataContract.getId(),
-          transitions: documentTransitions.map((t) => t.toObject()),
+          ownerId: ownerIdJs,
+          contractId: dataContractJs.getId(),
+          transitions: documentTransitionsJs.map((t) => t.toObject()),
         }, [dataContract]);
 
-        stateTransition.transitions.forEach((t) => {
-          // eslint-disable-next-line no-param-reassign
-          t.createdAt.setMinutes(t.createdAt.getMinutes() - 6);
-          // eslint-disable-next-line no-param-reassign
-          t.updatedAt = undefined;
+        const transitions = stateTransition.getTransitions();
+        transitions.forEach((t) => {
+          const createdAtMinus6Mins = t.getCreatedAt() - (6 * 60 * 1000);
+          t.setCreatedAt(createdAtMinus6Mins);
+          t.setUpdatedAt(undefined);
         });
+        stateTransition.setTransitions(transitions);
 
-        const result = await validateDocumentsBatchTransitionState(stateTransition);
+        const result = await validateDocumentsBatchTransitionState(
+          stateRepositoryMock, stateTransition,
+        );
 
-        expectValidationError(result, DocumentTimestampWindowViolationError);
+        expect(result).is.instanceOf(ValidationResult);
+        expect(result.isValid()).is.not.true();
 
         const [error] = result.getErrors();
-
+        expect(error).is.instanceOf(DocumentTimestampWindowViolationError);
         expect(error.getCode()).to.equal(4008);
+        expect(error.getTimestampName()).to.equal('createdAt');
 
-        documentTransitions[0].createdAt.setMinutes(
-          documentTransitions[0].createdAt.getMinutes() - 6,
+        expect(error.getTimestamp().getMilliseconds()).to.equal(
+          documentTransitionsJs[0].createdAt.getMilliseconds(),
         );
-        documentTransitions[0].updatedAt = undefined;
-
-        expect(Buffer.isBuffer(error.getDocumentId())).to.be.true();
-        expect(error.getDocumentId()).to.deep.equal(documentTransitions[0].getId().toBuffer());
-        expect(error.getTimestampName()).to.equal('createdAt');
-        expect(error.getTimestamp()).to.deep.equal(documentTransitions[0].createdAt);
         expect(error.getTimeWindowStart()).to.deep.equal(timeWindowStart);
         expect(error.getTimeWindowEnd()).to.deep.equal(timeWindowEnd);
       });
 
-      it('should return invalid result if "$updatedAt" have violated time window', async () => {
-        documentTransitions = getDocumentTransitionsFixture({
-          create: [documents[1]],
+      it('should return invalid result if "$updatedAt" have violated time window - Rust', async () => {
+        documentTransitionsJs = getDocumentTransitionsFixture({
+          create: [documentsJs[1]],
         });
 
         stateTransition = new DocumentsBatchTransition({
-          ownerId,
-          contractId: dataContract.getId(),
-          transitions: documentTransitions.map((t) => t.toObject()),
+          ownerId: ownerIdJs,
+          contractId: dataContractJs.getId(),
+          transitions: documentTransitionsJs.map((t) => t.toObject()),
         }, [dataContract]);
 
-        stateTransition.transitions.forEach((t) => {
-          // eslint-disable-next-line no-param-reassign
-          t.updatedAt.setMinutes(t.updatedAt.getMinutes() - 6);
-          // eslint-disable-next-line no-param-reassign
-          t.createdAt = undefined;
+        const transitions = stateTransition.getTransitions();
+        transitions.forEach((t) => {
+          const createdAtMinus6Mins = t.getUpdatedAt() - (6 * 60 * 1000);
+          t.setUpdatedAt(createdAtMinus6Mins);
+          t.setCreatedAt(undefined);
         });
+        stateTransition.setTransitions(transitions);
 
-        const result = await validateDocumentsBatchTransitionState(stateTransition);
+        const result = await validateDocumentsBatchTransitionState(
+          stateRepositoryMock, stateTransition,
+        );
 
-        expectValidationError(result, DocumentTimestampWindowViolationError);
+        expect(result).is.instanceOf(ValidationResult);
+        expect(result.isValid()).is.not.true();
 
         const [error] = result.getErrors();
-
+        expect(error).is.instanceOf(DocumentTimestampWindowViolationError);
         expect(error.getCode()).to.equal(4008);
 
-        documentTransitions[0].updatedAt.setMinutes(
-          documentTransitions[0].updatedAt.getMinutes() - 6,
+        documentTransitionsJs[0].updatedAt.setMinutes(
+          documentTransitionsJs[0].updatedAt.getMinutes() - 6,
         );
-        documentTransitions[0].createdAt = undefined;
+        documentTransitionsJs[0].createdAt = undefined;
 
-        expect(Buffer.isBuffer(error.getDocumentId())).to.be.true();
-        expect(error.getDocumentId()).to.deep.equal(documentTransitions[0].getId().toBuffer());
+        expect(error.getDocumentId()).to.deep.equal(documentTransitionsJs[0].getId().toBuffer());
         expect(error.getTimestampName()).to.equal('updatedAt');
-        expect(error.getTimestamp()).to.deep.equal(documentTransitions[0].updatedAt);
+        expect(error.getTimestamp().getMilliseconds()).to.deep.equal(
+          documentTransitionsJs[0].updatedAt.getMilliseconds(),
+        );
         expect(error.getTimeWindowStart()).to.deep.equal(timeWindowStart);
         expect(error.getTimeWindowEnd()).to.deep.equal(timeWindowEnd);
       });
 
-      it('should not validate time in block window on dry run', async () => {
-        documentTransitions = getDocumentTransitionsFixture({
-          create: [documents[1]],
+      it('should not validate time in block window on dry run - Rust', async () => {
+        documentTransitionsJs = getDocumentTransitionsFixture({
+          create: [documentsJs[1]],
         });
 
         executeDataTriggersMock.resolves([
@@ -604,29 +454,31 @@ describe('validateDocumentsBatchTransitionStateFactory', () => {
         ]);
 
         stateTransition = new DocumentsBatchTransition({
-          ownerId,
-          contractId: dataContract.getId(),
-          transitions: documentTransitions.map((t) => t.toObject()),
+          ownerId: ownerIdJs,
+          contractId: dataContractJs.getId(),
+          transitions: documentTransitionsJs.map((t) => t.toObject()),
         }, [dataContract]);
 
-        stateTransition.transitions.forEach((t) => {
-          // eslint-disable-next-line no-param-reassign
-          t.updatedAt.setMinutes(t.updatedAt.getMinutes() - 6);
+        const transitions = stateTransition.getTransitions();
+        transitions.forEach((t) => {
+          const createdAtMinus6Mins = t.getUpdatedAt() - (6 * 60 * 1000);
+          t.setUpdatedAt(createdAtMinus6Mins);
+          t.setCreatedAt(undefined);
         });
-
+        stateTransition.setTransitions(transitions);
         stateTransition.getExecutionContext().enableDryRun();
 
-        const result = await validateDocumentsBatchTransitionState(stateTransition);
-
-        stateTransition.getExecutionContext().disableDryRun();
+        const result = await validateDocumentsBatchTransitionState(
+          stateRepositoryMock, stateTransition,
+        );
 
         expect(result).to.be.an.instanceOf(ValidationResult);
         expect(result.isValid()).to.be.true();
       });
 
-      it('should return valid result if timestamps mismatch on dry run', async () => {
-        documentTransitions = getDocumentTransitionsFixture({
-          create: [documents[0]],
+      it('should return valid result if timestamps mismatch on dry run - Rust', async () => {
+        documentTransitionsJs = getDocumentTransitionsFixture({
+          create: [documentsJs[0]],
         });
 
         executeDataTriggersMock.resolves([
@@ -634,21 +486,21 @@ describe('validateDocumentsBatchTransitionStateFactory', () => {
         ]);
 
         stateTransition = new DocumentsBatchTransition({
-          ownerId,
-          contractId: dataContract.getId(),
-          transitions: documentTransitions.map((t) => t.toObject()),
+          ownerId: ownerIdJs,
+          contractId: dataContractJs.getId(),
+          transitions: documentTransitionsJs.map((t) => t.toObject()),
         }, [dataContract]);
 
-        stateTransition.transitions.forEach((t) => {
+        const transitions = stateTransition.getTransitions();
+        transitions.forEach((t) => {
           // eslint-disable-next-line no-param-reassign
-          t.updatedAt = new Date();
+          t.setUpdatedAt(new Date().getMilliseconds());
         });
-
         stateTransition.getExecutionContext().enableDryRun();
 
-        const result = await validateDocumentsBatchTransitionState(stateTransition);
-
-        stateTransition.getExecutionContext().disableDryRun();
+        const result = await validateDocumentsBatchTransitionState(
+          stateRepositoryMock, stateTransition,
+        );
 
         expect(result).to.be.an.instanceOf(ValidationResult);
         expect(result.isValid()).to.be.true();
@@ -656,81 +508,83 @@ describe('validateDocumentsBatchTransitionStateFactory', () => {
     });
 
     describe('REPLACE transition', () => {
-      it('should return invalid result if documents with action "replace" have violated time window', async () => {
-        documentTransitions = getDocumentTransitionsFixture({
+      it('should return invalid result if documents with action "replace" have violated time window - Rust', async () => {
+        documentTransitionsJs = getDocumentTransitionsFixture({
           create: [],
-          replace: [documents[1]],
+          replace: [documentsJs[1]],
         });
 
         stateTransition = new DocumentsBatchTransition({
-          ownerId,
-          contractId: dataContract.getId(),
-          transitions: documentTransitions.map((t) => t.toObject()),
+          ownerId: ownerIdJs,
+          contractId: dataContractJs.getId(),
+          transitions: documentTransitionsJs.map((t) => t.toObject()),
         }, [dataContract]);
 
-        documents[1].updatedAt.setMinutes(
-          documents[1].updatedAt.getMinutes() - 6,
+        documentsJs[1].updatedAt.setMinutes(
+          documentsJs[1].updatedAt.getMinutes() - 6,
         );
 
-        fetchDocumentsMock.resolves([documents[1]]);
+        const documentToReturn = new Document(documentsJs[1].toObject(), dataContract);
+        stateRepositoryMock.fetchDocuments.resolves([documentToReturn]);
 
-        stateTransition.transitions.forEach((t) => {
-          // eslint-disable-next-line no-param-reassign
-          t.updatedAt.setMinutes(t.updatedAt.getMinutes() - 6);
+        const transitions = stateTransition.getTransitions();
+        transitions.forEach((t) => {
+          const createdAtMinus6Mins = t.getUpdatedAt() - (6 * 60 * 1000);
+          t.setUpdatedAt(createdAtMinus6Mins);
         });
+        stateTransition.setTransitions(transitions);
 
-        const result = await validateDocumentsBatchTransitionState(stateTransition);
-
-        expectValidationError(result, DocumentTimestampWindowViolationError);
+        const result = await validateDocumentsBatchTransitionState(
+          stateRepositoryMock, stateTransition,
+        );
 
+        expect(result).is.instanceOf(ValidationResult);
+        expect(result.isValid()).is.not.true();
         const [error] = result.getErrors();
 
+        expect(error).is.instanceOf(DocumentTimestampWindowViolationError);
         expect(error.getCode()).to.equal(4008);
 
-        documentTransitions[0].updatedAt.setMinutes(
-          documentTransitions[0].updatedAt.getMinutes() - 6,
+        documentTransitionsJs[0].updatedAt.setMinutes(
+          documentTransitionsJs[0].updatedAt.getMinutes() - 6,
         );
 
-        expect(Buffer.isBuffer(error.getDocumentId())).to.be.true();
-        expect(error.getDocumentId()).to.deep.equal(documentTransitions[0].getId().toBuffer());
+        expect(error.getDocumentId()).to.deep.equal(documentTransitionsJs[0].getId().toBuffer());
         expect(error.getTimestampName()).to.equal('updatedAt');
-        expect(error.getTimestamp()).to.deep.equal(documentTransitions[0].updatedAt);
+        expect(error.getTimestamp()).to.deep.equal(documentTransitionsJs[0].updatedAt);
         expect(error.getTimeWindowStart()).to.deep.equal(timeWindowStart);
         expect(error.getTimeWindowEnd()).to.deep.equal(timeWindowEnd);
       });
 
-      it('should return valid result if documents with action "replace" have violated time window on dry run', async () => {
-        executeDataTriggersMock.resolves([
-          new DataTriggerExecutionResult(),
-        ]);
-
-        documentTransitions = getDocumentTransitionsFixture({
+      it('should return valid result if documents with action "replace" have violated time window on dry run - Rust', async () => {
+        documentTransitionsJs = getDocumentTransitionsFixture({
           create: [],
-          replace: [documents[1]],
+          replace: [documentsJs[1]],
         });
 
         stateTransition = new DocumentsBatchTransition({
-          ownerId,
-          contractId: dataContract.getId(),
-          transitions: documentTransitions.map((t) => t.toObject()),
+          ownerId: ownerIdJs,
+          contractId: dataContractJs.getId(),
+          transitions: documentTransitionsJs.map((t) => t.toObject()),
         }, [dataContract]);
 
-        documents[1].updatedAt.setMinutes(
-          documents[1].updatedAt.getMinutes() - 6,
+        documentsJs[1].updatedAt.setMinutes(
+          documentsJs[1].updatedAt.getMinutes() - 6,
         );
 
-        fetchDocumentsMock.resolves([documents[1]]);
+        const documentToReturn = new Document(documentsJs[1].toObject(), dataContract);
+        stateRepositoryMock.fetchDocuments.resolves([documentToReturn]);
 
-        stateTransition.transitions.forEach((t) => {
-          // eslint-disable-next-line no-param-reassign
-          t.updatedAt.setMinutes(t.updatedAt.getMinutes() - 6);
+        const transitions = stateTransition.getTransitions(); transitions.forEach((t) => {
+          const createdAtMinus6Mins = t.getUpdatedAt() - (6 * 60 * 1000);
+          t.setUpdatedAt(createdAtMinus6Mins);
         });
-
+        stateTransition.setTransitions(transitions);
         stateTransition.getExecutionContext().enableDryRun();
 
-        const result = await validateDocumentsBatchTransitionState(stateTransition);
-
-        stateTransition.getExecutionContext().disableDryRun();
+        const result = await validateDocumentsBatchTransitionState(
+          stateRepositoryMock, stateTransition,
+        );
 
         expect(result).to.be.an.instanceOf(ValidationResult);
         expect(result.isValid()).to.be.true();
@@ -738,67 +592,77 @@ describe('validateDocumentsBatchTransitionStateFactory', () => {
     });
   });
 
-  it('should return valid result if document transitions are valid', async () => {
+  it('should return valid result if document transitions are valid - Rust', async () => {
     const fetchedDocuments = [
-      new Document(documents[1].toObject(), dataContract),
-      new Document(documents[2].toObject(), dataContract),
+      new Document(documentsJs[1].toObject(), dataContract),
+      new Document(documentsJs[2].toObject(), dataContract),
     ];
 
-    fetchDocumentsMock.resolves(fetchedDocuments);
+    stateRepositoryMock.fetchDocuments.resolves(fetchedDocuments);
 
-    documents[1].setRevision(1);
-    documents[2].setRevision(1);
+    documentsJs[1].setRevision(1);
+    documentsJs[2].setRevision(1);
 
-    documentTransitions = getDocumentTransitionsFixture({
+    documentTransitionsJs = getDocumentTransitionsFixture({
       create: [],
-      replace: [documents[1]],
-      delete: [documents[2]],
+      replace: [documentsJs[1]],
+      delete: [documentsJs[2]],
     });
 
     stateTransition = new DocumentsBatchTransition({
-      ownerId,
-      contractId: dataContract.getId(),
-      transitions: documentTransitions.map((t) => t.toObject()),
+      ownerId: ownerIdJs,
+      contractId: dataContractJs.getId(),
+      transitions: documentTransitionsJs.map((t) => t.toObject()),
     }, [dataContract]);
 
-    stateTransition.setExecutionContext(executionContext);
-
-    const dataTriggersExecutionContext = new DataTriggerExecutionContext(
-      stateRepositoryMock,
-      ownerId,
-      dataContract,
-      executionContext,
+    const result = await validateDocumentsBatchTransitionState(
+      stateRepositoryMock, stateTransition,
     );
 
-    executeDataTriggersMock.resolves([
-      new DataTriggerExecutionResult(),
-    ]);
-
-    const result = await validateDocumentsBatchTransitionState(stateTransition);
-
     expect(result).to.be.an.instanceOf(ValidationResult);
     expect(result.isValid()).to.be.true();
 
-    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnceWithExactly(
-      dataContract.getId(),
-      new StateTransitionExecutionContext(),
-    );
+    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+    const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+    expect(fetchDataContractId.toBuffer()).to.deep.equal(dataContract.getId().toBuffer());
 
-    expect(fetchDocumentsMock).to.have.been.calledOnceWithExactly(
-      stateTransition.transitions,
-      executionContext,
-    );
+    expect(stateRepositoryMock.fetchDocuments).to.have.been.calledOnce();
+  });
 
-    expect(validateDocumentsUniquenessByIndicesMock).to.have.been.calledOnceWithExactly(
-      ownerId,
-      [documentTransitions[0]],
-      dataContract,
-      executionContext,
-    );
+  it('should return valid result if document transitions are valid - Rust', async () => {
+    const fetchedDocuments = [
+      new Document(documentsJs[1].toObject(), dataContract),
+      new Document(documentsJs[2].toObject(), dataContract),
+    ];
+
+    stateRepositoryMock.fetchDocuments.resolves(fetchedDocuments);
+
+    documentsJs[1].setRevision(1);
+    documentsJs[2].setRevision(1);
+
+    documentTransitionsJs = getDocumentTransitionsFixture({
+      create: [],
+      replace: [documentsJs[1]],
+      delete: [documentsJs[2]],
+    });
+
+    stateTransition = new DocumentsBatchTransition({
+      ownerId: ownerIdJs,
+      contractId: dataContractJs.getId(),
+      transitions: documentTransitionsJs.map((t) => t.toObject()),
+    }, [dataContract]);
 
-    expect(executeDataTriggersMock).to.have.been.calledOnceWithExactly(
-      documentTransitions,
-      dataTriggersExecutionContext,
+    const result = await validateDocumentsBatchTransitionState(
+      stateRepositoryMock, stateTransition,
     );
+
+    expect(result).to.be.an.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.true();
+
+    expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
+    const [fetchDataContractId] = stateRepositoryMock.fetchDataContract.getCall(0).args;
+    expect(fetchDataContractId.toBuffer()).to.deep.equal(dataContract.getId().toBuffer());
+
+    expect(stateRepositoryMock.fetchDocuments).to.have.been.calledOnce();
   });
 });