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)); }