public async Task CreateIdentityRequestHandler_Handle_Returns_InvalidUserKey()
{
AuthenticationContext.OpenInMemoryConnection();
try
{
CreateIdentityResponse response;
var request = new CreateIdentityRequest();
using (var context = AuthenticationContext.GetInMemoryContext())
{
var handler = new CreateIdentityRequestHandler(context);
response = await handler.Handle(request);
}
using (var context = AuthenticationContext.GetInMemoryContext())
{
Assert.IsFalse(context.Users.Any());
Assert.IsNull(response.ActivationToken);
Assert.IsFalse(response.IsSuccess);
Assert.AreEqual(ErrorType.InvalidKey, response.ErrorType);
}
}
finally
{
AuthenticationContext.CloseInMemoryConnection();
}
}
public async Task UserLoginRequestHandler_Handle_Returns_Success()
{
AuthenticationContext.OpenInMemoryConnection();
try
{
//Arrange
using (var context = AuthenticationContext.GetInMemoryContext())
{
var user = new User
{
UserKey = Guid.NewGuid(),
Name = "Test User",
Created = DateTime.Now,
IsActive = true,
Role = Role.Donator
};
var credential = new Credential
{
CredentialType = CredentialType.Default,
User = user,
Identifier = "Admin",
Secret = Encryption.CreateHash("admin"),
};
context.Add(user);
context.Add(credential);
context.SaveChanges();
}
UserLoginResponse response;
var request = new UserLoginRequest
{
Identifier = "admin",
LoginTypeCode = CredentialType.Default
};
//Act
using (var context = AuthenticationContext.GetInMemoryContext())
{
var handler = new UserLoginRequestHandler(context);
response = await handler.Handle(request);
}
//Assert
using (var context = AuthenticationContext.GetInMemoryContext())
{
Assert.IsTrue(response.IsSuccess);
Assert.IsTrue(Encryption.ValidatePassword("admin", response.EncrytedPassword));
Assert.AreEqual(response.UserName, context.Users.Single().Name);
Assert.AreEqual(response.UserKey, context.Users.Single().UserKey);
Assert.IsTrue(response.Role.OnlyHasFlag(Role.Donator));
}
}
finally
{
AuthenticationContext.CloseInMemoryConnection();
}
}
public async Task UserLoginRequestHandler_Handle_Returns_InactiveAccount()
{
AuthenticationContext.OpenInMemoryConnection();
try
{
//Arrange
using (var context = AuthenticationContext.GetInMemoryContext())
{
var user = new User
{
UserKey = Guid.NewGuid(),
Name = "Test User",
Created = DateTime.Now,
IsActive = false,
Role = Role.Donator
};
var credential = new Credential
{
CredentialType = CredentialType.Default,
User = user,
Identifier = "Admin",
Secret = Core.Encryption.CreateHash("admin"),
};
context.Add(user);
context.Add(credential);
context.SaveChanges();
}
UserLoginResponse response;
var request = new UserLoginRequest
{
Identifier = "admin",
LoginTypeCode = CredentialType.Default
};
//Act
using (var context = AuthenticationContext.GetInMemoryContext())
{
var handler = new UserLoginRequestHandler(context);
response = await handler.Handle(request);
}
//Assert
Assert.AreEqual(ErrorType.InactiveAccount, response.ErrorType);
Assert.IsNull(response.EncrytedPassword);
Assert.IsFalse(response.IsSuccess);
Assert.IsNull(response.UserName);
Assert.AreEqual(response.UserKey, Guid.Empty);
Assert.AreEqual(Role.Default, response.Role);
}
finally
{
AuthenticationContext.CloseInMemoryConnection();
}
}
public async Task UserUpdatedEventHandler_Consume_Updates_Name()
{
AuthenticationContext.OpenInMemoryConnection();
try
{
var userUpdatedEvent = new UserUpdatedEvent
{
UserKey = Guid.NewGuid(),
FirstName = "Ellen",
LastName = "Doe",
EmailAddress = "*****@*****.**"
};
var user = new User
{
UserKey = userUpdatedEvent.UserKey,
Name = "John Doe"
};
var credential = new Credential
{
CredentialType = CredentialType.Email,
User = user,
Identifier = "*****@*****.**"
};
using (var context = AuthenticationContext.GetInMemoryContext())
{
context.Users.Add(user);
context.Credentials.Add(credential);
context.SaveChanges();
}
using (var context = AuthenticationContext.GetInMemoryContext())
{
var handler = new UserUpdatedEventHandler(context);
await handler.ConsumeAsync(userUpdatedEvent);
}
using (var context = AuthenticationContext.GetInMemoryContext())
{
Assert.AreEqual("Ellen Doe", context.Users.Single().Name);
Assert.AreEqual("*****@*****.**", context.Credentials.Single().Identifier);
}
}
finally
{
AuthenticationContext.CloseInMemoryConnection();
}
}
public async Task GetUserActivationTokenRequestHandler_Handle_ReturnsToken()
{
AuthenticationContext.OpenInMemoryConnection();
try
{
using (var context = AuthenticationContext.GetInMemoryContext())
{
var user = new User
{
Id = Guid.NewGuid(),
Name = "John Doe",
IsActive = false
};
var credential = new Credential
{
Id = Guid.NewGuid(),
CredentialType = CredentialType.Email,
Identifier = "*****@*****.**",
User = user
};
context.Users.Add(user);
context.Credentials.Add(credential);
context.SaveChanges();
}
GetUserActivationTokenResponse response;
var request = new GetUserActivationTokenRequest
{
EmailAddress = "*****@*****.**"
};
using (var context = AuthenticationContext.GetInMemoryContext())
{
var handler = new GetUserActivationTokenRequestHandler(context);
response = await handler.Handle(request);
}
using (var context = AuthenticationContext.GetInMemoryContext())
{
Assert.IsFalse(context.Users.Single().IsActive);
Assert.IsNotNull(response.ActivationToken);
Assert.AreEqual(context.Users.Single().ActivationToken, response.ActivationToken);
Assert.AreEqual(context.Users.Single().Name, response.UserName);
}
}
finally
{
AuthenticationContext.CloseInMemoryConnection();
}
}
public async Task CreateIdentityRequestHandler_Handle_Returns_EmailExists()
{
AuthenticationContext.OpenInMemoryConnection();
try
{
using (var context = AuthenticationContext.GetInMemoryContext())
{
var user = new User
{
Id = Guid.NewGuid(),
Name = "John Doe"
};
context.Credentials.Add(new Credential
{
Id = Guid.NewGuid(),
CredentialType = CredentialType.Email,
Identifier = "*****@*****.**",
User = user
});
context.Users.Add(user);
context.SaveChanges();
}
CreateIdentityResponse response;
var request = new CreateIdentityRequest
{
UserKey = Guid.NewGuid(),
Identifier = "*****@*****.**",
CredentialType = CredentialType.Email
};
using (var context = AuthenticationContext.GetInMemoryContext())
{
var handler = new CreateIdentityRequestHandler(context);
response = await handler.Handle(request);
}
using (var context = AuthenticationContext.GetInMemoryContext())
{
Assert.IsTrue(context.Users.Count() == 1);
Assert.IsNull(response.ActivationToken);
Assert.IsFalse(response.IsSuccess);
Assert.AreEqual(ErrorType.EmailExists, response.ErrorType);
}
}
finally
{
AuthenticationContext.CloseInMemoryConnection();
}
}
public async Task UpdateRolesRequestHandler_Handle_ReturnsInvalidUserKey()
{
AuthenticationContext.OpenInMemoryConnection();
try
{
UpdateRolesResponse response;
var request = new UpdateRolesRequest
{
UserKey = Guid.NewGuid(),
Role = Role.CharityOwner
};
using (var context = AuthenticationContext.GetInMemoryContext())
{
var user = new User
{
Id = Guid.NewGuid(),
UserKey = Guid.NewGuid(),
Name = "John Doe",
Role = Role.Donator
};
context.Users.Add(user);
context.SaveChanges();
}
using (var context = AuthenticationContext.GetInMemoryContext())
{
var handler = new UpdateRolesRequestHandler(context);
response = await handler.Handle(request);
}
using (var context = AuthenticationContext.GetInMemoryContext())
{
Assert.IsTrue(context.Users.Single().Role.OnlyHasFlag(Role.Donator));
Assert.AreEqual(response.ErrorType, ErrorType.InvalidKey);
Assert.IsFalse(response.IsSuccess);
}
}
finally
{
AuthenticationContext.CloseInMemoryConnection();
}
}
public async Task CreateIdentityRequestHandler_Handle_Returns_ActivationCode()
{
AuthenticationContext.OpenInMemoryConnection();
try
{
CreateIdentityResponse response;
var request = new CreateIdentityRequest
{
CredentialType = CredentialType.Email,
Identifier = "*****@*****.**",
Role = Role.Donator,
Secret = "password",
UserKey = Guid.NewGuid(),
UserName = "******"
};
using (var context = AuthenticationContext.GetInMemoryContext())
{
var handler = new CreateIdentityRequestHandler(context);
response = await handler.Handle(request);
}
using (var context = AuthenticationContext.GetInMemoryContext())
{
Assert.IsNotNull(response.ActivationToken);
Assert.IsTrue(response.IsSuccess);
Assert.IsTrue(context.Users.Count() == 1);
Assert.AreEqual(request.UserName, context.Users.Single().Name);
Assert.AreEqual(request.UserKey, context.Users.Single().UserKey);
Assert.AreEqual(request.Role, context.Users.Single().Role);
Assert.IsTrue(context.Credentials.Count() == 1);
Assert.AreEqual(request.CredentialType, context.Credentials.Single().CredentialType);
Assert.AreEqual(request.Identifier, context.Credentials.Single().Identifier);
Assert.AreEqual(request.Secret, context.Credentials.Single().Secret);
}
}
finally
{
AuthenticationContext.CloseInMemoryConnection();
}
}
public async Task ActivateUserRequestHandler_Handle_Returns_TokenExpired()
{
AuthenticationContext.OpenInMemoryConnection();
try
{
using (var context = AuthenticationContext.GetInMemoryContext())
{
context.Users.Add(new User
{
Id = Guid.NewGuid(),
Name = "John Doe",
ActivationToken = "testtoken",
ActivationTokenExpirationDate = DateTime.UtcNow.Subtract(TimeSpan.FromDays(1))
});
context.SaveChanges();
}
ActivateUserResponse response;
var request = new ActivateUserRequest
{
ActivationToken = "testtoken"
};
using (var context = AuthenticationContext.GetInMemoryContext())
{
var handler = new ActivateUserRequestHandler(context);
response = await handler.Handle(request);
}
using (var context = AuthenticationContext.GetInMemoryContext())
{
Assert.IsFalse(context.Users.Single().IsActive);
Assert.AreEqual(ErrorType.TokenExpired, response.ErrorType);
Assert.IsFalse(response.IsSuccess);
}
}
finally
{
AuthenticationContext.CloseInMemoryConnection();
}
}
public async Task ActivateUserRequestHandler_Handle_Returns_Success()
{
AuthenticationContext.OpenInMemoryConnection();
try
{
using (var context = AuthenticationContext.GetInMemoryContext())
{
context.Users.Add(new User
{
Id = Guid.NewGuid(),
Name = "John Doe",
ActivationToken = "token",
ActivationTokenExpirationDate = DateTime.UtcNow.AddDays(1)
});
context.SaveChanges();
}
ActivateUserResponse response;
var request = new ActivateUserRequest
{
ActivationToken = "token"
};
using (var context = AuthenticationContext.GetInMemoryContext())
{
var handler = new ActivateUserRequestHandler(context);
response = await handler.Handle(request);
}
using (var context = AuthenticationContext.GetInMemoryContext())
{
Assert.IsTrue(context.Users.Single().IsActive);
Assert.IsNull(context.Users.Single().ActivationToken);
Assert.IsTrue(response.IsSuccess);
}
}
finally
{
AuthenticationContext.CloseInMemoryConnection();
}
}