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);
        }
Example #2
0
        public void ShowSymbols(UserAccount userAccount)
        {
            using var viewModel = new SymbolsViewModel(exchangeService, userAccount, logger);
            var view = new SymbolsView(viewModel);

            view.ShowDialog();
        }
Example #3
0
        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);
        }
Example #4
0
 public ShellViewModel(AddSymbolViewModel addSymbol, SymbolsViewModel symbols, StatusViewModel status, AutoRefreshViewModel autoRefresh, QuotesViewModel quotes)
 {
     AddSymbol   = addSymbol;
     Symbols     = symbols;
     Status      = status;
     Quotes      = quotes;
     AutoRefresh = autoRefresh;
 }
        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);
        }
Example #6
0
        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);
        }
Example #7
0
        public async Task SelectedSymbol()
        {
            // Arrange
            var    fail             = false;
            Symbol selectedSymbol   = null;
            var    exchangeApi      = ExchangeServiceHelper.GetExchangeService(ExchangeServiceType.SymbolsViewModel);
            var    exchangeService  = new WpfExchangeService(exchangeApi);
            var    symbolsCache     = SymbolsCacheHelper.GetSymbolsCache(exchangeService);
            var    symbolsViewModel = new SymbolsViewModel(exchangeService, symbolsCache, 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;
                }
            });

            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);
        }
Example #8
0
        public SymbolsView(SymbolsViewModel symbolsViewModel)
        {
            InitializeComponent();

            DataContext = symbolsViewModel;
        }