public void ResolvesEntityInterceptorOnEachOpen()
{
TestSessionScopeSettings sss = Fake <TestSessionScopeSettings>(options => options
.CallsBaseMethods()
.WithArgumentsForConstructor(new[] { expectedSessionFactory })
);
ISession expectedSession = Fake <ISession>();
sss.DefaultFlushMode = FlushMode.Never;
SessionScope sc = new SessionScope(sss, false);
CallTo(() => sss.DoResolveEntityInterceptor()).Returns(expectedEntityInterceptor);
CallTo(() => expectedSessionFactory.OpenSession(expectedEntityInterceptor)).Returns(expectedSession);
sc.Open();
SessionHolder sessionHolder = (SessionHolder)TransactionSynchronizationManager.GetResource(expectedSessionFactory);
sessionHolder.ContainsSession(null); // force opening session
sc.Close();
sc.Open();
sessionHolder = (SessionHolder)TransactionSynchronizationManager.GetResource(expectedSessionFactory);
sessionHolder.ContainsSession(null); // force opening session
sc.Close();
CallToSet(() => expectedSession.FlushMode).WhenArgumentsMatch(x => x.Get <FlushMode>(0) == FlushMode.Never).MustHaveHappenedTwiceExactly();
CallTo(() => expectedSession.Close()).MustHaveHappenedTwiceExactly();
}
public void ClosingTwiceIsIgnored()
{
using (SessionScope scope = new SessionScope(expectedSessionFactory, true))
{
scope.Close();
scope.Close();
}
}
public void DoesOpenImmediatelyOnOpenIsTrue()
{
SessionScope scope = null;
using (scope = new SessionScope(expectedSessionFactory, true))
{
// ensure is open
Assert.IsTrue(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
scope.Close();
// ensure is closed
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
}
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
using (scope = new SessionScope(expectedSessionFactory, true))
{
// ensure is open
Assert.IsTrue(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
}
// ensure dispose closes scope
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
}
public void SingleSessionNestedSessionParticipatesInParentScopeSessionFactory()
{
SessionScope scope = null;
using (scope = new SessionScope(expectedSessionFactory, null, true, FlushMode.Auto, true))
{
Assert.IsTrue(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
using (SessionScope innerScope = new SessionScope(expectedSessionFactory, true))
{
// outer scope didn't change
Assert.IsTrue(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
// participating only - no SessionHolder will be registered!
Assert.IsTrue(innerScope.IsOpen);
Assert.IsTrue(innerScope.IsParticipating);
innerScope.Close();
Assert.IsFalse(innerScope.IsOpen);
Assert.IsFalse(innerScope.IsParticipating);
// outer scope didn't change
Assert.IsTrue(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
Assert.IsTrue(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
}
}
// ensure scope is closed and sessionHolder is unregistered from TSM
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
}
public void CanCreateAndCloseSimpleCtor()
{
using (mocks.Ordered())
{
ISession session = mocks.StrictMock <ISession>();
Expect.Call(expectedSessionFactory.OpenSession()).Return(session);
session.FlushMode = FlushMode.Never;
Expect.Call(session.Close()).Return(null);
}
mocks.ReplayAll();
using (SessionScope scope = new SessionScope(expectedSessionFactory, true))
{
// no op - just create & dispose
Assert.AreSame(expectedSessionFactory, scope.SessionFactory);
//Assert.AreSame(null, scope.EntityInterceptor);
Assert.AreEqual(expectedSingleSession, scope.SingleSession);
Assert.AreEqual(expectedDefaultFlushMode, scope.DefaultFlushMode);
// ensure SessionHolder object is registered with TSM
Assert.IsTrue(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
SessionHolder sessionHolder =
(SessionHolder)TransactionSynchronizationManager.GetResource(expectedSessionFactory);
// by default session is lazy, so ask for it.
Assert.IsNotNull(sessionHolder.Session);
scope.Close();
}
mocks.VerifyAll();
}
public void CanCreateAndCloseSimpleCtor()
{
ISession session = Fake <ISession>();
CallTo(() => expectedSessionFactory.OpenSession()).Returns(session);
using (SessionScope scope = new SessionScope(expectedSessionFactory, true))
{
// no op - just create & dispose
Assert.AreSame(expectedSessionFactory, scope.SessionFactory);
//Assert.AreSame(null, scope.EntityInterceptor);
Assert.AreEqual(expectedSingleSession, scope.SingleSession);
Assert.AreEqual(expectedDefaultFlushMode, scope.DefaultFlushMode);
// ensure SessionHolder object is registered with TSM
Assert.IsTrue(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
SessionHolder sessionHolder =
(SessionHolder)TransactionSynchronizationManager.GetResource(expectedSessionFactory);
// by default session is lazy, so ask for it.
Assert.IsNotNull(sessionHolder.Session);
scope.Close();
}
CallToSet(() => session.FlushMode).WhenArgumentsMatch(x => x.Get <FlushMode>(0) == FlushMode.Never).MustHaveHappenedOnceExactly();
CallTo(() => session.Close()).MustHaveHappenedOnceExactly();
}
public void ResolvesEntityInterceptorOnEachOpen()
{
TestSessionScopeSettings sss =
(TestSessionScopeSettings)mocks.PartialMock(typeof(TestSessionScopeSettings), expectedSessionFactory);
ISession expectedSession = mocks.StrictMock <ISession>();
sss.DefaultFlushMode = FlushMode.Never;
SessionScope sc = new SessionScope(sss, false);
using (mocks.Ordered())
{
Expect.Call(sss.DoResolveEntityInterceptor()).Return(expectedEntityInterceptor);
Expect.Call(expectedSessionFactory.OpenSession(expectedEntityInterceptor)).Return(expectedSession);
expectedSession.FlushMode = FlushMode.Never;
Expect.Call(expectedSession.Close()).Return(null);
Expect.Call(sss.DoResolveEntityInterceptor()).Return(expectedEntityInterceptor);
Expect.Call(expectedSessionFactory.OpenSession(expectedEntityInterceptor)).Return(expectedSession);
expectedSession.FlushMode = FlushMode.Never;
Expect.Call(expectedSession.Close()).Return(null);
}
mocks.ReplayAll();
sc.Open();
SessionHolder sessionHolder = (SessionHolder)TransactionSynchronizationManager.GetResource(expectedSessionFactory);
sessionHolder.ContainsSession(null); // force opening session
sc.Close();
sc.Open();
sessionHolder = (SessionHolder)TransactionSynchronizationManager.GetResource(expectedSessionFactory);
sessionHolder.ContainsSession(null); // force opening session
sc.Close();
mocks.VerifyAll();
}
public void CanCreateAndClose()
{
using (SessionScope scope = new SessionScope(expectedSessionFactory, expectedEntityInterceptor, expectedSingleSession, expectedDefaultFlushMode, false))
{
// no op - just create & dispose
Assert.AreSame(expectedSessionFactory, scope.SessionFactory);
Assert.AreSame(expectedEntityInterceptor, scope.EntityInterceptor);
Assert.AreEqual(expectedSingleSession, scope.SingleSession);
Assert.AreEqual(expectedDefaultFlushMode, scope.DefaultFlushMode);
// ensure nothing got registered with TSM
Assert.IsFalse(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
scope.Close();
}
}
public void CanCreateAndClose()
{
using (SessionScope scope = new SessionScope(expectedSessionFactory, expectedEntityInterceptor, expectedSingleSession, expectedDefaultFlushMode, false))
{
// no op - just create & dispose
Assert.AreSame(expectedSessionFactory, scope.SessionFactory);
Assert.AreSame(expectedEntityInterceptor, scope.EntityInterceptor);
Assert.AreEqual(expectedSingleSession, scope.SingleSession);
Assert.AreEqual(expectedDefaultFlushMode, scope.DefaultFlushMode);
// ensure nothing got registered with TSM
Assert.IsFalse(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
scope.Close();
}
}
public void DoesNotOpenImmediatelyOnOpenIsFalse()
{
SessionScope scope = null;
using (scope = new SessionScope(expectedSessionFactory, false))
{
// ensure is *not* open
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
scope.Open();
// ensure is open now
Assert.IsTrue(scope.IsOpen);
scope.Close();
// ensure is closed
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
}
// ensure is closed
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
}
public void MultipleDBAccessUsingMultipleSessionScopes()
{
SessionScope scope1 = new SessionScope( (ISessionFactory) ctx["SessionFactory1"], false );
SessionScope scope2 = new SessionScope( (ISessionFactory) ctx["SessionFactory2"], false );
scope1.Open();
scope2.Open();
// do something
MultipleDBAccess();
scope1.Close();
scope2.Close();
}
public void DoesOpenImmediatelyOnOpenIsTrue()
{
SessionScope scope = null;
using (scope = new SessionScope(expectedSessionFactory, true))
{
// ensure is open
Assert.IsTrue(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
scope.Close();
// ensure is closed
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
}
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
using (scope = new SessionScope(expectedSessionFactory, true))
{
// ensure is open
Assert.IsTrue(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
}
// ensure dispose closes scope
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
}
public void DoesNotOpenImmediatelyOnOpenIsFalse()
{
SessionScope scope = null;
using (scope = new SessionScope(expectedSessionFactory, false))
{
// ensure is *not* open
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
scope.Open();
// ensure is open now
Assert.IsTrue(scope.IsOpen);
scope.Close();
// ensure is closed
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
}
// ensure is closed
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
}
public void SingleSessionNestedSessionParticipatesInParentScopeSessionFactory()
{
SessionScope scope = null;
using (scope = new SessionScope(expectedSessionFactory, null, true, FlushMode.Auto, true))
{
Assert.IsTrue(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
using (SessionScope innerScope = new SessionScope(expectedSessionFactory, true))
{
// outer scope didn't change
Assert.IsTrue(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
// participating only - no SessionHolder will be registered!
Assert.IsTrue(innerScope.IsOpen);
Assert.IsTrue(innerScope.IsParticipating);
innerScope.Close();
Assert.IsFalse(innerScope.IsOpen);
Assert.IsFalse(innerScope.IsParticipating);
// outer scope didn't change
Assert.IsTrue(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
Assert.IsTrue(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
}
}
// ensure scope is closed and sessionHolder is unregistered from TSM
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
}
public void ResolvesEntityInterceptorOnEachOpen()
{
TestSessionScopeSettings sss =
(TestSessionScopeSettings)mocks.PartialMock(typeof(TestSessionScopeSettings), expectedSessionFactory);
ISession expectedSession = mocks.StrictMock<ISession>();
sss.DefaultFlushMode = FlushMode.Never;
SessionScope sc = new SessionScope(sss, false);
using (mocks.Ordered())
{
Expect.Call(sss.DoResolveEntityInterceptor()).Return(expectedEntityInterceptor);
Expect.Call(expectedSessionFactory.OpenSession(expectedEntityInterceptor)).Return(expectedSession);
expectedSession.FlushMode = FlushMode.Never;
Expect.Call(expectedSession.Close()).Return(null);
Expect.Call(sss.DoResolveEntityInterceptor()).Return(expectedEntityInterceptor);
Expect.Call(expectedSessionFactory.OpenSession(expectedEntityInterceptor)).Return(expectedSession);
expectedSession.FlushMode = FlushMode.Never;
Expect.Call(expectedSession.Close()).Return(null);
}
mocks.ReplayAll();
sc.Open();
SessionHolder sessionHolder = (SessionHolder)TransactionSynchronizationManager.GetResource(expectedSessionFactory);
sessionHolder.ContainsSession(null); // force opening session
sc.Close();
sc.Open();
sessionHolder = (SessionHolder)TransactionSynchronizationManager.GetResource(expectedSessionFactory);
sessionHolder.ContainsSession(null); // force opening session
sc.Close();
mocks.VerifyAll();
}
public void ClosingTwiceIsIgnored()
{
using (SessionScope scope = new SessionScope(expectedSessionFactory, true))
{
scope.Close();
scope.Close();
}
}
public void CanCreateAndCloseSimpleCtor()
{
using (mocks.Ordered())
{
ISession session = mocks.StrictMock<ISession>();
Expect.Call(expectedSessionFactory.OpenSession()).Return(session);
session.FlushMode = FlushMode.Never;
Expect.Call(session.Close()).Return(null);
}
mocks.ReplayAll();
using (SessionScope scope = new SessionScope(expectedSessionFactory, true))
{
// no op - just create & dispose
Assert.AreSame(expectedSessionFactory, scope.SessionFactory);
//Assert.AreSame(null, scope.EntityInterceptor);
Assert.AreEqual(expectedSingleSession, scope.SingleSession);
Assert.AreEqual(expectedDefaultFlushMode, scope.DefaultFlushMode);
// ensure SessionHolder object is registered with TSM
Assert.IsTrue(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
SessionHolder sessionHolder =
(SessionHolder) TransactionSynchronizationManager.GetResource(expectedSessionFactory);
// by default session is lazy, so ask for it.
Assert.IsNotNull(sessionHolder.Session);
scope.Close();
}
mocks.VerifyAll();
}
