public void GetClass()
{
SecurableClassDefinition classDefinition = _testHelper.CreateClassDefinition("SecurableClass");
StatefulAccessControlList acl = _testHelper.CreateStatefulAcl(classDefinition);
Assert.That(acl.Class, Is.SameAs(classDefinition));
}
public void SetAndGet_Index()
{
StatefulAccessControlList acl = StatefulAccessControlList.NewObject();
acl.Index = 1;
Assert.That(acl.Index, Is.EqualTo(1));
}
private void HandleStatefulAccessControlListsChanged(StatefulAccessControlList acl)
{
if (acl != null)
{
acl.Index = StatefulAccessControlLists.IndexOf(acl);
}
}
private void CreateStateCombination(StatefulAccessControlList acl, StatePropertyDefinition stateProperty, StateDefinition stateDefinition)
{
StateCombination stateCombination = acl.CreateStateCombination();
stateProperty.AddState(stateDefinition);
stateCombination.AttachState(stateDefinition);
}
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 StateCombination CreateStateCombination(SecurableClassDefinition classDefinition, ClientTransaction transaction, params StateDefinition[] states)
{
using (transaction.EnterNonDiscardingScope())
{
StatefulAccessControlList acl = CreateStatefulAcl(classDefinition, transaction, states);
return(acl.StateCombinations[0]);
}
}
private AccessControlEntry CreateAceForStateful()
{
var ace = AccessControlEntry.NewObject();
ace.AccessControlList = StatefulAccessControlList.NewObject();
return(ace);
}
public StatefulAccessControlList CreateStatefulAccessControlList()
{
var accessControlList = StatefulAccessControlList.NewObject();
StatefulAccessControlLists.Add(accessControlList);
accessControlList.CreateStateCombination();
accessControlList.CreateAccessControlEntry();
return(accessControlList);
}
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 AccessControlList CreateStatefulAcl(params AccessControlEntry[] aces)
{
using (_transaction.EnterNonDiscardingScope())
{
AccessControlList acl = StatefulAccessControlList.NewObject();
foreach (AccessControlEntry ace in aces)
{
acl.AccessControlEntries.Add(ace);
}
return(acl);
}
}
private StatefulAccessControlList CreateStatefulAcl(SecurableClassDefinition classDefinition, ClientTransaction transaction, params StateDefinition[] states)
{
using (transaction.EnterNonDiscardingScope())
{
var acl = StatefulAccessControlList.NewObject();
classDefinition.StatefulAccessControlLists.Add(acl);
StateCombination stateCombination = acl.CreateStateCombination();
foreach (StateDefinition state in states)
{
stateCombination.AttachState(state);
}
return(acl);
}
}
public void CreateStateCombination()
{
SecurableClassDefinition classDefinition = _testHelper.CreateClassDefinition("SecurableClass");
StatefulAccessControlList acl = _testHelper.CreateStatefulAcl(classDefinition);
using (_testHelper.Transaction.CreateSubTransaction().EnterDiscardingScope())
{
acl.EnsureDataAvailable();
Assert.That(acl.State, Is.EqualTo(StateType.Unchanged));
StateCombination stateCombination = acl.CreateStateCombination();
Assert.That(stateCombination.AccessControlList, Is.SameAs(acl));
Assert.That(stateCombination.Class, Is.EqualTo(acl.Class));
Assert.That(stateCombination.GetStates(), Is.Empty);
Assert.That(acl.State, Is.EqualTo(StateType.Changed));
}
}
public void CreateStatefulAccessControlList()
{
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
SecurableClassDefinition classDefinition = SecurableClassDefinition.NewObject();
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
classDefinition.EnsureDataAvailable();
Assert.That(classDefinition.State, Is.EqualTo(StateType.Unchanged));
StatefulAccessControlList accessControlList = classDefinition.CreateStatefulAccessControlList();
Assert.That(accessControlList.Class, Is.SameAs(classDefinition));
Assert.IsNotEmpty(accessControlList.AccessControlEntries);
Assert.IsNotEmpty(accessControlList.StateCombinations);
Assert.That(classDefinition.State, Is.EqualTo(StateType.Changed));
}
}
}
public AccessControlList CreateAndCommitAccessControlListWithAccessControlEntries(int accessControlEntries, ClientTransaction transaction)
{
CreateEmptyDomain();
using (transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition classDefinition = CreateOrderSecurableClassDefinition();
StatefulAccessControlList acl = StatefulAccessControlList.NewObject();
classDefinition.StatefulAccessControlLists.Add(acl);
acl.CreateStateCombination();
for (int i = 0; i < accessControlEntries; i++)
{
acl.CreateAccessControlEntry();
}
ClientTransactionScope.CurrentTransaction.Commit();
return(acl);
}
}
public void CreateStateCombination_TwoNewEntries()
{
StatefulAccessControlList acl = StatefulAccessControlList.NewObject();
var securableClassDefinition = _testHelper.CreateClassDefinition("SecurableClass");
securableClassDefinition.StatefulAccessControlLists.Add(acl);
using (_testHelper.Transaction.CreateSubTransaction().EnterDiscardingScope())
{
acl.EnsureDataAvailable();
Assert.That(acl.State, Is.EqualTo(StateType.Unchanged));
StateCombination stateCombination0 = acl.CreateStateCombination();
StateCombination stateCombination1 = acl.CreateStateCombination();
Assert.That(acl.StateCombinations.Count, Is.EqualTo(2));
Assert.That(acl.StateCombinations[0], Is.SameAs(stateCombination0));
Assert.That(stateCombination0.Index, Is.EqualTo(0));
Assert.That(acl.StateCombinations[1], Is.SameAs(stateCombination1));
Assert.That(stateCombination1.Index, Is.EqualTo(1));
Assert.That(acl.State, Is.EqualTo(StateType.Changed));
}
}
public void CreateStatefulAccessControlList_TwoNewAcls()
{
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
SecurableClassDefinition classDefinition = SecurableClassDefinition.NewObject();
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
classDefinition.EnsureDataAvailable();
Assert.That(classDefinition.State, Is.EqualTo(StateType.Unchanged));
StatefulAccessControlList acccessControlList0 = classDefinition.CreateStatefulAccessControlList();
StatefulAccessControlList acccessControlListl = classDefinition.CreateStatefulAccessControlList();
Assert.That(classDefinition.StatefulAccessControlLists.Count, Is.EqualTo(2));
Assert.That(classDefinition.StatefulAccessControlLists[0], Is.SameAs(acccessControlList0));
Assert.That(acccessControlList0.Index, Is.EqualTo(0));
Assert.That(classDefinition.StatefulAccessControlLists[1], Is.SameAs(acccessControlListl));
Assert.That(acccessControlListl.Index, Is.EqualTo(1));
Assert.That(classDefinition.State, Is.EqualTo(StateType.Changed));
}
}
}
public void OnCommitting_WithDeletedAcl_RegistersClassForCommit()
{
var acl = StatefulAccessControlList.NewObject();
var classDefinition = _testHelper.CreateClassDefinition("SecurableClass");
classDefinition.StatefulAccessControlLists.Add(acl);
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
bool commitOnClassWasCalled = false;
classDefinition.Committing += (sender, e) =>
{
commitOnClassWasCalled = true;
Assert.That(GetDataContainer((DomainObject)sender).HasBeenMarkedChanged, Is.True);
};
acl.Delete();
ClientTransaction.Current.Commit();
Assert.That(commitOnClassWasCalled, Is.True);
}
}
public void DomainObjectsAreSerializable()
{
CheckDomainObjectSerializability(delegate { return(AccessControlEntry.NewObject()); });
CheckDomainObjectSerializability(delegate { return(StatefulAccessControlList.NewObject()); });
CheckDomainObjectSerializability(delegate { return(Permission.NewObject()); });
CheckDomainObjectSerializability(delegate { return(StateCombination.NewObject()); });
CheckDomainObjectSerializability(delegate { return(StateUsage.NewObject()); });
CheckDomainObjectSerializability(delegate { return(AbstractRoleDefinition.NewObject()); });
CheckDomainObjectSerializability(delegate { return(AccessTypeDefinition.NewObject()); });
CheckDomainObjectSerializability(delegate { return(AccessTypeReference.NewObject()); });
CheckDomainObjectSerializability(delegate { return(Culture.NewObject("DE-DE")); });
CheckDomainObjectSerializability(delegate { return(LocalizedName.NewObject("foo", Culture.NewObject("DE-DE"), SecurableClassDefinition.NewObject())); });
CheckDomainObjectSerializability(delegate { return(SecurableClassDefinition.NewObject()); });
CheckDomainObjectSerializability(delegate { return(StateDefinition.NewObject()); });
CheckDomainObjectSerializability(delegate { return(StatePropertyDefinition.NewObject()); });
CheckDomainObjectSerializability(delegate { return(StatePropertyReference.NewObject()); });
CheckDomainObjectSerializability(delegate { return((Group)LifetimeService.NewObject(ClientTransaction.Current, typeof(Group), ParamList.Empty)); });
CheckDomainObjectSerializability(delegate { return((GroupType)LifetimeService.NewObject(ClientTransaction.Current, typeof(GroupType), ParamList.Empty)); });
CheckDomainObjectSerializability(delegate { return(GroupTypePosition.NewObject()); });
CheckDomainObjectSerializability(delegate { return((Position)LifetimeService.NewObject(ClientTransaction.Current, typeof(Position), ParamList.Empty)); });
CheckDomainObjectSerializability(delegate { return(Role.NewObject()); });
CheckDomainObjectSerializability(delegate { return((Tenant)LifetimeService.NewObject(ClientTransaction.Current, typeof(Tenant), ParamList.Empty)); });
CheckDomainObjectSerializability(delegate { return((User)LifetimeService.NewObject(ClientTransaction.Current, typeof(User), ParamList.Empty)); });
}
public void CreateAccessControlEntry_BeforeClassIsSet_WithStatefulAccessControlList()
{
AccessControlList acl = StatefulAccessControlList.NewObject();
acl.CreateAccessControlEntry();
}
public void CreateStateCombination_BeforeClassIsSet()
{
StatefulAccessControlList acl = StatefulAccessControlList.NewObject();
acl.CreateStateCombination();
}
