public void TransactionNotHijackingTheSession()
{
ISessionManager sessionManager = container.Resolve <ISessionManager>();
ITransaction transaction;
using (ISession session = sessionManager.OpenSession())
{
transaction = session.Transaction;
Assert.IsFalse(transaction.IsActive);
FirstDao service = container.Resolve <FirstDao>("myfirstdao");
// This call is transactional
Blog blog = service.Create();
RootService rootService = container.Resolve <RootService>();
Array blogs = rootService.FindAll(typeof(Blog));
Assert.AreEqual(1, blogs.Length);
}
Assert.IsTrue(transaction.WasCommitted);
}
public void SessionBeingSharedByMultipleTransactionsInSequenceStateless()
{
ISessionManager sessionManager = container.Resolve <ISessionManager>();
ITransaction transaction;
using (IStatelessSession session = sessionManager.OpenStatelessSession())
{
transaction = session.Transaction;
Assert.IsFalse(transaction.IsActive);
FirstDao service = container.Resolve <FirstDao>("myfirstdao");
// This call is transactional
service.CreateStateless();
// This call is transactional
service.CreateStateless("ps2's blogs");
// This call is transactional
service.CreateStateless("game cube's blogs");
RootService rootService = container.Resolve <RootService>();
Array blogs = rootService.FindAllStateless(typeof(Blog));
Assert.AreEqual(3, blogs.Length);
}
Assert.IsTrue(transaction.WasCommitted);
}
public void ExceptionOnEndWithTwoDatabases()
{
RootService service = container.Resolve <RootService>();
OrderDao orderDao = container.Resolve <OrderDao>("myorderdao");
try
{
service.DoTwoDBOperation_Create(true);
}
catch (InvalidOperationException)
{
// Expected
}
Array blogs = service.FindAll(typeof(Blog));
Array blogitems = service.FindAll(typeof(BlogItem));
Array orders = orderDao.FindAll(typeof(Order));
Assert.IsNotNull(blogs);
Assert.IsNotNull(blogitems);
Assert.IsNotNull(orders);
Assert.AreEqual(0, blogs.Length);
Assert.AreEqual(0, blogitems.Length);
Assert.AreEqual(0, orders.Length);
}
public void SessionBeingSharedByMultipleTransactionsInSequence()
{
ISessionManager sessionManager = (ISessionManager)
container[typeof(ISessionManager)];
using (ISession session = sessionManager.OpenSession())
{
Assert.IsNull(session.Transaction);
FirstDao service = (FirstDao)container["myfirstdao"];
// This call is transactional
service.Create();
Assert.IsTrue(session.Transaction.WasCommitted);
// This call is transactional
service.Create("ps2's blogs");
Assert.IsTrue(session.Transaction.WasCommitted);
// This call is transactional
service.Create("game cube's blogs");
RootService rootService = (RootService)container["root"];
Array blogs = rootService.FindAll(typeof(Blog));
Assert.AreEqual(3, blogs.Length);
}
}
public void SimpleAndSucessfulSituationUsingRootTransactionBoundaryStateless()
{
RootService service = container.Resolve <RootService>();
service.SuccessFullCallStateless();
Array blogs = service.FindAllStateless(typeof(Blog));
Array blogitems = service.FindAllStateless(typeof(BlogItem));
Assert.IsNotNull(blogs);
Assert.IsNotNull(blogitems);
Assert.AreEqual(1, blogs.Length);
Assert.AreEqual(1, blogitems.Length);
}
public void SimpleAndSucessfulSituationUsingRootTransactionBoundary()
{
RootService service = (RootService)container["root"];
service.SuccessFullCall();
Array blogs = service.FindAll(typeof(Blog));
Array blogitems = service.FindAll(typeof(BlogItem));
Assert.IsNotNull(blogs);
Assert.IsNotNull(blogitems);
Assert.AreEqual(1, blogs.Length);
Assert.AreEqual(1, blogitems.Length);
}
public void TestTransactionStatelessUsingDetachedCriteria()
{
RootService service = container.Resolve <RootService>();
string blogName = "Delicious Food!";
var blogA = service.CreateBlogStatelessUsingDetachedCriteria(blogName);
Assert.IsNotNull(blogA);
var blogB = service.FindBlogStatelessUsingDetachedCriteria(blogName);
Assert.IsNotNull(blogB);
Assert.AreEqual(blogA.Name, blogB.Name);
}
public void SuccessfulSituationWithTwoDatabasesStateless()
{
RootService service = container.Resolve <RootService>();
OrderDao orderDao = container.Resolve <OrderDao>("myorderdao");
service.DoTwoDBOperation_Create_Stateless(false);
Array blogs = service.FindAllStateless(typeof(Blog));
Array blogitems = service.FindAllStateless(typeof(BlogItem));
Array orders = orderDao.FindAllStateless(typeof(Order));
Assert.IsNotNull(blogs);
Assert.IsNotNull(blogitems);
Assert.IsNotNull(orders);
Assert.AreEqual(1, blogs.Length);
Assert.AreEqual(1, blogitems.Length);
Assert.AreEqual(1, orders.Length);
}
public void TestTransaction()
{
RootService service = container.Resolve <RootService>();
FirstDao dao = container.Resolve <FirstDao>("myfirstdao");
Blog blog = dao.Create("Blog1");
try
{
service.DoBlogRefOperation(blog);
// Expects a constraint exception on Commit
Assert.Fail("Must fail");
}
catch (Exception)
{
// transaction exception expected
}
}
public void CallWithExceptionStateless2()
{
RootService service = container.Resolve <RootService>();
try
{
service.CallWithExceptionStateless2();
}
catch (NotSupportedException)
{
}
// Ensure rollback happened
Array blogs = service.FindAllStateless(typeof(Blog));
Array blogitems = service.FindAllStateless(typeof(BlogItem));
Assert.IsEmpty(blogs);
Assert.IsEmpty(blogitems);
}
public void CallWithException2()
{
RootService service = (RootService)container["root"];
try
{
service.CallWithException2();
}
catch (Exception)
{
}
// Ensure rollback happened
Array blogs = service.FindAll(typeof(Blog));
Array blogitems = service.FindAll(typeof(BlogItem));
Assert.IsNull(blogs);
Assert.IsNull(blogitems);
}
public void NonTransactionalRootStateless()
{
ISessionManager sessionManager = container.Resolve <ISessionManager>();
ITransaction transaction;
using (IStatelessSession session = sessionManager.OpenStatelessSession())
{
transaction = session.Transaction;
Assert.IsFalse(transaction.IsActive);
FirstDao first = container.Resolve <FirstDao>("myfirstdao");
SecondDao second = container.Resolve <SecondDao>("myseconddao");
// This call is transactional
Blog blog = first.CreateStateless();
// TODO: Assert transaction was committed
// Assert.IsTrue(session.Transaction.WasCommitted);
try
{
second.CreateWithExceptionStateless2(blog);
}
catch (Exception)
{
// Expected
}
// TODO: Assert transaction was rolledback
// Assert.IsTrue(session.Transaction.WasRolledBack);
RootService rootService = container.Resolve <RootService>();
Array blogs = rootService.FindAllStateless(typeof(Blog));
Assert.AreEqual(1, blogs.Length);
Array blogitems = rootService.FindAllStateless(typeof(BlogItem));
Assert.IsEmpty(blogitems);
}
}
public void TransactionNotHijackingTheSession()
{
ISessionManager sessionManager = (ISessionManager)
container[typeof(ISessionManager)];
using (ISession session = sessionManager.OpenSession())
{
Assert.IsNull(session.Transaction);
FirstDao service = (FirstDao)container["myfirstdao"];
// This call is transactional
Blog blog = service.Create();
Assert.IsTrue(session.Transaction.WasCommitted);
RootService rootService = (RootService)container["root"];
Array blogs = rootService.FindAll(typeof(Blog));
Assert.AreEqual(1, blogs.Length);
}
}
public void NonTransactionalRoot()
{
ISessionManager sessionManager = (ISessionManager)
container[typeof(ISessionManager)];
using (ISession session = sessionManager.OpenSession())
{
Assert.IsNull(session.Transaction);
FirstDao first = (FirstDao)container["myfirstdao"];
SecondDao second = (SecondDao)container["myseconddao"];
// This call is transactional
Blog blog = first.Create();
Assert.IsTrue(session.Transaction.WasCommitted);
try
{
second.CreateWithException2(blog);
}
catch (Exception)
{
// Expected
}
Assert.IsTrue(session.Transaction.WasRolledBack);
RootService rootService = (RootService)container["root"];
Array blogs = rootService.FindAll(typeof(Blog));
Assert.AreEqual(1, blogs.Length);
Array blogitems = rootService.FindAll(typeof(BlogItem));
Assert.IsNull(blogitems);
}
}
