public void Add(IncomingUser user)
{
using (var context = new WorldOfWordsDatabaseContext())
{
context.IncomingUsers.AddOrUpdate(user);
context.SaveChanges();
}
}
public void Add(IncomingUser user)
{
using (var uow = _unitOfWorkFactory.GetUnitOfWork())
{
uow.IncomingUserRepository.AddOrUpdate(user);
uow.Save();
}
}
public User ToDomainModel(IncomingUser incomingUser)
{
return new User
{
Id = incomingUser.Id,
Name = incomingUser.Name,
Email = incomingUser.Email,
Password = incomingUser.Password
};
}
public void AddToken(IncomingUser user)
{
if (Exists(user))
{
using (var uow = _unitOfWorkFactory.GetUnitOfWork())
{
var searchedUser = uow.IncomingUserRepository.GetById(user.Id);
searchedUser.Token = user.Token;
uow.Save();
}
}
}
public void AddToken(IncomingUser user)
{
if (Exists(user))
{
using (var context = new WorldOfWordsDatabaseContext())
{
var searchedUser = context.IncomingUsers.First(e => e.Id == user.Id);
searchedUser.Token = user.Token;
context.SaveChanges();
}
}
}
public void Add(IncomingUser user)
{
using (var uow = _unitOfWorkFactory.GetUnitOfWork())
{
uow.IncomingUserRepository.AddOrUpdate(user);
uow.Save();
}
//using (var context = new WorldOfWordsDatabaseContext())
//{
// context.IncomingUsers.AddOrUpdate(user);
// context.SaveChanges();
//}
}
public void AddToken(IncomingUser user)
{
if (Exists(user))
{
using (var uow = _unitOfWorkFactory.GetUnitOfWork())
{
var searchedUser = uow.IncomingUserRepository.GetById(user.Id);
searchedUser.Token = user.Token;
uow.Save();
}
//using (var context = new WorldOfWordsDatabaseContext())
//{
// var searchedUser = context.IncomingUsers.First(e => e.Id == user.Id);
// searchedUser.Token = user.Token;
// context.SaveChanges();
//}
}
}
public void Setup()
{
uowFactory = new Mock<IUnitOfWorkFactory>();
worldOfWordsUow = new Mock<IWorldOfWordsUow>();
incUserReposit = new Mock<IIncomingUserRepository>();
tokenVaidation = new Mock<ITokenValidation>();
userReposit = new Mock<IUserRepository>();
iusService = new Mock<IUserService>();
incUserMapper = new Mock<IIncomingUserMapper>();
userForListMaper = new Mock<IUserForListingMapper>();
uowFactory.Setup(t => t.GetUnitOfWork()).Returns(worldOfWordsUow.Object);
usServ = new UserService(incUserMapper.Object, tokenVaidation.Object, uowFactory.Object, userForListMaper.Object);
roleRepository = new Mock<IRepository<Role>>();
entity = new IncomingUser
{
Email = "*****@*****.**",
Id = 1,
Password = "******",
Name = "Roman",
Token = "jsdjsjd"
};
}
public async Task Post_Register_Should_Return_Ok_TokenModel()
{
//Arrange
var registerUser = new RegisterUserModel
{
Login = "******",
Email = "*****@*****.**",
Password = "******",
Id = 0
};
var incomingUser = new IncomingUser
{
Name = "Cat-Ok",
Email = "*****@*****.**",
Password = "******",
Token = "asdf",
Id = 1
};
var user = new User
{
Name = "Roman Hapatyn",
Email = "*****@*****.**",
Password = "******",
HashedToken = "asdf",
Id = 1
};
TokenModel token = new TokenModel();
token.RolesToken = "Student";
//Action
GenerateData("1", new[] { "NoRoles" });
RegisterController registerController = new RegisterController(userService.Object,
tokenValidation.Object,
incUserMapper.Object,
mesService.Object);
var tokenModel = new TokenModel();
string locationUrl = "http://location/";
var message = new IdentityMessage
{
Body = "Please confirm your account at: www.xxx.xxx ",
Destination = "*****@*****.**",
Subject = "Confirm your registration"
};
urlHelper.Setup(x => x.Link(It.IsAny<string>(), It.IsAny<object>()))
.Returns(locationUrl);
registerController.Url = urlHelper.Object;
mesService
.Setup(x => x.SendAsync(message))
.Returns(Task.FromResult(0));
incUserMapper
.Setup(x => x.ToIncomingUser(registerUser))
.Returns(incomingUser);
userMapper
.Setup(x => x.Map(registerUser))
.Returns(user);
userService
.Setup(x => x.Exists(incomingUser))
.Returns(false);
tokenValidation
.Setup(x => x.GetHashSha256("asdf"))
.Returns("fdsa");
var actual = await registerController.Post(registerUser) as OkNegotiatedContentResult<TokenModel>;
var contentResult = actual as OkNegotiatedContentResult<TokenModel>;
//Assert
Assert.IsNotNull(actual);
Assert.AreEqual(actual.Content.GetType(), tokenModel.GetType());
}
public bool Exists(IncomingUser user)
{
using (var uow = _unitOfWorkFactory.GetUnitOfWork())
{
return
uow.UserRepository.GetAll().Any(users => users.Email.ToLower() == user.Email.ToLower())
|| uow.IncomingUserRepository.GetAll().Any(users => users.Email.ToLower() == user.Email.ToLower());
}
}
public bool Exists(IncomingUser user)
{
using (var uow = _unitOfWorkFactory.GetUnitOfWork())
{
return uow.UserRepository.GetAll().Any(users => users.Email.ToLower() == user.Email.ToLower())
|| uow.IncomingUserRepository.GetAll().Any(users => users.Email.ToLower() == user.Email.ToLower());
}
//using (var context = new WorldOfWordsDatabaseContext())
//{
// return context.Users.Any(users => users.Email.ToLower() == user.Email.ToLower())
// || context.IncomingUsers.Any(users => users.Email.ToLower() == user.Email.ToLower());
//}
}
[Test] //
public void ConfirmUserRegistration_IsFalseTest()
{
//Arrange
IncomingUser inUser = new IncomingUser
{
Email = "*****@*****.**",
Id = 1,
Password = "******",
Name = "Stepan",
Token = "jsdjsjd"
};
IQueryable<IncomingUser> incomUsers = new List<IncomingUser>
{
inUser
}.AsQueryable<IncomingUser>();
User user = new User
{
Email = "*****@*****.**",
Id = 1,
Password = "******",
Name = "Stepan",
HashedToken = "sknsdmsopp"
};
IQueryable<Role> roles = new List<Role>
{
new Role(){ Id = 1, Name = "Student"}
}.AsQueryable<Role>();
worldOfWordsUow.Setup(t => t.IncomingUserRepository).Returns(incUserReposit.Object);
incUserReposit.Setup(t => t.GetAll()).Returns(incomUsers);
incUserReposit.Setup(s => s.Delete(It.IsAny<IncomingUser>())).Verifiable("deleted");
incUserMapper.Setup(t => t.ToDomainModel(It.IsAny<IncomingUser>())).Returns(user);
worldOfWordsUow.Setup(t => t.RoleRepository).Returns(roleRepository.Object);
roleRepository.Setup(t => t.GetAll()).Returns(roles);
worldOfWordsUow.Setup(t => t.UserRepository).Returns(userReposit.Object);
userReposit.Setup(t => t.Add(user)).Verifiable("Added user");
worldOfWordsUow.Setup(t => t.Save()).Verifiable("Saved");
//Act
var result = usServ.ConfirmUserRegistration(2, "jaflkasjdl");
//Assert
uowFactory.Verify(t => t.GetUnitOfWork(), Times.Once);
worldOfWordsUow.Verify(t => t.IncomingUserRepository, Times.Once);
incUserReposit.Verify(t => t.GetAll(), Times.Once);
incUserReposit.Verify(t => t.Delete(It.IsAny<IncomingUser>()), Times.Never);
incUserMapper.Verify(t => t.ToDomainModel(It.IsAny<IncomingUser>()), Times.Never);
worldOfWordsUow.Verify(t => t.RoleRepository, Times.Never);
roleRepository.Verify(t => t.GetAll(), Times.Never);
worldOfWordsUow.Verify(t => t.UserRepository, Times.Never);
userReposit.Verify(t => t.Add(It.IsAny<User>()), Times.Never);
worldOfWordsUow.Verify(t => t.Save(), Times.Never);
Assert.IsFalse(result);
}
public bool Exists(IncomingUser user)
{
using (var context = new WorldOfWordsDatabaseContext())
{
return context.Users.Any(users => users.Email.ToLower() == user.Email.ToLower())
|| context.IncomingUsers.Any(users => users.Email.ToLower() == user.Email.ToLower());
}
}
