ActiveRecord/Castle.ActiveRecord.Tests/DifferentDatabaseScopeTestCase.cs

   1 // Copyright 2004-2007 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 System.Data.SqlClient;
  19
  20         using Castle.ActiveRecord.Framework;
  21         using Castle.ActiveRecord.Framework.Scopes;
  22         using Castle.ActiveRecord.Tests.Model;
  23         using Castle.Core.Configuration;
  24
  25         using NHibernate;
  26
  27         using NUnit.Framework;
  28
  29         [TestFixture]
  30         public class DifferentDatabaseScopeTestCase : AbstractActiveRecordTest
  31         {
  32                 [SetUp]
  33                 public void Setup()
  34                 {
  35                         base.Init();
  36
  37                         ActiveRecordStarter.Initialize( GetConfigSource(),
  38                                 typeof(Blog), typeof(Post),
  39                                 typeof(OtherDbBlog), typeof(OtherDbPost), typeof(Test2ARBase) );
  40
  41                         Recreate();
  42                 }
  43
  44                 [Test, Category("mssql")]
  45                 public void SimpleCase()
  46                 {
  47                         Blog blog = new Blog();
  48                         blog.Name = "hammett's blog";
  49                         blog.Author = "hamilton verissimo";
  50                         blog.Save();
  51
  52                         SqlConnection conn = CreateSqlConnection();
  53
  54                         using(conn)
  55                         {
  56                                 conn.Open();
  57
  58                                 using(new DifferentDatabaseScope(conn))
  59                                 {
  60                                         blog.Create();
  61                                 }
  62                         }
  63
  64                         Blog[] blogs = Blog.FindAll();
  65                         Assert.IsNotNull( blogs );
  66                         Assert.AreEqual( 1, blogs.Length );
  67
  68                         OtherDbBlog[] blogs2 = OtherDbBlog.FindAll();
  69                         Assert.IsNotNull( blogs2 );
  70                         Assert.AreEqual( 1, blogs2.Length );
  71                 }
  72
  73                 [Test, Category("mssql")]
  74                 public void UsingSessionScope()
  75                 {
  76                         ISession session1, session2;
  77
  78                         using(new SessionScope())
  79                         {
  80                                 Blog blog = new Blog();
  81                                 blog.Name = "hammett's blog";
  82                                 blog.Author = "hamilton verissimo";
  83                                 blog.Save();
  84
  85                                 session1 = blog.CurrentSession;
  86                                 Assert.IsNotNull(session1);
  87
  88                                 SqlConnection conn = CreateSqlConnection();
  89
  90                                 using(conn)
  91                                 {
  92                                         conn.Open();
  93
  94                                         using(new DifferentDatabaseScope(conn))
  95                                         {
  96                                                 blog.Create();
  97
  98                                                 session2 = blog.CurrentSession;
  99                                                 Assert.IsNotNull(session2);
 100
 101                                                 Assert.IsFalse( Object.ReferenceEquals(session1, session2) );
 102                                         }
 103                                 }
 104                         }
 105
 106                         Blog[] blogs = Blog.FindAll();
 107                         Assert.IsNotNull( blogs );
 108                         Assert.AreEqual( 1, blogs.Length );
 109
 110                         OtherDbBlog[] blogs2 = OtherDbBlog.FindAll();
 111                         Assert.IsNotNull( blogs2 );
 112                         Assert.AreEqual( 1, blogs2.Length );
 113                 }
 114
 115                 [Test, Category("mssql")]
 116                 public void UsingTransactionScope()
 117                 {
 118                         SqlConnection conn = CreateSqlConnection();
 119                         ISession session1, session2;
 120                         ITransaction trans1, trans2;
 121
 122                         using(new TransactionScope())
 123                         {
 124                                 Blog blog = new Blog();
 125                                 blog.Name = "hammett's blog";
 126                                 blog.Author = "hamilton verissimo";
 127                                 blog.Save();
 128
 129                                 session1 = blog.CurrentSession;
 130                                 trans1 = blog.CurrentSession.Transaction;
 131                                 Assert.IsNotNull(session1);
 132                                 Assert.IsNotNull(session1.Transaction);
 133                                 Assert.IsFalse(session1.Transaction.WasCommitted);
 134                                 Assert.IsFalse(session1.Transaction.WasRolledBack);
 135
 136                                 conn.Open();
 137
 138                                 using(new DifferentDatabaseScope(conn))
 139                                 {
 140                                         blog.Create();
 141
 142                                         session2 = blog.CurrentSession;
 143                                         trans2 = blog.CurrentSession.Transaction;
 144                                         Assert.IsNotNull(session2);
 145
 146                                         Assert.IsFalse( Object.ReferenceEquals(session1, session2) );
 147
 148                                         Assert.IsNotNull(session2.Transaction);
 149                                         Assert.IsFalse(session2.Transaction.WasCommitted);
 150                                         Assert.IsFalse(session2.Transaction.WasRolledBack);
 151                                 }
 152                         }
 153
 154                         Assert.IsFalse(session1.IsOpen);
 155                         Assert.IsFalse(session2.IsOpen);
 156                         Assert.IsTrue(trans1.WasCommitted);
 157                         Assert.IsFalse(trans1.WasRolledBack);
 158                         Assert.IsTrue(trans2.WasCommitted);
 159                         Assert.IsFalse(trans2.WasRolledBack);
 160
 161                         Blog[] blogs = Blog.FindAll();
 162                         Assert.IsNotNull( blogs );
 163                         Assert.AreEqual( 1, blogs.Length );
 164
 165                         OtherDbBlog[] blogs2 = OtherDbBlog.FindAll();
 166                         Assert.IsNotNull( blogs2 );
 167                         Assert.AreEqual( 1, blogs2.Length );
 168                 }
 169
 170                 [Test, Category("mssql")]
 171                 public void UsingTransactionScopeWithRollback()
 172                 {
 173                         SqlConnection conn = CreateSqlConnection();
 174                         ISession session1, session2;
 175                         ITransaction trans1, trans2;
 176
 177                         using(TransactionScope scope = new TransactionScope())
 178                         {
 179                                 Blog blog = new Blog();
 180                                 blog.Name = "hammett's blog";
 181                                 blog.Author = "hamilton verissimo";
 182                                 blog.Save();
 183
 184                                 session1 = blog.CurrentSession;
 185                                 trans1 = blog.CurrentSession.Transaction;
 186                                 Assert.IsNotNull(session1);
 187                                 Assert.IsNotNull(session1.Transaction);
 188                                 Assert.IsFalse(session1.Transaction.WasCommitted);
 189                                 Assert.IsFalse(session1.Transaction.WasRolledBack);
 190
 191                                 conn.Open();
 192
 193                                 using(new DifferentDatabaseScope(conn))
 194                                 {
 195                                         blog.Create();
 196
 197                                         session2 = blog.CurrentSession;
 198                                         trans2 = blog.CurrentSession.Transaction;
 199                                         Assert.IsNotNull(session2);
 200
 201                                         Assert.IsFalse( Object.ReferenceEquals(session1, session2) );
 202
 203                                         Assert.IsNotNull(session2.Transaction);
 204                                         Assert.IsFalse(session2.Transaction.WasCommitted);
 205                                         Assert.IsFalse(session2.Transaction.WasRolledBack);
 206
 207                                         scope.VoteRollBack();
 208                                 }
 209                         }
 210
 211                         Assert.IsFalse(session1.IsOpen);
 212                         Assert.IsFalse(session2.IsOpen);
 213                         Assert.IsFalse(trans1.WasCommitted);
 214                         Assert.IsTrue(trans1.WasRolledBack);
 215                         Assert.IsFalse(trans2.WasCommitted);
 216                         Assert.IsTrue(trans2.WasRolledBack);
 217
 218                         Blog[] blogs = Blog.FindAll();
 219                         Assert.IsNotNull( blogs );
 220                         Assert.AreEqual( 0, blogs.Length );
 221
 222                         OtherDbBlog[] blogs2 = OtherDbBlog.FindAll();
 223                         Assert.IsNotNull( blogs2 );
 224                         Assert.AreEqual( 0, blogs2.Length );
 225                 }
 226
 227                 [Test, Category("mssql")]
 228                 public void MoreThanOneConnectionWithinTheSessionScope()
 229                 {
 230                         SqlConnection conn = CreateSqlConnection();
 231                         SqlConnection conn2 = CreateSqlConnection2();
 232
 233                         using(new SessionScope())
 234                         {
 235                                 foreach(SqlConnection connection in new SqlConnection[] { conn, conn2 })
 236                                 {
 237                                         connection.Open();
 238
 239                                         using(new DifferentDatabaseScope(connection))
 240                                         {
 241                                                 Blog blog = new Blog();
 242                                                 blog.Name = "hammett's blog";
 243                                                 blog.Author = "hamilton verissimo";
 244                                                 blog.Create();
 245                                         }
 246                                 }
 247                         }
 248
 249                         OtherDbBlog[] blogs2 = OtherDbBlog.FindAll();
 250                         Assert.IsNotNull( blogs2 );
 251                         Assert.AreEqual( 1, blogs2.Length );
 252
 253                         Blog[] blogs = Blog.FindAll();
 254                         Assert.IsNotNull( blogs );
 255                         Assert.AreEqual( 1, blogs.Length );
 256                 }
 257
 258                 [Test, Category("mssql")]
 259                 public void UsingSessionAndTransactionScope()
 260                 {
 261                         SqlConnection conn = CreateSqlConnection();
 262                         ISession session1, session2;
 263
 264                         ITransaction trans1, trans2;
 265                         using(new SessionScope())
 266                         {
 267                                 using(TransactionScope scope = new TransactionScope())
 268                                 {
 269                                         Blog blog = new Blog();
 270                                         blog.Name = "hammett's blog";
 271                                         blog.Author = "hamilton verissimo";
 272                                         blog.Save();
 273
 274                                         session1 = blog.CurrentSession;
 275                                         Assert.IsNotNull(session1);
 276                                         trans1 = session1.Transaction;
 277                                         Assert.IsNotNull(trans1);
 278                                         Assert.IsFalse(trans1.WasCommitted);
 279                                         Assert.IsFalse(trans1.WasRolledBack);
 280
 281                                         conn.Open();
 282
 283                                         using(new DifferentDatabaseScope(conn))
 284                                         {
 285                                                 blog = new Blog();
 286                                                 blog.Name = "hammett's blog";
 287                                                 blog.Author = "hamilton verissimo";
 288                                                 blog.Save();
 289
 290                                                 session2 = blog.CurrentSession;
 291                                                 Assert.IsNotNull(session2);
 292                                                 trans2 = session2.Transaction;
 293                                                 Assert.IsFalse( Object.ReferenceEquals(session1, session2) );
 294
 295                                                 Assert.IsNotNull(session2.Transaction);
 296                                                 Assert.IsFalse(session2.Transaction.WasCommitted);
 297                                                 Assert.IsFalse(session2.Transaction.WasRolledBack);
 298                                         }
 299
 300                                         using(new DifferentDatabaseScope(conn))
 301                                         {
 302                                                 blog = new Blog();
 303                                                 blog.Name = "hammett's blog";
 304                                                 blog.Author = "hamilton verissimo";
 305                                                 blog.Save();
 306
 307                                                 session2 = blog.CurrentSession;
 308                                                 Assert.IsNotNull(session2);
 309
 310                                                 Assert.IsFalse( Object.ReferenceEquals(session1, session2) );
 311
 312                                                 Assert.IsNotNull(session2.Transaction);
 313                                                 Assert.IsFalse(session2.Transaction.WasCommitted);
 314                                                 Assert.IsFalse(session2.Transaction.WasRolledBack);
 315                                         }
 316                                 }
 317                         }
 318
 319                         Assert.IsFalse(session1.IsOpen);
 320                         Assert.IsFalse(session2.IsOpen);
 321                         Assert.IsTrue(trans1.WasCommitted);
 322                         Assert.IsFalse(trans1.WasRolledBack);
 323                         Assert.IsTrue(trans2.WasCommitted);
 324                         Assert.IsFalse(session2.Transaction.WasRolledBack);
 325
 326                         Blog[] blogs = Blog.FindAll();
 327                         Assert.IsNotNull( blogs );
 328                         Assert.AreEqual( 1, blogs.Length );
 329
 330                         OtherDbBlog[] blogs2 = OtherDbBlog.FindAll();
 331                         Assert.IsNotNull( blogs2 );
 332                         Assert.AreEqual( 2, blogs2.Length );
 333                 }
 334
 335                 [Test, Category("mssql")]
 336                 public void SequenceOfTransactions()
 337                 {
 338                         SqlConnection conn = CreateSqlConnection();
 339                         ISession session1, session2;
 340
 341                         ITransaction trans1, trans2;
 342                         using(new SessionScope())
 343                         {
 344                                 using(TransactionScope scope = new TransactionScope())
 345                                 {
 346                                         Blog blog = new Blog();
 347                                         blog.Name = "hammett's blog";
 348                                         blog.Author = "hamilton verissimo";
 349                                         blog.Save();
 350
 351                                         session1 = blog.CurrentSession;
 352                                         Assert.IsNotNull(session1);
 353                                         trans1 = session1.Transaction;
 354                                         Assert.IsNotNull(trans1);
 355                                         Assert.IsFalse(trans1.WasCommitted);
 356                                         Assert.IsFalse(trans1.WasRolledBack);
 357
 358                                         conn.Open();
 359
 360                                         using(new DifferentDatabaseScope(conn))
 361                                         {
 362                                                 blog = new Blog();
 363                                                 blog.Name = "hammett's blog";
 364                                                 blog.Author = "hamilton verissimo";
 365                                                 blog.Save();
 366
 367                                                 session2 = blog.CurrentSession;
 368                                                 Assert.IsNotNull(session2);
 369                                                 trans2 = session2.Transaction;
 370                                                 Assert.IsFalse( Object.ReferenceEquals(session1, session2) );
 371
 372                                                 Assert.IsNotNull(session2.Transaction);
 373                                                 Assert.IsFalse(session2.Transaction.WasCommitted);
 374                                                 Assert.IsFalse(session2.Transaction.WasRolledBack);
 375                                         }
 376
 377                                         using(new DifferentDatabaseScope(conn))
 378                                         {
 379                                                 blog = new Blog();
 380                                                 blog.Name = "hammett's blog";
 381                                                 blog.Author = "hamilton verissimo";
 382                                                 blog.Save();
 383
 384                                                 session2 = blog.CurrentSession;
 385                                                 Assert.IsNotNull(session2);
 386
 387                                                 Assert.IsFalse( Object.ReferenceEquals(session1, session2) );
 388
 389                                                 Assert.IsNotNull(trans2);
 390                                                 Assert.IsFalse(trans2.WasCommitted);
 391                                                 Assert.IsFalse(trans2.WasRolledBack);
 392                                         }
 393                                 }
 394
 395                                 conn.Close();
 396
 397                                 using(TransactionScope scope = new TransactionScope())
 398                                 {
 399                                         Blog blog = new Blog();
 400                                         blog.Name = "another blog";
 401                                         blog.Author = "erico verissimo";
 402                                         blog.Save();
 403                                 }
 404                         }
 405
 406                         Assert.IsFalse(session1.IsOpen);
 407                         Assert.IsFalse(session2.IsOpen);
 408                         Assert.IsTrue(trans1.WasCommitted);
 409                         Assert.IsFalse(trans1.WasRolledBack);
 410                         Assert.IsTrue(trans2.WasCommitted);
 411                         Assert.IsFalse(trans2.WasRolledBack);
 412
 413                         Blog[] blogs = Blog.FindAll();
 414                         Assert.IsNotNull( blogs );
 415                         Assert.AreEqual( 2, blogs.Length );
 416
 417                         OtherDbBlog[] blogs2 = OtherDbBlog.FindAll();
 418                         Assert.IsNotNull( blogs2 );
 419                         Assert.AreEqual( 2, blogs2.Length );
 420                 }
 421
 422                 private SqlConnection CreateSqlConnection()
 423                 {
 424                         IConfigurationSource config = GetConfigSource();
 425
 426                         IConfiguration db2 = config.GetConfiguration( typeof(Test2ARBase) );
 427
 428                         SqlConnection conn = null;
 429
 430                         foreach(IConfiguration child in db2.Children)
 431                         {
 432                                 if (child.Name == "hibernate.connection.connection_string")
 433                                 {
 434                                         conn = new SqlConnection(child.Value);
 435                                 }
 436                         }
 437
 438                         return conn;
 439                 }
 440
 441                 private SqlConnection CreateSqlConnection2()
 442                 {
 443                         IConfigurationSource config = GetConfigSource();
 444
 445                         IConfiguration db2 = config.GetConfiguration( typeof(ActiveRecordBase) );
 446
 447                         SqlConnection conn = null;
 448
 449                         foreach(IConfiguration child in db2.Children)
 450                         {
 451                                 if (child.Name == "hibernate.connection.connection_string")
 452                                 {
 453                                         conn = new SqlConnection(child.Value);
 454                                 }
 455                         }
 456
 457                         return conn;
 458                 }
 459         }
 460 }