public void WriteTableDataBodyForSingleState(AclExpansionEntry aclExpansionEntry)
{
if (aclExpansionEntry.AccessControlList is StatelessAccessControlList)
{
HtmlTagWriter.Value(StatelessAclStateHtmlText);
}
else
{
IOrderedEnumerable <StateDefinition> stateDefinitions = GetAllStatesForAclExpansionEntry(aclExpansionEntry);
if (!stateDefinitions.Any())
{
HtmlTagWriter.Value(AclWithNoAssociatedStatesHtmlText);
}
else
{
bool firstElement = true;
foreach (StateDefinition stateDefiniton in stateDefinitions)
{
if (!firstElement)
{
HtmlTagWriter.Value(", ");
}
string stateName = _settings.ShortenNames ? stateDefiniton.ShortName() : stateDefiniton.DisplayName;
HtmlTagWriter.Value(stateName);
firstElement = false;
}
}
}
}
public void AclExpansionEntryIgnoreStateEqualityComparerTest2()
{
var comparer = AclExpansionTree.AclExpansionEntryIgnoreStateEqualityComparer;
var aclSameClassDiffernenStates = TestHelper.CreateStatefulAcl(Acl.Class, new StateDefinition[] { });
var aclDifferentClass = TestHelper.CreateStatefulAcl(TestHelper.CreateClassDefinition("2008-11-26, 16:41"), new StateDefinition[] { });
var a =
new AclExpansionEntry(
User, Role, Acl, new AclExpansionAccessConditions(), new[] { WriteAccessType }, new[] { ReadAccessType, DeleteAccessType });
var aDifferent =
new AclExpansionEntry(
User2, Role2, aclDifferentClass, new AclExpansionAccessConditions {
OwningTenant = Tenant
}, new[] { ReadAccessType }, new[] { DeleteAccessType });
Assert.That(comparer.Equals(a,
new AclExpansionEntry(a.User, a.Role, a.AccessControlList, a.AccessConditions, a.AllowedAccessTypes, a.DeniedAccessTypes)), Is.True);
Assert.That(comparer.Equals(a,
new AclExpansionEntry(a.User, a.Role, aclSameClassDiffernenStates, a.AccessConditions, a.AllowedAccessTypes, a.DeniedAccessTypes)), Is.True);
Assert.That(comparer.Equals(a,
new AclExpansionEntry(aDifferent.User, a.Role, a.AccessControlList, a.AccessConditions, a.AllowedAccessTypes, a.DeniedAccessTypes)), Is.False);
Assert.That(comparer.Equals(a,
new AclExpansionEntry(a.User, aDifferent.Role, a.AccessControlList, a.AccessConditions, a.AllowedAccessTypes, a.DeniedAccessTypes)), Is.False);
Assert.That(comparer.Equals(a,
new AclExpansionEntry(a.User, a.Role, aDifferent.AccessControlList, a.AccessConditions, a.AllowedAccessTypes, a.DeniedAccessTypes)), Is.False);
Assert.That(comparer.Equals(a,
new AclExpansionEntry(a.User, a.Role, a.AccessControlList, aDifferent.AccessConditions, a.AllowedAccessTypes, a.DeniedAccessTypes)), Is.False);
Assert.That(comparer.Equals(a,
new AclExpansionEntry(a.User, a.Role, a.AccessControlList, a.AccessConditions, aDifferent.AllowedAccessTypes, a.DeniedAccessTypes)), Is.False);
Assert.That(comparer.Equals(a,
new AclExpansionEntry(a.User, a.Role, a.AccessControlList, a.AccessConditions, a.AllowedAccessTypes, aDifferent.DeniedAccessTypes)), Is.False);
}
public void GetStateCombinationsTest()
{
SecurableClassDefinition classDefinition = TestHelper.CreateOrderClassDefinition();
var aclExpansionEntry = new AclExpansionEntry(User, Role, Acl, new AclExpansionAccessConditions(), AccessTypeDefinitions, AccessTypeDefinitions2);
var result = aclExpansionEntry.GetStateCombinations();
Assert.That(result, Is.EqualTo(Acl.StateCombinations));
}
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 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 virtual AclExpansionEntry CreateAclExpansionEntry(UserRoleAclAceCombination userRoleAclAce)
{
var accessTypesResult = GetAccessTypes(userRoleAclAce);
AclExpansionEntry aclExpansionEntry = null;
// Create an AclExpansionEntry, if the current probe ACE contributed to the result and returned allowed access types.
if (accessTypesResult.AccessTypeStatistics.IsInAccessTypesContributingAces(userRoleAclAce.Ace) && accessTypesResult.AccessInformation.AllowedAccessTypes.Length > 0)
{
aclExpansionEntry = new AclExpansionEntry(userRoleAclAce.User, userRoleAclAce.Role, userRoleAclAce.Acl, accessTypesResult.AclProbe.AccessConditions,
accessTypesResult.AccessInformation.AllowedAccessTypes, accessTypesResult.AccessInformation.DeniedAccessTypes);
}
return(aclExpansionEntry);
}
public void AclExpansionEntryIgnoreStateEqualityComparerTest()
{
var comparer = AclExpansionTree.AclExpansionEntryIgnoreStateEqualityComparer;
var aclExpansionEntry1 =
new AclExpansionEntry(
User, Role, Acl, new AclExpansionAccessConditions(), new[] { WriteAccessType }, new[] { ReadAccessType, DeleteAccessType });
var aclExpansionEntry2 =
new AclExpansionEntry(
User, Role, Acl2, new AclExpansionAccessConditions(), new[] { WriteAccessType }, new[] { ReadAccessType, DeleteAccessType });
var aclExpansionEntry3 =
new AclExpansionEntry(
User, Role, Acl, new AclExpansionAccessConditions(), new[] { ReadAccessType, WriteAccessType }, new[] { DeleteAccessType });
Assert.That(comparer.Equals(aclExpansionEntry1, aclExpansionEntry1), Is.True);
Assert.That(comparer.Equals(aclExpansionEntry1, aclExpansionEntry2), Is.True);
Assert.That(comparer.Equals(aclExpansionEntry1, aclExpansionEntry3), Is.False);
}
public void GetAccessControlEntriesForUserTest()
{
AclExpansionEntry aclExpansionEntry0 = GetAclExpansionEntryWithUser(User);
AclExpansionEntry aclExpansionEntry1 = GetAclExpansionEntryWithUser(User);
AclExpansionEntry aclExpansionEntry2 = GetAclExpansionEntryWithUser(User);
var aclExpansionEntryList = new List <AclExpansionEntry> ();
aclExpansionEntryList.Add(GetAclExpansionEntryWithUser(User3));
aclExpansionEntryList.Add(aclExpansionEntry0);
aclExpansionEntryList.Add(GetAclExpansionEntryWithUser(User3));
aclExpansionEntryList.Add(GetAclExpansionEntryWithUser(User2));
aclExpansionEntryList.Add(aclExpansionEntry1);
aclExpansionEntryList.Add(GetAclExpansionEntryWithUser(User3));
aclExpansionEntryList.Add(aclExpansionEntry2);
aclExpansionEntryList.Add(GetAclExpansionEntryWithUser(User2));
var aclExpansionEntryListResult = AclExpansionMultiFileHtmlWriter.GetAccessControlEntriesForUser(aclExpansionEntryList, User);
Assert.That(aclExpansionEntryListResult, Is.EquivalentTo(ListObjectMother.New(aclExpansionEntry0, aclExpansionEntry1, aclExpansionEntry2)));
Assert.That(aclExpansionEntryListResult, Is.EquivalentTo(ListObjectMother.New(aclExpansionEntry0, aclExpansionEntry1, aclExpansionEntry2)));
}
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 DeniedRightsTest()
{
var aclExpansionEntry = new AclExpansionEntry(
User, Role, Acl, new AclExpansionAccessConditions(), new[] { DeleteAccessType }, new[] { ReadAccessType, WriteAccessType });
var aclExpansionEntryList = ListObjectMother.New(aclExpansionEntry);
using (var textWriter = new StringWriter())
{
var aclExpansionWriter = new AclExpansionHtmlWriter(textWriter, true,
new AclExpansionHtmlWriterSettings {
OutputDeniedRights = true
});
aclExpansionWriter.WriteAclExpansion(aclExpansionEntryList);
string result = textWriter.ToString();
//Clipboard.SetText (result);
// Detail tests
Assert.That(result, Is.StringContaining("Denied Rights</th>")); // Denied rights header
Assert.That(result, Is.StringContaining("<td>Delete</td>")); // allowed rights
Assert.That(result, Is.StringContaining("<td>Read, Write</td>")); // denied rights
const string resultExpected =
#region
@"<!DOCTYPE HTML PUBLIC ""-//W3C//DTD HTML 4.0 Transitional//EN"" """">
<html>
<head>
<title>re-motion ACL Expansion</title>
<style>@import ""AclExpansion.css"";</style>
<meta http-equiv=""Content-Type"" content=""text/html; charset=UTF-8"" />
</head>
<body>
<table style=""width: 100%;"" class=""aclExpansionTable"" id=""remotion-ACL-expansion-table"">
<tr>
<th class=""header"">User</th>
<th class=""header"">Role</th>
<th class=""header"">Class</th>
<th class=""header"">States</th>
<th class=""header"">User Must Own</th>
<th class=""header"">Owning Group Equals</th>
<th class=""header"">Owning Tenant Equals</th>
<th class=""header"">User Must Have Abstract Role</th>
<th class=""header"">Access Rights</th>
<th class=""header"">Denied Rights</th>
</tr>
<tr>
<td rowspan=""1"">Usa Da, Dr.</td>
<td rowspan=""1"">Da Group, Supreme Being</td>
<td rowspan=""1"">Order</td>
<td>DHL, None, Received</td>
<td></td>
<td></td>
<td></td>
<td></td>
<td>Delete</td>
<td>Read, Write</td>
</tr>
</table>
</body>
</html>";
#endregion
// Full test
Assert.That(result, Is.EqualTo(resultExpected));
}
}
private void AssertAclExpansionEntryAccessTypesAndConditions(AclExpansionEntry actualAclExpansionEntry, AccessTypeDefinition[] expectedAccessTypeDefinitions,
AclExpansionAccessConditions expectedAclExpansionAccessConditions)
{
Assert.That(actualAclExpansionEntry.AllowedAccessTypes, Is.EquivalentTo(expectedAccessTypeDefinitions));
Assert.That(actualAclExpansionEntry.AccessConditions, Is.EqualTo(expectedAclExpansionAccessConditions));
}
private IOrderedEnumerable <StateDefinition> GetAllStatesForAclExpansionEntry(AclExpansionEntry aclExpansionEntry)
{
// Get all states for AclExpansionEntry by flattening the StateCombinations of the AccessControlEntry ACL.
return(aclExpansionEntry.GetStateCombinations().SelectMany(x => x.GetStates()).OrderBy(x => x.DisplayName));
}
