public async Task SellOrder_Should_BeValid()
{
CryptoApiMock.MockSellingTrade(new CryptoOrder
{
Market = Market,
PricePerUnit = 110,
Price = 1100,
OrderType = CryptoOrderType.LimitSell,
Quantity = 10M,
Limit = 110
});
Strategy.SetupGet(strategy => strategy.Settings).Returns(new TraderSettings {
TradingBudget = 1000
});
InitializeTrader(new TradeAction {
TradeAdvice = TradeAdvice.Sell, OrderPricePerUnit = 110
});
CoinTrader.TraderState.Trades[0].BuyOrder.Quantity = 10;
await CoinTrader.UpdatePrice(new Ticker());
CryptoApiMock.Verify(c => c.SellCoinAsync(It.Is <CryptoOrder>(s => s.PricePerUnit == 110 &&
s.Price == 1100 &&
s.Market == Market &&
s.OrderType == CryptoOrderType.LimitSell &&
s.Quantity == 10M &&
s.Limit == 110)), Times.Once);
}
public async Task BuyOrder_Should_BeValid()
{
CryptoApiMock.MockBuyingTrade(new CryptoOrder
{
Market = Market,
PricePerUnit = 100,
Price = 1000,
IsClosed = false,
OrderType = CryptoOrderType.LimitBuy,
Quantity = 9.975M,
Limit = 100
});
Strategy.SetupGet(strategy => strategy.Settings).Returns(new TraderSettings {
TradingBudget = 1000
});
InitializeTrader(new TradeAction {
TradeAdvice = TradeAdvice.Buy, OrderPricePerUnit = 100
});
await CoinTrader.UpdatePrice(new Ticker());
CryptoApiMock.Verify(c => c.BuyCoinAsync(It.Is <CryptoOrder>(b => b.PricePerUnit == 100 &&
b.Price == 1000 &&
b.Market == Market &&
!b.IsClosed &&
b.OrderType == CryptoOrderType.LimitBuy &&
b.Quantity == 9.975M &&
b.Limit == 100)), Times.Once);
}
protected CoinTraderTestBase()
{
Market = "BTC-ETC";
var pushManagerMock = new Mock <IPushManager>();
CoinTrader = new CoinTrader(CryptoApiMock.Object, OrleansClientMock.Object, HubNotifierMock.Object, pushManagerMock.Object)
{
Strategy = Strategy.Object
};
var tickerSubject = new Subject <Ticker>();
var orderSubject = new Subject <CryptoOrder>();
CryptoApiMock.SetupGet(c => c.TickerUpdated).Returns(tickerSubject);
CryptoApiMock.SetupGet(c => c.OrderUpdated).Returns(orderSubject);
TraderGrainMock.Setup(t => t.IsInitialized()).ReturnsAsync(true);
HubNotifierMock.Setup(h => h.UpdateTrader(It.IsAny <TraderState>())).Returns(Task.CompletedTask);
HubNotifierMock.Setup(h => h.UpdateTicker(It.IsAny <Ticker>())).Returns(Task.CompletedTask);
TraderGrainMock.Setup(t => t.UpdateTrades(It.IsAny <List <Trade> >())).Returns(Task.CompletedTask);
pushManagerMock.Setup(p => p.TriggerPush(It.IsAny <PushMessage>())).Returns(Task.CompletedTask);
TraderGrainMock.Setup(c => c.GetTraderData()).ReturnsAsync(new TraderState {
Trades = new List <Trade>()
});
OrleansClientMock.Setup(c => c.GetGrain <ITraderGrain>(It.IsAny <string>(), It.IsAny <string>()))
.Returns(TraderGrainMock.Object);
}
public async Task SellAdvice_Should_CreateSellOrder()
{
await InitializeTrader(new TradeAction { TradeAdvice = TradeAdvice.Sell, OrderPricePerUnit = 120 });
await CoinTrader.UpdatePrice(_newPriceTicker);
CryptoApiMock.Verify(c => c.SellCoinAsync(It.Is <CryptoOrder>(b => b.PricePerUnit == 120)), Times.Once);
}
public async Task EachTrader_ShouldHave_ABudget()
{
await TriggerBuy(1, 100, 1000);
CoinTrader.Strategy.Settings.TradingBudget.Should().Be(1000);
CoinTrader.TraderState.Budget.Available.Should().Be(900);
CoinTrader.TraderState.Budget.Invested.Should().Be(1000);
CryptoApiMock.Verify(c => c.BuyCoinAsync(It.Is <CryptoOrder>(o => o.Price == 1000)), Times.Once);
}
public async Task BuyAdvice_Should_CreateBuyOrder()
{
CryptoApiMock.MockBuyingTrade(new CryptoOrder());
await InitializeTrader(new TradeAction { TradeAdvice = TradeAdvice.Buy, OrderPricePerUnit = 98 });
await CoinTrader.UpdatePrice(_newPriceTicker);
CryptoApiMock.Verify(c => c.BuyCoinAsync(It.Is <CryptoOrder>(b => b.PricePerUnit == 98)), Times.Once);
}
public async Task BuyingOrder_Should_UpdateTraderStatus()
{
CryptoApiMock.MockBuyingTrade(new CryptoOrder());
await InitializeTrader(new TradeAction { TradeAdvice = TradeAdvice.Buy, OrderPricePerUnit = 98 });
await CoinTrader.UpdatePrice(_newPriceTicker);
CoinTrader.Trades[0].Status.Should().Be(TradeStatus.Buying);
}
public async Task CancellingBuyOrder_Should_RemoveTrade()
{
CryptoApiMock.MockCancelTrade(new CryptoOrder());
await InitializeTrader(new TradeAction { TradeAdvice = TradeAdvice.Cancel });
await CoinTrader.UpdatePrice(_newPriceTicker);
CoinTrader.Trades.Count.Should().Be(0);
}
public async Task CancelAdvice_Should_CancelBuyOrder()
{
CryptoApiMock.MockCancelTrade(new CryptoOrder());
await InitializeTrader(new TradeAction { TradeAdvice = TradeAdvice.Cancel });
CoinTrader.Trades[0].BuyOrder.Uuid = "test";
await CoinTrader.UpdatePrice(_newPriceTicker);
CryptoApiMock.Verify(c => c.CancelOrder(It.Is <string>(s => s == "test")), Times.Once);
}
public async Task EmptyTradesList_Should_AddNewTrade()
{
CryptoApiMock.MockBuyingTrade(new CryptoOrder());
await InitializeTrader(new TradeAction { TradeAdvice = TradeAdvice.Buy, OrderPricePerUnit = 98 });
CoinTrader.Trades = new List <Trade>();
await CoinTrader.UpdatePrice(_newPriceTicker);
CoinTrader.Trades.Count.Should().Be(1);
}
public async Task UpdatePrice_Should_UpdateAllTrades()
{
await InitializeTrader(new TradeAction { TradeAdvice = TradeAdvice.Cancel });
CryptoApiMock.MockCancelTrade(new CryptoOrder());
CoinTrader.Trades.Add(new Trade());
await CoinTrader.UpdatePrice(_newPriceTicker);
Strategy.Verify(s => s.CalculateTradeAction(It.IsAny <Ticker>(), It.IsAny <Trade>()), Times.Exactly(2));
}
protected async Task InitializeTrader(TradeAction tradeAction)
{
CryptoApiMock.MockSellingTrade(new CryptoOrder());
Strategy.SetupGet(strategy => strategy.Settings).Returns(new TraderSettings {
TradingBudget = 1000
});
Strategy.SetTradeAction(tradeAction);
CoinTrader.Initialize(Market);
CoinTrader.Strategy = Strategy.Object;
await CoinTrader.StartAsync();
}
public async Task ClosedOrder_Should_UpdateTradeStatus()
{
CryptoApiMock.MockBuyingTrade(new CryptoOrder());
InitializeTrader(new TradeAction {
TradeAdvice = TradeAdvice.Buy, OrderPricePerUnit = 98
});
await CoinTrader.UpdatePrice(_newPriceTicker);
await CoinTrader.UpdateOrder(new CryptoOrder { IsClosed = false, OrderType = CryptoOrderType.LimitBuy });
CoinTrader.TraderState.Trades[0].Status.Should().NotBe(TradeStatus.Bought);
}
private async Task TriggerBuy(decimal pricePerUnit, decimal price, decimal budget)
{
var cryptoOrder = new CryptoOrder {
PricePerUnit = pricePerUnit, Price = price
};
CryptoApiMock.MockBuyingTrade(cryptoOrder);
CryptoApiMock.MockCancelTrade(cryptoOrder);
await InitializeTrader(new TradeAction { TradeAdvice = TradeAdvice.Buy, OrderPricePerUnit = pricePerUnit });
Strategy.SetupGet(strategy => strategy.Settings).Returns(new TraderSettings {
TradingBudget = budget
});
await CoinTrader.UpdatePrice(new Ticker());
}
public async Task PriceUpdate_Should_UpdateTraderProfit()
{
CryptoApiMock.MockBuyingTrade(new CryptoOrder());
var trade = new Trade();
trade.BuyOrder.PricePerUnit = 100;
CryptoBroker.TraderState.Trades = new List <Trade> {
trade
};
trade.Status = TradeStatus.Bought;
CryptoBroker.Strategy = new HoldUntilPriceDropsStrategy();
await CryptoBroker.UpdatePrice(_newPriceTicker);
CryptoBroker.TraderState.Trades[0].Profit.Should().Be(19.4M);
}
public async Task OnlyCompletedTrades_Should_AddNewTrade()
{
CryptoApiMock.MockBuyingTrade(new CryptoOrder());
InitializeTrader(new TradeAction {
TradeAdvice = TradeAdvice.Buy, OrderPricePerUnit = 98
});
CoinTrader.TraderState.Trades = new List <Trade> {
new Trade {
Status = TradeStatus.Completed
}
};
await CoinTrader.UpdatePrice(_newPriceTicker);
CoinTrader.TraderState.Trades.Count.Should().Be(2);
}
public async Task SellingCoin_Should_UpdateOrderForTrade()
{
await InitializeTrader(new TradeAction { TradeAdvice = TradeAdvice.Sell, OrderPricePerUnit = 98 });
var sellOrder = new CryptoOrder {
OrderType = CryptoOrderType.LimitSell, Price = 1100, Uuid = "S"
};
CryptoApiMock.MockSellingTrade(sellOrder);
CoinTrader.Trades[0].SellOrder.Uuid = "S";
await CoinTrader.UpdatePrice(_newPriceTicker);
CoinTrader.Trades[0].SellOrder.Uuid.Should().Be("S");
CoinTrader.Trades[0].SellOrder.Price.Should().Be(1100);
}
protected void InitializeTrader(TradeAction tradeAction)
{
CryptoApiMock.MockSellingTrade(new CryptoOrder());
Strategy.SetupGet(strategy => strategy.Settings).Returns(new TraderSettings {
TradingBudget = 1000
});
Strategy.SetTradeAction(tradeAction);
CoinTrader.Initialize(new TraderState
{
Trades = new List <Trade>(),
Market = Market,
Settings = new TraderSettings {
TradingBudget = 1000
}
});
CoinTrader.Strategy = Strategy.Object;
}
public async Task UpdatePrice_ShouldNot_RunConcurrently()
{
var subject = new Subject <Ticker>();
CryptoApiMock.MockBuyingTrade(new CryptoOrder());
CryptoApiMock.SetupGet(c => c.TickerUpdated).Returns(subject);
await InitializeTrader(new TradeAction { TradeAdvice = TradeAdvice.Buy, OrderPricePerUnit = 1 });
for (int i = 0; i < 100; i++)
{
subject.OnNext(new Ticker {
Market = Market
});
}
Strategy.Verify(s => s.CalculateTradeAction(It.IsAny <Ticker>(), It.IsAny <Trade>()), Times.Exactly(100));
}
protected void Reset()
{
Market = "BTC-ETC";
var pushManagerMock = new Mock <IPushManager>();
Strategy.SetupGet(strategy => strategy.Settings).Returns(new TraderSettings {
TradingBudget = 1000
});
CoinTrader = new CoinTrader(CryptoApiMock.Object)
{
Strategy = Strategy.Object,
IsInTestMode = true
};
var tickerSubject = new Subject <Ticker>();
var orderSubject = new Subject <CryptoOrder>();
CryptoApiMock.SetupGet(c => c.TickerUpdated).Returns(tickerSubject);
CryptoApiMock.SetupGet(c => c.OrderUpdated).Returns(orderSubject);
TraderGrainMock.Setup(t => t.IsInitialized()).ReturnsAsync(true);
HubNotifierMock.Setup(h => h.UpdateTrader(It.IsAny <TraderState>())).Returns(Task.CompletedTask);
HubNotifierMock.Setup(h => h.UpdateTicker(It.IsAny <Ticker>())).Returns(Task.CompletedTask);
TraderGrainMock.Setup(t => t.UpdateTrades(It.IsAny <List <Trade> >())).Returns(Task.CompletedTask);
pushManagerMock.Setup(p => p.TriggerPush(It.IsAny <PushMessage>())).Returns(Task.CompletedTask);
var traderState = new TraderState
{
Trades = new List <Trade>(),
Budget = new Budget(),
Settings = new TraderSettings {
TradingBudget = 1000
}
};
CoinTrader.TraderState = traderState;
TraderGrainMock.Setup(c => c.GetTraderData()).ReturnsAsync(traderState);
OrleansClientMock.Setup(c => c.GetGrain <ITraderGrain>(It.IsAny <string>(), It.IsAny <string>()))
.Returns(TraderGrainMock.Object);
}
private void CheckBuyOrderInvocation(decimal quantity, decimal pricePerUnit, decimal price)
{
CryptoApiMock.Verify(c => c.BuyCoinAsync(It.Is <CryptoOrder>(o => o.Price == price &&
o.PricePerUnit == pricePerUnit &&
o.Quantity == quantity)), Times.Once);
}
