public void GetDisplayName_WithoutPosition()
{
GroupTypePosition groupTypePosition = CreateGroupTypePosition();
groupTypePosition.Position = null;
Assert.That(groupTypePosition.DisplayName, Is.EqualTo("GroupTypeName / "));
}
public void GetDisplayName_WithoutGroupType()
{
GroupTypePosition groupTypePosition = CreateGroupTypePosition();
groupTypePosition.GroupType = null;
Assert.That(groupTypePosition.DisplayName, Is.EqualTo(" / PositionName"));
}
public GroupTypePosition CreateGroupTypePosition(GroupType groupType, Position position)
{
using (_transaction.EnterNonDiscardingScope())
{
GroupTypePosition concretePosition = GroupTypePosition.NewObject();
concretePosition.GroupType = groupType;
concretePosition.Position = position;
return(concretePosition);
}
}
private static GroupTypePosition CreateGroupTypePosition()
{
OrganizationalStructureFactory factory = new OrganizationalStructureFactory();
GroupTypePosition groupTypePosition = GroupTypePosition.NewObject();
groupTypePosition.GroupType = GroupType.NewObject();
groupTypePosition.GroupType.Name = "GroupTypeName";
groupTypePosition.Position = factory.CreatePosition();
groupTypePosition.Position.Name = "PositionName";
return(groupTypePosition);
}
public void DeleteGroupType_WithGroupTypePosition()
{
OrganizationalStructureTestHelper testHelper = new OrganizationalStructureTestHelper();
using (testHelper.Transaction.EnterNonDiscardingScope())
{
GroupType groupType = testHelper.CreateGroupType("GroupType");
Position position = testHelper.CreatePosition("Position");
GroupTypePosition concretePosition = testHelper.CreateGroupTypePosition(groupType, position);
groupType.Delete();
Assert.That(concretePosition.State, Is.EqualTo(StateType.Invalid));
}
}
public void DomainObjectsAreSerializable()
{
CheckDomainObjectSerializability(delegate { return(AccessControlEntry.NewObject()); });
CheckDomainObjectSerializability(delegate { return(StatefulAccessControlList.NewObject()); });
CheckDomainObjectSerializability(delegate { return(Permission.NewObject()); });
CheckDomainObjectSerializability(delegate { return(StateCombination.NewObject()); });
CheckDomainObjectSerializability(delegate { return(StateUsage.NewObject()); });
CheckDomainObjectSerializability(delegate { return(AbstractRoleDefinition.NewObject()); });
CheckDomainObjectSerializability(delegate { return(AccessTypeDefinition.NewObject()); });
CheckDomainObjectSerializability(delegate { return(AccessTypeReference.NewObject()); });
CheckDomainObjectSerializability(delegate { return(Culture.NewObject("DE-DE")); });
CheckDomainObjectSerializability(delegate { return(LocalizedName.NewObject("foo", Culture.NewObject("DE-DE"), SecurableClassDefinition.NewObject())); });
CheckDomainObjectSerializability(delegate { return(SecurableClassDefinition.NewObject()); });
CheckDomainObjectSerializability(delegate { return(StateDefinition.NewObject()); });
CheckDomainObjectSerializability(delegate { return(StatePropertyDefinition.NewObject()); });
CheckDomainObjectSerializability(delegate { return(StatePropertyReference.NewObject()); });
CheckDomainObjectSerializability(delegate { return((Group)LifetimeService.NewObject(ClientTransaction.Current, typeof(Group), ParamList.Empty)); });
CheckDomainObjectSerializability(delegate { return((GroupType)LifetimeService.NewObject(ClientTransaction.Current, typeof(GroupType), ParamList.Empty)); });
CheckDomainObjectSerializability(delegate { return(GroupTypePosition.NewObject()); });
CheckDomainObjectSerializability(delegate { return((Position)LifetimeService.NewObject(ClientTransaction.Current, typeof(Position), ParamList.Empty)); });
CheckDomainObjectSerializability(delegate { return(Role.NewObject()); });
CheckDomainObjectSerializability(delegate { return((Tenant)LifetimeService.NewObject(ClientTransaction.Current, typeof(Tenant), ParamList.Empty)); });
CheckDomainObjectSerializability(delegate { return((User)LifetimeService.NewObject(ClientTransaction.Current, typeof(User), ParamList.Empty)); });
}
public void GetDisplayName_WithGroupTypeAndPosition()
{
GroupTypePosition groupTypePosition = CreateGroupTypePosition();
Assert.That(groupTypePosition.DisplayName, Is.EqualTo("GroupTypeName / PositionName"));
}
/// <summary>
/// Inits security manager database with users, groups, roles, group types, position, etc for 2 tenants.
/// Use to catch sideffect due to incorrect tenant domain seperation.
/// Caution: DB setup is performance critical. Avoid if possible.
/// </summary>
/// <returns>The tenant to use in the test.</returns>
public Tenant CreateAndCommitOrganizationalStructureWithTwoTenants(ClientTransaction transaction)
{
CreateEmptyDomain();
using (transaction.EnterNonDiscardingScope())
{
AbstractRoleDefinition qualityManagerRole = AbstractRoleDefinition.NewObject(
Guid.NewGuid(),
"QualityManager|Remotion.SecurityManager.UnitTests.TestDomain.ProjectRoles, Remotion.SecurityManager.UnitTests",
0);
qualityManagerRole.Index = 1;
AbstractRoleDefinition developerRole = AbstractRoleDefinition.NewObject(
Guid.NewGuid(),
"Developer|Remotion.SecurityManager.UnitTests.TestDomain.ProjectRoles, Remotion.SecurityManager.UnitTests",
1);
developerRole.Index = 0;
Position globalPosition = CreatePosition("Global");
globalPosition.Delegation = Delegation.Enabled;
globalPosition.UniqueIdentifier = "UID: Global";
Position officialPosition = CreatePosition("Official");
officialPosition.UniqueIdentifier = "UID: Official";
officialPosition.Delegation = Delegation.Enabled;
Position managerPosition = CreatePosition("Manager");
managerPosition.Delegation = Delegation.Disabled;
managerPosition.UniqueIdentifier = "UID: Manager";
GroupType groupType1 = CreateGroupType("groupType 1");
GroupType groupType2 = CreateGroupType("groupType 2");
GroupTypePosition groupType1_managerPosition = GroupTypePosition.NewObject();
groupType1_managerPosition.GroupType = groupType1;
groupType1_managerPosition.Position = managerPosition;
GroupTypePosition groupType1_officialPosition = GroupTypePosition.NewObject();
groupType1_officialPosition.GroupType = groupType1;
groupType1_officialPosition.Position = officialPosition;
GroupTypePosition groupType2_officialPosition = GroupTypePosition.NewObject();
groupType2_officialPosition.GroupType = groupType2;
groupType2_officialPosition.Position = officialPosition;
Tenant tenant1 = CreateTenant("TestTenant");
tenant1.UniqueIdentifier = "UID: testTenant";
Group rootGroup = CreateGroup("rootGroup", "RG", "UID: rootGroup", null, tenant1);
for (int i = 0; i < 2; i++)
{
Group parentGroup = CreateGroup(
string.Format("parentGroup{0}", i),
string.Format("PG{0}", i),
string.Format("UID: parentGroup{0}", i),
rootGroup,
tenant1);
parentGroup.GroupType = groupType1;
Group group = CreateGroup(
string.Format("group{0}", i),
string.Format("G{0}", i),
string.Format("UID: group{0}", i),
parentGroup,
tenant1);
group.GroupType = groupType2;
User user1 = CreateUser(string.Format("group{0}/user1", i), string.Empty, "user1", string.Empty, group, tenant1);
User user2 = CreateUser(string.Format("group{0}/user2", i), string.Empty, "user2", string.Empty, group, tenant1);
CreateRole(user1, parentGroup, managerPosition);
CreateRole(user2, parentGroup, officialPosition);
}
Group testRootGroup = CreateGroup("testRootGroup", null, "UID: testRootGroup", null, tenant1);
Group testParentOfOwningGroup = CreateGroup("testParentOfOwningGroup", null, "UID: testParentOfOwningGroup", testRootGroup, tenant1);
Group testOwningGroup = CreateGroup("testOwningGroup", null, "UID: testOwningGroup", testParentOfOwningGroup, tenant1);
Group testGroup = CreateGroup("testGroup", null, "UID: testGroup", null, tenant1);
User testUser = CreateUser("test.user", "test", "user", "Dipl.Ing.(FH)", testOwningGroup, tenant1);
Role officialRole = CreateRole(testUser, testGroup, officialPosition);
Role managerRole = CreateRole(testUser, testGroup, managerPosition);
CreateRole(testUser, testOwningGroup, managerPosition);
CreateRole(testUser, testRootGroup, officialPosition);
User substitutingUser = CreateUser("substituting.user", null, "substitute", null, testRootGroup, tenant1);
CreateRole(substitutingUser, testOwningGroup, managerPosition);
CreateRole(substitutingUser, testRootGroup, officialPosition);
Substitution enabledUserSubstitution = Substitution.NewObject();
enabledUserSubstitution.SubstitutingUser = substitutingUser;
enabledUserSubstitution.SubstitutedUser = testUser;
Substitution enabledRoleSubstitution = Substitution.NewObject();
enabledRoleSubstitution.SubstitutingUser = substitutingUser;
enabledRoleSubstitution.SubstitutedUser = testUser;
enabledRoleSubstitution.SubstitutedRole = officialRole;
Substitution disabledRoleSubstitution = Substitution.NewObject();
disabledRoleSubstitution.SubstitutingUser = substitutingUser;
disabledRoleSubstitution.SubstitutedUser = testUser;
disabledRoleSubstitution.SubstitutedRole = managerRole;
disabledRoleSubstitution.IsEnabled = false;
Tenant tenant2 = CreateTenant("Tenant 2");
Group groupTenant2 = CreateGroup("Group Tenant 2", "GT2", "UID: group Tenant 2", null, tenant2);
User userTenant2 = CreateUser("User.Tenant2", "User", "Tenant 2", string.Empty, groupTenant2, tenant2);
Substitution userTenant2Substitution = Substitution.NewObject();
userTenant2Substitution.SubstitutingUser = userTenant2;
userTenant2Substitution.SubstitutedUser = testUser;
ClientTransactionScope.CurrentTransaction.Commit();
return(tenant1);
}
}
