@dashevo/wasm-dpp 0.23.0-dev.10

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

@@ -0,0 +1,171 @@
+const Document = require('../../../../../lib/document/Document');
+const DocumentsBatchTransition = require(
+  '../../../../../lib/document/stateTransition/DocumentsBatchTransition/DocumentsBatchTransition',
+);
+
+const applyDocumentsBatchTransitionFactory = require(
+  '../../../../../lib/document/stateTransition/DocumentsBatchTransition/applyDocumentsBatchTransitionFactory',
+);
+
+const getDataContractFixture = require('../../../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentsFixture = require('../../../../../lib/test/fixtures/getDocumentsFixture');
+const getDocumentTransitionsFixture = require(
+  '../../../../../lib/test/fixtures/getDocumentTransitionsFixture',
+);
+
+const createStateRepositoryMock = require('../../../../../lib/test/mocks/createStateRepositoryMock');
+
+const protocolVersion = require('../../../../../lib/version/protocolVersion');
+const StateTransitionExecutionContext = require('../../../../../lib/stateTransition/StateTransitionExecutionContext');
+const DocumentNotProvidedError = require('../../../../../lib/document/errors/DocumentNotProvidedError');
+
+describe('applyDocumentsBatchTransitionFactory', () => {
+  let documents;
+  let dataContract;
+  let documentTransitions;
+  let ownerId;
+  let replaceDocument;
+  let stateTransition;
+  let documentsFixture;
+  let applyDocumentsBatchTransition;
+  let stateRepositoryMock;
+  let fetchDocumentsMock;
+  let executionContext;
+
+  beforeEach(function beforeEach() {
+    dataContract = getDataContractFixture();
+    documentsFixture = getDocumentsFixture(dataContract);
+
+    ownerId = getDocumentsFixture.ownerId;
+
+    replaceDocument = new Document({
+      ...documentsFixture[1].toObject(),
+      lastName: 'NotSoShiny',
+    }, dataContract);
+
+    documents = [replaceDocument, documentsFixture[2]];
+
+    documentTransitions = getDocumentTransitionsFixture({
+      create: [documentsFixture[0]],
+      replace: [documents[0]],
+      delete: [documents[1]],
+    });
+
+    stateTransition = new DocumentsBatchTransition({
+      protocolVersion: protocolVersion.latestVersion,
+      ownerId,
+      transitions: documentTransitions.map((t) => t.toObject()),
+    }, [dataContract]);
+
+    executionContext = new StateTransitionExecutionContext();
+
+    stateTransition.setExecutionContext(executionContext);
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchDataContract.resolves(dataContract);
+    stateRepositoryMock.fetchLatestPlatformBlockHeader.resolves({
+      time: {
+        seconds: 86400,
+      },
+    });
+
+    fetchDocumentsMock = this.sinonSandbox.stub();
+    fetchDocumentsMock.resolves([
+      replaceDocument,
+    ]);
+
+    applyDocumentsBatchTransition = applyDocumentsBatchTransitionFactory(
+      stateRepositoryMock,
+      fetchDocumentsMock,
+    );
+  });
+
+  it('should call `store`, `replace` and `remove` functions for specific type of transitions', async () => {
+    await applyDocumentsBatchTransition(stateTransition);
+
+    const replaceDocumentTransition = documentTransitions[1];
+
+    expect(fetchDocumentsMock).to.have.been.calledOnceWithExactly(
+      [replaceDocumentTransition],
+      executionContext,
+    );
+
+    expect(stateRepositoryMock.createDocument).to.have.been.calledOnce();
+    expect(stateRepositoryMock.updateDocument).to.have.been.calledOnce();
+
+    const callsArgs = [
+      ...stateRepositoryMock.createDocument.getCall(0).args,
+      ...stateRepositoryMock.updateDocument.getCall(0).args,
+    ];
+
+    expect(callsArgs).to.have.deep.members([
+      documentsFixture[0],
+      documents[0],
+      executionContext,
+      executionContext,
+    ]);
+
+    expect(stateRepositoryMock.removeDocument).to.have.been.calledOnceWithExactly(
+      documentTransitions[2].getDataContract(),
+      documentTransitions[2].getType(),
+      documentTransitions[2].getId(),
+      executionContext,
+    );
+  });
+
+  it('should throw an error if document was not provided for a replacement', async () => {
+    fetchDocumentsMock.resolves([]);
+
+    const replaceDocumentTransition = documentTransitions[1];
+
+    try {
+      await applyDocumentsBatchTransition(stateTransition);
+      expect.fail('Error was not thrown');
+    } catch (e) {
+      expect(e).to.be.an.instanceOf(DocumentNotProvidedError);
+      expect(e.getDocumentTransition()).to.deep.equal(replaceDocumentTransition);
+    }
+  });
+
+  it('should call `replace` functions on dry run', async () => {
+    documentTransitions = getDocumentTransitionsFixture({
+      create: [],
+      replace: [documents[0]],
+      delete: [],
+    });
+
+    stateTransition = new DocumentsBatchTransition({
+      protocolVersion: protocolVersion.latestVersion,
+      ownerId,
+      transitions: documentTransitions.map((t) => t.toObject()),
+    }, [dataContract]);
+
+    stateTransition.getExecutionContext().enableDryRun();
+
+    await applyDocumentsBatchTransition(stateTransition);
+
+    stateTransition.getExecutionContext().disableDryRun();
+
+    expect(stateRepositoryMock.fetchLatestPlatformBlockHeader).to.have.been.calledOnceWith();
+
+    const [documentTransition] = stateTransition.getTransitions();
+    const newDocument = new Document({
+      $protocolVersion: stateTransition.getProtocolVersion(),
+      $id: documentTransition.getId(),
+      $type: documentTransition.getType(),
+      $dataContractId: documentTransition.getDataContractId(),
+      $ownerId: stateTransition.getOwnerId(),
+      $createdAt: 86400 * 1000,
+      ...documentTransition.getData(),
+    }, documentTransition.getDataContract());
+
+    newDocument.setRevision(documentTransition.getRevision());
+    newDocument.setData(documentTransition.getData());
+    newDocument.setUpdatedAt(documentTransition.getUpdatedAt());
+
+    expect(stateRepositoryMock.updateDocument).to.have.been.calledOnceWithExactly(
+      newDocument,
+      executionContext,
+    );
+  });
+});

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

@@ -0,0 +1,25 @@
+const getDocumentTransitionsFixture = require('../../../../../../lib/test/fixtures/getDocumentTransitionsFixture');
+
+describe('DocumentCreateTransition', () => {
+  let documentTransition;
+
+  beforeEach(() => {
+    [documentTransition] = getDocumentTransitionsFixture();
+  });
+
+  describe('toJSON', () => {
+    it('should return json representation', () => {
+      const jsonDocumentTransition = documentTransition.toJSON();
+
+      expect(jsonDocumentTransition).to.deep.equal({
+        $id: documentTransition.getId().toString(),
+        $type: documentTransition.getType(),
+        $action: documentTransition.getAction(),
+        $dataContractId: documentTransition.getDataContractId().toString(),
+        $entropy: documentTransition.getEntropy().toString('base64'),
+        $createdAt: documentTransition.getCreatedAt().getTime(),
+        name: documentTransition.getData().name,
+      });
+    });
+  });
+});

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

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

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

@@ -0,0 +1,122 @@
+const Document = require('../../../../../../../lib/document/Document');
+
+const findDuplicateDocumentsByIndices = require('../../../../../../../lib/document/stateTransition/DocumentsBatchTransition/validation/basic/findDuplicatesByIndices');
+
+const getDataContractFixture = require('../../../../../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentsFixture = require('../../../../../../../lib/test/fixtures/getDocumentsFixture');
+const getDocumentTransitionsFixture = require('../../../../../../../lib/test/fixtures/getDocumentTransitionsFixture');
+
+const { generate: generateEntropy } = require('../../../../../../../lib/util/entropyGenerator');
+
+describe('findDuplicatesByIndices', () => {
+  let documents;
+  let contract;
+  let documentTransitions;
+
+  beforeEach(() => {
+    contract = getDataContractFixture();
+    contract.setDocumentSchema('nonUniqueIndexDocument', {
+      indices: [
+        {
+          name: 'ownerIdLastName',
+          properties: [
+            { $ownerId: 'asc' },
+            { lastName: 'asc' },
+          ],
+          unique: false,
+        },
+      ],
+      properties: {
+        firstName: {
+          type: 'string',
+        },
+        lastName: {
+          type: 'string',
+        },
+      },
+      required: ['lastName'],
+      additionalProperties: false,
+    });
+
+    contract.setDocumentSchema('singleDocument', {
+      indices: [
+        {
+          name: 'ownerIdLastName',
+          properties: [
+            { $ownerId: 'asc' },
+            { lastName: 'asc' },
+          ],
+          unique: true,
+        },
+      ],
+      properties: {
+        firstName: {
+          type: 'string',
+        },
+        lastName: {
+          type: 'string',
+        },
+      },
+      required: ['lastName'],
+      additionalProperties: false,
+    });
+
+    documents = getDocumentsFixture(contract);
+    documents.forEach((doc) => {
+      // eslint-disable-next-line no-param-reassign
+      doc.dataContract = contract;
+      // eslint-disable-next-line no-param-reassign
+      doc.dataContractId = contract.getId();
+    });
+
+    const [, , , william] = documents;
+
+    let document = new Document({
+      ...william.toObject(),
+      $type: 'nonUniqueIndexDocument',
+      $entropy: generateEntropy(),
+    }, contract);
+
+    document.setEntropy(generateEntropy());
+
+    documents.push(document);
+
+    document = new Document({
+      ...william.toObject(),
+      $type: 'singleDocument',
+      $entropy: generateEntropy(),
+    }, contract);
+
+    document.setEntropy(generateEntropy());
+
+    documents.push(document);
+
+    documentTransitions = getDocumentTransitionsFixture({
+      create: documents,
+    }).map((t) => t.toObject());
+  });
+
+  it('should return duplicate documents if they are present', () => {
+    const [, , , , leon] = documents;
+
+    leon.set('lastName', 'Birkin');
+
+    documentTransitions = getDocumentTransitionsFixture({
+      create: documents,
+    }).map((t) => t.toObject());
+
+    const duplicates = findDuplicateDocumentsByIndices(documentTransitions, contract);
+    expect(duplicates).to.have.deep.members(
+      [
+        documentTransitions[3],
+        documentTransitions[4],
+      ],
+    );
+  });
+
+  it('should return an empty array of there are no duplicates', () => {
+    const duplicates = findDuplicateDocumentsByIndices(documentTransitions, contract);
+
+    expect(duplicates.length).to.equal(0);
+  });
+});

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

@@ -0,0 +1,75 @@
+const validatePartialCompoundIndices = require('../../../../../../../lib/document/stateTransition/DocumentsBatchTransition/validation/basic/validatePartialCompoundIndices');
+const InconsistentCompoundIndexDataError = require('../../../../../../../lib/errors/consensus/basic/document/InconsistentCompoundIndexDataError');
+
+const getDocumentsFixture = require('../../../../../../../lib/test/fixtures/getDocumentsFixture');
+const getContractFixture = require('../../../../../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentTransitionsFixture = require('../../../../../../../lib/test/fixtures/getDocumentTransitionsFixture');
+
+const ValidationResult = require('../../../../../../../lib/validation/ValidationResult');
+const { expectValidationError } = require('../../../../../../../lib/test/expect/expectError');
+
+describe('validatePartialCompoundIndices', () => {
+  let documents;
+  let rawDocumentTransitions;
+  let dataContract;
+  let ownerId;
+
+  beforeEach(() => {
+    dataContract = getContractFixture();
+    ownerId = dataContract.getOwnerId();
+  });
+
+  it('should return invalid result if compound index contains not all fields', () => {
+    const document = getDocumentsFixture(dataContract)[9];
+    document.set('lastName', undefined);
+
+    documents = [document];
+    rawDocumentTransitions = getDocumentTransitionsFixture({
+      create: documents,
+    }).map((documentTransition) => documentTransition.toObject());
+
+    const result = validatePartialCompoundIndices(ownerId, rawDocumentTransitions, dataContract);
+
+    expectValidationError(result, InconsistentCompoundIndexDataError);
+
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(1021);
+
+    const { optionalUniqueIndexedDocument } = dataContract.getDocuments();
+
+    expect(error.getIndexedProperties()).to.deep.equal(
+      optionalUniqueIndexedDocument.indices[1].properties.map((i) => Object.keys(i)[0]),
+    );
+
+    expect(error.getDocumentType()).to.equal('optionalUniqueIndexedDocument');
+  });
+
+  it('should return valid result if compound index contains no fields', () => {
+    const document = getDocumentsFixture(dataContract)[8];
+    document.setData({ });
+
+    documents = [document];
+
+    rawDocumentTransitions = getDocumentTransitionsFixture({
+      create: documents,
+    }).map((documentTransition) => documentTransition.toObject());
+
+    const result = validatePartialCompoundIndices(ownerId, 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]];
+    rawDocumentTransitions = getDocumentTransitionsFixture({
+      create: documents,
+    }).map((documentTransition) => documentTransition.toObject());
+
+    const result = validatePartialCompoundIndices(ownerId, 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

@@ -0,0 +1,128 @@
+const getDocumentsFixture = require('../../../../../../../lib/test/fixtures/getDocumentsFixture');
+const getDocumentTransitionsFixture = require('../../../../../../../lib/test/fixtures/getDocumentTransitionsFixture');
+
+const fetchDocumentsFactory = require('../../../../../../../lib/document/stateTransition/DocumentsBatchTransition/validation/state/fetchDocumentsFactory');
+
+const createStateRepositoryMock = require('../../../../../../../lib/test/mocks/createStateRepositoryMock');
+
+const generateRandomIdentifier = require('../../../../../../../lib/test/utils/generateRandomIdentifier');
+const StateTransitionExecutionContext = require('../../../../../../../lib/stateTransition/StateTransitionExecutionContext');
+
+describe('fetchDocumentsFactory', () => {
+  let fetchDocuments;
+  let stateRepositoryMock;
+  let documentTransitions;
+  let documents;
+  let executionContext;
+
+  beforeEach(function beforeEach() {
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+
+    fetchDocuments = fetchDocumentsFactory(stateRepositoryMock);
+
+    executionContext = new StateTransitionExecutionContext();
+
+    documents = getDocumentsFixture().slice(0, 5);
+
+    documentTransitions = getDocumentTransitionsFixture({
+      create: documents,
+    });
+  });
+
+  it('should fetch specified Documents using StateRepository', async () => {
+    const firstDocumentDataContractId = generateRandomIdentifier().toBuffer();
+
+    documentTransitions[0].dataContractId = firstDocumentDataContractId;
+    documents[0].dataContractId = firstDocumentDataContractId;
+
+    stateRepositoryMock.fetchDocuments.withArgs(
+      documentTransitions[0].getDataContractId(),
+      documentTransitions[0].getType(),
+    ).resolves([documents[0]]);
+
+    stateRepositoryMock.fetchDocuments.withArgs(
+      documentTransitions[1].getDataContractId(),
+      documentTransitions[1].getType(),
+    ).resolves([documents[1], documents[2]]);
+
+    stateRepositoryMock.fetchDocuments.withArgs(
+      documentTransitions[3].getDataContractId(),
+      documentTransitions[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',
+          ],
+        ],
+      },
+      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);
+  });
+});