@dashevo/wasm-dpp 0.23.0-dev.10

package/test/integration/document/Document.spec.js

@@ -0,0 +1,90 @@
+const Identifier = require('../../../lib/identifier/Identifier');
+const Metadata = require('../../../lib/Metadata');
+
+const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentsFixture = require('../../../lib/test/fixtures/getDocumentsFixture');
+
+describe('Document', () => {
+  let document;
+  let dataContract;
+  let metadataFixture;
+
+  beforeEach(() => {
+    dataContract = getDataContractFixture();
+    [document] = getDocumentsFixture(dataContract).slice(8);
+
+    metadataFixture = new Metadata(42, 0);
+
+    document.setMetadata(metadataFixture);
+  });
+
+  describe('#toJSON', () => {
+    it('should return json document', () => {
+      const result = document.toJSON();
+
+      expect(result).to.deep.equal({
+        $protocolVersion: document.getProtocolVersion(),
+        $dataContractId: dataContract.getId().toString(),
+        $id: document.getId().toString(),
+        $ownerId: getDocumentsFixture.ownerId.toString(),
+        $revision: 1,
+        $type: 'withByteArrays',
+        byteArrayField: document.get('byteArrayField').toString('base64'),
+        identifierField: document.get('identifierField').toString(),
+      });
+    });
+  });
+
+  describe('#toObject', () => {
+    it('should return raw document', () => {
+      const result = document.toObject();
+
+      expect(result).to.deep.equal({
+        $protocolVersion: document.getProtocolVersion(),
+        $dataContractId: dataContract.getId(),
+        $id: document.getId(),
+        $ownerId: getDocumentsFixture.ownerId,
+        $revision: 1,
+        $type: 'withByteArrays',
+        byteArrayField: document.get('byteArrayField'),
+        identifierField: document.get('identifierField'),
+      });
+    });
+
+    it('should return raw document with Identifiers', () => {
+      const result = document.toObject({ skipIdentifiersConversion: true });
+
+      expect(result).to.deep.equal({
+        $protocolVersion: document.getProtocolVersion(),
+        $dataContractId: dataContract.getId(),
+        $id: document.getId(),
+        $ownerId: getDocumentsFixture.ownerId,
+        $revision: 1,
+        $type: 'withByteArrays',
+        byteArrayField: document.get('byteArrayField'),
+        identifierField: document.get('identifierField'),
+      });
+
+      expect(result.$dataContractId).to.be.an.instanceOf(Identifier);
+      expect(result.$id).to.be.an.instanceOf(Identifier);
+      expect(result.$ownerId).to.be.an.instanceOf(Identifier);
+      expect(result.identifierField).to.be.an.instanceOf(Identifier);
+    });
+  });
+
+  describe('#setMetadata', () => {
+    it('should set metadata', () => {
+      const otherMetadata = new Metadata(43, 1);
+
+      document.setMetadata(otherMetadata);
+
+      expect(document.metadata).to.deep.equal(otherMetadata);
+    });
+  });
+
+  describe('#getMetadata', () => {
+    it('should get metadata', () => {
+      expect(document.getMetadata()).to.deep.equal(metadataFixture);
+    });
+  });
+});

package/test/integration/document/DocumentFacade.spec.js

@@ -0,0 +1,155 @@
+const generateRandomIdentifier = require('../../../lib/test/utils/generateRandomIdentifier');
+const DashPlatformProtocol = require('../../../lib/DashPlatformProtocol');
+
+const Document = require('../../../lib/document/Document');
+const DocumentsBatchTransition = require('../../../lib/document/stateTransition/DocumentsBatchTransition/DocumentsBatchTransition');
+
+const ValidationResult = require('../../../lib/validation/ValidationResult');
+
+const createStateRepositoryMock = require('../../../lib/test/mocks/createStateRepositoryMock');
+
+const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentsFixture = require('../../../lib/test/fixtures/getDocumentsFixture');
+const getDocumentTransitionsFixture = require('../../../lib/test/fixtures/getDocumentTransitionsFixture');
+
+const DataContractNotPresentError = require('../../../lib/errors/consensus/basic/document/DataContractNotPresentError');
+const MissingOptionError = require('../../../lib/errors/MissingOptionError');
+
+describe('DocumentFacade', () => {
+  let dpp;
+  let document;
+  let documents;
+  let dataContract;
+  let ownerId;
+  let stateRepositoryMock;
+
+  beforeEach(async function beforeEach() {
+    ownerId = generateRandomIdentifier();
+    dataContract = getDataContractFixture(ownerId);
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+
+    stateRepositoryMock.fetchDataContract.resolves(dataContract);
+
+    dpp = new DashPlatformProtocol({
+      stateRepository: stateRepositoryMock,
+    });
+    await dpp.initialize();
+
+    documents = getDocumentsFixture(dataContract);
+    ([document] = documents);
+  });
+
+  describe('create', () => {
+    it('should create Document', () => {
+      const result = dpp.document.create(
+        dataContract,
+        ownerId,
+        document.getType(),
+        document.getData(),
+      );
+
+      expect(result).to.be.an.instanceOf(Document);
+
+      expect(result.getType()).to.equal(document.getType());
+      expect(result.getData()).to.deep.equal(document.getData());
+    });
+  });
+
+  describe('createFromObject', () => {
+    it('should throw MissingOption if stateRepository is not set', async () => {
+      dpp = new DashPlatformProtocol();
+      await dpp.initialize();
+
+      try {
+        await dpp.document.createFromObject(document.toObject());
+
+        expect.fail('MissingOption should be thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(MissingOptionError);
+        expect(e.getOptionName()).to.equal('stateRepository');
+      }
+    });
+
+    it('should create Document from plain object', async () => {
+      const result = await dpp.document.createFromObject(document.toObject());
+
+      expect(result).to.be.an.instanceOf(Document);
+
+      expect(result.toObject()).to.deep.equal(document.toObject());
+    });
+  });
+
+  describe('createFromBuffer', () => {
+    it('should throw MissingOption if stateRepository is not set', async () => {
+      dpp = new DashPlatformProtocol();
+      await dpp.initialize();
+
+      try {
+        await dpp.document.createFromBuffer(document.toObject());
+
+        expect.fail('MissingOption should be thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(MissingOptionError);
+        expect(e.getOptionName()).to.equal('stateRepository');
+      }
+    });
+
+    it('should create Document from serialized', async () => {
+      const result = await dpp.document.createFromBuffer(document.toBuffer());
+
+      expect(result).to.be.an.instanceOf(Document);
+
+      expect(result.toObject()).to.deep.equal(document.toObject());
+    });
+  });
+
+  describe('createStateTransition', () => {
+    it('should create DocumentsBatchTransition with passed documents', () => {
+      const result = dpp.document.createStateTransition({
+        create: documents,
+      });
+
+      expect(result).to.be.instanceOf(DocumentsBatchTransition);
+      expect(result.getTransitions()).to.deep.equal(getDocumentTransitionsFixture({
+        create: documents,
+      }));
+    });
+  });
+
+  describe('validate', () => {
+    it('should throw MissingOption if stateRepository is not set', async () => {
+      dpp = new DashPlatformProtocol();
+      await dpp.initialize();
+
+      try {
+        await dpp.document.validate(document);
+
+        expect.fail('MissingOption should be thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(MissingOptionError);
+        expect(e.getOptionName()).to.equal('stateRepository');
+      }
+    });
+
+    it('should validate Document', async () => {
+      const result = await dpp.document.validate(document);
+
+      expect(result).to.be.an.instanceOf(ValidationResult);
+      expect(result.isValid()).to.be.true();
+    });
+
+    it('should return invalid result if Data Contract is invalid', async () => {
+      stateRepositoryMock.fetchDataContract.returns(null);
+
+      const result = await dpp.document.validate(document);
+
+      expect(result).to.be.an.instanceOf(ValidationResult);
+      expect(result.isValid()).to.be.false();
+
+      const [error] = result.getErrors();
+
+      expect(error).to.be.an.instanceOf(DataContractNotPresentError);
+    });
+  });
+});

package/test/integration/document/stateTransition/DocumentsBatchTransition/DocumentBatchTransition.spec.js

@@ -0,0 +1,83 @@
+const IdentityPublicKey = require('../../../../../lib/identity/IdentityPublicKey');
+
+const getDataContractFixture = require('../../../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentsFixture = require('../../../../../lib/test/fixtures/getDocumentsFixture');
+const DocumentFactory = require('../../../../../lib/document/DocumentFactory');
+const createDPPMock = require('../../../../../lib/test/mocks/createDPPMock');
+
+describe('DocumentBatchTransition', () => {
+  let stateTransitionFixture;
+  let dataContractFixture;
+  let documentsFixture;
+  let documentFactory;
+  let mediumSecurityDocumentFixture;
+  let masterSecurityDocumentFixture;
+  let noSecurityLevelSpecifiedDocumentFixture;
+
+  beforeEach(() => {
+    dataContractFixture = getDataContractFixture();
+
+    dataContractFixture.documents.niceDocument
+      .signatureSecurityLevelRequirement = IdentityPublicKey.SECURITY_LEVELS.MEDIUM;
+    dataContractFixture.documents.prettyDocument
+      .signatureSecurityLevelRequirement = IdentityPublicKey.SECURITY_LEVELS.MASTER;
+
+    // 0 is niceDocument,
+    // 1 and 2 are pretty documents,
+    // 3 and 4 are indexed documents that do not have security level specified
+    documentsFixture = getDocumentsFixture(dataContractFixture);
+    [
+      mediumSecurityDocumentFixture,,
+      masterSecurityDocumentFixture,,
+      noSecurityLevelSpecifiedDocumentFixture,
+    ] = documentsFixture;
+
+    documentFactory = new DocumentFactory(
+      createDPPMock(),
+      () => {},
+      () => {},
+    );
+
+    stateTransitionFixture = documentFactory.createStateTransition({
+      create: documentsFixture,
+      replace: [],
+      delete: [],
+    });
+  });
+
+  describe('#getRequiredKeySecurityLevel', () => {
+    it('should return the highest security level of all transitions', () => {
+      stateTransitionFixture = documentFactory.createStateTransition({
+        create: [mediumSecurityDocumentFixture],
+        replace: [],
+        delete: [],
+      });
+
+      // Nice document has medium security level
+      expect(stateTransitionFixture.getKeySecurityLevelRequirement())
+        .to.be.equal(IdentityPublicKey.SECURITY_LEVELS.MEDIUM);
+
+      stateTransitionFixture = documentFactory.createStateTransition({
+        create: [mediumSecurityDocumentFixture, masterSecurityDocumentFixture],
+        replace: [],
+        delete: [],
+      });
+
+      // Should be the highest security level out of MEDIUM and MASTER
+      expect(stateTransitionFixture.getKeySecurityLevelRequirement())
+        .to.be.equal(IdentityPublicKey.SECURITY_LEVELS.MASTER);
+    });
+
+    it('should return default security level if no document has a security level defined', () => {
+      stateTransitionFixture = documentFactory.createStateTransition({
+        create: [noSecurityLevelSpecifiedDocumentFixture],
+        replace: [],
+        delete: [],
+      });
+
+      // Should be the default level, which is HIGH
+      expect(stateTransitionFixture.getKeySecurityLevelRequirement())
+        .to.be.equal(IdentityPublicKey.SECURITY_LEVELS.HIGH);
+    });
+  });
+});