Exemple #1
0
        public async Task GetTest()
        {
            //Arrange
            var customer = new CustomerMngt.Domain.Entities.Customer
            {
                Id        = 1,
                Password  = "******",
                Email     = "*****@*****.**",
                Surname   = "Surname",
                FirstName = "First Name"
            };

            var customerResponseDto = new CustomerResponseDto
            {
                Id        = 1,
                Email     = "*****@*****.**",
                Surname   = "Surname",
                FirstName = "First Name",
                FullName  = "First Name Surname"
            };

            var filterDto = new CustomerFilterDto {
                Id = 1
            };
            var filter = new CustomerFilter {
                Id = 1
            };

            //Act
            var mockService = new Mock <ICustomerService>();
            var mockMapper  = new Mock <IMapper>();

            mockMapper.Setup(x => x.Map <CustomerResponseDto>(customer)).Returns(customerResponseDto);
            mockMapper.Setup(x => x.Map <CustomerFilter>(filterDto)).Returns(filter);
            mockService.Setup(x => x.GetByFilterAsync(filter)).ReturnsAsync(customer);

            //Assert
            var mockFacade = new CustomerFacade(mockService.Object, mockMapper.Object);
            var result     = await mockFacade.GetByFilterAsync(filterDto);

            Assert.Equal(customer.Id, result.Id);
        }
Exemple #2
0
        public IDataResult <CustomerResponseDto> LoginCustomer(UserLoginDto userLoginDto)
        {
            var resultUserByEMail = _userService.GetUserByEMail(userLoginDto.EMail);

            if (!resultUserByEMail.Success)
            {
                return(new ErrorDataResult <CustomerResponseDto>(resultUserByEMail.Message));
            }
            var userToCheck = resultUserByEMail.Data;

            var resultCustomerDetailsByUserId = _customerService.GetCustomerDetailsByUserId(userToCheck.Id);

            if (!resultCustomerDetailsByUserId.Success)
            {
                return(new ErrorDataResult <CustomerResponseDto>(resultCustomerDetailsByUserId.Message));
            }

            var customerToReturn = resultCustomerDetailsByUserId.Data;

            var customerResponse = new CustomerResponseDto()
            {
                Id          = customerToReturn.Id,
                UserId      = customerToReturn.UserId,
                FirstName   = customerToReturn.FirstName,
                LastName    = customerToReturn.LastName,
                EMail       = customerToReturn.EMail,
                CompanyName = customerToReturn.CompanyName,
            };

            if (!HashingHelper.VerifyPasswordHash(userLoginDto.Password, userToCheck.PasswordHash, userToCheck.PasswordSalt))
            {
                customerResponse.AccessToken = null;
                return(new ErrorDataResult <CustomerResponseDto>(Messages.PasswordNotTrue, customerResponse));
            }

            customerResponse.AccessToken = CreateAccessTokenMine(userToCheck);
            return(new SuccessDataResult <CustomerResponseDto>(Messages.UserLoggedIn, customerResponse));
        }
Exemple #3
0
        public async Task GetListTest()
        {
            //Arrange
            var customerOne = new CustomerMngt.Domain.Entities.Customer
            {
                Id        = 1,
                Password  = "******",
                Email     = "*****@*****.**",
                Surname   = "Surname",
                FirstName = "Ronaldo",
                Updated   = DateTime.Now,
                Created   = DateTime.Now
            };

            var customerTwo = new CustomerMngt.Domain.Entities.Customer
            {
                Id        = 2,
                Password  = "******",
                Email     = "*****@*****.**",
                Surname   = "Surname",
                FirstName = "Ronaldinho",
                Updated   = DateTime.Now,
                Created   = DateTime.Now
            };

            var customers = new List <CustomerMngt.Domain.Entities.Customer>
            {
                customerOne,
                customerTwo
            };

            var pagination = new Pagination <CustomerMngt.Domain.Entities.Customer>
            {
                PageSize    = 10,
                CurrentPage = 1,
                Count       = 2,
                Result      = customers
            };

            var customerOneDto = new CustomerResponseDto
            {
                Id        = 1,
                Email     = "*****@*****.**",
                Surname   = "Surname",
                FirstName = "Ronaldo"
            };

            var customerTwoDto = new CustomerResponseDto
            {
                Id        = 2,
                Email     = "*****@*****.**",
                Surname   = "Surname",
                FirstName = "Ronaldinho"
            };

            var customersDto = new List <CustomerResponseDto>
            {
                customerOneDto,
                customerTwoDto
            };

            var paginationDto = new PaginationDto <CustomerResponseDto>
            {
                PageSize    = 10,
                CurrentPage = 1,
                Count       = 2,
                TotalPages  = 1,
                Result      = customersDto
            };

            var filterDto = new CustomerFilterDto {
                Id = 1
            };
            var filter = new CustomerFilter {
                Id = 1
            };

            //Act
            var mockService = new Mock <ICustomerService>();
            var mockMapper  = new Mock <IMapper>();

            mockMapper.Setup(x => x.Map <CustomerFilter>(filterDto)).Returns(filter);
            mockMapper.Setup(x => x.Map <PaginationDto <CustomerResponseDto> >(pagination)).Returns(paginationDto);
            mockService.Setup(x => x.GetListByFilterAsync(filter)).ReturnsAsync(pagination);

            //Assert
            var mockFacade = new CustomerFacade(mockService.Object, mockMapper.Object);
            var result     = await mockFacade.GetListByFilterAsync(filterDto);

            Assert.Equal(paginationDto.Count, result.Count);
        }