Facilities/NHibernateIntegration/Castle.Facilities.NHibernateIntegration.Tests/Transactions/TransactionsTestCase.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Facilities.NHibernateIntegration.Tests.Transactions
  16 {
  17         using System;
  18
  19         using Castle.Facilities.AutomaticTransactionManagement;
  20
  21         using NHibernate;
  22         using NUnit.Framework;
  23
  24         [TestFixture]
  25         public class TransactionsTestCase : AbstractNHibernateTestCase
  26         {
  27                 protected override void ConfigureContainer()
  28                 {
  29                         container.AddFacility("transactions", new TransactionFacility());
  30
  31                         container.AddComponent("root", typeof(RootService));
  32                         container.AddComponent("myfirstdao", typeof(FirstDao));
  33                         container.AddComponent("myseconddao", typeof(SecondDao));
  34                 }
  35
  36                 [Test]
  37                 public void TestTransaction()
  38                 {
  39                         ISessionManager sessionManager = (ISessionManager) container[typeof(ISessionManager)];
  40
  41                         RootService service = (RootService) container[typeof(RootService)];
  42                         FirstDao dao = (FirstDao) container[typeof(FirstDao)];
  43
  44                         Blog blog = dao.Create("Blog1");
  45
  46                         try
  47                         {
  48                                 service.DoBlogRefOperation(blog);
  49
  50                                 // Expects a constraint exception on Commit
  51
  52                                 Assert.Fail("Must fail");
  53                         }
  54                         catch(Exception)
  55                         {
  56                                 // transaction exception expected
  57                         }
  58                 }
  59
  60                 [Test]
  61                 // [Ignore("This doesn't work with the NH 1.2 transaction property, needs to be fixed")]
  62                 public void TransactionNotHijackingTheSession()
  63                 {
  64                         ISessionManager sessionManager = (ISessionManager)
  65                                                          container[typeof(ISessionManager)];
  66
  67                         using(ISession session = sessionManager.OpenSession())
  68                         {
  69                                 Assert.IsFalse(session.Transaction.IsActive);
  70
  71                                 FirstDao service = (FirstDao) container["myfirstdao"];
  72
  73                                 // This call is transactional
  74                                 Blog blog = service.Create();
  75
  76                                 // TODO: Assert transaction was committed
  77                                 // Assert.IsTrue(session.Transaction.WasCommitted);
  78
  79                                 RootService rootService = (RootService) container["root"];
  80
  81                                 Array blogs = rootService.FindAll(typeof(Blog));
  82                                 Assert.AreEqual(1, blogs.Length);
  83                         }
  84                 }
  85
  86                 [Test]
  87                 // [Ignore("This doesn't work with the NH 1.2 transaction property, needs to be fixed")]
  88                 public void SessionBeingSharedByMultipleTransactionsInSequence()
  89                 {
  90                         ISessionManager sessionManager = (ISessionManager)
  91                                                          container[typeof(ISessionManager)];
  92
  93                         using(ISession session = sessionManager.OpenSession())
  94                         {
  95                                 Assert.IsFalse(session.Transaction.IsActive);
  96
  97                                 FirstDao service = (FirstDao) container["myfirstdao"];
  98
  99                                 // This call is transactional
 100                                 service.Create();
 101
 102                                 // TODO: Assert transaction was committed
 103                                 // Assert.IsTrue(session.Transaction.WasCommitted);
 104
 105                                 // This call is transactional
 106                                 service.Create("ps2's blogs");
 107
 108                                 // TODO: Assert transaction was committed
 109                                 // Assert.IsTrue(session.Transaction.WasCommitted);
 110
 111                                 // This call is transactional
 112                                 service.Create("game cube's blogs");
 113
 114                                 RootService rootService = (RootService) container["root"];
 115
 116                                 Array blogs = rootService.FindAll(typeof(Blog));
 117                                 Assert.AreEqual(3, blogs.Length);
 118                         }
 119                 }
 120
 121                 [Test]
 122                 // [Ignore("This doesn't work with the NH 1.2 transaction property, needs to be fixed")]
 123                 public void NonTransactionalRoot()
 124                 {
 125                         ISessionManager sessionManager = (ISessionManager)
 126                                                          container[typeof(ISessionManager)];
 127
 128                         using(ISession session = sessionManager.OpenSession())
 129                         {
 130                                 Assert.IsFalse(session.Transaction.IsActive);
 131
 132                                 FirstDao first = (FirstDao) container["myfirstdao"];
 133                                 SecondDao second = (SecondDao) container["myseconddao"];
 134
 135                                 // This call is transactional
 136                                 Blog blog = first.Create();
 137
 138                                 // TODO: Assert transaction was committed
 139                                 // Assert.IsTrue(session.Transaction.WasCommitted);
 140
 141                                 try
 142                                 {
 143                                         second.CreateWithException2(blog);
 144                                 }
 145                                 catch(Exception)
 146                                 {
 147                                         // Expected
 148                                 }
 149
 150                                 // TODO: Assert transaction was rolledback
 151                                 // Assert.IsTrue(session.Transaction.WasRolledBack);
 152
 153                                 RootService rootService = (RootService) container["root"];
 154
 155                                 Array blogs = rootService.FindAll(typeof(Blog));
 156                                 Assert.AreEqual(1, blogs.Length);
 157                                 Array blogitems = rootService.FindAll(typeof(BlogItem));
 158                                 Assert.IsEmpty(blogitems);
 159                         }
 160                 }
 161
 162                 [Test]
 163                 public void SimpleAndSucessfulSituationUsingRootTransactionBoundary()
 164                 {
 165                         RootService service = (RootService) container["root"];
 166
 167                         service.SuccessFullCall();
 168
 169                         Array blogs = service.FindAll(typeof(Blog));
 170                         Array blogitems = service.FindAll(typeof(BlogItem));
 171
 172                         Assert.IsNotNull(blogs);
 173                         Assert.IsNotNull(blogitems);
 174                         Assert.AreEqual(1, blogs.Length);
 175                         Assert.AreEqual(1, blogitems.Length);
 176                 }
 177
 178                 [Test]
 179                 public void CallWithException()
 180                 {
 181                         RootService service = (RootService) container["root"];
 182
 183                         try
 184                         {
 185                                 service.CallWithException();
 186                         }
 187                         catch(Exception)
 188                         {
 189                         }
 190
 191                         // Ensure rollback happened
 192
 193                         Array blogs = service.FindAll(typeof(Blog));
 194                         Array blogitems = service.FindAll(typeof(BlogItem));
 195
 196                         Assert.IsEmpty(blogs);
 197                         Assert.IsEmpty(blogitems);
 198                 }
 199
 200                 [Test]
 201                 public void CallWithException2()
 202                 {
 203                         RootService service = (RootService) container["root"];
 204
 205                         try
 206                         {
 207                                 service.CallWithException2();
 208                         }
 209                         catch(Exception)
 210                         {
 211                         }
 212
 213                         // Ensure rollback happened
 214
 215                         Array blogs = service.FindAll(typeof(Blog));
 216                         Array blogitems = service.FindAll(typeof(BlogItem));
 217
 218                         Assert.IsEmpty(blogs);
 219                         Assert.IsEmpty(blogitems);
 220                 }
 221         }
 222 }