@Test
public void shouldGetOpenOrders() throws IOException {
// given
final LimitOrder[] expectedOrders = expectedOrders();
BitMarketOrdersResponse response =
new BitMarketOrdersResponse(
true, createOpenOrdersData(), new BitMarketAPILimit(3, 100, 12345000L), 0, null);
BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
PowerMockito.when(
bitMarketAuthenticated.orders(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class)))
.thenReturn(response);
Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);
// when
OpenOrders orders = tradeService.getOpenOrders();
List<LimitOrder> openOrders = orders.getOpenOrders();
// then
assertThat(openOrders).hasSize(2);
for (int i = 0; i < openOrders.size(); i++) {
BitMarketAssert.assertEquals(openOrders.get(i), expectedOrders[i]);
assertThat(orders.toString()).contains(expectedOrders[i].toString());
}
}
@Test
public void shouldCancelOrder() throws IOException {
// given
BitMarketCancelResponse response =
new BitMarketCancelResponse(
true,
new BitMarketBalance(createAvailable(), createBlocked()),
new BitMarketAPILimit(3, 100, 12345000L),
0,
null);
BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
PowerMockito.when(
bitMarketAuthenticated.cancel(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq(12345L)))
.thenReturn(response);
Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);
// when
boolean cancelled = tradeService.cancelOrder("12345");
// then
assertThat(cancelled).isTrue();
}
@Test(expected = ExchangeException.class)
public void shouldFailOnUnsuccessfulLimitOrder() throws IOException {
// given
BitMarketTradeResponse response =
new BitMarketTradeResponse(
false, null, new BitMarketAPILimit(3, 100, 12345000L), 502, "Invalid message hash");
BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
PowerMockito.when(
bitMarketAuthenticated.trade(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq("BTCAUD"),
Mockito.eq("sell"),
Mockito.eq(BigDecimal.ONE),
Mockito.eq(BigDecimal.TEN)))
.thenReturn(response);
Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);
// when
tradeService.placeLimitOrder(
new LimitOrder(
Order.OrderType.ASK,
BigDecimal.ONE,
CurrencyPair.BTC_AUD,
"12345",
null,
BigDecimal.TEN));
// then
fail(
"BitMarketTradeService should throw ExchangeException when place limit order request was unsuccessful");
}
@Test
public void shouldGetCurrencyPairTradeHistory() throws IOException {
// given
final UserTrade[] expectedCpUserTrades = expectedCpUserTrades();
BitMarketHistoryTradesResponse historyTradesCPResponse =
parse("trade/example-history-trades-cp-data", BitMarketHistoryTradesResponse.class);
BitMarketHistoryOperationsResponse marketHistoryOperationsEurResponse =
parse(
"trade/example-history-operations-eur-data", BitMarketHistoryOperationsResponse.class);
BitMarketHistoryOperationsResponse marketHistoryOperationsBtcResponse =
parse(
"trade/example-history-operations-btc-data", BitMarketHistoryOperationsResponse.class);
BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
PowerMockito.when(
bitMarketAuthenticated.trades(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq("BTCEUR"),
Mockito.eq(1000),
Mockito.eq(0L)))
.thenReturn(historyTradesCPResponse);
PowerMockito.when(
bitMarketAuthenticated.history(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq(Currency.EUR.toString()),
Mockito.anyInt(),
Mockito.anyLong()))
.thenReturn(marketHistoryOperationsEurResponse);
PowerMockito.when(
bitMarketAuthenticated.history(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq(Currency.BTC.toString()),
Mockito.anyInt(),
Mockito.anyLong()))
.thenReturn(marketHistoryOperationsBtcResponse);
Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);
// when
UserTrades tradesCP =
tradeService.getTradeHistory(
new DefaultTradeHistoryParamCurrencyPair(CurrencyPair.BTC_EUR));
List<UserTrade> userTrades = tradesCP.getUserTrades();
// then
assertThat(userTrades).hasSize(2);
for (int i = 0; i < userTrades.size(); i++) {
BitMarketAssert.assertEquals(userTrades.get(i), expectedCpUserTrades[i]);
}
}
@Test
public void shouldCreateParams() {
// when
TradeHistoryParams params = tradeService.createTradeHistoryParams();
// then
assertThat(params instanceof BitMarketHistoryParams).isTrue();
assertThat(((BitMarketHistoryParams) params).getCount()).isEqualTo(1000);
assertThat(((BitMarketHistoryParams) params).getCurrencyPair()).isEqualTo(CurrencyPair.BTC_PLN);
assertThat(((BitMarketHistoryParams) params).getOffset()).isEqualTo(0L);
}
@Test
public void shouldGetTradeHistory() throws IOException {
// given
BitMarketHistoryTradesResponse historyTradesBMResponse =
parse("trade/example-history-trades-bm-data", BitMarketHistoryTradesResponse.class);
BitMarketHistoryOperationsResponse marketHistoryOperationsEurResponse =
parse(
"trade/example-history-operations-eur-data", BitMarketHistoryOperationsResponse.class);
BitMarketHistoryOperationsResponse marketHistoryOperationsBtcResponse =
parse(
"trade/example-history-operations-btc-data", BitMarketHistoryOperationsResponse.class);
BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
PowerMockito.when(
bitMarketAuthenticated.trades(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq("BTCEUR"),
Mockito.eq(3500),
Mockito.eq(500L)))
.thenReturn(historyTradesBMResponse);
PowerMockito.when(
bitMarketAuthenticated.history(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq(Currency.EUR.toString()),
Mockito.anyInt(),
Mockito.anyLong()))
.thenReturn(marketHistoryOperationsEurResponse);
PowerMockito.when(
bitMarketAuthenticated.history(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq(Currency.BTC.toString()),
Mockito.anyInt(),
Mockito.anyLong()))
.thenReturn(marketHistoryOperationsBtcResponse);
Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);
// when
UserTrades tradesBM =
tradeService.getTradeHistory(new BitMarketHistoryParams(CurrencyPair.BTC_EUR, 500L, 3500));
List<UserTrade> userTrades = tradesBM.getUserTrades();
// then
assertThat(userTrades).hasSize(1);
BitMarketAssert.assertEquals(userTrades.get(0), EXPECTED_BM_USER_TRADES);
}
@Test(expected = NotAvailableFromExchangeException.class)
public void shouldFailOnPlaceMarketOrder() throws IOException {
// given
MarketOrder marketOrder =
new MarketOrder(Order.OrderType.ASK, BigDecimal.TEN, CurrencyPair.BTC_USD, new Date());
// when
tradeService.placeMarketOrder(marketOrder);
// then
fail(
"BitMarketTradeService should throw NotAvailableFromExchangeException when call placeMarketOrder");
}
@Test(expected = ExchangeException.class)
public void shouldFailOnUnsuccessfulTradeHistory() throws IOException {
// given
BitMarketHistoryTradesResponse response =
new BitMarketHistoryTradesResponse(
false, null, new BitMarketAPILimit(3, 100, 12345000L), 502, "Invalid message hash");
BitMarketHistoryOperationsResponse marketHistoryOperationsPlnResponse =
parse("trade/example-history-operations-data", BitMarketHistoryOperationsResponse.class);
BitMarketHistoryOperationsResponse marketHistoryOperationsBtcResponse =
parse(
"trade/example-history-operations-btc-data", BitMarketHistoryOperationsResponse.class);
BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
PowerMockito.when(
bitMarketAuthenticated.trades(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq("BTCPLN"),
Mockito.eq(1000),
Mockito.eq(0L)))
.thenReturn(response);
PowerMockito.when(
bitMarketAuthenticated.history(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq(Currency.PLN.toString()),
Mockito.anyInt(),
Mockito.anyLong()))
.thenReturn(marketHistoryOperationsPlnResponse);
PowerMockito.when(
bitMarketAuthenticated.history(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq(Currency.BTC.toString()),
Mockito.anyInt(),
Mockito.anyLong()))
.thenReturn(marketHistoryOperationsBtcResponse);
Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);
// when
tradeService.getTradeHistory(new DefaultTradeHistoryParamPaging(150));
// then
fail(
"BitMarketTradeService should throw ExchangeException when open orders request was unsuccessful");
}
// should be changed after order type convertion fix
@Test
public void shouldPlaceBuyLimitOrder() throws IOException {
// given
BitMarketTradeResponse responseBuy =
new BitMarketTradeResponse(
true,
new BitMarketTrade(
12345,
new BitMarketOrder(
12345,
"BTCAUD",
BigDecimal.ONE,
new BigDecimal("1.1"),
BigDecimal.ZERO,
"BUY",
1234567890L),
new BitMarketBalance(createAvailable(), createBlocked())),
new BitMarketAPILimit(3, 100, 12345000L),
0,
null);
BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
PowerMockito.when(
bitMarketAuthenticated.trade(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq("BTCAUD"),
Mockito.eq("buy"),
Mockito.eq(BigDecimal.ONE),
Mockito.eq(BigDecimal.TEN)))
.thenReturn(responseBuy);
Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);
// when
String placedBuy =
tradeService.placeLimitOrder(
new LimitOrder(
Order.OrderType.BID,
BigDecimal.ONE,
CurrencyPair.BTC_AUD,
"12345",
null,
BigDecimal.TEN));
// then
assertThat(placedBuy).isEqualTo("12345");
}
@Test(expected = ExchangeException.class)
public void shouldFailOnUnsuccessfulOpenOrders() throws IOException {
// given
BitMarketOrdersResponse response =
new BitMarketOrdersResponse(
false, null, new BitMarketAPILimit(3, 100, 12345000L), 502, "Invalid message hash");
BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
PowerMockito.when(
bitMarketAuthenticated.orders(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class)))
.thenReturn(response);
Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);
// when
tradeService.getOpenOrders();
// then
fail(
"BitMarketTradeService should throw ExchangeException when open orders request was unsuccessful");
}
