public async void GetMammalsByHabitatName_ShouldReturnMammal(string inlineHabitatName, int expected)
        {
            //Arrange
            var     profile = new MammalAPI.Configuration.Mapper();
            var     config  = new MapperConfiguration(x => x.AddProfile(profile));
            IMapper mapper  = new Mapper(config);

            //Mocking
            var mammal      = GetTestMammals();
            var mockContext = new Mock <DBContext>();

            mockContext.Setup(z => z.Mammals).ReturnsDbSet(mammal);

            //Mocking repo
            var logger = Mock.Of <ILogger <MammalRepository> >();
            var repo   = new MammalRepository(mockContext.Object, logger);

            //mocking IActionDescriptor
            var actions        = new List <ActionDescriptor>();
            var mockDescriptor = new Mock <IActionDescriptorCollectionProvider>();

            mockDescriptor.Setup(x => x.ActionDescriptors).Returns(new ActionDescriptorCollection(actions, 0));

            // setting up controller
            var controller = new MammalsController(repo, mapper, mockDescriptor.Object);

            //Act
            var result = await controller.GetMammalsByHabitatName(inlineHabitatName, false);

            var content = result as OkObjectResult;
            var dto     = (MammalDTO[])content.Value;

            //Assert
            Assert.Equal(2, dto.Length);
        }
        public async void PostMammal_Should_SaveOneMammal()
        {
            // Arrange
            var           profile       = new MammalAPI.Configuration.Mapper();
            var           configuration = new MapperConfiguration(cfg => cfg.AddProfile(profile));
            IMapper       mapper        = new Mapper(configuration);
            List <Mammal> mammals       = new List <Mammal>();

            //Mock Repo
            var mammalRepo = new Mock <IMammalRepository>();

            mammalRepo.Setup(r => r.Add <Mammal>(It.IsAny <Mammal>()));
            mammalRepo.Setup(r => r.GetAllMammals(It.IsAny <Boolean>(), It.IsAny <Boolean>())).Returns(Task.FromResult(mammals));
            mammalRepo.Setup(r => r.Save()).Returns(Task.FromResult(true));

            //Mock IActionDescriptorCollectionProvider
            var actions = new List <ActionDescriptor>
            {
                new ActionDescriptor
                {
                    AttributeRouteInfo = new AttributeRouteInfo()
                    {
                        Template = "/test",
                    },
                    RouteValues = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
                    {
                        { "action", "Test" },
                        { "controller", "Test" },
                    },
                },
            };
            var mockDescriptorProvider = new Mock <IActionDescriptorCollectionProvider>();

            mockDescriptorProvider.Setup(m => m.ActionDescriptors).Returns(new ActionDescriptorCollection(actions, 0));

            //Setup new controller based on mocks
            var controller = new MammalsController(mammalRepo.Object, mapper, mockDescriptorProvider.Object);

            //Create new DTO
            var dto = new MammalDTO
            {
                Name     = "test",
                MammalID = 1
            };


            // Act
            var result = await controller.PostMammal(dto);

            // Assert
            var r         = result.Result as CreatedResult;
            var dtoResult = (MammalDTO)r.Value;

            Assert.Equal("test", dtoResult.Name);
        }
        public async void GetAllMammal_ShouldReturnMammal()
        {
            //Arrange
            var     profile = new MammalAPI.Configuration.Mapper();
            var     config  = new MapperConfiguration(s => s.AddProfile(profile));
            IMapper mapper  = new Mapper(config);

            //mockContext
            var mammal      = GenerateMammal();
            var mockContext = new Mock <DBContext>();

            mockContext.Setup(x => x.Mammals).ReturnsDbSet(mammal);

            //Mocking
            var logger   = Mock.Of <ILogger <MammalRepository> >();
            var mockRepo = new MammalRepository(mockContext.Object, logger);

            //actionDescriptor
            var actions = new List <ActionDescriptor>
            {
                new ActionDescriptor
                {
                    AttributeRouteInfo = new AttributeRouteInfo
                    {
                        Template = "/test"
                    },
                    RouteValues = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
                    {
                        { "action", "test" },
                        { "controller", "test " }
                    }
                }
            };

            var mockDescriptor = new Mock <IActionDescriptorCollectionProvider>();

            mockDescriptor.Setup(z => z.ActionDescriptors).Returns(new ActionDescriptorCollection(actions, 0));

            //setting up controller
            var controller = new MammalsController(mockRepo, mapper, mockDescriptor.Object);

            //Act
            var result = await controller.Get(false);

            var content = result.Result as OkObjectResult;

            MammalDTO[] mammals = (MammalDTO[])content.Value;

            //Assert
            Assert.Equal(1, (int)mammals.Length);
        }
        public async void GetMammalsByFamilyName_FetchMammalsBasedOnFamilyName_ListLengthOfMammalsWithCorrespondingFamilyName(string inlineFamilyName, int expected)
        {
            // Arrange
            var     profile       = new MammalAPI.Configuration.Mapper();
            var     configuration = new MapperConfiguration(cfg => cfg.AddProfile(profile));
            IMapper mapper        = new Mapper(configuration);

            //Mock context
            var testMammals = GetTestMammals();
            var contextMock = new Mock <DBContext>();

            contextMock.Setup(m => m.Mammals).ReturnsDbSet(testMammals);

            //Mock Repo
            var logger         = Mock.Of <ILogger <MammalRepository> >();
            var mammalRepoMock = new MammalRepository(contextMock.Object, logger);

            //Mock IActionDescriptorCollectionProvider
            var actions = new List <ActionDescriptor>
            {
                new ActionDescriptor
                {
                    AttributeRouteInfo = new AttributeRouteInfo()
                    {
                        Template = "/test",
                    },
                    RouteValues = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
                    {
                        { "action", "Test" },
                        { "controller", "Test" },
                    },
                }
            };
            var mockDescriptorProvider = new Mock <IActionDescriptorCollectionProvider>();

            mockDescriptorProvider.Setup(m => m.ActionDescriptors).Returns(new ActionDescriptorCollection(actions, 0));

            //Setup new controller based on mocks
            var controller = new MammalsController(mammalRepoMock, mapper, mockDescriptorProvider.Object);

            //Act
            var result = await controller.GetMammalsByFamilyName(inlineFamilyName, false);

            var contentResult = result as OkObjectResult;

            MammalDTO[] dto = (MammalDTO[])contentResult.Value;

            //Assert
            Assert.Equal(expected, dto.Length);
        }
        public async void GetAllFamilies_FetchListOfAllFamilies_LengthOfTwoExpected()
        {
            // Arrange
            var     profile       = new MammalAPI.Configuration.Mapper();
            var     configuration = new MapperConfiguration(cfg => cfg.AddProfile(profile));
            IMapper mapper        = new Mapper(configuration);

            //Mock context
            var testFamilies = GetTestFamilies();
            var contextMock  = new Mock <DBContext>();

            contextMock.Setup(f => f.Families).ReturnsDbSet(testFamilies);

            //Mock Repo
            var logger         = Mock.Of <ILogger <FamilyRepository> >();
            var familyRepoMock = new FamilyRepository(contextMock.Object, logger);

            //Mock IActionDescriptorCollectionProvider
            var actions = new List <ActionDescriptor>
            {
                new ActionDescriptor
                {
                    AttributeRouteInfo = new AttributeRouteInfo()
                    {
                        Template = "/test",
                    },
                    RouteValues = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
                    {
                        { "action", "Test" },
                        { "controller", "Test" },
                    },
                }
            };
            var mockDescriptorProvider = new Mock <IActionDescriptorCollectionProvider>();

            mockDescriptorProvider.Setup(m => m.ActionDescriptors).Returns(new ActionDescriptorCollection(actions, 0));

            //Setup new controller based on mocks
            var controller = new FamilyController(familyRepoMock, mapper, mockDescriptorProvider.Object);

            //Act
            var result = await controller.GetAllFamilies(false);

            var contentResult = result as OkObjectResult;

            FamilyDTO[] dto = (FamilyDTO[])contentResult.Value;

            //Assert
            Assert.Equal(2, dto.Length);
        }
        public async void GetHabitatById_FetchHabitatBasedOnId_SameIdAsInputExpected(int inlineHabitatID, int expected)
        {
            // Arrange
            var     profile       = new MammalAPI.Configuration.Mapper();
            var     configuration = new MapperConfiguration(cfg => cfg.AddProfile(profile));
            IMapper mapper        = new Mapper(configuration);

            //Mock context
            var testHabitats = GetTestHabitats();
            var contextMock  = new Mock <DBContext>();

            contextMock.Setup(h => h.Habitats).ReturnsDbSet(testHabitats);

            //Mock Repo
            var logger          = Mock.Of <ILogger <HabitatRepository> >();
            var habitatRepoMock = new HabitatRepository(contextMock.Object, logger);

            //Mock IActionDescriptorCollectionProvider
            var actions = new List <ActionDescriptor>
            {
                new ActionDescriptor
                {
                    AttributeRouteInfo = new AttributeRouteInfo()
                    {
                        Template = "/test",
                    },
                    RouteValues = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
                    {
                        { "action", "Test" },
                        { "controller", "Test" },
                    },
                }
            };
            var mockDescriptorProvider = new Mock <IActionDescriptorCollectionProvider>();

            mockDescriptorProvider.Setup(m => m.ActionDescriptors).Returns(new ActionDescriptorCollection(actions, 0));

            //Setup new controller based on mocks
            var controller = new HabitatController(habitatRepoMock, mapper, mockDescriptorProvider.Object);

            //Act
            var result = await controller.GetHabitatById(inlineHabitatID, false);

            var        contentResult = result.Result as OkObjectResult;
            HabitatDTO dto           = (HabitatDTO)contentResult.Value;

            //Assert
            Assert.Equal(expected, dto.HabitatID);
        }
        public async void PostHabitat_Should_SaveOne()
        {
            var            profile  = new MammalAPI.Configuration.Mapper();
            var            config   = new MapperConfiguration(c => c.AddProfile(profile));
            IMapper        mapper   = new Mapper(config);
            List <Habitat> habitats = new List <Habitat>();

            var habitatrepo = new Mock <IHabitatRepository>();

            habitatrepo.Setup(h => h.Add <Habitat>(It.IsAny <Habitat>()));
            habitatrepo.Setup(h => h.GetAllHabitats(It.IsAny <Boolean>())).Returns(Task.FromResult(habitats));
            habitatrepo.Setup(h => h.Save()).Returns(Task.FromResult(true));

            var actions = new List <ActionDescriptor>
            {
                new ActionDescriptor
                {
                    AttributeRouteInfo = new AttributeRouteInfo()
                    {
                        Template = "/test",
                    },
                    RouteValues = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
                    {
                        { "action", "Test" },
                        { "controller", "Test" },
                    },
                },
            };
            var mockDescriptorProvider = new Mock <IActionDescriptorCollectionProvider>();

            mockDescriptorProvider.Setup(m => m.ActionDescriptors).Returns(new ActionDescriptorCollection(actions, 0));

            var controller = new HabitatController(habitatrepo.Object, mapper, mockDescriptorProvider.Object);

            var habitatDTO = new HabitatDTO
            {
                HabitatID = 1,
                Name      = "Habitat test"
            };

            var result = await controller.PostHabitat(habitatDTO);

            var test      = result.Result as CreatedResult;
            var dtoResult = (HabitatDTO)test.Value;

            Assert.Equal("Habitat test", dtoResult.Name);
        }