Services/Transaction/Castle.Services.Transaction.Tests/TransactionManagerTestCase.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.Services.Transaction.Tests
  16 {
  17         using System;
  18
  19         using NUnit.Framework;
  20
  21         [TestFixture]
  22         public class TransactionManagerTestCase
  23         {
  24                 private DefaultTransactionManager tm;
  25
  26                 [SetUp]
  27                 public void Init()
  28                 {
  29                         tm = new DefaultTransactionManager(new TransientActivityManager());
  30                 }
  31
  32                 [Test]
  33                 public void SynchronizationsAndCommit()
  34                 {
  35                         ITransaction transaction =
  36                                 tm.CreateTransaction(TransactionMode.Unspecified, IsolationMode.Unspecified);
  37
  38                         transaction.Begin();
  39
  40                         SynchronizationImpl sync = new SynchronizationImpl();
  41
  42                         transaction.RegisterSynchronization( sync );
  43
  44                         Assert.AreEqual( DateTime.MinValue, sync.Before );
  45                         Assert.AreEqual( DateTime.MinValue, sync.After );
  46
  47                         transaction.Commit();
  48
  49                         Assert.IsTrue( sync.Before > DateTime.MinValue );
  50                         Assert.IsTrue( sync.After > DateTime.MinValue );
  51                 }
  52
  53                 [Test]
  54                 public void SynchronizationsAndRollback()
  55                 {
  56                         ITransaction transaction =
  57                                 tm.CreateTransaction(TransactionMode.Unspecified, IsolationMode.Unspecified);
  58
  59                         transaction.Begin();
  60
  61                         SynchronizationImpl sync = new SynchronizationImpl();
  62
  63                         transaction.RegisterSynchronization( sync );
  64
  65                         Assert.AreEqual( DateTime.MinValue, sync.Before );
  66                         Assert.AreEqual( DateTime.MinValue, sync.After );
  67
  68                         transaction.Rollback();
  69
  70                         Assert.IsTrue( sync.Before > DateTime.MinValue );
  71                         Assert.IsTrue( sync.After > DateTime.MinValue );
  72                 }
  73
  74                 [Test]
  75                 public void ResourcesAndCommit()
  76                 {
  77                         ITransaction transaction =
  78                                 tm.CreateTransaction(TransactionMode.Unspecified, IsolationMode.Unspecified);
  79
  80                         ResourceImpl resource = new ResourceImpl();
  81
  82                         transaction.Enlist( resource );
  83
  84                         Assert.IsFalse( resource.Started );
  85                         Assert.IsFalse( resource.Committed );
  86                         Assert.IsFalse( resource.Rolledback );
  87
  88                         transaction.Begin();
  89
  90                         Assert.IsTrue( resource.Started );
  91                         Assert.IsFalse( resource.Committed );
  92                         Assert.IsFalse( resource.Rolledback );
  93
  94                         transaction.Commit();
  95
  96                         Assert.IsTrue( resource.Started );
  97                         Assert.IsTrue( resource.Committed );
  98                         Assert.IsFalse( resource.Rolledback );
  99                 }
 100
 101                 [Test]
 102                 public void ResourcesAndRollback()
 103                 {
 104                         ITransaction transaction =
 105                                 tm.CreateTransaction(TransactionMode.Unspecified, IsolationMode.Unspecified);
 106
 107                         ResourceImpl resource = new ResourceImpl();
 108
 109                         transaction.Enlist( resource );
 110
 111                         Assert.IsFalse( resource.Started );
 112                         Assert.IsFalse( resource.Committed );
 113                         Assert.IsFalse( resource.Rolledback );
 114
 115                         transaction.Begin();
 116
 117                         Assert.IsTrue( resource.Started );
 118                         Assert.IsFalse( resource.Committed );
 119                         Assert.IsFalse( resource.Rolledback );
 120
 121                         transaction.Rollback();
 122
 123                         Assert.IsTrue( resource.Started );
 124                         Assert.IsTrue( resource.Rolledback );
 125                         Assert.IsFalse( resource.Committed );
 126                 }
 127
 128                 [Test]
 129                 [ExpectedException( typeof(TransactionException) )]
 130                 public void InvalidBegin()
 131                 {
 132                         ITransaction transaction = tm.CreateTransaction(
 133                                 TransactionMode.Requires, IsolationMode.Unspecified);
 134
 135                         transaction.Begin();
 136                         transaction.Begin();
 137                 }
 138
 139                 [Test]
 140                 [ExpectedException( typeof(TransactionException) )]
 141                 public void InvalidCommit()
 142                 {
 143                         ITransaction transaction = tm.CreateTransaction(
 144                                 TransactionMode.Requires, IsolationMode.Unspecified);
 145
 146                         transaction.Begin();
 147                         transaction.Rollback();
 148
 149                         transaction.Commit();
 150                 }
 151
 152                 [Test]
 153                 public void TransactionCreatedEvent()
 154                 {
 155                         bool transactionCreatedEventTriggered = false;
 156
 157                         tm.TransactionCreated += delegate { transactionCreatedEventTriggered = true; };
 158
 159                         Assert.IsFalse(transactionCreatedEventTriggered);
 160
 161                         ITransaction transaction = tm.CreateTransaction(
 162                                 TransactionMode.Requires, IsolationMode.Unspecified);
 163
 164                         Assert.IsTrue(transactionCreatedEventTriggered);
 165                 }
 166
 167                 [Test]
 168                 public void TransactionDisposedEvent()
 169                 {
 170                         bool transactionDisposedEventTriggered = false;
 171
 172                         tm.TransactionDisposed += delegate { transactionDisposedEventTriggered = true; };
 173
 174                         ITransaction transaction = tm.CreateTransaction(
 175                                 TransactionMode.Requires, IsolationMode.Unspecified);
 176
 177                         Assert.IsFalse(transactionDisposedEventTriggered);
 178
 179                         transaction.Begin();
 180
 181                         Assert.IsFalse(transactionDisposedEventTriggered);
 182
 183                         transaction.Commit();
 184
 185                         Assert.IsFalse(transactionDisposedEventTriggered);
 186
 187                         tm.Dispose(transaction);
 188
 189                         Assert.IsTrue(transactionDisposedEventTriggered);
 190                 }
 191
 192                 [Test]
 193                 public void TransactionCommittedEvent()
 194                 {
 195                         bool transactionCommittedEventTriggered = false;
 196                         bool transactionRolledBackEventTriggered = false;
 197                         bool transactionFailedEventTriggered = false;
 198
 199                         tm.TransactionCommitted += delegate { transactionCommittedEventTriggered = true; };
 200                         tm.TransactionRolledback += delegate { transactionRolledBackEventTriggered = true; };
 201                         tm.TransactionFailed += delegate { transactionFailedEventTriggered = true; };
 202
 203                         ITransaction transaction = tm.CreateTransaction(
 204                                 TransactionMode.Requires, IsolationMode.Unspecified);
 205
 206                         ResourceImpl resource = new ResourceImpl();
 207
 208                         transaction.Enlist(resource);
 209
 210                         Assert.IsFalse(transactionCommittedEventTriggered);
 211                         Assert.IsFalse(transactionRolledBackEventTriggered);
 212                         Assert.IsFalse(transactionFailedEventTriggered);
 213
 214                         transaction.Begin();
 215
 216                         Assert.IsFalse(transactionCommittedEventTriggered);
 217                         Assert.IsFalse(transactionRolledBackEventTriggered);
 218                         Assert.IsFalse(transactionFailedEventTriggered);
 219
 220                         transaction.Commit();
 221
 222                         Assert.IsTrue(transactionCommittedEventTriggered);
 223                         Assert.IsFalse(transactionRolledBackEventTriggered);
 224                         Assert.IsFalse(transactionFailedEventTriggered);
 225                 }
 226
 227                 [Test]
 228                 public void TransactionRolledBackEvent()
 229                 {
 230                         bool transactionCommittedEventTriggered = false;
 231                         bool transactionRolledBackEventTriggered = false;
 232                         bool transactionFailedEventTriggered = false;
 233
 234                         tm.TransactionCommitted += delegate { transactionCommittedEventTriggered = true; };
 235                         tm.TransactionRolledback += delegate { transactionRolledBackEventTriggered = true; };
 236                         tm.TransactionFailed += delegate { transactionFailedEventTriggered = true; };
 237
 238                         ITransaction transaction = tm.CreateTransaction(
 239                                 TransactionMode.Requires, IsolationMode.Unspecified);
 240
 241                         ResourceImpl resource = new ResourceImpl();
 242
 243                         transaction.Enlist(resource);
 244
 245                         Assert.IsFalse(transactionCommittedEventTriggered);
 246                         Assert.IsFalse(transactionRolledBackEventTriggered);
 247                         Assert.IsFalse(transactionFailedEventTriggered);
 248
 249                         transaction.Begin();
 250
 251                         Assert.IsFalse(transactionCommittedEventTriggered);
 252                         Assert.IsFalse(transactionRolledBackEventTriggered);
 253                         Assert.IsFalse(transactionFailedEventTriggered);
 254
 255                         transaction.Rollback();
 256
 257                         Assert.IsFalse(transactionCommittedEventTriggered);
 258                         Assert.IsTrue(transactionRolledBackEventTriggered);
 259                         Assert.IsFalse(transactionFailedEventTriggered);
 260                 }
 261
 262                 [Test]
 263                 public void TransactionFailedOnCommitEvent()
 264                 {
 265                         bool transactionCommittedEventTriggered = false;
 266                         bool transactionRolledBackEventTriggered = false;
 267                         bool transactionFailedEventTriggered = false;
 268
 269                         tm.TransactionCommitted += delegate { transactionCommittedEventTriggered = true; };
 270                         tm.TransactionRolledback += delegate { transactionRolledBackEventTriggered = true; };
 271                         tm.TransactionFailed += delegate { transactionFailedEventTriggered = true; };
 272
 273                         ITransaction transaction = tm.CreateTransaction(
 274                                 TransactionMode.Requires, IsolationMode.Unspecified);
 275
 276                         ResourceImpl resource = new ThrowsExceptionResourceImpl(true, false);
 277
 278                         transaction.Enlist(resource);
 279
 280                         Assert.IsFalse(transactionCommittedEventTriggered);
 281                         Assert.IsFalse(transactionRolledBackEventTriggered);
 282                         Assert.IsFalse(transactionFailedEventTriggered);
 283
 284                         transaction.Begin();
 285
 286                         Assert.IsFalse(transactionCommittedEventTriggered);
 287                         Assert.IsFalse(transactionRolledBackEventTriggered);
 288                         Assert.IsFalse(transactionFailedEventTriggered);
 289
 290                         TransactionException exception = null;
 291
 292                         try
 293                         {
 294                                 transaction.Commit();
 295                         }
 296                         catch (TransactionException transactionError)
 297                         {
 298                                 exception = transactionError;
 299                         }
 300
 301                         Assert.IsFalse(transactionCommittedEventTriggered);
 302                         Assert.IsFalse(transactionRolledBackEventTriggered);
 303                         Assert.IsTrue(transactionFailedEventTriggered);
 304
 305                         Assert.IsNotNull(exception);
 306                         Assert.IsInstanceOfType(typeof(CommitResourceException), exception);
 307                 }
 308
 309                 [Test]
 310                 public void TransactionFailedOnRollbackEvent()
 311                 {
 312                         bool transactionCommittedEventTriggered = false;
 313                         bool transactionRolledBackEventTriggered = false;
 314                         bool transactionFailedEventTriggered = false;
 315
 316                         tm.TransactionCommitted += delegate { transactionCommittedEventTriggered = true; };
 317                         tm.TransactionRolledback += delegate { transactionRolledBackEventTriggered = true; };
 318                         tm.TransactionFailed += delegate { transactionFailedEventTriggered = true; };
 319
 320                         ITransaction transaction = tm.CreateTransaction(
 321                                 TransactionMode.Requires, IsolationMode.Unspecified);
 322
 323                         ResourceImpl resource = new ThrowsExceptionResourceImpl(false, true);
 324
 325                         transaction.Enlist(resource);
 326
 327                         Assert.IsFalse(transactionCommittedEventTriggered);
 328                         Assert.IsFalse(transactionRolledBackEventTriggered);
 329                         Assert.IsFalse(transactionFailedEventTriggered);
 330
 331                         transaction.Begin();
 332
 333                         Assert.IsFalse(transactionCommittedEventTriggered);
 334                         Assert.IsFalse(transactionRolledBackEventTriggered);
 335                         Assert.IsFalse(transactionFailedEventTriggered);
 336
 337                         TransactionException exception = null;
 338
 339                         try
 340                         {
 341                                 transaction.Rollback();
 342                         }
 343                         catch (TransactionException transactionError)
 344                         {
 345                                 exception = transactionError;
 346                         }
 347
 348                         Assert.IsFalse(transactionCommittedEventTriggered);
 349                         Assert.IsFalse(transactionRolledBackEventTriggered);
 350                         Assert.IsTrue(transactionFailedEventTriggered);
 351
 352                         Assert.IsNotNull(exception);
 353                         Assert.IsInstanceOfType(typeof(RollbackResourceException), exception);
 354                 }
 355         }
 356 }