@dashevo/wasm-dpp 0.23.0-dev.10

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

@@ -0,0 +1,376 @@
+const bs58 = require('bs58');
+
+const Document = require('../../../lib/document/Document');
+
+const DocumentCreateTransition = require('../../../lib/document/stateTransition/DocumentsBatchTransition/documentTransition/DocumentCreateTransition');
+
+const getDocumentsFixture = require('../../../lib/test/fixtures/getDocumentsFixture');
+const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentTransitionsFixture = require('../../../lib/test/fixtures/getDocumentTransitionsFixture');
+
+const ValidationResult = require('../../../lib/validation/ValidationResult');
+
+const Identifier = require('../../../lib/identifier/Identifier');
+
+const InvalidDocumentTypeError = require('../../../lib/errors/InvalidDocumentTypeError');
+const InvalidDocumentError = require('../../../lib/document/errors/InvalidDocumentError');
+const InvalidActionNameError = require('../../../lib/document/errors/InvalidActionNameError');
+const NoDocumentsSuppliedError = require('../../../lib/document/errors/NoDocumentsSuppliedError');
+const MismatchOwnerIdsError = require('../../../lib/document/errors/MismatchOwnerIdsError');
+const InvalidInitialRevisionError = require('../../../lib/document/errors/InvalidInitialRevisionError');
+const SerializedObjectParsingError = require('../../../lib/errors/consensus/basic/decode/SerializedObjectParsingError');
+
+const generateRandomIdentifier = require('../../../lib/test/utils/generateRandomIdentifier');
+const createDPPMock = require('../../../lib/test/mocks/createDPPMock');
+const SomeConsensusError = require('../../../lib/test/mocks/SomeConsensusError');
+const entropyGenerator = require('../../../lib/util/entropyGenerator');
+const DocumentFactory = require('../../../lib/document/DocumentFactory');
+
+describe('DocumentFactory', () => {
+  let decodeProtocolEntityMock;
+  let generateEntropyMock;
+  let validateDocumentMock;
+  let fetchAndValidateDataContractMock;
+  let ownerId;
+  let dataContract;
+  let document;
+  let documents;
+  let rawDocument;
+  let factory;
+  let fakeTime;
+  let fakeTimeDate;
+  let entropy;
+  let dppMock;
+
+  beforeEach(function beforeEach() {
+    ({ ownerId } = getDocumentsFixture);
+    dataContract = getDataContractFixture();
+
+    documents = getDocumentsFixture(dataContract);
+    ([,,, 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);
+
+    fetchAndValidateDataContractMock = this.sinonSandbox.stub().returns(fetchContractResult);
+
+    dppMock = createDPPMock();
+
+    factory = new DocumentFactory(
+      dppMock,
+      validateDocumentMock,
+      fetchAndValidateDataContractMock,
+      decodeProtocolEntityMock,
+    );
+
+    fakeTimeDate = new Date();
+    fakeTime = this.sinonSandbox.useFakeTimers(fakeTimeDate);
+  });
+
+  afterEach(() => {
+    fakeTime.reset();
+    generateEntropyMock.restore();
+  });
+
+  describe('create', () => {
+    it('should return new Document with specified type and data', () => {
+      const contractId = bs58.decode('FQco85WbwNgb5ix8QQAH6wurMcgEC5ENSCv5ixG9cj12');
+      const name = 'Cutie';
+
+      ownerId = bs58.decode('5zcXZpTLWFwZjKjq3ME5KVavtZa9YUaZESVzrndehBhq');
+      dataContract.id = Identifier.from(contractId);
+
+      const newDocument = factory.create(
+        dataContract,
+        ownerId,
+        rawDocument.$type,
+        { name },
+      );
+
+      expect(newDocument).to.be.an.instanceOf(Document);
+
+      expect(newDocument.getType()).to.equal(rawDocument.$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.getRevision()).to.equal(DocumentCreateTransition.INITIAL_REVISION);
+
+      expect(newDocument.getId()).to.deep.equal(bs58.decode('B99gjrjq6R1FXwGUQnoP7VrmCDDT1PbKprUNzjVbxXfz'));
+
+      expect(newDocument.getCreatedAt().getTime()).to.be.equal(fakeTimeDate.getTime());
+      expect(newDocument.getCreatedAt().getTime()).to.equal(newDocument.getUpdatedAt().getTime());
+    });
+
+    it('should throw an error if type is not defined', () => {
+      const type = 'wrong';
+
+      try {
+        factory.create(dataContract, ownerId, type);
+
+        expect.fail('InvalidDocumentTypeError should be thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(InvalidDocumentTypeError);
+        expect(e.getType()).to.equal(type);
+        expect(e.getDataContract()).to.equal(dataContract);
+      }
+    });
+
+    it('should throw an error if validation faled', () => {
+      const error = new Error('validation failed');
+      const validationResult = new ValidationResult();
+      validationResult.addError(error);
+
+      validateDocumentMock.returns(validationResult);
+
+      try {
+        factory.create(dataContract, ownerId, rawDocument.$type);
+
+        expect.fail('InvalidDocumentError should be thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(InvalidDocumentError);
+      }
+    });
+  });
+
+  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,
+      );
+    });
+
+    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);
+
+      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();
+    });
+
+    it('should throw InvalidDocumentError if passed object is not valid', async () => {
+      const validationError = new SomeConsensusError('test');
+
+      validateDocumentMock.returns(
+        new ValidationResult([validationError]),
+      );
+
+      try {
+        await factory.createFromObject(rawDocument);
+
+        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);
+
+        expect(fetchAndValidateDataContractMock).to.have.been.calledOnceWithExactly(rawDocument);
+        expect(validateDocumentMock).to.have.been.calledOnceWithExactly(rawDocument, dataContract);
+      }
+    });
+
+    it('should throw InvalidDocumentError if Data Contract is not valid', async () => {
+      const fetchContractError = new SomeConsensusError('error');
+
+      fetchAndValidateDataContractMock.returns(
+        new ValidationResult([fetchContractError]),
+      );
+
+      try {
+        await factory.createFromObject(rawDocument);
+
+        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(fetchContractError);
+
+        expect(fetchAndValidateDataContractMock).to.have.been.calledOnceWith(rawDocument);
+        expect(validateDocumentMock).to.have.not.been.called();
+      }
+    });
+  });
+
+  describe('createFromBuffer', () => {
+    let serializedDocument;
+
+    beforeEach(function beforeEach() {
+      this.sinonSandbox.stub(factory, 'createFromObject');
+      // eslint-disable-next-line prefer-destructuring
+      document = documents[8]; // document with binary fields
+
+      serializedDocument = document.toBuffer();
+      rawDocument = document.toObject();
+    });
+
+    afterEach(() => {
+      factory.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,
+      );
+    });
+
+    it('should throw InvalidDocumentError if the decoding fails with consensus error', async () => {
+      const parsingError = new SerializedObjectParsingError(
+        serializedDocument,
+        new Error(),
+      );
+
+      decodeProtocolEntityMock.throws(parsingError);
+
+      try {
+        await factory.createFromBuffer(serializedDocument);
+
+        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);
+
+      try {
+        await factory.createFromBuffer(serializedDocument);
+
+        expect.fail('should throw an error');
+      } catch (e) {
+        expect(e).to.equal(parsingError);
+      }
+    });
+  });
+
+  describe('createStateTransition', () => {
+    it('should throw and error if documents have unknown action', () => {
+      try {
+        factory.createStateTransition({
+          unknown: documents,
+        });
+        expect.fail('Error was not thrown');
+      } catch (e) {
+        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', () => {
+      try {
+        factory.createStateTransition({});
+        expect.fail('Error was not thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(NoDocumentsSuppliedError);
+      }
+    });
+
+    it('should throw and error if documents have mixed owner ids', () => {
+      documents[0].ownerId = generateRandomIdentifier().toBuffer();
+      try {
+        factory.createStateTransition({
+          create: documents,
+        });
+        expect.fail('Error was not thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(MismatchOwnerIdsError);
+        expect(e.getDocuments()).to.have.deep.members(documents);
+      }
+    });
+
+    it('should throw and error if create documents have invalid initial version', () => {
+      documents[0].setRevision(3);
+      try {
+        factory.createStateTransition({
+          create: documents,
+        });
+        expect.fail('Error was not thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(InvalidInitialRevisionError);
+        expect(e.getDocument()).to.deep.equal(documents[0]);
+      }
+    });
+
+    it('should create DocumentsBatchTransition with passed documents', () => {
+      const [newDocument] = getDocumentsFixture(dataContract);
+
+      fakeTime.tick(1000);
+
+      const stateTransition = factory.createStateTransition({
+        create: documents,
+        replace: [newDocument],
+      });
+
+      const expectedTransitions = getDocumentTransitionsFixture({
+        create: documents,
+        replace: [newDocument],
+      });
+
+      expectedTransitions.slice(-1).updatedAt = new Date();
+
+      expect(stateTransition.getTransitions()).to.deep.equal(
+        expectedTransitions,
+      );
+    });
+  });
+});

package/test/unit/document/errors/InvalidDocumentError.spec.js

@@ -0,0 +1,46 @@
+const InvalidDocumentError = require('../../../../lib/document/errors/InvalidDocumentError');
+const getDocumentsFixture = require('../../../../lib/test/fixtures/getDocumentsFixture');
+
+describe('InvalidDocumentError', () => {
+  let rawDocument;
+  let error;
+
+  beforeEach(() => {
+    error = new Error('Some error');
+
+    const [document] = getDocumentsFixture();
+    rawDocument = document.toObject();
+  });
+
+  it('should return errors', () => {
+    const errors = [error];
+
+    const invalidDocumentError = new InvalidDocumentError(errors, rawDocument);
+
+    expect(invalidDocumentError.getErrors()).to.deep.equal(errors);
+  });
+
+  it('should return Document', async () => {
+    const errors = [error];
+
+    const invalidDocumentError = new InvalidDocumentError(errors, rawDocument);
+
+    expect(invalidDocumentError.getRawDocument()).to.deep.equal(rawDocument);
+  });
+
+  it('should contain message for 1 error', async () => {
+    const errors = [error];
+
+    const invalidDocumentError = new InvalidDocumentError(errors, rawDocument);
+
+    expect(invalidDocumentError.message).to.equal(`Invalid Document: "${error.message}"`);
+  });
+
+  it('should contain message for multiple errors', async () => {
+    const errors = [error, error];
+
+    const invalidDocumentError = new InvalidDocumentError(errors, rawDocument);
+
+    expect(invalidDocumentError.message).to.equal(`Invalid Document: "${error.message}" and 1 more`);
+  });
+});

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

@@ -0,0 +1,66 @@
+const fetchAndValidateDataContractFactory = require('../../../lib/document/fetchAndValidateDataContractFactory');
+
+const createStateRepositoryMock = require('../../../lib/test/mocks/createStateRepositoryMock');
+
+const getDocumentsFixture = require('../../../lib/test/fixtures/getDocumentsFixture');
+const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
+
+const ValidationResult = require('../../../lib/validation/ValidationResult');
+
+const MissingDataContractIdError = require('../../../lib/errors/consensus/basic/document/MissingDataContractIdError');
+const DataContractNotPresentError = require('../../../lib/errors/consensus/basic/document/DataContractNotPresentError');
+
+const { expectValidationError } = require('../../../lib/test/expect/expectError');
+
+describe('fetchAndValidateDataContractFactory', () => {
+  let stateRepositoryMock;
+  let fetchAndValidateDataContract;
+  let rawDocument;
+
+  beforeEach(function beforeEach() {
+    const dataContract = getDataContractFixture();
+
+    const [document] = getDocumentsFixture(dataContract);
+    rawDocument = document.toObject();
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+
+    stateRepositoryMock.fetchDataContract.resolves(dataContract);
+
+    fetchAndValidateDataContract = fetchAndValidateDataContractFactory(
+      stateRepositoryMock,
+    );
+  });
+
+  it('should return with invalid result if $dataContractId is not present', async () => {
+    delete rawDocument.$dataContractId;
+
+    const result = await fetchAndValidateDataContract(rawDocument);
+
+    expectValidationError(result, MissingDataContractIdError);
+
+    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);
+
+    const result = await fetchAndValidateDataContract(rawDocument);
+
+    expectValidationError(result, DataContractNotPresentError);
+
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(1018);
+    expect(error.getDataContractId()).to.deep.equal(rawDocument.$dataContractId);
+  });
+
+  it('should return valid result', async () => {
+    const result = await fetchAndValidateDataContract(rawDocument);
+
+    expect(result).to.be.an.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.true();
+  });
+});

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

@@ -0,0 +1,168 @@
+const getDataContractFixture = require('../../../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentsFixture = require('../../../../../lib/test/fixtures/getDocumentsFixture');
+const stateTransitionTypes = require('../../../../../lib/stateTransition/stateTransitionTypes');
+const createDPPMock = require('../../../../../lib/test/mocks/createDPPMock');
+const protocolVersion = require('../../../../../lib/version/protocolVersion');
+const DocumentFactory = require('../../../../../lib/document/DocumentFactory');
+const serializer = require('../../../../../lib/util/serializer');
+const hash = require('../../../../../lib/util/hash');
+
+describe('DocumentsBatchTransition', () => {
+  let stateTransition;
+  let documents;
+  let hashMock;
+  let encodeMock;
+  let dataContract;
+
+  beforeEach(function beforeEach() {
+    dataContract = getDataContractFixture();
+    documents = getDocumentsFixture(dataContract);
+
+    encodeMock = this.sinonSandbox.stub(serializer, 'encode');
+    hashMock = this.sinonSandbox.stub(hash, 'hash');
+
+    const factory = new DocumentFactory(createDPPMock(), undefined, undefined);
+    stateTransition = factory.createStateTransition({
+      create: documents,
+    });
+  });
+
+  afterEach(() => {
+    encodeMock.restore();
+    hashMock.restore();
+  });
+
+  describe('#getProtocolVersion', () => {
+    it('should return the current protocol version', () => {
+      const result = stateTransition.getProtocolVersion();
+
+      expect(result).to.equal(protocolVersion.latestVersion);
+    });
+  });
+
+  describe('#getType', () => {
+    it('should return State Transition type', () => {
+      const result = stateTransition.getType();
+
+      expect(result).to.equal(stateTransitionTypes.DOCUMENTS_BATCH);
+    });
+  });
+
+  describe('#getTransitions', () => {
+    it('should return document transitions', () => {
+      const result = stateTransition.getTransitions();
+
+      expect(result).to.equal(stateTransition.transitions);
+    });
+  });
+
+  describe('#toJSON', () => {
+    it('should return State Transition as JSON', () => {
+      expect(stateTransition.toJSON()).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.DOCUMENTS_BATCH,
+        ownerId: documents[0].getOwnerId().toString(),
+        transitions: stateTransition.getTransitions().map((d) => d.toJSON()),
+        signaturePublicKeyId: undefined,
+        signature: undefined,
+      });
+    });
+  });
+
+  describe('#toObject', () => {
+    it('should return State Transition as plain object', () => {
+      expect(stateTransition.toObject()).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.DOCUMENTS_BATCH,
+        ownerId: documents[0].getOwnerId(),
+        transitions: stateTransition.getTransitions().map((d) => d.toObject()),
+        signaturePublicKeyId: undefined,
+        signature: undefined,
+      });
+    });
+  });
+
+  describe('#toBuffer', () => {
+    it('should return serialized Documents State Transition', () => {
+      const serializedStateTransition = Buffer.from('123');
+
+      encodeMock.returns(serializedStateTransition);
+
+      const result = stateTransition.toBuffer();
+
+      const protocolVersionUInt32 = Buffer.alloc(4);
+      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
+
+      expect(result).to.deep.equal(
+        Buffer.concat([protocolVersionUInt32, serializedStateTransition]),
+      );
+
+      const dataToEncode = stateTransition.toObject();
+      delete dataToEncode.protocolVersion;
+
+      expect(encodeMock).to.have.been.calledOnceWith(dataToEncode);
+    });
+  });
+
+  describe('#hash', () => {
+    it('should return Documents State Transition hash as hex', () => {
+      const serializedDocument = Buffer.from('123');
+      const hashedDocument = '456';
+
+      encodeMock.returns(serializedDocument);
+      hashMock.returns(hashedDocument);
+
+      const result = stateTransition.hash();
+
+      expect(result).to.equal(hashedDocument);
+
+      const dataToEncode = stateTransition.toObject();
+      delete dataToEncode.protocolVersion;
+
+      expect(encodeMock).to.have.been.calledOnceWith(dataToEncode);
+
+      const protocolVersionUInt32 = Buffer.alloc(4);
+      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
+
+      expect(hashMock).to.have.been.calledOnceWith(
+        Buffer.concat([protocolVersionUInt32, serializedDocument]),
+      );
+    });
+  });
+
+  describe('#getOwnerId', () => {
+    it('should return owner id', async () => {
+      const result = stateTransition.getOwnerId();
+
+      expect(result).to.deep.equal(getDocumentsFixture.ownerId);
+    });
+  });
+
+  describe('#getModifiedDataIds', () => {
+    it('should return ids of affected documents', () => {
+      const expectedIds = documents.map((doc) => doc.getId());
+      const result = stateTransition.getModifiedDataIds();
+
+      expect(result.length).to.be.equal(10);
+      expect(result).to.be.deep.equal(expectedIds);
+    });
+  });
+
+  describe('#isDataContractStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransition.isDataContractStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isDocumentStateTransition', () => {
+    it('should return true', () => {
+      expect(stateTransition.isDocumentStateTransition()).to.be.true();
+    });
+  });
+
+  describe('#isIdentityStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransition.isIdentityStateTransition()).to.be.false();
+    });
+  });
+});