public void SubTransactionCanContinueToBeUsedAfterRollback()
{
_subTransaction.Rollback();
Assert.That(_subTransaction.IsDiscarded, Is.False);
using (_subTransaction.EnterDiscardingScope())
{
Order order = Order.NewObject();
Assert.That(order, Is.Not.Null);
}
}
public void GetObjects_UnloadedObjects_Events()
{
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
var listenerMock = MockRepository.GenerateMock <IClientTransactionListener> ();
PrivateInvoke.InvokeNonPublicMethod(subTransaction, "AddListener", listenerMock);
var eventReceiver = new ClientTransactionEventReceiver(subTransaction);
DomainObject[] objects = LifetimeService.GetObjects <DomainObject> (
subTransaction,
DomainObjectIDs.Order1,
DomainObjectIDs.Order3,
DomainObjectIDs.OrderItem1);
Assert.That(eventReceiver.LoadedDomainObjectLists.Count, Is.EqualTo(1));
Assert.That(eventReceiver.LoadedDomainObjectLists[0], Is.EqualTo(objects));
listenerMock.AssertWasCalled(mock => mock.ObjectsLoading(
Arg.Is(subTransaction),
Arg <ReadOnlyCollection <ObjectID> > .List.Equal(new[] { DomainObjectIDs.Order1, DomainObjectIDs.Order3, DomainObjectIDs.OrderItem1 })));
listenerMock.AssertWasCalled(mock => mock.ObjectsLoaded(
Arg.Is(subTransaction),
Arg <ReadOnlyCollection <DomainObject> > .List.Equal(objects)));
}
}
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));
}
}
protected void ReInitializeTransaction()
{
DisposeTransaction();
_testableClientTransaction = ClientTransaction.CreateRootTransaction();
_testableClientTransaction.EnterDiscardingScope();
}
public void ConcurrentDeleteWithoutForeignKey()
{
ClientTransaction clientTransaction1 = ClientTransaction.CreateRootTransaction();
ClientTransaction clientTransaction2 = ClientTransaction.CreateRootTransaction();
DataContainer changedDataContainer;
ClassWithAllDataTypes changedObject;
using (clientTransaction1.EnterDiscardingScope())
{
changedObject = DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> ();
changedDataContainer = changedObject.InternalDataContainer;
changedObject.StringProperty = "New text";
}
DataContainer deletedDataContainer;
ClassWithAllDataTypes deletedObject;
using (clientTransaction2.EnterDiscardingScope())
{
deletedObject = DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> ();
deletedDataContainer = deletedObject.InternalDataContainer;
deletedObject.Delete();
}
Provider.Connect();
Provider.Save(new[] { changedDataContainer });
Provider.Save(new[] { deletedDataContainer });
}
public void GetObjects_LoadedObjects_Events()
{
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
var eventReceiver = new ClientTransactionEventReceiver(subTransaction);
DomainObjectIDs.Order1.GetObject <Order> ();
DomainObjectIDs.Order3.GetObject <Order> ();
DomainObjectIDs.OrderItem1.GetObject <OrderItem>();
eventReceiver.Clear();
var listenerMock = MockRepository.GenerateMock <IClientTransactionListener> ();
PrivateInvoke.InvokeNonPublicMethod(subTransaction, "AddListener", listenerMock);
LifetimeService.GetObjects <DomainObject> (subTransaction, DomainObjectIDs.Order1, DomainObjectIDs.Order3, DomainObjectIDs.OrderItem1);
Assert.That(eventReceiver.LoadedDomainObjectLists, Is.Empty);
listenerMock.AssertWasNotCalled(mock => mock.ObjectsLoading(
Arg <ClientTransaction> .Is.Anything,
Arg <ReadOnlyCollection <ObjectID> > .Is.Anything));
listenerMock.AssertWasNotCalled(mock => mock.ObjectsLoaded(
Arg <ClientTransaction> .Is.Anything,
Arg <ReadOnlyCollection <DomainObject> > .Is.Anything));
}
}
public void ConcurrentDeleteWithForeignKey()
{
ClientTransaction clientTransaction1 = ClientTransaction.CreateRootTransaction();
ClientTransaction clientTransaction2 = ClientTransaction.CreateRootTransaction();
OrderTicket changedOrderTicket;
DataContainer changedDataContainer;
using (clientTransaction1.EnterDiscardingScope())
{
changedOrderTicket = DomainObjectIDs.OrderTicket1.GetObject <OrderTicket> ();
changedOrderTicket.FileName = @"C:\NewFile.jpg";
changedDataContainer = changedOrderTicket.InternalDataContainer;
}
OrderTicket deletedOrderTicket;
DataContainer deletedDataContainer;
using (clientTransaction2.EnterDiscardingScope())
{
deletedOrderTicket = DomainObjectIDs.OrderTicket1.GetObject <OrderTicket> ();
deletedOrderTicket.Delete();
deletedDataContainer = deletedOrderTicket.InternalDataContainer;
}
Provider.Connect();
Provider.Save(new[] { changedDataContainer });
Provider.Save(new[] { deletedDataContainer });
}
public override void SetUp()
{
base.SetUp();
_subTransaction = TestableClientTransaction.CreateSubTransaction();
_subTransaction.EnterDiscardingScope();
}
private int GetInt32Property(ClientTransaction clientTransaction)
{
using (clientTransaction.EnterDiscardingScope())
{
SampleObject objectWithAllDataTypes = DomainObjectIDs.ClassWithAllDataTypes1.GetObject <SampleObject> ();
return(objectWithAllDataTypes.Int32Property);
}
}
public void GetObjects_InvalidType()
{
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
LifetimeService.GetObjects <OrderItem> (subTransaction, DomainObjectIDs.Order1);
}
}
public void GetObjects_NotFound()
{
var guid = new Guid("33333333333333333333333333333333");
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
LifetimeService.GetObjects <DomainObject> (subTransaction, new ObjectID(typeof(Order), guid));
}
}
public override void SetUp()
{
base.SetUp();
_rootTransaction = ClientTransaction.CreateRootTransaction();
_subTransaction = _rootTransaction.CreateSubTransaction();
_subTransaction.EnterDiscardingScope();
_orderReference = DomainObjectIDs.Order1.GetObjectReference <Order> (_rootTransaction);
}
public void Parent_CannotAccessObject_CreatedInSubTransaction()
{
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
Order order;
using (subTransaction.EnterDiscardingScope())
{
order = Order.NewObject();
}
Dev.Null = order.OrderNumber;
}
public void SubTransaction_CanAccessObject_CreatedInParent()
{
Order order = Order.NewObject();
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
order.OrderNumber = 5;
order.OrderTicket = OrderTicket.NewObject();
}
}
public void Parent_CanReloadObject_LoadedInSubTransaction_AndGetTheSameReference()
{
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
Order order;
using (subTransaction.EnterDiscardingScope())
{
order = DomainObjectIDs.Order1.GetObject <Order> ();
}
Assert.That(DomainObjectIDs.Order1.GetObject <Order> (), Is.SameAs(order));
}
public void Parent_CanAccessObject_LoadedInSubTransaction()
{
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
Order order;
using (subTransaction.EnterDiscardingScope())
{
order = DomainObjectIDs.Order1.GetObject <Order> ();
}
Assert.That(order.OrderNumber, Is.EqualTo(1));
}
private void SetInt32Property(int value, ClientTransaction clientTransaction)
{
using (clientTransaction.EnterDiscardingScope())
{
SampleObject objectWithAllDataTypes = DomainObjectIDs.ClassWithAllDataTypes1.GetObject <SampleObject> ();
objectWithAllDataTypes.Int32Property = value;
clientTransaction.Commit();
}
}
public void DomainObjects_CreatedInSubTransaction_InvalidInParent()
{
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
Order order = Order.NewObject();
Assert.That(order.TransactionContext[subTransaction].State, Is.EqualTo(StateType.New));
Assert.That(order.TransactionContext[TestableClientTransaction].State, Is.EqualTo(StateType.Invalid));
}
}
public void GetObjects_Invalid_Throws()
{
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> ().Delete();
subTransaction.Commit();
LifetimeService.GetObjects <ClassWithAllDataTypes> (subTransaction, DomainObjectIDs.ClassWithAllDataTypes1);
}
}
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 GetObjects_NewObjects()
{
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
var expectedObjects = new DomainObject[] { Order.NewObject(), OrderItem.NewObject() };
DomainObject[] objects = LifetimeService.GetObjects <DomainObject> (subTransaction, expectedObjects[0].ID, expectedObjects[1].ID);
Assert.That(objects, Is.EqualTo(expectedObjects));
}
}
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 DefaultEnterScope()
{
ClientTransactionScope outerScope = ClientTransactionScope.ActiveScope;
ClientTransaction newTransaction = ClientTransaction.CreateRootTransaction();
using (newTransaction.EnterDiscardingScope())
{
Assert.That(ClientTransactionScope.ActiveScope, Is.Not.SameAs(outerScope));
Assert.That(ClientTransactionScope.CurrentTransaction, Is.SameAs(newTransaction));
Assert.That(ClientTransactionScope.ActiveScope.AutoRollbackBehavior, Is.EqualTo(AutoRollbackBehavior.Discard));
}
}
public void SubTransaction_CanAccessObject_LoadedInParent()
{
Order order = DomainObjectIDs.Order1.GetObject <Order> ();
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
++order.OrderNumber;
Dev.Null = order.OrderTicket;
order.OrderTicket = OrderTicket.NewObject();
}
}
public override void SetUp()
{
base.SetUp();
_customer1 = DomainObjectIDs.Customer1.GetObject <Customer> ();
_secondClientTransaction = ClientTransaction.CreateRootTransaction();
_secondCollection = new DomainObjectCollection();
using (_secondClientTransaction.EnterDiscardingScope())
{
_secondCustomer1 = DomainObjectIDs.Customer1.GetObject <Customer> ();
}
}
public void DomainObjects_CreatedInSubTransaction_CommitMakesValidInParent()
{
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
var instance = ClassWithAllDataTypes.NewObject();
Assert.That(instance.TransactionContext[subTransaction].State, Is.EqualTo(StateType.New));
Assert.That(instance.TransactionContext[TestableClientTransaction].State, Is.EqualTo(StateType.Invalid));
subTransaction.Commit();
Assert.That(instance.TransactionContext[TestableClientTransaction].State, Is.EqualTo(StateType.New));
}
}
public void GetObjects_Deleted()
{
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
var order = DomainObjectIDs.Order1.GetObject <Order> ();
order.Delete();
var result = LifetimeService.GetObjects <Order> (subTransaction, DomainObjectIDs.Order1);
Assert.That(result[0], Is.SameAs(order));
}
}
public void GetObjectReference_DeletedInParentTransaction()
{
var order1 = DomainObjectIDs.Order1.GetObject <Order> ();
order1.Delete();
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
var objectReference = LifetimeService.GetObjectReference(subTransaction, order1.ID);
Assert.That(objectReference, Is.SameAs(order1));
Assert.That(objectReference.State, Is.EqualTo(StateType.Invalid));
}
}
protected override void OnLoad(EventArgs e)
{
_clientTransaction = ClientTransaction.CreateRootTransaction();
_clientTransaction.EnterDiscardingScope();
if (!IsPostBack)
{
using (SecurityFreeSection.Activate())
{
var users = (from u in QueryFactory.CreateLinqQuery <SecurityManagerUser>() orderby u.UserName select u).ToArray();
var user = SecurityManagerPrincipal.Current.User;
UsersField.SetBusinessObjectList(users);
UsersField.LoadUnboundValue(user, false);
}
}
}
public void GetObject_DeletedInParentTransaction_IncludeDeletedTrue()
{
var order1 = DomainObjectIDs.Order1.GetObject <Order> ();
order1.Delete();
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
Assert.That(
() => order1.ID.GetObject <Order> (includeDeleted: true),
Throws.TypeOf <ObjectInvalidException> ().With.Message.EqualTo(
"Object 'Order|5682f032-2f0b-494b-a31c-c97f02b89c36|System.Guid' is invalid in this transaction."));
}
}
