public void HttpPost_WhenCorrectTokenAndDescendingSortOptionPassed_ReturnsNameDescendingOKSortedList() { // Arrange string strToken = "e3b5361b-e85c-4c62-85fd-4c9e2af2c053"; string strOption = "Descending"; _mockService.Setup(repo => repo.ProductNameDescending()) .ReturnsAsync(FakeCartItems.GetProductNameDescending); _controller = new SortController(_mockService.Object); // Act _controller = new SortController(_mockService.Object); var okObjectResult = _controller.Post(strToken, strOption); var result = (OkObjectResult)okObjectResult.Result.Result; var list = (List <CartItem>)result.Value; // Assert // the fake cart items list has 9 items // CartItem{Name = "Yogurt", Price = 12.75, Quantity = 1} should be the first item // CartItem{Name = "Apple", Price = 1.90, Quantity = 1} should be the last item // So the first item name must be Lemon and Price 20.00 Assert.IsType <OkObjectResult>(result); Assert.Equal(9, list.Count); Assert.Equal("Yogurt", list[0].Name); Assert.Equal(12.75, list[0].Price); Assert.Equal("Apple", list[8].Name); Assert.Equal(1.90, list[8].Price); }
public void DoNotThrowAWobblyWhenRemovingaMutatedValue() { var pageController = new PageController(); var sortController = new SortController<TestVm>(SortExpressionComparer<TestVm>.Ascending(t => t.DateFavorited ?? DateTime.MinValue)); var filterController = new FilterController<TestVm>(myVm => myVm.Id != 0); var items = new ObservableCollectionExtended<TestVm>(); var itemCache = new SourceCache<TestVm, int>(myVm => myVm.Id); var item1 = new TestVm(1) { DateFavorited = DateTime.Now }; var item2 = new TestVm(2) { DateFavorited = DateTime.Now }; itemCache.AddOrUpdate(item1); itemCache.AddOrUpdate(item2); bool error = false; itemCache.Connect() .Filter(filterController) .Sort(sortController) .Page(pageController)//error doesnt occur with paging disabled .Bind(items) .Subscribe(changes => { }, ex => error = true); pageController.Change(new PageRequest(1, 100)); //NB: never errored if it was the first item which was removed item2.DateFavorited = null; itemCache.Remove(item2); //ERROR! Assert.IsFalse(error, "Error has been thrown"); }
public void HttpPost_WhenCorrectTokenAndHighSortOptionPassed_ReturnsPriceHighToLowOKSortedList() { // Arrange string strToken = "e3b5361b-e85c-4c62-85fd-4c9e2af2c053"; string strOption = "High"; _mockService.Setup(repo => repo.ProductPriceHighToLow()) .ReturnsAsync(FakeCartItems.GetProductPriceHighToLow); _controller = new SortController(_mockService.Object); // Act _controller = new SortController(_mockService.Object); var okObjectResult = _controller.Post(strToken, strOption); var result = (OkObjectResult)okObjectResult.Result.Result; var list = (List <CartItem>)result.Value; // Assert // the fake cart items list has 9 items // CartItem{Name = "Lemon", Price = 20.00, Quantity = 1} is the highest priced item // CartItem{Name = "Apple", Price = 1.90, Quantity = 1} is the lowest priced item // So the first item name must be Lemon and Price 20.00 Assert.IsType <OkObjectResult>(result); Assert.Equal(9, list.Count); Assert.Equal("Lemon", list[0].Name); Assert.Equal(20.00, list[0].Price); }
public bool Route() { HomeView homepage = new HomeView(); var input = Renderer.Render(homepage); string userRequest = input.GetSelectedValue(); switch (userRequest) { case "0": SortController.SortByPerson <Student>(); break; case "1": SortController.SortByPerson <Teacher>(); break; case "2": SortController.SortByPerson <Extern>(); break; case "3": SortController.SortByCourses(); break; case "4": SortController.SortBySchoolYear(); break; case "5": SortController.SortByPromotions(); break; case "6": SortController.SortByDateAsc(); break; case "7": SortController.SortByDateDesc(); break; case "8": SortController.SortByKeywords(); break; case "9": EditController.AddNewProject(); break; case "10": EditController.RemoveProject(); break; default: return(false); } return(true); }
public Move(SortController controller, string originalFilepath, string toFilepath, string[] tags, string note, int fileIndex) : base(controller) { this.originalFilepath = originalFilepath; this.toFilepath = toFilepath; this.tags = tags; this.note = note; this.fileIndex = fileIndex; }
public void NoSpecialCharacterTest() { var sortController = new SortController(); var sortDto = new SortDto() { TextToSort = "Lorem Ipsu@@" }; Assert.IsFalse(sortController.SortText(sortDto).IsSuccessful); }
public void SortController_SortAscendingOrderOfEmpty_ReturnEnpty() { var mockHorseService = new Mock <IHorseResultService>(); mockHorseService.Setup(hs => hs.CombineHorses()) .Returns(new List <Horse>()); var controller = new SortController(mockHorseService.Object); var result = controller.AscendingPriceOrder(); Assert.That(result, Is.Empty); }
public void NoNumberAllowedTest() { var sortController = new SortController(); var sortDto = new SortDto() { SortStrategy = SortStrategy.BUBBLESORT, TextToSort = "Lorem Ipsum123" }; Assert.IsFalse(sortController.SortText(sortDto).IsSuccessful); }
public void InvalidOrNoSortStrategyTest() { var sortController = new SortController(); var sortDto = new SortDto() { TextToSort = "Lorem Ipsum" }; // It should be True because not setting Sort Strategy will have default BUBBLE SORT Assert.IsTrue(sortController.SortText(sortDto).IsSuccessful); }
public void BubbleSortTest() { var sortController = new SortController(); var sortDto = new SortDto() { SortStrategy = SortStrategy.BUBBLESORT, TextToSort = "Lorem Ipsum" }; Assert.AreEqual("ILemmoprsu", sortController.SortText(sortDto).Result); }
public void QuickSortTest() { var sortController = new SortController(); var sortDto = new SortDto() { SortStrategy = SortStrategy.QUICKSORT, TextToSort = "simply" }; Assert.AreEqual("ilmpsy", sortController.SortText(sortDto).Result); }
public void Get_Returns_For_Valid_Options(string sortOption, string expectedFirstName) { // Arrange var productList = new List <ProductDto>() { new ProductDto() { Name = "Product A", Quantity = 1, Price = 1 }, new ProductDto() { Name = "Product B", Quantity = 1, Price = 2 } }; var shopperHistoryDtoList = new List <ShopperHistoryDto>() { new ShopperHistoryDto() { CustomerId = 0, Products = new List <ShopperHistoryProductDto>() { new ShopperHistoryProductDto() { Name = "Product A", Quantity = 10 }, new ShopperHistoryProductDto() { Name = "Product B", Quantity = 20 } } } }; var resourceServiceClient = new Mock <IResourceServiceHttpClient>(); resourceServiceClient .Setup(x => x.GetProducts()) .ReturnsAsync(productList); resourceServiceClient .Setup(x => x.GetShopperHistory()) .ReturnsAsync(shopperHistoryDtoList); var controller = new SortController(resourceServiceClient.Object); // Act var result = controller.Get(sortOption); //Assert Assert.False(result.IsFaulted); Assert.Equal(2, result.Result.Count()); Assert.Equal(expectedFirstName, result.Result.First().Name); Assert.Equal(1, result.Result.First().Quantity); //Assert.Equal(1, result.Result.First().Price); //Assert.Equal(0, result.Result.First().Popularity); }
static void Main(string[] args) { IHorseResultService horseService = new HorseResultService(); var sortController = new SortController(horseService); var sorted = sortController.AscendingPriceOrder(); foreach (var item in sorted) { Console.WriteLine(item); } }
public void Initialise() { _comparer = SortExpressionComparer<Person>.Ascending(p => p.Name).ThenByAscending(p => p.Age); _cache = new SourceCache<Person, string>(p => p.Name); _sortController = new SortController<Person>(_comparer); _results = new SortedChangeSetAggregator<Person, string> ( _cache.Connect().Sort(_sortController) ); }
public void Initialise() { _comparer = SortExpressionComparer <Person> .Ascending(p => p.Name).ThenByAscending(p => p.Age); _cache = new SourceCache <Person, string>(p => p.Name); _sortController = new SortController <Person>(_comparer); _results = new SortedChangeSetAggregator <Person, string> ( _cache.Connect().Sort(_sortController) ); }
public PageWithSortControllerFixture() { _sortController = new SortController <Person>(_originalComparer); _source = new SourceCache <Person, string>(p => p.Key); _pageController = new PageController(new PageRequest(1, 25)); _aggregators = new PagedChangeSetAggregator <Person, string> ( _source.Connect() .Sort(_sortController) .Page(_pageController) ); }
public void Initialise() { _sortController = new SortController<Person>(_originalComparer); _source = new SourceCache<Person, string>(p => p.Key); _pageController = new PageController(new PageRequest(1, 25)); _aggregators = new PagedChangeSetAggregator<Person, string> ( _source.Connect() .Sort(_sortController) .Page(_pageController) ); }
public void ContentEditorControllerTest_Actions_Secured_By_Permissions() { //Arrange var backOfficeRequestContext = GetBackOfficeRequestContext(); var controller = new ContentEditorController(backOfficeRequestContext); controller.InjectDependencies(GetBackOfficeRequestContext()); //TODO: There may be a better way of automatically getting a single controller variable using the controller extenders, //but likely that's just testing the action invoker, so for now here's the individual controllers var copyController = new MoveCopyController(backOfficeRequestContext); copyController.InjectDependencies(GetBackOfficeRequestContext()); var sortController = new SortController(backOfficeRequestContext); sortController.InjectDependencies(GetBackOfficeRequestContext()); var publishController = new PublishController(backOfficeRequestContext); publishController.InjectDependencies(GetBackOfficeRequestContext()); var hos = new HostnameController(backOfficeRequestContext); hos.InjectDependencies(GetBackOfficeRequestContext()); var rollback = new RollbackController(backOfficeRequestContext); rollback.InjectDependencies(GetBackOfficeRequestContext()); var permissions = new PermissionsController(backOfficeRequestContext); permissions.InjectDependencies(GetBackOfficeRequestContext()); //Assert Assert.IsTrue(ActionIsSecuredByPermission(controller, "CreateNew", FixedPermissionIds.Create)); Assert.IsTrue(ActionIsSecuredByPermission(controller, "Edit", FixedPermissionIds.Update)); Assert.IsTrue(ActionIsSecuredByPermission(controller, "Delete", FixedPermissionIds.Delete)); Assert.IsTrue(ActionIsSecuredByPermission(copyController, "Copy", FixedPermissionIds.Copy)); Assert.IsTrue(ActionIsSecuredByPermission(copyController, "Move", FixedPermissionIds.Move)); Assert.IsTrue(ActionIsSecuredByPermission(sortController, "Sort", FixedPermissionIds.Sort)); Assert.IsTrue(ActionIsSecuredByPermission(publishController, "Publish", FixedPermissionIds.Publish)); Assert.IsTrue(ActionIsSecuredByPermission(permissions, "Permissions", FixedPermissionIds.Permissions)); Assert.IsTrue(ActionIsSecuredByPermission(rollback, "Rollback", FixedPermissionIds.Rollback)); // TODO: (APN @ Matt) the assertion for action name doesn't take into account two methods with the same name // but differing parameter counts, so this one fails // NOTE: (MPB) Have renamed post action to HostnameForm to get test passing for now, not sure if that is enough // or whether assertion method should allow you to query for a specific method signature? Assert.IsTrue(ActionIsSecuredByPermission(hos, "Hostname", FixedPermissionIds.Hostnames)); }
public async Task SortController_ReturnsBadRequestResultWhenInValidSortOption(string sortOption) { // Arrange var mockProductService = new Mock <IProductService>(); //Act var controller = new SortController(mockProductService.Object); //Assert var result = await controller.Get(sortOption); Assert.IsInstanceOf(typeof(BadRequestObjectResult), result); }
public void Initialize() { // arrange _exercise2Service = Substitute.For <IExercise2Service>(); List <Product> product = new List <Product>(); product.Add(new Product() { Name = "Jas", Price = 99, Quantity = 1 }); _exercise2Service.SortProducts("High").Returns(product); _sortController = Substitute.ForPartsOf <SortController>(_exercise2Service); }
public WarehouseForm(EmployeeController employeeController, SortController sortController, StorePlaceController storePlaceController, ParcelController parcelController) { _employeeController = employeeController; _sortController = sortController; vehiclesCargoDictionary = new Dictionary <Vehicle, List <ListViewItem> >(); _availableVehicles = new List <Vehicle>(); _availableParcels = new List <ListViewItem>(); _parcels = new List <Parcel>(); _storePlaceController = storePlaceController; _parcelController = parcelController; InitializeComponent(); }
public async Task SortController_ReturnsBadRequestResultWhithoutSortOption() { // Arrange var mockProductService = new Mock <IProductService>(); mockProductService.Setup(s => s.GetAllSorted(SortOptions.Ascending)).Returns(Task.Run(() => fakeProducts)); //Act var controller = new SortController(mockProductService.Object); //Assert var result = await controller.Get(string.Empty); Assert.IsInstanceOf(typeof(BadRequestObjectResult), result); }
public SortForm(DirectoryInfo dirInfo) { InitializeComponent(); //These are here because the designer likes to delete them from the designer file all the time. this.KeyPreview = true; this.ActiveControl = tagSearchTextBox; //this.dirInfo = dirInfo; controller = new SortController(this, dirInfo); sortControllerBindingSource.DataSource = controller; loadingPanel.Hide(); }
public void Get_Faults_For_Invalid_Option() { // Arrange var resourceServiceClient = new Mock <IResourceServiceHttpClient>(); resourceServiceClient .Setup(x => x.GetProducts()) .ReturnsAsync(new List <ProductDto>()); var controller = new SortController(resourceServiceClient.Object); // Act var result = controller.Get("bla"); //Assert Assert.True(result.IsFaulted); }
public TableModel() { rows = new List <RowModel>(); filteredRows = new List <RowModel>(); columns = new List <ColumnModel>(); filters = new List <FilterStruct>(); sorts = new List <SortStruct>(); controller = new TableController(this); sortController = new SortController(this); filterController = new FilterController(this); columnListener = new ColumnChangeListener(this); rowListener = new RowChangeListener(this); nameListener = new NameChangeListener(this); rowDataListener = new RowDataListener(this); }
public MainWindow() { InitializeComponent(); ItemCache = new SourceCache <int, int>(x => x); IntSorter = new IntSorter(); Items = new ObservableCollectionExtended <int>(); SortController = new SortController <int>(IntSorter); for (var i = 0; i < 1000; i++) { ItemCache.AddOrUpdate(i); } DataContext = this; Connect(); }
public void HttpPost_WhenEmptyTokenPassed_ReturnsBadRequestResult() { // Arrange string strToken = string.Empty; string strOption = string.Empty; // Act _controller = new SortController(_mockService.Object); var modelState = _controller.ModelState; var actionResult = _controller.Post(strToken, strOption); var result = (List <Product>)actionResult.Result.Value; // Assert // should return model state error token is required // shoud return 400 BadRequest // List<Product> must be Null Assert.Equal("token is required", modelState["token"].Errors[0].ErrorMessage); Assert.Null(result); }
public PagedDataViewer(ILogger logger, ITradeService tradeService, ISchedulerProvider schedulerProvider) { _logger = logger; //watch for filter changes and change filter var filterController = new FilterController <Trade>(trade => true); var filterApplier = this.ObservePropertyValue(t => t.SearchText) .Throttle(TimeSpan.FromMilliseconds(250)) .Select(propargs => BuildFilter(propargs.Value)) .Subscribe(filterController.Change); //watch for changes to sort and apply when necessary var sortContoller = new SortController <TradeProxy>(SortExpressionComparer <TradeProxy> .Ascending(proxy => proxy.Id)); var sortChange = SortParameters.ObservePropertyValue(t => t.SelectedItem).Select(prop => prop.Value.Comparer) .ObserveOn(schedulerProvider.TaskPool) .Subscribe(sortContoller.Change); //watch for page changes and change filter var pageController = new PageController(); var currentPageChanged = PageParameters.ObservePropertyValue(p => p.CurrentPage).Select(prop => prop.Value); var pageSizeChanged = PageParameters.ObservePropertyValue(p => p.PageSize).Select(prop => prop.Value); var pageChanger = currentPageChanged.CombineLatest(pageSizeChanged, (page, size) => new PageRequest(page, size)) .DistinctUntilChanged() .Sample(TimeSpan.FromMilliseconds(100)) .Subscribe(pageController.Change); // filter, sort, page and bind to loaded data var loader = tradeService.All.Connect() .Filter(filterController) // apply user filter .Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5)) .Sort(sortContoller, SortOptimisations.ComparesImmutableValuesOnly) .Page(pageController) .ObserveOn(schedulerProvider.MainThread) .Do(changes => _pageParameters.Update(changes.Response)) .Bind(_data) // update observable collection bindings .DisposeMany() //since TradeProxy is disposable dispose when no longer required .Subscribe(); _cleanUp = new CompositeDisposable(loader, filterController, filterApplier, sortChange, sortContoller, pageChanger, pageController); }
static void Main(string[] args) { var ItemCache = new SourceCache <string, string>(x => x); var ItemsSorter = new ItemSorter(); var FilterController = new FilterController <string>(FilterFunc); var SortController = new SortController <string>(ItemsSorter); var FilteredCache = ItemCache.Connect() .Filter(FilterController) .AsObservableCache(); var Connected = FilteredCache .Connect() .Sort(SortController) .Bind(Items) .Subscribe(); ItemCache.AddOrUpdate("wtf"); Console.ReadLine(); }
public async Task TrolleyTotal_WhenDataIsFound_ShouldReturn_OKSuccess() { var logger = Mock.Of <ILogger <SortController> >(); var mapper = new Mock <IMapper>(); mapper.Setup(x => x.Map <ProductSortOption>(It.IsAny <SortOption>())) .Returns(It.IsAny <ProductSortOption>()); var mediator = new Mock <IMediator>(); mediator.Setup(x => x.Send(It.IsAny <GetSortedProductsQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(new List <GetSortedProductsQuery.SortedProductViewModel> { new GetSortedProductsQuery.SortedProductViewModel { Name = "a", Price = 1.0M, Quantity = 1 }, new GetSortedProductsQuery.SortedProductViewModel { Name = "b", Price = 1.0M, Quantity = 2 } }); var controller = new SortController(mediator.Object, mapper.Object, logger) { ControllerContext = new ControllerContext { HttpContext = new DefaultHttpContext() } }; var response = await controller.Sort(It.IsAny <SortOption>()); response.ShouldNotBeNull(); response.ShouldBeOfType <OkObjectResult>(); var data = response as OkObjectResult; var products = data.Value as IEnumerable <GetSortedProductsQuery.SortedProductViewModel>; products.ShouldNotBeNull(); products.Count().ShouldBe(2); }
public PagedDataViewer(ILogger logger, ITradeService tradeService, ISchedulerProvider schedulerProvider) { _logger = logger; //watch for filter changes and change filter var filterController = new FilterController<Trade>(trade => true); var filterApplier = this.ObservePropertyValue(t => t.SearchText) .Throttle(TimeSpan.FromMilliseconds(250)) .Select(propargs => BuildFilter(propargs.Value)) .Subscribe(filterController.Change); //watch for changes to sort and apply when necessary var sortContoller = new SortController<TradeProxy>(SortExpressionComparer<TradeProxy>.Ascending(proxy=>proxy.Id)); var sortChange = SortParameters.ObservePropertyValue(t => t.SelectedItem).Select(prop=>prop.Value.Comparer) .ObserveOn(schedulerProvider.TaskPool) .Subscribe(sortContoller.Change); //watch for page changes and change filter var pageController = new PageController(); var currentPageChanged = PageParameters.ObservePropertyValue(p => p.CurrentPage).Select(prop => prop.Value); var pageSizeChanged = PageParameters.ObservePropertyValue(p => p.PageSize).Select(prop => prop.Value); var pageChanger = currentPageChanged.CombineLatest(pageSizeChanged,(page, size) => new PageRequest(page, size)) .DistinctUntilChanged() .Sample(TimeSpan.FromMilliseconds(100)) .Subscribe(pageController.Change); // filter, sort, page and bind to loaded data var loader = tradeService.All .Connect() .Filter(filterController) // apply user filter .Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5)) .Sort(sortContoller, SortOptimisations.ComparesImmutableValuesOnly) .Page(pageController) .ObserveOn(schedulerProvider.MainThread) .Do(changes => _pageParameters.Update(changes.Response)) .Bind(_data) // update observable collection bindings .DisposeMany() //since TradeProxy is disposable dispose when no longer required .Subscribe(); _cleanUp = new CompositeDisposable(loader, filterController, filterApplier, sortChange,sortContoller, pageChanger, pageController); }
public void HttpPost_WhenCorrectTokenAndEmptySortOptionPassed_ReturnsBadRequestResult() { // Arrange string strToken = "e3b5361b-e85c-4c62-85fd-4c9e2af2c053"; string strOption = string.Empty; // Act _controller = new SortController(_mockService.Object); var badRequestResult = _controller.Post(strToken, strOption); var modelState = _controller.ModelState; var result = (List <Product>)badRequestResult.Result.Value; // Assert // should return model state error sort option required // shoud return 400 BadRequest // List<Product> must be Null Assert.Equal("sort option required", modelState["sortoption"].Errors[0].ErrorMessage); Assert.Null(result); }
public void HttpPost_WhenCorrectToken_And_InCorrectSortOptionPassed_ReturnsBadRequestResult() { // Arrange string strToken = "e3b5361b-e85c-4c62-85fd-4c9e2af2c053"; string strOption = "LowHigh"; // Act _controller = new SortController(_mockService.Object); var badRequestResult = _controller.Post(strToken, strOption); var modelState = _controller.ModelState; var result = (List <Product>)badRequestResult.Result.Value; // Assert // should return model state error invalid sort option // should return model state error low, high, ascending, descending and recommended // shoud return 400 BadRequest // List<Product> must be Null Assert.Equal("low, high, ascending, descending and recommended", modelState["expected"].Errors[0].ErrorMessage); Assert.Equal("invalid sort option", modelState["sortoption"].Errors[0].ErrorMessage); Assert.Null(result); }
public void SortController_SortAscendingOrderTwoItems_ReturnCorrectOrder() { var mockHorseService = new Mock <IHorseResultService>(); mockHorseService.Setup(hs => hs.CombineHorses()) .Returns( new List <Horse>() { new Horse() { Price = "10", Name = "horse1" }, new Horse() { Price = "12", Name = "horse2" } }); var controller = new SortController(mockHorseService.Object); var result = controller.AscendingPriceOrder(); var expectedResult = new string[] { "horse1", "horse2" }; Assert.That(result, Is.EqualTo(expectedResult)); }