test(core-magistrate-crypto): increase test coverage to 100% (#3983)

__tests__/unit/core-magistrate-crypto/builders/bridgechain-registration.test.ts

@@ -0,0 +1,64 @@
+import "jest-extended";
+
+import { BridgechainRegistrationTransaction } from "@arkecosystem/core-magistrate-crypto/dist/transactions";
+import { BridgechainRegistrationBuilder } from "@packages/core-magistrate-crypto/src/builders";
+import { IBridgechainRegistrationAsset } from "@packages/core-magistrate-crypto/src/interfaces";
+import { Managers, Transactions } from "@packages/crypto";
+
+let builder: BridgechainRegistrationBuilder;
+
+const bridgechainRegistrationAsset: IBridgechainRegistrationAsset = {
+    name: "dummy_name",
+    seedNodes: [],
+    genesisHash: "dummy_genesis_hash",
+    bridgechainRepository: "dummy_repository",
+    bridgechainAssetRepository: "dummy_asset_repository",
+    ports: {
+        port_name: 1234,
+    },
+};
+
+beforeAll(() => {
+    Transactions.TransactionRegistry.registerTransactionType(BridgechainRegistrationTransaction);
+});
+
+beforeEach(() => {
+    Managers.configManager.setFromPreset("testnet");
+    Managers.configManager.setHeight(2);
+    builder = new BridgechainRegistrationBuilder();
+});
+
+describe("Bridgechain registration builder", () => {
+    describe("bridgechainRegistrationAsset", () => {
+        it("should set asset", () => {
+            expect(builder.bridgechainRegistrationAsset(bridgechainRegistrationAsset)).toBe(builder);
+
+            expect(builder.data.asset!.bridgechainRegistration).toEqual(bridgechainRegistrationAsset);
+        });
+
+        it("should not set asset if asset is undefined", () => {
+            builder.data.asset = undefined;
+
+            expect(builder.bridgechainRegistrationAsset(bridgechainRegistrationAsset)).toBe(builder);
+
+            expect(builder.data.asset).toBeUndefined();
+        });
+
+        it("should not set asset if asset.bridgechainRegistration is undefined", () => {
+            builder.data.asset!.bridgechainRegistration = undefined;
+
+            expect(builder.bridgechainRegistrationAsset(bridgechainRegistrationAsset)).toBe(builder);
+
+            expect(builder.data.asset!.bridgechainRegistration).toBeUndefined();
+        });
+    });
+
+    describe("getStruct", () => {
+        it("should return struct", () => {
+            builder.bridgechainRegistrationAsset(bridgechainRegistrationAsset);
+            const struct = builder.sign("dummy_passphrase").getStruct();
+
+            expect(struct.asset!.bridgechainRegistration).toEqual(bridgechainRegistrationAsset);
+        });
+    });
+});

__tests__/unit/core-magistrate-crypto/builders/bridgechain-resignation.test.ts

@@ -0,0 +1,57 @@
+import "jest-extended";
+
+import { BridgechainResignationTransaction } from "@arkecosystem/core-magistrate-crypto/dist/transactions";
+import { BridgechainResignationBuilder } from "@packages/core-magistrate-crypto/src/builders";
+import { IBridgechainResignationAsset } from "@packages/core-magistrate-crypto/src/interfaces";
+import { Managers, Transactions } from "@packages/crypto";
+
+let builder: BridgechainResignationBuilder;
+
+const bridgechainResignationAsset: IBridgechainResignationAsset = {
+    bridgechainId: "dummy_id",
+};
+
+beforeAll(() => {
+    Transactions.TransactionRegistry.registerTransactionType(BridgechainResignationTransaction);
+});
+
+beforeEach(() => {
+    Managers.configManager.setFromPreset("testnet");
+    Managers.configManager.setHeight(2);
+    builder = new BridgechainResignationBuilder();
+});
+
+describe("Bridgechain resignation builder", () => {
+    describe("bridgechainResignationAsset", () => {
+        it("should set asset", () => {
+            expect(builder.bridgechainResignationAsset("dummy_id")).toBe(builder);
+
+            expect(builder.data.asset!.bridgechainResignation).toEqual(bridgechainResignationAsset);
+        });
+
+        it("should not set asset if asset is undefined", () => {
+            builder.data.asset = undefined;
+
+            expect(builder.bridgechainResignationAsset("dummy_id")).toBe(builder);
+
+            expect(builder.data.asset).toBeUndefined();
+        });
+
+        it("should not set asset if asset.bridgechainRegistration is undefined", () => {
+            builder.data.asset!.bridgechainResignation = undefined;
+
+            expect(builder.bridgechainResignationAsset("dummy_id")).toBe(builder);
+
+            expect(builder.data.asset!.bridgechainResignation).toBeUndefined();
+        });
+    });
+
+    describe("getStruct", () => {
+        it("should return struct", () => {
+            builder.bridgechainResignationAsset("dummy_id");
+            const struct = builder.sign("dummy_passphrase").getStruct();
+
+            expect(struct.asset!.bridgechainResignation).toEqual(bridgechainResignationAsset);
+        });
+    });
+});

__tests__/unit/core-magistrate-crypto/builders/bridgechain-update.test.ts

@@ -0,0 +1,63 @@
+import "jest-extended";
+
+import { BridgechainUpdateTransaction } from "@arkecosystem/core-magistrate-crypto/dist/transactions";
+import { BridgechainUpdateBuilder } from "@packages/core-magistrate-crypto/src/builders";
+import { IBridgechainUpdateAsset } from "@packages/core-magistrate-crypto/src/interfaces";
+import { Managers, Transactions } from "@packages/crypto";
+
+let builder: BridgechainUpdateBuilder;
+
+const bridgechainUpdateAsset: IBridgechainUpdateAsset = {
+    bridgechainId: "dummy_id",
+    seedNodes: [],
+    ports: {
+        dummy_port: 1234,
+    },
+    bridgechainRepository: "dummy_repository",
+    bridgechainAssetRepository: "dummy_asset_repository",
+};
+
+beforeAll(() => {
+    Transactions.TransactionRegistry.registerTransactionType(BridgechainUpdateTransaction);
+});
+
+beforeEach(() => {
+    Managers.configManager.setFromPreset("testnet");
+    Managers.configManager.setHeight(2);
+    builder = new BridgechainUpdateBuilder();
+});
+
+describe("Bridgechain update builder", () => {
+    describe("bridgechainUpdateAsset", () => {
+        it("should set asset", () => {
+            expect(builder.bridgechainUpdateAsset(bridgechainUpdateAsset)).toBe(builder);
+
+            expect(builder.data.asset!.bridgechainUpdate).toEqual(bridgechainUpdateAsset);
+        });
+
+        it("should not set asset if asset is undefined", () => {
+            builder.data.asset = undefined;
+
+            expect(builder.bridgechainUpdateAsset(bridgechainUpdateAsset)).toBe(builder);
+
+            expect(builder.data.asset).toBeUndefined();
+        });
+
+        it("should not set asset if asset.bridgechainRegistration is undefined", () => {
+            builder.data.asset!.bridgechainUpdate = undefined;
+
+            expect(builder.bridgechainUpdateAsset(bridgechainUpdateAsset)).toBe(builder);
+
+            expect(builder.data.asset!.bridgechainUpdate).toBeUndefined();
+        });
+    });
+
+    describe("getStruct", () => {
+        it("should return struct", () => {
+            builder.bridgechainUpdateAsset(bridgechainUpdateAsset);
+            const struct = builder.sign("dummy_passphrase").getStruct();
+
+            expect(struct.asset!.bridgechainUpdate).toEqual(bridgechainUpdateAsset);
+        });
+    });
+});

__tests__/unit/core-magistrate-crypto/builders/business-registration.test.ts

@@ -0,0 +1,60 @@
+import "jest-extended";
+
+import { BusinessRegistrationTransaction } from "@arkecosystem/core-magistrate-crypto/dist/transactions";
+import { BusinessRegistrationBuilder } from "@packages/core-magistrate-crypto/src/builders";
+import { IBusinessRegistrationAsset } from "@packages/core-magistrate-crypto/src/interfaces";
+import { Managers, Transactions } from "@packages/crypto";
+
+let builder: BusinessRegistrationBuilder;
+
+const businessRegistrationAsset: IBusinessRegistrationAsset = {
+    name: "dummy_name",
+    website: "dummy_website",
+    vat: "dummy_vat",
+    repository: "dummy_repository",
+};
+
+beforeAll(() => {
+    Transactions.TransactionRegistry.registerTransactionType(BusinessRegistrationTransaction);
+});
+
+beforeEach(() => {
+    Managers.configManager.setFromPreset("testnet");
+    Managers.configManager.setHeight(2);
+    builder = new BusinessRegistrationBuilder();
+});
+
+describe("Business registration builder", () => {
+    describe("businessRegistrationAsset", () => {
+        it("should set asset", () => {
+            expect(builder.businessRegistrationAsset(businessRegistrationAsset)).toBe(builder);
+
+            expect(builder.data.asset!.businessRegistration).toEqual(businessRegistrationAsset);
+        });
+
+        it("should not set asset if asset is undefined", () => {
+            builder.data.asset = undefined;
+
+            expect(builder.businessRegistrationAsset(businessRegistrationAsset)).toBe(builder);
+
+            expect(builder.data.asset).toBeUndefined();
+        });
+
+        it("should not set asset if asset.bridgechainRegistration is undefined", () => {
+            builder.data.asset!.businessRegistration = undefined;
+
+            expect(builder.businessRegistrationAsset(businessRegistrationAsset)).toBe(builder);
+
+            expect(builder.data.asset!.businessRegistration).toBeUndefined();
+        });
+    });
+
+    describe("getStruct", () => {
+        it("should return struct", () => {
+            builder.businessRegistrationAsset(businessRegistrationAsset);
+            const struct = builder.sign("dummy_passphrase").getStruct();
+
+            expect(struct.asset!.businessRegistration).toEqual(businessRegistrationAsset);
+        });
+    });
+});

__tests__/unit/core-magistrate-crypto/builders/business-resignation.test.ts

@@ -0,0 +1,27 @@
+import "jest-extended";
+
+import { BusinessResignationTransaction } from "@arkecosystem/core-magistrate-crypto/dist/transactions";
+import { BusinessResignationBuilder } from "@packages/core-magistrate-crypto/src/builders";
+import { Managers, Transactions } from "@packages/crypto";
+
+let builder: BusinessResignationBuilder;
+
+beforeAll(() => {
+    Transactions.TransactionRegistry.registerTransactionType(BusinessResignationTransaction);
+});
+
+beforeEach(() => {
+    Managers.configManager.setFromPreset("testnet");
+    Managers.configManager.setHeight(2);
+    builder = new BusinessResignationBuilder();
+});
+
+describe("Business resignation builder", () => {
+    describe("getStruct", () => {
+        it("should return struct", () => {
+            const struct = builder.sign("dummy_passphrase").getStruct();
+
+            expect(struct.asset!.businessResignation).toEqual({});
+        });
+    });
+});

__tests__/unit/core-magistrate-crypto/builders/business-update.test.ts

@@ -0,0 +1,60 @@
+import "jest-extended";
+
+import { BusinessUpdateTransaction } from "@arkecosystem/core-magistrate-crypto/dist/transactions";
+import { BusinessUpdateBuilder } from "@packages/core-magistrate-crypto/src/builders";
+import { IBusinessUpdateAsset } from "@packages/core-magistrate-crypto/src/interfaces";
+import { Managers, Transactions } from "@packages/crypto";
+
+let builder: BusinessUpdateBuilder;
+
+const businessUpdateAsset: IBusinessUpdateAsset = {
+    name: "dummy_name",
+    website: "dummy_website",
+    vat: "dummy_vat",
+    repository: "dummy_repository",
+};
+
+beforeAll(() => {
+    Transactions.TransactionRegistry.registerTransactionType(BusinessUpdateTransaction);
+});
+
+beforeEach(() => {
+    Managers.configManager.setFromPreset("testnet");
+    Managers.configManager.setHeight(2);
+    builder = new BusinessUpdateBuilder();
+});
+
+describe("Business update builder", () => {
+    describe("businessUpdateAsset", () => {
+        it("should set asset", () => {
+            expect(builder.businessUpdateAsset(businessUpdateAsset)).toBe(builder);
+
+            expect(builder.data.asset!.businessUpdate).toEqual(businessUpdateAsset);
+        });
+
+        it("should not set asset if asset is undefined", () => {
+            builder.data.asset = undefined;
+
+            expect(builder.businessUpdateAsset(businessUpdateAsset)).toBe(builder);
+
+            expect(builder.data.asset).toBeUndefined();
+        });
+
+        it("should not set asset if asset.bridgechainRegistration is undefined", () => {
+            builder.data.asset!.businessUpdate = undefined;
+
+            expect(builder.businessUpdateAsset(businessUpdateAsset)).toBe(builder);
+
+            expect(builder.data.asset!.businessUpdate).toBeUndefined();
+        });
+    });
+
+    describe("getStruct", () => {
+        it("should return struct", () => {
+            builder.businessUpdateAsset(businessUpdateAsset);
+            const struct = builder.sign("dummy_passphrase").getStruct();
+
+            expect(struct.asset!.businessUpdate).toEqual(businessUpdateAsset);
+        });
+    });
+});

__tests__/unit/core-magistrate-crypto/builders/enity.test.ts

@@ -0,0 +1,49 @@
+import "jest-extended";
+
+import { EntityAction, EntitySubType, EntityType } from "@arkecosystem/core-magistrate-crypto/dist/enums";
+import { EntityTransaction } from "@arkecosystem/core-magistrate-crypto/dist/transactions";
+import { EntityBuilder } from "@packages/core-magistrate-crypto/src/builders";
+import { IEntityAsset } from "@packages/core-magistrate-crypto/src/interfaces";
+import { Managers, Transactions } from "@packages/crypto";
+
+let builder: EntityBuilder;
+
+const entityAsset: IEntityAsset = {
+    type: EntityType.Bridgechain,
+    subType: EntitySubType.None,
+    action: EntityAction.Register,
+    registrationId: "dummy_registration_id",
+    data: {
+        name: "dummy_name",
+        ipfsData: "dummy_ipfs_data",
+    },
+};
+
+beforeAll(() => {
+    Transactions.TransactionRegistry.registerTransactionType(EntityTransaction);
+});
+
+beforeEach(() => {
+    Managers.configManager.setFromPreset("testnet");
+    Managers.configManager.setHeight(2);
+    builder = new EntityBuilder();
+});
+
+describe("Entity builder", () => {
+    describe("businessRegistrationAsset", () => {
+        it("should set asset", () => {
+            expect(builder.asset(entityAsset)).toBe(builder);
+
+            expect(builder.data.asset).toEqual(entityAsset);
+        });
+    });
+
+    describe("getStruct", () => {
+        it("should return struct", () => {
+            builder.asset(entityAsset);
+            const struct = builder.sign("dummy_passphrase").getStruct();
+
+            expect(struct.asset).toEqual(entityAsset);
+        });
+    });
+});