public void UpdateTrades_Second_Update_3_New_Trades_Less_Than_Limit()
{
// Arrange
var preferences = new Model.Preferences();
preferences.OrderBookChartDisplayCount = 8;
preferences.OrderBookDisplayCount = 5;
preferences.TradesDisplayCount = 15;
preferences.TradesChartDisplayCount = 18;
var exchangeApi = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.SubscribeOrderBookAggregateTrades);
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolViewModel = new SymbolViewModel(Exchange.Test, exchangeService, chartHelper,
new BinanceOrderBookHelper(),
new TradeHelper(),
preferences, new DebugLogger());
var trx = TestHelper.BNB.GetViewSymbol();
symbolViewModel.Symbol = trx;
var firstTrades = TradesUpdateHelper.Trades_BNB_InitialTradeUpdate_10_Trades();
var secondTrades = TradesUpdateHelper.Trades_BNB_NextTradeUpdate(firstTrades, 3, 3);
// Act
symbolViewModel.UpdateTrades(firstTrades);
symbolViewModel.UpdateTrades(secondTrades);
// Assert
Assert.AreEqual(symbolViewModel.Trades.Count, 13);
Assert.AreEqual(symbolViewModel.TradesChart.Count, 13);
var chart = firstTrades.Take(3).ToList();
chart.AddRange(secondTrades);
// Assert - chart trades
for (int i = 0; i < 13; i++)
{
Assert.AreEqual(symbolViewModel.TradesChart[i].Id, chart[i].Id);
Assert.AreEqual(symbolViewModel.TradesChart[i].Time, chart[i].Time);
}
// Assert - trades
var trades = chart.Reverse <ITrade>().ToList();
for (int i = 0; i < 13; i++)
{
Assert.AreEqual(symbolViewModel.Trades[i].Id, trades[i].Id);
Assert.AreEqual(symbolViewModel.Trades[i].Time, trades[i].Time);
}
}
public async Task SelectedSymbol()
{
// Arrange
var fail = false;
Symbol selectedSymbol = null;
var exchangeApi = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.SymbolsViewModel);
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolsCacheFactory = SymbolsCacheFactoryHelper.GetSymbolsCachefactory(exchangeService);
var symbolsViewModel = new SymbolsViewModel(exchangeService, symbolsCacheFactory, new DebugLogger());
var symbolsObservable = Observable.FromEventPattern <SymbolsEventArgs>(
eventHandler => symbolsViewModel.OnSymbolsNotification += eventHandler,
eventHandler => symbolsViewModel.OnSymbolsNotification -= eventHandler)
.Select(eventPattern => eventPattern.EventArgs);
symbolsObservable.Subscribe((args) =>
{
if (args.Value != null)
{
selectedSymbol = args.Value;
}
else if (args.Symbols != null)
{
// expected
}
else
{
fail = true;
}
});
var userAccount = new UserAccount
{
Preferences = new Preferences {
SelectedSymbol = "BNBBTC",
}
};
userAccount.Preferences.FavouriteSymbols.Add("BNBBTC");
userAccount.Preferences.FavouriteSymbols.Add("TRXBTC");
await symbolsViewModel.SetAccount(userAccount);
await Task.Delay(1000);
// Act
var trx = symbolsViewModel.Symbols.Single(s => s.Name.Equals("TRXBTC"));
symbolsViewModel.SelectedSymbol = trx;
// Assert
Assert.AreEqual(symbolsViewModel.SelectedSymbol, selectedSymbol);
Assert.IsFalse(fail);
}
public async Task Buy_Fails_Order_Validation()
{
// Arrange
var cxlToken = new CancellationToken();
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var tradeViewModel = new TradeViewModel(exchangeService, new DebugLogger());
var symbols = await exchangeService.GetSymbols24HourStatisticsAsync(Exchange.Test, cxlToken);
var trx = symbols.Single(s => s.Name.Equals("TRXBTC"));
var account = new Account(new Core.Model.AccountInfo {
User = new Core.Model.User()
})
{
ApiKey = "apikey",
ApiSecret = "apisecret"
};
account = await exchangeService.GetAccountInfoAsync(Exchange.Test, account.AccountInfo.User, cxlToken);
var selectedAsset = account.Balances.Single(ab => ab.Asset.Equals("TRX"));
tradeViewModel.SetSymbols(symbols.ToList());
tradeViewModel.SetAccount(account);
tradeViewModel.SetSymbol(selectedAsset);
tradeViewModel.QuoteAccountBalance.Free = 0.00012693M;
tradeViewModel.SelectedOrderType = "Limit";
tradeViewModel.Price = 0.00000900M;
var tradeObservable = Observable.FromEventPattern <TradeEventArgs>(
eventHandler => tradeViewModel.OnTradeNotification += eventHandler,
eventHandler => tradeViewModel.OnTradeNotification -= eventHandler)
.Select(eventPattern => eventPattern.EventArgs);
Exception ex = null;
tradeObservable.Subscribe(args =>
{
if (args.HasException)
{
ex = args.Exception;
}
});
// Act
tradeViewModel.BuyCommand.Execute(null);
// Assert
Assert.IsInstanceOfType(ex, typeof(OrderValidationException));
}
public void SelectedAsset()
{
// Arrange
var fail = false;
AccountBalance selectedAccountBalance = null;
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolsCache = SymbolsCacheHelper.GetSymbolsCache(exchangeService);
var accountViewModel = new AccountViewModel(exchangeService, symbolsCache, new DebugLogger());
var account = new Account(new Interface.AccountInfo {
User = new Interface.User()
})
{
ApiKey = "apikey",
ApiSecret = "apisecret"
};
accountViewModel.Account = account;
var accountObservable = Observable.FromEventPattern <AccountEventArgs>(
eventHandler => accountViewModel.OnAccountNotification += eventHandler,
eventHandler => accountViewModel.OnAccountNotification -= eventHandler)
.Select(eventPattern => eventPattern.EventArgs);
accountObservable.Subscribe(args =>
{
if (args.AccountEventType.Equals(AccountEventType.LoggedOut) ||
args.AccountEventType.Equals(AccountEventType.LoggedIn))
{
// expected
}
else if (args.AccountEventType.Equals(AccountEventType.SelectedAsset))
{
selectedAccountBalance = args.SelectedAsset;
}
else
{
fail = true;
}
});
// Act
accountViewModel.SetAccount(account);
accountViewModel.LoginCommand.Execute(null);
var trx = accountViewModel.Account.Balances.Single(ab => ab.Asset.Equals("TRX"));
accountViewModel.SelectedAsset = trx;
// Assert
Assert.AreEqual(selectedAccountBalance, trx);
Assert.IsFalse(fail);
}
public async Task Buy_Fails_No_OrderType()
{
// Arrange
var cxlToken = new CancellationToken();
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var tradeViewModel = new TradeViewModel(exchangeService);
var symbols = await exchangeService.GetSymbols24HourStatisticsAsync(cxlToken);
var trx = symbols.Single(s => s.Name.Equals("TRXBTC"));
var account = new Account(new Interface.AccountInfo {
User = new Interface.User()
})
{
ApiKey = "apikey",
ApiSecret = "apisecret"
};
account = await exchangeService.GetAccountInfoAsync(account.AccountInfo.User.ApiKey, account.AccountInfo.User.ApiSecret, cxlToken);
var selectedAsset = account.Balances.Single(ab => ab.Asset.Equals("TRX"));
tradeViewModel.SetSymbols(symbols.ToList());
tradeViewModel.SetAccount(account);
tradeViewModel.SetSymbol(selectedAsset);
tradeViewModel.Quantity = 200m;
tradeViewModel.Price = 0.00000900M;
var tradeObservable = Observable.FromEventPattern <TradeEventArgs>(
eventHandler => tradeViewModel.OnTradeNotification += eventHandler,
eventHandler => tradeViewModel.OnTradeNotification -= eventHandler)
.Select(eventPattern => eventPattern.EventArgs);
Exception ex = null;
tradeObservable.Subscribe(args =>
{
if (args.HasException)
{
ex = args.Exception;
}
});
// Act
tradeViewModel.BuyCommand.Execute(null);
// Assert
Assert.IsNotNull(ex);
Assert.IsTrue(ex.Message.Contains("order type"));
}
public void HasQuoteBaseBalance_Null()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var tradeViewModel = new TradeViewModel(exchangeService, new DebugLogger());
// Act
// Assert
Assert.IsFalse(tradeViewModel.HasBaseBalance);
Assert.IsFalse(tradeViewModel.HasQuoteBalance);
}
public void Login()
{
// Arrange
var fail = false;
var loggedInAccount = string.Empty;
string errorMessage = string.Empty;
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolsCache = SymbolsCacheHelper.GetSymbolsCache(exchangeService);
var accountViewModel = new AccountViewModel(exchangeService, symbolsCache, new DebugLogger());
var account = new Account(new Interface.AccountInfo {
User = new Interface.User()
})
{
ApiKey = "apikey",
ApiSecret = "apisecret"
};
accountViewModel.Account = account;
var accountObservable = Observable.FromEventPattern <AccountEventArgs>(
eventHandler => accountViewModel.OnAccountNotification += eventHandler,
eventHandler => accountViewModel.OnAccountNotification -= eventHandler)
.Select(eventPattern => eventPattern.EventArgs);
accountObservable.Subscribe(args =>
{
if (args.AccountEventType.Equals(AccountEventType.LoggedIn))
{
loggedInAccount = JsonConvert.SerializeObject(args.Value);
}
else
{
fail = true;
}
});
// Act
accountViewModel.LoginCommand.Execute(null);
// Assert
var accountViewModelAccount = JsonConvert.SerializeObject(accountViewModel.Account);
var accountInfo = JsonConvert.SerializeObject(accountViewModel.Account.AccountInfo);
var testAccountInfo = JsonConvert.SerializeObject(TestHelper.AccountInfo);
Assert.AreEqual(accountViewModelAccount, loggedInAccount);
Assert.AreEqual(accountInfo, testAccountInfo);
Assert.IsFalse(fail);
}
public void HasQuoteBaseBalance_Null()
{
// Arrange
var cxlToken = new CancellationToken();
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var tradeViewModel = new TradeViewModel(exchangeService);
// Act
// Assert
Assert.IsFalse(tradeViewModel.HasBaseBalance);
Assert.IsFalse(tradeViewModel.HasQuoteBalance);
}
public async Task GetSymbols24HourStatisticsAsync()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var cxlToken = new CancellationToken();
// Act
var symbols = await exchangeService.GetSymbols24HourStatisticsAsync(Exchange.Test, cxlToken).ConfigureAwait(false);
// Assert
var testResults = symbols.Where(s => s.SymbolStatistics.LastPrice.Equals(0.0M)).ToList();
Assert.IsFalse(testResults.Any());
}
public async Task SymbolsViewModel_SetAccount()
{
// Arrange
var fail = false;
var exchangeApi = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.SymbolsViewModel);
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolsCacheFactory = SymbolsCacheFactoryHelper.GetSymbolsCachefactory(exchangeService);
// Act
var symbolsViewModel = new SymbolsViewModel(exchangeService, symbolsCacheFactory, new DebugLogger());
var symbolsObservable = Observable.FromEventPattern <SymbolsEventArgs>(
eventHandler => symbolsViewModel.OnSymbolsNotification += eventHandler,
eventHandler => symbolsViewModel.OnSymbolsNotification -= eventHandler)
.Select(eventPattern => eventPattern.EventArgs);
symbolsObservable.Subscribe((args) =>
{
if (args.Symbols != null || // OnLoadedSymbols
args.Value.Name.Equals("BNBBTC")) // OnSelectedSymbol
{
// expected
}
else
{
fail = true;
}
});
await symbolsViewModel.SetAccount(
new UserAccount
{
Preferences = new Preferences
{
SelectedSymbol = "BNBBTC",
FavouriteSymbols = new ObservableCollection <string>(new[] { "BNBBTC", "TRXBTC" })
}
});
await Task.Delay(1000);
// Assert
Assert.AreEqual(symbolsViewModel.Symbols.Count, 2);
Assert.IsNotNull(symbolsViewModel.AccountPreferences);
Assert.IsNotNull(symbolsViewModel.SelectedSymbol);
Assert.AreEqual(symbolsViewModel.SelectedSymbol.Name, "BNBBTC");
Assert.IsFalse(fail);
}
public async Task UpdateOrderBook()
{
// Arrange
var cxlToken = new CancellationToken();
var exchangeApi = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.SubscribeOrderBookAggregateTrades);
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolViewModel = new SymbolViewModel(exchangeService);
var trx = TestHelper.Trx.GetViewSymbol();
// Act
await symbolViewModel.SetSymbol(trx);
// Assert
Assert.AreEqual(symbolViewModel.OrderBook.LastUpdateId, TestHelper.OrderBookUpdated.LastUpdateId);
}
public async Task Login()
{
// Arrange
var fail = false;
Account notifyAccount = null;
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolsCacheFactory = SymbolsCacheFactoryHelper.GetSymbolsCachefactory(exchangeService);
var accountViewModel = new AccountBalancesViewModel(exchangeService, symbolsCacheFactory, new DebugLogger());
var account = new Account(new Core.Model.AccountInfo {
User = new Core.Model.User()
})
{
ApiKey = "apikey",
ApiSecret = "apisecret"
};
var accountObservable = Observable.FromEventPattern <AccountEventArgs>(
eventHandler => accountViewModel.OnAccountNotification += eventHandler,
eventHandler => accountViewModel.OnAccountNotification -= eventHandler)
.Select(eventPattern => eventPattern.EventArgs);
accountObservable.Subscribe(args =>
{
if (args.AccountEventType.Equals(AccountEventType.LoggedIn))
{
notifyAccount = args.Value;
}
else
{
fail = true;
}
});
// Act
await accountViewModel.Login(account);
// Assert
Assert.AreEqual(account.ApiKey, accountViewModel.Account.ApiKey);
Assert.AreEqual(account.AccountInfo.User.ApiSecret, accountViewModel.Account.AccountInfo.User.ApiSecret);
Assert.IsNotNull(notifyAccount);
Assert.AreEqual(account.ApiKey, notifyAccount.ApiKey);
Assert.AreEqual(account.AccountInfo.User.ApiSecret, notifyAccount.AccountInfo.User.ApiSecret);
Assert.IsFalse(fail);
}
public void SetAccount()
{
// Arrange
var fail = false;
Account notifyAccount = null;
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var accountViewModel = new AccountViewModel(exchangeService);
var account = new Account(new Interface.AccountInfo {
User = new Interface.User()
})
{
ApiKey = "apikey",
ApiSecret = "apisecret"
};
var accountObservable = Observable.FromEventPattern <AccountEventArgs>(
eventHandler => accountViewModel.OnAccountNotification += eventHandler,
eventHandler => accountViewModel.OnAccountNotification -= eventHandler)
.Select(eventPattern => eventPattern.EventArgs);
accountObservable.Subscribe(args =>
{
if (args.AccountEventType.Equals(AccountEventType.LoggedIn))
{
notifyAccount = args.Value;
}
else
{
fail = true;
}
});
// Act
accountViewModel.SetAccount(account);
// Assert
Assert.AreEqual(account.ApiKey, accountViewModel.Account.ApiKey);
Assert.AreEqual(account.AccountInfo.User.ApiSecret, accountViewModel.Account.AccountInfo.User.ApiSecret);
Assert.IsNotNull(notifyAccount);
Assert.AreEqual(account.ApiKey, notifyAccount.ApiKey);
Assert.AreEqual(account.AccountInfo.User.ApiSecret, notifyAccount.AccountInfo.User.ApiSecret);
Assert.IsFalse(fail);
}
public void Login_AccountKeyMissing_NotifyHasException()
{
// Arrange
var fail = false;
string errorMessage = string.Empty;
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolsCache = SymbolsCacheHelper.GetSymbolsCache(exchangeService);
var accountViewModel = new AccountViewModel(exchangeService, symbolsCache, new DebugLogger());
var account = new Account(new Interface.AccountInfo {
User = new Interface.User()
})
{
ApiKey = "apikey"
};
accountViewModel.Account = account;
var accountObservable = Observable.FromEventPattern <AccountEventArgs>(
eventHandler => accountViewModel.OnAccountNotification += eventHandler,
eventHandler => accountViewModel.OnAccountNotification -= eventHandler)
.Select(eventPattern => eventPattern.EventArgs);
accountObservable.Subscribe(args =>
{
if (args.HasException)
{
errorMessage = args.Exception.Message;
}
else
{
fail = true;
}
});
// Act
accountViewModel.LoginCommand.Execute(null);
// Assert
Assert.AreEqual(errorMessage, "Both api key and secret key are required to login to an account.");
Assert.IsFalse(fail);
}
public void UpdateTrades_Third_Update()
{
// Arrange
var preferences = new Model.Preferences
{
OrderBookChartDisplayCount = 8,
OrderBookDisplayCount = 5,
TradesDisplayCount = 15,
TradesChartDisplayCount = 18
};
var exchangeApi = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.SubscribeOrderBookAggregateTrades);
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolViewModel = new SymbolViewModel(Exchange.Test, exchangeService, chartHelper,
new BinanceOrderBookHelper(),
new TradeHelper(),
preferences, new DebugLogger());
var trx = TestHelper.BNB.GetViewSymbol();
symbolViewModel.Symbol = trx;
var firstTrades = TradesUpdateHelper.Trades_BNB_InitialTradeUpdate_10_Trades();
var secondTrades = TradesUpdateHelper.Trades_BNB_NextTradeUpdate(firstTrades, 3, 3);
var thirdTrades = TradesUpdateHelper.Trades_BNB_NextTradeUpdate(secondTrades, 9, 9);
// Act
symbolViewModel.UpdateTrades(firstTrades);
symbolViewModel.UpdateTrades(secondTrades);
symbolViewModel.UpdateTrades(thirdTrades);
// Assert
var update = secondTrades.Skip(1).Take(8).ToList();
update.AddRange(thirdTrades);
AssertTradeUpdate(symbolViewModel, preferences, update);
}
public void Quantity_and_Price_and_StopPrice_NoSelectedSymbol()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var tradeViewModel = new TradeViewModel(exchangeService, new DebugLogger());
var quantity = 294.123m;
var price = 1.123456789m;
// Act
tradeViewModel.Quantity = quantity;
tradeViewModel.Price = price;
tradeViewModel.StopPrice = price;
// Assert
Assert.AreEqual(tradeViewModel.Quantity, quantity);
Assert.AreEqual(tradeViewModel.Price, price);
Assert.AreEqual(tradeViewModel.StopPrice, price);
}
public async Task SelectedSymbol()
{
// Arrange
var fail = false;
Symbol selectedSymbol = null;
var exchangeApi = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.SymbolsViewModel);
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolsViewModel = new SymbolsViewModel(exchangeService);
var symbolsObservable = Observable.FromEventPattern <SymbolsEventArgs>(
eventHandler => symbolsViewModel.OnSymbolsNotification += eventHandler,
eventHandler => symbolsViewModel.OnSymbolsNotification -= eventHandler)
.Select(eventPattern => eventPattern.EventArgs);
symbolsObservable.Subscribe((args) =>
{
if (args.Value != null)
{
selectedSymbol = args.Value;
}
else if (args.Symbols != null)
{
// expected
}
else
{
fail = true;
}
});
await Task.Delay(1000);
// Act
var trx = symbolsViewModel.Symbols.Single(s => s.Name.Equals("TRXBTC"));
symbolsViewModel.SelectedSymbol = trx;
// Assert
Assert.AreEqual(symbolsViewModel.SelectedSymbol, selectedSymbol);
Assert.IsFalse(fail);
}
public async Task OrderTypes_NoSelectedSymbol()
{
// Arrange
var cxlToken = new CancellationToken();
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var tradeViewModel = new TradePanelViewModel(exchangeService, new DebugLogger());
var symbols = await exchangeService.GetSymbols24HourStatisticsAsync(Exchange.Test, cxlToken);
tradeViewModel.SetSymbols(symbols.ToList());
// Act
// Assert
Assert.IsNull(tradeViewModel.SelectedSymbol);
var intersection = tradeViewModel.OrderTypes.Intersect(InterfaceExtensions.OrderExtensions.OrderTypes()).ToList();
Assert.IsTrue(InterfaceExtensions.OrderExtensions.OrderTypes().Count().Equals(intersection.Count));
}
public async Task SetAccount_Different_Account_Null_SelectedAsset()
{
// Arrange
var cxlToken = new CancellationToken();
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var tradeViewModel = new TradeViewModel(exchangeService);
var symbols = await exchangeService.GetSymbols24HourStatisticsAsync(cxlToken);
tradeViewModel.SetSymbols(symbols.ToList());
var account = new Account(new Interface.AccountInfo {
User = new Interface.User()
})
{
ApiKey = "apikey",
ApiSecret = "apisecret"
};
account = await exchangeService.GetAccountInfoAsync(account.AccountInfo.User.ApiKey, account.AccountInfo.User.ApiSecret, cxlToken);
tradeViewModel.SetAccount(account);
var differentAccount = new Account(new Interface.AccountInfo {
User = new Interface.User()
})
{
ApiKey = "test123",
ApiSecret = "test123"
};
// Act
tradeViewModel.SetAccount(differentAccount);
// Assert
Assert.AreEqual(tradeViewModel.Account, differentAccount);
Assert.AreEqual(tradeViewModel.SelectedOrderType, null);
Assert.IsNull(tradeViewModel.SelectedSymbol);
}
public async Task UpdateAggregateTrades()
{
// Arrange
var cxlToken = new CancellationToken();
var exchangeApi = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.SubscribeOrderBookAggregateTrades);
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolViewModel = new SymbolViewModel(exchangeService);
var trx = TestHelper.Trx.GetViewSymbol();
// Act
await symbolViewModel.SetSymbol(trx);
// Assert
var trades = TestHelper.AggregateTrades;
var updatedtrades = TestHelper.AggregateTradesUpdated;
var maxId = trades.Max(t => t.Id);
var newTrades = (from t in updatedtrades
where t.Id > maxId
orderby t.Time
select t).ToList();
for (int i = 0; i < newTrades.Count(); i++)
{
if (trades.Count >= 20)
{
trades.RemoveAt(trades.Count - 1);
}
trades.Insert(0, newTrades[i]);
}
Assert.AreEqual(symbolViewModel.AggregateTrades.Count, trades.Count);
for (int i = 0; i < symbolViewModel.AggregateTrades.Count; i++)
{
Assert.AreEqual(symbolViewModel.AggregateTrades[i].Id, trades[i].Id);
}
}
public async Task SetAccount_OverrideAccount()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var accountViewModel = new OrdersViewModel(exchangeService, new DebugLogger());
var firstAccount = new Account(new Interface.Model.AccountInfo {
User = new Interface.Model.User()
})
{
ApiKey = "apikey",
ApiSecret = "apisecret"
};
accountViewModel.Account = firstAccount;
var firstorder = new Order {
ClientOrderId = "test123", Symbol = "ETHBTC"
};
accountViewModel.Orders.Add(firstorder);
var newAccount = new Account(new Interface.Model.AccountInfo {
User = new Interface.Model.User()
})
{
ApiKey = "newapikey",
ApiSecret = "newapisecret"
};
// Act
await accountViewModel.SetAccount(newAccount);
// Assert
Assert.IsTrue(accountViewModel.Account.ApiKey.Equals(newAccount.ApiKey));
foreach (var order in TestHelper.Orders)
{
Assert.IsNotNull(accountViewModel.Orders.SingleOrDefault(o => o.ClientOrderId.Equals(order.ClientOrderId)));
}
}
public async Task SubscribeStatistics()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var cxlToken = new CancellationToken();
var symbols = await exchangeService.GetSymbols24HourStatisticsAsync(cxlToken).ConfigureAwait(false);
Action <Exception> exception = e => { };
// Act
exchangeService.SubscribeStatistics(symbols, exception, cxlToken);
// Assert
var eth = symbols.Single(s => s.Name.Equals("ETHBTC"));
var updatedEthStats = TestHelper.EthStats_UpdatedLastPrice_Upwards;
Assert.AreEqual(eth.SymbolStatistics.PriceChangePercent, updatedEthStats.PriceChangePercent);
Assert.AreEqual(eth.LastPriceChangeDirection, 1);
Assert.AreEqual(eth.SymbolStatistics.LastPrice, updatedEthStats.LastPrice);
}
public void UpdateOrderBook_SecondUpdate()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var preferences = new Model.Preferences
{
OrderBookChartDisplayCount = 8,
OrderBookDisplayCount = 5
};
var symbolViewModel = new SymbolViewModel(Exchange.Test, exchangeService, chartHelper,
new BinanceOrderBookHelper(),
new TradeHelper(),
preferences, new DebugLogger());
var trx = TestHelper.Trx.GetViewSymbol();
symbolViewModel.Symbol = trx;
var orderBook = new OrderBookUpdateHelper();
var firstOrderBook = orderBook.OrderBook_Trx_GetFirstUpdate();
var secondOrderBook = orderBook.OrderBook_Trx_GetSecondUpdate();
// AppVeyor Hack!!!
if (firstOrderBook.LastUpdateId.Equals(secondOrderBook.LastUpdateId))
{
secondOrderBook.LastUpdateId++;
}
// Act
symbolViewModel.UpdateOrderBook(firstOrderBook);
symbolViewModel.UpdateOrderBook(secondOrderBook);
// Assert
AssertOrderBookUpdate(symbolViewModel, secondOrderBook, preferences);
}
public async Task SelectedOrderType_IsStopLoss_Not_IsLoading()
{
// Arrange
var cxlToken = new CancellationToken();
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var tradeViewModel = new TradeViewModel(exchangeService);
var symbols = await exchangeService.GetSymbols24HourStatisticsAsync(cxlToken);
tradeViewModel.SetSymbols(symbols.ToList());
var trx = tradeViewModel.Symbols.Single(s => s.Name.Equals("TRXBTC"));
tradeViewModel.SelectedSymbol = trx;
// Act
tradeViewModel.SelectedOrderType = "Stop Loss";
// Assert
Assert.IsFalse(tradeViewModel.IsPriceEditable);
Assert.IsTrue(tradeViewModel.IsMarketPrice);
}
public async Task SelectedSymbol_HasAccount()
{
// Arrange
var cxlToken = new CancellationToken();
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var tradeViewModel = new TradeViewModel(exchangeService);
var account = new Account(new Interface.AccountInfo {
User = new Interface.User()
})
{
ApiKey = "apikey",
ApiSecret = "apisecret"
};
account = await exchangeService.GetAccountInfoAsync(account.AccountInfo.User.ApiKey, account.AccountInfo.User.ApiSecret, cxlToken);
var baseBalance = account.Balances.Single(a => a.Asset.Equals("TRX"));
var quoteAsset = account.Balances.Single(a => a.Asset.Equals("BTC"));
tradeViewModel.SetAccount(account);
var symbols = await exchangeService.GetSymbols24HourStatisticsAsync(cxlToken);
tradeViewModel.SetSymbols(symbols.ToList());
var trx = tradeViewModel.Symbols.Single(s => s.Name.Equals("TRXBTC"));
// Act
tradeViewModel.SelectedSymbol = trx;
// Assert
Assert.AreEqual(tradeViewModel.SelectedSymbol, trx);
Assert.AreEqual(tradeViewModel.Quantity, 0);
Assert.AreEqual(tradeViewModel.Price, trx.SymbolStatistics.LastPrice);
Assert.AreEqual(tradeViewModel.StopPrice, trx.SymbolStatistics.LastPrice);
Assert.AreEqual(tradeViewModel.BaseAccountBalance, baseBalance);
Assert.AreEqual(tradeViewModel.QuoteAccountBalance, quoteAsset);
}
public async Task SetSymbol()
{
// Arrange
var cxlToken = new CancellationToken();
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolViewModel = new SymbolViewModel(exchangeService);
var trx = TestHelper.Trx.GetViewSymbol();
// Act
await symbolViewModel.SetSymbol(trx);
// Assert
Assert.AreEqual(symbolViewModel.Symbol, trx);
Assert.IsNotNull(symbolViewModel.OrderBook);
Assert.AreEqual(symbolViewModel.OrderBook.LastUpdateId, TestHelper.OrderBook.LastUpdateId);
Assert.IsNotNull(symbolViewModel.OrderBook.Top);
Assert.IsTrue(symbolViewModel.OrderBook.TopAsks.Count > 0);
Assert.IsTrue(symbolViewModel.OrderBook.TopBids.Count > 0);
Assert.IsTrue(symbolViewModel.AggregateTrades.Count > 0);
}
public void HasQuoteBaseBalance()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var tradeViewModel = new TradeViewModel(exchangeService, new DebugLogger());
var quoteBalance = new AccountBalance {
Free = 299m
};
var baseBalance = new AccountBalance {
Free = 0.000123m
};
// Act
tradeViewModel.QuoteAccountBalance = quoteBalance;
tradeViewModel.BaseAccountBalance = baseBalance;
// Assert
Assert.IsTrue(tradeViewModel.HasBaseBalance);
Assert.IsTrue(tradeViewModel.HasQuoteBalance);
}
public async Task SelectedSymbol_Null()
{
// Arrange
var cxlToken = new CancellationToken();
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var tradeViewModel = new TradeViewModel(exchangeService, new DebugLogger());
var account = new Account(new Interface.Model.AccountInfo {
User = new Interface.Model.User()
})
{
ApiKey = "apikey",
ApiSecret = "apisecret"
};
account = await exchangeService.GetAccountInfoAsync(Exchange.Test, account.AccountInfo.User, cxlToken);
tradeViewModel.SetAccount(account);
var symbols = await exchangeService.GetSymbols24HourStatisticsAsync(Exchange.Test, cxlToken);
tradeViewModel.SetSymbols(symbols.ToList());
var trx = tradeViewModel.Symbols.Single(s => s.Name.Equals("TRXBTC"));
tradeViewModel.SelectedSymbol = trx;
// Act
tradeViewModel.SelectedSymbol = null;
// Assert
Assert.IsNull(tradeViewModel.SelectedSymbol);
Assert.AreEqual(tradeViewModel.Quantity, 0);
Assert.AreEqual(tradeViewModel.Price, 0);
Assert.AreEqual(tradeViewModel.StopPrice, 0);
Assert.IsNull(tradeViewModel.BaseAccountBalance);
Assert.IsNull(tradeViewModel.QuoteAccountBalance);
}
public async Task GetRangeOfOrderTypes()
{
var cxlToken = new CancellationToken();
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var symbols = await exchangeService.GetSymbols24HourStatisticsAsync(Exchange.Test, cxlToken);
var orderTypes = new List <Core.Model.OrderType>();
foreach (var symbol in symbols)
{
foreach (var orderType in symbol.OrderTypes)
{
if (!orderTypes.Contains(orderType))
{
orderTypes.Add(orderType);
}
}
}
Assert.AreEqual(orderTypes.Count, 5);
}
public void HasQuoteBaseBalance_Zero()
{
// Arrange
var cxlToken = new CancellationToken();
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var tradeViewModel = new TradeViewModel(exchangeService);
var quoteBalance = new AccountBalance {
Free = 0m
};
var baseBalance = new AccountBalance {
Free = 0m
};
// Act
tradeViewModel.QuoteAccountBalance = quoteBalance;
tradeViewModel.BaseAccountBalance = baseBalance;
// Assert
Assert.IsFalse(tradeViewModel.HasBaseBalance);
Assert.IsFalse(tradeViewModel.HasQuoteBalance);
}
