public void GetUsers_Test()
{
using (var appHost = new BasicAppHost(typeof(GetUsersService).Assembly).Init())
{
var request = new GetUsers
{
UserIds = new ArrayOfLong(1, 2),
UserNames = new ArrayOfString("User3", "User4")
};
var factory = new OrmLiteConnectionFactory(
InMemoryDb, SqliteDialect.Provider);
using (var db = factory.Open())
{
db.DropAndCreateTable<User>();
db.Insert(new User { Id = 1, UserName = "******" });
db.Insert(new User { Id = 2, UserName = "******" });
db.Insert(new User { Id = 3, UserName = "******" });
db.Insert(new User { Id = 4, UserName = "******" });
var handler = appHost.Resolve<GetUsersService>();
var response = handler.Any(request);
Assert.That(response.Users.Count, Is.EqualTo(4));
}
}
}
public void Does_dispose_request_scope_dependency_in_PostMessageHandler()
{
var disposeCount = 0;
using (var appHost = new BasicAppHost(typeof(HelloWithDepService).Assembly)
{
ConfigureAppHost = host =>
{
RequestContext.UseThreadStatic = true;
host.Container.Register<IDisposableDependency>(c => new DisposableDependency(() =>
{
disposeCount++;
}))
.ReusedWithin(ReuseScope.Request);
host.Container.Register(c => CreateMqServer(host));
var mqServer = host.Container.Resolve<IMessageService>();
mqServer.RegisterHandler<HelloIntroWithDep>(host.ServiceController.ExecuteMessage);
mqServer.Start();
}
}.Init())
{
using (var mqClient = appHost.Resolve<IMessageService>().CreateMessageQueueClient())
{
mqClient.Publish(new HelloIntroWithDep { Name = "World" });
IMessage<HelloIntroResponse> responseMsg = mqClient.Get<HelloIntroResponse>(QueueNames<HelloIntroResponse>.In);
mqClient.Ack(responseMsg);
Assert.That(disposeCount, Is.EqualTo(1));
}
}
}
public void Does_process_messages_in_BasicAppHost()
{
using (var appHost = new BasicAppHost(typeof(HelloService).Assembly)
{
ConfigureAppHost = host =>
{
host.Container.Register(c => CreateMqServer());
var mqServer = host.Container.Resolve<IMessageService>();
mqServer.RegisterHandler<HelloIntro>(host.ServiceController.ExecuteMessage);
mqServer.Start();
}
}.Init())
{
using (var mqClient = appHost.Resolve<IMessageService>().CreateMessageQueueClient())
{
mqClient.Publish(new HelloIntro { Name = "World" });
IMessage<HelloIntroResponse> responseMsg = mqClient.Get<HelloIntroResponse>(QueueNames<HelloIntroResponse>.In);
mqClient.Ack(responseMsg);
Assert.That(responseMsg.GetBody().Result, Is.EqualTo("Hello, World!"));
}
}
}
public void CheckRoleAssignmentInUserRoleTableUsingIAuthRepository()
{
using (var appHost = new BasicAppHost
{
ConfigureContainer = container =>
{
container.Register<IUnitOfWork>(c => UnitOfWork);
container.Register<IAuthRepository>(c =>
new LightSpeedUserAuthRepository(c.Resolve<IUnitOfWork>())
{
UseDistinctRoleTables = true
});
}
}.Init())
{
// Arrange
LightSpeed.UserAuth userAuth;
AssignRolesResponse assignRolesResponse;
var newRegistration = CreateNewUserRegistration();
var request = new BasicRequest(newRegistration);
var response = (RegisterResponse)appHost.ExecuteService(newRegistration, request);
var authRepo = appHost.Resolve<IAuthRepository>();
// Test #1: Check role and permission assignment
// ---------------------------------------------
// Act
userAuth = UnitOfWork.FindById<LightSpeed.UserAuth>(response.UserId); // Hydrate userAuth
var assignRoleRequest =
new AssignRoles
{
UserName = userAuth.UserName,
Roles = { TestRoleName },
Permissions = { TestPermissionName },
};
userAuth = (LightSpeed.UserAuth)authRepo.GetUserAuthByUserName(assignRoleRequest.UserName);
authRepo.AssignRoles(userAuth, assignRoleRequest.Roles, assignRoleRequest.Permissions);
// Assert #1.1:
// Check UserAuth to contain roles and permissions
Assert.That(authRepo.GetRoles(userAuth).FirstOrDefault(), Is.EqualTo(TestRoleName));
Assert.That(authRepo.GetPermissions(userAuth).FirstOrDefault(), Is.EqualTo(TestPermissionName));
// Assert #1.2:
// Check that roles and permissions are not persisted to UserAuth table
Assert.That(userAuth.Roles.Count, Is.EqualTo(0));
Assert.That(userAuth.Permissions.Count, Is.EqualTo(0));
// Assert #1.3:
// Check UserRoles table to contain roles and permissions
var manageRoles = (IManageRoles)appHost.Container.Resolve<IAuthRepository>();
Assert.That(manageRoles.HasRole(userAuth.Id.ToString(), TestRoleName));
Assert.That(manageRoles.HasPermission(userAuth.Id.ToString(), TestPermissionName));
// Test #2: Check role and permission un-assignment
// ------------------------------------------------
// Act
userAuth = UnitOfWork.FindById<LightSpeed.UserAuth>(response.UserId); // Hydrate userAuth
var unassignRolesRequest =
new UnAssignRoles
{
UserName = userAuth.UserName,
Roles = { TestRoleName },
Permissions = { TestPermissionName },
};
userAuth = (LightSpeed.UserAuth)authRepo.GetUserAuthByUserName(assignRoleRequest.UserName);
authRepo.UnAssignRoles(userAuth, unassignRolesRequest.Roles, unassignRolesRequest.Permissions);
// Assert #2.1:
// Check UserAuth to contain roles and permissions
Assert.That(authRepo.GetRoles(userAuth).FirstOrDefault(), Is.Null);
Assert.That(authRepo.GetPermissions(userAuth).FirstOrDefault(), Is.Null);
// Assert #2.2:
// Check UserRole table not to contain roles and permissions above
Assert.That(!manageRoles.HasRole(userAuth.Id.ToString(), TestRoleName));
Assert.That(!manageRoles.HasPermission(userAuth.Id.ToString(), TestPermissionName));
}
}
