@dashevo/wasm-dpp 0.23.0-dev.10

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

@@ -0,0 +1,279 @@
+const verifyDocumentsUniquenessByIndicesFactory = require('../../../../../../../lib/document/stateTransition/DocumentsBatchTransition/validation/state/validateDocumentsUniquenessByIndicesFactory');
+
+const getDocumentsFixture = require('../../../../../../../lib/test/fixtures/getDocumentsFixture');
+const getContractFixture = require('../../../../../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentTransitionsFixture = require('../../../../../../../lib/test/fixtures/getDocumentTransitionsFixture');
+
+const { expectValidationError } = require('../../../../../../../lib/test/expect/expectError');
+const createStateRepositoryMock = require('../../../../../../../lib/test/mocks/createStateRepositoryMock');
+
+const ValidationResult = require('../../../../../../../lib/validation/ValidationResult');
+
+const DuplicateUniqueIndexError = require('../../../../../../../lib/errors/consensus/state/document/DuplicateUniqueIndexError');
+const StateTransitionExecutionContext = require('../../../../../../../lib/stateTransition/StateTransitionExecutionContext');
+
+describe('validateDocumentsUniquenessByIndices', () => {
+  let stateRepositoryMock;
+  let validateDocumentsUniquenessByIndices;
+  let documents;
+  let documentTransitions;
+  let dataContract;
+  let ownerId;
+  let executionContext;
+
+  beforeEach(function beforeEach() {
+    ({ ownerId } = getDocumentsFixture);
+
+    documents = getDocumentsFixture(dataContract);
+    documentTransitions = getDocumentTransitionsFixture({
+      create: documents,
+    });
+    dataContract = getContractFixture();
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchDocuments.resolves([]);
+
+    executionContext = new StateTransitionExecutionContext();
+
+    validateDocumentsUniquenessByIndices = verifyDocumentsUniquenessByIndicesFactory(
+      stateRepositoryMock,
+    );
+  });
+
+  it('should return valid result if Documents have no unique indices', async () => {
+    const [niceDocument] = documents;
+    const noIndexDocumentTransitions = getDocumentTransitionsFixture({
+      create: [niceDocument],
+    });
+
+    const result = await validateDocumentsUniquenessByIndices(
+      ownerId,
+      noIndexDocumentTransitions,
+      dataContract,
+      executionContext,
+    );
+
+    expect(result).to.be.an.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.true();
+    expect(stateRepositoryMock.fetchDocuments).to.have.not.been.called();
+  });
+
+  it('should return valid result if Document has unique indices and there are no duplicates', async () => {
+    const [, , , william] = documents;
+
+    stateRepositoryMock.fetchDocuments
+      .withArgs(
+        dataContract.getId().toBuffer(),
+        william.getType(),
+        {
+          where: [
+            ['$ownerId', '==', ownerId],
+            ['firstName', '==', william.get('firstName')],
+          ],
+        },
+      )
+      .resolves([william]);
+
+    stateRepositoryMock.fetchDocuments
+      .withArgs(
+        dataContract.getId().toBuffer(),
+        william.getType(),
+        {
+          where: [
+            ['$ownerId', '==', ownerId],
+            ['lastName', '==', william.get('lastName')],
+          ],
+        },
+      )
+      .resolves([william]);
+
+    const result = await validateDocumentsUniquenessByIndices(
+      ownerId,
+      documentTransitions,
+      dataContract,
+      executionContext,
+    );
+
+    expect(result).to.be.an.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.true();
+  });
+
+  it('should return invalid result if Document has unique indices and there are duplicates', async () => {
+    const [, , , william, leon] = documents;
+
+    const indicesDefinition = dataContract.getDocumentSchema(william.getType()).indices;
+
+    stateRepositoryMock.fetchDocuments
+      .withArgs(
+        dataContract.getId(),
+        william.getType(),
+        {
+          where: [
+            ['$ownerId', '==', ownerId],
+            ['firstName', '==', william.get('firstName')],
+          ],
+        },
+      )
+      .resolves([leon]);
+
+    stateRepositoryMock.fetchDocuments
+      .withArgs(
+        dataContract.getId(),
+        william.getType(),
+        {
+          where: [
+            ['$ownerId', '==', ownerId],
+            ['lastName', '==', william.get('lastName')],
+          ],
+        },
+      )
+      .resolves([leon]);
+
+    stateRepositoryMock.fetchDocuments
+      .withArgs(
+        dataContract.getId(),
+        leon.getType(),
+        {
+          where: [
+            ['$ownerId', '==', ownerId],
+            ['firstName', '==', leon.get('firstName')],
+          ],
+        },
+      )
+      .resolves([william]);
+
+    stateRepositoryMock.fetchDocuments
+      .withArgs(
+        dataContract.getId(),
+        leon.getType(),
+        {
+          where: [
+            ['$ownerId', '==', ownerId],
+            ['lastName', '==', leon.get('lastName')],
+          ],
+        },
+      )
+      .resolves([william]);
+
+    const result = await validateDocumentsUniquenessByIndices(
+      ownerId,
+      documentTransitions,
+      dataContract,
+      executionContext,
+    );
+
+    expectValidationError(result, DuplicateUniqueIndexError, 4);
+
+    const errors = result.getErrors();
+
+    const [error] = result.getErrors();
+
+    expect(error.getCode()).to.equal(4009);
+
+    expect(errors.map((e) => e.getDocumentId())).to.have.deep.members([
+      documentTransitions[3].getId().toBuffer(),
+      documentTransitions[3].getId().toBuffer(),
+      documentTransitions[4].getId().toBuffer(),
+      documentTransitions[4].getId().toBuffer(),
+    ]);
+
+    expect(errors.map((e) => e.getDuplicatingProperties())).to.have.deep.members([
+      indicesDefinition[0].properties.map((i) => Object.keys(i)[0]),
+      indicesDefinition[1].properties.map((i) => Object.keys(i)[0]),
+      indicesDefinition[0].properties.map((i) => Object.keys(i)[0]),
+      indicesDefinition[1].properties.map((i) => Object.keys(i)[0]),
+    ]);
+  });
+
+  it('should return valid result if Document has undefined field from index', async () => {
+    const indexedDocument = documents[7];
+    const indexedDocumentTransitions = getDocumentTransitionsFixture({
+      create: [indexedDocument],
+    });
+
+    stateRepositoryMock.fetchDocuments
+      .withArgs(
+        dataContract.getId().toBuffer(),
+        indexedDocument.getType(),
+        {
+          where: [
+            ['$ownerId', '==', ownerId],
+            ['firstName', '==', indexedDocument.get('firstName')],
+          ],
+        },
+      )
+      .resolves([indexedDocument]);
+
+    stateRepositoryMock.fetchDocuments
+      .withArgs(
+        dataContract.getId(),
+        indexedDocument.getType(),
+        {
+          where: [
+            ['$ownerId', '==', ownerId],
+          ],
+        },
+      )
+      .resolves([indexedDocument]);
+
+    const result = await validateDocumentsUniquenessByIndices(
+      ownerId,
+      indexedDocumentTransitions,
+      dataContract,
+      executionContext,
+    );
+
+    expect(result).to.be.an.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.true();
+  });
+
+  it('should return valid result if Document being created and has createdAt and updatedAt indices', async () => {
+    const [, , , , , , uniqueDatesDocument] = documents;
+
+    const uniqueDatesDocumentTransitions = getDocumentTransitionsFixture({
+      create: [uniqueDatesDocument],
+    });
+    stateRepositoryMock.fetchDocuments
+      .withArgs(
+        dataContract.getId().toBuffer(),
+        uniqueDatesDocument.getType(),
+        {
+          where: [
+            ['$createdAt', '==', uniqueDatesDocument.getCreatedAt().getTime()],
+            ['$updatedAt', '==', uniqueDatesDocument.getUpdatedAt().getTime()],
+          ],
+        },
+      )
+      .resolves([uniqueDatesDocument]);
+
+    const result = await validateDocumentsUniquenessByIndices(
+      ownerId,
+      uniqueDatesDocumentTransitions,
+      dataContract,
+      executionContext,
+    );
+
+    expect(result.isValid()).to.be.true();
+  });
+
+  it('should return invalid result on dry run', async () => {
+    const [niceDocument] = documents;
+    const noIndexDocumentTransitions = getDocumentTransitionsFixture({
+      create: [niceDocument],
+    });
+
+    executionContext.enableDryRun();
+
+    const result = await validateDocumentsUniquenessByIndices(
+      ownerId,
+      noIndexDocumentTransitions,
+      dataContract,
+      executionContext,
+    );
+    executionContext.disableDryRun();
+
+    expect(result).to.be.an.instanceOf(ValidationResult);
+    expect(result.isValid()).to.be.true();
+    expect(stateRepositoryMock.fetchDocuments).to.have.not.been.called();
+  });
+});

package/test/unit/errors/consensus/codes.spec.js

@@ -0,0 +1,102 @@
+const path = require('path');
+const fs = require('fs');
+const codes = require('../../../../lib/errors/consensus/codes');
+const AbstractConsensusError = require('../../../../lib/errors/consensus/AbstractConsensusError');
+const AbstractBasicError = require('../../../../lib/errors/consensus/basic/AbstractBasicError');
+const AbstractSignatureError = require('../../../../lib/errors/consensus/signature/AbstractSignatureError');
+const AbstractFeeError = require('../../../../lib/errors/consensus/fee/AbstractFeeError');
+const AbstractStateError = require('../../../../lib/errors/consensus/state/AbstractStateError');
+
+const getAllFiles = (dirPath, arrayOfFiles) => {
+  const files = fs.readdirSync(dirPath);
+
+  // eslint-disable-next-line no-param-reassign
+  arrayOfFiles = arrayOfFiles || [];
+
+  files.forEach((file) => {
+    if (fs.statSync(`${dirPath}/${file}`).isDirectory()) {
+      // eslint-disable-next-line no-param-reassign
+      arrayOfFiles = getAllFiles(`${dirPath}/${file}`, arrayOfFiles);
+    } else if (file.slice(-3) === '.js') {
+      arrayOfFiles.push(path.join(dirPath, '/', file));
+    }
+  });
+
+  return arrayOfFiles;
+};
+
+function isChildOf(classToCheck, parentClass) {
+  if (!classToCheck || !classToCheck.prototype) {
+    return false;
+  }
+
+  if (classToCheck.prototype instanceof parentClass) {
+    return true;
+  }
+
+  return isChildOf(classToCheck.prototype, parentClass);
+}
+
+const errorClasses = Object.values(codes).map((ErrorClass) => ErrorClass);
+const errorClassDuplicates = errorClasses.filter((item, index) => (
+  errorClasses.indexOf(item) !== index
+));
+
+describe('Consensus error codes', () => {
+  // Skip the tests for browsers
+  if (global.window !== undefined) {
+    return;
+  }
+
+  const normalizedPath = path.join(__dirname, '../../../../lib/errors/');
+  const allFiles = getAllFiles(normalizedPath);
+
+  allFiles.forEach((fileName) => {
+    // eslint-disable-next-line global-require,import/no-dynamic-require
+    const ErrorClass = require(fileName);
+
+    if (
+      (isChildOf(ErrorClass, AbstractConsensusError)) && !ErrorClass.name.startsWith('Abstract')
+    ) {
+      context(ErrorClass.name, () => {
+        let code;
+        let AssignedErrorClass;
+
+        beforeEach(() => {
+          const result = Object.entries(codes)
+            .find(([, ErrorClassWithCode]) => ErrorClassWithCode === ErrorClass);
+
+          if (result) {
+            code = Number(result[0]);
+            // eslint-disable-next-line prefer-destructuring
+            AssignedErrorClass = result[1];
+          }
+        });
+
+        it('should have error code defined', () => {
+          expect(AssignedErrorClass).to.exist();
+        });
+
+        it('should have been define in the correct code range', () => {
+          if (isChildOf(ErrorClass, AbstractBasicError)) {
+            expect(code).to.be.above(999);
+            expect(code).to.be.below(2000);
+          } else if (isChildOf(ErrorClass, AbstractSignatureError)) {
+            expect(code).to.be.above(1999);
+            expect(code).to.be.below(3000);
+          } else if (isChildOf(ErrorClass, AbstractFeeError)) {
+            expect(code).to.be.above(2999);
+            expect(code).to.be.below(4000);
+          } else if (isChildOf(ErrorClass, AbstractStateError)) {
+            expect(code).to.be.above(3999);
+            expect(code).to.be.below(5000);
+          }
+        });
+
+        it('should not have duplicates', () => {
+          expect(errorClassDuplicates).to.not.include(ErrorClass);
+        });
+      });
+    }
+  });
+});

package/test/unit/identity/Identity.spec.js

@@ -0,0 +1,243 @@
+const generateRandomIdentifier = require('../../../lib/test/utils/generateRandomIdentifier');
+
+const IdentityPublicKey = require('../../../lib/identity/IdentityPublicKey');
+const Metadata = require('../../../lib/Metadata');
+const protocolVersion = require('../../../lib/version/protocolVersion');
+
+const Identity = require('../../../lib/identity/Identity');
+const serializer = require('../../../lib/util/serializer');
+const hash = require('../../../lib/util/hash');
+
+describe('Identity', () => {
+  let rawIdentity;
+  let identity;
+  let hashMock;
+  let encodeMock;
+  let metadataFixture;
+
+  beforeEach(function beforeEach() {
+    rawIdentity = {
+      protocolVersion: protocolVersion.latestVersion,
+      id: generateRandomIdentifier(),
+      publicKeys: [
+        {
+          id: 0,
+          type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+          data: Buffer.alloc(36).fill('a'),
+          purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+          securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+          readOnly: false,
+        },
+      ],
+      balance: 0,
+      revision: 0,
+    };
+
+    identity = new Identity(rawIdentity);
+
+    metadataFixture = new Metadata(42, 0);
+
+    identity.setMetadata(metadataFixture);
+
+    encodeMock = this.sinonSandbox.stub(serializer, 'encode');
+    hashMock = this.sinonSandbox.stub(hash, 'hash');
+  });
+
+  afterEach(() => {
+    encodeMock.restore();
+    hashMock.restore();
+  });
+
+  describe('#constructor', () => {
+    it('should set variables from raw model', () => {
+      const instance = new Identity(rawIdentity);
+
+      expect(instance.id).to.deep.equal(rawIdentity.id);
+      expect(instance.type).to.equal(rawIdentity.type);
+      expect(instance.publicKeys).to.deep.equal(
+        rawIdentity.publicKeys.map((rawPublicKey) => new IdentityPublicKey(rawPublicKey)),
+      );
+    });
+  });
+
+  describe('#getId', () => {
+    it('should return set id', () => {
+      expect(identity.getId()).to.deep.equal(rawIdentity.id);
+    });
+  });
+
+  describe('#getPublicKeys', () => {
+    it('should return set public keys', () => {
+      expect(identity.getPublicKeys()).to.deep.equal(
+        rawIdentity.publicKeys.map((rawPublicKey) => new IdentityPublicKey(rawPublicKey)),
+      );
+    });
+  });
+
+  describe('#setPublicKeys', () => {
+    it('should set public keys', () => {
+      identity.setPublicKeys(42);
+      expect(identity.publicKeys).to.equal(42);
+    });
+  });
+
+  describe('#getPublicKeyById', () => {
+    it('should return a public key for a given id', () => {
+      const key = identity.getPublicKeyById(0);
+
+      expect(key).to.be.deep.equal(new IdentityPublicKey(rawIdentity.publicKeys[0]));
+    });
+
+    it("should return undefined if there's no key with such id", () => {
+      const key = identity.getPublicKeyById(3);
+      expect(key).to.be.undefined();
+    });
+  });
+
+  describe('#toBuffer', () => {
+    it('should return serialized Identity', () => {
+      const encodeMockData = Buffer.from('42');
+      encodeMock.returns(encodeMockData); // for example
+
+      const result = identity.toBuffer();
+
+      const identityDataToEncode = identity.toObject();
+      delete identityDataToEncode.protocolVersion;
+
+      const protocolVersionUInt32 = Buffer.alloc(4);
+      protocolVersionUInt32.writeUInt32LE(identity.getProtocolVersion(), 0);
+
+      expect(encodeMock).to.have.been.calledOnceWith(identityDataToEncode);
+      expect(result).to.deep.equal(Buffer.concat([protocolVersionUInt32, encodeMockData]));
+    });
+  });
+
+  describe('#hash', () => {
+    it('should return hex string of a buffer return by serialize', () => {
+      const buffer = Buffer.from('someString');
+
+      encodeMock.returns(buffer);
+      hashMock.returns(buffer);
+
+      const result = identity.hash();
+
+      const identityDataToEncode = identity.toObject();
+      delete identityDataToEncode.protocolVersion;
+
+      const protocolVersionUInt32 = Buffer.alloc(4);
+      protocolVersionUInt32.writeUInt32LE(identity.getProtocolVersion(), 0);
+
+      expect(encodeMock).to.have.been.calledOnceWith(identityDataToEncode);
+      expect(hashMock).to.have.been.calledOnceWith(Buffer.concat([protocolVersionUInt32, buffer]));
+      expect(result).to.equal(buffer);
+    });
+  });
+
+  describe('#toObject', () => {
+    it('should return plain object representation', () => {
+      expect(identity.toObject()).to.deep.equal(rawIdentity);
+    });
+  });
+
+  describe('#toJSON', () => {
+    it('should return json representation', () => {
+      const jsonIdentity = identity.toJSON();
+
+      expect(jsonIdentity).to.deep.equal({
+        protocolVersion: protocolVersion.latestVersion,
+        id: rawIdentity.id.toString(),
+        publicKeys: [
+          {
+            id: 0,
+            type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+            data: rawIdentity.publicKeys[0].data.toString('base64'),
+            purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+            securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+            readOnly: false,
+          },
+        ],
+        balance: 0,
+        revision: 0,
+      });
+    });
+  });
+
+  describe('#getBalance', () => {
+    it('should return set identity balance', () => {
+      identity.balance = 42;
+      expect(identity.getBalance()).to.equal(42);
+    });
+  });
+
+  describe('#setBalance', () => {
+    it('should set identity balance', () => {
+      identity.setBalance(42);
+      expect(identity.balance).to.equal(42);
+    });
+  });
+
+  describe('#increaseBalance', () => {
+    it('should increase identity balance', () => {
+      const result = identity.increaseBalance(42);
+
+      expect(result).to.equal(42);
+      expect(identity.balance).to.equal(42);
+    });
+  });
+
+  describe('#reduceBalance', () => {
+    it('should reduce identity balance', () => {
+      identity.balance = 42;
+
+      const result = identity.reduceBalance(2);
+
+      expect(result).to.equal(40);
+      expect(identity.balance).to.equal(40);
+    });
+  });
+
+  describe('#setMetadata', () => {
+    it('should set metadata', () => {
+      const otherMetadata = new Metadata(43, 1);
+
+      identity.setMetadata(otherMetadata);
+
+      expect(identity.metadata).to.deep.equal(otherMetadata);
+    });
+  });
+
+  describe('#getMetadata', () => {
+    it('should get metadata', () => {
+      expect(identity.getMetadata()).to.deep.equal(metadataFixture);
+    });
+  });
+
+  describe('#getPublicKeyMaxId', () => {
+    it('should get the biggest public key ID', () => {
+      identity.publicKeys.push(
+        new IdentityPublicKey({
+          id: 99,
+          type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+          data: Buffer.alloc(36).fill('a'),
+          purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+          securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+          readOnly: false,
+        }),
+        new IdentityPublicKey({
+          id: 50,
+          type: IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+          data: Buffer.alloc(36).fill('a'),
+          purpose: IdentityPublicKey.PURPOSES.AUTHENTICATION,
+          securityLevel: IdentityPublicKey.SECURITY_LEVELS.MASTER,
+          readOnly: false,
+        }),
+      );
+
+      const maxId = identity.getPublicKeyMaxId();
+
+      const publicKeyIds = identity.getPublicKeys().map((publicKey) => publicKey.getId());
+
+      expect(Math.max(...publicKeyIds)).to.equal(maxId);
+    });
+  });
+});