コード例 #1
0
        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);
        }
コード例 #2
0
        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");
        }
コード例 #3
0
        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);
        }
コード例 #4
0
ファイル: App.cs プロジェクト: hast0n/ProjetProgAvENSC1A
        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);
        }
コード例 #5
0
ファイル: Move.cs プロジェクト: Issung/SorterExpress
 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;
 }
コード例 #6
0
        public void NoSpecialCharacterTest()
        {
            var sortController = new SortController();
            var sortDto        = new SortDto()
            {
                TextToSort = "Lorem Ipsu@@"
            };

            Assert.IsFalse(sortController.SortText(sortDto).IsSuccessful);
        }
コード例 #7
0
        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);
        }
コード例 #8
0
        public void NoNumberAllowedTest()
        {
            var sortController = new SortController();
            var sortDto        = new SortDto()
            {
                SortStrategy = SortStrategy.BUBBLESORT,
                TextToSort   = "Lorem Ipsum123"
            };

            Assert.IsFalse(sortController.SortText(sortDto).IsSuccessful);
        }
コード例 #9
0
        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);
        }
コード例 #10
0
        public void BubbleSortTest()
        {
            var sortController = new SortController();
            var sortDto        = new SortDto()
            {
                SortStrategy = SortStrategy.BUBBLESORT,
                TextToSort   = "Lorem Ipsum"
            };

            Assert.AreEqual("ILemmoprsu", sortController.SortText(sortDto).Result);
        }
コード例 #11
0
        public void QuickSortTest()
        {
            var sortController = new SortController();
            var sortDto        = new SortDto()
            {
                SortStrategy = SortStrategy.QUICKSORT,
                TextToSort   = "simply"
            };

            Assert.AreEqual("ilmpsy", sortController.SortText(sortDto).Result);
        }
コード例 #12
0
        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);
        }
コード例 #13
0
        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);
            }
        }
コード例 #14
0
        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)
                );
        }
コード例 #15
0
        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)
                       );
        }
コード例 #16
0
 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)
                       );
 }
コード例 #17
0
		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)
				);
		}
コード例 #18
0
        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));
        }
コード例 #19
0
        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);
        }
コード例 #20
0
        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);
        }
コード例 #21
0
ファイル: WarehouseForm.cs プロジェクト: kamiljan199/IOP
 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();
 }
コード例 #22
0
        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);
        }
コード例 #23
0
        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();
        }
コード例 #24
0
        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);
        }
コード例 #25
0
        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);
        }
コード例 #26
0
        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();
        }
コード例 #27
0
        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);
        }
コード例 #28
0
        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);
        }
コード例 #29
0
        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);
        }
コード例 #31
0
        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);
        }
コード例 #32
0
        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);
        }
コード例 #33
0
        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);
        }
コード例 #34
0
        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));
        }