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 Initialization_Default() { var collection = new DomainObjectCollection(); Assert.That(collection.IsReadOnly, Is.False); Assert.That(collection.AssociatedEndPointID, Is.Null); DomainObjectCollectionDataTestHelper.CheckStandAloneCollectionStrategy(collection, null); }
public void Initialization_WithItemType() { var collection = new DomainObjectCollection(typeof(Order)); Assert.That(collection.IsReadOnly, Is.False); Assert.That(collection.AssociatedEndPointID, Is.Null); DomainObjectCollectionDataTestHelper.CheckStandAloneCollectionStrategy(collection, typeof(Order)); }
public void Clone_ReadOnly_DataStrategy() { OrderCollection associatedCollection = CreateAssociatedCollectionWithEndPointStub(); var clonedCollection = associatedCollection.Clone(true); // clone is always stand-alone, even when source is associated with end point DomainObjectCollectionDataTestHelper.CheckReadOnlyCollectionStrategy(clonedCollection); }
public void Clone_BecomesStandAlone() { OrderCollection associatedCollection = CreateAssociatedCollectionWithEndPointStub(); var clonedCollection = (DomainObjectCollection)associatedCollection.Clone(); // clone is always stand-alone, even when source is associated with end point DomainObjectCollectionDataTestHelper.CheckStandAloneCollectionStrategy(clonedCollection, associatedCollection.RequiredItemType); }
public void CreateCollection_ForStandaloneCollection() { DomainObjectCollection collection = _factory.CreateCollection(typeof(ObjectList <Order>), new[] { _orderA, _orderB }, typeof(Order)); Assert.That(collection, Is.Not.Null); Assert.That(collection.RequiredItemType, Is.EqualTo(typeof(Order))); DomainObjectCollectionDataTestHelper.CheckStandAloneCollectionStrategy(collection, typeof(Order)); }
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); }
private void CheckOriginalDataMatches(IDomainObjectCollectionData expected, IDomainObjectCollectionData actual) { var expectedInner = DomainObjectCollectionDataTestHelper.GetWrappedDataAndCheckType <CopyOnWriteDomainObjectCollectionData> ( (ReadOnlyCollectionDataDecorator)expected); var actualInner = DomainObjectCollectionDataTestHelper.GetWrappedDataAndCheckType <CopyOnWriteDomainObjectCollectionData> ( (ReadOnlyCollectionDataDecorator)actual); Assert.That(actualInner, Is.SameAs(expectedInner)); }
public void Clone() { var clonedCollection = _collection.Clone(); Assert.That(clonedCollection, Is.EqualTo(new[] { _customer1, _customer2 })); Assert.That(clonedCollection.IsReadOnly, Is.False); Assert.That(clonedCollection.RequiredItemType, Is.EqualTo(_collection.RequiredItemType)); DomainObjectCollectionDataTestHelper.CheckStandAloneCollectionStrategy(clonedCollection, typeof(Customer)); }
public void CopyOnWrite_Twice() { _copyOnWriteData.CopyOnWrite(); var data1 = DomainObjectCollectionDataTestHelper.GetWrappedData(_copyOnWriteData); _copyOnWriteData.CopyOnWrite(); var data2 = DomainObjectCollectionDataTestHelper.GetWrappedData(_copyOnWriteData); Assert.That(data1, Is.SameAs(data2)); }
private void CheckOriginalDataNotCopied(ChangeCachingCollectionDataDecorator decorator) { var originalData = DomainObjectCollectionDataTestHelper.GetWrappedDataAndCheckType <CopyOnWriteDomainObjectCollectionData> ( decorator.OriginalData); var originalDataStore = DomainObjectCollectionDataTestHelper.GetWrappedData(originalData); var observedWrappedData = PrivateInvoke.GetNonPublicField(decorator, "_observedWrappedData"); Assert.That(originalDataStore, Is.SameAs(observedWrappedData)); }
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 CollectionEndPoint_DelegatingDataMembers() { _endPoint.Collection.Add(DomainObjectIDs.OrderItem5.GetObject <OrderItem>()); var deserializedEndPoint = FlattenedSerializer.SerializeAndDeserialize(_endPoint); DomainObjectCollectionDataTestHelper.CheckAssociatedCollectionStrategy( deserializedEndPoint.Collection, _endPoint.Collection.RequiredItemType, deserializedEndPoint.ID); }
public void Initialization_WithEnumerable() { var collection = new DomainObjectCollection(new[] { _customer1, _customer2 }, typeof(Customer)); Assert.That(collection, Is.EqualTo(new[] { _customer1, _customer2 })); Assert.That(collection.RequiredItemType, Is.SameAs(typeof(Customer))); Assert.That(collection.IsReadOnly, Is.False); Assert.That(collection.AssociatedEndPointID, Is.Null); DomainObjectCollectionDataTestHelper.CheckStandAloneCollectionStrategy(collection, typeof(Customer)); }
public void Commit_ReadOnly() { _customerEndPoint.Collection.Add(_order3); DomainObjectCollectionDataTestHelper.MakeCollectionReadOnly(_customerEndPoint.Collection); _customerEndPoint.Commit(); Assert.That(_customerEndPoint.Collection, Is.EqualTo(new[] { _order1, _order2, _order3 })); Assert.That(_customerEndPoint.GetCollectionWithOriginalData(), Is.EqualTo(new[] { _order1, _order2, _order3 })); Assert.That(_customerEndPoint.OriginalCollection, Is.SameAs(_customerEndPoint.Collection)); Assert.That(_customerEndPoint.Collection.IsReadOnly, Is.True); }
public void DomainObjectCollection_StandAlone_Data() { var collection = new DomainObjectCollection(typeof(Order)); collection.Add(DomainObjectIDs.Order1.GetObject <Order> ()); DomainObjectCollection deserializedCollection = SerializeAndDeserialize(collection); DomainObjectCollectionDataTestHelper.CheckStandAloneCollectionStrategy(deserializedCollection, typeof(Order)); Assert.That(deserializedCollection.Count, Is.EqualTo(1)); Assert.That(deserializedCollection[0].ID, Is.EqualTo(DomainObjectIDs.Order1)); }
public void Initialization_WithData() { var givenData = new DomainObjectCollectionData(); var collection = new DomainObjectCollection(givenData); Assert.That(collection.IsReadOnly, Is.False); Assert.That(collection.AssociatedEndPointID, Is.Null); var actualData = DomainObjectCollectionDataTestHelper.GetDataStrategy(collection); Assert.That(actualData, Is.SameAs(givenData)); }
public void RollbackReadOnlyOppositeDomainObjects() { Customer customer = DomainObjectIDs.Customer1.GetObject <Customer> (); customer.Orders.Add(DomainObjectIDs.Order3.GetObject <Order> ()); DomainObjectCollectionDataTestHelper.MakeCollectionReadOnly(customer.Orders); TestableClientTransaction.Rollback(); Assert.That(customer.GetOriginalRelatedObjects("Remotion.Data.DomainObjects.UnitTests.TestDomain.Customer.Orders").IsReadOnly, Is.True); Assert.That(customer.Orders.IsReadOnly, Is.True); }
public void TransformToStandAlone() { var endPoint = RelationEndPointObjectMother.CreateCollectionEndPoint_Customer1_Orders(); var collection = endPoint.Collection; var originalCollectionDataStrategy = DomainObjectCollectionDataTestHelper.GetDataStrategy(collection); var originalCollectionContents = collection.Cast <DomainObject> ().ToArray(); var result = ((IAssociatableDomainObjectCollection)collection).TransformToStandAlone(); DomainObjectCollectionDataTestHelper.CheckStandAloneCollectionStrategy(collection, typeof(Order)); Assert.That(collection, Is.EqualTo(originalCollectionContents)); Assert.That(result, Is.SameAs(originalCollectionDataStrategy)); }
public void GetData() { var collectionDataStub = MockRepository.GenerateStub <IDomainObjectCollectionData> (); _dataManagerMock.Stub(stub => stub.CollectionData).Return(collectionDataStub); var result = _loadState.GetData(_collectionEndPointMock); Assert.That(result, Is.TypeOf(typeof(ReadOnlyCollectionDataDecorator))); var wrappedData = DomainObjectCollectionDataTestHelper.GetWrappedData(result); Assert.That(wrappedData, Is.SameAs(collectionDataStub)); }
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 RegisterOriginalItem_ItemAlreadyExists_InOriginal() { var underlyingOriginalData = DomainObjectCollectionDataTestHelper.GetWrappedDataAndCheckType <CopyOnWriteDomainObjectCollectionData> ( _decoratorWithRealData.OriginalData); var domainObject = DomainObjectMother.CreateFakeObject <Order> (); underlyingOriginalData.Add(domainObject); Assert.That(_decoratorWithRealData.GetObject(domainObject.ID), Is.Null); Assert.That(_decoratorWithRealData.OriginalData.GetObject(domainObject.ID), Is.Not.Null); _decoratorWithRealData.RegisterOriginalItem(domainObject); }
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 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 SetCollection_DataStrategy_OfNewOpposites() { var newOpposites = new OrderCollection { _order2 }; SetCollectionAndNotify(_customerEndPoint, newOpposites); // New collection now has a delegating data store... DomainObjectCollectionDataTestHelper.CheckAssociatedCollectionStrategy(newOpposites, typeof(Order), _customerEndPoint.ID); // ... and the end-point now has data newOpposites had before! Assert.That(_customerEndPoint.GetData(), Is.EqualTo(new[] { _order2 })); Assert.That(newOpposites, Is.EqualTo(new[] { _order2 })); }
public void CreateDataStrategyForEndPoint() { var ordersEndPointID = RelationEndPointID.Create(DomainObjectIDs.Customer1, typeof(Customer), "Orders"); var result = _factory.CreateDataStrategyForEndPoint(ordersEndPointID); Assert.That(result, Is.TypeOf <ModificationCheckingCollectionDataDecorator> ()); var checkingDecorator = (ModificationCheckingCollectionDataDecorator)result; Assert.That(checkingDecorator.RequiredItemType, Is.SameAs(typeof(Order))); var delegator = DomainObjectCollectionDataTestHelper.GetWrappedDataAndCheckType <EndPointDelegatingCollectionData> (checkingDecorator); Assert.That(delegator.AssociatedEndPointID, Is.EqualTo(ordersEndPointID)); Assert.That(delegator.VirtualEndPointProvider, Is.SameAs(_virtualEndPointProviderStub)); }
public void SetCollection_SourceCollection_IsReadOnly() { DomainObjectCollectionDataTestHelper.MakeCollectionReadOnly(_customerEndPoint.Collection); var newOpposites = new OrderCollection { _order2, _order3 }; var oldOpposites = _customerEndPoint.Collection; Assert.That(oldOpposites.IsReadOnly, Is.True); SetCollectionAndNotify(_customerEndPoint, newOpposites); Assert.That(_customerEndPoint.Collection, Is.SameAs(newOpposites)); Assert.That(_customerEndPoint.OriginalCollection, Is.SameAs(oldOpposites)); }
public void TransformToAssociated() { var endPointID = RelationEndPointID.Create(DomainObjectIDs.Customer1, typeof(Customer), "Orders"); var originalCollectionDataStrategy = DomainObjectCollectionDataTestHelper.GetDataStrategy(_collection); var originalCollectionContents = _collection.Cast <DomainObject> ().ToArray(); var originalEndPointContents = ((ICollectionEndPoint)TestableClientTransaction.DataManager.GetRelationEndPointWithLazyLoad(endPointID)).GetData().ToArray(); var associatedCollectionDataStrategyFactory = new AssociatedCollectionDataStrategyFactory(TestableClientTransaction.DataManager); var result = ((IAssociatableDomainObjectCollection)_collection).TransformToAssociated(endPointID, associatedCollectionDataStrategyFactory); DomainObjectCollectionDataTestHelper.CheckAssociatedCollectionStrategy(_collection, typeof(Order), endPointID); Assert.That(result, Is.SameAs(originalCollectionDataStrategy)); Assert.That(result, Is.EqualTo(originalCollectionContents)); Assert.That(_collection, Is.EqualTo(originalEndPointContents)); }
public void GetCollection() { _associatedCollectionDataStrategyFactoryMock .Expect(mock => mock.CreateDataStrategyForEndPoint(_endPointID)) .Return(_dataStrategyStub); _associatedCollectionDataStrategyFactoryMock.Replay(); _dataStrategyStub.Stub(stub => stub.AssociatedEndPointID).Return(_endPointID); var result = _provider.GetCollection(_endPointID); _associatedCollectionDataStrategyFactoryMock.VerifyAllExpectations(); Assert.That(result, Is.TypeOf <OrderCollection> ()); Assert.That(DomainObjectCollectionDataTestHelper.GetDataStrategy(result), Is.SameAs(_dataStrategyStub)); Assert.That(result, Is.SameAs(_provider.GetCollection(_endPointID))); }
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)); }