public DogSearchManagerTests()
 {
     _dogBreedFilterStrategy = MockRepository.GenerateMock<IDogBreedFilterStrategy>();
                     _dogCategoryFilterStrategy = MockRepository.GenerateMock<IDogCategoryFilterStrategy>();
                     _dogCategoryService = MockRepository.GenerateMock<IDogCategoryService>();
                     _dogLocationFilterStrategy = MockRepository.GenerateMock<IDogLocationFilter>();
                     _configuration = MockRepository.GenerateMock<IConfiguration>();
                     _dogSearchResultsListBuilder = new DogSearchResultsListBuilder();
 }
        public void AddDogsInSameCategoryToDogsCollection_when_appending_dogs_in_same_category_then_there_are_no_duplicates_returned()
        {
            // arrange
            var dogSearchResultsListBuilder = new DogSearchResultsListBuilder();
            var dogsMatchingByBreed = dogSearchResultsListBuilder.ListOfThreeDuplicateDogs(_categoryId, _breedIdDalmatian).Build().AsQueryable();
            var dogCategoryService = new DogCategoryService(_configuration, _breedsRepository, _dogCategoryFilterStrategy);

            // act
            var results = dogCategoryService.AddDogsInSameCategoryToDogsCollection(dogsMatchingByBreed, _breedIdDalmatian);

            // assert
            Assert.That(results.Count(), Is.EqualTo(4));
        }
        public void AddDogsInSameCategoryToDogsCollection_place_matching_dogs_above_dogs_in_same_category()
        {
            // arrange
            var dogSearchResultsListBuilder = new DogSearchResultsListBuilder();
            var dogsMatchingByBreed = dogSearchResultsListBuilder.ListOf3DalmatiansByCategory(_categoryId, _breedIdDalmatian).Build().AsQueryable();
            var dogCategoryService = new DogCategoryService(_configuration, _breedsRepository, _dogCategoryFilterStrategy);

            // act
            var results = dogCategoryService.AddDogsInSameCategoryToDogsCollection(dogsMatchingByBreed, _breedIdDalmatian);

            // assert
            Assert.That(results.First().Breed.Id == _breedIdDalmatian);
            Assert.That(results.Last().Breed.Id == _breedIdBeagel);
        }
        public void Get_Paged_With_Breed_Returns_Correct_Search_Description()
        {
            // arrange
              const int breedId = 3;
              const int page = 2;
              const int pageSize = 5;

              var dogsList = new DogSearchResultsListBuilder().ListOf14Beagels().Build();

              _dogSearchhelper.Stub(x => x.GetDogsByBreed(breedId)).Return(dogsList);

              _dogSearchhelper.Stub(x => x.ApplyDogLocationFilteringAndSorting(Arg<IQueryable<Dog>>.Is.Anything, Arg<int>.Is.Anything,
            Arg<string>.Is.Anything, Arg<int>.Is.Anything)).Return(dogsList);

              var dogsController = new DogsController(_dogsRepository, _breedsRepository, _unitofWork, _dogSearchhelper, _configuration, _placesRepository);

              //act
              var result = dogsController.GetPagedByBreed(page, pageSize, breedId, SearchSortOptions.PRICE_HIGHEST);

              Assert.That(result.SearchDescription, Is.EqualTo("Showing results 6 to 10 out of 14 results for Beagel nationwide"));
        }
        public void AddDogsInSameCategoryToDogsCollection_when_no_matching_dogs_then_return_dogs_in_category()
        {
            // arrange
            var dogSearchResultsListBuilder = new DogSearchResultsListBuilder();
            var dogsMatchingByBreedEmptyList = new List<Dog>().AsQueryable();
            var dogCategoryService = new DogCategoryService(_configuration, _breedsRepository, _dogCategoryFilterStrategy);

            // act
            var results = dogCategoryService.AddDogsInSameCategoryToDogsCollection(dogsMatchingByBreedEmptyList, _breedIdDalmatian);

            // assert
            Assert.That(results.Count(), Is.EqualTo(3));
        }
        public void Setup()
        {
            var dogSearchResultsListBuilder = new DogSearchResultsListBuilder();

            _configuration.Stub(x => x.GetSearchResultsMinimumMatchingNumber()).Return(_searchResultsMinimumMatchingNumber);

            _breedsRepository.Stub(x => x.GetById(Arg<int>.Is.Anything)).Return(
                new Breed { Id = _breedIdDalmatian, Category = new Category { Id = _categoryId } });

            _dogCategoryFilterStrategy.Stub(x => x.Filter(_categoryId, _breedIdDalmatian)).Return(
                dogSearchResultsListBuilder.ListOf3BeagelsByCategory(_categoryId, _breedIdBeagel).Build().AsQueryable());
        }
        public void DogLocationFilter_Returns_Items_Within_A_Configured_Radius_Of_A_Place()
        {
            var placesRepository = MockRepository.GenerateMock<IPlacesRepository>();
            var configuration = MockRepository.GenerateMock<IConfiguration>();

            configuration.Stub(x => x.GetSearchRadiusDefaultDistanceInMetres()).Return(50000);

            var sunderland = new Place()
            {
                PlacesID = 20629,
                Name = "Sunderland",
                County = "Tyne and Wear",
                Country = "England",
                Postcode = "DH7 7",
                Longitude = -1.384,
                Latitude = 54.907
            };
            var durhamNearby = new Place()
            {
                PlacesID = 15770,
                Name = "Aldin Grange",
                County = "Durham",
                Country = "England",
                Postcode = "CV6 6",
                Longitude = -1.624,
                Latitude = 54.781,
            };
            var midlandsFarAway = new Place()
            {
                PlacesID = 12864,
                Name = "Little Heath",
                County = "West Midlands",
                Country = "England",
                Postcode = "CV6 6",
                Longitude = -1.492,
                Latitude = 52.443
            };

            placesRepository.Stub(x => x.GetAll()).Return(
                new List<Place>()
                {
                    sunderland,
                    durhamNearby,
                    midlandsFarAway,
                }
            );
            placesRepository.Stub(x => x.GetById(sunderland.PlacesID)).Return(sunderland);

            var dogs = new DogSearchResultsListBuilder().ListOf3DogsWithConfigurableLocation(
                1, sunderland.PlacesID, durhamNearby.PlacesID, midlandsFarAway.PlacesID
                ).Build();

            var dogLocationFilter = new DogLocationFilter(placesRepository, configuration);

            // act
            var filteredDogs = dogLocationFilter.Filter(dogs.AsQueryable(), sunderland.PlacesID).ToList();

            // assert
            Assert.That(filteredDogs.Exists(dog => dog.PlaceId == sunderland.PlacesID));
            Assert.That(filteredDogs.Exists(dog => dog.PlaceId == durhamNearby.PlacesID));
            Assert.That(!filteredDogs.Exists(dog => dog.PlaceId == midlandsFarAway.PlacesID));
        }
        public void GetDogsByBreed_filters_dogs_by_breed()
        {
            // arrange
                        var dogBreedFilterStrategy = MockRepository.GenerateMock<IDogBreedFilterStrategy>();
                        var dogSearchResultsListBuilder = new DogSearchResultsListBuilder();

                        dogBreedFilterStrategy.Stub(x => x.Filter(Arg<int>.Is.Anything)).Return(
                                dogSearchResultsListBuilder.ListOf14Beagels().Build().AsQueryable()
                                );

                        var dogSearchManager = new DogSearchService(dogBreedFilterStrategy
                                , _dogCategoryFilterStrategy
                                , _dogCategoryService
                                , _dogLocationFilterStrategy
                                , _configuration);

                        // act
                        var result = dogSearchManager.GetDogsByBreed(1);

                        // assert
                        dogBreedFilterStrategy.AssertWasCalled(x => x.Filter(1));
                        Assert.That(result.Count(), Is.EqualTo(14));
        }
        public void ApplyDogLocationFilteringAndSorting_filters_dogs_by_place()
        {
            // arrange
                        const int breedId = 3;
                        const int placeId = 1;

                        var dogBreedFilterStrategy = MockRepository.GenerateMock<IDogBreedFilterStrategy>();
                        var dogSearchResultsListBuilder = new DogSearchResultsListBuilder();
                        var dogs = dogSearchResultsListBuilder.ListOf14Beagels().Build().AsQueryable();
                        dogBreedFilterStrategy.Stub(x => x.Filter(breedId)).Return(dogs);

                        _dogCategoryService.Stub(x => x.AddDogsInSameCategoryToDogsCollection(dogs, breedId)).Return(dogs);
                        _dogLocationFilterStrategy.Stub(x => x.Filter(dogs, placeId)).Return(dogs);

                        var dogSearchManager = new DogSearchService(dogBreedFilterStrategy
                                , _dogCategoryFilterStrategy
                                , _dogCategoryService
                                , _dogLocationFilterStrategy
                                , _configuration);

                        // act
                        dogSearchManager.ApplyDogLocationFilteringAndSorting(dogs, breedId, _sortColumn, placeId);

                        // assert
                        _dogLocationFilterStrategy.AssertWasCalled(x => x.Filter(dogs, placeId));
        }