public void CreateAthlete_CallsRepositoryAndThrowsException()
        {
            var input = new AthleteRequest
            {
                Username = "******",
                Email    = "*****@*****.**",
                FullName = "User Two"
            };
            var expected = new ConflictException(
                new List <string>()
            {
                ErrorConstants.UsernameAlreadyExists
            });

            var convertedDto = new AthleteDto
            {
                Username = "******",
                Email    = "*****@*****.**",
                FullName = "User Two"
            };

            mockAthleteRepository.Setup(repo => repo.AddAthlete(convertedDto))
            .Throws(expected);

            // act
            var actual = Assert.Throws <ConflictException>(
                () => athleteService.CreateAthlete(input)
                );

            // assert
            Assert.Equal(expected.Messages, actual.Messages);
            mockAthleteRepository.Verify(repo => repo.AddAthlete(convertedDto), Times.Once);
            mockAthleteRepository.VerifyNoOtherCalls();
        }
        public void CreateAthlete_CallsRepository()
        {
            var input = new AthleteRequest
            {
                Username = "******",
                Email    = "*****@*****.**",
                FullName = "User One"
            };
            var expected = new AthleteDto
            {
                Username = "******",
                Email    = "*****@*****.**",
                FullName = "User One"
            };
            var convertedDto = new AthleteDto
            {
                Username = "******",
                Email    = "*****@*****.**",
                FullName = "User One"
            };

            mockAthleteRepository.Setup(repo => repo.AddAthlete(convertedDto))
            .Returns(convertedDto);

            // act
            var actual = athleteService.CreateAthlete(input);

            // assert
            Assert.Equal(expected, actual);
            mockAthleteRepository.Verify(repo => repo.AddAthlete(convertedDto), Times.Once);
            mockAthleteRepository.VerifyNoOtherCalls();
        }
 private AthleteDto ConvertRequestToDto(AthleteRequest athleteRequest)
 {
     return(new AthleteDto
     {
         Username = athleteRequest.Username,
         Email = athleteRequest.Email,
         FullName = athleteRequest.FullName
     });
 }
        public ActionResult <DetailResponse <AthleteResponse> > CreateAthlete(AthleteRequest athlete)
        {
            var athleteDto = _athleteService.CreateAthlete(athlete);

            return(Created("CreateUser",
                           new DetailResponse <AthleteResponse>
            {
                Status = 201,
                Detail = ConvertToAthleteResponse(athleteDto)
            }));
        }
        public void CreateAthlete_CallsRepository()
        {
            var input = new AthleteRequest
            {
                Username = "******",
                Email    = "*****@*****.**",
                FullName = "User One"
            };
            var expectedStatus = 201;
            var expected       = new DetailResponse <AthleteResponse>
            {
                Status = 201,
                Detail = new AthleteResponse
                {
                    Username = "******",
                    Email    = "*****@*****.**",
                    FullName = "User One"
                }
            };
            var convertedDto = new AthleteDto
            {
                Username = "******",
                Email    = "*****@*****.**",
                FullName = "User One"
            };

            mockAthleteService.Setup(service => service.CreateAthlete(input))
            .Returns(convertedDto);

            // act
            var actual = athleteController.CreateAthlete(input).Result
                         as CreatedResult;

            // assert
            Assert.Equal(expected, actual.Value);
            Assert.Equal(expectedStatus, actual.StatusCode);
            mockAthleteService.Verify(service => service.CreateAthlete(input), Times.Once);
            mockAthleteService.VerifyNoOtherCalls();
        }
 public AthleteDto CreateAthlete(AthleteRequest athleteRequest)
 {
     return(_athleteRepository.AddAthlete(ConvertRequestToDto(athleteRequest)));
 }