public void GroupAndRegisterRelatedObjects_PropertyOnDerivedType()
{
var endPointDefinition = GetEndPointDefinition(typeof(Customer), "ContactPerson");
var originatingCustomer = DomainObjectMother.CreateFakeObject <Customer>();
var originatingCustomerData = LoadedObjectDataObjectMother.CreateLoadedObjectDataStub(originatingCustomer);
var originatingCompany = DomainObjectMother.CreateFakeObject <Company>();
var originatingCompanyData = LoadedObjectDataObjectMother.CreateLoadedObjectDataStub(originatingCompany);
var originatingSupplier = DomainObjectMother.CreateFakeObject <Supplier>();
var originatingSupplierData = LoadedObjectDataObjectMother.CreateLoadedObjectDataStub(originatingSupplier);
var fetchedPerson = DomainObjectMother.CreateFakeObject <Person>();
var fetchedPersonData = LoadedObjectDataObjectMother.CreateLoadedObjectDataWithDataSourceData(fetchedPerson);
fetchedPersonData.DataSourceData.SetValue(GetPropertyDefinition(typeof(Person), "AssociatedCustomerCompany"), originatingCustomer.ID);
_loadedDataContainerProviderStub.Stub(stub => stub.GetDataContainerWithoutLoading(fetchedPerson.ID)).Return(fetchedPersonData.DataSourceData);
var endPointMock = MockRepository.GenerateStrictMock <IVirtualObjectEndPoint> ();
ExpectGetEndPoint(originatingCustomer.ID, endPointDefinition, _virtualEndPointProviderMock, endPointMock, false);
endPointMock.Expect(mock => mock.MarkDataComplete(fetchedPerson));
_virtualEndPointProviderMock.Replay();
endPointMock.Replay();
_agent.GroupAndRegisterRelatedObjects(
endPointDefinition,
new[] { originatingCustomerData, originatingCompanyData, originatingSupplierData },
new[] { fetchedPersonData });
_virtualEndPointProviderMock.VerifyAllExpectations();
endPointMock.VerifyAllExpectations();
}
public void CreateSetCommand_NotSame()
{
_dataManagerMock.Stub(stub => stub.CurrentOppositeObject).Return(_relatedObject);
_dataManagerMock.Stub(stub => stub.OriginalItemWithoutEndPoint).Return(null);
_dataManagerMock.Replay();
_virtualObjectEndPointMock.Stub(mock => mock.GetDomainObject()).Return(_owningObject);
_virtualObjectEndPointMock.Stub(mock => mock.GetOppositeObject()).Return(_relatedObject);
_virtualObjectEndPointMock.Stub(mock => mock.IsNull).Return(false);
_virtualObjectEndPointMock.Stub(mock => mock.Definition).Return(_definition);
_virtualObjectEndPointMock.Replay();
var newRelatedObject = DomainObjectMother.CreateFakeObject <OrderTicket> ();
var command = (RelationEndPointModificationCommand)_loadState.CreateSetCommand(_virtualObjectEndPointMock, newRelatedObject);
Assert.That(command, Is.TypeOf(typeof(ObjectEndPointSetOneOneCommand)));
Assert.That(command.ModifiedEndPoint, Is.SameAs(_virtualObjectEndPointMock));
Assert.That(command.NewRelatedObject, Is.SameAs(newRelatedObject));
Assert.That(command.OldRelatedObject, Is.SameAs(_relatedObject));
Assert.That(command.TransactionEventSink, Is.SameAs(_transactionEventSinkStub));
CheckOppositeObjectIDSetter((ObjectEndPointSetCommand)command);
}
public override void SetUp()
{
base.SetUp();
_endPointID = RelationEndPointID.Create(DomainObjectIDs.Customer1, typeof(Customer), "Orders");
_collectionEndPointMock = MockRepository.GenerateStrictMock <ICollectionEndPoint> ();
_endPointLoaderMock = MockRepository.GenerateStrictMock <IncompleteCollectionEndPointLoadState.IEndPointLoader> ();
_dataManagerFactoryStub = MockRepository.GenerateStub <ICollectionEndPointDataManagerFactory> ();
var dataManagerStub = MockRepository.GenerateStub <ICollectionEndPointDataManager> ();
dataManagerStub.Stub(stub => stub.HasDataChanged()).Return(false);
_loadState = new IncompleteCollectionEndPointLoadState(_endPointLoaderMock, _dataManagerFactoryStub);
_relatedObject = DomainObjectMother.CreateFakeObject <Order> ();
_relatedEndPointStub = MockRepository.GenerateStub <IRealObjectEndPoint> ();
_relatedEndPointStub.Stub(stub => stub.ObjectID).Return(_relatedObject.ID);
_relatedObject2 = DomainObjectMother.CreateFakeObject <Order> ();
_relatedEndPointStub2 = MockRepository.GenerateStub <IRealObjectEndPoint> ();
_relatedEndPointStub2.Stub(stub => stub.ObjectID).Return(_relatedObject2.ID);
}
public override void SetUp()
{
base.SetUp();
_endPointID = RelationEndPointObjectMother.CreateRelationEndPointID(DomainObjectIDs.Order1, "OrderTicket");
_lazyLoaderMock = MockRepository.GenerateStrictMock <ILazyLoader>();
_endPointProviderStub = MockRepository.GenerateStub <IRelationEndPointProvider> ();
_transactionEventSinkStub = MockRepository.GenerateStub <IClientTransactionEventSink>();
_dataManagerFactory = new VirtualObjectEndPointDataManagerFactory();
_loadStateMock = MockRepository.GenerateStrictMock <IVirtualObjectEndPointLoadState> ();
_endPoint = new VirtualObjectEndPoint(
ClientTransaction.Current,
_endPointID,
_lazyLoaderMock,
_endPointProviderStub,
_transactionEventSinkStub,
_dataManagerFactory);
PrivateInvoke.SetNonPublicField(_endPoint, "_loadState", _loadStateMock);
_oppositeEndPointStub = MockRepository.GenerateStub <IRealObjectEndPoint>();
_oppositeObject = DomainObjectMother.CreateFakeObject <OrderTicket>();
}
public static PersistableData Create()
{
var domainObject = DomainObjectMother.CreateFakeObject <Order>();
return(new PersistableData(domainObject, StateType.New, DataContainer.CreateNew(domainObject.ID), new IRelationEndPoint[0]));
}
public void CreateSetCommand()
{
var orderTicket = DomainObjectMother.CreateFakeObject <OrderTicket> ();
CheckCreateStateUpdateRaisingCommand(ep => ep.CreateSetCommand(orderTicket));
}
public void Resolve_Expression_NonExistingProperty()
{
var instance = DomainObjectMother.CreateFakeObject <Order> (_objectID);
RelationEndPointID.Resolve(instance, o => ((OrderItem)(object)o).Product);
}
public static LoadedObjectDataWithDataSourceData CreateLoadedObjectDataWithDataSourceData()
{
return(CreateLoadedObjectDataWithDataSourceData(DomainObjectMother.CreateFakeObject <Order>()));
}
private InvalidLoadedObjectData GetInvalidLoadedObject()
{
var domainObject = DomainObjectMother.CreateFakeObject <Order> ();
return(new InvalidLoadedObjectData(domainObject));
}
public void CreateSetCommand()
{
var relatedObject = DomainObjectMother.CreateFakeObject <OrderTicket> ();
_state.CreateSetCommand(_endPointStub, relatedObject, domainObject => { });
}
public void OnAfterObjectRegistration_ExceptionInEventSink_HierarchyManager_IsStillNotified()
{
var loadedObjectIDs = Array.AsReadOnly(new[] { DomainObjectIDs.Order1, DomainObjectIDs.Order3 });
var actuallyLoadedDomainObjects = Array.AsReadOnly(new[] { DomainObjectMother.CreateFakeObject(), DomainObjectMother.CreateFakeObject() });
var exception = new Exception("Test");
using (_mockRepository.Ordered())
{
_eventSinkWithMock.Expect(mock => mock.RaiseObjectsLoadedEvent(actuallyLoadedDomainObjects))
.Throw(exception);
_hierarchyManagerMock.Expect(mock => mock.OnAfterObjectRegistration(loadedObjectIDs));
}
_mockRepository.ReplayAll();
Assert.That(() => _decorator.OnAfterObjectRegistration(loadedObjectIDs, actuallyLoadedDomainObjects), Throws.Exception.SameAs(exception));
_mockRepository.VerifyAll();
}
public void OnAfterObjectRegistration()
{
var loadedObjectIDs = Array.AsReadOnly(new[] { DomainObjectIDs.Order1, DomainObjectIDs.Order3 });
var actuallyLoadedDomainObjects = Array.AsReadOnly(new[] { DomainObjectMother.CreateFakeObject(), DomainObjectMother.CreateFakeObject() });
using (_mockRepository.Ordered())
{
_eventSinkWithMock.Expect(mock => mock.RaiseObjectsLoadedEvent(actuallyLoadedDomainObjects));
_hierarchyManagerMock.Expect(mock => mock.OnAfterObjectRegistration(loadedObjectIDs));
}
_mockRepository.ReplayAll();
_decorator.OnAfterObjectRegistration(loadedObjectIDs, actuallyLoadedDomainObjects);
_mockRepository.VerifyAll();
}
public void UnregisterOriginalItemWithoutEndPoint_InvalidID()
{
_dataManager.RegisterOriginalItemWithoutEndPoint(_oppositeObject);
_dataManager.UnregisterOriginalItemWithoutEndPoint(DomainObjectMother.CreateFakeObject <OrderTicket> (DomainObjectIDs.OrderTicket2));
}
public static QueryResult <T> CreateQueryResult <T> () where T : DomainObject
{
return(new QueryResult <T> (QueryObjectMother.Create(), new[] { DomainObjectMother.CreateFakeObject <T>() }));
}
public void CreateInsertCommand()
{
var orderItem = DomainObjectMother.CreateFakeObject <OrderItem> ();
CheckCreateStateUpdateRaisingCommand(ep => ep.CreateInsertCommand(orderItem, 0));
}
public void ContainsObject_False_SameID_DifferentReference()
{
var customer1InOtherTransaction = DomainObjectMother.GetObjectInOtherTransaction <Customer> (_collection[0].ID);
Assert.That(_collection.ContainsObject(customer1InOtherTransaction), Is.False);
}
public void CreateReplaceCommand()
{
var orderItem = DomainObjectMother.CreateFakeObject <OrderItem> ();
CheckCreateStateUpdateRaisingCommand(ep => ep.CreateReplaceCommand(0, orderItem));
}
public void IndexOf_Object_OtherTransaction()
{
var customer1InOtherTransaction = DomainObjectMother.GetObjectInOtherTransaction <Customer> (_collection[0].ID);
Assert.That(_collection.IndexOf(customer1InOtherTransaction), Is.EqualTo(-1));
}
public static LoadedObjectDataWithDataSourceData CreateLoadedObjectDataWithDataSourceData(ObjectID objectID)
{
return(CreateLoadedObjectDataWithDataSourceData(DomainObjectMother.CreateFakeObject(objectID)));
}
public void SetEquals_UsesReferenceComparison()
{
var order1FromOtherTransaction = DomainObjectMother.GetObjectInOtherTransaction <Order> (_order1.ID);
Assert.That(_data.SetEquals(new[] { order1FromOtherTransaction, _order2 }), Is.False);
}
public void Resolve_Expression_NonRelationProperty()
{
var instance = DomainObjectMother.CreateFakeObject <Order> (_objectID);
RelationEndPointID.Resolve(instance, o => o.OrderNumber);
}
public void CreateAddCommand()
{
var fakeCollectionData =
new DomainObjectCollectionData(new[] { DomainObjectMother.CreateFakeObject <Order> (), DomainObjectMother.CreateFakeObject <Order> () });
_dataManagerMock.Stub(stub => stub.CollectionData).Return(fakeCollectionData);
_dataManagerMock.Stub(stub => stub.ContainsOriginalItemWithoutEndPoint(_relatedObject)).Return(false);
var fakeCollection = new DomainObjectCollection();
_collectionEndPointMock.Stub(mock => mock.IsNull).Return(false);
_collectionEndPointMock.Stub(mock => mock.Collection).Return(fakeCollection);
_collectionEndPointMock.Stub(mock => mock.GetDomainObject()).Return(_owningObject);
var command = (RelationEndPointModificationCommand)_loadState.CreateAddCommand(_collectionEndPointMock, _relatedObject);
Assert.That(command, Is.InstanceOf(typeof(CollectionEndPointInsertCommand)));
Assert.That(command.ModifiedEndPoint, Is.SameAs(_collectionEndPointMock));
Assert.That(command.NewRelatedObject, Is.SameAs(_relatedObject));
Assert.That(((CollectionEndPointInsertCommand)command).Index, Is.EqualTo(2));
Assert.That(((CollectionEndPointInsertCommand)command).ModifiedCollectionData, Is.SameAs(fakeCollectionData));
Assert.That(((CollectionEndPointInsertCommand)command).ModifiedCollection, Is.SameAs(fakeCollection));
Assert.That(((CollectionEndPointInsertCommand)command).EndPointProvider, Is.SameAs(_endPointProviderStub));
}
