public void FlushAndPauseShouldNotCloseTheSession()
{
NhConversation c = NewStartedConversation();
c.FlushAndPause();
AssertIsPaused(c.GetSession(sessions));
}
public void NeedsSessionFactoryAndContext()
{
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateStub<INhConversationContext>();
var c = new NhConversation(sf, cc);
Assert.That(c != null);
}
public void DefaultCommitModeIsAutomatic()
{
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateStub<INhConversationContext>();
var c = new NhConversation(sf, cc);
var cm = c.CommitMode;
Assert.That(cm, Is.EqualTo(ConversationCommitMode.Automatic));
}
public void CanSetDifferentCommitMode()
{
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateStub<INhConversationContext>();
var cm = ConversationCommitMode.Explicit;
var c = new NhConversation(sf, cc) { CommitMode = cm };
Assert.That(c.CommitMode, Is.EqualTo(cm));
}
public void StartedUnitOfWorkShouldNotFlushToDatabaseUntilEndOfConversation()
{
NhConversation c = NewStartedConversation();
ISession s = c.GetSession(sessions);
Assert.That(s.FlushMode, Is.EqualTo(FlushMode.Never));
}
public void StartShouldStartUnitOfWork()
{
NhConversation c = NewConversation();
c.Start();
ISession s = c.GetSession(sessions);
AssertIsOpen(s);
}
public void PauseShouldDisconnectButNotCloseUnitOfWork()
{
NhConversation c = NewStartedConversation();
c.Pause();
ISession s = c.GetSession(sessions);
AssertIsPaused(s);
}
private NhConversation NewPausedConversation()
{
NhConversation c = NewConversation();
c.Start();
c.Pause();
AssertIsPaused(c.GetSession(sessions));
return(c);
}
public void ResumeShouldReconnectUnitOfWork()
{
NhConversation c = NewPausedConversation();
c.Resume();
ISession s = c.GetSession(sessions);
AssertIsOpen(s);
Assert.That(s.IsConnected);
}
public void ResumeAfterStartShouldNotStatAnotherUnitOfWork()
{
NhConversation c = NewStartedConversation();
ISession startedUoW = c.GetSession(sessions);
c.Resume();
ISession currentUoW = c.GetSession(sessions);
Assert.That(currentUoW, Is.SameAs(startedUoW));
}
public void PauseShouldNotFlushUnitOfWork()
{
NhConversation c = NewStartedConversation();
var persistedObj = new Silly3();
c.GetSession(sessions).Save(persistedObj);
c.Pause();
AssertDoesNotExistInDb(persistedObj);
}
public void Destructor()
{
NhConversation c = NewStartedConversation();
ISession s = c.GetSession(sessions);
c.Dispose();
Assert.That(s, Is.Not.Null);
Assert.That(s.IsOpen, Is.False);
Assert.Throws <ConversationException>(() => s = c.GetSession(sessions));
}
private NhConversation NewStartedConversation()
{
NhConversation c = NewConversation();
c.Start();
ISession s = c.GetSession(sessions);
Assert.That(s.IsOpen, Is.True, "UoW expected to be started");
return(c);
}
public void EndShouldCloseStartedUnitOfWork()
{
NhConversation c = NewStartedConversation();
c.End();
ISession s = c.GetSession(sessions);
Assert.That(s, Is.Not.Null);
Assert.That(s.IsOpen, Is.False);
}
public IConversation CreateConversation(string conversationId)
{
var result = new NhConversation(factoriesProvider, wrapper, conversationId);
if (conversationId.StartsWith("Notify"))
{
result.Ended += EventSource.Conversation_Ended;
}
return(result);
}
public void StartCalledTwiceWithoutEndShouldNotStartAnotherUnitOfWork()
{
NhConversation c = NewConversation();
c.Start();
ISession s = c.GetSession(sessions);
c.Start();
Assert.That(c.GetSession(sessions), Is.SameAs(s), "ReStart of the same conversation should not change the session.");
Assert.That(s.IsOpen);
}
public void EndShouldFlushStartedUnitOfWork()
{
NhConversation c = NewStartedConversation();
ISession s = c.GetSession(sessions);
var persistedObj = new Silly3();
s.Save(persistedObj);
c.End();
AssertExistsInDb(persistedObj);
}
public void EndShouldNotFlushPausedUnitOfWork()
{
NhConversation c = NewPausedConversation();
ISession s = c.GetSession(sessions);
var persistedObj = new Silly3();
s.Save(persistedObj);
c.End();
AssertDoesNotExistInDb(persistedObj);
}
public void ManualUnbindSessionDoNotCreateProblemsInARunningConversation()
{
NhConversation c = NewStartedConversation();
ISession s = c.GetSession(sessions);
c.Unbind(s);
Assert.That(c.GetSession(sessions), Is.Null, "A session still bind after manual Unbind.");
c.Resume();
Assert.That(c.GetSession(sessions).IsOpen);
c.End();
}
public void StartAfterEndShouldStartAnotherUnitOfWork()
{
NhConversation c = NewStartedConversation();
ISession previousUoW = c.GetSession(sessions);
c.End();
c.Start();
ISession currentUoW = c.GetSession(sessions);
AssertIsOpen(currentUoW);
Assert.That(currentUoW, Is.Not.SameAs(previousUoW));
}
public void ManualBindSessionToConversationShouldUnbindOrphanedSession()
{
// TODO: recreate this test in ConversationFixtureBase to check the wrapper
NhConversation c = NewStartedConversation();
ISession s = sessions.OpenSession();
Assert.That(Spying.Logger <NhConversation>().Execute(() => c.Bind(s)).WholeMessage,
Text.Contains("Already session bound on call to Bind()"));
ISession sessionFromConversation = c.GetSession(sessions);
Assert.That(c.Wrapper.IsWrapped(sessionFromConversation), "The new bind session should be wrapped and managed by the Wrapper.");
Assert.That(sessionFromConversation.FlushMode, Is.EqualTo(FlushMode.Never), "The FlushMode of new bind session should be changed to Never.");
}
public void SessionCloseOutsideTheConversation()
{
NhConversation c = NewStartedConversation();
ISession session = c.GetSession(sessions);
session.Close();
Assert.That(c.GetSession(sessions), Is.SameAs(session));
Assert.DoesNotThrow(c.Pause);
Assert.That(Spying.Logger <NhConversation>().Execute(c.Resume).WholeMessage,
Text.DoesNotContain("Already session bound on call to Bind()"),
"No warning is needed for a closed session.");
Assert.That(c.GetSession(sessions), Is.Not.SameAs(session));
c.Dispose();
}
public void CannotSetCommitModeAfterSessionStarted()
{
var t = MockRepository.GenerateStub<ITransaction>();
var s = MockRepository.GenerateStub<ISession>();
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateStub<INhConversationContext>();
sf.Stub(x => x.OpenSession()).Return(s);
s.Stub(x => x.BeginTransaction()).IgnoreArguments().Return(t);
var cm = ConversationCommitMode.Explicit;
var c = new NhConversation(sf, cc);
c.Execute(x => { }); // Call doesn't matter, it's a stub
var e = Assert.Throws<NotSupportedException>(() => c.CommitMode = cm);
Assert.That(e.Message, Contains.Substring("CommitMode"));
Assert.That(e.Message, Contains.Substring("started"));
}
public void CancelingRaisesEvent()
{
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateStub<INhConversationContext>();
var c = new NhConversation(sf, cc);
ConversationCanceledEventArgs eventRaised = null;
object eventRaiser = null;
c.Canceled += (o, a) =>
{
eventRaiser = o;
eventRaised = a;
};
c.Cancel();
Assert.That(eventRaised, Is.Not.Null);
Assert.That(eventRaised.CanceledByUser);
Assert.That(eventRaised.Exception, Is.Null);
Assert.That(eventRaiser, Is.SameAs(c));
}
public void SessionDisposeOutsideTheConversation()
{
NhConversation c = NewStartedConversation();
using (c.GetSession(sessions))
{
// Do nothing only simulate a possible usage
// of sessions.GetCurrentSession() outside conversation management
}
// Need some new events in NH about session.Close (Event/Listener)
// Assert.That(c.GetSession(sessions), Is.Null, "should auto unbind the session.");
Assert.DoesNotThrow(c.Pause);
Assert.That(Spying.Logger <NhConversation>().Execute(c.Resume).WholeMessage,
Text.DoesNotContain("Already session bound on call to Bind()"),
"No warning is needed for a closed session.");
Assert.That(c.GetSession(sessions), Is.Not.Null);
c.Dispose();
}
public void ConversationUsage()
{
CommitInNewSession(session =>
{
var o = new Other3 {
Name = "some other silly"
};
var e = new Silly3 {
Name = "somebody", Other = o
};
session.Save(e);
});
using (NhConversation c = NewConversation())
{
c.Start();
ISession s = c.GetSession(sessions);
IList <Silly3> sl = s.CreateQuery("from Silly3").List <Silly3>();
c.Pause();
Assert.That(sl.Count == 1);
Assert.That(!NHibernateUtil.IsInitialized(sl[0].Other));
// working with entities, even using lazy loading
Assert.That(!s.Transaction.IsActive);
Assert.That("some other silly", Is.EqualTo(sl[0].Other.Name));
Assert.That(NHibernateUtil.IsInitialized(sl[0].Other));
sl[0].Other.Name = "nobody";
c.Resume();
s = c.GetSession(sessions);
s.SaveOrUpdate(sl[0]);
// the dispose auto-end the conversation
}
using (NhConversation c = NewConversation())
{
c.Start();
ISession s = c.GetSession(sessions);
s.Delete("from Silly3");
c.End();
}
}
public void ResumeWithoutStartShouldNotThrow()
{
NhConversation c = NewConversation();
Assert.DoesNotThrow(c.Resume);
}
public void ScopesAreNotLeaking()
{
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = new NhConversationContext();
var c = new NhConversation(sf, cc);
WeakReference weakRef = CreateScope(c);
GC.Collect();
GC.WaitForPendingFinalizers();
Assert.That(weakRef.Target, Is.Null);
}
public void ScopesAreInvalidatedOnConversationDisposal()
{
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateStub<INhConversationContext>();
var c = new NhConversation(sf, cc);
INhScope s = (INhScope)c.Scope();
Assert.That(s.IsValid);
c.Dispose();
Assert.That(s.IsValid, Is.False);
s.Dispose(); // Must not throw
}
public void ExceptionsInExecuteSilentlyCancelTheConversationWithoutThrowing()
{
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateStub<INhConversationContext>();
var c = new NhConversation(sf, cc);
var e = new Exception("foo");
ConversationCanceledEventArgs eventRaised = null;
object eventRaiser = null;
c.Canceled += (o, a) =>
{
eventRaiser = o;
eventRaised = a;
};
c.ExecuteSilently(() => { throw e; }); // Doesn't throw.
Assert.That(eventRaised, Is.Not.Null);
Assert.That(eventRaised.CanceledByUser, Is.False);
Assert.That(eventRaised.Exception, Is.SameAs(e));
Assert.That(eventRaiser, Is.SameAs(c));
}
public void ExceptionsInExecuteCancelTheConversation()
{
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateStub<INhConversationContext>();
var c = new NhConversation(sf, cc);
ConversationCanceledEventArgs eventRaised = null;
object eventRaiser = null;
c.Canceled += (o, a) =>
{
eventRaiser = o;
eventRaised = a;
};
var e = Assert.Throws<Exception>(() => c.Execute(() => { throw new Exception("foo"); }));
Assert.That(e.Message, Is.EqualTo("foo"));
Assert.That(eventRaised, Is.Not.Null);
Assert.That(eventRaised.CanceledByUser, Is.False);
Assert.That(eventRaised.Exception, Is.SameAs(e));
Assert.That(eventRaiser, Is.SameAs(c));
}
public void CancelStateCanBeQueried()
{
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateStub<INhConversationContext>();
var c = new NhConversation(sf, cc);
c.Cancel();
Assert.That(c.IsCanceled);
}
public void CanUseExecuteToSwitchConversation()
{
NhConversationContext context = new NhConversationContext();
var sf = MockRepository.GenerateStub<ISessionFactory>();
var conv1 = new NhConversation(sf, context);
var conv2 = new NhConversation(sf, context);
Assert.That(context.CurrentConversation, Is.Null);
conv1.Execute(() => Assert.That(context.CurrentConversation, Is.SameAs(conv1)));
conv2.Execute(() => Assert.That(context.CurrentConversation, Is.SameAs(conv2)));
Assert.That(context.CurrentConversation, Is.Null);
}
public void CanSwitchBetweenConversations()
{
NhConversationContext context = new NhConversationContext();
var sf = MockRepository.GenerateStub<ISessionFactory>();
var conv1 = new NhConversation(sf, context);
var conv2 = new NhConversation(sf, context);
Assert.That(context.CurrentConversation, Is.Null);
using (conv1.Scope())
{
Assert.That(context.CurrentConversation, Is.SameAs(conv1));
using (conv2.Scope())
{
Assert.That(context.CurrentConversation, Is.SameAs(conv2));
}
Assert.That(context.CurrentConversation, Is.SameAs(conv1));
}
Assert.That(context.CurrentConversation, Is.Null);
}
public void ExceptionsCancelTheConversation()
{
var t = MockRepository.GenerateStub<ITransaction>();
var s = MockRepository.GenerateStub<ISession>();
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateStub<INhConversationContext>();
sf.Stub(x => x.OpenSession()).Return(s);
s.Stub(x => x.BeginTransaction()).IgnoreArguments().Return(t);
var c = new NhConversation(sf, cc);
ConversationCanceledEventArgs eventRaised = null;
object eventRaiser = null;
c.Canceled += (o, a) =>
{
eventRaiser = o;
eventRaised = a;
};
var e = Assert.Throws<Exception>(() => c.Execute(x => { throw new Exception("foo"); }));
Assert.That(e.Message, Is.EqualTo("foo"));
Assert.That(eventRaised, Is.Not.Null);
Assert.That(eventRaised.CanceledByUser, Is.False);
Assert.That(eventRaised.Exception, Is.SameAs(e));
Assert.That(eventRaiser, Is.SameAs(c));
}
public void EndWithoutStartShouldNotThrow()
{
NhConversation c = NewConversation();
Assert.DoesNotThrow(c.End);
}
public void CantCommitAfterCanceling()
{
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateStub<INhConversationContext>();
var c = new NhConversation(sf, cc);
c.Cancel();
Assert.Throws<InvalidOperationException>(() => c.Commit());
}
public void GetSessionsShouldThrowWhenConversationNotYetStarted()
{
NhConversation c = NewConversation();
Assert.Throws <ConversationException>(() => c.GetSession(sessions));
}
public void CannotCallExecuteWhenConversationIsCanceled()
{
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateStub<INhConversationContext>();
var c = new NhConversation(sf, cc);
c.Cancel();
var e = Assert.Throws<InvalidOperationException>(() => c.Execute(() => { ; })); // Call doesn't matter, it's a stub
Assert.That(e.Message, Contains.Substring("canceled"));
}
public void ScopeIsRegistered()
{
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateMock<INhConversationContext>();
cc.Expect(m => m.RegisterScope(null)).IgnoreArguments();
var c = new NhConversation(sf, cc);
using (c.Scope()) { }
cc.VerifyAllExpectations();
}
public void RestartingTheConversationResetsCancelState()
{
var t = MockRepository.GenerateStub<ITransaction>();
var s = MockRepository.GenerateStub<ISession>();
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateStub<INhConversationContext>();
sf.Stub(x => x.OpenSession()).Return(s);
s.Stub(x => x.BeginTransaction()).IgnoreArguments().Return(t);
var c = new NhConversation(sf, cc);
c.Cancel();
c.Restart();
bool called = false;
c.Execute(x => called = true); // Call doesn't matter, it's a stub
Assert.That(called);
}
public void CanCreateScope()
{
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateStub<INhConversationContext>();
var c = new NhConversation(sf, cc);
using (c.Scope()) { }
}
public void ScopeIsDeregistered()
{
INhScope registeredScope = null;
var sf = MockRepository.GenerateStub<ISessionFactory>();
var cc = MockRepository.GenerateMock<INhConversationContext>();
cc.Expect(m => m.RegisterScope(null)).IgnoreArguments().WhenCalled(i => registeredScope = (INhScope)i.Arguments[0]);
var c = new NhConversation(sf, cc);
using (c.Scope())
{
cc.Expect(m => m.ReleaseScope(registeredScope));
}
cc.VerifyAllExpectations();
}
