public void GetHashCodeTest()
{
var aclExpansionAccessConditions = new AclExpansionAccessConditions();
Assert.That(aclExpansionAccessConditions.GetHashCode(),
Is.EqualTo(AclExpansionAccessConditions.EqualityComparer.GetHashCode(aclExpansionAccessConditions)));
}
private void WriteTableDataForOwningGroupCondition(AclExpansionAccessConditions conditions)
{
Assertion.IsFalse(conditions.GroupHierarchyCondition == GroupHierarchyCondition.Undefined && conditions.OwningGroup != null);
HtmlTagWriter.Tags.td();
HtmlTagWriter.Value(""); // To force <td></td> instead of <td />
var owningGroup = conditions.OwningGroup;
if (owningGroup != null)
{
HtmlTagWriter.Value(owningGroup.DisplayName);
}
var groupHierarchyCondition = conditions.GroupHierarchyCondition;
// Bitwise operation is OK (alas marking GroupHierarchyCondition with [Flags] is not supported).
if ((groupHierarchyCondition & GroupHierarchyCondition.Parent) != 0)
{
HtmlTagWriter.Tags.br();
HtmlTagWriter.Value(AclToolsExpansion.OrItsParents); // or its parents
}
// Bitwise operation is OK (alas marking GroupHierarchyCondition with [Flags] is not supported).
if ((groupHierarchyCondition & GroupHierarchyCondition.Children) != 0)
{
HtmlTagWriter.Tags.br();
HtmlTagWriter.Value(AclToolsExpansion.OrItsChildren); // or its children
}
HtmlTagWriter.Tags.tdEnd();
}
public void WriteTableDataForBodyConditions(AclExpansionAccessConditions accessConditions)
{
WriteTableDataForBooleanCondition(accessConditions.IsOwningUserRequired);
WriteTableDataForOwningGroupCondition(accessConditions);
WriteTableDataForOwningTenantCondition(accessConditions);
WriteTableDataForAbstractRoleCondition(accessConditions);
}
public void WriteTableDataForAbstractRoleConditionNoAbstractRoleTest()
{
AclExpansionAccessConditions accessConditions = new AclExpansionAccessConditions {
AbstractRole = null
};
AssertAclExpansionHtmlWriterImplementationResult(x => x.WriteTableDataForAbstractRoleCondition(accessConditions), "<td></td>");
}
public void EqualsByCheckingCompoundValueEqualityComparerParticipatingObjects()
{
var a = new AclExpansionAccessConditions();
var equalityObjects = AclExpansionAccessConditions.EqualityComparer.GetEqualityParticipatingObjects(a);
Assert.That(equalityObjects, Is.EqualTo(new object[] { a.AbstractRole, a.OwningGroup, a.OwningTenant,
a.GroupHierarchyCondition, a.TenantHierarchyCondition, a.IsOwningUserRequired }));
}
public void WriteTableDataForAbstractRoleConditionAbstractRoleTest()
{
var abstractRole = TestHelper.CreateTestAbstractRole();
AclExpansionAccessConditions accessConditions = new AclExpansionAccessConditions {
AbstractRole = abstractRole
};
AssertAclExpansionHtmlWriterImplementationResult(x => x.WriteTableDataForAbstractRoleCondition(accessConditions), "<td>Test</td>");
}
public void StateCombinationsForStatelessAclThrowsTest()
{
SecurableClassDefinition classDefinition = TestHelper.CreateOrderClassDefinition();
var statlessAcl = TestHelper.CreateStatelessAcl(classDefinition);
var accessConditions = new AclExpansionAccessConditions();
var aclExpansionEntry = new AclExpansionEntry(User, Role, statlessAcl, accessConditions, AccessTypeDefinitions, AccessTypeDefinitions2);
Dev.Null = aclExpansionEntry.GetStateCombinations();
}
public void GetAclExpansionEntryList_AceWithPosition_GroupSelectionAll()
{
List <AclExpansionEntry> aclExpansionEntryList =
GetAclExpansionEntryList_UserPositionGroupSelection(User, Position, GroupCondition.None, GroupHierarchyCondition.Undefined);
var accessTypeDefinitionsExpected = new[] { ReadAccessType, DeleteAccessType };
var accessConditions = new AclExpansionAccessConditions();
Assert.That(aclExpansionEntryList.Count, Is.EqualTo(1));
Assert.That(aclExpansionEntryList[0].AllowedAccessTypes, Is.EquivalentTo(accessTypeDefinitionsExpected));
Assert.That(aclExpansionEntryList[0].AccessConditions, Is.EqualTo(accessConditions));
}
public void DefaultCtor()
{
var accessConditions = new AclExpansionAccessConditions();
Assert.That(accessConditions.AbstractRole, Is.Null);
Assert.That(accessConditions.IsAbstractRoleRequired, Is.EqualTo(false));
Assert.That(accessConditions.HasOwningGroupCondition, Is.EqualTo(false));
Assert.That(accessConditions.HasOwningTenantCondition, Is.EqualTo(false));
Assert.That(accessConditions.IsOwningUserRequired, Is.EqualTo(false));
Assert.That(accessConditions.OwningGroup, Is.EqualTo(null));
Assert.That(accessConditions.GroupHierarchyCondition, Is.EqualTo(GroupHierarchyCondition.Undefined));
}
public void CreateAclProbe_GroupSelectionAll_Test()
{
AccessControlEntry ace = TestHelper.CreateAceWithoutGroupCondition();
FleshOutAccessControlEntryForTest(ace);
AclProbe aclProbe = AclProbe.CreateAclProbe(User, Role, ace);
Assert.That(aclProbe.SecurityToken.OwningGroup, Is.Null);
var accessConditionsExpected = new AclExpansionAccessConditions();
Assert.That(aclProbe.AccessConditions, Is.EqualTo(accessConditionsExpected));
}
public void CtorTest()
{
var accessConditions = new AclExpansionAccessConditions();
var aclExpansionEntry = new AclExpansionEntry(User, Role, Acl, accessConditions, AccessTypeDefinitions, AccessTypeDefinitions2);
Assert.That(aclExpansionEntry.User, Is.EqualTo(User));
Assert.That(aclExpansionEntry.Role, Is.EqualTo(Role));
Assert.That(aclExpansionEntry.Class, Is.EqualTo(Acl.Class));
Assert.That(aclExpansionEntry.GetStateCombinations(), Is.EqualTo(Acl.StateCombinations));
Assert.That(aclExpansionEntry.AccessConditions, Is.EqualTo(accessConditions));
Assert.That(aclExpansionEntry.AllowedAccessTypes, Is.EqualTo(AccessTypeDefinitions));
Assert.That(aclExpansionEntry.DeniedAccessTypes, Is.EqualTo(AccessTypeDefinitions2));
}
public void CreateAclProbe_SpecificTenant_Test()
{
AccessControlEntry ace = TestHelper.CreateAceWithSpecificTenant(Tenant);
FleshOutAccessControlEntryForTest(ace);
AclProbe aclProbe = AclProbe.CreateAclProbe(User, Role, ace);
Assert.That(aclProbe.SecurityToken.OwningTenant, Is.Null);
var accessConditionsExpected = new AclExpansionAccessConditions();
Assert.That(aclProbe.AccessConditions, Is.EqualTo(accessConditionsExpected));
}
public void CreateAclProbe_SpecificAbstractRole_Test()
{
AccessControlEntry ace = TestHelper.CreateAceWithAbstractRole();
FleshOutAccessControlEntryForTest(ace);
Assert.That(ace.SpecificAbstractRole, Is.Not.Null);
AclProbe aclProbe = AclProbe.CreateAclProbe(User, Role, ace);
Assert.That(aclProbe.SecurityToken.AbstractRoles, Has.Member(ace.SpecificAbstractRole).Using(DomainObjectHandleComparer.Instance));
var accessConditionsExpected = new AclExpansionAccessConditions();
accessConditionsExpected.AbstractRole = ace.SpecificAbstractRole;
Assert.That(aclProbe.AccessConditions, Is.EqualTo(accessConditionsExpected));
}
public void GetAclExpansionEntryList_AceWithPosition_GroupSelectionOwningGroup()
{
List <AclExpansionEntry> aclExpansionEntryList =
GetAclExpansionEntryList_UserPositionGroupSelection(User, Position, GroupCondition.OwningGroup, GroupHierarchyCondition.This);
var accessTypeDefinitionsExpected = new[] { ReadAccessType, DeleteAccessType };
var accessConditions = new AclExpansionAccessConditions
{
OwningGroup = aclExpansionEntryList[0].Role.Group, // GroupSelection.OwningGroup => group must be owner
GroupHierarchyCondition = GroupHierarchyCondition.This
};
Assert.That(aclExpansionEntryList.Count, Is.EqualTo(1));
Assert.That(aclExpansionEntryList[0].AllowedAccessTypes, Is.EquivalentTo(accessTypeDefinitionsExpected));
Assert.That(aclExpansionEntryList[0].AccessConditions, Is.EqualTo(accessConditions));
}
public void CreateAclProbe_OwningGroup_Test()
{
AccessControlEntry ace = TestHelper.CreateAceWithOwningGroup();
FleshOutAccessControlEntryForTest(ace);
AclProbe aclProbe = AclProbe.CreateAclProbe(User, Role, ace);
Assert.That(aclProbe.SecurityToken.OwningGroup, Is.EqualTo(Role.Group).Using(DomainObjectHandleComparer.Instance));
var accessConditionsExpected = new AclExpansionAccessConditions
{
OwningGroup = Group,
GroupHierarchyCondition = GroupHierarchyCondition.ThisAndChildren
};
Assert.That(aclProbe.AccessConditions, Is.EqualTo(accessConditionsExpected));
}
public void CreateAclProbe_OwningTenant_Test()
{
AccessControlEntry ace = TestHelper.CreateAceWithOwningTenant();
FleshOutAccessControlEntryForTest(ace);
AclProbe aclProbe = AclProbe.CreateAclProbe(User, Role, ace);
Assert.That(aclProbe.SecurityToken.OwningTenant, Is.EqualTo(User.Tenant).Using(DomainObjectHandleComparer.Instance));
var accessConditionsExpected = new AclExpansionAccessConditions
{
OwningTenant = Tenant,
TenantHierarchyCondition = TenantHierarchyCondition.This
};
Assert.That(aclProbe.AccessConditions, Is.EqualTo(accessConditionsExpected));
}
public void TenantHierarchyConditionTest()
{
// Create a new user whose tenant has a parent
var tenant = TestHelper.CreateTenant("Tenant");
var parentTenant = TestHelper.CreateTenant("Parent Tenant");
tenant.Parent = parentTenant;
var group = TestHelper.CreateGroup("Group", null, tenant);
var position = TestHelper.CreatePosition("Position");
var user = TestHelper.CreateUser("User", "U", "Ser", "Dr", group, tenant);
TestHelper.CreateRole(user, group, position);
var ace = TestHelper.CreateAceWithOwningTenant();
ace.TenantHierarchyCondition = TenantHierarchyCondition.ThisAndParent;
AttachAccessTypeReadWriteDelete(ace, null, true, null);
Assert.That(ace.Validate().IsValid);
var acl = TestHelper.CreateStatefulAcl(ace);
List <AccessControlList> aclList = new List <AccessControlList> ();
aclList.Add(acl);
List <AclExpansionEntry> aclExpansionEntryList = GetAclExpansionEntryList(ListObjectMother.New(User), aclList);
var owningTenant = aclExpansionEntryList[0].User.Tenant;
var tenantHierarchyCondition = TenantHierarchyCondition.ThisAndParent;
var accessConditions = new AclExpansionAccessConditions
{
OwningTenant = owningTenant,
TenantHierarchyCondition = tenantHierarchyCondition
};
var accessTypeDefinitionsExpected = new[] { WriteAccessType };
Assert.That(aclExpansionEntryList.Count, Is.EqualTo(1));
Assert.That(aclExpansionEntryList[0].AllowedAccessTypes, Is.EquivalentTo(accessTypeDefinitionsExpected));
Assert.That(aclExpansionEntryList[0].AccessConditions.OwningTenant, Is.EqualTo(owningTenant));
Assert.That(aclExpansionEntryList[0].AccessConditions.TenantHierarchyCondition, Is.EqualTo(tenantHierarchyCondition));
Assert.That(aclExpansionEntryList[0].AccessConditions, Is.EqualTo(accessConditions));
}
public void GetAclExpansionEntryList_UserList_AceList()
{
var ace = TestHelper.CreateAceWithPositionAndGroupCondition(Position, GroupCondition.OwningGroup);
AttachAccessTypeReadWriteDelete(ace, true, null, true);
List <AclExpansionEntry> aclExpansionEntryList =
GetAclExpansionEntryList(
ListObjectMother.New(User),
ListObjectMother.New(TestHelper.CreateStatefulAcl(ace)), false);
var accessTypeDefinitionsExpected = new[] { ReadAccessType, DeleteAccessType };
var accessConditions = new AclExpansionAccessConditions
{
OwningGroup = User.Roles[0].Group, // GroupSelection.OwningGroup => group must be owner
GroupHierarchyCondition = GroupHierarchyCondition.ThisAndParent
};
Assert.That(aclExpansionEntryList.Count, Is.EqualTo(1));
Assert.That(aclExpansionEntryList[0].AllowedAccessTypes, Is.EquivalentTo(accessTypeDefinitionsExpected));
Assert.That(aclExpansionEntryList[0].AccessConditions, Is.EqualTo(accessConditions));
}
public void GetAclExpansionEntryListSortedAndDistinctTest()
{
var userRoleAclAceCombinationFinderStub = MockRepository.GenerateStub <IUserRoleAclAceCombinationFinder> ();
var mocks = new MockRepository();
var aclExpanderMock = mocks.PartialMock <AclExpander> (userRoleAclAceCombinationFinderStub);
var accessConditions = new AclExpansionAccessConditions();
var accessTypeDefinitions = new AccessTypeDefinition[0];
var aclExpansionEntry0 = new AclExpansionEntry(User2, Role, Acl, accessConditions, accessTypeDefinitions, accessTypeDefinitions);
var aclExpansionEntry1 = new AclExpansionEntry(User3, Role, Acl, accessConditions, accessTypeDefinitions, accessTypeDefinitions);
var aclExpansionEntry2 = new AclExpansionEntry(User, Role, Acl, accessConditions, accessTypeDefinitions, accessTypeDefinitions);
var aclExpansionEntryList = ListObjectMother.New(aclExpansionEntry0, aclExpansionEntry2, aclExpansionEntry1, aclExpansionEntry1, aclExpansionEntry0);
aclExpanderMock.Expect(x => x.GetAclExpansionEntryList()).Return(aclExpansionEntryList);
aclExpanderMock.Replay();
var aclExpansionEntryListResult = aclExpanderMock.GetAclExpansionEntryListSortedAndDistinct();
var aclExpansionEntryListExpected = ListObjectMother.New(aclExpansionEntry1, aclExpansionEntry0, aclExpansionEntry2);
Assert.That(aclExpansionEntryListResult, Is.EqualTo(aclExpansionEntryListExpected));
aclExpanderMock.VerifyAllExpectations();
}
public void AssertTenantHierarchyCondition(Tenant owningTenant, TenantHierarchyCondition tenantHierarchyCondition, string inResultingHtmlString,
string[] notInResultingHtmlStrings)
{
var accessConditions = new AclExpansionAccessConditions {
OwningTenant = owningTenant, TenantHierarchyCondition = tenantHierarchyCondition
};
var aclExpansionEntry = new AclExpansionEntry(User, Role, Acl, accessConditions, new AccessTypeDefinition[0], new AccessTypeDefinition[0]);
List <AclExpansionEntry> aclExpansion = ListObjectMother.New(aclExpansionEntry);
var stringWriter = new StringWriter();
var aclExpansionHtmlWriter = new AclExpansionHtmlWriter(stringWriter, true, new AclExpansionHtmlWriterSettings());
aclExpansionHtmlWriter.WriteAclExpansion(aclExpansion);
string result = stringWriter.ToString();
//Clipboard.SetText (result);
Assert.That(result, Is.StringContaining(inResultingHtmlString));
foreach (string notInResultingHtml in notInResultingHtmlStrings)
{
Assert.That(result, Is.Not.StringContaining(notInResultingHtml));
}
}
public void WriteTableDataForAbstractRoleCondition(AclExpansionAccessConditions accessConditions)
{
HtmlTagWriter.Tags.td();
HtmlTagWriter.Value(accessConditions.IsAbstractRoleRequired ? accessConditions.AbstractRole.DisplayName : "");
HtmlTagWriter.Tags.tdEnd();
}
private void AssertAclExpansionEntryAccessTypesAndConditions(AclExpansionEntry actualAclExpansionEntry, AccessTypeDefinition[] expectedAccessTypeDefinitions,
AclExpansionAccessConditions expectedAclExpansionAccessConditions)
{
Assert.That(actualAclExpansionEntry.AllowedAccessTypes, Is.EquivalentTo(expectedAccessTypeDefinitions));
Assert.That(actualAclExpansionEntry.AccessConditions, Is.EqualTo(expectedAclExpansionAccessConditions));
}
