public void SubTransaction_CanBeUsedToCreateAndLoadNewObjects()
{
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
Assert.That(ClientTransactionScope.CurrentTransaction, Is.SameAs(subTransaction));
Order order = Order.NewObject();
Assert.That(subTransaction.IsEnlisted(order), Is.True);
Assert.That(TestableClientTransaction.IsEnlisted(order), Is.True);
order.OrderNumber = 4711;
Assert.That(order.OrderNumber, Is.EqualTo(4711));
OrderItem item = OrderItem.NewObject();
order.OrderItems.Add(item);
Assert.That(order.OrderItems.Contains(item.ID), Is.True);
Ceo ceo = DomainObjectIDs.Ceo1.GetObject <Ceo> ();
Assert.That(ceo, Is.Not.Null);
Assert.That(subTransaction.IsEnlisted(ceo), Is.True);
Assert.That(TestableClientTransaction.IsEnlisted(ceo), Is.True);
Assert.That(DomainObjectIDs.Company1.GetObject <Company> (), Is.SameAs(ceo.Company));
}
}
public void AutomaticCleanup_WhenDomainObjectCtorThrows_DoesNotRequireDeletePermissions()
{
_securityProviderStub.Stub(mock => mock.GetAccess(_securityContextStub, _securityPrincipalStub)).Return(new AccessType[0]);
_functionalSecurityStrategyStub
.Stub(
mock => mock.HasAccess(
Arg.Is(typeof(SecurableObject)),
Arg.Is(_securityProviderStub),
Arg.Is(_securityPrincipalStub),
Arg <IReadOnlyList <AccessType> > .List.Equal(new[] { AccessType.Get(GeneralAccessTypes.Create) })))
.Return(true);
var exception = new Exception("Test.");
SecurableObject throwingObject = null;
Assert.That(
() => CreateSecurableObject(
_securityContextFactoryStub,
action: obj =>
{
throwingObject = obj;
throw exception;
}),
Throws.Exception.SameAs(exception));
Assert.That(_clientTransaction.IsEnlisted(throwingObject), Is.False);
}
public void DomainObjects_CreatedInParent_CanBeUsedInSubTransactions()
{
Order order = Order.NewObject();
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
Assert.That(TestableClientTransaction.IsEnlisted(order), Is.True);
Assert.That(subTransaction.IsEnlisted(order), Is.True);
}
public void DomainObjects_LoadedInParent_CanBeUsedInSubTransactions()
{
Order order = DomainObjectIDs.Order1.GetObject <Order> ();
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
Assert.That(TestableClientTransaction.IsEnlisted(order), Is.True);
Assert.That(subTransaction.IsEnlisted(order), Is.True);
}
public void DomainObjects_CreatedInSubTransaction_CanBeUsedInParent()
{
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
Order order = Order.NewObject();
Assert.That(subTransaction.IsEnlisted(order), Is.True);
Assert.That(TestableClientTransaction.IsEnlisted(order), Is.True);
}
}
public void GetObjectByNewIndependentTransaction()
{
ClientTransaction clientTransaction = ClientTransaction.CreateRootTransaction();
using (clientTransaction.EnterDiscardingScope())
{
Order order = DomainObjectIDs.Order1.GetObject <Order> ();
Assert.That(order.InternalDataContainer.ClientTransaction, Is.SameAs(clientTransaction));
Assert.That(clientTransaction.IsEnlisted(order), Is.True);
}
}
public void MarkInvalid(DomainObject domainObject)
{
ArgumentUtility.CheckNotNull("domainObject", domainObject);
// This uses IsEnlisted rather than a RootTransaction check because the DomainObject reference is used inside the ClientTransaction, and we
// explicitly want to allow only objects enlisted in the transaction.
if (!_clientTransaction.IsEnlisted(domainObject))
{
throw CreateClientTransactionsDifferException(
"Cannot mark DomainObject '{0}' invalid, because it belongs to a different ClientTransaction.",
domainObject.ID);
}
if (DataContainers[domainObject.ID] != null)
{
var message = string.Format("Cannot mark DomainObject '{0}' invalid because there is data registered for the object.", domainObject.ID);
throw new InvalidOperationException(message);
}
_invalidDomainObjectManager.MarkInvalid(domainObject);
}
private void CheckDomainObject(
DomainObject result,
ClientTransaction expectedClientTransaction,
ObjectID expectedID = null,
StateType?expectedState = null)
{
Assert.That(expectedClientTransaction.IsEnlisted(result), Is.True);
if (expectedID != null)
{
Assert.That(result.ID, Is.EqualTo(expectedID));
}
if (expectedState != null)
{
Assert.That(expectedClientTransaction.ExecuteInScope(() => result.State), Is.EqualTo(expectedState));
}
}
