@dashevo/wasm-dpp 0.23.0-dev.10

package/test/unit/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition.spec.js

@@ -0,0 +1,158 @@
+const getDataContractFixture = require('../../../../../lib/test/fixtures/getDataContractFixture');
+const stateTransitionTypes = require('../../../../../lib/stateTransition/stateTransitionTypes');
+
+const Identifier = require('../../../../../lib/identifier/Identifier');
+const protocolVersion = require('../../../../../lib/version/protocolVersion');
+const DataContractUpdateTransition = require('../../../../../lib/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition');
+const hash = require('../../../../../lib/util/hash');
+const serializer = require('../../../../../lib/util/serializer');
+
+describe('DataContractUpdateTransition', () => {
+  let stateTransition;
+  let dataContract;
+  let hashMock;
+  let encodeMock;
+
+  beforeEach(function beforeEach() {
+    dataContract = getDataContractFixture();
+
+    encodeMock = this.sinonSandbox.stub(serializer, 'encode');
+    hashMock = this.sinonSandbox.stub(hash, 'hash');
+
+    stateTransition = new DataContractUpdateTransition({
+      protocolVersion: protocolVersion.latestVersion,
+      dataContract: dataContract.toObject(),
+    });
+  });
+
+  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.DATA_CONTRACT_UPDATE);
+    });
+  });
+
+  describe('#getDataContract', () => {
+    it('should return Data Contract', () => {
+      const result = stateTransition.getDataContract();
+
+      expect(result.toObject()).to.deep.equal(dataContract.toObject());
+    });
+  });
+
+  describe('#toJSON', () => {
+    it('should return State Transition as plain JS object', () => {
+      expect(stateTransition.toJSON()).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        type: stateTransitionTypes.DATA_CONTRACT_UPDATE,
+        dataContract: dataContract.toJSON(),
+        signaturePublicKeyId: undefined,
+        signature: undefined,
+      });
+    });
+  });
+
+  describe('#toBuffer', () => {
+    it('should return serialized State Transition', () => {
+      const serializedStateTransition = Buffer.from('123');
+
+      encodeMock.returns(serializedStateTransition);
+
+      const protocolVersionUInt32 = Buffer.alloc(4);
+      protocolVersionUInt32.writeUInt32LE(stateTransition.protocolVersion, 0);
+
+      const result = stateTransition.toBuffer();
+
+      expect(result).to.deep.equal(
+        Buffer.concat([protocolVersionUInt32, serializedStateTransition]),
+      );
+
+      const dataToEncode = stateTransition.toObject();
+      delete dataToEncode.protocolVersion;
+
+      expect(encodeMock.getCall(0).args).to.have.deep.members([
+        dataToEncode,
+      ]);
+    });
+  });
+
+  describe('#hash', () => {
+    it('should return 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.getCall(0).args).to.have.deep.members([
+        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.equal(stateTransition.getDataContract().getOwnerId());
+    });
+  });
+
+  describe('#getModifiedDataIds', () => {
+    it('should return ids of affected data contracts', () => {
+      const result = stateTransition.getModifiedDataIds();
+
+      expect(result.length).to.be.equal(1);
+      const contractId = result[0];
+
+      expect(contractId).to.be.an.instanceOf(Identifier);
+      expect(contractId).to.be.deep.equal(dataContract.getId());
+    });
+  });
+
+  describe('#isDataContractStateTransition', () => {
+    it('should return true', () => {
+      expect(stateTransition.isDataContractStateTransition()).to.be.true();
+    });
+  });
+
+  describe('#isDocumentStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransition.isDocumentStateTransition()).to.be.false();
+    });
+  });
+
+  describe('#isIdentityStateTransition', () => {
+    it('should return false', () => {
+      expect(stateTransition.isIdentityStateTransition()).to.be.false();
+    });
+  });
+});

package/test/unit/dataContract/stateTransition/DataContractUpdateTransition/applyDataContractUpdateTransitionFactory.spec.js

@@ -0,0 +1,47 @@
+const DataContractUpdateTransition = require(
+  '../../../../../lib/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition',
+);
+
+const getDataContractFixture = require('../../../../../lib/test/fixtures/getDataContractFixture');
+
+const applyDataContractUpdateTransitionFactory = require(
+  '../../../../../lib/dataContract/stateTransition/DataContractUpdateTransition/applyDataContractUpdateTransitionFactory',
+);
+
+const createStateRepositoryMock = require('../../../../../lib/test/mocks/createStateRepositoryMock');
+const StateTransitionExecutionContext = require('../../../../../lib/stateTransition/StateTransitionExecutionContext');
+
+describe('applyDataContractUpdateTransitionFactory', () => {
+  let stateTransition;
+  let dataContract;
+  let stateRepositoryMock;
+  let applyDataContractUpdateTransition;
+  let executionContext;
+
+  beforeEach(function beforeEach() {
+    dataContract = getDataContractFixture();
+
+    stateTransition = new DataContractUpdateTransition({
+      dataContract: dataContract.toObject(),
+    });
+
+    executionContext = new StateTransitionExecutionContext();
+
+    stateTransition.setExecutionContext(executionContext);
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+
+    applyDataContractUpdateTransition = applyDataContractUpdateTransitionFactory(
+      stateRepositoryMock,
+    );
+  });
+
+  it('should store a data contract from state transition in the repository', async () => {
+    await applyDataContractUpdateTransition(stateTransition);
+
+    expect(stateRepositoryMock.storeDataContract).to.have.been.calledOnceWithExactly(
+      stateTransition.getDataContract(),
+      executionContext,
+    );
+  });
+});

package/test/unit/dataContract/stateTransition/DataContractUpdateTransition/validation/basic/validateIndicesAreBackwardCompatible.spec.js

@@ -0,0 +1,121 @@
+const validateIndicesAreBackwardCompatible = require('../../../../../../../lib/dataContract/stateTransition/DataContractUpdateTransition/validation/basic/validateIndicesAreBackwardCompatible');
+const DataContractHaveNewIndexWithOldPropertiesError = require('../../../../../../../lib/errors/consensus/basic/dataContract/DataContractInvalidIndexDefinitionUpdateError');
+const DataContractHaveNewUniqueIndexError = require('../../../../../../../lib/errors/consensus/basic/dataContract/DataContractHaveNewUniqueIndexError');
+const DataContractIndicesChangedError = require('../../../../../../../lib/errors/consensus/basic/dataContract/DataContractUniqueIndicesChangedError');
+const getDataContractFixture = require('../../../../../../../lib/test/fixtures/getDataContractFixture');
+const DataContractInvalidIndexDefinitionUpdateError = require('../../../../../../../lib/errors/consensus/basic/dataContract/DataContractInvalidIndexDefinitionUpdateError');
+
+describe('validateIndicesAreBackwardCompatible', () => {
+  let oldDocumentsSchema;
+  let newDocumentsSchema;
+
+  beforeEach(() => {
+    const oldDataContract = getDataContractFixture();
+    const newDataContract = getDataContractFixture();
+
+    newDataContract.getDocumentSchema('indexedDocument').properties.otherName = {
+      type: 'string',
+    };
+
+    newDataContract.getDocumentSchema('indexedDocument').indices.push({
+      name: 'index42',
+      unique: false,
+      properties: [
+        { otherName: 'asc' },
+      ],
+    });
+
+    newDataContract.getDocumentSchema('indexedDocument').indices.push({
+      name: 'index42',
+      properties: [
+        { otherName: 'asc' },
+      ],
+    });
+
+    oldDocumentsSchema = oldDataContract.getDocuments();
+    newDocumentsSchema = newDataContract.getDocuments();
+  });
+
+  it('should return invalid result if some of unique indices have changed', async () => {
+    newDocumentsSchema.indexedDocument.indices[0].properties[0].lastName = 'asc';
+
+    const result = validateIndicesAreBackwardCompatible(oldDocumentsSchema, newDocumentsSchema);
+
+    expect(result.isValid()).to.be.false();
+
+    const error = result.getErrors()[0];
+
+    expect(error).to.be.an.instanceOf(DataContractIndicesChangedError);
+    expect(error.getIndexName()).to.equal(newDocumentsSchema.indexedDocument.indices[0].name);
+  });
+
+  it('should return invalid result if non-unique index update failed due to changed old properties', async () => {
+    newDocumentsSchema.indexedDocument.indices[2].properties[0].$id = 'asc';
+
+    const result = validateIndicesAreBackwardCompatible(oldDocumentsSchema, newDocumentsSchema);
+
+    expect(result.isValid()).to.be.false();
+
+    const error = result.getErrors()[0];
+
+    expect(error).to.be.an.instanceOf(DataContractInvalidIndexDefinitionUpdateError);
+    expect(error.getIndexName()).to.equal(newDocumentsSchema.indexedDocument.indices[2].name);
+  });
+
+  it('should return invalid result if non-unique index update failed due old properties used', async () => {
+    newDocumentsSchema.indexedDocument.indices[2].properties.push({ firstName: 'asc' });
+
+    const result = validateIndicesAreBackwardCompatible(oldDocumentsSchema, newDocumentsSchema);
+
+    expect(result.isValid()).to.be.false();
+
+    const error = result.getErrors()[0];
+
+    expect(error).to.be.an.instanceOf(DataContractInvalidIndexDefinitionUpdateError);
+    expect(error.getIndexName()).to.equal(newDocumentsSchema.indexedDocument.indices[2].name);
+  });
+
+  it('should return invalid result if one of new indices contains old properties in the wrong order', async () => {
+    newDocumentsSchema.indexedDocument.indices.push({
+      name: 'index_other',
+      properties: [
+        { firstName: 'asc' },
+        { $ownerId: 'asc' },
+      ],
+    });
+
+    const result = validateIndicesAreBackwardCompatible(oldDocumentsSchema, newDocumentsSchema);
+
+    expect(result.isValid()).to.be.false();
+
+    const error = result.getErrors()[0];
+
+    expect(error).to.be.an.instanceOf(DataContractHaveNewIndexWithOldPropertiesError);
+    expect(error.getIndexName()).to.equal('index_other');
+  });
+
+  it('should return invalid result if one of new indices is unique', async () => {
+    newDocumentsSchema.indexedDocument.indices.push({
+      name: 'index_other',
+      properties: [
+        { otherName: 'asc' },
+      ],
+      unique: true,
+    });
+
+    const result = validateIndicesAreBackwardCompatible(oldDocumentsSchema, newDocumentsSchema);
+
+    expect(result.isValid()).to.be.false();
+
+    const error = result.getErrors()[0];
+
+    expect(error).to.be.an.instanceOf(DataContractHaveNewUniqueIndexError);
+    expect(error.getIndexName()).to.equal('index_other');
+  });
+
+  it('should return valid result if indices are not changed', async () => {
+    const result = validateIndicesAreBackwardCompatible(oldDocumentsSchema, newDocumentsSchema);
+
+    expect(result.isValid()).to.be.true();
+  });
+});

package/test/unit/dataContract/stateTransition/DataContractUpdateTransition/validation/state/validateDataContractUpdateTransitionStateFactory.spec.js

@@ -0,0 +1,111 @@
+const validateDataContractUpdateTransitionStateFactory = require('../../../../../../../lib/dataContract/stateTransition/DataContractUpdateTransition/validation/state/validateDataContractUpdateTransitionStateFactory');
+const DataContractUpdateTransition = require('../../../../../../../lib/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition');
+
+const createStateRepositoryMock = require('../../../../../../../lib/test/mocks/createStateRepositoryMock');
+const getDataContractFixture = require('../../../../../../../lib/test/fixtures/getDataContractFixture');
+
+const { expectValidationError } = require('../../../../../../../lib/test/expect/expectError');
+
+const ValidationResult = require('../../../../../../../lib/validation/ValidationResult');
+
+const DataContractNotPresentError = require('../../../../../../../lib/errors/consensus/basic/document/DataContractNotPresentError');
+const InvalidDataContractVersionError = require('../../../../../../../lib/errors/consensus/basic/dataContract/InvalidDataContractVersionError');
+const StateTransitionExecutionContext = require('../../../../../../../lib/stateTransition/StateTransitionExecutionContext');
+
+describe('validateDataContractUpdateTransitionStateFactory', () => {
+  let validateDataContractUpdateTransitionState;
+  let dataContract;
+  let stateTransition;
+  let stateRepositoryMock;
+  let executionContext;
+
+  beforeEach(function beforeEach() {
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+
+    dataContract = getDataContractFixture();
+
+    const updatedRawDataContract = dataContract.toObject();
+
+    updatedRawDataContract.version += 1;
+
+    stateTransition = new DataContractUpdateTransition({
+      dataContract: updatedRawDataContract,
+    });
+
+    executionContext = new StateTransitionExecutionContext();
+
+    stateTransition.setExecutionContext(executionContext);
+
+    stateRepositoryMock.fetchDataContract.resolves(dataContract);
+
+    validateDataContractUpdateTransitionState = validateDataContractUpdateTransitionStateFactory(
+      stateRepositoryMock,
+    );
+  });
+
+  it('should return invalid result if Data Contract with specified contractId was not found', async () => {
+    stateRepositoryMock.fetchDataContract.resolves(undefined);
+
+    const result = await validateDataContractUpdateTransitionState(stateTransition);
+
+    expectValidationError(result, DataContractNotPresentError);
+
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(1018);
+    expect(Buffer.isBuffer(error.getDataContractId())).to.be.true();
+    expect(error.getDataContractId()).to.deep.equal(dataContract.getId().toBuffer());
+
+    expect(stateRepositoryMock.fetchDataContract).to.be.calledOnceWithExactly(
+      dataContract.getId(),
+      executionContext,
+    );
+  });
+
+  it('should return invalid result if Data Contract version is not larger by 1', async () => {
+    dataContract.version -= 1;
+
+    const result = await validateDataContractUpdateTransitionState(stateTransition);
+
+    expectValidationError(result, InvalidDataContractVersionError);
+
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(1050);
+
+    expect(stateRepositoryMock.fetchDataContract).to.be.calledOnceWithExactly(
+      dataContract.getId(),
+      executionContext,
+    );
+  });
+
+  it('should return valid result', async () => {
+    const result = await validateDataContractUpdateTransitionState(stateTransition);
+
+    expect(result).to.be.an.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.true();
+
+    expect(stateRepositoryMock.fetchDataContract).to.be.calledOnceWithExactly(
+      dataContract.getId(),
+      executionContext,
+    );
+  });
+
+  it('should return valid result on dry run', async () => {
+    stateRepositoryMock.fetchDataContract.resolves(undefined);
+
+    executionContext.enableDryRun();
+
+    const result = await validateDataContractUpdateTransitionState(stateTransition);
+
+    executionContext.disableDryRun();
+
+    expect(result).to.be.an.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.true();
+
+    expect(stateRepositoryMock.fetchDataContract).to.be.calledOnceWithExactly(
+      dataContract.getId(),
+      executionContext,
+    );
+  });
+});

package/test/unit/dataContract/validation/validateDataContractMaxDepthFactory.spec.js

@@ -0,0 +1,93 @@
+const validateDataContractMaxDepthFactory = require('../../../../lib/dataContract/validation/validateDataContractMaxDepthFactory');
+const ValidationResult = require('../../../../lib/validation/ValidationResult');
+const { expectValidationError } = require('../../../../lib/test/expect/expectError');
+const DataContractMaxDepthExceedError = require('../../../../lib/errors/consensus/basic/dataContract/DataContractMaxDepthExceedError');
+const generateDeepJson = require('../../../../lib/test/utils/generateDeepJson');
+const InvalidJsonSchemaRefError = require('../../../../lib/errors/consensus/basic/dataContract/InvalidJsonSchemaRefError');
+
+describe('validateDataContractMaxDepthFactory', () => {
+  let refParserMock;
+  let validateDataContractMaxDepth;
+  let dataContractFixture;
+
+  beforeEach(function beforeEach() {
+    dataContractFixture = {};
+
+    refParserMock = {
+      dereference: this.sinonSandbox.stub(),
+    };
+
+    validateDataContractMaxDepth = validateDataContractMaxDepthFactory(refParserMock);
+  });
+
+  it('should throw error if depth > MAX_DEPTH', async () => {
+    dataContractFixture = generateDeepJson(DataContractMaxDepthExceedError.MAX_DEPTH + 1);
+
+    refParserMock.dereference.resolves(dataContractFixture);
+
+    const result = await validateDataContractMaxDepth(dataContractFixture);
+
+    expectValidationError(result);
+
+    const [error] = result.getErrors();
+
+    expect(error).to.be.an.instanceOf(DataContractMaxDepthExceedError);
+    expect(error.getCode()).to.equal(1007);
+  });
+
+  it('should return valid result if depth = MAX_DEPTH', async () => {
+    dataContractFixture = generateDeepJson(DataContractMaxDepthExceedError.MAX_DEPTH);
+
+    refParserMock.dereference.resolves(dataContractFixture);
+
+    const result = await validateDataContractMaxDepth(dataContractFixture);
+
+    expect(result).to.be.an.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.true();
+  });
+
+  it('should throw error if contract contains array with depth > MAX_DEPTH', async () => {
+    const deepJson = generateDeepJson(DataContractMaxDepthExceedError.MAX_DEPTH + 1);
+
+    dataContractFixture = {
+      array: [
+        0, deepJson,
+      ],
+    };
+
+    refParserMock.dereference.resolves(dataContractFixture);
+
+    const result = await validateDataContractMaxDepth(dataContractFixture);
+
+    expectValidationError(result);
+
+    const [error] = result.getErrors();
+
+    expect(error).to.be.an.instanceOf(DataContractMaxDepthExceedError);
+    expect(error.getCode()).to.equal(1007);
+  });
+
+  it('should return error if refParser throws an error', async () => {
+    const refParserError = new Error('refParser error');
+
+    refParserMock.dereference.throws(refParserError);
+
+    const result = await validateDataContractMaxDepth(dataContractFixture);
+
+    expectValidationError(result);
+
+    const [error] = result.getErrors();
+
+    expect(error).to.be.an.instanceOf(InvalidJsonSchemaRefError);
+    expect(error.message).to.equal(`Invalid JSON Schema $ref: ${refParserError.message}`);
+  });
+
+  it('should return valid result', async () => {
+    refParserMock.dereference.resolves(dataContractFixture);
+
+    const result = await validateDataContractMaxDepth(dataContractFixture);
+
+    expect(result).to.be.an.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.true();
+  });
+});

package/test/unit/dataContract/validation/validateDataContractPatternsFactory.spec.js

@@ -0,0 +1,64 @@
+const { getRE2Class } = require('@dashevo/wasm-re2');
+
+const validateDataContractPatternsFactory = require('../../../../lib/dataContract/validation/validateDataContractPatternsFactory');
+const { expectValidationError } = require(
+  '../../../../lib/test/expect/expectError',
+);
+const IncompatibleRe2PatternError = require('../../../../lib/errors/consensus/basic/dataContract/IncompatibleRe2PatternError');
+
+describe('validateDataContractPatternsFactory', () => {
+  let validateDataContractPatterns;
+  let RE2;
+
+  before(async () => {
+    RE2 = await getRE2Class();
+  });
+
+  beforeEach(() => {
+    validateDataContractPatterns = validateDataContractPatternsFactory(RE2);
+  });
+
+  it('should return valid result', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        foo: { type: 'integer' },
+        bar: {
+          type: 'string',
+          pattern: '([a-z]+)+$',
+        },
+      },
+      required: ['foo'],
+      additionalProperties: false,
+    };
+
+    const result = validateDataContractPatterns(schema);
+
+    expect(result.isValid()).to.be.true();
+  });
+
+  it('should return invalid result on incompatible pattern', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        foo: { type: 'integer' },
+        bar: {
+          type: 'string',
+          pattern: '^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$',
+        },
+      },
+      required: ['foo'],
+      additionalProperties: false,
+    };
+
+    const result = validateDataContractPatterns(schema);
+
+    expectValidationError(result, IncompatibleRe2PatternError);
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(1009);
+    expect(error.getPattern()).to.equal('^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$');
+    expect(error.getPath()).to.equal('/properties/bar');
+    expect(error.getPatternError()).to.be.instanceOf(Error);
+  });
+});