public void OnNavigatingTo_Search_Results_Page_Without_Search_Term()
        {
            var repository = new MockProductCatalogRepository();
            repository.GetFilteredProductsAsyncDelegate = (queryString, maxResults) =>
            {
                Collection<Product> products;
                if (queryString == "bike")
                    products = new Collection<Product>(new List<Product>
                        {
                            new Product(){Title = "bike1", ProductNumber = "1", ImageUri = new Uri("http://image")},
                            new Product(){Title = "bike2", ProductNumber = "2", ImageUri = new Uri("http://image")}
                        });
                else
                {
                    products = new Collection<Product>(new List<Product>
                        {
                            new Product(){Title = "bike1", ProductNumber = "1", ImageUri = new Uri("http://image")},
                            new Product(){Title = "bike2", ProductNumber = "2", ImageUri = new Uri("http://image")},
                            new Product(){Title = "product3", ProductNumber = "3", ImageUri = new Uri("http://image")}
                        });
                }

                return Task.FromResult(new SearchResult(3, products));
            };

            var target = new SearchResultsPageViewModel(repository, new MockResourceLoader(), new MockAlertMessageService());
            var searchTerm = string.Empty;
            target.OnNavigatedTo(new NavigatedToEventArgs { Parameter = searchTerm, NavigationMode = NavigationMode.New }, null);
            Assert.AreEqual(string.Empty, target.SearchTerm);
            Assert.IsNotNull(target.Results);
            Assert.AreEqual(3, target.Results.Count);
        }
        public void OnNavigatedTo_When_Service_Not_Available_Then_Pops_Alert()
        {
            var repository = new MockProductCatalogRepository();
            var alertService = new MockAlertMessageService();
            var resourceLoader = new MockResourceLoader();

            bool alertCalled = false;
            repository.GetProductAsyncDelegate = (productNumber) =>
                {
                    throw new Exception();
                };

            repository.GetProductsAsyncDelegate = (subCategoryId) =>
                {
                    throw new Exception();
                };

            alertService.ShowAsyncDelegate = (msg, title) =>
                {
                    alertCalled = true;
                    return Task.FromResult(string.Empty);
                };

            var target = new ItemDetailPageViewModel(repository, new MockShoppingCartRepository(), alertService, resourceLoader, null);
            target.OnNavigatedTo(new NavigatedToEventArgs { Parameter = "1", NavigationMode = NavigationMode.New }, null);

            Assert.IsTrue(alertCalled);
        }
        public void OnNavigatedTo_Fill_Items_And_SelectedProduct()
        {
            var repository = new MockProductCatalogRepository();

            repository.GetProductAsyncDelegate = (productNumber) =>
                {
                    Product product = null;

                    if (productNumber == "1")
                    {
                        product = new Product { ProductNumber = productNumber, SubcategoryId = 1 };
                    }

                    return Task.FromResult(product);
                };

            repository.GetProductsAsyncDelegate = (subCategoryId) =>
                {
                    ICollection<Product> products = null;

                    if (subCategoryId == 1)
                    {
                        products = new Collection<Product>(new List<Product>
                        {
                            new Product(){ ProductNumber = "1", ImageUri = new Uri("http://image") },
                            new Product(){ ProductNumber = "2", ImageUri = new Uri("http://image") },
                            new Product(){ ProductNumber = "3", ImageUri = new Uri("http://image") }
                        });
                    }

                    return Task.FromResult(products);
                };

            var secondaryTileService = new MockSecondaryTileService() { SecondaryTileExistsDelegate = s => false};

            var target = new ItemDetailPageViewModel(repository, new MockShoppingCartRepository(), null, null, secondaryTileService);
            target.OnNavigatedTo(new NavigatedToEventArgs { Parameter = "1", NavigationMode = NavigationMode.New }, null);

            Assert.IsNotNull(target.Items);
            Assert.AreEqual(3, ((IReadOnlyCollection<ProductViewModel>)target.Items).Count);
            Assert.AreEqual(target.Items.First(), target.SelectedProduct);
        }
        public void OnNavigatedTo_Fill_Items_And_Title()
        {
            var repository = new MockProductCatalogRepository();

            repository.GetCategoryAsyncDelegate = (categoryId) =>
            {
                Category category = null;

                if (categoryId == 1)
                {
                    category = new Category { Id = categoryId,
                        Title = "CategoryTitle"
                    };
                }

                return Task.FromResult(category);
            };
            repository.GetProductsAsyncDelegate = i =>
            {
                ICollection<Product> products = null;
                if (i == 1)
                {
                    products = new Collection<Product>(new List<Product>
                                    {
                                        new Product(),
                                        new Product(),
                                        new Product()
                                    });
                }
                return Task.FromResult(products);
            };

           var viewModel = new GroupDetailPageViewModel(repository, null, null);
            viewModel.OnNavigatedTo(new NavigatedToEventArgs { Parameter = 1, NavigationMode = NavigationMode.New }, null);

            Assert.IsNotNull(viewModel.Items);
            Assert.AreEqual(3, ((ICollection<ProductViewModel>)viewModel.Items).Count);
            Assert.AreEqual("CategoryTitle", viewModel.Title);
        }
 public void FailedCallToProductCatalogRepository_ShowsAlert()
 {
     var alertCalled = false;
     var productCatalogRepository = new MockProductCatalogRepository();
     var navService = new MockNavigationService();
     productCatalogRepository.GetRootCategoriesAsyncDelegate = (maxAmmountOfProducts) =>
     {
         throw new Exception();
     };
     var alertMessageService = new MockAlertMessageService();
     alertMessageService.ShowAsyncDelegate = (s, s1) =>
     {
         alertCalled = true;
         Assert.AreEqual("ErrorServiceUnreachable", s1);
         return Task.FromResult(string.Empty);
     };
     var target = new HubPageViewModel(productCatalogRepository, navService,
                                                          alertMessageService, new MockResourceLoader());
     target.OnNavigatedTo(new NavigatedToEventArgs { Parameter = null, NavigationMode = NavigationMode.New }, null);
     
     Assert.IsTrue(alertCalled);
 }
        public void OnNavigatedTo_Fill_RootCategories()
        {
            var repository = new MockProductCatalogRepository();
            var navigationService = new MockNavigationService();

            repository.GetRootCategoriesAsyncDelegate = (maxAmmountOfProducts) =>
            {
                var categories = new Collection<Category>(new List<Category>{
                    new Category(),
                    new Category(),
                    new Category()
                });

                return Task.FromResult((ICollection<Category>)categories);
            };

            var viewModel = new HubPageViewModel(repository, navigationService, null, null);
            viewModel.OnNavigatedTo(new NavigatedToEventArgs { Parameter = null, NavigationMode = NavigationMode.New }, null);

            Assert.IsNotNull(viewModel.RootCategories);
            Assert.AreEqual(((ICollection<CategoryViewModel>)viewModel.RootCategories).Count, 3);
        }