public void MapFrom_Should_ReturnCorrectInstanceOfCollection_UsersDto()
{
//Arrange
var sut = new UserDtoMapper();
var users = new List <User>()
{
new User
{
Id = Guid.NewGuid(),
UserName = "******",
Email = "*****@*****.**"
},
new User
{
Id = Guid.NewGuid(),
UserName = "******",
Email = "*****@*****.**"
},
};
//Act
var result = sut.MapFrom(users);
//Assert
Assert.IsInstanceOfType(result, typeof(List <UserDto>));
}
public void ConvertToDTOTest()
{
var user = new Domain.User.User {
Id = Guid.NewGuid(),
FirstName = "test",
LastName = "test",
Address = new Address {
Country = "UK",
City = "London",
Street = "Baker street",
HouseNumber = "221B"
}
};
var mapper = new UserDtoMapper();
var result = mapper.ConvertToDTO(user);
Assert.AreEqual(user.Id, result.Id);
Assert.AreEqual(user.FirstName, result.FirstName);
Assert.AreEqual(user.LastName, result.LastName);
Assert.AreEqual(user.Address.Country, result.Country);
Assert.AreEqual(user.Address.City, result.City);
Assert.AreEqual(user.Address.Street, result.Street);
Assert.AreEqual(user.Address.HouseNumber, result.HouseNumber);
}
public void MapFromCollection_Should_ReturnCorrectCountUsersDto()
{
//Arrange
var sut = new UserDtoMapper();
var users = new List <User>()
{
new User
{
Id = Guid.NewGuid(),
UserName = "******",
Email = "*****@*****.**"
},
new User
{
Id = Guid.NewGuid(),
UserName = "******",
Email = "*****@*****.**"
},
};
//Act
var result = sut.MapFrom(users);
//Assert
Assert.AreEqual(2, result.Count());
}
public void ConvertToDTOMutipleTest()
{
var user1 = new Domain.User.User {
Id = Guid.NewGuid(),
FirstName = "test",
LastName = "test",
Address = new Address {
Country = "UK",
City = "London",
Street = "Baker street",
HouseNumber = "221B"
}
};
var user2 = new Domain.User.User {
Id = Guid.NewGuid(),
FirstName = "test2",
LastName = "test2",
Address = new Address {
Country = "US",
City = "New York",
Street = "Test street",
HouseNumber = "123"
}
};
var users = new List <Domain.User.User> {
user1,
user2
};
var mapper = new UserDtoMapper();
var results = mapper.ConvertToDTO(users);
Assert.AreEqual(2, results.Count());
var firstDto = results.First();
Assert.AreEqual(user1.Id, firstDto.Id);
Assert.AreEqual(user1.FirstName, firstDto.FirstName);
Assert.AreEqual(user1.LastName, firstDto.LastName);
Assert.AreEqual(user1.Address.Country, firstDto.Country);
Assert.AreEqual(user1.Address.City, firstDto.City);
Assert.AreEqual(user1.Address.Street, firstDto.Street);
Assert.AreEqual(user1.Address.HouseNumber, firstDto.HouseNumber);
var lastDto = results.Last();
Assert.AreEqual(user2.Id, lastDto.Id);
Assert.AreEqual(user2.FirstName, lastDto.FirstName);
Assert.AreEqual(user2.LastName, lastDto.LastName);
Assert.AreEqual(user2.Address.Country, lastDto.Country);
Assert.AreEqual(user2.Address.City, lastDto.City);
Assert.AreEqual(user2.Address.Street, lastDto.Street);
Assert.AreEqual(user2.Address.HouseNumber, lastDto.HouseNumber);
}
public UserService(IUserRepository usersRepository, ITeamRepository teamRepository, IAuthenticationService authService)
{
usersStorage = usersRepository;
teamsStorage = teamRepository;
authenticator = authService;
factory = new UserFactory();
userMapper = new UserDtoMapper();
teamMapper = new TeamDtoMapper();
}
public void MapFrom_Should_ReturnCorrectInstanceOf_UserDto()
{
//Arrange
var sut = new UserDtoMapper();
var user = new User
{
Id = Guid.NewGuid(),
UserName = "******",
Email = "*****@*****.**"
};
//Act
var result = sut.MapFrom(user);
//Assert
Assert.IsInstanceOfType(result, typeof(UserDto));
}
public void MapFrom_Should_CorrectlyMapFrom_User_To_UserDto()
{
//Arrange
var sut = new UserDtoMapper();
var user = new User
{
Id = Guid.NewGuid(),
UserName = "******",
Email = "*****@*****.**"
};
//Act
var result = sut.MapFrom(user);
//Assert
Assert.AreEqual(result.Id, user.Id);
Assert.AreEqual(result.UserName, user.UserName);
Assert.AreEqual(result.Email, user.Email);
}
public void ConvertToDomainObjectTest()
{
var dto = new UserEditDTO {
FirstName = "test",
LastName = "test",
Country = "UK",
City = "London",
Street = "Baker street",
HouseNumber = "221B"
};
var mapper = new UserDtoMapper();
var result = mapper.ConvertToDomainObject(dto);
Assert.AreEqual(dto.FirstName, result.FirstName);
Assert.AreEqual(dto.LastName, result.LastName);
Assert.AreEqual(dto.Country, result.Address.Country);
Assert.AreEqual(dto.City, result.Address.City);
Assert.AreEqual(dto.Street, result.Address.Street);
Assert.AreEqual(dto.HouseNumber, result.Address.HouseNumber);
}
public async Task <UserDto> GetUserByPolicy(Guid policyId)
{
return(UserDtoMapper.Map(await _userDataService.GetUserByPolicy(policyId).ConfigureAwait(false)));
}
public AuthenticationService(IUserRepository aRepo, ILogInfoRepository aLogger)
{
users = aRepo;
logger = aLogger;
mapper = new UserDtoMapper();
}
public int EditUser(UserDto dto)
{
return(Edit(UserDtoMapper.To(dto)));
}
public int AddUser(UserDto dto)
{
return(Add(UserDtoMapper.To(dto)));
}
public IList <UserDto> GetAllUsers()
{
return(UserDtoMapper.From(GetAll()));
}
public UserDto GetUser(long id)
{
return(UserDtoMapper.From(Get(id)));
}
public async Task <UserDto> GetUserByName(string userName)
{
return(UserDtoMapper.Map(await _userDataService.GetUserByName(userName).ConfigureAwait(false)));
}
public void SetupTests()
{
_sut = new UserDtoMapper();
}
public UsersBal()
{
UsersMapper = new UsersMapper();
UsersMapper2 = new UserDtoMapper();
}
