private void CreateStateCombination(StatefulAccessControlList acl, StatePropertyDefinition stateProperty, StateDefinition stateDefinition)
{
StateCombination stateCombination = acl.CreateStateCombination();
stateProperty.AddState(stateDefinition);
stateCombination.AttachState(stateDefinition);
}
public void AddDuplicateStateCombination(StateCombination duplicateStateCombination)
{
ArgumentUtility.CheckNotNull("duplicateStateCombination", duplicateStateCombination);
_isValid = false;
_duplicateStateCombinations.Add(duplicateStateCombination);
}
public void AddInvalidStateCombination(StateCombination invalidStateCombination)
{
ArgumentUtility.CheckNotNull("invalidStateCombination", invalidStateCombination);
_isValid = false;
_invalidStateCombinations.Add(invalidStateCombination);
}
public void GetClass()
{
StateCombination combination = _testHelper.GetStateCombinationForDeliveredAndUnpaidOrder();
Assert.That(combination.AccessControlList.Class, Is.Not.Null);
Assert.That(combination.Class, Is.SameAs(combination.AccessControlList.Class));
}
public void MatchesStates_StatefulAndWithoutDemandedStates()
{
StateCombination combination = _testHelper.GetStateCombinationForDeliveredAndUnpaidOrder();
List <StateDefinition> states = CreateEmptyStateList();
Assert.That(combination.MatchesStates(states), Is.False);
}
public void SetAndGet_Index()
{
StateCombination stateCombination = StateCombination.NewObject();
stateCombination.Index = 1;
Assert.That(stateCombination.Index, Is.EqualTo(1));
}
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 MatchesStates_DeliveredAndUnpaid()
{
StateCombination combination = _testHelper.GetStateCombinationForDeliveredAndUnpaidOrder();
StateDefinition[] states = combination.GetStates();
Assert.That(combination.MatchesStates(states), Is.True);
}
public void MatchesStates_StatefulWithWildcard()
{
StateCombination combination = _testHelper.GetStateCombinationForDeliveredAndUnpaidOrder();
StateDefinition[] states = combination.GetStates();
Assert.Fail("TODO: Implement");
Assert.That(combination.MatchesStates(states), Is.True);
}
public void AttachState_WithoutClassDefinition()
{
StateCombination combination = StateCombination.NewObject();
StatePropertyDefinition property = _testHelper.CreateTestProperty();
combination.AttachState(property["Test1"]);
Assert.That(combination.GetStates().Length, Is.EqualTo(1));
}
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 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)));
}
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_OneStatelessAndOneWithAState()
{
SecurableClassDefinition orderClass = _testHelper.CreateOrderClassDefinition();
StatePropertyDefinition paymentProperty = _testHelper.CreatePaymentStateProperty(orderClass);
StateCombination combination1 = _testHelper.CreateStateCombination(orderClass);
StateCombination combination2 = _testHelper.CreateStateCombination(orderClass, paymentProperty[EnumWrapper.Get(PaymentState.Paid).Name]);
StateCombinationComparer comparer = new StateCombinationComparer();
Assert.That(comparer.GetHashCode(combination2), Is.Not.EqualTo(comparer.GetHashCode(combination1)));
}
public void Equals_TwoDifferent()
{
SecurableClassDefinition orderClass = _testHelper.CreateOrderClassDefinition();
StatePropertyDefinition paymentProperty = _testHelper.CreatePaymentStateProperty(orderClass);
StateCombination combination1 = _testHelper.CreateStateCombination(orderClass, paymentProperty[EnumWrapper.Get(PaymentState.None).Name]);
StateCombination combination2 = _testHelper.CreateStateCombination(orderClass, paymentProperty[EnumWrapper.Get(PaymentState.Paid).Name]);
StateCombinationComparer comparer = new StateCombinationComparer();
Assert.That(comparer.Equals(combination1, combination2), Is.False);
}
public void GetStates_OneState()
{
SecurableClassDefinition classDefinition = _testHelper.CreateOrderClassDefinition();
StatePropertyDefinition property = _testHelper.CreatePaymentStateProperty(classDefinition);
StateDefinition state = property.DefinedStates[1];
StateCombination combination = _testHelper.CreateStateCombination(classDefinition, state);
StateDefinition[] states = combination.GetStates();
Assert.That(states.Length, Is.EqualTo(1));
Assert.That(states[0], Is.SameAs(state));
}
public void GetStateCombinations_TwoCombinations()
{
AccessControlTestHelper testHelper = new AccessControlTestHelper();
using (testHelper.Transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition orderClass = testHelper.CreateOrderClassDefinition();
StateCombination stateCombination = testHelper.CreateStateCombination(orderClass);
List <StateCombination> stateCombinations = testHelper.CreateOrderStateAndPaymentStateCombinations(orderClass);
Assert.That(orderClass.StateCombinations, Is.EqualTo(ArrayUtility.Combine(stateCombination, stateCombinations.ToArray())));
}
}
public void ClearStates()
{
SecurableClassDefinition classDefinition = _testHelper.CreateOrderClassDefinition();
StateCombination combination = _testHelper.CreateStateCombination(classDefinition);
StatePropertyDefinition property = _testHelper.CreateTestProperty();
combination.AttachState(property["Test1"]);
Assert.That(combination.GetStates(), Is.Not.Empty);
combination.ClearStates();
Assert.That(combination.GetStates(), Is.Empty);
}
public void GetStates_MultipleStates()
{
SecurableClassDefinition classDefinition = _testHelper.CreateOrderClassDefinition();
StatePropertyDefinition paymentProperty = _testHelper.CreatePaymentStateProperty(classDefinition);
StateDefinition paidState = paymentProperty.DefinedStates[1];
StatePropertyDefinition orderStateProperty = _testHelper.CreateOrderStateProperty(classDefinition);
StateDefinition deliveredState = orderStateProperty.DefinedStates[1];
StateCombination combination = _testHelper.CreateStateCombination(classDefinition, paidState, deliveredState);
StateDefinition[] states = combination.GetStates();
Assert.That(states.Length, Is.EqualTo(2));
Assert.That(states, Has.Member(paidState));
Assert.That(states, Has.Member(deliveredState));
}
public void AttachState_NewState()
{
SecurableClassDefinition classDefinition = _testHelper.CreateOrderClassDefinition();
StateCombination combination = _testHelper.CreateStateCombination(classDefinition);
StatePropertyDefinition property = _testHelper.CreateTestProperty();
using (_testHelper.Transaction.CreateSubTransaction().EnterDiscardingScope())
{
combination.AttachState(property["Test1"]);
var states = combination.GetStates();
Assert.That(states.Length, Is.EqualTo(1));
Assert.That(states[0], Is.SameAs(property["Test1"]));
}
}
public void IsValid_DuplicateStateCombination()
{
AccessControlTestHelper testHelper = new AccessControlTestHelper();
using (testHelper.Transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition orderClass = testHelper.CreateOrderClassDefinition();
StateCombination stateCombination = testHelper.CreateStateCombination(orderClass);
SecurableClassValidationResult result = new SecurableClassValidationResult();
result.AddDuplicateStateCombination(stateCombination);
Assert.That(result.IsValid, Is.False);
}
}
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 ValidateStateCombinationsAgainstStateProperties_EmptyStateCombinationInClassWithStateProperties()
{
AccessControlTestHelper testHelper = new AccessControlTestHelper();
using (testHelper.Transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition orderClass = testHelper.CreateOrderClassDefinition();
testHelper.CreateOrderStateAndPaymentStateCombinations(orderClass);
StateCombination statelessCombination = testHelper.CreateStateCombination(orderClass);
SecurableClassValidationResult result = new SecurableClassValidationResult();
orderClass.ValidateStateCombinationsAgainstStateProperties(result);
Assert.That(result.IsValid, Is.False);
Assert.That(result.InvalidStateCombinations, Is.EquivalentTo(new[] { statelessCombination }));
}
}
public void DuplicateStateCombinations_OneInvalidStateCombination()
{
AccessControlTestHelper testHelper = new AccessControlTestHelper();
using (testHelper.Transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition orderClass = testHelper.CreateOrderClassDefinition();
StateCombination stateCombination = testHelper.CreateStateCombination(orderClass);
SecurableClassValidationResult result = new SecurableClassValidationResult();
result.AddDuplicateStateCombination(stateCombination);
Assert.That(result.DuplicateStateCombinations.Count, Is.EqualTo(1));
Assert.That(result.DuplicateStateCombinations, Has.Member(stateCombination));
}
}
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 ValidateUniqueStateCombinations_TwoEmptyStateCombinations()
{
AccessControlTestHelper testHelper = new AccessControlTestHelper();
using (testHelper.Transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition orderClass = testHelper.CreateOrderClassDefinition();
StateCombination statelessCombination1 = testHelper.CreateStateCombination(orderClass);
StateCombination statelessCombination2 = testHelper.CreateStateCombination(orderClass);
SecurableClassValidationResult result = new SecurableClassValidationResult();
orderClass.ValidateUniqueStateCombinations(result);
Assert.That(result.IsValid, Is.False);
Assert.That(result.DuplicateStateCombinations, Has.Member(statelessCombination1));
Assert.That(result.DuplicateStateCombinations, Has.Member(statelessCombination2));
}
}
private void CreateEditStateCombinationControls(IList <StateCombination> stateCombinations)
{
StateCombinationControls.Controls.Clear();
_editStateCombinationControls.Clear();
for (int i = 0; i < stateCombinations.Count; i++)
{
StateCombination stateCombination = stateCombinations[i];
EditStateCombinationControl editStateCombinationControl = (EditStateCombinationControl)LoadControl("EditStateCombinationControl.ascx");
editStateCombinationControl.ID = "SC_" + i;
editStateCombinationControl.BusinessObject = stateCombination;
editStateCombinationControl.Delete += EditStateCombinationControl_Delete;
StateCombinationControls.Controls.Add(editStateCombinationControl);
_editStateCombinationControls.Add(editStateCombinationControl);
}
}
public void ValidateUniqueStateCombinations_TwoStateCombinations()
{
AccessControlTestHelper testHelper = new AccessControlTestHelper();
using (testHelper.Transaction.EnterNonDiscardingScope())
{
SecurableClassDefinition orderClass = testHelper.CreateOrderClassDefinition();
StatePropertyDefinition paymentProperty = testHelper.CreatePaymentStateProperty(orderClass);
StateCombination paidCombination1 = testHelper.CreateStateCombination(orderClass, paymentProperty[EnumWrapper.Get(PaymentState.Paid).Name]);
StateCombination paidCombination2 = testHelper.CreateStateCombination(orderClass, paymentProperty[EnumWrapper.Get(PaymentState.Paid).Name]);
testHelper.CreateStateCombination(orderClass, paymentProperty[EnumWrapper.Get(PaymentState.None).Name]);
SecurableClassValidationResult result = new SecurableClassValidationResult();
orderClass.ValidateUniqueStateCombinations(result);
Assert.That(result.IsValid, Is.False);
Assert.That(result.DuplicateStateCombinations.Count, Is.EqualTo(2));
Assert.That(result.DuplicateStateCombinations, Has.Member(paidCombination1));
Assert.That(result.DuplicateStateCombinations, Has.Member(paidCombination2));
}
}
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 ValidateDuringCommit_ByTouchOnClassForChangedStateUsagesCollection()
{
SecurableClassDefinition orderClass = _testHelper.CreateOrderClassDefinition();
StatePropertyDefinition paymentProperty = _testHelper.CreatePaymentStateProperty(orderClass);
StateDefinition paidState = paymentProperty[EnumWrapper.Get(PaymentState.Paid).Name];
StateDefinition notPaidState = paymentProperty[EnumWrapper.Get(PaymentState.None).Name];
StateCombination combination1 = _testHelper.CreateStateCombination(orderClass, paidState);
StateCombination combination2 = _testHelper.CreateStateCombination(orderClass, notPaidState);
StateCombination combination3 = _testHelper.CreateStateCombination(orderClass);
combination1.AccessControlList.AccessControlEntries.Add(AccessControlEntry.NewObject());
combination2.AccessControlList.AccessControlEntries.Add(AccessControlEntry.NewObject());
combination3.AccessControlList.AccessControlEntries.Add(AccessControlEntry.NewObject());
var dupicateStateCombination = orderClass.CreateStatefulAccessControlList().StateCombinations[0];
using (_testHelper.Transaction.CreateSubTransaction().EnterDiscardingScope())
{
dupicateStateCombination.AttachState(paidState);
ClientTransaction.Current.Commit();
}
}
