ActiveRecord/Castle.ActiveRecord.Tests/Validation/ValidationTestCase.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.Validation
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Globalization;
  20         using System.Reflection;
  21         using System.Threading;
  22         using NUnit.Framework;
  23
  24         using Castle.ActiveRecord.Tests.Validation.Model;
  25         using Castle.Components.Validator;
  26
  27         [TestFixture]
  28         public class ValidationTestCase : AbstractActiveRecordTest
  29         {
  30                 [Test]
  31                 public void IsValid()
  32                 {
  33                         ActiveRecordStarter.Initialize( GetConfigSource(), typeof(User) );
  34
  35                         User user = new User();
  36
  37                         Assert.IsFalse(user.IsValid());
  38
  39                         user.Name = "hammett";
  40                         user.Login = "hammett";
  41                         user.Password = "123";
  42                         user.ConfirmationPassword = "123";
  43                         user.Email = "hammett@gmail.com";
  44
  45                         Assert.IsTrue(user.IsValid());
  46                 }
  47
  48                 [Test]
  49                 public void ErrorMessages()
  50                 {
  51                         Thread.CurrentThread.CurrentCulture =
  52                                 Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-us");
  53
  54                         ActiveRecordStarter.Initialize( GetConfigSource(), typeof(User) );
  55
  56                         User user = new User();
  57                         Type type = user.GetType();
  58                         PropertyInfo info;
  59                         ArrayList propertyMessages;
  60
  61                         Assert.IsFalse(user.IsValid());
  62                         Assert.AreEqual(5, user.ValidationErrorMessages.Length);
  63                         Assert.AreEqual("This is a required field", user.ValidationErrorMessages[0]);
  64                         Assert.AreEqual("This is a required field", user.ValidationErrorMessages[1]);
  65                         Assert.AreEqual("This is a required field", user.ValidationErrorMessages[2]);
  66                         Assert.AreEqual("This is a required field", user.ValidationErrorMessages[3]);
  67                         Assert.AreEqual("This is a required field", user.ValidationErrorMessages[4]);
  68
  69                         Assert.AreEqual(5, user.PropertiesValidationErrorMessage.Count);
  70
  71                         info = type.GetProperty("Login");
  72                         Assert.IsTrue(user.PropertiesValidationErrorMessage.Contains(info));
  73                         propertyMessages = (ArrayList)user.PropertiesValidationErrorMessage[info];
  74                         Assert.AreEqual(1, propertyMessages.Count);
  75                         Assert.AreEqual("This is a required field", propertyMessages[0]);
  76
  77                         info = type.GetProperty("Name");
  78                         Assert.IsTrue(user.PropertiesValidationErrorMessage.Contains(info));
  79                         propertyMessages = (ArrayList)user.PropertiesValidationErrorMessage[info];
  80                         Assert.AreEqual(1, propertyMessages.Count);
  81                         Assert.AreEqual("This is a required field", propertyMessages[0]);
  82
  83                         info = type.GetProperty("Email");
  84                         Assert.IsTrue(user.PropertiesValidationErrorMessage.Contains(info));
  85                         propertyMessages = (ArrayList)user.PropertiesValidationErrorMessage[info];
  86                         Assert.AreEqual(1, propertyMessages.Count);
  87                         Assert.AreEqual("This is a required field", propertyMessages[0]);
  88
  89                         info = type.GetProperty("Password");
  90                         Assert.IsTrue(user.PropertiesValidationErrorMessage.Contains(info));
  91                         propertyMessages = (ArrayList)user.PropertiesValidationErrorMessage[info];
  92                         Assert.AreEqual(1, propertyMessages.Count);
  93                         Assert.AreEqual("This is a required field", propertyMessages[0]);
  94
  95                         info = type.GetProperty("ConfirmationPassword");
  96                         Assert.IsTrue(user.PropertiesValidationErrorMessage.Contains(info));
  97                         propertyMessages = (ArrayList)user.PropertiesValidationErrorMessage[info];
  98                         Assert.AreEqual(1, propertyMessages.Count);
  99                         Assert.AreEqual("This is a required field", propertyMessages[0]);
 100
 101                         user.Name = "hammett";
 102                         user.Login = "hammett";
 103                         user.Email = "hammett@gmail.com";
 104                         user.Password = "123x";
 105                         user.ConfirmationPassword = "123";
 106
 107                         Assert.IsFalse(user.IsValid());
 108                         Assert.AreEqual(1, user.ValidationErrorMessages.Length);
 109                         Assert.AreEqual("Fields do not match", user.ValidationErrorMessages[0]);
 110
 111                         info = type.GetProperty("Password");
 112                         Assert.IsTrue(user.PropertiesValidationErrorMessage.Contains(info));
 113                         propertyMessages = (ArrayList)user.PropertiesValidationErrorMessage[info];
 114                         Assert.AreEqual(1, propertyMessages.Count);
 115                         Assert.AreEqual("Fields do not match", propertyMessages[0]);
 116
 117                         user.Password = "123";
 118
 119                         Assert.IsTrue(user.IsValid());
 120                         Assert.AreEqual(0, user.ValidationErrorMessages.Length);
 121                 }
 122
 123                 [Test, ExpectedException(typeof(ValidationException))]
 124                 public void CreateFail1()
 125                 {
 126                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(User));
 127                         Recreate();
 128
 129                         User user = new User();
 130
 131                         user.Create();
 132                 }
 133
 134                 [Test, ExpectedException(typeof(ValidationException))]
 135                 public void CreateFail2()
 136                 {
 137                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(User));
 138                         Recreate();
 139
 140                         User user = new User();
 141
 142                         user.Save();
 143                 }
 144
 145                 [Test, ExpectedException(typeof(ValidationException))]
 146                 public void CreateFail3()
 147                 {
 148                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(User));
 149                         Recreate();
 150
 151                         using (new SessionScope())
 152                         {
 153                                 User user = new User();
 154
 155                                 user.Save();
 156                         }
 157                 }
 158
 159                 [Test, ExpectedException(typeof(ValidationException))]
 160                 public void CreateFail4()
 161                 {
 162                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(User));
 163                         Recreate();
 164
 165                         using (new TransactionScope())
 166                         {
 167                                 User user = new User();
 168
 169                                 user.Save();
 170                         }
 171                 }
 172
 173                 [Test, ExpectedException(typeof(ValidationException))]
 174                 public void UpdateFail1()
 175                 {
 176                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(User));
 177                         Recreate();
 178
 179                         int id = CreateNewUser();
 180
 181                         User user = (User)
 182                                 ActiveRecordMediator.FindByPrimaryKey(typeof(User), id, true);
 183
 184                         user.Name = "";
 185                         user.Update();
 186                 }
 187
 188                 [Test, ExpectedException(typeof(ValidationException))]
 189                 public void UpdateFail2()
 190                 {
 191                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(User));
 192                         Recreate();
 193
 194                         int id = CreateNewUser();
 195
 196                         User user = (User)
 197                                 ActiveRecordMediator.FindByPrimaryKey(typeof(User), id, true);
 198
 199                         user.Name = "";
 200                         user.Save();
 201                 }
 202
 203                 [Test, ExpectedException(typeof(ValidationException))]
 204                 public void UpdateFail3()
 205                 {
 206                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(User));
 207                         Recreate();
 208
 209                         int id = CreateNewUser();
 210
 211                         User user = (User)
 212                                 ActiveRecordMediator.FindByPrimaryKey(typeof(User), id, true);
 213
 214                         user.Name = "";
 215                         user.UpdateAndFlush();
 216                 }
 217
 218                 [Test, ExpectedException(typeof(ValidationException))]
 219                 public void UpdateFail4()
 220                 {
 221                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(User));
 222                         Recreate();
 223
 224                         int id = CreateNewUser();
 225
 226                         User user = (User)
 227                                 ActiveRecordMediator.FindByPrimaryKey(typeof(User), id, true);
 228
 229                         user.Name = "";
 230                         user.SaveAndFlush();
 231                 }
 232
 233                 [Test, ExpectedException(typeof(ValidationException))]
 234                 public void DeleteFail1()
 235                 {
 236                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(User));
 237                         Recreate();
 238
 239                         int id1 = CreateNewUser();
 240                         int id2 = CreateNewUser();
 241
 242                         using (new SessionScope())
 243                         {
 244                                 User user1 = (User) ActiveRecordMediator.FindByPrimaryKey(typeof(User), id1, true);
 245                                 User user2 = (User) ActiveRecordMediator.FindByPrimaryKey(typeof(User), id2, true);
 246
 247                                 user1.Name = "";
 248                                 user2.DeleteAndFlush();
 249                         }
 250                 }
 251
 252                 [Test]
 253                 public void CheckScope()
 254                 {
 255                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(User));
 256                         Recreate();
 257
 258                         int id1 = CreateNewUser();
 259                         int id2 = CreateNewUser();
 260
 261                         try
 262                         {
 263                                 using (new SessionScope())
 264                                 {
 265                                         User user1 = (User)ActiveRecordMediator.FindByPrimaryKey(typeof(User), id1, true);
 266                                         User user2 = (User)ActiveRecordMediator.FindByPrimaryKey(typeof(User), id2, true);
 267
 268                                         user1.Name = "dng";
 269                                         user2.Name = "";
 270                                 }
 271                         }
 272                         catch (ValidationException)
 273                         {
 274                         }
 275
 276                         User user = (User)ActiveRecordMediator.FindByPrimaryKey(typeof(User), id1, true);
 277                         Assert.AreNotEqual("dng", user.Name);
 278                 }
 279
 280                 [Test, ExpectedException(typeof(ValidationException))]
 281                 public void InvalidClassIsNotPersisted()
 282                 {
 283                         ActiveRecordStarter.Initialize( GetConfigSource(), typeof(User) );
 284                         Recreate();
 285
 286                         int id = CreateNewUser();
 287
 288                         {
 289                                 User user = (User)
 290                                         ActiveRecordMediator.FindByPrimaryKey(typeof(User), id, true);
 291
 292                                 Assert.AreEqual("hammett@gmail.com", user.Email);
 293                                 Assert.AreEqual("123", user.Password);
 294                                 Assert.AreEqual("123", user.ConfirmationPassword);
 295                         }
 296
 297                         using(new SessionScope())
 298                         {
 299                                 User user = (User)
 300                                         ActiveRecordMediator.FindByPrimaryKey(typeof(User), id, true);
 301
 302                                 user.Email = "wrong";
 303                                 user.ConfirmationPassword = "123x";
 304                                 user.Password = "123y";
 305                         }
 306                 }
 307
 308                 [Test]
 309                 [ExpectedException(typeof(ValidationException), "Can't save or update as there is one (or more) field that has not passed the validation test")]
 310                 public void IsUnique()
 311                 {
 312                         ActiveRecordStarter.Initialize( GetConfigSource(), typeof(Blog2) );
 313                         Recreate();
 314
 315                         Blog2.DeleteAll();
 316
 317                         Blog2 blog = new Blog2();
 318                         blog.Name = "hammett";
 319                         blog.Create();
 320
 321                         blog = new Blog2();
 322                         blog.Name = "hammett";
 323
 324                         String[] messages = blog.ValidationErrorMessages;
 325                         Assert.IsTrue(messages.Length == 1);
 326                         Assert.AreEqual("Name is currently in use. Please pick up a new Name.", messages[0]);
 327
 328                         blog.Create();
 329                 }
 330
 331                 [Test(Description = "Reproduces AR-136")]
 332                 public void IsUniqueWithInvalidData()
 333                 {
 334                         ActiveRecordStarter.Initialize( GetConfigSource(), typeof(Blog2), typeof(Blog2B) );
 335                         Recreate();
 336
 337                         Blog2B.DeleteAll();
 338
 339                         Blog2B blog = new Blog2B();
 340                         blog.Name = "hammett";
 341                         blog.Create();
 342
 343                         blog = new Blog2B();
 344                         blog.Name = "hammett";
 345                         blog.Create();
 346
 347                         Blog2 blog2 = new Blog2();
 348                         blog2.Name = blog.Name;
 349
 350                         Assert.IsFalse(blog2.IsValid());
 351                 }
 352
 353
 354                 [Test]
 355                 [ExpectedException(typeof(ValidationException), "Can't save or update as there is one (or more) field that has not passed the validation test")]
 356                 public void IsUniqueWithNullKey()
 357                 {
 358                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Blog4));
 359                         Recreate();
 360
 361                         Blog4.DeleteAll();
 362
 363                         Blog4 blog = new Blog4();
 364                         blog.Name = "hammett";
 365                         blog.Create();
 366
 367                         blog = new Blog4();
 368                         blog.Name = "hammett";
 369
 370                         String[] messages = blog.ValidationErrorMessages;
 371                         Assert.IsTrue(messages.Length == 1);
 372                         Assert.AreEqual("Name is currently in use. Please pick up a new Name.", messages[0]);
 373
 374                         blog.Create();
 375                 }
 376
 377                 [Test]
 378                 public void IsUniqueWithSessionScope()
 379                 {
 380                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof (Blog2));
 381                         Recreate();
 382
 383                         Blog2.DeleteAll();
 384
 385                         Blog2 blog = new Blog2();
 386                         blog.Name = "hammett";
 387                         blog.Create();
 388
 389                         using (new SessionScope())
 390                         {
 391                                 Blog2 fromDb = Blog2.Find(blog.Id);
 392                                 fromDb.Name = "foo";
 393                                 fromDb.Save();
 394                         }
 395                 }
 396
 397                 [Test]
 398                 [ExpectedException(typeof(ValidationException), "Can't save or update as there is one (or more) field that has not passed the validation test")]
 399                 public void IsUnique2()
 400                 {
 401                         ActiveRecordStarter.Initialize( GetConfigSource(), typeof(Blog3) );
 402                         Recreate();
 403
 404                         Blog3.DeleteAll();
 405
 406                         Blog3 blog = new Blog3();
 407                         blog.Id = "assignedKey";
 408                         blog.Name = "First Blog";
 409                         blog.Create();
 410
 411                         blog = new Blog3();
 412                         blog.Id = "assignedKey";
 413                         blog.Name = "Second Blog";
 414
 415                         String[] messages = blog.ValidationErrorMessages;
 416                         Assert.IsTrue(messages.Length == 1);
 417                         Assert.AreEqual("The ID you specified already exists.", messages[0]);
 418
 419                         blog.Create();
 420                 }
 421
 422                 [Test]
 423                 public void Hierarchy()
 424                 {
 425                         ActiveRecordStarter.Initialize( GetConfigSource(), typeof(Person), typeof(Customer) );
 426                         // Recreate();
 427
 428                         Person p1 = new Person();
 429
 430                         Assert.IsFalse( p1.IsValid() );
 431
 432                         p1.Name = "hammett";
 433                         p1.Age = 25;
 434
 435                         Assert.IsTrue( p1.IsValid() );
 436
 437                         Customer c1 = new Customer();
 438
 439                         Assert.IsFalse( c1.IsValid() );
 440
 441                         c1.ContactName = "someone";
 442                         c1.Phone = "11";
 443
 444                         Assert.IsFalse( c1.IsValid() );
 445
 446                         c1.Name = "hammett";
 447
 448                         Assert.IsTrue( c1.IsValid() );
 449                 }
 450
 451                 [Test]
 452                 public void ValidateIsUniqueWithinTransactionScope()
 453                 {
 454                         ActiveRecordStarter.Initialize( GetConfigSource(), typeof(Blog2) );
 455                         Recreate();
 456
 457                         // The IsUniqueValidator was created a new SessionScope and causing an
 458                         // error when used inside TransactionScope
 459
 460                         using (TransactionScope scope = new TransactionScope())
 461                         {
 462                                 Blog2 blog = new Blog2();
 463                                 blog.Name = "A cool blog";
 464                                 blog.Create();
 465
 466                                 blog = new Blog2();
 467                                 blog.Name = "Another cool blog";
 468                                 blog.Create();
 469
 470                                 scope.VoteCommit();
 471                         }
 472                 }
 473
 474                 [Test, ExpectedException(typeof(ValidationException))]
 475                 public void IsUniqueTimeoutExpiredBug()
 476                 {
 477                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Blog2), typeof(Blog5));
 478                         Recreate();
 479
 480                         for (int i = 0; i < 5; i++)
 481                         {
 482                                 Blog5 blog = new Blog5();
 483                                 blog.Name = "A cool blog";
 484                                 blog.Create();
 485                         }
 486
 487                         Blog5 theBlog = new Blog5();
 488                         theBlog.Name = "A cool blog";
 489                         theBlog.Create();
 490
 491                         Blog5 anotherBlog = new Blog5();
 492                         anotherBlog.Name = "A cool blog";
 493                         anotherBlog.Create();
 494
 495                         anotherBlog.Name = "A very cool blog";
 496                         anotherBlog.Update();
 497
 498                         Assert.IsFalse(Blog2.Find(theBlog.Id).IsValid());
 499
 500                         Blog2 weblog = new Blog2();
 501                         weblog.Name = theBlog.Name;
 502
 503                         Assert.IsFalse(weblog.IsValid());
 504
 505                         weblog.Create();
 506                 }
 507
 508                 private int CreateNewUser()
 509                 {
 510                         int id;
 511
 512                         using (new SessionScope())
 513                         {
 514                                 User user = new User();
 515
 516                                 user.Name = "hammett";
 517                                 user.Login = "hammett";
 518                                 user.Email = "hammett@gmail.com";
 519                                 user.ConfirmationPassword = "123";
 520                                 user.Password = "123";
 521
 522                                 user.Save();
 523
 524                                 id = user.Id;
 525                         }
 526
 527                         return id;
 528                 }
 529         }
 530 }