diff --git a/src/routes/safe/component/AddTransaction/test/transactions.builder.js b/src/routes/safe/component/AddTransaction/test/transactions.builder.js deleted file mode 100644 index e69de29b..00000000 diff --git a/src/routes/safe/component/Safe/BalanceInfo.jsx b/src/routes/safe/component/Safe/BalanceInfo.jsx index 7073f2d4..8ce24646 100644 --- a/src/routes/safe/component/Safe/BalanceInfo.jsx +++ b/src/routes/safe/component/Safe/BalanceInfo.jsx @@ -29,7 +29,7 @@ const styles = { }, } -export const MOVE_FUNDS_BUTTON_TEXT = 'Move Funds' +export const MOVE_FUNDS_BUTTON_TEXT = 'Move' const BalanceComponent = openHoc(({ open, toggle, balances, classes, onMoveFunds, diff --git a/src/test/safe.service.transactions.test.js b/src/test/safe.service.transactions.test.js new file mode 100644 index 00000000..ea05bbcb --- /dev/null +++ b/src/test/safe.service.transactions.test.js @@ -0,0 +1,226 @@ +// @flow +import { List, Map } from 'immutable' +import { storeTransaction, buildConfirmationsFrom, EXECUTED_CONFIRMATION_HASH, buildExecutedConfirmationFrom } from '~/routes/safe/component/AddTransaction/createTransactions' +import { type Transaction } from '~/routes/safe/store/model/transaction' +import { SafeFactory } from '~/routes/safe/store/test/builder/safe.builder' +import { type Safe } from '~/routes/safe/store/model/safe' +import { type Owner } from '~/routes/safe/store/model/owner' +import { loadSafeTransactions } from '~/routes/safe/store/actions/fetchTransactions' +import { type Confirmation } from '~/routes/safe/store/model/confirmation' +import { EMPTY_DATA } from '~/wallets/ethTransactions' +import { testSizeOfSafesWith, testSizeOfTransactions, testTransactionFrom } from './utils/historyServiceHelper' + +describe('Transactions Suite', () => { + let safe: Safe + let destination: string + let value: number + let owners: List + beforeEach(async () => { + localStorage.clear() + + safe = SafeFactory.twoOwnersSafe('foo', 'bar') + destination = 'baz' + value = 2 + owners = safe.get('owners') + + const firstOwner = owners.get(0) + if (!firstOwner) { throw new Error() } + const secondOwner = owners.get(1) + if (!secondOwner) { throw new Error() } + }) + + it('adds first confirmation to stored safe', async () => { + // GIVEN + const txName = 'Buy butteries for project' + const nonce: number = 10 + const confirmations: List = buildConfirmationsFrom(owners, 'foo', 'confirmationHash') + storeTransaction(txName, nonce, destination, value, 'foo', confirmations, '', safe.get('address'), safe.get('threshold'), EMPTY_DATA) + + // WHEN + const transactions: Map> = loadSafeTransactions() + + // THEN + testSizeOfSafesWith(transactions, 1) + + const safeTransactions: List | typeof undefined = transactions.get(safe.get('address')) + if (!safeTransactions) { throw new Error() } + testSizeOfTransactions(safeTransactions, 1) + + testTransactionFrom(safeTransactions, 0, txName, nonce, value, 2, destination, EMPTY_DATA, 'foo', 'confirmationHash', owners.get(0), owners.get(1)) + }) + + it('adds second confirmation to stored safe with one confirmation', async () => { + // GIVEN + const firstTxName = 'Buy butteries for project' + const firstNonce: number = Date.now() + const safeAddress = safe.get('address') + const creator = 'foo' + const confirmations: List = buildConfirmationsFrom(owners, creator, 'confirmationHash') + storeTransaction(firstTxName, firstNonce, destination, value, creator, confirmations, '', safeAddress, safe.get('threshold'), EMPTY_DATA) + + const secondTxName = 'Buy printers for project' + const secondNonce: number = firstNonce + 100 + const secondConfirmations: List = buildConfirmationsFrom(owners, creator, 'confirmationHash') + storeTransaction(secondTxName, secondNonce, destination, value, creator, secondConfirmations, '', safeAddress, safe.get('threshold'), EMPTY_DATA) + + // WHEN + const transactions: Map> = loadSafeTransactions() + + // THEN + testSizeOfSafesWith(transactions, 1) + + const safeTxs: List | typeof undefined = transactions.get(safeAddress) + if (!safeTxs) { throw new Error() } + testSizeOfTransactions(safeTxs, 2) + + testTransactionFrom(safeTxs, 0, firstTxName, firstNonce, value, 2, destination, EMPTY_DATA, 'foo', 'confirmationHash', owners.get(0), owners.get(1)) + testTransactionFrom(safeTxs, 1, secondTxName, secondNonce, value, 2, destination, EMPTY_DATA, 'foo', 'confirmationHash', owners.get(0), owners.get(1)) + }) + + it('adds second confirmation to stored safe having two safes with one confirmation each', async () => { + const txName = 'Buy batteris for Alplha project' + const nonce = 10 + const safeAddress = safe.address + const creator = 'foo' + const confirmations: List = buildConfirmationsFrom(owners, creator, 'confirmationHash') + storeTransaction(txName, nonce, destination, value, creator, confirmations, '', safeAddress, safe.get('threshold'), EMPTY_DATA) + + const secondSafe = SafeFactory.dailyLimitSafe(10, 2) + const txSecondName = 'Buy batteris for Beta project' + const txSecondNonce = 10 + const secondSafeAddress = secondSafe.address + const secondCreator = '0x03db1a8b26d08df23337e9276a36b474510f0023' + const secondConfirmations: List = buildConfirmationsFrom(secondSafe.get('owners'), secondCreator, 'confirmationHash') + storeTransaction( + txSecondName, txSecondNonce, destination, value, secondCreator, + secondConfirmations, '', secondSafeAddress, secondSafe.get('threshold'), EMPTY_DATA, + ) + + let transactions: Map> = loadSafeTransactions() + testSizeOfSafesWith(transactions, 2) + + const firstSafeTxs: List | typeof undefined = transactions.get(safeAddress) + if (!firstSafeTxs) { throw new Error() } + testSizeOfTransactions(firstSafeTxs, 1) + + const secondSafeTxs: List | typeof undefined = transactions.get(secondSafeAddress) + if (!secondSafeTxs) { throw new Error() } + testSizeOfTransactions(secondSafeTxs, 1) + + // WHEN + const txFirstName = 'Buy paper for Alplha project' + const txFirstNonce = 11 + const txConfirmations: List = buildConfirmationsFrom(owners, creator, 'secondConfirmationHash') + storeTransaction( + txFirstName, txFirstNonce, destination, value, creator, + txConfirmations, '', safe.get('address'), safe.get('threshold'), EMPTY_DATA, + ) + + transactions = loadSafeTransactions() + + // THEN + testSizeOfSafesWith(transactions, 2) + testSizeOfTransactions(transactions.get(safeAddress), 2) + testSizeOfTransactions(transactions.get(secondSafeAddress), 1) + + // Test 2 transactions of first safe + testTransactionFrom( + transactions.get(safe.address), 0, + txName, nonce, value, 2, destination, EMPTY_DATA, + 'foo', 'confirmationHash', owners.get(0), owners.get(1), + ) + testTransactionFrom( + transactions.get(safe.address), 1, + txFirstName, txFirstNonce, value, 2, destination, EMPTY_DATA, + 'foo', 'secondConfirmationHash', owners.get(0), owners.get(1), + ) + + // Test one transaction of second safe + testTransactionFrom( + transactions.get(secondSafe.address), 0, + txSecondName, txSecondNonce, value, 2, destination, EMPTY_DATA, + '0x03db1a8b26d08df23337e9276a36b474510f0023', 'confirmationHash', secondSafe.get('owners').get(0), secondSafe.get('owners').get(1), + ) + }) + + it('does not allow to store same transaction twice', async () => { + // GIVEN + const txName = 'Buy butteries for project' + const nonce: number = 10 + const creator = 'foo' + const confirmations: List = buildConfirmationsFrom(owners, creator, 'confirmationHash') + storeTransaction(txName, nonce, destination, value, creator, confirmations, '', safe.get('address'), safe.get('threshold'), EMPTY_DATA) + + // WHEN + const createTxFnc = () => storeTransaction(txName, nonce, destination, value, creator, confirmations, '', safe.get('address'), safe.get('threshold'), EMPTY_DATA) + expect(createTxFnc).toThrow(/Transaction with same nonce/) + }) + + it('checks the owner who creates the tx has confirmed it', async () => { + // GIVEN + const txName = 'Buy butteries for project' + const nonce: number = 10 + const creator = 'foo' + const confirmations: List = buildConfirmationsFrom(owners, creator, 'confirmationHash') + storeTransaction(txName, nonce, destination, value, creator, confirmations, '', safe.get('address'), safe.get('threshold'), EMPTY_DATA) + + // WHEN + const transactions: Map> = loadSafeTransactions() + + // THEN + testSizeOfSafesWith(transactions, 1) + }) + + it('checks the owner who creates the tx is an owner', async () => { + // GIVEN + const ownerName = 'invented' + const buildConfirmationsTxFnc = () => buildConfirmationsFrom(owners, ownerName, 'confirmationHash') + + expect(buildConfirmationsTxFnc).toThrow(/The creator of the tx is not an owner/) + }) + + it('checks if safe has one owner transaction has been executed', async () => { + const ownerName = 'foo' + const oneOwnerSafe = SafeFactory.oneOwnerSafe(ownerName) + const txName = 'Buy butteries for project' + const nonce: number = 10 + const tx = '' + const confirmations: List = buildExecutedConfirmationFrom(oneOwnerSafe.get('owners'), ownerName) + const createTxFnc = () => storeTransaction(txName, nonce, destination, value, ownerName, confirmations, tx, oneOwnerSafe.get('address'), oneOwnerSafe.get('threshold'), EMPTY_DATA) + + expect(createTxFnc).toThrow(/The tx should be mined before storing it in safes with one owner/) + }) + + it('checks if safe has one owner transaction the confirmation list is correctly build', async () => { + const ownerName = 'foo' + const oneOwnerSafe = SafeFactory.oneOwnerSafe(ownerName) + const txName = 'Buy butteries for project' + const nonce: number = 10 + const tx = 'validTxHash' + const confirmations: List = buildExecutedConfirmationFrom(oneOwnerSafe.get('owners'), ownerName) + storeTransaction(txName, nonce, destination, value, ownerName, confirmations, tx, oneOwnerSafe.get('address'), oneOwnerSafe.get('threshold'), EMPTY_DATA) + + // WHEN + const safeTransactions: Map> = loadSafeTransactions() + + // THEN + expect(safeTransactions.size).toBe(1) + + const transactions: List | typeof undefined = safeTransactions.get(oneOwnerSafe.address) + if (!transactions) throw new Error() + expect(transactions.count()).toBe(1) + + const batteriesTx: Transaction | typeof undefined = transactions.get(0) + if (!batteriesTx) throw new Error() + expect(batteriesTx.get('name')).toBe(txName) + + const txConfirmations = batteriesTx.confirmations + if (!txConfirmations) throw new Error() + expect(txConfirmations.count()).toBe(1) + + const firstConfirmation: Confirmation | typeof undefined = txConfirmations.get(0) + if (!firstConfirmation) throw new Error() + expect(firstConfirmation.get('hash')).toBe(EXECUTED_CONFIRMATION_HASH) + }) +}) + diff --git a/src/test/utils/historyServiceHelper.js b/src/test/utils/historyServiceHelper.js new file mode 100644 index 00000000..8ad22983 --- /dev/null +++ b/src/test/utils/historyServiceHelper.js @@ -0,0 +1,51 @@ +// @flow +import { List, Map } from 'immutable' +import { type Confirmation } from '~/routes/safe/store/model/confirmation' +import { type Transaction } from '~/routes/safe/store/model/transaction' +import { type Owner } from '~/routes/safe/store/model/owner' + +export const testSizeOfSafesWith = (transactions: Map>, size: number) => { + expect(transactions).not.toBe(undefined) + expect(transactions).not.toBe(null) + expect(transactions.size).toBe(size) +} + +export const testSizeOfTransactions = (safeTxs: List | typeof undefined, size: number) => { + if (!safeTxs) { throw new Error() } + expect(safeTxs.count()).toBe(size) + expect(safeTxs.get(0)).not.toBe(undefined) + expect(safeTxs.get(0)).not.toBe(null) +} + +export const testTransactionFrom = ( + safeTxs: List | typeof undefined, pos: number, name: string, + nonce: number, value: number, threshold: number, destination: string, + data: string, creator: string, txHash: string, + firstOwner: Owner | typeof undefined, secondOwner: Owner | typeof undefined, +) => { + if (!safeTxs) { throw new Error() } + const tx: Transaction | typeof undefined = safeTxs.get(pos) + + if (!tx) { throw new Error() } + expect(tx.get('name')).toBe(name) + expect(tx.get('value')).toBe(value) + expect(tx.get('threshold')).toBe(threshold) + expect(tx.get('destination')).toBe(destination) + expect(tx.get('confirmations').count()).toBe(2) + expect(tx.get('nonce')).toBe(nonce) + expect(tx.get('data')).toBe(data) + + const confirmations: List = tx.get('confirmations') + const firstConfirmation: Confirmation | typeof undefined = confirmations.get(0) + if (!firstConfirmation) { throw new Error() } + expect(firstConfirmation.get('owner')).not.toBe(undefined) + expect(firstConfirmation.get('owner')).toEqual(firstOwner) + expect(firstConfirmation.get('status')).toBe(true) + expect(firstConfirmation.get('hash')).toBe(txHash) + + const secondConfirmation: Confirmation | typeof undefined = confirmations.get(1) + if (!secondConfirmation) { throw new Error() } + expect(secondConfirmation.get('owner')).not.toBe(undefined) + expect(secondConfirmation.get('owner')).toEqual(secondOwner) + expect(secondConfirmation.get('status')).toBe(false) +}