public void GetClass()
{
SecurableClassDefinition classDefinition = _testHelper.CreateClassDefinition("SecurableClass");
StatefulAccessControlList acl = _testHelper.CreateStatefulAcl(classDefinition);
Assert.That(acl.Class, Is.SameAs(classDefinition));
}
public void LeavesPermissionsUntouched()
{
var accessType0 = AccessTypeDefinition.NewObject();
var accessType1 = AccessTypeDefinition.NewObject();
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.AddAccessType(accessType0);
securableClassDefinition.AddAccessType(accessType1);
var testHelper = new AccessControlTestHelper(ClientTransaction.Current);
var acls = new List <AccessControlList>();
acls.Add(testHelper.CreateStatefulAcl(securableClassDefinition));
acls.Add(testHelper.CreateStatelessAcl(securableClassDefinition));
foreach (var acl in acls)
{
var ace = acl.CreateAccessControlEntry();
ace.DenyAccess(accessType0);
ace.AllowAccess(accessType1);
}
securableClassDefinition.MoveAccessType(0, accessType1);
foreach (var acl in acls)
{
var permissions = acl.AccessControlEntries[0].GetPermissions();
Assert.That(permissions.Count, Is.EqualTo(2));
Assert.That(permissions[0].AccessType, Is.SameAs(accessType1));
Assert.That(permissions[0].Allowed, Is.True);
Assert.That(permissions[1].AccessType, Is.SameAs(accessType0));
Assert.That(permissions[1].Allowed, Is.False);
}
}
public SecurableClassDefinition CreateAndCommitSecurableClassDefinitionWithAccessControlLists(int accessControlLists, ClientTransaction transaction)
{
CreateEmptyDomain();
using (transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition classDefinition = CreateOrderSecurableClassDefinition();
StatelessAccessControlList statelessAccessControlList = StatelessAccessControlList.NewObject();
classDefinition.StatelessAccessControlList = statelessAccessControlList;
var stateProperty = StatePropertyDefinition.NewObject(Guid.NewGuid(), "Property");
classDefinition.AddStateProperty(stateProperty);
for (int i = 1; i < accessControlLists; i++)
{
StatefulAccessControlList statefulAccessControlList = StatefulAccessControlList.NewObject();
classDefinition.StatefulAccessControlLists.Add(statefulAccessControlList);
statefulAccessControlList.CreateAccessControlEntry();
CreateStateCombination(statefulAccessControlList, stateProperty, StateDefinition.NewObject(string.Format("Value {0}", i), i));
}
ClientTransactionScope.CurrentTransaction.Commit();
return(classDefinition);
}
}
public void Get_AccessControlListsFromDatabase()
{
DatabaseFixtures dbFixtures = new DatabaseFixtures();
SecurableClassDefinition expectedClassDefinition;
ObjectList <StatefulAccessControlList> expectedAcls;
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
expectedClassDefinition =
dbFixtures.CreateAndCommitSecurableClassDefinitionWithAccessControlLists(10, ClientTransactionScope.CurrentTransaction);
expectedAcls = expectedClassDefinition.StatefulAccessControlLists;
}
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
SecurableClassDefinition actualClassDefinition = expectedClassDefinition.ID.GetObject <SecurableClassDefinition>();
Assert.That(actualClassDefinition.StatefulAccessControlLists.Count, Is.EqualTo(9));
for (int i = 0; i < 9; i++)
{
Assert.That(actualClassDefinition.StatefulAccessControlLists[i].ID, Is.EqualTo(expectedAcls[i].ID));
}
}
}
private void LocalizeStatePropertyEnDe(SecurableClassDefinition classDefinition,
string statePropertyName, string nameEnglish, string nameGerman)
{
var stateProperty = classDefinition.GetStateProperty(statePropertyName);
LocalizeMetadataObjectEnDe(stateProperty, nameEnglish, nameGerman);
}
public void Import_2SecurableClasses()
{
string metadataXml =
@"
<securityMetadata xmlns=""http://www.re-motion.org/Security/Metadata/1.0"">
<classes>
<class id=""00000000-0000-0000-0001-000000000000"" name=""Remotion.Security.UnitTests.TestDomain.File"" />
<class id=""00000000-0000-0000-0002-000000000000"" name=""Remotion.Security.UnitTests.TestDomain.Directory"" />
</classes>
<stateProperties />
<accessTypes />
<abstractRoles />
</securityMetadata>
";
_importer.Import(GetXmlDocument(metadataXml));
using (_testHelper.Transaction.EnterNonDiscardingScope())
{
Assert.AreEqual(2, _importer.Classes.Count, "Class count");
Assert.AreEqual(0, _importer.StateProperties.Count, "State property count");
Assert.AreEqual(0, _importer.AbstractRoles.Count, "Abstract role count");
Assert.AreEqual(0, _importer.AccessTypes.Count, "Access type count");
SecurableClassDefinition actualClass1 = _importer.Classes[new Guid("00000000-0000-0000-0001-000000000000")];
Assert.That(actualClass1.Index, Is.EqualTo(0));
Assert.That(actualClass1.Name, Is.EqualTo("Remotion.Security.UnitTests.TestDomain.File"));
SecurableClassDefinition actualClass2 = _importer.Classes[new Guid("00000000-0000-0000-0002-000000000000")];
Assert.That(actualClass2.Index, Is.EqualTo(1));
Assert.That(actualClass2.Name, Is.EqualTo("Remotion.Security.UnitTests.TestDomain.Directory"));
}
}
public void RemovesAccessType()
{
var accessType0 = AccessTypeDefinition.NewObject();
var accessType1 = AccessTypeDefinition.NewObject();
var accessType2 = AccessTypeDefinition.NewObject();
var accessType3 = AccessTypeDefinition.NewObject();
var accessType4 = AccessTypeDefinition.NewObject();
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.AddAccessType(accessType0);
securableClassDefinition.AddAccessType(accessType1);
securableClassDefinition.AddAccessType(accessType2);
securableClassDefinition.AddAccessType(accessType3);
securableClassDefinition.AddAccessType(accessType4);
securableClassDefinition.RemoveAccessType(accessType2);
Assert.That(securableClassDefinition.AccessTypes, Is.EqualTo(new[] { accessType0, accessType1, accessType3, accessType4 }));
var references = new SecurableClassDefinitionWrapper(securableClassDefinition).AccessTypeReferences;
Assert.That(((AccessTypeReference)references[0]).Index, Is.EqualTo(0));
Assert.That(((AccessTypeReference)references[1]).Index, Is.EqualTo(1));
Assert.That(((AccessTypeReference)references[2]).Index, Is.EqualTo(2));
Assert.That(((AccessTypeReference)references[3]).Index, Is.EqualTo(3));
}
public void MoveToLaterPosition()
{
var accessType0 = AccessTypeDefinition.NewObject();
var accessType1 = AccessTypeDefinition.NewObject();
var accessType2 = AccessTypeDefinition.NewObject();
var accessType3 = AccessTypeDefinition.NewObject();
var accessType4 = AccessTypeDefinition.NewObject();
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.AddAccessType(accessType0);
securableClassDefinition.AddAccessType(accessType1);
securableClassDefinition.AddAccessType(accessType2);
securableClassDefinition.AddAccessType(accessType3);
securableClassDefinition.AddAccessType(accessType4);
securableClassDefinition.MoveAccessType(3, accessType1);
Assert.That(securableClassDefinition.AccessTypes, Is.EqualTo(new[] { accessType0, accessType2, accessType3, accessType1, accessType4 }));
var references = new SecurableClassDefinitionWrapper(securableClassDefinition).AccessTypeReferences;
for (int i = 0; i < references.Count; i++)
{
Assert.That(((AccessTypeReference)references[i]).Index, Is.EqualTo(i));
}
}
public void Commit_DeletedStateCombination()
{
SecurableClassDefinition orderClass = _testHelper.CreateOrderClassDefinition();
using (_testHelper.Transaction.CreateSubTransaction().EnterDiscardingScope())
{
orderClass.EnsureDataAvailable();
Assert.That(orderClass.State, Is.EqualTo(StateType.Unchanged));
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
StateCombination combination = _testHelper.CreateStateCombination(orderClass, ClientTransaction.Current);
combination.AccessControlList.AccessControlEntries.Add(AccessControlEntry.NewObject());
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
orderClass.EnsureDataAvailable();
Assert.That(orderClass.State, Is.EqualTo(StateType.Unchanged));
combination.AccessControlList.Delete();
Assert.That(combination.Class, Is.Null);
Assert.That(orderClass.State, Is.EqualTo(StateType.Changed));
ClientTransaction.Current.Commit();
}
ClientTransaction.Current.Commit();
}
Assert.That(orderClass.State, Is.EqualTo(StateType.Changed));
}
}
public void ValidateUniqueStateCombinations_DoubleStateCombinationAndObjectIsDeleted()
{
AccessControlTestHelper testHelper = new AccessControlTestHelper();
using (testHelper.Transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition orderClass = testHelper.CreateOrderClassDefinition();
List <StateCombination> stateCombinations = testHelper.CreateOrderStateAndPaymentStateCombinations(orderClass);
var states = stateCombinations[0].GetStates();
StatePropertyDefinition orderStateProperty = states[0].StateProperty;
StatePropertyDefinition paymentProperty = states[1].StateProperty;
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
testHelper.CreateStateCombination(
orderClass,
ClientTransaction.Current,
orderStateProperty[EnumWrapper.Get(OrderState.Received).Name],
paymentProperty[EnumWrapper.Get(PaymentState.Paid).Name]);
Assert.That(orderClass.StateCombinations, Is.Not.Empty);
orderClass.Delete();
SecurableClassValidationResult result = new SecurableClassValidationResult();
orderClass.ValidateUniqueStateCombinations(result);
Assert.That(result.IsValid, Is.True);
Assert.That(orderClass.State, Is.EqualTo(StateType.Deleted));
}
}
}
public void RemovesPermissionsForRemovedAccessType()
{
var accessType0 = AccessTypeDefinition.NewObject();
var accessType1 = AccessTypeDefinition.NewObject();
var accessType2 = AccessTypeDefinition.NewObject();
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.AddAccessType(accessType0);
securableClassDefinition.AddAccessType(accessType1);
securableClassDefinition.AddAccessType(accessType2);
var testHelper = new AccessControlTestHelper(ClientTransaction.Current);
var acls = new List <AccessControlList>();
acls.Add(testHelper.CreateStatefulAcl(securableClassDefinition));
acls.Add(testHelper.CreateStatelessAcl(securableClassDefinition));
foreach (var acl in acls)
{
acl.CreateAccessControlEntry();
}
securableClassDefinition.RemoveAccessType(accessType1);
foreach (var acl in acls)
{
var permissions = acl.AccessControlEntries[0].GetPermissions();
Assert.That(permissions.Count, Is.EqualTo(2));
Assert.That(permissions[0].AccessType, Is.SameAs(accessType0));
Assert.That(permissions[1].AccessType, Is.SameAs(accessType2));
}
}
public void GetDerivedClasses_TenFound()
{
DatabaseFixtures dbFixtures = new DatabaseFixtures();
SecurableClassDefinition expectedBaseClassDefinition;
ObjectList <SecurableClassDefinition> expectedDerivedClasses;
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
SecurableClassDefinition[] expectedBaseClassDefinitions =
dbFixtures.CreateAndCommitSecurableClassDefinitionsWithSubClassesEach(10, 10, ClientTransactionScope.CurrentTransaction);
expectedBaseClassDefinition = expectedBaseClassDefinitions[4];
expectedDerivedClasses = expectedBaseClassDefinition.DerivedClasses;
}
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
SecurableClassDefinition actualBaseClassDefinition = expectedBaseClassDefinition.ID.GetObject <SecurableClassDefinition>();
Assert.That(actualBaseClassDefinition.DerivedClasses.Count, Is.EqualTo(10));
for (int i = 0; i < actualBaseClassDefinition.DerivedClasses.Count; i++)
{
Assert.AreEqual(expectedDerivedClasses[i].ID, actualBaseClassDefinition.DerivedClasses[i].ID, "Wrong Index.");
}
}
}
public void Import_ABaseClassAndADerivedClass()
{
string metadataXml =
@"
<securityMetadata xmlns=""http://www.re-motion.org/Security/Metadata/1.0"">
<classes>
<class id=""00000000-0000-0000-0001-000000000000"" name=""Remotion.Security.UnitTests.TestDomain.File"" />
<class id=""00000000-0000-0000-0002-000000000000"" name=""Remotion.Security.UnitTests.TestDomain.PaperFile"" base=""00000000-0000-0000-0001-000000000000"" />
</classes>
<stateProperties />
<accessTypes />
<abstractRoles />
</securityMetadata>";
_importer.Import(GetXmlDocument(metadataXml));
using (_testHelper.Transaction.EnterNonDiscardingScope())
{
Assert.AreEqual(2, _importer.Classes.Count, "Class count");
Assert.AreEqual(0, _importer.StateProperties.Count, "State property count");
Assert.AreEqual(0, _importer.AbstractRoles.Count, "Abstract role count");
Assert.AreEqual(0, _importer.AccessTypes.Count, "Access type count");
SecurableClassDefinition baseClass = _importer.Classes[new Guid("00000000-0000-0000-0001-000000000000")];
SecurableClassDefinition derivedClass = _importer.Classes[new Guid("00000000-0000-0000-0002-000000000000")];
Assert.That(baseClass.DerivedClasses.Count, Is.EqualTo(1));
Assert.That(baseClass.DerivedClasses[0], Is.SameAs(derivedClass));
Assert.That(baseClass.BaseClass, Is.Null);
Assert.That(derivedClass.DerivedClasses.Count, Is.EqualTo(0));
Assert.That(derivedClass.BaseClass, Is.SameAs(baseClass));
}
}
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));
}
private void LoadTree(bool interim, bool refreshTreeNodes)
{
SecurableClassDefinitionTree.LoadUnboundValue(SecurableClassDefinition.FindAllBaseClasses(), interim);
if (refreshTreeNodes)
{
SecurableClassDefinitionTree.RefreshTreeNodes();
}
}
public StateCombination CreateStateCombination(SecurableClassDefinition classDefinition, ClientTransaction transaction, params StateDefinition[] states)
{
using (transaction.EnterNonDiscardingScope())
{
StatefulAccessControlList acl = CreateStatefulAcl(classDefinition, transaction, states);
return(acl.StateCombinations[0]);
}
}
public StatelessAccessControlList GetAclForStateless(SecurableClassDefinition classDefinition)
{
using (_transaction.EnterNonDiscardingScope())
{
List <AccessControlList> acls = CreateAclsForOrderAndPaymentStates(classDefinition);
return((StatelessAccessControlList)acls[4]);
}
}
public AccessControlList GetAclForDeliveredAndUnpaidAndDhlStates(SecurableClassDefinition classDefinition)
{
using (_transaction.EnterNonDiscardingScope())
{
List <AccessControlList> acls = CreateAclsForOrderAndPaymentAndDeliveryStates(classDefinition);
return(acls[2]);
}
}
public List <StateCombination> CreateStateCombinationsForOrder()
{
using (_transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition orderClass = CreateOrderClassDefinition();
return(CreateOrderStateAndPaymentStateCombinations(orderClass));
}
}
public SecurableClassDefinition CreateOrderClassDefinitionWithProperties()
{
SecurableClassDefinition classDefinition = CreateOrderClassDefinition();
CreateOrderStateProperty(classDefinition);
CreatePaymentStateProperty(classDefinition);
return(classDefinition);
}
private SecurableClassDefinition CreateOrderSecurableClassDefinition()
{
SecurableClassDefinition classDefinition = CreateSecurableClassDefinition(
ClientTransactionScope.CurrentTransaction,
new Guid("b8621bc9-9ab3-4524-b1e4-582657d6b420"),
"Remotion.SecurityManager.UnitTests.TestDomain.Order, Remotion.SecurityManager.UnitTests");
return(classDefinition);
}
public StatelessAccessControlList CreateStatelessAcl(SecurableClassDefinition classDefinition, ClientTransaction transaction)
{
using (transaction.EnterNonDiscardingScope())
{
var acl = StatelessAccessControlList.NewObject();
classDefinition.StatelessAccessControlList = acl;
return(acl);
}
}
public void AddsStateProperty()
{
var stateProperty = StatePropertyDefinition.NewObject();
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.AddStateProperty(stateProperty);
Assert.That(securableClassDefinition.StateProperties, Is.EqualTo(new[] { stateProperty }));
}
// construction and disposing
public SecurableClassDefinitionWrapper(SecurableClassDefinition securableClassDefinition)
{
ArgumentUtility.CheckNotNull("securableClassDefinition", securableClassDefinition);
_securableClassDefinition = securableClassDefinition;
_accessTypeReferencesPropertyInfo = _securableClassDefinition.GetPublicDomainObjectType().GetProperty(
"AccessTypeReferences",
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
}
public void GetStates_Empty()
{
SecurableClassDefinition classDefinition = _testHelper.CreateOrderClassDefinition();
StateCombination combination = _testHelper.CreateStateCombination(classDefinition);
StateDefinition[] states = combination.GetStates();
Assert.That(states.Length, Is.EqualTo(0));
}
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 AccessTypeDefinition AttachAccessType(SecurableClassDefinition classDefinition, Guid metadataItemID, string name, int value)
{
using (_transaction.EnterNonDiscardingScope())
{
AccessTypeDefinition accessType = AccessTypeDefinition.NewObject(metadataItemID, name, value);
classDefinition.AddAccessType(accessType);
return(accessType);
}
}
public AccessTypeDefinition AttachJournalizeAccessType(SecurableClassDefinition classDefinition)
{
using (_transaction.EnterNonDiscardingScope())
{
AccessTypeDefinition accessType = CreateJournalizeAccessType();
classDefinition.AddAccessType(accessType);
return(accessType);
}
}
public void Equals_TwoStatelessCombinations()
{
SecurableClassDefinition orderClass = _testHelper.CreateOrderClassDefinition();
StateCombination combination1 = _testHelper.CreateStateCombination(orderClass);
StateCombination combination2 = _testHelper.CreateStateCombination(orderClass);
StateCombinationComparer comparer = new StateCombinationComparer();
Assert.That(comparer.Equals(combination1, combination2), Is.True);
}
public void GetHashCode_TwoStatelessCombinations()
{
SecurableClassDefinition orderClass = _testHelper.CreateOrderClassDefinition();
StateCombination combination1 = _testHelper.CreateStateCombination(orderClass);
StateCombination combination2 = _testHelper.CreateStateCombination(orderClass);
StateCombinationComparer comparer = new StateCombinationComparer();
Assert.That(comparer.GetHashCode(combination2), Is.EqualTo(comparer.GetHashCode(combination1)));
}
