Skip to content

Commit 1bea3ff

Browse files
faustbrianfaustbrian
authored
feat(core-jest-matchers): functional test matchers (#2562)
1 parent 1ad8526 commit 1bea3ff

File tree

14 files changed

+270
-192
lines changed

14 files changed

+270
-192
lines changed

‎__tests__/functional/transaction-forging/__support__/index.ts

Lines changed: 0 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,6 @@ import "jest-extended";
33
import { Container, Database, State } from "@arkecosystem/core-interfaces";
44
import { Identities, Managers, Utils } from "@arkecosystem/crypto";
55
import delay from "delay";
6-
import { RestClient } from "../../../helpers";
76
import { secrets } from "../../../utils/config/testnet/delegates.json";
87
import { setUpContainer } from "../../../utils/helpers/container";
98

@@ -64,35 +63,6 @@ export const getLastHeight = (): number => {
6463
.getLastHeight();
6564
};
6665

67-
export const expectAcceptAndBroadcast = async (transactions, id): Promise<void> => {
68-
const { body } = await RestClient.broadcast(transactions);
69-
70-
if (body.data.invalid.length) {
71-
console.log(body.errors);
72-
}
73-
74-
expect(body.errors).toBeUndefined();
75-
expect(body.data.accept).toContain(id);
76-
expect(body.data.broadcast).toContain(id);
77-
};
78-
79-
export const expectInvalidAndError = async (transactions, id): Promise<void> => {
80-
const { body } = await RestClient.broadcast(transactions);
81-
82-
expect(body.errors).not.toBeUndefined();
83-
expect(body.data.invalid).toContain(id);
84-
};
85-
86-
export const expectTransactionForged = async (id): Promise<void> => {
87-
const { body } = await RestClient.get(`transactions/${id}`);
88-
89-
expect(body.data.id).toBe(id);
90-
};
91-
92-
export const expectTransactionNotForged = async (id): Promise<void> => {
93-
await expect(RestClient.get(`transactions/${id}`)).rejects.toThrowError("Response code 404 (Not Found)");
94-
};
95-
9666
export const passphrases = {
9767
passphrase: "this is top secret passphrase number 1",
9868
secondPassphrase: "this is top secret passphrase number 2",

‎__tests__/functional/transaction-forging/delegate-registration.test.ts

Lines changed: 33 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -13,20 +13,20 @@ describe("Transaction Forging - Delegate Registration", () => {
1313
// Initial Funds
1414
const initialFunds = TransactionFactory.transfer(Identities.Address.fromPassphrase(passphrase), 100 * 1e8)
1515
.withPassphrase(secrets[0])
16-
.create();
16+
.createOne();
1717

18-
await support.expectAcceptAndBroadcast(initialFunds, initialFunds[0].id);
18+
await expect(initialFunds).toBeAccepted();
1919
await support.snoozeForBlock(1);
20-
await support.expectTransactionForged(initialFunds[0].id);
20+
await expect(initialFunds.id).toBeForged();
2121

2222
// Register a delegate
2323
const transactions = TransactionFactory.delegateRegistration()
2424
.withPassphrase(passphrase)
25-
.create();
25+
.createOne();
2626

27-
await support.expectAcceptAndBroadcast(transactions, transactions[0].id);
27+
await expect(transactions).toBeAccepted();
2828
await support.snoozeForBlock(1);
29-
await support.expectTransactionForged(transactions[0].id);
29+
await expect(transactions.id).toBeForged();
3030
});
3131

3232
it("should broadcast, accept and forge it [Signed with 2 Passphrases]", async () => {
@@ -36,40 +36,40 @@ describe("Transaction Forging - Delegate Registration", () => {
3636
// Initial Funds
3737
const initialFunds = TransactionFactory.transfer(Identities.Address.fromPassphrase(passphrase), 100 * 1e8)
3838
.withPassphrase(secrets[0])
39-
.create();
39+
.createOne();
4040

41-
await support.expectAcceptAndBroadcast(initialFunds, initialFunds[0].id);
41+
await expect(initialFunds).toBeAccepted();
4242
await support.snoozeForBlock(1);
43-
await support.expectTransactionForged(initialFunds[0].id);
43+
await expect(initialFunds.id).toBeForged();
4444

4545
// Register a second passphrase
4646
const secondSignature = TransactionFactory.secondSignature(secondPassphrase)
4747
.withPassphrase(passphrase)
48-
.create();
48+
.createOne();
4949

50-
await support.expectAcceptAndBroadcast(secondSignature, secondSignature[0].id);
50+
await expect(secondSignature).toBeAccepted();
5151
await support.snoozeForBlock(1);
52-
await support.expectTransactionForged(secondSignature[0].id);
52+
await expect(secondSignature.id).toBeForged();
5353

5454
// Register a delegate
5555
const delegateRegistration = TransactionFactory.delegateRegistration()
5656
.withPassphrasePair({ passphrase, secondPassphrase })
57-
.create();
57+
.createOne();
5858

59-
await support.expectAcceptAndBroadcast(delegateRegistration, delegateRegistration[0].id);
59+
await expect(delegateRegistration).toBeAccepted();
6060
await support.snoozeForBlock(1);
61-
await support.expectTransactionForged(delegateRegistration[0].id);
61+
await expect(delegateRegistration.id).toBeForged();
6262
});
6363

6464
it("should broadcast, accept and forge it [3-of-3 multisig]", async () => {
6565
// Funds to register a multi signature wallet
6666
const initialFunds = TransactionFactory.transfer(Identities.Address.fromPassphrase(secrets[3]), 50 * 1e8)
6767
.withPassphrase(secrets[0])
68-
.create();
68+
.createOne();
6969

70-
await support.expectAcceptAndBroadcast(initialFunds, initialFunds[0].id);
70+
await expect(initialFunds).toBeAccepted();
7171
await support.snoozeForBlock(1);
72-
await support.expectTransactionForged(initialFunds[0].id);
72+
await expect(initialFunds.id).toBeForged();
7373

7474
// Register a multi signature wallet with defaults
7575
const passphrases = [secrets[3], secrets[4], secrets[5]];
@@ -82,42 +82,42 @@ describe("Transaction Forging - Delegate Registration", () => {
8282
const multiSignature = TransactionFactory.multiSignature(participants, 3)
8383
.withPassphrase(secrets[3])
8484
.withPassphraseList(passphrases)
85-
.create();
85+
.createOne();
8686

87-
await support.expectAcceptAndBroadcast(multiSignature, multiSignature[0].id);
87+
await expect(multiSignature).toBeAccepted();
8888
await support.snoozeForBlock(1);
89-
await support.expectTransactionForged(multiSignature[0].id);
89+
await expect(multiSignature.id).toBeForged();
9090

9191
// Send funds to multi signature wallet
92-
const multiSigAddress = Identities.Address.fromMultiSignatureAsset(multiSignature[0].asset.multiSignature);
93-
const multiSigPublicKey = Identities.PublicKey.fromMultiSignatureAsset(multiSignature[0].asset.multiSignature);
92+
const multiSigAddress = Identities.Address.fromMultiSignatureAsset(multiSignature.asset.multiSignature);
93+
const multiSigPublicKey = Identities.PublicKey.fromMultiSignatureAsset(multiSignature.asset.multiSignature);
9494

9595
const multiSignatureFunds = TransactionFactory.transfer(multiSigAddress, 30 * 1e8)
9696
.withPassphrase(secrets[0])
97-
.create();
97+
.createOne();
9898

99-
await support.expectAcceptAndBroadcast(multiSignatureFunds, multiSignatureFunds[0].id);
99+
await expect(multiSignatureFunds).toBeAccepted();
100100
await support.snoozeForBlock(1);
101-
await support.expectTransactionForged(multiSignatureFunds[0].id);
101+
await expect(multiSignatureFunds.id).toBeForged();
102102

103103
// Try to register a delegate which should fail
104104
const delegateRegistration = TransactionFactory.delegateRegistration()
105105
.withSenderPublicKey(multiSigPublicKey)
106106
.withPassphraseList(passphrases)
107-
.create();
107+
.createOne();
108108

109-
await support.expectInvalidAndError(delegateRegistration, delegateRegistration[0].id);
109+
await expect(delegateRegistration.id).toBeRejected();
110110
await support.snoozeForBlock(1);
111-
await support.expectTransactionNotForged(delegateRegistration[0].id);
111+
await expect(delegateRegistration.id).not.toBeForged();
112112

113-
// Create transfer to assert multi sig wallet can still send funds
113+
// createOne transfer to assert multi sig wallet can still send funds
114114
const transfer = TransactionFactory.transfer(multiSigAddress, 29 * 1e8)
115115
.withSenderPublicKey(multiSigPublicKey)
116116
.withPassphraseList(passphrases)
117-
.create();
117+
.createOne();
118118

119-
await support.expectAcceptAndBroadcast(transfer, transfer[0].id);
119+
await expect(transfer).toBeAccepted();
120120
await support.snoozeForBlock(1);
121-
await support.expectTransactionForged(transfer[0].id);
121+
await expect(transfer.id).toBeForged();
122122
});
123123
});

‎__tests__/functional/transaction-forging/ipfs.test.ts

Lines changed: 29 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -19,20 +19,20 @@ describe("Transaction Forging - IPFS", () => {
1919
// Initial Funds
2020
const initialFunds = TransactionFactory.transfer(Identities.Address.fromPassphrase(passphrase), 100 * 1e8)
2121
.withPassphrase(secrets[0])
22-
.create();
22+
.createOne();
2323

24-
await support.expectAcceptAndBroadcast(initialFunds, initialFunds[0].id);
24+
await expect(initialFunds).toBeAccepted();
2525
await support.snoozeForBlock(1);
26-
await support.expectTransactionForged(initialFunds[0].id);
26+
await expect(initialFunds.id).toBeForged();
2727

2828
// Submit ipfs transaction
2929
const transactions = TransactionFactory.ipfs(ipfsIds[0])
3030
.withPassphrase(passphrase)
31-
.create();
31+
.createOne();
3232

33-
await support.expectAcceptAndBroadcast(transactions, transactions[0].id);
33+
await expect(transactions).toBeAccepted();
3434
await support.snoozeForBlock(1);
35-
await support.expectTransactionForged(transactions[0].id);
35+
await expect(transactions.id).toBeForged();
3636
});
3737

3838
it("should broadcast, accept and forge it [Signed with 2 Passphrases]", async () => {
@@ -42,40 +42,40 @@ describe("Transaction Forging - IPFS", () => {
4242
// Initial Funds
4343
const initialFunds = TransactionFactory.transfer(Identities.Address.fromPassphrase(passphrase), 100 * 1e8)
4444
.withPassphrase(secrets[0])
45-
.create();
45+
.createOne();
4646

47-
await support.expectAcceptAndBroadcast(initialFunds, initialFunds[0].id);
47+
await expect(initialFunds).toBeAccepted();
4848
await support.snoozeForBlock(1);
49-
await support.expectTransactionForged(initialFunds[0].id);
49+
await expect(initialFunds.id).toBeForged();
5050

5151
// Register a second passphrase
5252
const secondSignature = TransactionFactory.secondSignature(secondPassphrase)
5353
.withPassphrase(passphrase)
54-
.create();
54+
.createOne();
5555

56-
await support.expectAcceptAndBroadcast(secondSignature, secondSignature[0].id);
56+
await expect(secondSignature).toBeAccepted();
5757
await support.snoozeForBlock(1);
58-
await support.expectTransactionForged(secondSignature[0].id);
58+
await expect(secondSignature.id).toBeForged();
5959

6060
// Submit ipfs transaction
6161
const transactions = TransactionFactory.ipfs(ipfsIds[1])
6262
.withPassphrasePair({ passphrase, secondPassphrase })
63-
.create();
63+
.createOne();
6464

65-
await support.expectAcceptAndBroadcast(transactions, transactions[0].id);
65+
await expect(transactions).toBeAccepted();
6666
await support.snoozeForBlock(1);
67-
await support.expectTransactionForged(transactions[0].id);
67+
await expect(transactions.id).toBeForged();
6868
});
6969

7070
it("should broadcast, accept and forge it [3-of-3 multisig]", async () => {
7171
// Funds to register a multi signature wallet
7272
const initialFunds = TransactionFactory.transfer(Identities.Address.fromPassphrase(secrets[3]), 50 * 1e8)
7373
.withPassphrase(secrets[0])
74-
.create();
74+
.createOne();
7575

76-
await support.expectAcceptAndBroadcast(initialFunds, initialFunds[0].id);
76+
await expect(initialFunds).toBeAccepted();
7777
await support.snoozeForBlock(1);
78-
await support.expectTransactionForged(initialFunds[0].id);
78+
await expect(initialFunds.id).toBeForged();
7979

8080
// Register a multi signature wallet with defaults
8181
const passphrases = [secrets[3], secrets[4], secrets[5]];
@@ -88,32 +88,32 @@ describe("Transaction Forging - IPFS", () => {
8888
const multiSignature = TransactionFactory.multiSignature(participants, 3)
8989
.withPassphrase(secrets[3])
9090
.withPassphraseList(passphrases)
91-
.create();
91+
.createOne();
9292

93-
await support.expectAcceptAndBroadcast(multiSignature, multiSignature[0].id);
93+
await expect(multiSignature).toBeAccepted();
9494
await support.snoozeForBlock(1);
95-
await support.expectTransactionForged(multiSignature[0].id);
95+
await expect(multiSignature.id).toBeForged();
9696

9797
// Send funds to multi signature wallet
98-
const multiSigAddress = Identities.Address.fromMultiSignatureAsset(multiSignature[0].asset.multiSignature);
99-
const multiSigPublicKey = Identities.PublicKey.fromMultiSignatureAsset(multiSignature[0].asset.multiSignature);
98+
const multiSigAddress = Identities.Address.fromMultiSignatureAsset(multiSignature.asset.multiSignature);
99+
const multiSigPublicKey = Identities.PublicKey.fromMultiSignatureAsset(multiSignature.asset.multiSignature);
100100

101101
const multiSignatureFunds = TransactionFactory.transfer(multiSigAddress, 20 * 1e8)
102102
.withPassphrase(secrets[0])
103-
.create();
103+
.createOne();
104104

105-
await support.expectAcceptAndBroadcast(multiSignatureFunds, multiSignatureFunds[0].id);
105+
await expect(multiSignatureFunds).toBeAccepted();
106106
await support.snoozeForBlock(1);
107-
await support.expectTransactionForged(multiSignatureFunds[0].id);
107+
await expect(multiSignatureFunds.id).toBeForged();
108108

109109
// Submit ipfs transaction
110110
const transactions = TransactionFactory.ipfs(ipfsIds[0])
111111
.withSenderPublicKey(multiSigPublicKey)
112112
.withPassphraseList(passphrases)
113-
.create();
113+
.createOne();
114114

115-
await support.expectAcceptAndBroadcast(transactions, transactions[0].id);
115+
await expect(transactions).toBeAccepted();
116116
await support.snoozeForBlock(1);
117-
await support.expectTransactionForged(transactions[0].id);
117+
await expect(transactions.id).toBeForged();
118118
});
119119
});

‎__tests__/functional/transaction-forging/multi-signature-registration.test.ts

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -13,11 +13,11 @@ describe("Transaction Forging - Multi Signature Registration", () => {
1313
// Funds to register a multi signature wallet
1414
const initialFunds = TransactionFactory.transfer(Identities.Address.fromPassphrase(passphrase), 50 * 1e8)
1515
.withPassphrase(secrets[0])
16-
.create();
16+
.createOne();
1717

18-
await support.expectAcceptAndBroadcast(initialFunds, initialFunds[0].id);
18+
await expect(initialFunds).toBeAccepted();
1919
await support.snoozeForBlock(1);
20-
await support.expectTransactionForged(initialFunds[0].id);
20+
await expect(initialFunds.id).toBeForged();
2121

2222
// Register a multi signature wallet with defaults
2323
const passphrases = [passphrase, secrets[1], secrets[2]];
@@ -30,32 +30,32 @@ describe("Transaction Forging - Multi Signature Registration", () => {
3030
const multiSignature = TransactionFactory.multiSignature(participants, 3)
3131
.withPassphrase(passphrase)
3232
.withPassphraseList(passphrases)
33-
.create();
33+
.createOne();
3434

35-
await support.expectAcceptAndBroadcast(multiSignature, multiSignature[0].id);
35+
await expect(multiSignature).toBeAccepted();
3636
await support.snoozeForBlock(1);
37-
await support.expectTransactionForged(multiSignature[0].id);
37+
await expect(multiSignature.id).toBeForged();
3838
});
3939

4040
it("should broadcast, accept and forge it [Signed with 2 Passphrases]", async () => {
4141
const passphrase = secrets[2];
4242
// Make a fresh wallet for the second signature tests
4343
const initialFunds = TransactionFactory.transfer(Identities.Address.fromPassphrase(passphrase), 100 * 1e8)
4444
.withPassphrase(secrets[0])
45-
.create();
45+
.createOne();
4646

47-
await support.expectAcceptAndBroadcast(initialFunds, initialFunds[0].id);
47+
await expect(initialFunds).toBeAccepted();
4848
await support.snoozeForBlock(1);
49-
await support.expectTransactionForged(initialFunds[0].id);
49+
await expect(initialFunds.id).toBeForged();
5050

5151
// Register a second passphrase
5252
const secondSignature = TransactionFactory.secondSignature(secondPassphrase)
5353
.withPassphrase(passphrase)
54-
.create();
54+
.createOne();
5555

56-
await support.expectAcceptAndBroadcast(secondSignature, secondSignature[0].id);
56+
await expect(secondSignature).toBeAccepted();
5757
await support.snoozeForBlock(1);
58-
await support.expectTransactionForged(secondSignature[0].id);
58+
await expect(secondSignature.id).toBeForged();
5959

6060
// Register a multi signature wallet with defaults
6161
const passphrases = [passphrase, secrets[3], secrets[4]];
@@ -68,10 +68,10 @@ describe("Transaction Forging - Multi Signature Registration", () => {
6868
const multiSignature = TransactionFactory.multiSignature(participants, 3)
6969
.withPassphraseList(passphrases)
7070
.withPassphrasePair({ passphrase, secondPassphrase })
71-
.create();
71+
.createOne();
7272

73-
await support.expectAcceptAndBroadcast(multiSignature, multiSignature[0].id);
73+
await expect(multiSignature).toBeAccepted();
7474
await support.snoozeForBlock(1);
75-
await support.expectTransactionForged(multiSignature[0].id);
75+
await expect(multiSignature.id).toBeForged();
7676
});
7777
});

0 commit comments

Comments
 (0)