public void UpdateOrderBook_SecondUpdate()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var preferences = new Model.Preferences();
preferences.OrderBookChartDisplayCount = 8;
preferences.OrderBookDisplayCount = 5;
var symbolViewModel = new SymbolViewModel(exchangeService, chartHelper, preferences, new DebugLogger());
var trx = TestHelper.Trx.GetViewSymbol();
symbolViewModel.Symbol = trx;
var firstOrderBook = OrderBookUpdateHelper.OrderBook_Trx_GetFirstUpdate();
var secondOrderBook = OrderBookUpdateHelper.OrderBook_Trx_GetSecondUpdate();
// Act
symbolViewModel.UpdateOrderBook(firstOrderBook);
symbolViewModel.UpdateOrderBook(secondOrderBook);
// Assert
AssertOrderBookUpdate(symbolViewModel, secondOrderBook, preferences);
}
public async Task BuyQuantity_SufficientFunds()
{
// 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 Interface.Model.AccountInfo {
User = new Interface.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;
// Act
tradeViewModel.BuyQuantityCommand.Execute(75);
// Assert
Assert.IsTrue(tradeViewModel.Quantity.Equals(10));
}
public async Task GetMultipleBalancesUDTValue_BTC_BNB()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.Standard);
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolsCache = SymbolsCacheHelper.GetSymbolsCache(exchangeService);
var symbols = await symbolsCache.GetSymbols(new[] { "BNBBTC" });
var balances = new List <Interface.Model.AccountBalance>();
balances.Add(new Interface.Model.AccountBalance {
Asset = "BTC", Free = 0.00396715m
});
balances.Add(new Interface.Model.AccountBalance {
Asset = "BNB", Free = 0.94444141m
});
var accountInfo = new Interface.Model.AccountInfo
{
Balances = balances
};
var account = new Account(accountInfo);
// Act
symbolsCache.ValueAccount(account);
// Assert
Assert.AreEqual(account.USDTValue, 50.51m);
Assert.AreEqual(account.BTCValue, 0.00534226m);
}
public async Task AccountPreferences()
{
// Arrange
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 userData = File.ReadAllText("UserAccounts.txt");
var accounts = JsonConvert.DeserializeObject <UserAccounts>(userData);
var account = accounts.Accounts.First();
// Act
await symbolsViewModel.SetAccount(account);
await Task.Delay(1000);
// Assert
var favourites = from s in symbolsViewModel.Symbols
join f in account.Preferences.FavouriteSymbols on s.Name equals f
select s;
foreach (var favourite in favourites)
{
Assert.IsNotNull(symbolsViewModel.Symbols.First(s => s.Name.Equals(favourite.Name)));
}
Assert.AreEqual(symbolsViewModel.SelectedSymbol.Name, account.Preferences.SelectedSymbol);
}
public async Task GetSingleBalanceUDTValue_BNB()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.Standard);
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolsCache = SymbolsCacheHelper.GetSymbolsCache(exchangeService);
var symbols = await symbolsCache.GetSymbols(new[] { "BNBBTC" });
var balances = new List <Interface.Model.AccountBalance>();
balances.Add(new Interface.Model.AccountBalance {
Asset = "BNB", Free = 1.88373641m
});
var accountInfo = new Interface.Model.AccountInfo
{
Balances = balances
};
var account = new Account(accountInfo);
// Act
symbolsCache.ValueAccount(account);
// Assert
Assert.AreEqual(account.USDTValue, 25.93m);
Assert.AreEqual(account.BTCValue, 0.00274272m);
}
public async Task SetSymbol()
{
// Arrange
var preferences = new Model.Preferences();
preferences.OrderBookChartDisplayCount = 8;
preferences.OrderBookDisplayCount = 5;
preferences.TradesDisplayCount = 5;
preferences.TradesChartDisplayCount = 8;
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolViewModel = new SymbolViewModel(Exchange.Test, exchangeService, chartHelper,
new BinanceOrderBookHelper(),
new TradeHelper(),
preferences, new DebugLogger());
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.IsTrue(symbolViewModel.OrderBook.TopAsks.Count > 0);
Assert.IsTrue(symbolViewModel.OrderBook.TopBids.Count > 0);
Assert.IsTrue(symbolViewModel.Trades.Count > 0);
}
public void UpdateOrderBook_FirstUpdate()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var preferences = new Model.Preferences();
preferences.OrderBookChartDisplayCount = 8;
preferences.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 orderBook1 = new OrderBookUpdateHelper();
var orderBook = orderBook1.OrderBook_Trx_GetFirstUpdate();
// Act
symbolViewModel.UpdateOrderBook(orderBook);
// Assert
AssertOrderBookUpdate(symbolViewModel, orderBook, preferences);
}
public void UpdateTrades_Second_Update_3_New_Trades()
{
// Arrange
var preferences = new Model.Preferences();
preferences.OrderBookChartDisplayCount = 8;
preferences.OrderBookDisplayCount = 5;
preferences.TradesDisplayCount = 5;
preferences.TradesChartDisplayCount = 8;
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
AssertTradeUpdate(symbolViewModel, preferences, secondTrades);
}
public async Task GetSingleBalanceUDTValue_BTC()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.Standard);
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolsCache = SymbolsCacheHelper.GetSymbolsCache(exchangeService);
var symbols = await symbolsCache.GetSymbols();
var balances = new List <Interface.AccountBalance>();
balances.Add(new Interface.AccountBalance {
Asset = "BTC", Free = 0.00794722m
});
var accountInfo = new Interface.AccountInfo
{
Balances = balances
};
var account = new Account(accountInfo);
// Act
symbolsCache.ValueAccount(account);
// Assert
Assert.AreEqual(account.USDTValue, 64.84m);
Assert.AreEqual(account.BTCValue, 0.00794722m);
}
public async Task GetSingleBalanceUDTValue_BTC()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.Standard);
var exchangeService = new WpfExchangeService(exchangeApi);
var symbolsCache = SymbolsCacheHelper.GetSymbolsCache(exchangeService);
await symbolsCache.GetSymbols(new[] { "BNBBTC" });
var balances = new List <Core.Model.AccountBalance>
{
new Core.Model.AccountBalance {
Asset = "BTC", Free = 0.00794722m
}
};
var accountInfo = new Core.Model.AccountInfo();
accountInfo.Balances.AddRange(balances);
var account = new Account(accountInfo);
// Act
symbolsCache.ValueAccount(account);
// Assert
Assert.AreEqual(account.USDTValue, 75.14m);
Assert.AreEqual(account.BTCValue, 0.00794722m);
}
public async Task Quantity_and_Price_and_StopPrice_NoTrim()
{
// 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;
var quantity = 294m;
var price = 1.12345678m;
// Act
tradeViewModel.Quantity = quantity;
tradeViewModel.Price = price;
tradeViewModel.StopPrice = price;
// Assert
Assert.AreEqual(tradeViewModel.Quantity, quantity.Trim(trx.QuantityPrecision));
Assert.AreEqual(tradeViewModel.Price, price.Trim(trx.PricePrecision));
Assert.AreEqual(tradeViewModel.StopPrice, price.Trim(trx.PricePrecision));
}
public async Task SetAccount()
{
// 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"));
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);
// Act
tradeViewModel.SetAccount(account);
// Assert
Assert.AreEqual(tradeViewModel.Account, account);
Assert.AreEqual(tradeViewModel.SelectedOrderType, null);
Assert.IsNull(tradeViewModel.SelectedSymbol);
}
public async Task UpdateOrders()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.UpdateOrders);
var exchangeService = new WpfExchangeService(exchangeApi);
var accountViewModel = new OrdersViewModel(exchangeService, new DebugLogger());
var account = new Account(new Interface.Model.AccountInfo {
User = new Interface.Model.User()
})
{
ApiKey = "apikey",
ApiSecret = "apisecret"
};
accountViewModel.Account = account;
foreach (var order in TestHelper.Orders)
{
accountViewModel.Orders.Add(order.GetViewOrder());
}
//Act
await accountViewModel.UpdateOrders(account);
// Assert
foreach (var order in accountViewModel.Orders)
{
Assert.AreEqual(order.ExecutedQuantity, Math.Round(order.OriginalQuantity * 0.5m, 0));
Assert.AreEqual(order.FilledPercent, (int)((order.ExecutedQuantity / order.OriginalQuantity) * 100));
}
}
public async Task OrderTypes_SelectedSymbol()
{
// 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"));
tradeViewModel.SetSymbols(symbols.ToList());
tradeViewModel.SelectedSymbol = trx;
// Act
var orderTypes = tradeViewModel.OrderTypes;
// Assert
Assert.AreEqual(tradeViewModel.SelectedSymbol, trx);
var missing = InterfaceExtensions.OrderExtensions.OrderTypes().Except(tradeViewModel.OrderTypes).ToList();
foreach (var orderType in missing)
{
if (orderType != InterfaceExtensions.OrderExtensions.GetOrderTypeName(Interface.OrderType.StopLoss) &&
orderType != InterfaceExtensions.OrderExtensions.GetOrderTypeName(Interface.OrderType.TakeProfit))
{
Assert.Fail();
}
}
}
public async Task SetAccount_NullAccount()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var accountViewModel = new OrdersViewModel(exchangeService, new DebugLogger());
var account = new Account(new Interface.Model.AccountInfo {
User = new Interface.Model.User()
})
{
ApiKey = "apikey",
ApiSecret = "apisecret"
};
accountViewModel.Account = account;
foreach (var order in TestHelper.Orders)
{
accountViewModel.Orders.Add(order.GetViewOrder());
}
//Act
await accountViewModel.SetAccount(null);
// Assert
Assert.IsNull(accountViewModel.Account);
Assert.IsTrue(accountViewModel.Orders.Count().Equals(0));
}
public async Task SellQuantity()
{
// 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);
// Act
tradeViewModel.SellQuantityCommand.Execute(75);
// Assert
Assert.IsTrue(tradeViewModel.Quantity.Equals((selectedAsset.Free * 0.75m).Trim(trx.QuantityPrecision)));
}
public async Task SetAccount_NewAccount()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var accountViewModel = new OrdersViewModel(exchangeService, new DebugLogger());
var account = new Account(new Interface.Model.AccountInfo {
User = new Interface.Model.User()
})
{
ApiKey = "apikey",
ApiSecret = "apisecret"
};
//Act
await accountViewModel.SetAccount(account);
// Assert
Assert.AreEqual(accountViewModel.Account, account);
foreach (var order in TestHelper.Orders)
{
Assert.IsNotNull(accountViewModel.Orders.SingleOrDefault(o => o.ClientOrderId.Equals(order.ClientOrderId)));
}
}
public async Task SymbolsViewModel_Initialise()
{
// Arrange
var fail = false;
var exchangeApi = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.SymbolsViewModel);
var exchangeService = new WpfExchangeService(exchangeApi);
// Act
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.Symbols != null)
{
// expected
}
else
{
fail = true;
}
});
await Task.Delay(1000);
// Assert
Assert.AreEqual(symbolsViewModel.Symbols.Count, TestHelper.Symbols.Count);
Assert.IsNull(symbolsViewModel.AccountPreferences);
Assert.IsNull(symbolsViewModel.SelectedSymbol);
Assert.IsFalse(fail);
}
public async Task SubscribeStatistics()
{
// Arrange
var exchangeApi = ExchangeServiceHelper.GetExchangeService();
var exchangeService = new WpfExchangeService(exchangeApi);
var cxlToken = new CancellationToken();
var symbols = await exchangeService.GetSymbols24HourStatisticsAsync(Exchange.Test, cxlToken).ConfigureAwait(false);
public async Task Login_AccountInfo_Update()
{
// Arrange
var fail = false;
var hasUpdated = false;
string errorMessage = string.Empty;
var exchangeApi = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.SubscribeAccountInfo);
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"
};
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))
{
// expected
}
else if (args.AccountEventType.Equals(AccountEventType.UpdateOrders))
{
hasUpdated = true;
}
else
{
fail = true;
}
});
// Act
await accountViewModel.Login(account);
// Assert
var btc = accountViewModel.Account.Balances.SingleOrDefault(ab => ab.Asset.Equals("BTC"));
var bcpt = accountViewModel.Account.Balances.SingleOrDefault(ab => ab.Asset.Equals("BCPT"));
var test = accountViewModel.Account.Balances.SingleOrDefault(ab => ab.Asset.Equals("TEST"));
Assert.IsTrue(hasUpdated);
Assert.IsNull(btc);
Assert.IsNull(bcpt);
Assert.IsNotNull(test);
Assert.IsTrue(accountViewModel.Account.Balances.Count().Equals(5));
Assert.IsFalse(fail);
}
public async Task Buy_Fails_PlaceOrder()
{
// Arrange
var cxlToken = new CancellationToken();
var exchangeApi = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.PlaceOrderException);
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.QuoteAccountBalance.Free = 0.00012693M;
tradeViewModel.SelectedOrderType = "Limit";
tradeViewModel.Quantity = 200m;
tradeViewModel.Price = 0.00000900M;
tradeViewModel.QuoteAccountBalance.Free = 200m * 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("failed to place order"));
}
public async Task Sell_Pass()
{
// 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.Quantity = tradeViewModel.BaseAccountBalance.Free;
tradeViewModel.Price = 0.00000850M;
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.SellCommand.Execute(null);
// Assert
Assert.IsNull(ex);
}
public void UpdateTrades_Second_Update_3_New_Trades_Less_Than_Limit()
{
// 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);
// 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.Any())
{
// 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 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 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);
}
