public void TestInitialize()
{
AppHost = new BasicAppHost().Init();
Container = AppHost.Container;
Pusher = new MockPusher();
IdGenerator = new GuidEntityIdGenerator();
QuestionHelper = new QuestionHelper(Container);
ObjectFactory.Initialize(x => x.Scan(scan =>
{
scan.TheCallingAssembly();
scan.WithDefaultConventions();
}));
Container.Adapter = new StructureMapContainerAdapter();
Container.Register<ISessionFactory>(x => new InMemorySessionFactory());
Container.Register<IImageStorageService>(x => new MockImageStorageService());
Container.Register<ITypedSessionProvider>(x => _sessionProvider);
//Register all services
Container.RegisterAutoWired<UsersService>();
Container.RegisterAutoWired<QuestionService>();
Container.RegisterAutoWired<AnswerService>();
Container.RegisterAutoWired<SearchService>();
new TestConfig().Configure(ObjectFactory.Container);
ObjectFactory.Container.Configure(config => config.For<IPusher>().Use(Pusher).Singleton());
ObjectFactory.Container.AssertConfigurationIsValid();
}
static IAppHost GetAppHost()
{
if (_appHost == null)
{
_appHost = new BasicAppHost();
var authService = new AuthService();
authService.SetAppHost(_appHost);
_appHost.Container.Register(authService);
_appHost.Container.Register<IAuthSession>(authUserSession);
}
return _appHost;
}
public void Run_RunReportsService()
{
var appHost = new BasicAppHost();
appHost.Container.Register(c => new ReportsService { DbFactory = DbFactory });
var service = new RunReportsService
{
Config = Config,
DbFactory = DbFactory,
AppHost = appHost,
};
var response = service.Get(new RunReports { RunType = "all" });
Console.WriteLine(response.Dump());
}
public void Can_register_IDtoBValidator_separately()
{
using (var appHost = new BasicAppHost
{
ConfigureAppHost = host => {
host.RegisterService <DtoAService>();
host.Plugins.Add(new ValidationFeature());
},
ConfigureContainer = c => {
c.RegisterAs <DtoBValidator, IDtoBValidator>();
c.RegisterValidators(typeof(DtoARequestValidator).Assembly);
}
}.Init())
{
var dtoAValidator = (DtoARequestValidator)appHost.TryResolve <IValidator <DtoA> >();
Assert.That(dtoAValidator, Is.Not.Null);
Assert.That(dtoAValidator.dtoBValidator, Is.Not.Null);
Assert.That(appHost.TryResolve <IValidator <DtoB> >(), Is.Not.Null);
Assert.That(appHost.TryResolve <IDtoBValidator>(), Is.Not.Null);
var result = dtoAValidator.Validate(new DtoA());
Assert.That(result.IsValid, Is.False);
Assert.That(result.Errors.Count, Is.EqualTo(1));
result = dtoAValidator.Validate(new DtoA {
FieldA = "foo", Items = new[] { new DtoB() }.ToList()
});
Assert.That(result.IsValid, Is.False);
Assert.That(result.Errors.Count, Is.EqualTo(1));
result = dtoAValidator.Validate(new DtoA {
FieldA = "foo", Items = new[] { new DtoB {
FieldB = "bar"
} }.ToList()
});
Assert.That(result.IsValid, Is.True);
}
}
public void Can_use_NetCore_APIs_to_register_dependencies()
{
using (var appHost = new BasicAppHost().Init())
{
var services = appHost.Container;
services.AddTransient <IFoo, Foo>();
services.AddSingleton <IBar>(c => new Bar {
Name = "bar"
});
var bar = (Bar)services.GetService(typeof(IBar));
Assert.That(bar.Name, Is.EqualTo("bar"));
var foo = (Foo)services.GetService(typeof(IFoo));
Assert.That(foo.Id, Is.EqualTo(0));
Assert.That(ReferenceEquals(foo.Bar, bar));
foo = (Foo)services.GetService(typeof(IFoo));
Assert.That(foo.Id, Is.EqualTo(1));
Assert.That(ReferenceEquals(foo.Bar, bar));
}
}
public void Does_dispose_request_scope_dependency_in_PostMessageHandler()
{
var disposeCount = 0;
using (var appHost = new BasicAppHost(typeof(HelloWithDepService).GetAssembly())
{
ConfigureAppHost = host =>
{
RequestContext.UseThreadStatic = true;
host.Container.Register <IDisposableDependency>(c => new DisposableDependency(() =>
{
Interlocked.Increment(ref disposeCount);
}))
.ReusedWithin(ReuseScope.Request);
host.Container.Register(c => CreateMqServer(host));
var mqServer = host.Container.Resolve <IMessageService>();
mqServer.RegisterHandler <HelloIntroWithDep>(host.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));
}
appHost.Resolve <IMessageService>().Dispose();
}
}
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));
}
}
}
private static void CanOptimizeResult(string contentType, IPlugin pluginFormat)
{
using (var appHost = new BasicAppHost().Init())
{
var dto = new TestDto {
Name = "test"
};
var httpReq = new MockHttpRequest {
PathInfo = "/"
};
httpReq.Headers.Add(HttpHeaders.AcceptEncoding, "gzip,deflate,sdch");
httpReq.ResponseContentType = contentType;
if (pluginFormat != null)
{
pluginFormat.Register(appHost);
}
object result = httpReq.ToOptimizedResult(dto);
Assert.IsNotNull(result);
Assert.IsTrue(result is CompressedResult);
}
}
public void Can_register_IDtoBValidator_separately()
{
using (var appHost = new BasicAppHost
{
ConfigureAppHost = host => {
host.RegisterService <DtoAService>();
host.Plugins.Add(new ValidationFeature());
},
ConfigureContainer = c => {
c.RegisterAs <DtoBValidator, IDtoBValidator>();
c.RegisterValidators(typeof(DtoARequestValidator).Assembly);
}
}.Init())
{
var c = appHost.Container;
var dtoAValidator = (DtoARequestValidator)c.TryResolve <IValidator <DtoA> >();
Assert.That(dtoAValidator, Is.Not.Null);
Assert.That(dtoAValidator.dtoBValidator, Is.Not.Null);
Assert.That(c.TryResolve <IValidator <DtoB> >(), Is.Not.Null);
Assert.That(c.TryResolve <IDtoBValidator>(), Is.Not.Null);
var response = appHost.ExecuteService(new DtoA());
}
}
public void Can_assign_roles_that_persist_to_UserAuthRole_table()
{
using (var appHost = new BasicAppHost
{
ConfigureAppHost = host =>
{
host.Plugins.Add(new AuthFeature(() => new AuthUserSession(), new[] { new BasicAuthProvider() })
{
IncludeRegistrationService = true,
});
},
ConfigureContainer = container =>
{
container.Register <IDbConnectionFactory>(c =>
new OrmLiteConnectionFactory(":memory:", SqliteDialect.Provider));
container.Register <IAuthRepository>(c =>
new OrmLiteAuthRepository(c.Resolve <IDbConnectionFactory>())
{
UseDistinctRoleTables = true,
});
container.Resolve <IAuthRepository>().InitSchema();
}
}.Init())
{
using (var db = appHost.Container.Resolve <IDbConnectionFactory>().Open())
{
var register = CreateNewUserRegistration();
var req = new BasicRequest(register);
req.QueryString["authSecret"] = appHost.Config.AdminAuthSecret = "allow";
var response = (RegisterResponse)appHost.ExecuteService(register, req);
var userAuth = db.SingleById <UserAuth>(response.UserId);
var assignResponse = (AssignRolesResponse)appHost.ExecuteService(new AssignRoles
{
UserName = userAuth.UserName,
Roles = { "TestRole" },
Permissions = { "TestPermission" },
}, req);
Assert.That(assignResponse.AllRoles[0], Is.EqualTo("TestRole"));
Assert.That(assignResponse.AllPermissions[0], Is.EqualTo("TestPermission"));
Assert.That(userAuth.Roles.Count, Is.EqualTo(0));
Assert.That(userAuth.Permissions.Count, Is.EqualTo(0));
var manageRoles = (IManageRoles)appHost.Container.Resolve <IAuthRepository>();
Assert.That(manageRoles.HasRole(userAuth.Id.ToString(), "TestRole"));
Assert.That(manageRoles.HasPermission(userAuth.Id.ToString(), "TestPermission"));
appHost.ExecuteService(new UnAssignRoles
{
UserName = userAuth.UserName,
Roles = { "TestRole" },
Permissions = { "TestPermission" },
}, req);
Assert.That(!manageRoles.HasRole(userAuth.Id.ToString(), "TestRole"));
Assert.That(!manageRoles.HasPermission(userAuth.Id.ToString(), "TestPermission"));
}
}
}
public void Can_assign_roles_that_persist_to_UserAuthRole_table_in_DynamoDb()
{
using (var appHost = new BasicAppHost
{
ConfigureAppHost = host =>
{
host.Plugins.Add(new AuthFeature(() => new AuthUserSession(), new[] { new BasicAuthProvider() })
{
IncludeRegistrationService = true,
});
},
ConfigureContainer = container =>
{
container.Register <IPocoDynamo>(c => new PocoDynamo(TestsConfig.CreateDynamoDBClient()));
//DynamoMetadata.Reset();
container.Resolve <IPocoDynamo>().DeleteAllTables(TimeSpan.FromMinutes(1));
container.Register <IAuthRepository>(c => new DynamoDbAuthRepository(c.Resolve <IPocoDynamo>()));
container.Resolve <IAuthRepository>().InitSchema();
}
}.Init())
{
var db = appHost.Container.Resolve <IPocoDynamo>();
var register = CreateNewUserRegistration();
var req = new BasicRequest(register)
{
QueryString = { ["authSecret"] = appHost.Config.AdminAuthSecret = "allow" }
};
var ret = appHost.ExecuteService(register, req);
var response = (RegisterResponse)ret;
var userAuth = db.GetItem <UserAuth>(response.UserId);
var assignResponse = (AssignRolesResponse)appHost.ExecuteService(new AssignRoles
{
UserName = userAuth.UserName,
Roles = { "TestRole" },
Permissions = { "TestPermission" },
}, req);
Assert.That(assignResponse.AllRoles[0], Is.EqualTo("TestRole"));
Assert.That(assignResponse.AllPermissions[0], Is.EqualTo("TestPermission"));
Assert.That(userAuth.Roles.Count, Is.EqualTo(0));
Assert.That(userAuth.Permissions.Count, Is.EqualTo(0));
var manageRoles = (IManageRoles)appHost.Container.Resolve <IAuthRepository>();
Assert.That(manageRoles.HasRole(userAuth.Id.ToString(), "TestRole"));
Assert.That(manageRoles.HasPermission(userAuth.Id.ToString(), "TestPermission"));
appHost.ExecuteService(new UnAssignRoles
{
UserName = userAuth.UserName,
Roles = { "TestRole" },
Permissions = { "TestPermission" },
}, req);
Assert.That(!manageRoles.HasRole(userAuth.Id.ToString(), "TestRole"));
Assert.That(!manageRoles.HasPermission(userAuth.Id.ToString(), "TestPermission"));
}
}
public void Can_dispose_without_init()
{
BasicAppHost appHost = new BasicAppHost();
appHost.Dispose();
}
public void TestFixtureSetUp()
{
loadAppHost = new BasicAppHost().Init();
}
public void CheckRoleAssignmentInUserRoleTable()
{
using (var appHost = new BasicAppHost
{
ConfigureAppHost = host =>
{
host.Config.AdminAuthSecret = AdminAuthSecret;
},
ConfigureContainer = container =>
{
container.Register <IDbConnectionFactory>(DbConnFactory);
container.Register <IAuthRepository>(c =>
new OrmLiteAuthRepository(c.Resolve <IDbConnectionFactory>())
{
UseDistinctRoleTables = true
});
}
}.Init())
{
// Arrange
UserAuth userAuth;
AssignRolesResponse assignRolesResponse;
var newRegistration = CreateNewUserRegistration();
var request = new BasicRequest(newRegistration);
request.QueryString["authSecret"] = AdminAuthSecret;
var response = (RegisterResponse)appHost.ExecuteService(newRegistration, request);
// Test #1: Check role and permission assignment
// ---------------------------------------------
// Act
using (var db = DbConnFactory.Open())
{
// Hydrate userAuth
userAuth = db.SingleById <UserAuth>(response.UserId);
}
var assignRoleRequest =
new AssignRoles
{
UserName = userAuth.UserName,
Roles = { TestRoleName },
Permissions = { TestPermissionName },
};
// Assert #1.1:
// Check AssignRoles response to contain roles and permissions
assignRolesResponse = (AssignRolesResponse)appHost.ExecuteService(assignRoleRequest, request);
Assert.That(assignRolesResponse.AllRoles[0], Is.EqualTo(TestRoleName));
Assert.That(assignRolesResponse.AllPermissions[0], 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
var unassignRolesRequest =
new UnAssignRoles
{
UserName = userAuth.UserName,
Roles = { TestRoleName },
Permissions = { TestPermissionName },
};
appHost.ExecuteService(unassignRolesRequest, request);
// Assert #2.1:
// 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));
}
}
public void CheckRoleAssignmentInUserAuthTable()
{
using (var appHost = new BasicAppHost
{
ConfigureContainer = container =>
{
container.Register <IDbConnectionFactory>(DbConnFactory);
container.Register <IAuthRepository>(c => new OrmLiteAuthRepository(c.Resolve <IDbConnectionFactory>()));
}
}.Init())
{
// Arrange
UserAuth userAuth;
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
using (var db = DbConnFactory.Open())
{
// Hydrate userAuth
userAuth = db.SingleById <UserAuth>(response.UserId);
}
var assignRoleRequest =
new AssignRoles
{
UserName = userAuth.UserName,
Roles = { TestRoleName },
Permissions = { TestPermissionName },
};
userAuth = (UserAuth)authRepo.GetUserAuthByUserName(assignRoleRequest.UserName);
authRepo.AssignRoles(userAuth, assignRoleRequest.Roles, assignRoleRequest.Permissions);
// Assert:
// 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));
// Test #2: Check role and permission un-assignment
// ------------------------------------------------
// Act
using (var db = DbConnFactory.Open())
{
// Hydrate userAuth
userAuth = db.SingleById <UserAuth>(response.UserId);
}
var unassignRolesRequest =
new UnAssignRoles
{
UserName = userAuth.UserName,
Roles = { TestRoleName },
Permissions = { TestPermissionName },
};
userAuth = (UserAuth)authRepo.GetUserAuthByUserName(assignRoleRequest.UserName);
authRepo.UnAssignRoles(userAuth, unassignRolesRequest.Roles, unassignRolesRequest.Permissions);
// Assert:
// Check UserAuth not to contain roles and permissions above
Assert.That(authRepo.GetRoles(userAuth).FirstOrDefault(), Is.Null);
Assert.That(authRepo.GetPermissions(userAuth).FirstOrDefault(), Is.Null);
}
}
public static RegistrationService GetRegistrationService(
IUserAuthRepository userAuthRepository,
AuthUserSession oAuthUserSession = null,
MockRequestContext requestContext = null)
{
if (requestContext == null)
requestContext = new MockRequestContext();
if (oAuthUserSession == null)
oAuthUserSession = requestContext.ReloadSession();
var httpReq = requestContext.Get<IHttpRequest>();
var httpRes = requestContext.Get<IHttpResponse>();
oAuthUserSession.Id = httpRes.CreateSessionId(httpReq);
httpReq.Items[ServiceExtensions.RequestItemsSessionKey] = oAuthUserSession;
var mockAppHost = new BasicAppHost {
Container = requestContext.Container
};
requestContext.Container.Register(userAuthRepository);
var authService = new AuthService {
RequestContext = requestContext,
};
authService.SetAppHost(mockAppHost);
mockAppHost.Register(authService);
var registrationService = new RegistrationService {
UserAuthRepo = userAuthRepository,
RequestContext = requestContext,
RegistrationValidator =
new RegistrationValidator { UserAuthRepo = RegistrationServiceTests.GetStubRepo() },
};
registrationService.SetAppHost(mockAppHost);
return registrationService;
}
public void Can_dispose_without_init()
{
BasicAppHost appHost = new BasicAppHost();
appHost.Dispose();
}
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));
}
}
public void TestFixtureSetUp()
{
loadAppHost = new BasicAppHost().Init();
}
public void By_default_assigned_roles_are_saved_in_UserAuth_table()
{
using (var appHost = new BasicAppHost
{
ConfigureAppHost = host =>
{
host.Plugins.Add(new AuthFeature(() => new AuthUserSession(), new [] { new BasicAuthProvider() })
{
IncludeRegistrationService = true,
});
},
ConfigureContainer = container =>
{
container.Register <IDbConnectionFactory>(c =>
new OrmLiteConnectionFactory(":memory:", SqliteDialect.Provider));
container.Register <IAuthRepository>(c =>
new OrmLiteAuthRepository(c.Resolve <IDbConnectionFactory>()));
container.Resolve <IAuthRepository>().InitSchema();
}
}.Init())
{
using (var db = appHost.Container.Resolve <IDbConnectionFactory>().Open())
{
var register = CreateNewUserRegistration();
var req = new BasicRequest(register)
{
QueryString = { ["authSecret"] = appHost.Config.AdminAuthSecret = "allow" }
};
var response = (RegisterResponse)appHost.ExecuteService(register, req);
var userAuth = db.SingleById <UserAuth>(response.UserId);
Assert.That(userAuth, Is.Not.Null);
var assignResponse = (AssignRolesResponse)appHost.ExecuteService(new AssignRoles
{
UserName = userAuth.UserName,
Roles = { "TestRole" },
Permissions = { "TestPermission" },
}, req);
Assert.That(assignResponse.AllRoles[0], Is.EqualTo("TestRole"));
Assert.That(assignResponse.AllPermissions[0], Is.EqualTo("TestPermission"));
userAuth = db.SingleById <UserAuth>(response.UserId);
Assert.That(userAuth.Roles[0], Is.EqualTo("TestRole"));
Assert.That(userAuth.Permissions[0], Is.EqualTo("TestPermission"));
appHost.ExecuteService(new UnAssignRoles
{
UserName = userAuth.UserName,
Roles = { "TestRole" },
Permissions = { "TestPermission" },
}, req);
userAuth = db.SingleById <UserAuth>(response.UserId);
Assert.That(userAuth.Roles.Count, Is.EqualTo(0));
Assert.That(userAuth.Permissions.Count, Is.EqualTo(0));
}
}
}
public void CheckRoleAssignmentInUserAuthTableUsingSecretKey()
{
using (var appHost = new BasicAppHost
{
ConfigureAppHost = host =>
{
host.Config.AdminAuthSecret = AdminAuthSecret;
},
ConfigureContainer = container =>
{
container.Register <IUnitOfWork>(c => UnitOfWork);
container.Register <IAuthRepository>(c =>
new LightSpeedUserAuthRepository(c.Resolve <IUnitOfWork>()));
}
}.Init())
{
// Arrange
LightSpeed.UserAuth userAuth;
AssignRolesResponse assignRolesResponse;
var newRegistration = CreateNewUserRegistration();
var request = new BasicRequest(newRegistration);
request.QueryString["authSecret"] = AdminAuthSecret;
var response = (RegisterResponse)appHost.ExecuteService(newRegistration, request);
// 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 },
};
// Assert #1.1:
// Check AssignRoles response to contain roles and permissions
assignRolesResponse = (AssignRolesResponse)appHost.ExecuteService(assignRoleRequest, request);
Assert.That(assignRolesResponse.AllRoles[0], Is.EqualTo(TestRoleName));
Assert.That(assignRolesResponse.AllPermissions[0], Is.EqualTo(TestPermissionName));
// Assert #1.2:
// Check UserAuth to contain roles and permissions
userAuth = UnitOfWork.FindById <LightSpeed.UserAuth>(response.UserId);
Assert.That(userAuth.Roles[0], Is.EqualTo(TestRoleName));
Assert.That(userAuth.Permissions[0], Is.EqualTo(TestPermissionName));
// Test #2: Check role and permission un-assignment
// ------------------------------------------------
// Act
var unassignRolesRequest =
new UnAssignRoles
{
UserName = userAuth.UserName,
Roles = { TestRoleName },
Permissions = { TestPermissionName },
};
appHost.ExecuteService(unassignRolesRequest, request);
// Assert #2.1:
// Check UserAuth not to contain roles and permissions above
userAuth = UnitOfWork.FindById <LightSpeed.UserAuth>(response.UserId);
Assert.That(userAuth.Roles.Count, Is.EqualTo(0));
Assert.That(userAuth.Permissions.Count, Is.EqualTo(0));
}
}
