838 lines
27 KiB
TypeScript
838 lines
27 KiB
TypeScript
import { delay } from 'redux-saga';
|
|
import { cloneableGenerator, createMockTask } from 'redux-saga/utils';
|
|
import { take, race, fork, call, cancel, apply, cancelled, put, select } from 'redux-saga/effects';
|
|
|
|
import { getAllRates, getOrderStatus, postOrder } from 'api/bity';
|
|
import shapeshift from 'api/shapeshift';
|
|
import configuredStore from 'features/store';
|
|
import { transactionTypes } from 'features/transaction';
|
|
import { walletTypes } from 'features/wallet';
|
|
import { notificationsActions } from 'features/notifications';
|
|
import * as types from './types';
|
|
import * as actions from './actions';
|
|
import * as reducer from './reducer';
|
|
import * as selectors from './selectors';
|
|
import * as sagas from './sagas';
|
|
|
|
configuredStore.getState();
|
|
|
|
//#region Lite Send
|
|
describe('swap: Sagas (Lite Send)', () => {
|
|
describe('Testing handle configure lite send', () => {
|
|
const generators = {
|
|
original: cloneableGenerator(sagas.handleConfigureLiteSend)()
|
|
};
|
|
const { original } = generators;
|
|
|
|
it('forks a configureLiteSend saga', () => {
|
|
const expectedYield = fork(sagas.configureLiteSendSaga);
|
|
expect(original.next().value).toEqual(expectedYield);
|
|
});
|
|
|
|
it('races between three conditions, either the transaction state is reset, the user navigated away from the page, or bitty/shapeshift polling as finished', () => {
|
|
const mockedTask = createMockTask();
|
|
const expectedYield = race({
|
|
transactionReset: take(transactionTypes.TransactionActions.RESET_REQUESTED),
|
|
userNavigatedAway: take(walletTypes.WalletActions.RESET),
|
|
bityPollingFinished: take(types.SwapActions.STOP_POLL_BITY_ORDER_STATUS),
|
|
shapeshiftPollingFinished: take(types.SwapActions.STOP_POLL_SHAPESHIFT_ORDER_STATUS)
|
|
});
|
|
|
|
expect(original.next(mockedTask).value).toEqual(expectedYield);
|
|
});
|
|
});
|
|
});
|
|
//#endregion Lite Send
|
|
|
|
//#region Orders
|
|
describe('swap: Sagas (Orders)', () => {
|
|
const ONE_SECOND = 1000;
|
|
const TEN_SECONDS = ONE_SECOND * 10;
|
|
const ELEVEN_SECONDS = ONE_SECOND * 11;
|
|
|
|
const orderInput: types.BityOrderInput = {
|
|
amount: 'amount',
|
|
currency: 'currency',
|
|
reference: 'reference',
|
|
status: 'status'
|
|
};
|
|
const orderOutput: types.BityOrderOutput = {
|
|
amount: 'amount',
|
|
currency: 'currency',
|
|
reference: 'reference',
|
|
status: 'status'
|
|
};
|
|
|
|
describe('pollBityOrderStatus*', () => {
|
|
const data = {} as any;
|
|
data.gen = cloneableGenerator(sagas.pollBityOrderStatus)();
|
|
const fakeSwap: types.SwapState = {
|
|
...reducer.INITIAL_STATE,
|
|
orderId: '1'
|
|
};
|
|
const orderResponse: types.BityOrderResponse = {
|
|
input: orderInput,
|
|
output: orderOutput,
|
|
status: 'status'
|
|
};
|
|
const cancelledSwap = 'CANC';
|
|
const successStatus = {
|
|
error: null,
|
|
data: orderResponse
|
|
};
|
|
const errorStatus = {
|
|
error: true,
|
|
msg: 'error message'
|
|
};
|
|
let random: () => number;
|
|
|
|
beforeAll(() => {
|
|
random = Math.random;
|
|
Math.random = () => 0.001;
|
|
});
|
|
|
|
afterAll(() => {
|
|
Math.random = random;
|
|
});
|
|
|
|
it('should select selectors.getSwap', () => {
|
|
expect(data.gen.next().value).toEqual(select(selectors.getSwap));
|
|
});
|
|
|
|
it('should put bityOrderStatusRequestedSwap', () => {
|
|
expect(data.gen.next(fakeSwap).value).toEqual(put(actions.bityOrderStatusRequested()));
|
|
});
|
|
|
|
it('should call getOrderStatus with swap.orderId', () => {
|
|
expect(data.gen.next().value).toEqual(call(getOrderStatus, fakeSwap.orderId));
|
|
});
|
|
|
|
it('should put showNotfication on error', () => {
|
|
data.clone = data.gen.clone();
|
|
expect(data.clone.next(errorStatus).value).toEqual(
|
|
put(
|
|
notificationsActions.showNotification(
|
|
'danger',
|
|
`Bity Error: ${errorStatus.msg}`,
|
|
TEN_SECONDS
|
|
)
|
|
)
|
|
);
|
|
});
|
|
|
|
it('should put orderStatusSucceededSwap', () => {
|
|
expect(data.gen.next(successStatus).value).toEqual(
|
|
put(actions.bityOrderStatusSucceededSwap(successStatus.data))
|
|
);
|
|
});
|
|
|
|
it('should call delay for 5 seconds', () => {
|
|
expect(data.gen.next().value).toEqual(call(delay, ONE_SECOND * 5));
|
|
});
|
|
|
|
it('should select selectors.getSwap', () => {
|
|
expect(data.gen.next().value).toEqual(select(selectors.getSwap));
|
|
});
|
|
|
|
it('should break loop if swap is cancelled', () => {
|
|
data.clone2 = data.gen.clone();
|
|
expect(data.clone2.next(cancelledSwap).value).toEqual(cancelled());
|
|
expect(data.clone2.next().done).toEqual(true);
|
|
});
|
|
|
|
it('should restart loop', () => {
|
|
expect(data.gen.next(fakeSwap).value).toEqual(put(actions.bityOrderStatusRequested()));
|
|
});
|
|
});
|
|
|
|
describe('pollShapeshiftOrderStatus*', () => {
|
|
const data = {} as any;
|
|
data.gen = cloneableGenerator(sagas.pollShapeshiftOrderStatus)();
|
|
const fakeSwap: types.SwapState = {
|
|
...reducer.INITIAL_STATE,
|
|
orderId: '1'
|
|
};
|
|
const cancelledSwap = 'CANC';
|
|
const successStatus = {
|
|
status: 'complete',
|
|
transaction: '0x'
|
|
};
|
|
const errorStatus = {
|
|
error: 'Shapeshift error',
|
|
status: 'failed'
|
|
};
|
|
let random: () => number;
|
|
|
|
beforeAll(() => {
|
|
random = Math.random;
|
|
Math.random = () => 0.001;
|
|
});
|
|
|
|
afterAll(() => {
|
|
Math.random = random;
|
|
});
|
|
|
|
it('should select selectors.getSwap', () => {
|
|
expect(data.gen.next().value).toEqual(select(selectors.getSwap));
|
|
});
|
|
|
|
it('should put shapeshiftOrderStatusRequestedSwap', () => {
|
|
expect(data.gen.next(fakeSwap).value).toEqual(put(actions.shapeshiftOrderStatusRequested()));
|
|
});
|
|
|
|
it('should apply shapeshift.checkStatus with swap.paymentAddress', () => {
|
|
expect(data.gen.next().value).toEqual(
|
|
apply(shapeshift, shapeshift.checkStatus, [fakeSwap.paymentAddress])
|
|
);
|
|
});
|
|
|
|
it('should put showNotfication on error', () => {
|
|
data.clone = data.gen.clone();
|
|
expect(data.clone.next(errorStatus).value).toEqual(
|
|
put(
|
|
notificationsActions.showNotification(
|
|
'danger',
|
|
`Shapeshift Error: ${errorStatus.error}`,
|
|
Infinity
|
|
)
|
|
)
|
|
);
|
|
});
|
|
|
|
it('should put shapeshiftOrderStatusSucceededSwap', () => {
|
|
expect(data.gen.next(successStatus).value).toEqual(
|
|
put(actions.shapeshiftOrderStatusSucceededSwap(successStatus))
|
|
);
|
|
});
|
|
|
|
it('should call delay for 5 seconds', () => {
|
|
expect(data.gen.next().value).toEqual(call(delay, ONE_SECOND * 5));
|
|
});
|
|
|
|
it('should select selectors.getSwap', () => {
|
|
expect(data.gen.next().value).toEqual(select(selectors.getSwap));
|
|
});
|
|
|
|
it('should break loop if swap is cancelled', () => {
|
|
data.clone2 = data.gen.clone();
|
|
expect(data.clone2.next(cancelledSwap).value).toEqual(cancelled());
|
|
expect(data.clone2.next().done).toEqual(true);
|
|
});
|
|
|
|
it('should restart loop', () => {
|
|
expect(data.gen.next(fakeSwap).value).toEqual(put(actions.shapeshiftOrderStatusRequested()));
|
|
});
|
|
});
|
|
|
|
describe('pollBityOrderStatusSaga*', () => {
|
|
const data = {} as any;
|
|
data.gen = cloneableGenerator(sagas.pollBityOrderStatusSaga)();
|
|
const mockedTask = createMockTask();
|
|
|
|
it('should take SWAP_START_POLL_BITY_ORDER_STATUS', () => {
|
|
expect(data.gen.next().value).toEqual(take(types.SwapActions.START_POLL_BITY_ORDER_STATUS));
|
|
});
|
|
|
|
it('should be done if order status is false', () => {
|
|
data.clone = data.gen.clone();
|
|
expect(data.clone.next(false).done).toEqual(true);
|
|
});
|
|
|
|
it('should fork pollBityOrderStatus', () => {
|
|
expect(data.gen.next(true).value).toEqual(fork(sagas.pollBityOrderStatus));
|
|
});
|
|
|
|
it('should take SWAP_STOP_POLL_BITY_ORDER_STATUS', () => {
|
|
expect(data.gen.next(mockedTask).value).toEqual(
|
|
take(types.SwapActions.STOP_POLL_BITY_ORDER_STATUS)
|
|
);
|
|
});
|
|
|
|
it('should cancel pollBityOrderStatusTask', () => {
|
|
expect(data.gen.next().value).toEqual(cancel(mockedTask));
|
|
});
|
|
});
|
|
|
|
describe('pollShapeshiftOrderStatusSaga*', () => {
|
|
const data = {} as any;
|
|
data.gen = cloneableGenerator(sagas.pollShapeshiftOrderStatusSaga)();
|
|
const mockedTask = createMockTask();
|
|
|
|
it('should take SWAP_START_POLL_SHAPESHIFT_ORDER_STATUS', () => {
|
|
expect(data.gen.next().value).toEqual(
|
|
take(types.SwapActions.START_POLL_SHAPESHIFT_ORDER_STATUS)
|
|
);
|
|
});
|
|
|
|
it('should be done if order status is false', () => {
|
|
data.clone = data.gen.clone();
|
|
expect(data.clone.next(false).done).toEqual(true);
|
|
});
|
|
|
|
it('should fork pollShapeshiftOrderStatus', () => {
|
|
expect(data.gen.next(true).value).toEqual(fork(sagas.pollShapeshiftOrderStatus));
|
|
});
|
|
|
|
it('should take SWAP_STOP_POLL_SHAPESHIFT_ORDER_STATUS', () => {
|
|
expect(data.gen.next(mockedTask).value).toEqual(
|
|
take(types.SwapActions.STOP_POLL_SHAPESHIFT_ORDER_STATUS)
|
|
);
|
|
});
|
|
|
|
it('should cancel pollShapeshiftOrderStatusTask', () => {
|
|
expect(data.gen.next().value).toEqual(cancel(mockedTask));
|
|
});
|
|
});
|
|
|
|
describe('postBityOrderCreate*', () => {
|
|
const amount = 100;
|
|
const destinationAddress = '0x0';
|
|
const pair = 'BTC_ETH';
|
|
const action = actions.bityOrderCreateRequestedSwap(amount, destinationAddress, pair);
|
|
const orderResp: types.BityOrderPostResponse = {
|
|
payment_address: '0x0',
|
|
status: 'status',
|
|
input: orderInput,
|
|
output: orderOutput,
|
|
timestamp_created: 'timestamp_created',
|
|
validFor: 10,
|
|
id: '0'
|
|
};
|
|
const successOrder = { error: false, data: orderResp };
|
|
const errorOrder = { error: true, msg: 'error msg' };
|
|
const connectionErrMsg =
|
|
'Connection Error. Please check the developer console for more details and/or contact support';
|
|
|
|
const data = {} as any;
|
|
data.gen = cloneableGenerator(sagas.postBityOrderCreate)(action);
|
|
|
|
let random: () => number;
|
|
beforeAll(() => {
|
|
random = Math.random;
|
|
Math.random = () => 0.001;
|
|
});
|
|
|
|
afterAll(() => {
|
|
Math.random = random;
|
|
});
|
|
|
|
it('should put stopLoadBityRatesSwap', () => {
|
|
expect(data.gen.next().value).toEqual(put(actions.stopLoadBityRatesSwap()));
|
|
});
|
|
|
|
it('should call postOrder', () => {
|
|
data.clone1 = data.gen.clone();
|
|
expect(data.gen.next().value).toEqual(
|
|
call(postOrder, amount, destinationAddress, action.payload.mode, pair)
|
|
);
|
|
});
|
|
|
|
it('should put bityOrderCreateSucceededSwap', () => {
|
|
data.clone2 = data.gen.clone();
|
|
expect(data.gen.next(successOrder).value).toEqual(
|
|
put(actions.bityOrderCreateSucceededSwap(successOrder.data))
|
|
);
|
|
});
|
|
|
|
it('should put changeStepSwap', () => {
|
|
expect(data.gen.next().value).toEqual(put(actions.changeStepSwap(3)));
|
|
});
|
|
|
|
it('should put startOrderTimerSwap', () => {
|
|
expect(data.gen.next().value).toEqual(put(actions.startOrderTimerSwap()));
|
|
});
|
|
|
|
it('should put startPollBityOrderStatus', () => {
|
|
expect(data.gen.next().value).toEqual(put(actions.startPollBityOrderStatus()));
|
|
});
|
|
|
|
// failure modes
|
|
it('should handle a connection exeception', () => {
|
|
expect(data.clone1.throw().value).toEqual(
|
|
put(notificationsActions.showNotification('danger', connectionErrMsg, TEN_SECONDS))
|
|
);
|
|
expect(data.clone1.next().value).toEqual(put(actions.bityOrderCreateFailedSwap()));
|
|
expect(data.clone1.next().done).toEqual(true);
|
|
});
|
|
|
|
it('should handle an errored order', () => {
|
|
expect(data.clone2.next(errorOrder).value).toEqual(
|
|
put(
|
|
notificationsActions.showNotification(
|
|
'danger',
|
|
`Bity Error: ${errorOrder.msg}`,
|
|
TEN_SECONDS
|
|
)
|
|
)
|
|
);
|
|
expect(data.clone2.next().value).toEqual(put(actions.bityOrderCreateFailedSwap()));
|
|
});
|
|
});
|
|
|
|
describe('postShapeshiftOrderCreate*', () => {
|
|
const amount = 100;
|
|
const withdrawalAddress = '0x0';
|
|
const originKind = 'BAT';
|
|
const destKind = 'ETH';
|
|
const action = actions.shapeshiftOrderCreateRequestedSwap(
|
|
withdrawalAddress,
|
|
originKind,
|
|
destKind,
|
|
amount
|
|
);
|
|
const orderResp: types.ShapeshiftOrderResponse = {
|
|
deposit: '0x0',
|
|
depositAmount: '0',
|
|
expiration: 100,
|
|
maxLimit: 1,
|
|
minerFee: '0.1',
|
|
orderId: '1',
|
|
pair: 'BTC_ETH',
|
|
quotedRate: '1',
|
|
withdrawal: '0x0',
|
|
withdrawalAmount: '2'
|
|
};
|
|
const successOrder = { success: orderResp };
|
|
const errorOrder = { error: 'message' };
|
|
const connectionErrMsg =
|
|
'Connection Error. Please check the developer console for more details and/or contact support';
|
|
|
|
const data = {} as any;
|
|
data.gen = cloneableGenerator(sagas.postShapeshiftOrderCreate)(action);
|
|
|
|
let random: () => number;
|
|
beforeAll(() => {
|
|
random = Math.random;
|
|
Math.random = () => 0.001;
|
|
});
|
|
|
|
afterAll(() => {
|
|
Math.random = random;
|
|
});
|
|
|
|
it('should put stopLoadShapeshiftRatesSwap', () => {
|
|
expect(data.gen.next().value).toEqual(put(actions.stopLoadShapeshiftRatesSwap()));
|
|
});
|
|
|
|
it('should call shapeshift.sendAmount', () => {
|
|
data.clone1 = data.gen.clone();
|
|
expect(data.gen.next().value).toEqual(
|
|
apply(shapeshift, shapeshift.sendAmount, [
|
|
action.payload.withdrawal,
|
|
action.payload.originKind,
|
|
action.payload.destinationKind,
|
|
action.payload.destinationAmount
|
|
])
|
|
);
|
|
});
|
|
|
|
it('should put shapeshiftOrderCreateSucceededSwap', () => {
|
|
data.clone2 = data.gen.clone();
|
|
expect(data.gen.next(successOrder).value).toEqual(
|
|
put(actions.shapeshiftOrderCreateSucceededSwap(successOrder.success))
|
|
);
|
|
});
|
|
|
|
it('should put changeStepSwap', () => {
|
|
expect(data.gen.next().value).toEqual(put(actions.changeStepSwap(3)));
|
|
});
|
|
|
|
it('should put startOrderTimerSwap', () => {
|
|
expect(data.gen.next().value).toEqual(put(actions.startOrderTimerSwap()));
|
|
});
|
|
|
|
it('should put startPollShapeshiftOrderStatus', () => {
|
|
expect(data.gen.next().value).toEqual(put(actions.startPollShapeshiftOrderStatus()));
|
|
});
|
|
|
|
// failure modes
|
|
it('should handle a connection exeception', () => {
|
|
expect(data.clone1.throw().value).toEqual(
|
|
put(notificationsActions.showNotification('danger', connectionErrMsg, TEN_SECONDS))
|
|
);
|
|
expect(data.clone1.next().value).toEqual(put(actions.shapeshiftOrderCreateFailedSwap()));
|
|
expect(data.clone1.next().done).toEqual(true);
|
|
});
|
|
|
|
it('should handle an errored order', () => {
|
|
expect(data.clone2.next(errorOrder).value).toEqual(
|
|
put(
|
|
notificationsActions.showNotification(
|
|
'danger',
|
|
`Shapeshift Error: ${errorOrder.error}`,
|
|
TEN_SECONDS
|
|
)
|
|
)
|
|
);
|
|
expect(data.clone2.next().value).toEqual(put(actions.shapeshiftOrderCreateFailedSwap()));
|
|
});
|
|
});
|
|
|
|
describe('bityOrderTimeRemaining*', () => {
|
|
const orderTime = new Date().toISOString();
|
|
const orderTimeExpired = new Date().getTime() - ELEVEN_SECONDS;
|
|
const swapValidFor = 10; //seconds
|
|
const swapOrder = {
|
|
...reducer.INITIAL_STATE,
|
|
orderTimestampCreatedISOString: orderTime,
|
|
validFor: swapValidFor
|
|
};
|
|
const swapOrderExpired = {
|
|
...reducer.INITIAL_STATE,
|
|
orderTimestampCreatedISOString: new Date(orderTimeExpired).toISOString(),
|
|
validFor: swapValidFor
|
|
};
|
|
let random: () => number;
|
|
|
|
const data = {} as any;
|
|
data.gen = cloneableGenerator(sagas.bityOrderTimeRemaining)();
|
|
|
|
beforeAll(() => {
|
|
random = Math.random;
|
|
Math.random = () => 0.001;
|
|
});
|
|
|
|
afterAll(() => {
|
|
Math.random = random;
|
|
});
|
|
|
|
it('should call delay of one second', () => {
|
|
expect(data.gen.next(true).value).toEqual(call(delay, ONE_SECOND));
|
|
});
|
|
|
|
it('should select selectors.getSwap', () => {
|
|
expect(data.gen.next().value).toEqual(select(selectors.getSwap));
|
|
});
|
|
|
|
it('should handle if isValidUntil.isAfter(now)', () => {
|
|
data.clone2 = data.gen.clone();
|
|
const result = data.clone2.next(swapOrder).value;
|
|
expect(result).toHaveProperty('PUT');
|
|
expect(result.PUT.action.type).toEqual('SWAP_ORDER_TIME');
|
|
expect(result.PUT.action.payload).toBeGreaterThan(0);
|
|
});
|
|
|
|
it('should handle an OPEN order state', () => {
|
|
const openOrder = { ...swapOrderExpired, bityOrderStatus: 'OPEN' };
|
|
data.OPEN = data.gen.clone();
|
|
expect(data.OPEN.next(openOrder).value).toEqual(put(actions.orderTimeSwap(0)));
|
|
expect(data.OPEN.next().value).toEqual(put(actions.stopPollBityOrderStatus()));
|
|
expect(data.OPEN.next().value).toEqual(put({ type: types.SwapActions.STOP_LOAD_BITY_RATES }));
|
|
expect(data.OPEN.next().value).toEqual(
|
|
put(notificationsActions.showNotification('danger', sagas.ORDER_TIMEOUT_MESSAGE, Infinity))
|
|
);
|
|
});
|
|
|
|
it('should handle a CANC order state', () => {
|
|
const cancOrder = { ...swapOrderExpired, bityOrderStatus: 'CANC' };
|
|
data.CANC = data.gen.clone();
|
|
expect(data.CANC.next(cancOrder).value).toEqual(put(actions.stopPollBityOrderStatus()));
|
|
expect(data.CANC.next().value).toEqual(put({ type: types.SwapActions.STOP_LOAD_BITY_RATES }));
|
|
expect(data.CANC.next().value).toEqual(
|
|
put(notificationsActions.showNotification('danger', sagas.ORDER_TIMEOUT_MESSAGE, Infinity))
|
|
);
|
|
});
|
|
|
|
it('should handle a RCVE order state', () => {
|
|
const rcveOrder = { ...swapOrderExpired, bityOrderStatus: 'RCVE' };
|
|
data.RCVE = data.gen.clone();
|
|
expect(data.RCVE.next(rcveOrder).value).toEqual(
|
|
put(notificationsActions.showNotification('warning', sagas.ORDER_TIMEOUT_MESSAGE, Infinity))
|
|
);
|
|
});
|
|
|
|
it('should handle a FILL order state', () => {
|
|
const fillOrder = { ...swapOrderExpired, bityOrderStatus: 'FILL' };
|
|
data.FILL = data.gen.clone();
|
|
expect(data.FILL.next(fillOrder).value).toEqual(put(actions.stopPollBityOrderStatus()));
|
|
expect(data.FILL.next().value).toEqual(put({ type: types.SwapActions.STOP_LOAD_BITY_RATES }));
|
|
});
|
|
});
|
|
|
|
describe('shapeshiftOrderTimeRemaining*', () => {
|
|
const orderTime = new Date().toISOString();
|
|
const orderTimeExpired = new Date().getTime() - ELEVEN_SECONDS;
|
|
const swapValidFor = 10; //seconds
|
|
const swapOrder = {
|
|
...reducer.INITIAL_STATE,
|
|
orderTimestampCreatedISOString: orderTime,
|
|
validFor: swapValidFor
|
|
};
|
|
const swapOrderExpired = {
|
|
...reducer.INITIAL_STATE,
|
|
orderTimestampCreatedISOString: new Date(orderTimeExpired).toISOString(),
|
|
validFor: swapValidFor
|
|
};
|
|
let random: () => number;
|
|
|
|
const data = {} as any;
|
|
data.gen = cloneableGenerator(sagas.shapeshiftOrderTimeRemaining)();
|
|
|
|
beforeAll(() => {
|
|
random = Math.random;
|
|
Math.random = () => 0.001;
|
|
});
|
|
|
|
afterAll(() => {
|
|
Math.random = random;
|
|
});
|
|
|
|
it('should call delay of one second', () => {
|
|
expect(data.gen.next(true).value).toEqual(call(delay, ONE_SECOND));
|
|
});
|
|
|
|
it('should select selectors.getSwap', () => {
|
|
expect(data.gen.next().value).toEqual(select(selectors.getSwap));
|
|
});
|
|
|
|
it('should handle if isValidUntil.isAfter(now)', () => {
|
|
data.clone2 = data.gen.clone();
|
|
const result = data.clone2.next(swapOrder).value;
|
|
expect(result).toHaveProperty('PUT');
|
|
expect(result.PUT.action.type).toEqual('SWAP_ORDER_TIME');
|
|
expect(result.PUT.action.payload).toBeGreaterThan(0);
|
|
});
|
|
|
|
it('should handle an no_deposits order state', () => {
|
|
const openOrder = { ...swapOrderExpired, shapeshiftOrderStatus: 'no_deposits' };
|
|
data.OPEN = data.gen.clone();
|
|
expect(data.OPEN.next(openOrder).value).toEqual(put(actions.orderTimeSwap(0)));
|
|
expect(data.OPEN.next().value).toEqual(put(actions.stopPollShapeshiftOrderStatus()));
|
|
expect(data.OPEN.next().value).toEqual(
|
|
put({ type: types.SwapActions.STOP_LOAD_SHAPESHIFT_RATES })
|
|
);
|
|
expect(data.OPEN.next().value).toEqual(
|
|
put(notificationsActions.showNotification('danger', sagas.ORDER_TIMEOUT_MESSAGE, Infinity))
|
|
);
|
|
});
|
|
|
|
it('should handle a failed order state', () => {
|
|
const cancOrder = { ...swapOrderExpired, shapeshiftOrderStatus: 'failed' };
|
|
data.CANC = data.gen.clone();
|
|
expect(data.CANC.next(cancOrder).value).toEqual(put(actions.stopPollShapeshiftOrderStatus()));
|
|
expect(data.CANC.next().value).toEqual(
|
|
put({ type: types.SwapActions.STOP_LOAD_SHAPESHIFT_RATES })
|
|
);
|
|
expect(data.CANC.next().value).toEqual(
|
|
put(notificationsActions.showNotification('danger', sagas.ORDER_TIMEOUT_MESSAGE, Infinity))
|
|
);
|
|
});
|
|
|
|
it('should handle a received order state', () => {
|
|
const rcveOrder = { ...swapOrderExpired, shapeshiftOrderStatus: 'received' };
|
|
data.RCVE = data.gen.clone();
|
|
expect(data.RCVE.next(rcveOrder).value).toEqual(
|
|
put(
|
|
notificationsActions.showNotification('warning', sagas.ORDER_RECEIVED_MESSAGE, Infinity)
|
|
)
|
|
);
|
|
});
|
|
|
|
it('should handle a complete order state', () => {
|
|
const fillOrder = { ...swapOrderExpired, shapeshiftOrderStatus: 'complete' };
|
|
data.COMPLETE = data.gen.clone();
|
|
expect(data.COMPLETE.next(fillOrder).value).toEqual(
|
|
put(actions.stopPollShapeshiftOrderStatus())
|
|
);
|
|
expect(data.COMPLETE.next().value).toEqual(
|
|
put({ type: types.SwapActions.STOP_LOAD_SHAPESHIFT_RATES })
|
|
);
|
|
expect(data.COMPLETE.next().value).toEqual(put(actions.stopOrderTimerSwap()));
|
|
});
|
|
});
|
|
});
|
|
//#endregion Orders
|
|
|
|
//#region Rates
|
|
describe('swap: Sagas (Rates)', () => {
|
|
describe('loadBityRates*', () => {
|
|
const gen1 = sagas.loadBityRates();
|
|
const apiResponse = {
|
|
BTCETH: {
|
|
id: 'BTCETH',
|
|
options: [{ id: 'BTC' }, { id: 'ETH' }],
|
|
rate: 23.27855114
|
|
},
|
|
ETHBTC: {
|
|
id: 'ETHBTC',
|
|
options: [{ id: 'ETH' }, { id: 'BTC' }],
|
|
rate: 0.042958
|
|
}
|
|
};
|
|
const err = { message: 'error' };
|
|
let random: () => number;
|
|
|
|
beforeAll(() => {
|
|
random = Math.random;
|
|
Math.random = () => 0.001;
|
|
});
|
|
|
|
afterAll(() => {
|
|
Math.random = random;
|
|
});
|
|
|
|
it('should call getAllRates', () => {
|
|
expect(gen1.next().value).toEqual(call(getAllRates));
|
|
});
|
|
|
|
it('should put loadBityRatesSucceededSwap', () => {
|
|
expect(gen1.next(apiResponse).value).toEqual(
|
|
put(actions.loadBityRatesSucceededSwap(apiResponse))
|
|
);
|
|
});
|
|
|
|
it(`should delay for ${sagas.POLLING_CYCLE}ms`, () => {
|
|
expect(gen1.next().value).toEqual(call(delay, sagas.POLLING_CYCLE));
|
|
});
|
|
|
|
it('should handle an exception', () => {
|
|
const errGen = sagas.loadBityRates();
|
|
errGen.next();
|
|
expect((errGen as any).throw(err).value).toEqual(
|
|
select(selectors.getHasNotifiedRatesFailure)
|
|
);
|
|
expect(errGen.next(false).value).toEqual(
|
|
put(notificationsActions.showNotification('danger', err.message))
|
|
);
|
|
expect(errGen.next().value).toEqual(put(actions.loadBityRatesFailedSwap()));
|
|
expect(errGen.next().value).toEqual(call(delay, sagas.POLLING_CYCLE));
|
|
});
|
|
|
|
it('should not notify on subsequent exceptions', () => {
|
|
const noNotifyErrGen = sagas.loadBityRates();
|
|
noNotifyErrGen.next();
|
|
expect((noNotifyErrGen as any).throw(err).value).toEqual(
|
|
select(selectors.getHasNotifiedRatesFailure)
|
|
);
|
|
expect(noNotifyErrGen.next(true).value).toEqual(put(actions.loadBityRatesFailedSwap()));
|
|
expect(noNotifyErrGen.next().value).toEqual(call(delay, sagas.POLLING_CYCLE));
|
|
});
|
|
});
|
|
|
|
describe('loadShapeshiftRates*', () => {
|
|
const gen1 = sagas.loadShapeshiftRates();
|
|
|
|
const apiResponse = {
|
|
['1SSTANT']: {
|
|
id: '1STANT',
|
|
options: [
|
|
{
|
|
id: '1ST',
|
|
status: 'available',
|
|
image: 'https://shapeshift.io/images/coins/firstblood.png',
|
|
name: 'FirstBlood'
|
|
},
|
|
{
|
|
id: 'ANT',
|
|
status: 'available',
|
|
image: 'https://shapeshift.io/images/coins/aragon.png',
|
|
name: 'Aragon'
|
|
}
|
|
],
|
|
rate: '0.24707537',
|
|
limit: 5908.29166225,
|
|
min: 7.86382979
|
|
}
|
|
};
|
|
const err = 'error';
|
|
let random: () => number;
|
|
|
|
beforeAll(() => {
|
|
random = Math.random;
|
|
Math.random = () => 0.001;
|
|
});
|
|
|
|
afterAll(() => {
|
|
Math.random = random;
|
|
});
|
|
|
|
it('should race shapeshift.getAllRates', () => {
|
|
expect(gen1.next().value).toEqual(
|
|
race({
|
|
tokens: call(shapeshift.getAllRates),
|
|
timeout: call(delay, sagas.SHAPESHIFT_TIMEOUT)
|
|
})
|
|
);
|
|
});
|
|
|
|
it('should put loadShapeshiftRatesSucceededSwap', () => {
|
|
expect(gen1.next({ tokens: apiResponse }).value).toEqual(
|
|
put(actions.loadShapeshiftRatesSucceededSwap(apiResponse as any))
|
|
);
|
|
});
|
|
|
|
it(`should delay for ${sagas.POLLING_CYCLE}ms`, () => {
|
|
expect(gen1.next().value).toEqual(call(delay, sagas.POLLING_CYCLE));
|
|
});
|
|
|
|
it('should handle an exception', () => {
|
|
const errGen = sagas.loadShapeshiftRates();
|
|
errGen.next();
|
|
expect((errGen as any).throw(err).value).toEqual(
|
|
select(selectors.getHasNotifiedRatesFailure)
|
|
);
|
|
expect(errGen.next(false).value).toEqual(
|
|
put(
|
|
notificationsActions.showNotification(
|
|
'danger',
|
|
'Failed to load swap rates from ShapeShift, please try again later'
|
|
)
|
|
)
|
|
);
|
|
expect(errGen.next().value).toEqual(put(actions.loadShapeshiftRatesFailedSwap()));
|
|
});
|
|
|
|
it('should not notify on subsequent exceptions', () => {
|
|
const noNotifyErrGen = sagas.loadShapeshiftRates();
|
|
noNotifyErrGen.next();
|
|
expect((noNotifyErrGen as any).throw(err).value).toEqual(
|
|
select(selectors.getHasNotifiedRatesFailure)
|
|
);
|
|
expect(noNotifyErrGen.next(true).value).toEqual(put(actions.loadShapeshiftRatesFailedSwap()));
|
|
});
|
|
});
|
|
|
|
describe('handleBityRates*', () => {
|
|
const gen = sagas.handleBityRates();
|
|
const mockTask = createMockTask();
|
|
|
|
it('should fork loadBityRates', () => {
|
|
expect(gen.next().value).toEqual(fork(sagas.loadBityRates));
|
|
});
|
|
|
|
it('should take SWAP_STOP_LOAD_BITY_RATES', () => {
|
|
expect(gen.next(mockTask).value).toEqual(take(types.SwapActions.STOP_LOAD_BITY_RATES));
|
|
});
|
|
|
|
it('should cancel loadBityRatesTask', () => {
|
|
expect(gen.next().value).toEqual(cancel(mockTask));
|
|
});
|
|
|
|
it('should be done', () => {
|
|
expect(gen.next().done).toEqual(true);
|
|
});
|
|
});
|
|
|
|
describe('handleShapeshiftRates*', () => {
|
|
const gen = sagas.handleShapeshiftRates();
|
|
const mockTask = createMockTask();
|
|
|
|
it('should fork loadShapeshiftRates', () => {
|
|
expect(gen.next().value).toEqual(fork(sagas.loadShapeshiftRates));
|
|
});
|
|
|
|
it('should take SWAP_STOP_LOAD_BITY_RATES', () => {
|
|
expect(gen.next(mockTask).value).toEqual(take(types.SwapActions.STOP_LOAD_SHAPESHIFT_RATES));
|
|
});
|
|
|
|
it('should cancel loadShapeShiftRatesTask', () => {
|
|
expect(gen.next().value).toEqual(cancel(mockTask));
|
|
});
|
|
|
|
it('should be done', () => {
|
|
expect(gen.next().done).toEqual(true);
|
|
});
|
|
});
|
|
});
|
|
//#endregion Rates
|