public async Task GivenAnInvalidModel_Post_ReturnsBadRequest()
        {
            // Arrange
            var logger           = new Mock <ILogger <CRUD.Controllers.PeopleController> >();
            var personRepository = new Mock <IPersonRepository>();
            var controller       = new CRUD.Controllers.PeopleController(logger.Object, personRepository.Object);

            controller.SetInvalidModelState();

            // Act
            var result = await controller.Post(null);

            // Assert
            personRepository.Verify(x => x.AddAsync(It.IsAny <Person>()), Times.Never);
            result.ShouldBeBadRequest();
        }
        public async Task GivenAPersonThatExists_Get_ReturnsOkResultWithPerson()
        {
            // Arrange
            var fakePerson       = Fakes.FakePeople.First();
            var logger           = new Mock <ILogger <CRUD.Controllers.PeopleController> >();
            var personRepository = new Mock <IPersonRepository>();

            personRepository.Setup(x => x.GetAsync(fakePerson.Id))
            .Returns(Task.FromResult(fakePerson));
            var controller = new CRUD.Controllers.PeopleController(logger.Object, personRepository.Object);

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

            // Assert
            personRepository.VerifyAll();
            result.ShouldBeOkWithModel(fakePerson);
        }
        public async Task GivenAPersonThatDoesntExist_Get_ReturnsNotFoundResult()
        {
            // Arrange
            const int personId         = 100;
            var       logger           = new Mock <ILogger <CRUD.Controllers.PeopleController> >();
            var       personRepository = new Mock <IPersonRepository>();

            personRepository.Setup(x => x.GetAsync(personId))
            .Returns(Task.FromResult((Person)null));
            var controller = new CRUD.Controllers.PeopleController(logger.Object, personRepository.Object);

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

            // Assert
            personRepository.VerifyAll();
            result.ShouldBeNotFound();
        }
        public async Task Index_ReturnsOkResultWithAListOfPeople()
        {
            // Arrange
            var fakePeople       = Fakes.FakePeople;
            var logger           = new Mock <ILogger <CRUD.Controllers.PeopleController> >();
            var personRepository = new Mock <IPersonRepository>();

            personRepository.Setup(x => x.GetAsync())
            .Returns(Task.FromResult(fakePeople));
            var controller = new CRUD.Controllers.PeopleController(logger.Object, personRepository.Object);

            // Act
            var result = await controller.Index();

            // Assert
            personRepository.VerifyAll();
            result.ShouldBeOkWithModel(fakePeople);
        }
        public async Task GivenAValidModel_Post_ReturnsCreatedResultWithLocationHeader()
        {
            // Arrange
            var       fakePerson       = Fakes.FakePeople.First();
            var       logger           = new Mock <ILogger <CRUD.Controllers.PeopleController> >();
            var       personRepository = new Mock <IPersonRepository>();
            const int newPersonId      = 100;

            personRepository.Setup(x => x.AddAsync(fakePerson))
            .ReturnsAsync(newPersonId);
            var controller = new CRUD.Controllers.PeopleController(logger.Object, personRepository.Object);

            // Act
            var result = await controller.Post(fakePerson);

            // Assert
            personRepository.VerifyAll();
            result.ShouldBeCreated();
        }