@dashevo/wasm-dpp 0.23.0-dev.10

package/test/unit/dataContract/errors/InvalidDataContractError.spec.js

@@ -0,0 +1,46 @@
+const InvalidDataContractError = require('../../../../lib/dataContract/errors/InvalidDataContractError');
+const getDataContractFixture = require('../../../../lib/test/fixtures/getDataContractFixture');
+
+describe('InvalidDataContractError', () => {
+  let rawDataContract;
+  let error;
+
+  beforeEach(() => {
+    error = new Error('Some error');
+
+    const dataContract = getDataContractFixture();
+    rawDataContract = dataContract.toObject();
+  });
+
+  it('should return errors', () => {
+    const errors = [error];
+
+    const invalidDataContractError = new InvalidDataContractError(errors, rawDataContract);
+
+    expect(invalidDataContractError.getErrors()).to.deep.equal(errors);
+  });
+
+  it('should return Data Contract', async () => {
+    const errors = [error];
+
+    const invalidDataContractError = new InvalidDataContractError(errors, rawDataContract);
+
+    expect(invalidDataContractError.getRawDataContract()).to.deep.equal(rawDataContract);
+  });
+
+  it('should contain message for 1 error', async () => {
+    const errors = [error];
+
+    const invalidDataContractError = new InvalidDataContractError(errors, rawDataContract);
+
+    expect(invalidDataContractError.message).to.equal(`Invalid Data Contract: "${error.message}"`);
+  });
+
+  it('should contain message for multiple errors', async () => {
+    const errors = [error, error];
+
+    const invalidDataContractError = new InvalidDataContractError(errors, rawDataContract);
+
+    expect(invalidDataContractError.message).to.equal(`Invalid Data Contract: "${error.message}" and 1 more`);
+  });
+});

package/test/unit/dataContract/generateDataContractId.spec.js

@@ -0,0 +1,19 @@
+const bs58 = require('bs58');
+const generateDataContractId = require('../../../lib/dataContract/generateDataContractId');
+
+describe('generateDataContractId', () => {
+  let ownerId;
+  let entropy;
+
+  beforeEach(() => {
+    ownerId = bs58.decode('23wdhodag');
+    entropy = bs58.decode('5dz916pTe1');
+  });
+
+  it('should generate bs58 id based on ', () => {
+    const id = bs58.decode('CnS7cz4z1qoPsNfEgpgyVnKdtH2u7bgzZXHLcCQt24US');
+    const generatedId = generateDataContractId(ownerId, entropy);
+
+    expect(Buffer.compare(id, generatedId)).to.equal(0);
+  });
+});

package/test/unit/dataContract/getBinaryPropertiesFromSchema.spec.js

@@ -0,0 +1,103 @@
+const { getBinaryPropertiesFromSchema } = require(
+  '../../../lib/dataContract/getBinaryPropertiesFromSchema',
+);
+
+describe('getBinaryPropertiesFromSchema', () => {
+  let documentSchema;
+
+  beforeEach(() => {
+    documentSchema = {
+      properties: {
+        simple: {
+          type: 'string',
+        },
+        withByteArray: {
+          type: 'object',
+          byteArray: true,
+        },
+        nestedObject: {
+          type: 'object',
+          properties: {
+            simple: {
+              type: 'string',
+            },
+            withByteArray: {
+              type: 'object',
+              byteArray: true,
+            },
+          },
+        },
+        arrayOfObject: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              simple: {
+                type: 'string',
+              },
+              withByteArray: {
+                type: 'object',
+                byteArray: true,
+              },
+            },
+          },
+        },
+        arrayOfObjects: {
+          type: 'array',
+          items: [
+            {
+              type: 'object',
+              properties: {
+                simple: {
+                  type: 'string',
+                },
+                withByteArray: {
+                  type: 'object',
+                  byteArray: true,
+                },
+              },
+            },
+            {
+              type: 'string',
+            },
+            {
+              type: 'array',
+              items: [
+                {
+                  type: 'object',
+                  properties: {
+                    simple: {
+                      type: 'string',
+                    },
+                    withByteArray: {
+                      type: 'object',
+                      byteArray: true,
+                    },
+                  },
+                },
+              ],
+            },
+          ],
+        },
+      },
+    };
+  });
+
+  it('should return an empty object if not `properties` property found', () => {
+    const result = getBinaryPropertiesFromSchema({});
+
+    expect(result).to.deep.equal({});
+  });
+
+  it('should return flat object with properties having contentEncoding keyword', () => {
+    const result = getBinaryPropertiesFromSchema(documentSchema);
+
+    expect(result).to.deep.equal({
+      withByteArray: { type: 'object', byteArray: true },
+      'nestedObject.withByteArray': { type: 'object', byteArray: true },
+      'arrayOfObject.withByteArray': { type: 'object', byteArray: true },
+      'arrayOfObjects[0].withByteArray': { type: 'object', byteArray: true },
+      'arrayOfObjects[2][0].withByteArray': { type: 'object', byteArray: true },
+    });
+  });
+});

package/test/unit/dataContract/getPropertyDefinitionByPath.spec.js

@@ -0,0 +1,84 @@
+const getPropertyDefinitionByPath = require(
+  '../../../lib/dataContract/getPropertyDefinitionByPath',
+);
+
+describe('getPropertyDefinitionByPath', () => {
+  let schema;
+
+  beforeEach(() => {
+    schema = {
+      properties: {
+        a: {
+          type: 'string',
+        },
+        b: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              inner: {
+                type: 'object',
+                properties: {
+                  abc: {
+                    type: 'string',
+                  },
+                },
+              },
+            },
+          },
+        },
+        c: {
+          type: 'object',
+          properties: {
+            inner: {
+              type: 'object',
+              patternProperties: {
+                '[a-z]': {
+                  type: 'string',
+                },
+              },
+            },
+          },
+        },
+      },
+    };
+  });
+
+  it('should return `undefined` if property not found', () => {
+    const definition = getPropertyDefinitionByPath(schema, 'nope');
+
+    expect(definition).to.be.undefined();
+  });
+
+  it('should return definition immediately if path is one-level', () => {
+    const definition = getPropertyDefinitionByPath(schema, 'a');
+
+    expect(definition).to.deep.equal({
+      type: 'string',
+    });
+  });
+
+  it('should return nested definition from an array', () => {
+    const definition = getPropertyDefinitionByPath(schema, 'b.inner');
+
+    expect(definition).to.deep.equal(schema.properties.b.items.properties.inner);
+  });
+
+  it('should return nested definition from object', () => {
+    const definition = getPropertyDefinitionByPath(schema, 'c.inner');
+
+    expect(definition).to.deep.equal(schema.properties.c.properties.inner);
+  });
+
+  it('should return `undefined` if path does not match a pattern', () => {
+    const definition = getPropertyDefinitionByPath(schema, 'c.inner.NOPE');
+
+    expect(definition).to.be.undefined();
+  });
+
+  it('should return `undefined` if first item in a path is not an object or array', () => {
+    const definition = getPropertyDefinitionByPath(schema, 'a.someOther');
+
+    expect(definition).to.be.undefined();
+  });
+});

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

@@ -0,0 +1,160 @@
+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 DataContractCreateTransition = require('../../../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
+const hash = require('../../../../../lib/util/hash');
+const serializer = require('../../../../../lib/util/serializer');
+
+describe('DataContractCreateTransition', () => {
+  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 DataContractCreateTransition({
+      protocolVersion: protocolVersion.latestVersion,
+      dataContract: dataContract.toObject(),
+      entropy: dataContract.getEntropy(),
+    });
+  });
+
+  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_CREATE);
+    });
+  });
+
+  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_CREATE,
+        dataContract: dataContract.toJSON(),
+        signaturePublicKeyId: undefined,
+        signature: undefined,
+        entropy: dataContract.getEntropy().toString('base64'),
+      });
+    });
+  });
+
+  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/DataContractCreateTransition/applyDataContractCreateTransitionFactory.spec.js

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

package/test/unit/dataContract/stateTransition/DataContractCreateTransition/validation/state/validateDataContractCreateTransitionStateFactory.spec.js

@@ -0,0 +1,85 @@
+const validateDataContractCreateTransitionStateFactory = require('../../../../../../../lib/dataContract/stateTransition/DataContractCreateTransition/validation/state/validateDataContractCreateTransitionStateFactory');
+const DataContractCreateTransition = require('../../../../../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
+
+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 DataContractAlreadyPresentError = require('../../../../../../../lib/errors/consensus/state/dataContract/DataContractAlreadyPresentError');
+const StateTransitionExecutionContext = require('../../../../../../../lib/stateTransition/StateTransitionExecutionContext');
+
+describe('validateDataContractCreateTransitionStateFactory', () => {
+  let validateDataContractCreateTransitionState;
+  let dataContract;
+  let stateTransition;
+  let stateRepositoryMock;
+  let executionContext;
+
+  beforeEach(function beforeEach() {
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+
+    dataContract = getDataContractFixture();
+    stateTransition = new DataContractCreateTransition({
+      dataContract: dataContract.toObject(),
+      entropy: dataContract.getEntropy(),
+    });
+
+    executionContext = new StateTransitionExecutionContext();
+
+    stateTransition.setExecutionContext(executionContext);
+
+    validateDataContractCreateTransitionState = validateDataContractCreateTransitionStateFactory(
+      stateRepositoryMock,
+    );
+  });
+
+  it('should return invalid result if Data Contract with specified contractId is already exist', async () => {
+    stateRepositoryMock.fetchDataContract.resolves(dataContract);
+
+    const result = await validateDataContractCreateTransitionState(stateTransition);
+
+    expectValidationError(result, DataContractAlreadyPresentError);
+
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(4000);
+    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 valid result', async () => {
+    const result = await validateDataContractCreateTransitionState(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(dataContract);
+
+    executionContext.enableDryRun();
+    const result = await validateDataContractCreateTransitionState(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,
+    );
+  });
+});