class/System.Transactions/Test/EnlistTest.cs

   1 //
   2 // Tests for combination of volatile & durable resource manangers
   3 //
   4 // Author:
   5 //      Ankit Jain      <JAnkit@novell.com>
   6 //
   7 // Copyright (C) 2006 Novell, Inc (http://www.novell.com)
   8 //
   9
  10 using System;
  11 using System.Transactions;
  12 using NUnit.Framework;
  13
  14 namespace MonoTests.System.Transactions {
  15
  16         [TestFixture]
  17         public class EnlistTest {
  18
  19                 #region Vol1_Dur0
  20
  21                 /* Single volatile resource, SPC happens */
  22                 [Test]
  23                 public void Vol1_Dur0 ()
  24                 {
  25                         IntResourceManager irm = new IntResourceManager (1);
  26                         irm.UseSingle = true;
  27                         using (TransactionScope scope = new TransactionScope ()) {
  28                                 irm.Value = 2;
  29
  30                                 scope.Complete ();
  31                         }
  32                         irm.CheckSPC ("irm");
  33                 }
  34
  35                 [Test]
  36                 public void Vol1_Dur0_2PC ()
  37                 {
  38                         IntResourceManager irm = new IntResourceManager (1);
  39
  40                         using (TransactionScope scope = new TransactionScope ()) {
  41                                 irm.Value = 2;
  42
  43                                 scope.Complete ();
  44                         }
  45                         irm.Check2PC ("irm");
  46                 }
  47
  48                 /* Single volatile resource, SPC happens */
  49                 [Test]
  50                 public void Vol1_Dur0_Fail1 ()
  51                 {
  52                         IntResourceManager irm = new IntResourceManager (1);
  53                         irm.UseSingle = true;
  54                         using (TransactionScope scope = new TransactionScope ()) {
  55                                 irm.Value = 2;
  56
  57                                 /* Not completing this..
  58                                 scope.Complete ();*/
  59                         }
  60
  61                         irm.Check ( 0, 0, 0, 1, 0, "irm" );
  62                 }
  63
  64                 [Test]
  65                 [ExpectedException ( typeof ( TransactionAbortedException ) )]
  66                 public void Vol1_Dur0_Fail2 ()
  67                 {
  68                         IntResourceManager irm = new IntResourceManager (1);
  69
  70                         irm.FailPrepare = true;
  71
  72                         using (TransactionScope scope = new TransactionScope ()) {
  73                                 irm.Value = 2;
  74
  75                                 scope.Complete ();
  76                         }
  77                 }
  78
  79                 [Test]
  80                 [ExpectedException ( typeof ( TransactionAbortedException ) )]
  81                 public void Vol1_Dur0_Fail3 ()
  82                 {
  83                         IntResourceManager irm = new IntResourceManager (1);
  84                         irm.UseSingle = true;
  85                         irm.FailSPC = true;
  86
  87                         using (TransactionScope scope = new TransactionScope ()) {
  88                                 irm.Value = 2;
  89
  90                                 scope.Complete ();
  91                         }
  92                 }
  93
  94                 #endregion
  95
  96                 #region Vol2_Dur0
  97
  98                 /* >1 volatile, 2PC */
  99                 [Test]
 100                 public void Vol2_Dur0_SPC ()
 101                 {
 102                         IntResourceManager irm = new IntResourceManager (1);
 103                         IntResourceManager irm2 = new IntResourceManager (3);
 104
 105                         irm.UseSingle = true;
 106                         irm2.UseSingle = true;
 107                         using (TransactionScope scope = new TransactionScope ()) {
 108                                 irm.Value = 2;
 109                                 irm2.Value = 6;
 110
 111                                 scope.Complete ();
 112                         }
 113                         irm.Check2PC ( "irm" );
 114                         irm2.Check2PC ( "irm2" );
 115                 }
 116
 117                 #endregion
 118
 119                 #region Vol0_Dur1
 120                 /* 1 durable */
 121                 [Test]
 122                 public void Vol0_Dur1 ()
 123                 {
 124                         IntResourceManager irm = new IntResourceManager (1);
 125                         irm.Volatile = false;
 126                         irm.UseSingle = true;
 127
 128                         using (TransactionScope scope = new TransactionScope ()) {
 129                                 irm.Value = 2;
 130
 131                                 scope.Complete ();
 132                         }
 133
 134                         irm.CheckSPC ( "irm" );
 135                 }
 136
 137                 /* We support only 1 durable with 2PC
 138                  * On .net, this becomes a distributed transaction
 139                  */
 140                 [Test]
 141                 [Category ("NotWorking")]
 142                 public void Vol0_Dur1_2PC ()
 143                 {
 144                         IntResourceManager irm = new IntResourceManager (1);
 145
 146                         /* Durable resource enlisted with a IEnlistedNotification
 147                          * object
 148                          */
 149                         irm.Volatile = false;
 150
 151                         using (TransactionScope scope = new TransactionScope ()) {
 152                                 irm.Value = 2;
 153
 154                                 scope.Complete ();
 155                         }
 156                 }
 157
 158                 [Test]
 159                 public void Vol0_Dur1_Fail ()
 160                 {
 161                         IntResourceManager irm = new IntResourceManager ( 1 );
 162
 163                         /* Durable resource enlisted with a IEnlistedNotification
 164                          * object
 165                          */
 166                         irm.Volatile = false;
 167                         irm.FailSPC = true;
 168                         irm.UseSingle = true;
 169                         try {
 170                                 using (TransactionScope scope = new TransactionScope ()) {
 171                                         irm.Value = 2;
 172
 173                                         scope.Complete ();
 174                                 }
 175                         }
 176                         catch (TransactionAbortedException) {
 177                                 irm.Check ( 1, 0, 0, 0, 0, "irm" );
 178                                 return;
 179                         }
 180
 181                         Assert.Fail ();
 182                 }
 183                 #endregion
 184
 185                 #region Vol2_Dur1
 186                 /* >1vol + 1 durable */
 187                 [Test]
 188                 public void Vol2_Dur1 ()
 189                 {
 190                         IntResourceManager [] irm = new IntResourceManager [4];
 191                         irm [0] = new IntResourceManager ( 1 );
 192                         irm [1] = new IntResourceManager ( 3 );
 193                         irm [2] = new IntResourceManager ( 5 );
 194                         irm [3] = new IntResourceManager ( 7 );
 195
 196                         irm [0].Volatile = false;
 197                         for ( int i = 0; i < 4; i++ )
 198                                 irm [i].UseSingle = true;
 199
 200                         using (TransactionScope scope = new TransactionScope ()) {
 201                                 irm [0].Value = 2;
 202                                 irm [1].Value = 6;
 203                                 irm [2].Value = 10;
 204                                 irm [3].Value = 14;
 205
 206                                 scope.Complete ();
 207                         }
 208
 209                         irm [0].CheckSPC ( "irm [0]" );
 210
 211                         /* Volatile RMs get 2PC */
 212                         for (int i = 1; i < 4; i++)
 213                                 irm [i].Check2PC ( "irm [" + i + "]" );
 214                 }
 215
 216                 /* >1vol + 1 durable
 217                  * Durable fails SPC
 218                  */
 219                 [Test]
 220                 public void Vol2_Dur1_Fail1 ()
 221                 {
 222                         IntResourceManager [] irm = new IntResourceManager [4];
 223                         irm [0] = new IntResourceManager (1);
 224                         irm [1] = new IntResourceManager (3);
 225                         irm [2] = new IntResourceManager (5);
 226                         irm [3] = new IntResourceManager (7);
 227
 228                         irm [0].Volatile = false;
 229                         irm [0].FailSPC = true;
 230
 231                         for ( int i = 0; i < 4; i++ )
 232                                 irm [i].UseSingle = true;
 233
 234                         /* Durable RM irm[0] does Abort on SPC, so
 235                          * all volatile RMs get Rollback */
 236                         try {
 237                                 using (TransactionScope scope = new TransactionScope ()) {
 238                                         irm [0].Value = 2;
 239                                         irm [1].Value = 6;
 240                                         irm [2].Value = 10;
 241                                         irm [3].Value = 14;
 242
 243                                         scope.Complete ();
 244                                 }
 245                         }
 246                         catch (TransactionAbortedException) {
 247                                 irm [0].CheckSPC ( "irm [0]" );
 248                                 /* Volatile RMs get 2PC Prepare, and then get rolled back */
 249                                 for (int i = 1; i < 4; i++)
 250                                         irm [i].Check ( 0, 1, 0, 1, 0, "irm [" + i + "]" );
 251                         }
 252                 }
 253
 254                 /* >1vol + 1 durable
 255                  * durable doesn't complete SPC
 256                  */
 257                 [Test]
 258                 [Ignore ( "Correct this test, it should throw TimeOutException or something" )]
 259                 public void Vol2_Dur1_Fail2 ()
 260                 {
 261                         IntResourceManager [] irm = new IntResourceManager [4];
 262                         irm [0] = new IntResourceManager (1);
 263                         irm [1] = new IntResourceManager (3);
 264                         irm [2] = new IntResourceManager (5);
 265                         irm [3] = new IntResourceManager (7);
 266
 267                         irm [0].Volatile = false;
 268                         irm [0].IgnoreSPC = true;
 269
 270                         for ( int i = 0; i < 4; i++ )
 271                                 irm [i].UseSingle = true;
 272
 273                         /* Durable RM irm[2] does on SPC, so
 274                          * all volatile RMs get Rollback */
 275                         try {
 276                                 using (TransactionScope scope = new TransactionScope ( TransactionScopeOption.Required, new TimeSpan ( 0, 0, 5 ) )) {
 277                                         irm [0].Value = 2;
 278                                         irm [1].Value = 6;
 279                                         irm [2].Value = 10;
 280                                         irm [3].Value = 14;
 281
 282                                         scope.Complete ();
 283                                 }
 284                         }
 285                         catch (TransactionAbortedException) {
 286                                 irm [0].CheckSPC ( "irm [0]" );
 287
 288                                 /* Volatile RMs get 2PC Prepare, and then get rolled back */
 289                                 for (int i = 1; i < 4; i++)
 290                                         irm [i].Check ( 0, 1, 0, 1, 0, "irm [" + i + "]" );
 291                         }
 292                 }
 293
 294                 /* >1vol + 1 durable
 295                  * Volatile fails Prepare
 296                  */
 297                 [Test]
 298                 public void Vol2_Dur1_Fail3 ()
 299                 {
 300                         IntResourceManager [] irm = new IntResourceManager [4];
 301                         irm [0] = new IntResourceManager ( 1 );
 302                         irm [1] = new IntResourceManager ( 3 );
 303                         irm [2] = new IntResourceManager ( 5 );
 304                         irm [3] = new IntResourceManager ( 7 );
 305
 306                         irm [0].Volatile = false;
 307                         irm [2].FailPrepare = true;
 308
 309                         for ( int i = 0; i < 4; i++ )
 310                                 irm [i].UseSingle = true;
 311
 312                         /* Durable RM irm[2] does on SPC, so
 313                          * all volatile RMs get Rollback */
 314                         try {
 315                                 using (TransactionScope scope = new TransactionScope ()) {
 316                                         irm [0].Value = 2;
 317                                         irm [1].Value = 6;
 318                                         irm [2].Value = 10;
 319                                         irm [3].Value = 14;
 320
 321                                         scope.Complete ();
 322                                 }
 323                         }
 324                         catch (TransactionAbortedException) {
 325                                 irm [0].Check ( 0, 0, 0, 1, 0, "irm [0]");
 326
 327                                 /* irm [1] & [2] get prepare,
 328                                  * [2] -> ForceRollback,
 329                                  * [1] & [3] get rollback,
 330                                  * [0](durable) gets rollback */
 331                                 irm [1].Check ( 0, 1, 0, 1, 0, "irm [1]" );
 332                                 irm [2].Check ( 0, 1, 0, 0, 0, "irm [2]" );
 333                                 irm [3].Check ( 0, 0, 0, 1, 0, "irm [3]" );
 334
 335                                 return;
 336                         }
 337
 338                         Assert.Fail ( "Expected TransactionAbortedException" );
 339                 }
 340
 341                 [Test]
 342                 public void Vol2_Dur1_Fail4 ()
 343                 {
 344                         IntResourceManager [] irm = new IntResourceManager [2];
 345                         irm [0] = new IntResourceManager ( 1 );
 346                         irm [1] = new IntResourceManager ( 3 );
 347
 348                         irm [0].Volatile = false;
 349                         irm [0].FailSPC = true;
 350                         irm [0].FailWithException = true;
 351
 352                         for ( int i = 0; i < 2; i++ )
 353                                 irm [i].UseSingle = true;
 354
 355                         /* Durable RM irm[2] does on SPC, so
 356                          * all volatile RMs get Rollback */
 357                         try {
 358                                 using ( TransactionScope scope = new TransactionScope () ) {
 359                                         irm [0].Value = 2;
 360                                         irm [1].Value = 6;
 361
 362                                         scope.Complete ();
 363                                 }
 364                         }
 365                         catch ( TransactionAbortedException e) {
 366                                 Assert.IsNotNull ( e.InnerException, "Expected e.InnerException == NotSupportedException, but got None");
 367                                 Assert.AreEqual ( typeof ( NotSupportedException ), e.InnerException.GetType (), "Expected e.InnerException == NotSupportedException, but got " + e.GetType () );
 368
 369                                 irm [0].Check ( 1, 0, 0, 0, 0, "irm [0]" );
 370                                 irm [1].Check ( 0, 1, 0, 1, 0, "irm [1]" );
 371                                 return;
 372                         }
 373
 374                         Assert.Fail ( "Expected TransactionAbortedException" );
 375                 }
 376
 377                 [Test]
 378                 public void Vol2_Dur1_Fail5 ()
 379                 {
 380                         CommittableTransaction ct = new CommittableTransaction ();
 381                         IntResourceManager [] irm = new IntResourceManager [2];
 382                         irm [0] = new IntResourceManager ( 1 );
 383                         irm [1] = new IntResourceManager ( 3 );
 384
 385                         Transaction.Current = ct;
 386                         irm [0].Volatile = false;
 387                         irm [0].FailSPC = true;
 388                         irm [0].FailWithException = true;
 389
 390                         for ( int i = 0; i < 2; i++ )
 391                                 irm [i].UseSingle = true;
 392
 393                         /* Durable RM irm[2] does on SPC, so
 394                          * all volatile RMs get Rollback */
 395
 396                         using ( TransactionScope scope = new TransactionScope () ) {
 397                                 irm [0].Value = 2;
 398                                 irm [1].Value = 6;
 399
 400                                 scope.Complete ();
 401                         }
 402
 403                         try {
 404                                 ct.Commit ();
 405                         }
 406                         catch ( TransactionAbortedException e ) {
 407                                 Assert.IsNotNull ( e.InnerException, "Expected e.InnerException == NotSupportedException, but got None" );
 408                                 Assert.AreEqual ( typeof ( NotSupportedException ), e.InnerException.GetType (), "Expected e.InnerException == NotSupportedException, but got " + e.GetType () );
 409
 410                                 irm [0].Check ( 1, 0, 0, 0, 0, "irm [0]" );
 411                                 irm [1].Check ( 0, 1, 0, 1, 0, "irm [1]" );
 412                                 try {
 413                                         ct.Commit ();
 414                                 }
 415                                 catch (InvalidOperationException x ) {
 416                                         Assert.IsNull ( x.InnerException);
 417                                         Transaction.Current = null;
 418                                         return;
 419                                 }
 420                                 Assert.Fail ( "Should not be reached" );
 421                         }
 422
 423                         Assert.Fail ( "Expected TransactionAbortedException" );
 424                 }
 425
 426                 #endregion
 427
 428                 #region Others
 429                 /* >1vol
 430                  * > 1 durable, On .net this becomes a distributed transaction
 431                  * We don't support this in mono yet.
 432                  */
 433                 [Test]
 434                 [Category ("NotWorking")]
 435                 public void Vol0_Dur2 ()
 436                 {
 437                         IntResourceManager [] irm = new IntResourceManager [2];
 438                         irm [0] = new IntResourceManager ( 1 );
 439                         irm [1] = new IntResourceManager ( 3 );
 440
 441                         irm [0].Volatile = false;
 442                         irm [1].Volatile = false;
 443
 444                         for ( int i = 0; i < 2; i++ )
 445                                 irm [i].UseSingle = true;
 446
 447                         using (TransactionScope scope = new TransactionScope ()) {
 448                                 irm [0].Value = 2;
 449                                 irm [1].Value = 6;
 450
 451                                 scope.Complete ();
 452                         }
 453                 }
 454
 455                 [Test]
 456                 public void TransactionDispose ()
 457                 {
 458                         CommittableTransaction ct = new CommittableTransaction ();
 459                         IntResourceManager irm = new IntResourceManager (1);
 460                         irm.Volatile = false;
 461
 462                         ct.Dispose ();
 463                         irm.Check  (0, 0, 0, 0, "Dispose transaction");
 464                 }
 465
 466                 [Test]
 467                 public void TransactionDispose2 ()
 468                 {
 469                         CommittableTransaction ct = new CommittableTransaction ();
 470                         IntResourceManager irm = new IntResourceManager (1);
 471
 472                         Transaction.Current = ct;
 473                         irm.Value = 5;
 474
 475                         try {
 476                                 ct.Dispose ();
 477                         } finally {
 478                                 Transaction.Current = null;
 479                         }
 480
 481                         irm.Check (0, 0, 1, 0, "Dispose transaction");
 482                         Assert.AreEqual (1, irm.Value);
 483                 }
 484
 485                 [Test]
 486                 public void TransactionDispose3 ()
 487                 {
 488                         CommittableTransaction ct = new CommittableTransaction ();
 489                         IntResourceManager irm = new IntResourceManager (1);
 490
 491                         try {
 492                                 Transaction.Current = ct;
 493                                 irm.Value = 5;
 494                                 ct.Commit ();
 495                                 ct.Dispose ();
 496                         } finally {
 497                                 Transaction.Current = null;
 498                         }
 499
 500                         irm.Check (1, 1, 0, 0, "Dispose transaction");
 501                         Assert.AreEqual (5, irm.Value);
 502                 }
 503
 504                 #endregion
 505
 506         }
 507 }
 508