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);
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 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(DynamoConfig.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);
req.QueryString["authSecret"] = appHost.Config.AdminAuthSecret = "allow";
var response = (RegisterResponse)appHost.ExecuteService(register, req);
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_assign_roles_that_persist_to_UserAuthRole_table()
{
using (var appHost = new BasicAppHost
{
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 By_default_assigned_roles_are_saved_in_UserAuth_table()
{
using (var appHost = new BasicAppHost
{
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);
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"));
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 Can_use_nested_classes_as_Request_DTOs()
{
using (var appHost = new BasicAppHost(typeof(NestedService).Assembly).Init())
{
var root = (Root)appHost.ExecuteService(new Root {
Id = 1
});
Assert.That(root.Id, Is.EqualTo(1));
var nested = (Root.Nested)appHost.ExecuteService(new Root.Nested {
Id = 2
});
Assert.That(nested.Id, Is.EqualTo(2));
}
}
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());
response.PrintDump();
}
}
public void Can_Mock_Session_in_Container()
{
using (var appHost = new BasicAppHost
{
ConfigureAppHost = host => host.RegisterService(typeof(MockSessionTestService)),
ConfigureContainer = x => x.Register <IAuthSession>(c => CreateUserSession())
}.Init())
{
var response = appHost.ExecuteService(new MockSessionTest()) as AuthUserSession;
Assert.That(response.UserAuthId, Is.EqualTo("1"));
Assert.That(response.UserAuthName, Is.EqualTo("Mocked"));
Assert.That(response.PrimaryEmail, Is.EqualTo("*****@*****.**"));
}
}
public void Can_Mock_Session_in_RequestFilterAttribute()
{
using (var appHost = new BasicAppHost
{
ConfigureAppHost = host =>
{
host.RegisterService(typeof(MockSessionTestService));
}
}.Init())
{
var response = appHost.ExecuteService(new MockSessionAttributeTest()) as AuthUserSession;
Assert.That(response.UserAuthId, Is.EqualTo("1"));
Assert.That(response.UserAuthName, Is.EqualTo("Mocked"));
Assert.That(response.PrimaryEmail, Is.EqualTo("*****@*****.**"));
}
}
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 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));
}
}
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 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));
}
}