public void CloneTransaction_ManualSet()
{
ClientTransaction cloneTransaction = ClientTransactionObjectMother.Create();
_cloner.CloneTransaction = cloneTransaction;
Assert.That(_cloner.CloneTransaction, Is.SameAs(cloneTransaction));
}
public void InactiveTransactionIsActivated_ForEvents_EvenWhenAlreadyCurrent()
{
var inactiveClientTransaction = ClientTransaction.CreateRootTransaction();
using (inactiveClientTransaction.EnterNonDiscardingScope())
{
using (ClientTransactionTestHelper.MakeInactive(inactiveClientTransaction))
{
var transactionEventReceiverMock = MockRepository.GenerateStrictMock <ClientTransactionMockEventReceiver> (inactiveClientTransaction);
transactionEventReceiverMock
.Expect(mock => mock.SubTransactionCreated(Arg <ClientTransaction> .Is.Anything, Arg <SubTransactionCreatedEventArgs> .Is.Anything))
.WhenCalled(
mi =>
{
Assert.That(ClientTransaction.Current, Is.SameAs(inactiveClientTransaction));
Assert.That(ClientTransaction.Current.ActiveTransaction, Is.SameAs(inactiveClientTransaction));
});
var eventBroker = new ClientTransactionEventBroker(inactiveClientTransaction);
eventBroker.RaiseSubTransactionCreatedEvent(ClientTransactionObjectMother.Create());
transactionEventReceiverMock.VerifyAllExpectations();
}
}
}
public void CreateSubTransaction()
{
var counter = new OrderedExpectationCounter();
bool subTransactionCreatingCalled = false;
_thisEventSinkWithStrictMock.Expect(mock => mock.RaiseSubTransactionCreatingEvent())
.WhenCalledOrdered(counter, mi =>
{
Assert.That(_manager.IsWriteable, Is.True);
subTransactionCreatingCalled = true;
});
ClientTransaction fakeSubTransaction = ClientTransactionObjectMother.CreateWithParent(_thisTransaction);
Func <ClientTransaction, ClientTransaction> factory = tx =>
{
Assert.That(tx, Is.SameAs(_thisTransaction));
Assert.That(subTransactionCreatingCalled, Is.True);
Assert.That(_manager.IsWriteable, Is.False, "IsWriteable needs to be set before the factory is called.");
ClientTransactionTestHelper.SetIsWriteable(_thisTransaction, false); // required by assertion in ReadOnlyClientTransactionListener
return(fakeSubTransaction);
};
_hierarchyStrictMock.Expect(mock => mock.AppendLeafTransaction(fakeSubTransaction)).Ordered(counter);
_thisEventSinkWithStrictMock.Expect(mock => mock.RaiseSubTransactionCreatedEvent(fakeSubTransaction)).Ordered(counter);
var result = _manager.CreateSubTransaction(factory);
Assert.That(result, Is.Not.Null.And.SameAs(fakeSubTransaction));
Assert.That(_manager.SubTransaction, Is.SameAs(fakeSubTransaction));
Assert.That(_manager.IsWriteable, Is.False);
_hierarchyStrictMock.VerifyAllExpectations();
}
public override void SetUp()
{
base.SetUp();
_mockRepository = new MockRepository();
_eventSinkWithMock = _mockRepository.StrictMock <IClientTransactionEventSink>();
_persistenceStrategyMock = _mockRepository.StrictMock <IPersistenceStrategy> ();
_dataManagerMock = _mockRepository.StrictMock <IDataManager> ();
_clientTransaction = ClientTransactionObjectMother.Create();
_agent = new CommitRollbackAgent(_clientTransaction, _eventSinkWithMock, _persistenceStrategyMock, _dataManagerMock);
_fakeChangedDomainObject = LifetimeService.NewObject(_clientTransaction, typeof(Order), ParamList.Empty);
_fakeNewDomainObject = LifetimeService.NewObject(_clientTransaction, typeof(Order), ParamList.Empty);
_fakeDeletedDomainObject = LifetimeService.NewObject(_clientTransaction, typeof(Order), ParamList.Empty);
var fakeDataContainer1 = DataContainerObjectMother.Create();
var fakeDataContainer2 = DataContainerObjectMother.Create();
var fakeDataContainer3 = DataContainerObjectMother.Create();
_fakeChangedPersistableItem = new PersistableData(_fakeChangedDomainObject, StateType.Changed, fakeDataContainer1, new IRelationEndPoint[0]);
_fakeNewPersistableItem = new PersistableData(_fakeNewDomainObject, StateType.New, fakeDataContainer2, new IRelationEndPoint[0]);
_fakeDeletedPersistableItem = new PersistableData(_fakeDeletedDomainObject, StateType.Deleted, fakeDataContainer3, new IRelationEndPoint[0]);
}
private ClientTransaction CreateFakeSubTransaction(ClientTransaction clientTransaction)
{
var fakeSubTransaction = ClientTransactionObjectMother.Create();
ClientTransactionTestHelper.SetSubTransaction(clientTransaction, fakeSubTransaction);
return(fakeSubTransaction);
}
public void GetOptionalRelatedObjectOverVirtualEndPointTwice()
{
var id = new ObjectID("ClassWithGuidKey", new Guid("{672C8754-C617-4b7a-890C-BFEF8AC86564}"));
CountingObjectLoaderDecorator decorator = null;
var clientTransactionMock = ClientTransactionObjectMother.CreateTransactionWithObjectLoaderDecorator <TestableClientTransaction> (
loader => decorator ?? (decorator = new CountingObjectLoaderDecorator(loader)));
DomainObject classWithGuidKey = clientTransactionMock.GetObject(id, false);
Assert.That(decorator.NumberOfCallsToLoadObject, Is.EqualTo(1));
Assert.That(decorator.NumberOfCallsToLoadRelatedObject, Is.EqualTo(0));
Assert.That(
clientTransactionMock.GetRelatedObject(
RelationEndPointID.Create(
classWithGuidKey.ID, "Remotion.Data.DomainObjects.UnitTests.TestDomain.ClassWithGuidKey.ClassWithValidRelationsOptional")),
Is.Null);
Assert.That(decorator.NumberOfCallsToLoadObject, Is.EqualTo(1));
Assert.That(decorator.NumberOfCallsToLoadRelatedObject, Is.EqualTo(1));
clientTransactionMock.GetRelatedObject(
RelationEndPointID.Create(classWithGuidKey.ID, "Remotion.Data.DomainObjects.UnitTests.TestDomain.ClassWithGuidKey.ClassWithValidRelationsOptional"));
Assert.That(decorator.NumberOfCallsToLoadObject, Is.EqualTo(1));
Assert.That(decorator.NumberOfCallsToLoadRelatedObject, Is.EqualTo(1));
}
public void GetOptionalRelatedObjectTwice()
{
var id = new ObjectID("ClassWithValidRelations", new Guid("{6BE4FA61-E050-469c-9DBA-B47FFBB0F8AD}"));
CountingObjectLoaderDecorator decorator = null;
var clientTransaction =
ClientTransactionObjectMother.CreateTransactionWithObjectLoaderDecorator <TestableClientTransaction> (
loader => decorator ?? (decorator = new CountingObjectLoaderDecorator(loader)));
DomainObject classWithValidRelation = clientTransaction.GetObject(id, false);
Assert.That(decorator.NumberOfCallsToLoadObject, Is.EqualTo(1));
Assert.That(decorator.NumberOfCallsToLoadRelatedObject, Is.EqualTo(0));
Assert.That(
clientTransaction.GetRelatedObject(
RelationEndPointID.Create(
classWithValidRelation.ID, "Remotion.Data.DomainObjects.UnitTests.TestDomain.ClassWithValidRelations.ClassWithGuidKeyOptional")),
Is.Null);
Assert.That(decorator.NumberOfCallsToLoadObject, Is.EqualTo(1));
Assert.That(decorator.NumberOfCallsToLoadRelatedObject, Is.EqualTo(0));
clientTransaction.GetRelatedObject(
RelationEndPointID.Create(classWithValidRelation.ID, "Remotion.Data.DomainObjects.UnitTests.TestDomain.ClassWithValidRelations.ClassWithGuidKeyOptional"));
Assert.That(decorator.NumberOfCallsToLoadObject, Is.EqualTo(1));
Assert.That(decorator.NumberOfCallsToLoadRelatedObject, Is.EqualTo(0));
}
private void FakeManagerWithSubtransaction(TransactionHierarchyManager transactionHierarchyManager)
{
TransactionHierarchyManagerTestHelper.SetIsWriteable(transactionHierarchyManager, false);
var fakeSubTransaction = ClientTransactionObjectMother.CreateWithParent(transactionHierarchyManager.ThisTransaction);
TransactionHierarchyManagerTestHelper.SetSubtransaction(transactionHierarchyManager, fakeSubTransaction);
}
public override void SetUp()
{
base.SetUp();
_transaction = ClientTransactionObjectMother.Create();
_eventSinkWithMock = MockRepository.GenerateStrictMock <IClientTransactionEventSink>();
_invalidDomainObjectManagerMock = MockRepository.GenerateStrictMock <IInvalidDomainObjectManager> ();
_dataManagerMock = MockRepository.GenerateStrictMock <IDataManager> ();
_enlistedDomainObjectManagerMock = MockRepository.GenerateStrictMock <IEnlistedDomainObjectManager> ();
_persistenceStrategyMock = MockRepository.GenerateStrictMock <IPersistenceStrategy>();
_agent = new ObjectLifetimeAgent(
_transaction,
_eventSinkWithMock,
_invalidDomainObjectManagerMock,
_dataManagerMock,
_enlistedDomainObjectManagerMock,
_persistenceStrategyMock);
_objectID1 = DomainObjectIDs.Order1;
_domainObject1 = DomainObjectMother.CreateFakeObject(_objectID1);
_dataContainer1 = DataContainerObjectMother.CreateExisting(_domainObject1);
_objectID2 = DomainObjectIDs.Order3;
_domainObject2 = DomainObjectMother.CreateFakeObject(_objectID2);
_dataContainer2 = DataContainerObjectMother.CreateExisting(_domainObject2);
_domainObjectCreatorMock = MockRepository.GenerateStrictMock <IDomainObjectCreator>();
_typeDefinitionWithCreatorMock = ClassDefinitionObjectMother.CreateClassDefinitionWithTable(
TestDomainStorageProviderDefinition,
classType: typeof(OrderItem),
instanceCreator: _domainObjectCreatorMock);
_objectIDWithCreatorMock = new ObjectID(_typeDefinitionWithCreatorMock, Guid.NewGuid());
}
public void CloneTransaction_Reset()
{
ClientTransaction cloneTransaction = ClientTransactionObjectMother.Create();
_cloner.CloneTransaction = cloneTransaction;
_cloner.CloneTransaction = null;
Assert.That(_cloner.CloneTransaction, Is.SameAs(TestableClientTransaction));
}
public void RaiseSubTransactionInitializeEvent()
{
var subTransaction = ClientTransactionObjectMother.Create();
CheckEventWithListenersFirst(
s => s.RaiseSubTransactionInitializeEvent(subTransaction),
l => l.SubTransactionInitialize(_clientTransaction, subTransaction),
x => x.SubTransactionInitialize(_clientTransaction, subTransaction));
}
public void Leave_NullAttachedScope_NoExceptionThrown()
{
var scopedTransaction = ClientTransactionObjectMother.Create();
var scope =
(ClientTransactionScope)
PrivateInvoke.CreateInstanceNonPublicCtor(typeof(ClientTransactionScope), scopedTransaction, AutoRollbackBehavior.None, null);
Assert.That(() => scope.Leave(), Throws.Nothing);
}
private ClientTransaction CreateTransactionWithStubbedLoading(DataContainer loadableDataContainer)
{
var persistenceStrategyStub = MockRepository.GenerateStub <IFetchEnabledPersistenceStrategy>();
persistenceStrategyStub.Stub(stub => stub.LoadObjectData(loadableDataContainer.ID)).Return(new FreshlyLoadedObjectData(loadableDataContainer));
persistenceStrategyStub
.Stub(stub => stub.LoadObjectData(Arg <IEnumerable <ObjectID> > .List.Equal(new[] { loadableDataContainer.ID })))
.Return(new[] { new FreshlyLoadedObjectData(loadableDataContainer) });
return(ClientTransactionObjectMother.CreateTransactionWithPersistenceStrategy <ClientTransaction> (persistenceStrategyStub));
}
public void ActivateTransaction_TransactionNotFromHierarchy_Throws()
{
var unrelatedTransaction = ClientTransactionObjectMother.Create();
Assert.That(
() => _hierarchy.ActivateTransaction(unrelatedTransaction),
Throws.ArgumentException.With.Message.EqualTo(
"The activated transaction must be from this ClientTransactionHierarchy.\r\nParameter name: clientTransaction"));
Assert.That(_hierarchy.ActiveTransaction, Is.SameAs(_rootTransaction));
}
public override void SetUp()
{
base.SetUp();
_clientTransaction = ClientTransactionObjectMother.Create();
_mockRepository = new MockRepository();
_dataManagerMock = _mockRepository.StrictMock <IDataManager> ();
_registrationListenerMock = _mockRepository.StrictMock <ILoadedObjectDataRegistrationListener> ();
_agent = new LoadedObjectDataRegistrationAgent(_clientTransaction, _dataManagerMock, _registrationListenerMock);
}
public override void SetUp()
{
base.SetUp();
_listener = new ReadOnlyClientTransactionListenerWithLoadRules();
_transaction = ClientTransactionObjectMother.Create();
_client1 = LifetimeService.GetObjectReference(_transaction, DomainObjectIDs.Client1);
_order1 = LifetimeService.GetObjectReference(_transaction, DomainObjectIDs.Order1);
_orderNumberPropertyDefinition = GetPropertyDefinition(typeof(Order), "OrderNumber");
_orderTicketEndPointDefinition = GetEndPointDefinition(typeof(Order), "OrderTicket");
}
public void AppendLeafTransaction_WithNotASubOfCurrentLeaf_Throws()
{
var unrelatedTransaction = ClientTransactionObjectMother.Create();
Assert.That(
() => _hierarchy.AppendLeafTransaction(unrelatedTransaction),
Throws.ArgumentException.With.Message.EqualTo(
"The new LeafTransaction must have the previous LeafTransaction as its parent.\r\nParameter name: leafTransaction"));
Assert.That(_hierarchy.RootTransaction, Is.SameAs(_rootTransaction));
Assert.That(_hierarchy.LeafTransaction, Is.SameAs(_rootTransaction));
Assert.That(_hierarchy.ActiveTransaction, Is.SameAs(_rootTransaction));
}
public void Leave_ExecutesAttachedScope_AfterAutoDiscardBehavior()
{
var scopedTransaction = ClientTransactionObjectMother.Create();
var attachedScopeMock = MockRepository.GenerateStrictMock <IDisposable> ();
attachedScopeMock.Expect(mock => mock.Dispose()).WhenCalled(mock => Assert.That(scopedTransaction.IsDiscarded, Is.True));
var scope = (ClientTransactionScope)PrivateInvoke.CreateInstanceNonPublicCtor(
typeof(ClientTransactionScope), scopedTransaction, AutoRollbackBehavior.Discard, attachedScopeMock);
scope.Leave();
attachedScopeMock.VerifyAllExpectations();
}
public void RaiseSubTransactionCreatedEvent()
{
var subTransaction = ClientTransactionObjectMother.Create();
CheckEventWithListenersLast(
s => s.RaiseSubTransactionCreatedEvent(subTransaction),
l => l.SubTransactionCreated(_clientTransaction, subTransaction),
x => x.SubTransactionCreated(_clientTransaction, subTransaction),
() =>
_transactionEventReceiverMock
.Expect(
mock => mock.SubTransactionCreated(
Arg.Is(_clientTransaction),
Arg <SubTransactionCreatedEventArgs> .Matches(args => args.SubTransaction == subTransaction)))
.WithCurrentTransaction(_clientTransaction));
}
public void Serializable()
{
var instance = new TransactionHierarchyManager(
ClientTransactionObjectMother.Create(),
new SerializableClientTransactionEventSinkFake(),
ClientTransactionObjectMother.Create(),
new SerializableTransactionHierarchyManagerFake(),
new SerializableClientTransactionEventSinkFake());
var deserializedInstance = Serializer.SerializeAndDeserialize(instance);
Assert.That(deserializedInstance.IsWriteable, Is.True);
Assert.That(deserializedInstance.SubTransaction, Is.Null);
Assert.That(deserializedInstance.ThisTransaction, Is.Not.Null);
Assert.That(deserializedInstance.ParentTransaction, Is.Not.Null);
Assert.That(deserializedInstance.ParentHierarchyManager, Is.Not.Null);
}
public void ExecuteCollectionQuery()
{
IQuery query = _cache.GetQuery <Order> ("id", orders => from o in orders where o.OrderNumber > 1 select o);
var queryManagerMock = MockRepository.GenerateMock <IQueryManager> ();
var clientTransactionStub = ClientTransactionObjectMother.CreateWithComponents <ClientTransaction> (queryManager: queryManagerMock);
var expectedResult = new QueryResult <Order> (query, new Order[0]);
queryManagerMock.Expect(mock => mock.GetCollection <Order> (query)).Return(expectedResult);
queryManagerMock.Replay();
var result = _cache.ExecuteCollectionQuery <Order> (clientTransactionStub, "id", orders => from o in orders where o.OrderNumber > 1 select o);
queryManagerMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(expectedResult));
}
public override void SetUp()
{
base.SetUp();
_thisTransaction = ClientTransactionObjectMother.Create();
_thisEventSinkWithStrictMock = MockRepository.GenerateStrictMock <IClientTransactionEventSink>();
_hierarchyStrictMock = MockRepository.GenerateStrictMock <IClientTransactionHierarchy>();
_parentTransaction = ClientTransactionObjectMother.Create();
_parentHierarchyManagerStrictMock = MockRepository.GenerateStrictMock <ITransactionHierarchyManager>();
_parentHierarchyManagerStrictMock.Stub(stub => stub.TransactionHierarchy).Return(_hierarchyStrictMock);
_parentEventSinkWithStrictMock = MockRepository.GenerateStrictMock <IClientTransactionEventSink>();
_manager = new TransactionHierarchyManager(
_thisTransaction, _thisEventSinkWithStrictMock, _parentTransaction, _parentHierarchyManagerStrictMock, _parentEventSinkWithStrictMock);
_managerWithoutParent = new TransactionHierarchyManager(_thisTransaction, _thisEventSinkWithStrictMock);
}
public void CreateSubTransaction_InvalidFactory()
{
_thisEventSinkWithStrictMock.Expect(mock => mock.RaiseSubTransactionCreatingEvent());
var fakeSubTransaction = ClientTransactionObjectMother.CreateWithParent(null);
Func <ClientTransaction, ClientTransaction> factory = tx => fakeSubTransaction;
Assert.That(
() => _manager.CreateSubTransaction(factory),
Throws.InvalidOperationException.With.Message.EqualTo("The given factory did not create a sub-transaction for this transaction."));
_thisEventSinkWithStrictMock.AssertWasNotCalled(mock => mock.RaiseSubTransactionCreatedEvent(Arg <ClientTransaction> .Is.Anything));
_thisEventSinkWithStrictMock.VerifyAllExpectations();
Assert.That(_manager.SubTransaction, Is.Null);
Assert.That(_manager.IsWriteable, Is.True);
}
public void EagerFetching_OnlyExecutesQueryOnce()
{
var outerQuery = QueryFactory.CreateCollectionQuery(
"test",
TestDomainStorageProviderDefinition,
"outerQuery",
new QueryParameterCollection(),
typeof(DomainObjectCollection));
var relationEndPointDefinition = GetEndPointDefinition(typeof(Customer), "Orders");
var fetchQuery = QueryFactory.CreateCollectionQuery(
"test fetch",
TestDomainStorageProviderDefinition,
"fetchQuery",
new QueryParameterCollection(),
typeof(DomainObjectCollection));
outerQuery.EagerFetchQueries.Add(relationEndPointDefinition, fetchQuery);
var persistenceStrategyMock = MockRepository.GenerateStrictMock <IFetchEnabledPersistenceStrategy>();
var customerDataContainer = TestDataContainerObjectMother.CreateCustomer1DataContainer();
var orderDataContainer = TestDataContainerObjectMother.CreateOrder1DataContainer();
persistenceStrategyMock
.Expect(mock => mock.ExecuteCollectionQuery(Arg.Is(outerQuery), Arg <ILoadedObjectDataProvider> .Is.Anything))
.Return(new[] { new FreshlyLoadedObjectData(customerDataContainer) });
persistenceStrategyMock
.Expect(mock => mock.ExecuteFetchQuery(Arg.Is(fetchQuery), Arg <ILoadedObjectDataProvider> .Is.Anything))
.Return(new[] { new LoadedObjectDataWithDataSourceData(new FreshlyLoadedObjectData(orderDataContainer), orderDataContainer) })
.Repeat.Once();
persistenceStrategyMock.Replay();
var clientTransaction = ClientTransactionObjectMother.CreateTransactionWithPersistenceStrategy <ClientTransaction> (persistenceStrategyMock);
using (clientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
var result = ClientTransaction.Current.QueryManager.GetCollection <Customer> (outerQuery).ToArray();
Assert.That(result, Is.EquivalentTo(new[] { DomainObjectIDs.Customer1.GetObject <Customer>() }));
Assert.That(result[0].Orders, Is.EquivalentTo(new[] { DomainObjectIDs.Order1.GetObject <Order>() }));
}
persistenceStrategyMock.VerifyAllExpectations();
}
public override void SetUp()
{
base.SetUp();
_queryGeneratorMock = MockRepository.GenerateStrictMock <IDomainObjectQueryGenerator>();
_queryExecutor = new DomainObjectQueryExecutor(TestDomainStorageProviderDefinition, _queryGeneratorMock);
_queryManagerMock = MockRepository.GenerateStrictMock <IQueryManager> ();
var transaction = ClientTransactionObjectMother.CreateTransactionWithQueryManager <ClientTransaction> (_queryManagerMock);
_transactionScope = transaction.EnterDiscardingScope();
_someQueryModel = QueryModelObjectMother.Create();
MockRepository.GenerateStub <IQuery>();
_someOrder = DomainObjectMother.CreateFakeObject <Order>();
_scalarExecutableQueryMock = MockRepository.GenerateStrictMock <IExecutableQuery <int> >();
_collectionExecutableQueryMock = MockRepository.GenerateStrictMock <IExecutableQuery <IEnumerable <Order> > > ();
}
public void Leave_ExecutesAutoDiscardBehavior()
{
var transactionMock = ClientTransactionObjectMother.CreateStrictMock();
transactionMock
.Expect(mock => mock.EnterScope(AutoRollbackBehavior.Discard))
.Return(
(ClientTransactionScope)
PrivateInvoke.CreateInstanceNonPublicCtor(typeof(ClientTransactionScope), transactionMock, AutoRollbackBehavior.Discard, null));
transactionMock.Expect(mock => mock.Discard());
transactionMock.Replay();
using (transactionMock.EnterScope(AutoRollbackBehavior.Discard))
{
}
transactionMock.VerifyAllExpectations();
}
