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 OpeningTwiceThrowsInvalidOperationException()
{
using (SessionScope scope = new SessionScope(expectedSessionFactory, true))
{
scope.Open();
}
}
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 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 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 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);
}
/// <summary>
/// Initialize a new instance.
/// </summary>
public LazySessionHolder(SessionScope owner)
{
if (log.IsDebugEnabled)
{
log.Debug("Created LazySessionHolder");
}
this.owner = owner;
}
public void ClosingTwiceIsIgnored()
{
using (SessionScope scope = new SessionScope(expectedSessionFactory, true))
{
scope.Close();
scope.Close();
}
}
public void DisposeClosesScope()
{
SessionScope scope = new SessionScope(expectedSessionFactory, true);
Assert.IsTrue(scope.IsOpen);
scope.Dispose();
Assert.IsFalse(scope.IsOpen);
}
public virtual void Init()
{
Log = LogManager.GetCurrentClassLogger();
Log.Debug("初始化必须的对象 ----->");
HibernatingRhinos.Profiler.Appender.NHibernate.NHibernateProfiler.Initialize();
//HibernatingRhinos.NHibernate.Profiler.Appender.NHibernateProfiler.Initialize();
var config = new AspMvcConfig();
//MvcConfig.RootContext.
Scope = new SessionScope("MySessionFactory".GetInstance<ISessionFactory>(), true);
Log.Debug("测试开始 ----->");
}
/// <summary>
/// Ensure session is closed (if any) and remove circular references to avoid memory leaks!
/// </summary>
public void Close()
{
owner = null;
if (session != null)
{
ISession tmpSession = session;
session = null;
SessionFactoryUtils.CloseSession(tmpSession);
}
if (log.IsDebugEnabled)
{
log.Debug("Closed LazySessionHolder");
}
}
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 SingleSessionAppliesDefaultFlushModeOnOpenSessionAndClosesSession()
{
ISession expectedSession = Fake <ISession>();
CallTo(() => expectedSessionFactory.OpenSession()).Returns(expectedSession);
SessionScope scope = null;
using (scope = new SessionScope(expectedSessionFactory, null, true, FlushMode.Auto, true))
{
SessionHolder sessionHolder = (SessionHolder)TransactionSynchronizationManager.GetResource(expectedSessionFactory);
Assert.IsTrue(sessionHolder.ContainsSession(expectedSession));
}
// ensure scope is closed and sessionHolder is unregistered from TSM
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
CallToSet(() => expectedSession.FlushMode).WhenArgumentsMatch(x => x.Get <FlushMode>(0) == FlushMode.Auto).MustHaveHappenedOnceExactly();
CallTo(() => expectedSession.Close()).MustHaveHappenedOnceExactly();
}
public void SingleSessionRegistersSessionHolderWithTSM()
{
SessionScope scope = null;
using (scope = new SessionScope(expectedSessionFactory, null, true, FlushMode.Auto, true))
{
// ensure is open
Assert.IsTrue(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
// ensure registered sessionholder with TSM
Assert.IsTrue(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
// ensure a sessionHolder is registered
SessionHolder sessionHolder = TransactionSynchronizationManager.GetResource(expectedSessionFactory) as SessionHolder;
Assert.IsNotNull(sessionHolder);
}
// ensure scope is closed and sessionHolder is unregistered from TSM
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
}
public void SingleSessionAppliesDefaultFlushModeOnOpenSessionAndClosesSession()
{
ISession expectedSession = mocks.StrictMock <ISession>();
Expect.Call(expectedSessionFactory.OpenSession()).Return(expectedSession);
expectedSession.FlushMode = FlushMode.Auto;
Expect.Call(expectedSession.Close()).Return(null);
mocks.ReplayAll();
SessionScope scope = null;
using (scope = new SessionScope(expectedSessionFactory, null, true, FlushMode.Auto, true))
{
SessionHolder sessionHolder = (SessionHolder)TransactionSynchronizationManager.GetResource(expectedSessionFactory);
Assert.IsTrue(sessionHolder.ContainsSession(expectedSession));
}
// ensure scope is closed and sessionHolder is unregistered from TSM
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
mocks.VerifyAll();
}
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 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();
}
/// <summary>
/// Ensure session is closed (if any) and remove circular references to avoid memory leaks!
/// </summary>
public void Close()
{
owner = null;
if (session != null)
{
ISession tmpSession = session;
session = null;
SessionFactoryUtils.CloseSession(tmpSession);
}
if (log.IsDebugEnabled) log.Debug("Closed LazySessionHolder");
}
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();
}
/// <summary>
/// Initialize a new instance.
/// </summary>
public LazySessionHolder(SessionScope owner)
{
if (log.IsDebugEnabled) log.Debug("Created LazySessionHolder");
this.owner = owner;
}
public void ClosingTwiceIsIgnored()
{
using (SessionScope scope = new SessionScope(expectedSessionFactory, true))
{
scope.Close();
scope.Close();
}
}
public void OpeningTwiceThrowsInvalidOperationException()
{
using (SessionScope scope = new SessionScope(expectedSessionFactory, true))
{
scope.Open();
}
}
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 DisposeClosesScope()
{
SessionScope scope = new SessionScope(expectedSessionFactory, true);
Assert.IsTrue(scope.IsOpen);
scope.Dispose();
Assert.IsFalse(scope.IsOpen);
}
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 SingleSessionRegistersSessionHolderWithTSM()
{
SessionScope scope = null;
using (scope = new SessionScope(expectedSessionFactory, null, true, FlushMode.Auto, true))
{
// ensure is open
Assert.IsTrue(scope.IsOpen);
Assert.IsFalse(scope.IsParticipating);
// ensure registered sessionholder with TSM
Assert.IsTrue(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
// ensure a sessionHolder is registered
SessionHolder sessionHolder = TransactionSynchronizationManager.GetResource(expectedSessionFactory) as SessionHolder;
Assert.IsNotNull(sessionHolder);
}
// ensure scope is closed and sessionHolder is unregistered from TSM
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
}
public void SingleSessionAppliesDefaultFlushModeOnOpenSessionAndClosesSession()
{
ISession expectedSession = mocks.StrictMock<ISession>();
Expect.Call(expectedSessionFactory.OpenSession()).Return(expectedSession);
expectedSession.FlushMode = FlushMode.Auto;
Expect.Call(expectedSession.Close()).Return(null);
mocks.ReplayAll();
SessionScope scope = null;
using (scope = new SessionScope(expectedSessionFactory, null, true, FlushMode.Auto, true))
{
SessionHolder sessionHolder = (SessionHolder)TransactionSynchronizationManager.GetResource(expectedSessionFactory);
Assert.IsTrue(sessionHolder.ContainsSession(expectedSession));
}
// ensure scope is closed and sessionHolder is unregistered from TSM
Assert.IsFalse(scope.IsOpen);
Assert.IsFalse(TransactionSynchronizationManager.HasResource(expectedSessionFactory));
mocks.VerifyAll();
}
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();
}