/xchange-bleutrade/src/test/java/org/knowm/xchange/bleutrade/service/BleutradeMarketDataServiceIntegration.java

package org.knowm.xchange.bleutrade.service;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import java.io.IOException;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.knowm.xchange.ExchangeFactory;
import org.knowm.xchange.bleutrade.BleutradeAssert;
import org.knowm.xchange.bleutrade.BleutradeAuthenticated;
import org.knowm.xchange.bleutrade.BleutradeExchange;
import org.knowm.xchange.bleutrade.dto.marketdata.BleutradeCurrenciesReturn;
import org.knowm.xchange.bleutrade.dto.marketdata.BleutradeCurrency;
import org.knowm.xchange.bleutrade.dto.marketdata.BleutradeMarket;
import org.knowm.xchange.bleutrade.dto.marketdata.BleutradeMarketHistoryReturn;
import org.knowm.xchange.bleutrade.dto.marketdata.BleutradeMarketsReturn;
import org.knowm.xchange.bleutrade.dto.marketdata.BleutradeOrderBookReturn;
import org.knowm.xchange.bleutrade.dto.marketdata.BleutradeTicker;
import org.knowm.xchange.bleutrade.dto.marketdata.BleutradeTickerReturn;
import org.knowm.xchange.bleutrade.dto.marketdata.BleutradeTrade;
import org.knowm.xchange.currency.CurrencyPair;
import org.knowm.xchange.dto.marketdata.OrderBook;
import org.knowm.xchange.dto.marketdata.Ticker;
import org.knowm.xchange.dto.marketdata.Trade;
import org.knowm.xchange.dto.marketdata.Trades;
import org.knowm.xchange.dto.trade.LimitOrder;
import org.knowm.xchange.exceptions.ExchangeException;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import si.mazi.rescu.ClientConfig;
import si.mazi.rescu.IRestProxyFactory;

@RunWith(MockitoJUnitRunner.class)
public class BleutradeMarketDataServiceIntegration extends BleutradeServiceTestSupport {

  private static final Ticker TICKER =
      new Ticker.Builder()
          .currencyPair(BLEU_BTC_CP)
          .last(new BigDecimal("0.00101977"))
          .bid(new BigDecimal("0.00100000"))
          .ask(new BigDecimal("0.00101977"))
          .high(new BigDecimal("0.00105000"))
          .low(new BigDecimal("0.00086000"))
          .vwap(new BigDecimal("0.00103455"))
          .volume(new BigDecimal("2450.97496015"))
          .timestamp(new Date(1406632770000L))
          .build();
  private BleutradeMarketDataService marketDataService;

  @Mock private BleutradeAuthenticated bleutrade;

  @Before
  public void setUp() {
    BleutradeExchange exchange =
        (BleutradeExchange)
            ExchangeFactory.INSTANCE.createExchange(BleutradeExchange.class.getCanonicalName());
    exchange.getExchangeSpecification().setUserName(SPECIFICATION_USERNAME);
    exchange.getExchangeSpecification().setApiKey(SPECIFICATION_API_KEY);
    exchange.getExchangeSpecification().setSecretKey(SPECIFICATION_SECRET_KEY);

    IRestProxyFactory restProxyFactory = mock(IRestProxyFactory.class);
    when(restProxyFactory.createProxy(
            eq(BleutradeAuthenticated.class), any(String.class), any(ClientConfig.class)))
        .thenReturn(bleutrade);

    marketDataService = new BleutradeMarketDataService(exchange, restProxyFactory);
  }

  @Test
  public void constructor() {
    assertThat(marketDataService.apiKey.equals(SPECIFICATION_API_KEY));
  }

  @Test
  public void shouldGetTicker() throws IOException {
    // given
    BleutradeTickerReturn tickerReturn = new BleutradeTickerReturn();
    tickerReturn.setSuccess(true);
    tickerReturn.setMessage("test message");
    tickerReturn.setResult(expectedBleutradeTicker());

    when(bleutrade.getBleutradeTicker("BLEU_BTC")).thenReturn(tickerReturn);

    // when
    Ticker ticker = marketDataService.getTicker(BLEU_BTC_CP);

    // then
    assertThat(ticker.toString()).isEqualTo(EXPECTED_BLEUTRADE_TICKER_STR);
    BleutradeAssert.assertEquals(ticker, TICKER);
  }

  @Test(expected = ExchangeException.class)
  public void shouldFailOnUnsuccesfulGetTicker() throws IOException {
    // given
    BleutradeTickerReturn tickerReturn = new BleutradeTickerReturn();
    tickerReturn.setSuccess(false);
    tickerReturn.setMessage("test message");
    tickerReturn.setResult(expectedBleutradeTicker());

    when(bleutrade.getBleutradeTicker("BLEU_BTC")).thenReturn(tickerReturn);

    // when
    marketDataService.getTicker(BLEU_BTC_CP);

    // then
    fail(
        "BleutradeMarketDataService should throw ExchangeException when ticker request was unsuccessful");
  }

  @Test
  public void shouldGetOrderBook() throws IOException {
    // given
    BleutradeOrderBookReturn orderBookReturn1 = new BleutradeOrderBookReturn();
    orderBookReturn1.setSuccess(true);
    orderBookReturn1.setMessage("test message");
    orderBookReturn1.setResult(
        createBleutradeOrderBook(expectedBleutradeLevelBuys(), expectedBleutradeLevelSells()));

    BleutradeOrderBookReturn orderBookReturn2 = new BleutradeOrderBookReturn();
    orderBookReturn2.setSuccess(true);
    orderBookReturn2.setMessage("");
    orderBookReturn2.setResult(
        createBleutradeOrderBook(Collections.EMPTY_LIST, Collections.EMPTY_LIST));

    when(bleutrade.getBleutradeOrderBook("BTC_AUD", "ALL", 30)).thenReturn(orderBookReturn1);
    when(bleutrade.getBleutradeOrderBook("BLEU_BTC", "ALL", 50)).thenReturn(orderBookReturn2);

    final LimitOrder[] expectedAsks = expectedAsks();
    final LimitOrder[] expectedBids = expectedBids();

    // when
    OrderBook orderBook1 = marketDataService.getOrderBook(CurrencyPair.BTC_AUD, 30);
    OrderBook orderBook2 = marketDataService.getOrderBook(BLEU_BTC_CP, "test parameter");

    // then
    List<LimitOrder> asks = orderBook1.getAsks();
    assertThat(asks).hasSize(4);
    for (int i = 0; i < asks.size(); i++) {
      BleutradeAssert.assertEquals(asks.get(i), expectedAsks[i]);
    }

    List<LimitOrder> bids = orderBook1.getBids();
    assertThat(bids).hasSize(2);
    for (int i = 0; i < bids.size(); i++) {
      BleutradeAssert.assertEquals(bids.get(i), expectedBids[i]);
    }

    assertThat(orderBook2.getAsks()).isEmpty();
    assertThat(orderBook2.getBids()).isEmpty();
  }

  @Test(expected = ExchangeException.class)
  public void shouldFailOnUnsuccessfulGetOrderBook() throws IOException {
    // given
    BleutradeOrderBookReturn orderBookReturn = new BleutradeOrderBookReturn();
    orderBookReturn.setSuccess(false);
    orderBookReturn.setMessage("test message");
    orderBookReturn.setResult(
        createBleutradeOrderBook(expectedBleutradeLevelBuys(), expectedBleutradeLevelSells()));

    when(bleutrade.getBleutradeOrderBook("BLEU_BTC", "ALL", 50)).thenReturn(orderBookReturn);

    // when
    marketDataService.getOrderBook(BLEU_BTC_CP);

    // then
    fail(
        "BleutradeMarketDataService should throw ExchangeException when order book request was unsuccessful");
  }

  @Test
  public void shouldGetTrades() throws IOException {
    // given
    final List<BleutradeTrade> expectedBleutradeTrades = expectedBleutradeTrades();

    BleutradeMarketHistoryReturn marketHistoryReturn1 = new BleutradeMarketHistoryReturn();
    marketHistoryReturn1.setSuccess(true);
    marketHistoryReturn1.setMessage("test message");
    marketHistoryReturn1.setResult(expectedBleutradeTrades);

    BleutradeMarketHistoryReturn marketHistoryReturn2 = new BleutradeMarketHistoryReturn();
    marketHistoryReturn2.setSuccess(true);
    marketHistoryReturn2.setMessage("");
    marketHistoryReturn2.setResult(Collections.EMPTY_LIST);

    BleutradeMarketHistoryReturn marketHistoryReturn3 = new BleutradeMarketHistoryReturn();
    marketHistoryReturn3.setSuccess(true);
    marketHistoryReturn3.setMessage("test message");
    marketHistoryReturn3.setResult(Arrays.asList(expectedBleutradeTrades.get(0)));

    BleutradeMarketHistoryReturn marketHistoryReturn4 = new BleutradeMarketHistoryReturn();
    marketHistoryReturn4.setSuccess(true);
    marketHistoryReturn4.setMessage("test message");
    marketHistoryReturn4.setResult(Arrays.asList(expectedBleutradeTrades.get(1)));

    when(bleutrade.getBleutradeMarketHistory("BTC_AUD", 30)).thenReturn(marketHistoryReturn1);
    when(bleutrade.getBleutradeMarketHistory("BTC_AUD", 50)).thenReturn(marketHistoryReturn2);
    when(bleutrade.getBleutradeMarketHistory("BTC_AUD", 1)).thenReturn(marketHistoryReturn3);
    when(bleutrade.getBleutradeMarketHistory("BTC_AUD", 200)).thenReturn(marketHistoryReturn4);

    final Trade[] expectedTrades = expectedTrades();

    // when
    Trades trades1 = marketDataService.getTrades(CurrencyPair.BTC_AUD, 30);
    Trades trades2 = marketDataService.getTrades(CurrencyPair.BTC_AUD, "test parameter");
    Trades trades3 = marketDataService.getTrades(CurrencyPair.BTC_AUD, 0);
    Trades trades4 = marketDataService.getTrades(CurrencyPair.BTC_AUD, 201);

    // then
    List<Trade> tradeList = trades1.getTrades();
    assertThat(tradeList).hasSize(2);

    for (int i = 0; i < tradeList.size(); i++) {
      BleutradeAssert.assertEquals(tradeList.get(i), expectedTrades[i]);
    }

    assertThat(trades2.getTrades()).isEmpty();

    assertThat(trades3.getTrades()).hasSize(1);
    BleutradeAssert.assertEquals(trades3.getTrades().get(0), expectedTrades[0]);

    assertThat(trades4.getTrades()).hasSize(1);
    BleutradeAssert.assertEquals(trades4.getTrades().get(0), expectedTrades[1]);
  }

  @Test(expected = ExchangeException.class)
  public void shouldFailOnUnsuccessfulGetTrades() throws IOException {
    // given
    BleutradeMarketHistoryReturn marketHistoryReturn = new BleutradeMarketHistoryReturn();
    marketHistoryReturn.setSuccess(false);
    marketHistoryReturn.setMessage("test message");
    marketHistoryReturn.setResult(expectedBleutradeTrades());

    when(bleutrade.getBleutradeMarketHistory("BLEU_BTC", 50)).thenReturn(marketHistoryReturn);

    // when
    marketDataService.getTrades(BLEU_BTC_CP);

    // then
    fail(
        "BleutradeMarketDataService should throw ExchangeException when trades request was unsuccessful");
  }

  @Test
  public void shouldGetTickers() throws IOException {
    // given
    final List<BleutradeTicker> expectedBleutradeTickers = expectedBleutradeTickers();
    final String[] expectedBleutradeTickersStr = expectedBleutradeTickersStr();

    BleutradeTickerReturn tickerReturn = new BleutradeTickerReturn();
    tickerReturn.setSuccess(true);
    tickerReturn.setMessage("test message");
    tickerReturn.setResult(expectedBleutradeTickers);

    when(bleutrade.getBleutradeTickers()).thenReturn(tickerReturn);

    // when
    List<BleutradeTicker> tickers = marketDataService.getBleutradeTickers();

    // then
    assertThat(tickers).hasSize(2);

    for (int i = 0; i < tickers.size(); i++) {
      BleutradeAssert.assertEquals(tickers.get(i), expectedBleutradeTickers.get(i));
      assertThat(tickers.get(i).toString()).isEqualTo(expectedBleutradeTickersStr[i]);
    }
  }

  @Test(expected = ExchangeException.class)
  public void shouldFailOnUnsuccesfulGetTickers() throws IOException {
    // given
    BleutradeTickerReturn tickerReturn = new BleutradeTickerReturn();
    tickerReturn.setSuccess(false);
    tickerReturn.setMessage("test message");
    tickerReturn.setResult(expectedBleutradeTickers());

    when(bleutrade.getBleutradeTickers()).thenReturn(tickerReturn);

    // when
    marketDataService.getBleutradeTickers();

    // then
    fail(
        "BleutradeMarketDataService should throw ExchangeException when tickers request was unsuccessful");
  }

  @Test
  public void shouldGetCurrencies() throws IOException {
    // given
    final List<BleutradeCurrency> expectedBleutradeCurrencies = expectedBleutradeCurrencies();
    final String[] expectedBleutradeCurrenciesStr = expectedBleutradeCurrenciesStr();

    BleutradeCurrenciesReturn currenciesReturn = new BleutradeCurrenciesReturn();
    currenciesReturn.setSuccess(true);
    currenciesReturn.setMessage("test message");
    currenciesReturn.setResult(expectedBleutradeCurrencies);

    when(bleutrade.getBleutradeCurrencies()).thenReturn(currenciesReturn);

    // when
    List<BleutradeCurrency> currencies = marketDataService.getBleutradeCurrencies();

    // then
    assertThat(currencies).hasSize(2);

    for (int i = 0; i < currencies.size(); i++) {
      BleutradeAssert.assertEquals(currencies.get(i), expectedBleutradeCurrencies.get(i));
      assertThat(currencies.get(i).toString()).isEqualTo(expectedBleutradeCurrenciesStr[i]);
    }
  }

  @Test(expected = ExchangeException.class)
  public void shouldFailOnUnsuccesfulGetCurrencies() throws IOException {
    // given
    BleutradeCurrenciesReturn currenciesReturn = new BleutradeCurrenciesReturn();
    currenciesReturn.setSuccess(false);
    currenciesReturn.setMessage("test message");
    currenciesReturn.setResult(expectedBleutradeCurrencies());

    when(bleutrade.getBleutradeCurrencies()).thenReturn(currenciesReturn);

    // when
    marketDataService.getBleutradeCurrencies();

    // then
    fail(
        "BleutradeMarketDataService should throw ExchangeException when currencies request was unsuccessful");
  }

  @Test
  public void shouldGetMarkets() throws IOException {
    // given
    final List<BleutradeMarket> expectedBleutradeMarkets = expectedBleutradeMarkets();
    final String[] expectedBleutradeMarketsStr = expectedBleutradeMarketsStr();

    BleutradeMarketsReturn marketsReturn = new BleutradeMarketsReturn();
    marketsReturn.setSuccess(true);
    marketsReturn.setMessage("test message");
    marketsReturn.setResult(expectedBleutradeMarkets);

    when(bleutrade.getBleutradeMarkets()).thenReturn(marketsReturn);

    // when
    List<BleutradeMarket> markets = marketDataService.getBleutradeMarkets();

    // then
    assertThat(markets).hasSize(2);

    for (int i = 0; i < markets.size(); i++) {
      BleutradeAssert.assertEquals(markets.get(i), expectedBleutradeMarkets.get(i));
      assertThat(markets.get(i).toString()).isEqualTo(expectedBleutradeMarketsStr[i]);
    }
  }

  @Test(expected = ExchangeException.class)
  public void shouldFailOnUnsuccesfulGetMarkets() throws IOException {
    // given
    BleutradeMarketsReturn marketsReturn = new BleutradeMarketsReturn();
    marketsReturn.setSuccess(false);
    marketsReturn.setMessage("test message");
    marketsReturn.setResult(expectedBleutradeMarkets());

    when(bleutrade.getBleutradeMarkets()).thenReturn(marketsReturn);

    // when
    marketDataService.getBleutradeMarkets();

    // then
    fail(
        "BleutradeMarketDataService should throw ExchangeException when markets request was unsuccessful");
  }
}