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 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 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 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 AddsStateProperty()
{
var stateProperty = StatePropertyDefinition.NewObject();
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.AddStateProperty(stateProperty);
Assert.That(securableClassDefinition.StateProperties, Is.EqualTo(new[] { stateProperty }));
}
public void DeleteFailsIfStatePropertyDefinitionIsAssociatedWithSecurableClassDefinition()
{
var securableClassDefinition = SecurableClassDefinition.NewObject();
var property = _testHelper.CreateNewStateProperty("NewProperty");
securableClassDefinition.AddStateProperty(property);
var messge = "State property 'NewProperty' cannot be deleted because it is associated with at least one securable class definition.";
Assert.That(() => property.Delete(), Throws.InvalidOperationException.And.Message.EqualTo(messge));
}
private SecurableClassDefinition CreateSecurableClassDefinition(ClientTransaction transaction, Guid metadataItemID, string name)
{
using (transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition classDefinition = SecurableClassDefinition.NewObject();
classDefinition.MetadataItemID = metadataItemID;
classDefinition.Name = name;
return(classDefinition);
}
}
private void CreateDerivedSecurableClassDefinitions(SecurableClassDefinition baseClassDefinition, int classDefinitionCount)
{
for (int i = 0; i < classDefinitionCount; i++)
{
SecurableClassDefinition classDefinition = SecurableClassDefinition.NewObject();
classDefinition.MetadataItemID = Guid.NewGuid();
classDefinition.Name = string.Format("{0} - Subsclass {0}", baseClassDefinition.Name, i);
classDefinition.Index = i;
classDefinition.BaseClass = baseClassDefinition;
}
}
public SecurableClassDefinition CreateClassDefinition(string name, SecurableClassDefinition baseClass)
{
using (_transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition classDefinition = SecurableClassDefinition.NewObject();
classDefinition.Name = name;
classDefinition.BaseClass = baseClass;
return(classDefinition);
}
}
public void FailsForIndexGreaterThanNumberOfItems()
{
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.Name = "Class";
securableClassDefinition.AddAccessType(AccessTypeDefinition.NewObject());
Assert.That(
() => securableClassDefinition.InsertAccessType(2, AccessTypeDefinition.NewObject()),
Throws.TypeOf <ArgumentOutOfRangeException>()
.And.Message.StartsWith(
"The index must not be less than 0 or greater than the total number of access types for the securable class definition."));
}
public void FailsForNonExistentAccessType()
{
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.Name = "Class";
securableClassDefinition.AddAccessType(AccessTypeDefinition.NewObject());
securableClassDefinition.AddAccessType(AccessTypeDefinition.NewObject());
Assert.That(
() => securableClassDefinition.RemoveAccessType(AccessTypeDefinition.NewObject(Guid.NewGuid(), "Test", 42)),
Throws.ArgumentException
.And.Message.StartsWith("The access type 'Test' is not associated with the securable class definition."));
}
public void DeleteFailsIfStateDefinitionIsAssociatedWithStateProperty()
{
var accessType = _testHelper.CreateAccessTypeCreate(0);
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.AddAccessType(accessType);
var messge = "Access type 'Create|Remotion.Security.GeneralAccessTypes, Remotion.Security' "
+ "cannot be deleted because it is associated with at least one securable class definition.";
Assert.That(() => accessType.Delete(), Throws.InvalidOperationException.And.Message.EqualTo(messge));
}
public void RegisterForCommit_AfterCreation()
{
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
SecurableClassDefinition classDefinition = SecurableClassDefinition.NewObject();
Assert.That(classDefinition.State, Is.EqualTo(StateType.New));
Assert.That(() => classDefinition.RegisterForCommit(), Throws.Nothing);
Assert.That(classDefinition.State, Is.EqualTo(StateType.New));
}
}
public void FailsForNonExistentStateProperty()
{
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.Name = "Class";
securableClassDefinition.AddStateProperty(StatePropertyDefinition.NewObject());
securableClassDefinition.AddStateProperty(StatePropertyDefinition.NewObject());
Assert.That(
() => securableClassDefinition.RemoveStateProperty(StatePropertyDefinition.NewObject(Guid.NewGuid(), "Test")),
Throws.ArgumentException
.And.Message.StartsWith("The property 'Test' does not exist on the securable class definition."));
}
public void FailsForExistingAccessType()
{
var accessType = AccessTypeDefinition.NewObject(Guid.NewGuid(), "Test", 42);
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.Name = "Class";
securableClassDefinition.AddAccessType(accessType);
Assert.That(
() => securableClassDefinition.AddAccessType(accessType),
Throws.ArgumentException
.And.Message.StartsWith("The access type 'Test' has already been added to the securable class definition."));
}
public void RegisterForCommit_AfterDiscard()
{
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
SecurableClassDefinition classDefinition = SecurableClassDefinition.NewObject();
classDefinition.Delete();
Assert.That(classDefinition.State, Is.EqualTo(StateType.Invalid));
Assert.That(() => classDefinition.RegisterForCommit(), Throws.TypeOf <ObjectInvalidException>());
}
}
public void RemovesStateProperty()
{
var stateProperty0 = StatePropertyDefinition.NewObject();
var stateProperty1 = StatePropertyDefinition.NewObject();
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.AddStateProperty(stateProperty0);
securableClassDefinition.AddStateProperty(stateProperty1);
securableClassDefinition.RemoveStateProperty(stateProperty0);
Assert.That(securableClassDefinition.StateProperties, Is.EqualTo(new[] { stateProperty1 }));
}
public void FailsForExistingStateProperty()
{
var stateProperty = StatePropertyDefinition.NewObject(Guid.NewGuid(), "Test");
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.Name = "Class";
securableClassDefinition.AddStateProperty(stateProperty);
Assert.That(
() => securableClassDefinition.AddStateProperty(stateProperty),
Throws.ArgumentException
.And.Message.StartsWith("The property 'Test' has already been added to the securable class definition."));
}
public void TouchesSecurableClassDefinition()
{
var securableClassDefinition = SecurableClassDefinition.NewObject();
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
securableClassDefinition.EnsureDataAvailable();
Assert.That(securableClassDefinition.State, Is.EqualTo(StateType.Unchanged));
securableClassDefinition.AddAccessType(AccessTypeDefinition.NewObject());
Assert.That(securableClassDefinition.State, Is.EqualTo(StateType.Changed));
}
}
public void FailsForIndexLessThanZero()
{
var accessType = AccessTypeDefinition.NewObject();
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.Name = "Class";
securableClassDefinition.AddAccessType(AccessTypeDefinition.NewObject());
securableClassDefinition.AddAccessType(accessType);
Assert.That(
() => securableClassDefinition.MoveAccessType(-1, accessType),
Throws.TypeOf <ArgumentOutOfRangeException>()
.And.Message.StartsWith(
"The index must not be less than 0 or greater than the top index of the access types for the securable class definition."));
}
public void RegisterForCommit_InNotLoadedState()
{
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
SecurableClassDefinition classDefinition = SecurableClassDefinition.NewObject();
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
Assert.That(classDefinition.State, Is.EqualTo(StateType.NotLoadedYet));
Assert.That(() => classDefinition.RegisterForCommit(), Throws.Nothing);
Assert.That(classDefinition.State, Is.EqualTo(StateType.Changed));
}
}
}
private SecurableClassDefinition[] CreateSecurableClassDefinitions(int classDefinitionCount, int derivedClassDefinitionCount)
{
SecurableClassDefinition[] classDefinitions = new SecurableClassDefinition[classDefinitionCount];
for (int i = 0; i < classDefinitionCount; i++)
{
SecurableClassDefinition classDefinition = SecurableClassDefinition.NewObject();
classDefinition.MetadataItemID = Guid.NewGuid();
classDefinition.Name = string.Format("Class {0}", i);
classDefinition.Index = i;
classDefinitions[i] = classDefinition;
CreateDerivedSecurableClassDefinitions(classDefinition, derivedClassDefinitionCount);
}
return(classDefinitions);
}
public void CreateStateCombination_WithoutClassDefinition()
{
StatefulAccessControlList acl = _testHelper.CreateStatefulAcl(SecurableClassDefinition.NewObject());
using (_testHelper.Transaction.CreateSubTransaction().EnterDiscardingScope())
{
acl.EnsureDataAvailable();
Assert.That(acl.State, Is.EqualTo(StateType.Unchanged));
acl.CreateStateCombination();
Assert.That(acl.State, Is.EqualTo(StateType.Changed));
}
}
public void AddsAccessTypes()
{
var accessType0 = AccessTypeDefinition.NewObject();
var accessType1 = AccessTypeDefinition.NewObject();
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.AddAccessType(accessType0);
securableClassDefinition.AddAccessType(accessType1);
Assert.That(securableClassDefinition.AccessTypes, Is.EqualTo(new[] { accessType0, accessType1 }));
var references = new SecurableClassDefinitionWrapper(securableClassDefinition).AccessTypeReferences;
Assert.That(((AccessTypeReference)references[0]).Index, Is.EqualTo(0));
Assert.That(((AccessTypeReference)references[1]).Index, Is.EqualTo(1));
}
public void CreateStatelessAccessControlList_Twice()
{
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
SecurableClassDefinition classDefinition = SecurableClassDefinition.NewObject();
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
classDefinition.EnsureDataAvailable();
Assert.That(classDefinition.State, Is.EqualTo(StateType.Unchanged));
classDefinition.CreateStatelessAccessControlList();
classDefinition.CreateStatelessAccessControlList();
}
}
}
public override void SetUp()
{
base.SetUp();
ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope();
_metadataObject = SecurableClassDefinition.NewObject();
_metadataObject.Name = "Technical Name";
_cultureInvariant = Culture.NewObject(string.Empty);
_cultureDe = Culture.NewObject("de");
_cultureDeAt = Culture.NewObject("de-AT");
_cultureRu = Culture.NewObject("ru");
_backupCulture = Thread.CurrentThread.CurrentCulture;
_backupUICulture = Thread.CurrentThread.CurrentUICulture;
}
public void CreateStatelessAccessControlList()
{
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
SecurableClassDefinition classDefinition = SecurableClassDefinition.NewObject();
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
classDefinition.EnsureDataAvailable();
Assert.That(classDefinition.State, Is.EqualTo(StateType.Unchanged));
StatelessAccessControlList accessControlList = classDefinition.CreateStatelessAccessControlList();
Assert.That(accessControlList.Class, Is.SameAs(classDefinition));
Assert.IsNotEmpty(accessControlList.AccessControlEntries);
Assert.That(classDefinition.State, Is.EqualTo(StateType.Changed));
}
}
}
public void RemoveStateProperty_DeletesAssociatedAccessControlListIfDeletedStateCombinationWasLastStateCombination()
{
var state1 = StateDefinition.NewObject("Test", 1);
var state2 = StateDefinition.NewObject();
var stateProperty = StatePropertyDefinition.NewObject();
stateProperty.AddState(state1);
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.AddStateProperty(stateProperty);
var acl1 = securableClassDefinition.CreateStatefulAccessControlList();
acl1.StateCombinations[0].AttachState(state1);
var acl2 = securableClassDefinition.CreateStatefulAccessControlList();
Assert.That(acl2.StateCombinations, Is.Not.Empty);
var acl3 = securableClassDefinition.CreateStatefulAccessControlList();
acl3.StateCombinations[0].Delete();
var acl4 = securableClassDefinition.CreateStatefulAccessControlList();
acl4.StateCombinations[0].AttachState(state2);
securableClassDefinition.RemoveStateProperty(stateProperty);
Assert.That(acl1.State, Is.EqualTo(StateType.Invalid));
Assert.That(acl2.State, Is.EqualTo(StateType.New));
Assert.That(acl2.StateCombinations.Count, Is.EqualTo(1));
Assert.That(acl2.StateCombinations[0].GetStates(), Is.Empty);
Assert.That(acl3.State, Is.EqualTo(StateType.New));
Assert.That(acl3.StateCombinations, Is.Empty);
Assert.That(acl4.State, Is.EqualTo(StateType.New));
Assert.That(acl4.StateCombinations.Count, Is.EqualTo(1));
Assert.That(acl4.StateCombinations[0].GetStates(), Is.EqualTo(new[] { state2 }));
}
public void OnCommitting_WithChangedStatePropertyReference_RegistersClassForCommit()
{
var classDefinition = SecurableClassDefinition.NewObject();
var stateProperty = _testHelper.CreateFileStateProperty(0);
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
bool commitOnClassWasCalled = false;
classDefinition.Committing += (sender, e) =>
{
commitOnClassWasCalled = true;
Assert.That(GetDataContainer((DomainObject)sender).HasBeenMarkedChanged, Is.True);
};
classDefinition.AddStateProperty(stateProperty);
ClientTransaction.Current.Commit();
Assert.That(commitOnClassWasCalled, Is.True);
}
}
public void RemoveStateProperty_DeletesAssociatedStateCombinations()
{
var state1 = StateDefinition.NewObject("Test", 1);
var state2 = StateDefinition.NewObject();
var stateProperty = StatePropertyDefinition.NewObject();
stateProperty.AddState(state1);
var securableClassDefinition = SecurableClassDefinition.NewObject();
securableClassDefinition.AddStateProperty(stateProperty);
var acl = securableClassDefinition.CreateStatefulAccessControlList();
acl.StateCombinations[0].AttachState(state1);
acl.CreateStateCombination().AttachState(state2);
securableClassDefinition.RemoveStateProperty(stateProperty);
Assert.That(acl.StateCombinations.Count, Is.EqualTo(1));
Assert.That(acl.StateCombinations[0].GetStates(), Is.EqualTo(new[] { state2 }));
}