ActiveRecord/Castle.ActiveRecord.Tests/TransactionScopeTestCase.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.ActiveRecord.Tests
  16 {
  17         using System;
  18         using NUnit.Framework;
  19         using NHibernate;
  20         using Castle.ActiveRecord.Tests.Model;
  21
  22         [TestFixture]
  23         public class TransactionScopeTestCase : AbstractActiveRecordTest
  24         {
  25                 [Test]
  26                 public void TransactionScopeUsage()
  27                 {
  28                         ISession session1, session2, session3, session4;
  29
  30                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
  31                         Recreate();
  32
  33                         using(new TransactionScope())
  34                         {
  35                                 session1 = Blog.Holder.CreateSession(typeof(Blog));
  36                                 session2 = Blog.Holder.CreateSession(typeof(Post));
  37                                 session3 = Blog.Holder.CreateSession(typeof(Blog));
  38                                 session4 = Blog.Holder.CreateSession(typeof(Post));
  39
  40                                 Assert.IsNotNull(session1);
  41                                 Assert.IsNotNull(session2);
  42                                 Assert.IsNotNull(session3);
  43                                 Assert.IsNotNull(session3);
  44
  45                                 Assert.IsTrue(session2 == session1);
  46                                 Assert.IsTrue(session3 == session1);
  47                                 Assert.IsTrue(session4 == session1);
  48                         }
  49
  50                         // Old behavior
  51
  52                         session1 = Blog.Holder.CreateSession(typeof(Blog));
  53                         session2 = Blog.Holder.CreateSession(typeof(Blog));
  54
  55                         Assert.IsNotNull(session1);
  56                         Assert.IsNotNull(session2);
  57                         Assert.IsTrue(session1 != session2);
  58
  59                         Blog.Holder.ReleaseSession(session1);
  60                         Blog.Holder.ReleaseSession(session2);
  61                 }
  62
  63                 [Test]
  64                 public void RollbackVote()
  65                 {
  66                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
  67                         Recreate();
  68
  69                         Post.DeleteAll();
  70                         Blog.DeleteAll();
  71
  72                         using(TransactionScope transaction = new TransactionScope())
  73                         {
  74                                 Blog blog = new Blog();
  75                                 blog.Author = "hammett";
  76                                 blog.Name = "some name";
  77                                 blog.Save();
  78
  79                                 Post post = new Post(blog, "title", "post contents", "Castle");
  80                                 post.Save();
  81
  82                                 // pretend something went wrong
  83
  84                                 transaction.VoteRollBack();
  85                         }
  86
  87                         Blog[] blogs = Blog.FindAll();
  88                         Assert.AreEqual(0, blogs.Length);
  89
  90                         Post[] posts = Post.FindAll();
  91                         Assert.AreEqual(0, posts.Length);
  92                 }
  93
  94                 [Test]
  95                 public void RollbackOnDispose()
  96                 {
  97                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
  98                         Recreate();
  99
 100                         Post.DeleteAll();
 101                         Blog.DeleteAll();
 102
 103                         using(TransactionScope transaction = new TransactionScope(OnDispose.Rollback))
 104                         {
 105                                 Blog blog = new Blog();
 106                                 blog.Author = "hammett";
 107                                 blog.Name = "some name";
 108                                 blog.Save();
 109
 110                                 Post post = new Post(blog, "title", "post contents", "Castle");
 111                                 post.Save();
 112                         }
 113
 114                         Blog[] blogs = Blog.FindAll();
 115                         Assert.AreEqual(0, blogs.Length);
 116
 117                         Post[] posts = Post.FindAll();
 118                         Assert.AreEqual(0, posts.Length);
 119                 }
 120
 121                 [Test]
 122                 public void CommitVote()
 123                 {
 124                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 125                         Recreate();
 126
 127                         Post.DeleteAll();
 128                         Blog.DeleteAll();
 129
 130                         using(TransactionScope transaction = new TransactionScope())
 131                         {
 132                                 Blog blog = new Blog();
 133                                 blog.Author = "hammett";
 134                                 blog.Name = "some name";
 135                                 blog.Save();
 136
 137                                 Post post = new Post(blog, "title", "post contents", "Castle");
 138                                 post.Save();
 139
 140                                 // Default to VoteCommit
 141                         }
 142
 143                         Blog[] blogs = Blog.FindAll();
 144                         Assert.AreEqual(1, blogs.Length);
 145
 146                         Post[] posts = Post.FindAll();
 147                         Assert.AreEqual(1, posts.Length);
 148                 }
 149
 150                 [Test]
 151                 public void RollbackUponException()
 152                 {
 153                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 154                         Recreate();
 155
 156                         Post.DeleteAll();
 157                         Blog.DeleteAll();
 158
 159                         using(TransactionScope transaction = new TransactionScope())
 160                         {
 161                                 Blog blog = new Blog();
 162                                 blog.Author = "hammett";
 163                                 blog.Name = "some name";
 164                                 blog.Save();
 165
 166                                 Post post = new Post(blog, "title", "post contents", "Castle");
 167
 168                                 try
 169                                 {
 170                                         post.SaveWithException();
 171                                 }
 172                                 catch(Exception)
 173                                 {
 174                                         transaction.VoteRollBack();
 175                                 }
 176                         }
 177
 178                         Blog[] blogs = Blog.FindAll();
 179                         Assert.AreEqual(0, blogs.Length);
 180
 181                         Post[] posts = Post.FindAll();
 182                         Assert.AreEqual(0, posts.Length);
 183                 }
 184
 185                 [Test]
 186                 public void NestedTransactions()
 187                 {
 188                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 189                         Recreate();
 190
 191                         Post.DeleteAll();
 192                         Blog.DeleteAll();
 193
 194                         using(TransactionScope root = new TransactionScope())
 195                         {
 196                                 Blog blog = new Blog();
 197
 198                                 using(TransactionScope t1 = new TransactionScope(TransactionMode.Inherits))
 199                                 {
 200                                         blog.Author = "hammett";
 201                                         blog.Name = "some name";
 202                                         blog.Save();
 203
 204                                         t1.VoteCommit();
 205                                 }
 206
 207                                 using(TransactionScope t2 = new TransactionScope(TransactionMode.Inherits))
 208                                 {
 209                                         Post post = new Post(blog, "title", "post contents", "Castle");
 210
 211                                         try
 212                                         {
 213                                                 post.SaveWithException();
 214                                         }
 215                                         catch(Exception)
 216                                         {
 217                                                 t2.VoteRollBack();
 218                                         }
 219                                 }
 220                         }
 221
 222                         Blog[] blogs = Blog.FindAll();
 223                         Assert.AreEqual(0, blogs.Length);
 224
 225                         Post[] posts = Post.FindAll();
 226                         Assert.AreEqual(0, posts.Length);
 227                 }
 228
 229                 [Test]
 230                 public void LotsOfNestedTransactionWithDifferentConfigurations()
 231                 {
 232                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 233                         Recreate();
 234
 235                         Post.DeleteAll();
 236                         Blog.DeleteAll();
 237
 238                         using(TransactionScope root = new TransactionScope())
 239                         {
 240                                 using(TransactionScope t1 = new TransactionScope()) // Isolated
 241                                 {
 242                                         Blog blog = new Blog();
 243
 244                                         Blog.FindAll(); // Just to force a session association
 245
 246                                         using(TransactionScope t1n = new TransactionScope(TransactionMode.Inherits))
 247                                         {
 248                                                 Blog.FindAll(); // Just to force a session association
 249
 250                                                 blog.Author = "hammett";
 251                                                 blog.Name = "some name";
 252                                                 blog.Save();
 253                                         }
 254
 255                                         using(TransactionScope t1n = new TransactionScope(TransactionMode.Inherits))
 256                                         {
 257                                                 Post post = new Post(blog, "title", "post contents", "Castle");
 258
 259                                                 post.Save();
 260                                         }
 261
 262                                         t1.VoteRollBack();
 263                                 }
 264
 265                                 Blog.FindAll(); // Cant be locked
 266
 267                                 using(TransactionScope t2 = new TransactionScope())
 268                                 {
 269                                         Blog blog = new Blog();
 270                                         Blog.FindAll(); // Just to force a session association
 271
 272                                         using(new TransactionScope())
 273                                         {
 274                                                 Blog.FindAll(); // Just to force a session association
 275
 276                                                 blog.Author = "hammett";
 277                                                 blog.Name = "some name";
 278                                                 blog.Save();
 279                                         }
 280
 281                                         using(TransactionScope t1n = new TransactionScope(TransactionMode.Inherits))
 282                                         {
 283                                                 Post post = new Post(blog, "title", "post contents", "Castle");
 284
 285                                                 try
 286                                                 {
 287                                                         post.SaveWithException();
 288                                                 }
 289                                                 catch(Exception)
 290                                                 {
 291                                                         t1n.VoteRollBack();
 292                                                 }
 293                                         }
 294                                 }
 295
 296                                 root.VoteCommit();
 297                         }
 298
 299                         Blog[] blogs = Blog.FindAll();
 300                         Assert.AreEqual(1, blogs.Length);
 301
 302                         Post[] posts = Post.FindAll();
 303                         Assert.AreEqual(0, posts.Length);
 304                 }
 305
 306                 [Test]
 307                 public void MixingSessionScopeAndTransactionScopes()
 308                 {
 309                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 310                         Recreate();
 311
 312                         Post.DeleteAll();
 313                         Blog.DeleteAll();
 314
 315                         using(new SessionScope())
 316                         {
 317                                 using(TransactionScope root = new TransactionScope())
 318                                 {
 319                                         using(TransactionScope t1 = new TransactionScope()) // Isolated
 320                                         {
 321                                                 Blog blog = new Blog();
 322
 323                                                 Blog.FindAll(); // Just to force a session association
 324
 325                                                 using(new TransactionScope(TransactionMode.Inherits))
 326                                                 {
 327                                                         Blog.FindAll(); // Just to force a session association
 328
 329                                                         blog.Author = "hammett";
 330                                                         blog.Name = "some name";
 331                                                         blog.Save();
 332                                                 }
 333
 334                                                 using(new TransactionScope(TransactionMode.Inherits))
 335                                                 {
 336                                                         Post post = new Post(blog, "title", "post contents", "Castle");
 337
 338                                                         post.Save();
 339                                                 }
 340
 341                                                 t1.VoteRollBack();
 342                                         }
 343
 344                                         Blog.FindAll(); // Cant be locked
 345
 346                                         using(new TransactionScope())
 347                                         {
 348                                                 Blog blog = new Blog();
 349                                                 Blog.FindAll(); // Just to force a session association
 350
 351                                                 using(new TransactionScope())
 352                                                 {
 353                                                         Blog.FindAll(); // Just to force a session association
 354
 355                                                         blog.Author = "hammett";
 356                                                         blog.Name = "some name";
 357                                                         blog.Save();
 358                                                 }
 359
 360                                                 using(TransactionScope t1n = new TransactionScope(TransactionMode.Inherits))
 361                                                 {
 362                                                         Post post = new Post(blog, "title", "post contents", "Castle");
 363
 364                                                         try
 365                                                         {
 366                                                                 post.SaveWithException();
 367                                                         }
 368                                                         catch(Exception)
 369                                                         {
 370                                                                 t1n.VoteRollBack();
 371                                                         }
 372                                                 }
 373                                         }
 374
 375                                         root.VoteCommit();
 376                                 }
 377                         }
 378
 379                         Blog[] blogs = Blog.FindAll();
 380                         Assert.AreEqual(1, blogs.Length);
 381
 382                         Post[] posts = Post.FindAll();
 383                         Assert.AreEqual(0, posts.Length);
 384                 }
 385
 386                 [Test]
 387                 public void MixingSessionScopeAndTransactionScopes2()
 388                 {
 389                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(PostLazy), typeof(BlogLazy));
 390                         Recreate();
 391
 392                         PostLazy.DeleteAll();
 393                         BlogLazy.DeleteAll();
 394
 395                         BlogLazy b = new BlogLazy();
 396
 397                         using(new SessionScope())
 398                         {
 399                                 b.Name = "a";
 400                                 b.Author = "x";
 401                                 b.Save();
 402
 403                                 using(new TransactionScope())
 404                                 {
 405                                         for(int i = 1; i <= 10; i++)
 406                                         {
 407                                                 PostLazy post = new PostLazy(b, "t", "c", "General");
 408                                                 post.Save();
 409                                         }
 410                                 }
 411                         }
 412
 413                         using(new SessionScope())
 414                         {
 415                                 // We should load this outside the transaction scope
 416
 417                                 b = BlogLazy.Find(b.Id);
 418
 419                                 using(new TransactionScope())
 420                                 {
 421                                         int total = b.Posts.Count;
 422
 423                                         foreach(PostLazy p in b.Posts)
 424                                         {
 425                                                 p.Delete();
 426                                         }
 427
 428                                         b.Delete();
 429                                 }
 430                         }
 431
 432                         BlogLazy[] blogs = BlogLazy.FindAll();
 433                         Assert.AreEqual(0, blogs.Length);
 434
 435                         PostLazy[] posts = PostLazy.FindAll();
 436                         Assert.AreEqual(0, posts.Length);
 437                 }
 438
 439                 [Test]
 440                 public void MixingSessionScopeAndTransactionScopes3()
 441                 {
 442                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(PostLazy), typeof(BlogLazy));
 443                         Recreate();
 444
 445                         PostLazy.DeleteAll();
 446                         BlogLazy.DeleteAll();
 447
 448                         BlogLazy b = new BlogLazy();
 449
 450                         using(new SessionScope())
 451                         {
 452                                 b.Name = "a";
 453                                 b.Author = "x";
 454                                 b.Save();
 455
 456                                 using(new TransactionScope())
 457                                 {
 458                                         for(int i = 1; i <= 10; i++)
 459                                         {
 460                                                 PostLazy post = new PostLazy(b, "t", "c", "General");
 461                                                 post.Save();
 462                                         }
 463                                 }
 464                         }
 465
 466                         using(new SessionScope())
 467                         {
 468                                 // We should load this outside the transaction scope
 469
 470                                 b = BlogLazy.Find(b.Id);
 471
 472                                 using(TransactionScope transaction = new TransactionScope())
 473                                 {
 474                                         int total = b.Posts.Count;
 475
 476                                         foreach(PostLazy p in b.Posts)
 477                                         {
 478                                                 p.Delete();
 479                                         }
 480
 481                                         b.Delete();
 482
 483                                         transaction.VoteRollBack();
 484                                 }
 485                         }
 486
 487                         BlogLazy[] blogs = BlogLazy.FindAll();
 488                         Assert.AreEqual(1, blogs.Length);
 489
 490                         PostLazy[] posts = PostLazy.FindAll();
 491                         Assert.AreEqual(10, posts.Length);
 492                 }
 493
 494                 [Test]
 495                 public void MixingSessionScopeAndTransactionScopes4()
 496                 {
 497                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 498                         Recreate();
 499
 500                         Post.DeleteAll();
 501                         Blog.DeleteAll();
 502
 503                         Blog b = new Blog();
 504                         Post post = null;
 505
 506                         {
 507                                 b.Name = "a";
 508                                 b.Author = "x";
 509                                 b.Save();
 510
 511                                 post = new Post(b, "t", "c", "General");
 512                                 post.Save();
 513                         }
 514
 515                         using(new SessionScope())
 516                         {
 517                                 using(new TransactionScope(TransactionMode.Inherits))
 518                                 {
 519                                         b = Blog.Find(b.Id);
 520                                         b.Name = "changed";
 521                                         b.Save();
 522                                 }
 523
 524                                 {
 525                                         Post post2 = Post.Find(post.Id);
 526                                         b = Blog.Find(b.Id);
 527                                 }
 528
 529                                 using(new TransactionScope(TransactionMode.Inherits))
 530                                 {
 531                                         Post post2 = Post.Find(post.Id);
 532                                         b = Blog.Find(b.Id);
 533                                 }
 534                         }
 535
 536                         Blog[] blogs = Blog.FindAll();
 537                         Assert.AreEqual(1, blogs.Length);
 538
 539                         Post[] posts = Post.FindAll();
 540                         Assert.AreEqual(1, posts.Length);
 541                 }
 542
 543                 [Test]
 544                 public void NestedTransactionWithRollbackOnDispose()
 545                 {
 546                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 547                         Recreate();
 548
 549                         Post.DeleteAll();
 550                         Blog.DeleteAll();
 551
 552                         using(new TransactionScope())
 553                         {
 554                                 Blog blog = new Blog();
 555
 556                                 using(TransactionScope t1 = new TransactionScope(TransactionMode.Inherits, OnDispose.Rollback))
 557                                 {
 558                                         blog.Author = "hammett";
 559                                         blog.Name = "some name";
 560                                         blog.Save();
 561
 562                                         t1.VoteCommit();
 563                                 }
 564
 565                                 using(TransactionScope t2 = new TransactionScope(TransactionMode.Inherits, OnDispose.Rollback))
 566                                 {
 567                                         Post post = new Post(blog, "title", "post contents", "Castle");
 568
 569                                         try
 570                                         {
 571                                                 post.SaveWithException();
 572
 573                                                 t2.VoteCommit(); // Will never be called
 574                                         }
 575                                         catch(Exception)
 576                                         {
 577                                                 // t2.VoteRollBack();
 578                                         }
 579                                 }
 580                         }
 581
 582                         Blog[] blogs = Blog.FindAll();
 583                         Assert.AreEqual(0, blogs.Length);
 584
 585                         Post[] posts = Post.FindAll();
 586                         Assert.AreEqual(0, posts.Length);
 587                 }
 588
 589                 [Test]
 590                 public void ReportedProblemOnForum()
 591                 {
 592                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Company), typeof(Person));
 593                         Recreate();
 594
 595                         using(new TransactionScope())
 596                         {
 597                                 Company comp1 = new Company("comp1");
 598                                 comp1.Create();
 599
 600                                 Company comp2 = new Company("comp2");
 601                                 comp2.Create();
 602                         }
 603                 }
 604
 605                 [Test]
 606                 public void ExplicitFlushInsideSecondTransactionProblem()
 607                 {
 608                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Company), typeof(Person));
 609                         Recreate();
 610
 611                         Company comp1 = new Company("comp1");
 612                         Company comp2 = new Company("comp2");
 613                         using(new SessionScope())
 614                         {
 615                                 comp1.Create();
 616                                 comp2.Create();
 617                         }
 618
 619                         using(new SessionScope(FlushAction.Never))
 620                         {
 621                                 using(TransactionScope tx = new TransactionScope(OnDispose.Rollback))
 622                                 {
 623                                         Company comp2a = Company.Find(comp2.Id);
 624                                         comp2a.Name = "changed";
 625                                         tx.VoteCommit();
 626                                 }
 627
 628                                 using(new TransactionScope(OnDispose.Rollback))
 629                                 {
 630                                         Company[] changedCompanies = ActiveRecordMediator<Company>.FindAllByProperty("Name", "changed");
 631                                         Assert.AreEqual(1, changedCompanies.Length);
 632                                         Company e2a = changedCompanies[0];
 633                                         e2a.Delete();
 634
 635                                         SessionScope.Current.Flush();
 636
 637                                         Assert.AreEqual(0, ActiveRecordMediator<Company>.FindAllByProperty("Name", "changed").Length);
 638                                 }
 639                         }
 640                 }
 641         }
 642 }