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

package/test/unit/document/stateTransition/DocumetsBatchTransition/validation/basic/findDuplicatesById.spec.js

@@ -1,25 +1,29 @@
-const findDuplicateDocuments = require('@dashevo/dpp/lib/document/stateTransition/DocumentsBatchTransition/validation/basic/findDuplicatesById');
-
 const getDocumentTransitionsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentTransitionsFixture');
+const { default: loadWasmDpp } = require('../../../../../../../dist');
+
+let findDuplicatesById;
 
 describe('findDuplicatesById', () => {
   let rawDocumentTransitions;
 
-  beforeEach(() => {
+  beforeEach(async () => {
+    ({
+      findDuplicatesById,
+    } = await loadWasmDpp());
     rawDocumentTransitions = getDocumentTransitionsFixture().map((t) => t.toObject());
   });
 
-  it('should return empty array if there are no duplicated Documents', () => {
-    const result = findDuplicateDocuments(rawDocumentTransitions);
+  it('should return empty array if there are no duplicated Documents - Rust', () => {
+    const result = findDuplicatesById(rawDocumentTransitions);
 
     expect(result).to.be.an('array');
     expect(result).to.have.lengthOf(0);
   });
 
-  it('should return duplicated Documents', () => {
+  it('should return duplicated Documents - Rust', () => {
     rawDocumentTransitions.push(rawDocumentTransitions[0]);
 
-    const result = findDuplicateDocuments(rawDocumentTransitions);
+    const result = findDuplicatesById(rawDocumentTransitions);
 
     expect(result).to.be.an('array');
     expect(result).to.have.lengthOf(2);

package/test/unit/document/stateTransition/DocumetsBatchTransition/validation/basic/findDuplicatesByIndices.spec.js

@@ -1,21 +1,28 @@
-const Document = require('@dashevo/dpp/lib/document/Document');
-
-const findDuplicateDocumentsByIndices = require('@dashevo/dpp/lib/document/stateTransition/DocumentsBatchTransition/validation/basic/findDuplicatesByIndices');
+const DocumentJs = require('@dashevo/dpp/lib/document/Document');
 
 const getDataContractFixture = require('@dashevo/dpp/lib/test/fixtures/getDataContractFixture');
 const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentsFixture');
 const getDocumentTransitionsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentTransitionsFixture');
 
 const { generate: generateEntropy } = require('@dashevo/dpp/lib/util/entropyGenerator');
+const { default: loadWasmDpp } = require('../../../../../../../dist');
+
+let DataContract;
+let findDuplicatesByIndices;
 
 describe('findDuplicatesByIndices', () => {
   let documents;
+  let contractJs;
   let contract;
   let documentTransitions;
 
-  beforeEach(() => {
-    contract = getDataContractFixture();
-    contract.setDocumentSchema('nonUniqueIndexDocument', {
+  beforeEach(async () => {
+    ({
+      DataContract,
+      findDuplicatesByIndices,
+    } = await loadWasmDpp());
+    contractJs = getDataContractFixture();
+    contractJs.setDocumentSchema('nonUniqueIndexDocument', {
       indices: [
         {
           name: 'ownerIdLastName',
@@ -38,7 +45,7 @@ describe('findDuplicatesByIndices', () => {
       additionalProperties: false,
     });
 
-    contract.setDocumentSchema('singleDocument', {
+    contractJs.setDocumentSchema('singleDocument', {
       indices: [
         {
           name: 'ownerIdLastName',
@@ -61,31 +68,33 @@ describe('findDuplicatesByIndices', () => {
       additionalProperties: false,
     });
 
-    documents = getDocumentsFixture(contract);
+    contract = DataContract.fromBuffer(contractJs.toBuffer());
+
+    documents = getDocumentsFixture(contractJs);
     documents.forEach((doc) => {
       // eslint-disable-next-line no-param-reassign
-      doc.dataContract = contract;
+      doc.dataContract = contractJs;
       // eslint-disable-next-line no-param-reassign
-      doc.dataContractId = contract.getId();
+      doc.dataContractId = contractJs.getId();
     });
 
     const [, , , william] = documents;
 
-    let document = new Document({
+    let document = new DocumentJs({
       ...william.toObject(),
       $type: 'nonUniqueIndexDocument',
       $entropy: generateEntropy(),
-    }, contract);
+    }, contractJs);
 
     document.setEntropy(generateEntropy());
 
     documents.push(document);
 
-    document = new Document({
+    document = new DocumentJs({
       ...william.toObject(),
       $type: 'singleDocument',
       $entropy: generateEntropy(),
-    }, contract);
+    }, contractJs);
 
     document.setEntropy(generateEntropy());
 
@@ -96,7 +105,7 @@ describe('findDuplicatesByIndices', () => {
     }).map((t) => t.toObject());
   });
 
-  it('should return duplicate documents if they are present', () => {
+  it('should return duplicate documents if they are present - Rust', () => {
     const [, , , , leon] = documents;
 
     leon.set('lastName', 'Birkin');
@@ -105,7 +114,9 @@ describe('findDuplicatesByIndices', () => {
       create: documents,
     }).map((t) => t.toObject());
 
-    const duplicates = findDuplicateDocumentsByIndices(documentTransitions, contract);
+    const duplicates = findDuplicatesByIndices(documentTransitions, contract);
+
+    expect(duplicates.length).to.equal(2);
     expect(duplicates).to.have.deep.members(
       [
         documentTransitions[3],
@@ -114,8 +125,8 @@ describe('findDuplicatesByIndices', () => {
     );
   });
 
-  it('should return an empty array of there are no duplicates', () => {
-    const duplicates = findDuplicateDocumentsByIndices(documentTransitions, contract);
+  it('should return an empty array of there are no duplicates - Rust', () => {
+    const duplicates = findDuplicatesByIndices(documentTransitions, contract);
 
     expect(duplicates.length).to.equal(0);
   });

package/test/unit/document/stateTransition/DocumetsBatchTransition/validation/basic/validatePartialCompoundIndices.spec.js

@@ -1,42 +1,51 @@
-const validatePartialCompoundIndices = require('@dashevo/dpp/lib/document/stateTransition/DocumentsBatchTransition/validation/basic/validatePartialCompoundIndices');
-const InconsistentCompoundIndexDataError = require('@dashevo/dpp/lib/errors/consensus/basic/document/InconsistentCompoundIndexDataError');
-
 const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentsFixture');
 const getContractFixture = 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 { expectValidationError } = require('@dashevo/dpp/lib/test/expect/expectError');
+const { default: loadWasmDpp } = require('../../../../../../../dist');
+
+let DataContract;
+let validatePartialCompoundIndices;
+let InconsistentCompoundIndexDataError;
+let ValidationResult;
 
 describe('validatePartialCompoundIndices', () => {
-  let documents;
+  let documentsJs;
   let rawDocumentTransitions;
+  let dataContractJs;
   let dataContract;
-  let ownerId;
 
-  beforeEach(() => {
-    dataContract = getContractFixture();
-    ownerId = dataContract.getOwnerId();
+  beforeEach(async () => {
+    ({
+      DataContract,
+      validatePartialCompoundIndices,
+      ValidationResult,
+      // Errors:
+      InconsistentCompoundIndexDataError,
+    } = await loadWasmDpp());
+
+    dataContractJs = getContractFixture();
+    dataContract = DataContract.fromBuffer(dataContractJs.toBuffer());
   });
 
-  it('should return invalid result if compound index contains not all fields', () => {
-    const document = getDocumentsFixture(dataContract)[9];
-    document.set('lastName', undefined);
+  it('should return invalid result if compound index contains not all fields - Rust', () => {
+    const documentJs = getDocumentsFixture(dataContractJs)[9];
+    documentJs.set('lastName', undefined);
 
-    documents = [document];
+    documentsJs = [documentJs];
     rawDocumentTransitions = getDocumentTransitionsFixture({
-      create: documents,
+      create: documentsJs,
     }).map((documentTransition) => documentTransition.toObject());
 
-    const result = validatePartialCompoundIndices(ownerId, rawDocumentTransitions, dataContract);
+    const result = validatePartialCompoundIndices(rawDocumentTransitions, dataContract);
 
-    expectValidationError(result, InconsistentCompoundIndexDataError);
+    expect(result.isValid()).is.false();
 
     const [error] = result.getErrors();
-
+    expect(error).is.instanceOf(InconsistentCompoundIndexDataError);
     expect(error.getCode()).to.equal(1021);
 
-    const { optionalUniqueIndexedDocument } = dataContract.getDocuments();
+    const { optionalUniqueIndexedDocument } = dataContractJs.getDocuments();
 
     expect(error.getIndexedProperties()).to.deep.equal(
       optionalUniqueIndexedDocument.indices[1].properties.map((i) => Object.keys(i)[0]),
@@ -45,29 +54,29 @@ describe('validatePartialCompoundIndices', () => {
     expect(error.getDocumentType()).to.equal('optionalUniqueIndexedDocument');
   });
 
-  it('should return valid result if compound index contains no fields', () => {
-    const document = getDocumentsFixture(dataContract)[8];
-    document.setData({ });
+  it('should return valid result if compound index contains no fields - Rust', () => {
+    const document = getDocumentsFixture(dataContractJs)[8];
+    document.setData({});
 
-    documents = [document];
+    documentsJs = [document];
 
     rawDocumentTransitions = getDocumentTransitionsFixture({
-      create: documents,
+      create: documentsJs,
     }).map((documentTransition) => documentTransition.toObject());
 
-    const result = validatePartialCompoundIndices(ownerId, rawDocumentTransitions, dataContract);
+    const result = validatePartialCompoundIndices(rawDocumentTransitions, dataContract);
 
     expect(result).to.be.an.instanceOf(ValidationResult);
     expect(result.isValid()).to.be.true();
   });
 
-  it('should return valid result if compound index contains all fields', () => {
-    documents = [getDocumentsFixture(dataContract)[8]];
+  it('should return valid result if compound index contains all fields - Rust', () => {
+    documentsJs = [getDocumentsFixture(dataContractJs)[8]];
     rawDocumentTransitions = getDocumentTransitionsFixture({
-      create: documents,
+      create: documentsJs,
     }).map((documentTransition) => documentTransition.toObject());
 
-    const result = validatePartialCompoundIndices(ownerId, rawDocumentTransitions, dataContract);
+    const result = validatePartialCompoundIndices(rawDocumentTransitions, dataContract);
 
     expect(result).to.be.an.instanceOf(ValidationResult);
     expect(result.isValid()).to.be.true();

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

@@ -1,128 +1,90 @@
 const getDocumentsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentsFixture');
 const getDocumentTransitionsFixture = require('@dashevo/dpp/lib/test/fixtures/getDocumentTransitionsFixture');
 
-const fetchDocumentsFactory = require('@dashevo/dpp/lib/document/stateTransition/DocumentsBatchTransition/validation/state/fetchDocumentsFactory');
-
 const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
 
-const generateRandomIdentifier = require('@dashevo/dpp/lib/test/utils/generateRandomIdentifier');
-const StateTransitionExecutionContext = require('@dashevo/dpp/lib/stateTransition/StateTransitionExecutionContext');
+const generateRandomIdentifierJs = require('@dashevo/dpp/lib/test/utils/generateRandomIdentifier');
+
+const sinon = require('sinon');
+const { default: loadWasmDpp } = require('../../../../../../../dist');
+
+let Identifier;
+let DataContract;
+let Document;
+let fetchDocuments;
+let DocumentTransition;
+let DocumentCreateTransition;
+let StateTransitionExecutionContext;
 
 describe('fetchDocumentsFactory', () => {
-  let fetchDocuments;
   let stateRepositoryMock;
+  let documentTransitionsJs;
   let documentTransitions;
+  let documentsJs;
   let documents;
   let executionContext;
 
-  beforeEach(function beforeEach() {
-    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+  beforeEach(async function beforeEach() {
+    ({
+      Identifier,
+      Document,
+      DataContract,
+      DocumentTransition,
+      DocumentCreateTransition,
+      StateTransitionExecutionContext,
+      fetchDocuments,
+    } = await loadWasmDpp());
 
-    fetchDocuments = fetchDocumentsFactory(stateRepositoryMock);
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
 
     executionContext = new StateTransitionExecutionContext();
 
-    documents = getDocumentsFixture().slice(0, 5);
+    documentsJs = getDocumentsFixture().slice(0, 5);
+    const dataContractBuffer = documentsJs[0].dataContract.toBuffer();
+    const dataContract = DataContract.fromBuffer(dataContractBuffer);
 
-    documentTransitions = getDocumentTransitionsFixture({
-      create: documents,
+    documents = documentsJs.map((document) => new Document(
+      document.toObject(), dataContract.clone(),
+    ));
+    documentTransitionsJs = getDocumentTransitionsFixture({
+      create: documentsJs,
     });
+    documentTransitions = documentTransitionsJs.map(
+      (transition) => DocumentTransition.fromTransitionCreate(
+        new DocumentCreateTransition(
+          transition.toObject(), dataContract.clone(),
+        ),
+      ),
+    );
   });
 
-  it('should fetch specified Documents using StateRepository', async () => {
-    const firstDocumentDataContractId = generateRandomIdentifier().toBuffer();
+  it('should fetch specified Documents using StateRepository - Rust', async () => {
+    const firstDocumentDataContractId = generateRandomIdentifierJs().toBuffer();
 
-    documentTransitions[0].dataContractId = firstDocumentDataContractId;
-    documents[0].dataContractId = firstDocumentDataContractId;
+    documentTransitions[0].setDataContractId(firstDocumentDataContractId);
+    documents[0].setDataContractId(firstDocumentDataContractId);
 
     stateRepositoryMock.fetchDocuments.withArgs(
-      documentTransitions[0].getDataContractId(),
+      sinon.match.instanceOf(Identifier),
       documentTransitions[0].getType(),
     ).resolves([documents[0]]);
 
     stateRepositoryMock.fetchDocuments.withArgs(
-      documentTransitions[1].getDataContractId(),
+      sinon.match.instanceOf(Identifier),
       documentTransitions[1].getType(),
     ).resolves([documents[1], documents[2]]);
 
     stateRepositoryMock.fetchDocuments.withArgs(
-      documentTransitions[3].getDataContractId(),
-      documentTransitions[3].getType(),
+      sinon.match.instanceOf(Identifier),
+      documentTransitionsJs[3].getType(),
     ).resolves([documents[3], documents[4]]);
 
-    const fetchedDocuments = await fetchDocuments(documentTransitions, executionContext);
-
-    expect(stateRepositoryMock.fetchDocuments).to.have.been.calledThrice();
-
-    const callArgsOne = [
-      documents[0].getDataContractId(),
-      documents[0].getType(),
-      {
-        where: [
-          ['$id', 'in', [documents[0].getId()]],
-        ],
-        orderBy: [
-          [
-            '$id',
-            'asc',
-          ],
-        ],
-      },
-      executionContext,
-    ];
-
-    const callArgsTwo = [
-      documents[1].getDataContractId(),
-      documents[1].getType(),
-      {
-        where: [
-          ['$id', 'in', [
-            documents[1].getId(),
-            documents[2].getId(),
-          ]],
-        ],
-        orderBy: [
-          [
-            '$id',
-            'asc',
-          ],
-        ],
-      },
-      executionContext,
-    ];
-
-    const callArgsThree = [
-      documents[3].getDataContractId(),
-      documents[3].getType(),
-      {
-        where: [
-          ['$id', 'in', [
-            documents[3].getId(),
-            documents[4].getId(),
-          ]],
-        ],
-        orderBy: [
-          [
-            '$id',
-            'asc',
-          ],
-        ],
-      },
+    await fetchDocuments(
+      stateRepositoryMock,
+      documentTransitions,
       executionContext,
-    ];
+    );
 
-    const callsArgs = [];
-    for (let i = 0; i < stateRepositoryMock.fetchDocuments.callCount; i++) {
-      const call = stateRepositoryMock.fetchDocuments.getCall(i);
-      callsArgs.push(call.args);
-    }
-
-    expect(callsArgs).to.have.deep.members([
-      callArgsOne,
-      callArgsTwo,
-      callArgsThree,
-    ]);
-
-    expect(fetchedDocuments).to.deep.equal(documents);
+    expect(stateRepositoryMock.fetchDocuments).to.have.been.calledThrice();
   });
 });