public void TryUnloadVirtualEndPointAndItemData_Failure_InHigherTransaction() { var customer = DomainObjectIDs.Customer1.GetObject <Customer> (); var parentOrdersEndPoint = DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(customer.Orders); EnsureEndPointLoadedAndComplete(parentOrdersEndPoint.ID); customer.Orders[0].RegisterForCommit(); Assert.That(parentOrdersEndPoint.Collection[0].State, Is.EqualTo(StateType.Changed)); var subTransaction = TestableClientTransaction.CreateSubTransaction(); var subOrdersEndPoint = (ICollectionEndPoint)ClientTransactionTestHelper.GetDataManager(subTransaction).GetRelationEndPointWithLazyLoad( parentOrdersEndPoint.ID); EnsureEndPointLoadedAndComplete(ClientTransactionTestHelper.GetDataManager(subTransaction), subOrdersEndPoint.ID); Assert.That(subOrdersEndPoint.Collection[0].TransactionContext[subTransaction].State, Is.EqualTo(StateType.Unchanged)); var result = UnloadService.TryUnloadVirtualEndPointAndItemData(subTransaction, parentOrdersEndPoint.ID); Assert.That(result, Is.False); Assert.That(subOrdersEndPoint.IsDataComplete, Is.True); Assert.That(parentOrdersEndPoint.IsDataComplete, Is.True); }
public void PerformCollectionRemoveWithOtherClientTransaction() { var order1 = DomainObjectIDs.Order1.GetObject <Order> (); var orderItem1 = DomainObjectMother.GetObjectInOtherTransaction <OrderItem> (DomainObjectIDs.OrderItem1); var endPoint = DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(order1.OrderItems); endPoint.Collection.Remove(orderItem1); }
public void UnloadVirtualEndPoint_Collection_AlreadyUnloaded() { var customer = DomainObjectIDs.Customer1.GetObject <Customer> (); var endPoint = DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(customer.Orders); UnloadService.UnloadVirtualEndPoint(TestableClientTransaction, endPoint.ID); ClientTransactionTestHelperWithMocks.EnsureTransactionThrowsOnEvents(TestableClientTransaction); Assert.That(endPoint.IsDataComplete, Is.False); UnloadService.UnloadVirtualEndPoint(TestableClientTransaction, endPoint.ID); }
public void UnloadVirtualEndPointAndItemData_Collection_EmptyCollection_UnloadsEndPoint() { var customer = DomainObjectIDs.Customer2.GetObject <Customer> (); var ordersEndPoint = DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(customer.Orders); EnsureEndPointLoadedAndComplete(ordersEndPoint.ID); Assert.That(ordersEndPoint.Collection, Is.Empty); UnloadService.UnloadVirtualEndPointAndItemData(TestableClientTransaction, ordersEndPoint.ID); Assert.That(ordersEndPoint.IsDataComplete, Is.False); Assert.That(customer.State, Is.EqualTo(StateType.Unchanged)); }
public void TryUnloadVirtualEndPointAndItemData_Success_IfDataNotComplete() { var customer = DomainObjectIDs.Customer1.GetObject <Customer> (); var ordersEndPoint = DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(customer.Orders); UnloadService.UnloadVirtualEndPoint(TestableClientTransaction, ordersEndPoint.ID); Assert.That(ordersEndPoint.IsDataComplete, Is.False); ClientTransactionTestHelperWithMocks.EnsureTransactionThrowsOnEvents(TestableClientTransaction); var result = UnloadService.TryUnloadVirtualEndPointAndItemData(TestableClientTransaction, ordersEndPoint.ID); Assert.That(result, Is.True); Assert.That(ordersEndPoint.IsDataComplete, Is.False); }
public void DomainObjectCollection_StandAlone_Contents() { var collection = new DomainObjectCollection(typeof(Order)); collection.Add(DomainObjectIDs.Order1.GetObject <Order> ()); DomainObjectCollection deserializedCollection = SerializeAndDeserialize(collection); Assert.That(deserializedCollection.Count, Is.EqualTo(1)); Assert.That(deserializedCollection.Contains(DomainObjectIDs.Order1), Is.True); Assert.That(deserializedCollection[0].ID, Is.EqualTo(DomainObjectIDs.Order1)); Assert.That(deserializedCollection.RequiredItemType, Is.EqualTo(typeof(Order))); Assert.That(deserializedCollection.IsReadOnly, Is.False); Assert.That(DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(deserializedCollection), Is.Null); }
public void UnloadVirtualEndPointAndItemData_Collection_UnloadsEndPointAndItems() { var order = DomainObjectIDs.Order1.GetObject <Order> (); var orderItemsEndPoint = DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(order.OrderItems); EnsureEndPointLoadedAndComplete(orderItemsEndPoint.ID); var orderItem1 = orderItemsEndPoint.Collection[0]; var orderItem2 = orderItemsEndPoint.Collection[1]; UnloadService.UnloadVirtualEndPointAndItemData(TestableClientTransaction, orderItemsEndPoint.ID); Assert.That(orderItemsEndPoint.IsDataComplete, Is.False); Assert.That(orderItem1.State, Is.EqualTo(StateType.NotLoadedYet)); Assert.That(orderItem2.State, Is.EqualTo(StateType.NotLoadedYet)); Assert.That(order.State, Is.EqualTo(StateType.Unchanged)); }
private OrderCollection CreateAssociatedCollectionWithEndPointStub() { var collectionEndPointStub = MockRepository.GenerateStub <ICollectionEndPoint> (); var endPointDataStub = new ReadOnlyCollectionDataDecorator(new DomainObjectCollectionData()); collectionEndPointStub.Stub(stub => stub.GetData()).Return(endPointDataStub); var virtualEndPointProviderStub = MockRepository.GenerateStub <IVirtualEndPointProvider>(); var endPointID = RelationEndPointID.Create(DomainObjectIDs.Customer1, typeof(Customer), "Orders"); virtualEndPointProviderStub.Stub(stub => stub.GetOrCreateVirtualEndPoint(endPointID)).Return(collectionEndPointStub); var delegatingStrategy = new EndPointDelegatingCollectionData(endPointID, virtualEndPointProviderStub); var associatedCollection = new OrderCollection(new ModificationCheckingCollectionDataDecorator(typeof(Order), delegatingStrategy)); Assert.That(DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(associatedCollection), Is.SameAs(collectionEndPointStub)); return(associatedCollection); }
public void TryUnloadVirtualEndPointAndItemData_Failure_EndPointChanged_EndPointAndItemsStillLoaded() { var customer = DomainObjectIDs.Customer1.GetObject <Customer> (); var orderA = customer.Orders[0]; var orderB = customer.Orders[1]; customer.Orders.Remove(orderB); var ordersEndPoint = DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(customer.Orders); Assert.That(ordersEndPoint.HasChanged, Is.True); Assert.That(orderA.State, Is.EqualTo(StateType.Unchanged)); var result = UnloadService.TryUnloadVirtualEndPointAndItemData(TestableClientTransaction, ordersEndPoint.ID); Assert.That(result, Is.False); Assert.That(orderA.State, Is.EqualTo(StateType.Unchanged)); Assert.That(ordersEndPoint.IsDataComplete, Is.True); }
public void UnloadVirtualEndPointAndItemData_ThrowsAndDoesNothing_IfItemCannotBeUnloaded() { var customer = DomainObjectIDs.Customer1.GetObject <Customer> (); var ordersEndPoint = DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(customer.Orders); var orderA = (Order)ordersEndPoint.Collection[0]; var orderB = (Order)ordersEndPoint.Collection[1]; // this will cause the orderB to be rejected for unload; orderA won't be unloaded either although it comes before orderB ++orderB.OrderNumber; Assert.That(orderA.State, Is.EqualTo(StateType.Unchanged)); Assert.That(orderB.State, Is.EqualTo(StateType.Changed)); Assert.That(() => UnloadService.UnloadVirtualEndPointAndItemData(TestableClientTransaction, ordersEndPoint.ID), Throws.InvalidOperationException); Assert.That(orderA.State, Is.EqualTo(StateType.Unchanged)); Assert.That(orderB.State, Is.EqualTo(StateType.Changed)); Assert.That(ordersEndPoint.IsDataComplete, Is.True); }
public void UnloadVirtualEndPoint_Collection_ChangedCollectionReference_Throws() { var order = DomainObjectIDs.Order1.GetObject <Order> (); order.OrderItems = new ObjectList <OrderItem> (order.OrderItems); // new collection reference, same contents var endPoint = DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(order.OrderItems); Assert.That(endPoint.HasChanged, Is.True); Assert.That( () => UnloadService.UnloadVirtualEndPoint(TestableClientTransaction, endPoint.ID), Throws.InvalidOperationException.With.Message.EqualTo( "The end point with ID " + "'Order|5682f032-2f0b-494b-a31c-c97f02b89c36|System.Guid/Remotion.Data.DomainObjects.UnitTests.TestDomain.Order.OrderItems' has been " + "changed. Changed end points cannot be unloaded.")); Assert.That(UnloadService.TryUnloadVirtualEndPoint(TestableClientTransaction, endPoint.ID), Is.False); CheckVirtualEndPointExistsAndComplete(order, "OrderItems", true, true); }
public void TryUnloadVirtualEndPointAndItemData_Failure_ItemCannotBeUnloaded_EndPointAndItemStillLoaded() { var customer = DomainObjectIDs.Customer1.GetObject <Customer> (); var ordersEndPoint = DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(customer.Orders); var orderA = (Order)ordersEndPoint.Collection[0]; var orderB = (Order)ordersEndPoint.Collection[1]; // this will cause the orderB to be rejected for unload; orderA won't be unloaded either although it comes before orderB ++orderB.OrderNumber; Assert.That(orderA.State, Is.EqualTo(StateType.Unchanged)); Assert.That(orderB.State, Is.EqualTo(StateType.Changed)); var result = UnloadService.TryUnloadVirtualEndPointAndItemData(TestableClientTransaction, ordersEndPoint.ID); Assert.That(result, Is.False); Assert.That(orderA.State, Is.EqualTo(StateType.Unchanged)); Assert.That(orderB.State, Is.EqualTo(StateType.Changed)); Assert.That(ordersEndPoint.IsDataComplete, Is.True); }
public void DomainObjectCollection_Associated() { var customer1 = DomainObjectIDs.Customer1.GetObject <Customer> (); var collection = customer1.Orders; var endPointID = collection.AssociatedEndPointID; var relatedIDs = collection.Select(obj => obj.ID).ToArray(); var deserializedCollectionAndTransaction = Serializer.SerializeAndDeserialize(Tuple.Create(collection, TestableClientTransaction)); var deserializedCollection = deserializedCollectionAndTransaction.Item1; var deserializedTransaction = deserializedCollectionAndTransaction.Item2; var deserializedEndPoint = deserializedTransaction.DataManager.GetRelationEndPointWithoutLoading(endPointID); Assert.That(DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(deserializedCollection), Is.SameAs(deserializedEndPoint)); var deserializedData = DomainObjectCollectionDataTestHelper.GetDataStrategyAndCheckType <ModificationCheckingCollectionDataDecorator> (deserializedCollection); DomainObjectCollectionDataTestHelper.GetWrappedDataAndCheckType <EndPointDelegatingCollectionData> (deserializedData); Assert.That(collection.Select(obj => obj.ID).ToArray(), Is.EqualTo(relatedIDs)); }
public void Clear_CancelAtSecondObject() { Assert.That(_oldCustomer.Orders, Is.EqualTo(new[] { _order1, _order2 })); var eventReceiver = new SequenceEventReceiver( new DomainObject[] { _oldCustomer, _order1, _order2 }, new[] { _oldCustomer.Orders }); eventReceiver.CancelEventNumber = 6; try { _oldCustomer.Orders.Clear(); Assert.Fail("Expected cancellation"); } catch (EventReceiverCancelException) { // ok } var expectedStates = new ChangeState[] { new RelationChangeState(_order2, typeof(Order).FullName + ".Customer", _oldCustomer, null, "1. Setting _order2.Customer to null"), new CollectionChangeState(_oldCustomer.Orders, _order2, "2. Removing _order2 from _oldCustomer.Orders"), new RelationChangeState(_oldCustomer, typeof(Customer).FullName + ".Orders", _order2, null, "3. Removing _order2 from _oldCustomer"), new RelationChangeState(_order1, typeof(Order).FullName + ".Customer", _oldCustomer, null, "4. Setting _order1.Customer to null"), new CollectionChangeState(_oldCustomer.Orders, _order1, "5. Removing _order1 from _oldCustomer.Orders"), new RelationChangeState(_oldCustomer, typeof(Customer).FullName + ".Orders", _order1, null, "6. Removing _order1 from _oldCustomer"), }; eventReceiver.Check(expectedStates); Assert.That(_oldCustomer.Orders, Is.EqualTo(new[] { _order1, _order2 })); Assert.That(_order2.Customer, Is.SameAs(_oldCustomer)); Assert.That(_order1.Customer, Is.SameAs(_oldCustomer)); Assert.That(DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(_oldCustomer.Orders).HasBeenTouched, Is.False); }
public void UnloadVirtualEndPointAndItemData_AppliedToParentTransaction_UnloadsFromWholeHierarchy() { var order = DomainObjectIDs.Order1.GetObject <Order> (); var parentOrderItemsEndPoint = DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(order.OrderItems); EnsureEndPointLoadedAndComplete(parentOrderItemsEndPoint.ID); var orderItem1 = parentOrderItemsEndPoint.Collection[0]; var subTransaction = TestableClientTransaction.CreateSubTransaction(); var subOrderItemsEndPoint = ClientTransactionTestHelper.GetDataManager(subTransaction).GetRelationEndPointWithLazyLoad( parentOrderItemsEndPoint.ID); EnsureEndPointLoadedAndComplete(ClientTransactionTestHelper.GetDataManager(subTransaction), subOrderItemsEndPoint.ID); UnloadService.UnloadVirtualEndPointAndItemData(TestableClientTransaction, parentOrderItemsEndPoint.ID); Assert.That(subOrderItemsEndPoint.IsDataComplete, Is.False); Assert.That(parentOrderItemsEndPoint.IsDataComplete, Is.False); Assert.That(orderItem1.TransactionContext[subTransaction].State, Is.EqualTo(StateType.NotLoadedYet)); Assert.That(orderItem1.TransactionContext[TestableClientTransaction].State, Is.EqualTo(StateType.NotLoadedYet)); }
public void Clear_Events() { Assert.That(_oldCustomer.Orders, Is.EqualTo(new[] { _order1, _order2 })); var eventReceiver = new SequenceEventReceiver( new DomainObject[] { _oldCustomer, _order1, _order2 }, new[] { _oldCustomer.Orders }); _oldCustomer.Orders.Clear(); var expectedStates = new ChangeState[] { new RelationChangeState(_order2, typeof(Order).FullName + ".Customer", _oldCustomer, null, "1. Setting _order2.Customer to null"), new CollectionChangeState(_oldCustomer.Orders, _order2, "2. Removing _order2 from _oldCustomer.Orders"), new RelationChangeState(_oldCustomer, typeof(Customer).FullName + ".Orders", _order2, null, "3. Removing _order2 from _oldCustomer"), new RelationChangeState(_order1, typeof(Order).FullName + ".Customer", _oldCustomer, null, "4. Setting _order1.Customer to null"), new CollectionChangeState(_oldCustomer.Orders, _order1, "5. Removing _order1 from _oldCustomer.Orders"), new RelationChangeState(_oldCustomer, typeof(Customer).FullName + ".Orders", _order1, null, "6. Removing _order1 from _oldCustomer"), new RelationChangeState(_oldCustomer, typeof(Customer).FullName + ".Orders", null, null, "7. Removed _order1 from _oldCustomer"), new CollectionChangeState(_oldCustomer.Orders, _order1, "8. Removed _order1 from _oldCustomer.Orders"), new RelationChangeState(_order1, typeof(Order).FullName + ".Customer", null, null, "9. Setting _order1.Customer to null"), new RelationChangeState(_oldCustomer, typeof(Customer).FullName + ".Orders", null, null, "10. Removed _order2 from _oldCustomer"), new CollectionChangeState(_oldCustomer.Orders, _order2, "11. Removed _order2 from _oldCustomer.Orders"), new RelationChangeState(_order2, typeof(Order).FullName + ".Customer", null, null, "12. Set _order2.Customer to null"), }; eventReceiver.Check(expectedStates); Assert.That(_oldCustomer.Orders, Is.Empty); Assert.That(_order2.Customer, Is.Null); Assert.That(_order1.Customer, Is.Null); Assert.That(DomainObjectCollectionDataTestHelper.GetAssociatedEndPoint(_oldCustomer.Orders).HasBeenTouched, Is.True); }