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

package/test/unit/document/DocumentFactory.spec.js

@@ -1,73 +1,102 @@
 const bs58 = require('bs58');
 
-const Document = require('@dashevo/dpp/lib/document/Document');
-
 const DocumentCreateTransition = require('@dashevo/dpp/lib/document/stateTransition/DocumentsBatchTransition/documentTransition/DocumentCreateTransition');
-
 const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentsFixture');
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
-const getDocumentTransitionsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentTransitionsFixture');
-
 const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
+const createDPPMock = require('@dashevo/dpp/lib/test/mocks/createDPPMock');
+const DocumentFactoryJS = require('@dashevo/dpp/lib/document/DocumentFactory');
 
-const Identifier = require('@dashevo/dpp/lib/identifier/Identifier');
+const createStateRepositoryMock = require('../../../lib/test/mocks/createStateRepositoryMock');
+const generateRandomIdentifierAsync = require('../../../lib/test/utils/generateRandomIdentifierAsync');
 
-const InvalidDocumentTypeError = require('@dashevo/dpp/lib/errors/InvalidDocumentTypeError');
-const InvalidDocumentError = require('@dashevo/dpp/lib/document/errors/InvalidDocumentError');
-const InvalidActionNameError = require('@dashevo/dpp/lib/document/errors/InvalidActionNameError');
-const NoDocumentsSuppliedError = require('@dashevo/dpp/lib/document/errors/NoDocumentsSuppliedError');
-const MismatchOwnerIdsError = require('@dashevo/dpp/lib/document/errors/MismatchOwnerIdsError');
-const InvalidInitialRevisionError = require('@dashevo/dpp/lib/document/errors/InvalidInitialRevisionError');
-const SerializedObjectParsingError = require('@dashevo/dpp/lib/errors/consensus/basic/decode/SerializedObjectParsingError');
+let {
+  Identifier, DocumentFactory, DataContract, Document, DocumentValidator, ProtocolVersionValidator,
+  InvalidDocumentTypeInDataContractError, InvalidDocumentError, JsonSchemaError,
+  NoDocumentsSuppliedError, MismatchOwnerIdsError, InvalidInitialRevisionError,
+  InvalidActionNameError,
+} = require('../../..');
 
-const generateRandomIdentifier = require('@dashevo/dpp/lib/test/utils/generateRandomIdentifier');
-const createDPPMock = require('@dashevo/dpp/lib/test/mocks/createDPPMock');
-const SomeConsensusError = require('@dashevo/dpp/lib/test/mocks/SomeConsensusError');
-const entropyGenerator = require('@dashevo/dpp/lib/util/entropyGenerator');
-const DocumentFactory = require('@dashevo/dpp/lib/document/DocumentFactory');
+const { default: loadWasmDpp } = require('../../..');
 
 describe('DocumentFactory', () => {
   let decodeProtocolEntityMock;
-  let generateEntropyMock;
   let validateDocumentMock;
   let fetchAndValidateDataContractMock;
+  let stateRepositoryMock;
+  let ownerIdJs;
   let ownerId;
   let dataContract;
+  let dataContractJs;
   let document;
+  let documentJs;
+  let documentsJs;
   let documents;
   let rawDocument;
+  let rawDocumentJs;
+  let factoryJs;
   let factory;
   let fakeTime;
   let fakeTimeDate;
-  let entropy;
   let dppMock;
+  let dataContractId;
+  let documentValidator;
+
+  beforeEach(async () => {
+    ({
+      Identifier, ProtocolVersionValidator, DocumentValidator, DocumentFactory,
+      DataContract, Document,
+      // Errors:
+      InvalidDocumentTypeInDataContractError,
+      InvalidDocumentError,
+      JsonSchemaError,
+      NoDocumentsSuppliedError,
+      MismatchOwnerIdsError,
+      InvalidInitialRevisionError,
+      InvalidActionNameError,
+    } = await loadWasmDpp());
+  });
 
   beforeEach(function beforeEach() {
-    ({ ownerId } = getDocumentsFixture);
-    dataContract = getDataContractFixture();
+    const protocolValidator = new ProtocolVersionValidator();
+    documentValidator = new DocumentValidator(protocolValidator);
+
+    ({ ownerId: ownerIdJs } = getDocumentsFixture);
+    ownerId = Identifier.from(ownerIdJs);
+
+    dataContractJs = getDataContractFixture();
+    dataContract = DataContract.fromBuffer(dataContractJs.toBuffer());
+    const dc = DataContract.fromBuffer(dataContractJs.toBuffer());
+    dataContractId = dataContractJs.getId().toBuffer();
+
+    documentsJs = getDocumentsFixture(dataContractJs);
+    documents = documentsJs.map((d) => {
+      const doc = new Document(d.toObject(), dataContract);
+      doc.setEntropy(d.entropy);
+      return doc;
+    });
 
-    documents = getDocumentsFixture(dataContract);
-    ([,,, document] = documents);
+    ([, , , documentJs] = documentsJs);
+    rawDocumentJs = documentJs.toObject();
+    ([, , , document] = documents);
     rawDocument = document.toObject();
 
     decodeProtocolEntityMock = this.sinonSandbox.stub();
-    generateEntropyMock = this.sinonSandbox.stub(entropyGenerator, 'generate');
     validateDocumentMock = this.sinonSandbox.stub();
 
     validateDocumentMock.returns(new ValidationResult());
 
-    entropy = bs58.decode('789');
-
-    generateEntropyMock.returns(entropy);
-
     const fetchContractResult = new ValidationResult();
-    fetchContractResult.setData(dataContract);
+    fetchContractResult.setData(dataContractJs);
 
-    fetchAndValidateDataContractMock = this.sinonSandbox.stub().returns(fetchContractResult);
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchDataContract.resolves(dc);
 
+    fetchAndValidateDataContractMock = this.sinonSandbox.stub().returns(fetchContractResult);
     dppMock = createDPPMock();
 
-    factory = new DocumentFactory(
+    factory = new DocumentFactory(1, documentValidator, stateRepositoryMock);
+    factoryJs = new DocumentFactoryJS(
       dppMock,
       validateDocumentMock,
       fetchAndValidateDataContractMock,
@@ -80,67 +109,70 @@ describe('DocumentFactory', () => {
 
   afterEach(() => {
     fakeTime.reset();
-    generateEntropyMock.restore();
   });
 
   describe('create', () => {
     it('should return new Document with specified type and data', () => {
+      // NiceDocument is used instead of IndexedDocument, because the NiceDocument
+      // should be valid for this test and it passes the DataContract validation.
+      // The previous version of test passed due to the fact that
+      // the mocked DataContract validator always returned true.
+      const [niceDocument] = documentsJs;
+
+      const newRawDocument = niceDocument.toObject();
       const contractId = bs58.decode('FQco85WbwNgb5ix8QQAH6wurMcgEC5ENSCv5ixG9cj12');
       const name = 'Cutie';
 
-      ownerId = bs58.decode('5zcXZpTLWFwZjKjq3ME5KVavtZa9YUaZESVzrndehBhq');
-      dataContract.id = Identifier.from(contractId);
+      ownerIdJs = bs58.decode('5zcXZpTLWFwZjKjq3ME5KVavtZa9YUaZESVzrndehBhq');
+      ownerId = Identifier.from(ownerIdJs);
+
+      dataContract.setId(Identifier.from(contractId));
 
       const newDocument = factory.create(
         dataContract,
-        ownerId,
-        rawDocument.$type,
+        ownerIdJs,
+        newRawDocument.$type,
         { name },
       );
 
       expect(newDocument).to.be.an.instanceOf(Document);
 
-      expect(newDocument.getType()).to.equal(rawDocument.$type);
+      expect(newDocument.getType()).to.equal(newRawDocument.$type);
 
       expect(newDocument.get('name')).to.equal(name);
 
       expect(newDocument.getDataContractId().toBuffer()).to.deep.equal(contractId);
-      expect(newDocument.getOwnerId().toBuffer()).to.deep.equal(ownerId);
 
-      expect(generateEntropyMock).to.have.been.calledOnce();
-      expect(newDocument.getEntropy()).to.deep.equal(entropy);
+      expect(newDocument.getOwnerId().toBuffer()).to.deep.equal(ownerIdJs);
 
       expect(newDocument.getRevision()).to.equal(DocumentCreateTransition.INITIAL_REVISION);
 
-      expect(newDocument.getId()).to.deep.equal(bs58.decode('B99gjrjq6R1FXwGUQnoP7VrmCDDT1PbKprUNzjVbxXfz'));
+      // in case of rust version, it is impossible to test the ID, because the ID
+      // is generated based on entropy generator which generates different output
+      // every time and it cannot be mocked. ID generation should be verified
+      // in a true unit test. Not here.
+      expect(newDocument.getEntropy()).not.to.deep.be.equal(Buffer.alloc(32));
 
-      expect(newDocument.getCreatedAt().getTime()).to.be.equal(fakeTimeDate.getTime());
-      expect(newDocument.getCreatedAt().getTime()).to.equal(newDocument.getUpdatedAt().getTime());
+      expect(newDocument.getCreatedAt()).to.be.an('number');
     });
 
     it('should throw an error if type is not defined', () => {
       const type = 'wrong';
 
       try {
-        factory.create(dataContract, ownerId, type);
+        factory.create(dataContract, ownerId, type, {});
 
         expect.fail('InvalidDocumentTypeError should be thrown');
       } catch (e) {
-        expect(e).to.be.an.instanceOf(InvalidDocumentTypeError);
+        expect(e).to.be.an.instanceOf(InvalidDocumentTypeInDataContractError);
         expect(e.getType()).to.equal(type);
-        expect(e.getDataContract()).to.equal(dataContract);
+        expect(e.getDataContractId().toBuffer()).to.deep.equal(dataContractId);
       }
     });
 
-    it('should throw an error if validation faled', () => {
-      const error = new Error('validation failed');
-      const validationResult = new ValidationResult();
-      validationResult.addError(error);
-
-      validateDocumentMock.returns(validationResult);
-
+    it('should throw an error if validation failed', () => {
       try {
-        factory.create(dataContract, ownerId, rawDocument.$type);
+        factory.create(dataContract, ownerId, rawDocumentJs.$type, {});
 
         expect.fail('InvalidDocumentError should be thrown');
       } catch (e) {
@@ -151,45 +183,25 @@ describe('DocumentFactory', () => {
 
   describe('createFromObject', () => {
     it('should return new Data Contract with data from passed object', async () => {
-      validateDocumentMock.returns(new ValidationResult());
-
       const result = await factory.createFromObject(rawDocument);
 
       expect(result).to.be.an.instanceOf(Document);
       expect(result.toObject()).to.deep.equal(document.toObject());
 
-      expect(fetchAndValidateDataContractMock).to.have.been.calledOnceWithExactly(rawDocument);
-
-      expect(validateDocumentMock).to.have.been.calledOnceWithExactly(
-        rawDocument, dataContract,
-      );
+      expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
     });
 
-    it('should return new Document without validation if "skipValidation" option is passed', async function it() {
-      const resultMock = {
-        isValid: () => true,
-        merge: this.sinonSandbox.stub(),
-        getData: () => getDataContractFixture(),
-      };
-
-      fetchAndValidateDataContractMock.resolves(resultMock);
-
+    it('should return new Document without validation if "skipValidation" option is passed - Rust', async () => {
+      delete rawDocument.lastName;
       const result = await factory.createFromObject(rawDocument, { skipValidation: true });
-
       expect(result).to.be.an.instanceOf(Document);
-      expect(result.toObject()).to.deep.equal(document.toObject());
 
-      expect(fetchAndValidateDataContractMock).to.have.been.calledOnceWithExactly(rawDocument);
-      expect(validateDocumentMock).to.have.not.been.called();
-      expect(resultMock.merge).to.have.not.been.called();
+      expect(result.toObject()).to.deep.equal(rawDocument);
+      expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
     });
 
     it('should throw InvalidDocumentError if passed object is not valid', async () => {
-      const validationError = new SomeConsensusError('test');
-
-      validateDocumentMock.returns(
-        new ValidationResult([validationError]),
-      );
+      delete rawDocument.lastName;
 
       try {
         await factory.createFromObject(rawDocument);
@@ -197,41 +209,44 @@ describe('DocumentFactory', () => {
         expect.fail('InvalidDocumentError should be thrown');
       } catch (e) {
         expect(e).to.be.an.instanceOf(InvalidDocumentError);
-
         expect(e.getErrors()).to.have.length(1);
-        expect(e.getRawDocument()).to.equal(rawDocument);
 
-        const [consensusError] = e.getErrors();
-        expect(consensusError).to.equal(validationError);
+        // Identifiers don't survive conversion back and forth unless done through
+        // a Document constructor
+        const rawDocumentFromError = e.getRawDocument();
+        rawDocumentFromError.$id = Buffer.from(rawDocumentFromError.$id);
+        rawDocumentFromError.$dataContractId = Buffer.from(rawDocumentFromError.$dataContractId);
+        rawDocumentFromError.$ownerId = Buffer.from(rawDocumentFromError.$ownerId);
+
+        expect(rawDocumentFromError).to.deep.equal(rawDocument);
 
-        expect(fetchAndValidateDataContractMock).to.have.been.calledOnceWithExactly(rawDocument);
-        expect(validateDocumentMock).to.have.been.calledOnceWithExactly(rawDocument, dataContract);
+        const [consensusError] = e.getErrors();
+        expect(consensusError).to.be.an.instanceOf(JsonSchemaError);
       }
     });
 
     it('should throw InvalidDocumentError if Data Contract is not valid', async () => {
-      const fetchContractError = new SomeConsensusError('error');
-
-      fetchAndValidateDataContractMock.returns(
-        new ValidationResult([fetchContractError]),
-      );
+      const dc = DataContract.fromBuffer(dataContractJs.toBuffer());
+      dc.setDocuments({ '$%34': { '^&*': 'Keck' } });
+      const oldDataContract = DataContract.fromBuffer(dataContractJs.toBuffer());
+      stateRepositoryMock.fetchDataContract.resolves(dc);
 
       try {
-        await factory.createFromObject(rawDocument);
+        await factory.createFromObject(rawDocumentJs);
 
         expect.fail('InvalidDocumentError should be thrown');
       } catch (e) {
         expect(e).to.be.an.instanceOf(InvalidDocumentError);
 
         expect(e.getErrors()).to.have.length(1);
-        expect(e.getRawDocument()).to.equal(rawDocument);
+        expect(
+          (new Document(e.getRawDocument(), oldDataContract).toObject()),
+        ).to.deep.equal(rawDocumentJs);
 
-        const [consensusError] = e.getErrors();
-
-        expect(consensusError).to.equal(fetchContractError);
+        expect(stateRepositoryMock.fetchDataContract.callCount).to.be.equal(1);
+        const callArguments = stateRepositoryMock.fetchDataContract.getCall(0).args[0];
 
-        expect(fetchAndValidateDataContractMock).to.have.been.calledOnceWith(rawDocument);
-        expect(validateDocumentMock).to.have.not.been.called();
+        expect(callArguments.toBuffer()).to.be.deep.equal(dc.getId().toBuffer());
       }
     });
   });
@@ -240,41 +255,27 @@ describe('DocumentFactory', () => {
     let serializedDocument;
 
     beforeEach(function beforeEach() {
-      this.sinonSandbox.stub(factory, 'createFromObject');
+      this.sinonSandbox.stub(factoryJs, 'createFromObject');
       // eslint-disable-next-line prefer-destructuring
-      document = documents[8]; // document with binary fields
+      documentJs = documentsJs[8]; // document with binary fields
 
-      serializedDocument = document.toBuffer();
-      rawDocument = document.toObject();
+      serializedDocument = documentJs.toBuffer();
+      rawDocumentJs = documentJs.toObject();
     });
 
     afterEach(() => {
-      factory.createFromObject.restore();
+      factoryJs.createFromObject.restore();
     });
 
     it('should return new Document from serialized one', async () => {
-      decodeProtocolEntityMock.returns([rawDocument.$protocolVersion, rawDocument]);
-
-      factory.createFromObject.returns(document);
-
       const result = await factory.createFromBuffer(serializedDocument);
-
-      expect(result).to.equal(document);
-
-      expect(factory.createFromObject).to.have.been.calledOnceWith(rawDocument);
-
-      expect(decodeProtocolEntityMock).to.have.been.calledOnceWith(
-        serializedDocument,
-      );
+      expect(result.toObject()).to.deep.equal(documentJs.toObject());
+      expect(stateRepositoryMock.fetchDataContract).to.have.been.calledOnce();
     });
 
     it('should throw InvalidDocumentError if the decoding fails with consensus error', async () => {
-      const parsingError = new SerializedObjectParsingError(
-        serializedDocument,
-        new Error(),
-      );
-
-      decodeProtocolEntityMock.throws(parsingError);
+      documentJs.data = 'Not a valid data';
+      serializedDocument = documentJs.toBuffer();
 
       try {
         await factory.createFromBuffer(serializedDocument);
@@ -282,41 +283,37 @@ describe('DocumentFactory', () => {
         expect.fail('should throw InvalidDocumentError');
       } catch (e) {
         expect(e).to.be.an.instanceOf(InvalidDocumentError);
-
-        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);
-
+    it('should throw an error if decoding fails with any other error - Rust', async () => {
+      const serializeDocument = Buffer.alloc(160, 1);
       try {
-        await factory.createFromBuffer(serializedDocument);
+        await factory.createFromBuffer(serializeDocument);
 
         expect.fail('should throw an error');
       } catch (e) {
-        expect(e).to.equal(parsingError);
+        // TODO - parsing errors are not handled yet, as they happen directly in the rust code when
+        //  trying to access a field
+        expect(e).to.startsWith('Error conversion not implemented:');
       }
     });
-  });
-
-  describe('createStateTransition', () => {
-    it('should throw and error if documents have unknown action', () => {
+  }); describe('createStateTransition', () => {
+    it('should throw and error if documents have unknown action', async () => {
       try {
         factory.createStateTransition({
           unknown: documents,
         });
+
         expect.fail('Error was not thrown');
       } catch (e) {
+        // documents of unknown actions are filtered out
         expect(e).to.be.an.instanceOf(InvalidActionNameError);
         expect(e.getActions()).to.have.deep.members(['unknown']);
       }
     });
 
-    it('should throw and error if no documents were supplied', () => {
+    it('should throw and error if no documents were supplied', async () => {
       try {
         factory.createStateTransition({});
         expect.fail('Error was not thrown');
@@ -325,8 +322,11 @@ describe('DocumentFactory', () => {
       }
     });
 
-    it('should throw and error if documents have mixed owner ids', () => {
-      documents[0].ownerId = generateRandomIdentifier().toBuffer();
+    it('should throw and error if documents have mixed owner ids', async () => {
+      const newId = await generateRandomIdentifierAsync();
+      documents[0].setOwnerId(newId);
+      const rawDocuments = documents.map((d) => d.toObject());
+
       try {
         factory.createStateTransition({
           create: documents,
@@ -334,12 +334,14 @@ describe('DocumentFactory', () => {
         expect.fail('Error was not thrown');
       } catch (e) {
         expect(e).to.be.an.instanceOf(MismatchOwnerIdsError);
-        expect(e.getDocuments()).to.have.deep.members(documents);
+        const rawDocumentsFromError = e.getDocuments().map((d) => d.toObject());
+        expect(rawDocumentsFromError).to.have.deep.members(rawDocuments);
       }
     });
 
-    it('should throw and error if create documents have invalid initial version', () => {
+    it('should throw and error if create documents have invalid initial version', async () => {
       documents[0].setRevision(3);
+      const expectedDocument = documents[0].toObject();
       try {
         factory.createStateTransition({
           create: documents,
@@ -347,30 +349,28 @@ describe('DocumentFactory', () => {
         expect.fail('Error was not thrown');
       } catch (e) {
         expect(e).to.be.an.instanceOf(InvalidInitialRevisionError);
-        expect(e.getDocument()).to.deep.equal(documents[0]);
+        expect(e.getDocument().toObject()).to.deep.equal(expectedDocument);
       }
     });
 
-    it('should create DocumentsBatchTransition with passed documents', () => {
-      const [newDocument] = getDocumentsFixture(dataContract);
-
-      fakeTime.tick(1000);
+    it('should create DocumentsBatchTransition with passed documents', async () => {
+      const [newDocumentJs] = getDocumentsFixture(dataContractJs);
+      const newDocument = new Document(newDocumentJs.toObject(), dataContract);
 
       const stateTransition = factory.createStateTransition({
         create: documents,
         replace: [newDocument],
       });
 
-      const expectedTransitions = getDocumentTransitionsFixture({
-        create: documents,
-        replace: [newDocument],
+      const stateTransitionJs = factoryJs.createStateTransition({
+        create: documentsJs,
+        replace: [newDocumentJs],
       });
 
-      expectedTransitions.slice(-1).updatedAt = new Date();
+      const transitions = stateTransition.getTransitions().map((t) => t.toObject());
+      const expectedTransitions = stateTransitionJs.getTransitions().map((t) => t.toObject());
 
-      expect(stateTransition.getTransitions()).to.deep.equal(
-        expectedTransitions,
-      );
+      expect(transitions).to.deep.includes.members(expectedTransitions);
     });
   });
 });

package/test/unit/document/fetchAndValidateDataContractFactory.spec.js

@@ -5,51 +5,89 @@ const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createSta
 const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentsFixture');
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 
-const ValidationResult = require('@dashevo/dpp/lib/validation/ValidationResult');
+const ValidationResultJs = require('@dashevo/dpp/lib/validation/ValidationResult');
 
-const MissingDataContractIdError = require('@dashevo/dpp/lib/errors/consensus/basic/document/MissingDataContractIdError');
-const DataContractNotPresentError = require('@dashevo/dpp/lib/errors/consensus/basic/document/DataContractNotPresentError');
+const MissingDataContractIdErrorJs = require('@dashevo/dpp/lib/errors/consensus/basic/document/MissingDataContractIdError');
+const DataContractNotPresentErrorJs = require('@dashevo/dpp/lib/errors/consensus/basic/document/DataContractNotPresentError');
 
 const { expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
 
+const { default: loadWasmDpp } = require('../../../dist');
+
+let ValidationResult;
+let DataContract;
+
 describe('fetchAndValidateDataContractFactory', () => {
+  let stateRepositoryMockJs;
   let stateRepositoryMock;
+  let fetchAndValidateDataContractJs;
   let fetchAndValidateDataContract;
   let rawDocument;
 
+  beforeEach(async () => {
+    ({
+      DataContract,
+      fetchAndValidateDataContract,
+      ValidationResult,
+    } = await loadWasmDpp());
+  });
+
   beforeEach(function beforeEach() {
-    const dataContract = getDataContractFixture();
+    const dataContractJs = getDataContractFixture();
+    const dataContract = DataContract.fromBuffer(dataContractJs.toBuffer());
 
-    const [document] = getDocumentsFixture(dataContract);
+    const [document] = getDocumentsFixture(dataContractJs);
     rawDocument = document.toObject();
 
-    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMockJs = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMockJs.fetchDataContract.resolves(dataContractJs);
 
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
     stateRepositoryMock.fetchDataContract.resolves(dataContract);
 
-    fetchAndValidateDataContract = fetchAndValidateDataContractFactory(
-      stateRepositoryMock,
+    fetchAndValidateDataContractJs = fetchAndValidateDataContractFactory(
+      stateRepositoryMockJs,
     );
   });
 
   it('should return with invalid result if $dataContractId is not present', async () => {
     delete rawDocument.$dataContractId;
 
-    const result = await fetchAndValidateDataContract(rawDocument);
+    const result = await fetchAndValidateDataContractJs(rawDocument);
 
-    expectValidationError(result, MissingDataContractIdError);
+    expectValidationError(result, MissingDataContractIdErrorJs);
 
     const [error] = result.getErrors();
 
     expect(error.getCode()).to.equal(1025);
   });
 
+  it('should return with invalid result if $dataContractId is not present - Rust', async () => {
+    delete rawDocument.$dataContractId;
+
+    const result = await fetchAndValidateDataContract(stateRepositoryMock, rawDocument);
+
+    const [error] = result.getErrors();
+    expect(error.getCode()).to.equal(1025);
+  });
+
   it('should return with invalid result if Data Contract is not present', async () => {
-    stateRepositoryMock.fetchDataContract.resolves(null);
+    stateRepositoryMockJs.fetchDataContract.resolves(null);
 
-    const result = await fetchAndValidateDataContract(rawDocument);
+    const result = await fetchAndValidateDataContractJs(rawDocument);
 
-    expectValidationError(result, DataContractNotPresentError);
+    expectValidationError(result, DataContractNotPresentErrorJs);
+
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(1018);
+    expect(error.getDataContractId()).to.deep.equal(rawDocument.$dataContractId);
+  });
+
+  it('should return with invalid result if Data Contract is not present - Rust', async () => {
+    stateRepositoryMock.fetchDataContract.resolves(null);
+
+    const result = await fetchAndValidateDataContract(stateRepositoryMock, rawDocument);
 
     const [error] = result.getErrors();
 
@@ -58,7 +96,14 @@ describe('fetchAndValidateDataContractFactory', () => {
   });
 
   it('should return valid result', async () => {
-    const result = await fetchAndValidateDataContract(rawDocument);
+    const result = await fetchAndValidateDataContractJs(rawDocument);
+
+    expect(result).to.be.an.instanceOf(ValidationResultJs);
+    expect(result.isValid()).to.be.true();
+  });
+
+  it('should return valid result - Rust', async () => {
+    const result = await fetchAndValidateDataContract(stateRepositoryMock, rawDocument);
 
     expect(result).to.be.an.instanceOf(ValidationResult);
     expect(result.isValid()).to.be.true();