ActiveRecord/Castle.ActiveRecord.Tests/ActiveRecordTestCase.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.Threading;
  19         using Castle.ActiveRecord.Framework;
  20         using Castle.ActiveRecord.Tests.Model;
  21         using Castle.ActiveRecord.Tests.Model.CompositeModel;
  22         using NHibernate.Expression;
  23         using NUnit.Framework;
  24
  25         [TestFixture]
  26         public class ActiveRecordTestCase : AbstractActiveRecordTest
  27         {
  28                 [Test,
  29                  ExpectedException(typeof(ActiveRecordInitializationException),
  30                         "You can't invoke ActiveRecordStarter.Initialize more than once")]
  31                 public void InitializeCantBeInvokedMoreThanOnce()
  32                 {
  33                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post));
  34                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Blog));
  35                 }
  36
  37
  38                 [Test]
  39                 public void SimpleOperations()
  40                 {
  41                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
  42                         Recreate();
  43
  44                         Post.DeleteAll();
  45                         Blog.DeleteAll();
  46
  47                         Blog[] blogs = Blog.FindAll();
  48
  49                         Assert.IsNotNull(blogs);
  50                         Assert.AreEqual(0, blogs.Length);
  51
  52                         Blog blog = new Blog();
  53                         blog.Name = "hammett's blog";
  54                         blog.Author = "hamilton verissimo";
  55                         blog.Save();
  56
  57                         blogs = Blog.FindAll();
  58                         Assert.IsNotNull(blogs);
  59                         Assert.AreEqual(1, blogs.Length);
  60
  61                         Blog retrieved = blogs[0];
  62                         Assert.IsNotNull(retrieved);
  63
  64                         Assert.AreEqual(blog.Name, retrieved.Name);
  65                         Assert.AreEqual(blog.Author, retrieved.Author);
  66                 }
  67
  68                 [Test]
  69                 public void SimpleOperations2()
  70                 {
  71                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
  72                         Recreate();
  73
  74                         Post.DeleteAll();
  75                         Blog.DeleteAll();
  76
  77                         Blog[] blogs = Blog.FindAll();
  78
  79                         Assert.IsNotNull(blogs);
  80                         Assert.AreEqual(0, blogs.Length);
  81
  82                         Blog blog = new Blog();
  83                         blog.Name = "hammett's blog";
  84                         blog.Author = "hamilton verissimo";
  85                         blog.Create();
  86
  87                         blogs = Blog.FindAll();
  88                         Assert.AreEqual(blog.Name, blogs[0].Name);
  89                         Assert.AreEqual(blog.Author, blogs[0].Author);
  90
  91                         Assert.IsNotNull(blogs);
  92                         Assert.AreEqual(1, blogs.Length);
  93
  94                         blog.Name = "something else1";
  95                         blog.Author = "something else2";
  96                         blog.Update();
  97
  98                         blogs = Blog.FindAll();
  99
 100                         Assert.IsNotNull(blogs);
 101                         Assert.AreEqual(1, blogs.Length);
 102                         Assert.AreEqual(blog.Name, blogs[0].Name);
 103                         Assert.AreEqual(blog.Author, blogs[0].Author);
 104                 }
 105
 106                 [Test]
 107                 public void ComponentAttribute()
 108                 {
 109                         ActiveRecordStarter.Initialize(GetConfigSource(),
 110                                                        typeof(Company), typeof(Client), typeof(Firm), typeof(Person));
 111                         Recreate();
 112
 113                         Company.DeleteAll();
 114
 115                         Company company = new Company("Castle Corp.");
 116                         company.Address = new PostalAddress(
 117                                 "Embau St., 102", "Sao Paulo", "SP", "040390-060");
 118                         company.Save();
 119
 120                         Company[] companies = Company.FindAll();
 121                         Assert.IsNotNull(companies);
 122                         Assert.AreEqual(1, companies.Length);
 123
 124                         Company corp = companies[0];
 125                         Assert.IsNotNull(corp.Address);
 126                         Assert.AreEqual(corp.Address.Address, company.Address.Address);
 127                         Assert.AreEqual(corp.Address.City, company.Address.City);
 128                         Assert.AreEqual(corp.Address.State, company.Address.State);
 129                         Assert.AreEqual(corp.Address.ZipCode, company.Address.ZipCode);
 130                 }
 131
 132                 [Test]
 133                 public void RelationsOneToMany()
 134                 {
 135                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 136                         Recreate();
 137
 138                         Post.DeleteAll();
 139                         Blog.DeleteAll();
 140
 141                         Blog blog = new Blog();
 142                         blog.Name = "hammett's blog";
 143                         blog.Author = "hamilton verissimo";
 144                         blog.Save();
 145
 146                         Post post1 = new Post(blog, "title1", "contents", "category1");
 147                         Post post2 = new Post(blog, "title2", "contents", "category2");
 148
 149                         post1.Save();
 150                         post2.Save();
 151
 152                         blog = Blog.Find(blog.Id);
 153
 154                         Assert.IsNotNull(blog);
 155                         Assert.IsNotNull(blog.Posts, "posts collection is null");
 156                         Assert.AreEqual(2, blog.Posts.Count);
 157
 158                         foreach(Post post in blog.Posts)
 159                         {
 160                                 Assert.AreEqual(blog.Id, post.Blog.Id);
 161                         }
 162                 }
 163
 164                 [Test]
 165                 public void RelationsWithCompositeKey()
 166                 {
 167                         // User HasAndBelongsToMany Groups
 168                         // Groups HasAndBelongsToMany Users
 169                         // User HasMany Groups
 170                         //
 171                         ActiveRecordStarter.Initialize(GetConfigSource(),
 172                                                        typeof(Group),
 173                                                        typeof(Agent),
 174                                                        typeof(Org));
 175                         Recreate();
 176
 177                         Agent.DeleteAll();
 178                         Org.DeleteAll();
 179                         Group.DeleteAll();
 180
 181                         Org org = new Org("org1", "Test Org.");
 182                         org.Save();
 183
 184                         Group group1 = new Group();
 185                         group1.Name = "Group1";
 186                         group1.Save();
 187
 188                         Group group2 = new Group();
 189                         group2.Name = "Group2";
 190                         group2.Save();
 191
 192                         AgentKey agentKey1 = new AgentKey("org1", "rbellamy");
 193                         Agent agent1 = new Agent(agentKey1);
 194                         agent1.Save();
 195                         agent1.Groups.Add(group1);
 196                         group1.Agents.Add(agent1);
 197                         agent1.Save();
 198                         agent1.Groups.Add(group2);
 199                         group2.Agents.Add(agent1);
 200                         agent1.Save();
 201
 202                         AgentKey agentKey2 = new AgentKey("org1", "hammett");
 203                         Agent agent2 = new Agent(agentKey2);
 204                         agent2.Groups.Add(group1);
 205                         agent2.Save();
 206
 207                         using(new SessionScope())
 208                         {
 209                                 org = Org.Find(org.Id);
 210                                 group1 = Group.Find(group1.Id);
 211                                 group2 = Group.Find(group2.Id);
 212                                 agent1 = Agent.Find(agentKey1);
 213                                 agent2 = Agent.Find(agentKey2);
 214
 215                                 Assert.IsNotNull(org);
 216                                 Assert.IsNotNull(group1);
 217                                 Assert.IsNotNull(group2);
 218                                 Assert.IsNotNull(agent1);
 219                                 Assert.IsNotNull(org.Agents, "Org agent collection is null.");
 220                                 Assert.IsNotNull(group1.Agents, "Group1 agent collection is null");
 221                                 Assert.IsNotNull(group2.Agents, "Group2 agent collection is null");
 222                                 Assert.IsNotNull(agent1.Groups, "Agent group collection is null.");
 223                                 Assert.IsNotNull(agent1.Org, "Agent's org is null.");
 224                                 Assert.AreEqual(2, group1.Agents.Count);
 225                                 Assert.AreEqual(2, agent1.Groups.Count);
 226                                 Assert.AreEqual(1, agent2.Groups.Count);
 227
 228                                 foreach(Agent agentLoop in org.Agents)
 229                                 {
 230                                         Assert.IsTrue(agentLoop.Groups.Contains(group1));
 231                                 }
 232                         }
 233                 }
 234
 235                 [Test]
 236                 public void RelationsOneToManyWithWhereAndOrder()
 237                 {
 238                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 239                         Recreate();
 240
 241                         Post.DeleteAll();
 242                         Blog.DeleteAll();
 243
 244                         Blog blog = new Blog();
 245                         blog.Name = "hammett's blog";
 246                         blog.Author = "hamilton verissimo";
 247                         blog.Save();
 248
 249                         Post post1 = new Post(blog, "title1", "contents", "category1");
 250                         Post post2 = new Post(blog, "title2", "contents", "category2");
 251                         Post post3 = new Post(blog, "title3", "contents", "category3");
 252
 253                         post1.Save();
 254                         Thread.Sleep(1000); // Its a smalldatetime (small precision)
 255                         post2.Save();
 256                         Thread.Sleep(1000); // Its a smalldatetime (small precision)
 257                         post3.Published = true;
 258                         post3.Save();
 259
 260                         blog = Blog.Find(blog.Id);
 261
 262                         Assert.IsNotNull(blog);
 263                         Assert.AreEqual(2, blog.UnPublishedPosts.Count);
 264                         Assert.AreEqual(1, blog.PublishedPosts.Count);
 265
 266                         Assert.AreEqual(3, blog.RecentPosts.Count);
 267                         Assert.AreEqual(post3.Id, ((Post) blog.RecentPosts[0]).Id);
 268                         Assert.AreEqual(post2.Id, ((Post) blog.RecentPosts[1]).Id);
 269                         Assert.AreEqual(post1.Id, ((Post) blog.RecentPosts[2]).Id);
 270                 }
 271
 272                 [Test]
 273                 public void RelationsOneToOne()
 274                 {
 275                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Employee), typeof(Award));
 276                         Recreate();
 277
 278                         Award.DeleteAll();
 279                         Employee.DeleteAll();
 280
 281                         Award award;
 282                         Employee emp = new Employee();
 283
 284                         using(new SessionScope())
 285                         {
 286                                 emp.FirstName = "john";
 287                                 emp.LastName = "doe";
 288                                 emp.Save();
 289
 290                                 Assert.AreEqual(1, Employee.FindAll().Length);
 291                                 Assert.AreEqual(0, Award.FindAll().Length);
 292
 293                                 award = new Award(emp);
 294                                 award.Description = "Invisible employee";
 295                                 award.Save();
 296                         }
 297
 298                         Assert.AreEqual(1, Award.FindAll().Length);
 299                         Assert.AreEqual(1, Employee.FindAll().Length);
 300
 301                         Employee emp2 = Employee.Find(emp.ID);
 302                         Assert.IsNotNull(emp2);
 303                         Assert.IsNotNull(emp2.Award);
 304                         Assert.AreEqual(emp.FirstName, emp2.FirstName);
 305                         Assert.AreEqual(emp.LastName, emp2.LastName);
 306                         Assert.AreEqual(award.Description, emp2.Award.Description);
 307                 }
 308
 309                 [Test]
 310                 [ExpectedException(typeof(NotFoundException))]
 311                 public void FindLoad()
 312                 {
 313                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 314                         Recreate();
 315
 316                         Post.DeleteAll();
 317                         Blog.DeleteAll();
 318
 319                         Blog blog = Blog.Find(0);
 320                         Assert.IsNull(blog);
 321                 }
 322
 323                 [Test]
 324                 public void SaveUpdate()
 325                 {
 326                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 327                         Recreate();
 328
 329
 330                         Post.DeleteAll();
 331                         Blog.DeleteAll();
 332
 333                         Blog[] blogs = Blog.FindAll();
 334
 335                         Assert.IsNotNull(blogs);
 336                         Assert.AreEqual(0, blogs.Length);
 337
 338                         Blog blog = new Blog();
 339                         blog.Name = "hammett's blog";
 340                         blog.Author = "hamilton verissimo";
 341                         blog.Save();
 342
 343                         blogs = Blog.FindAll();
 344
 345                         Assert.IsNotNull(blogs);
 346                         Assert.AreEqual(1, blogs.Length);
 347
 348                         blog.Name = "Something else";
 349                         blog.Author = "changed too";
 350                         blog.Save();
 351
 352                         blogs = Blog.FindAll();
 353
 354                         Assert.IsNotNull(blogs);
 355                         Assert.AreEqual(1, blogs.Length);
 356
 357                         Assert.AreEqual(blog.Name, blogs[0].Name);
 358                         Assert.AreEqual(blog.Author, blogs[0].Author);
 359                 }
 360
 361                 [Test]
 362                 public void Delete()
 363                 {
 364                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 365                         Recreate();
 366
 367                         Post.DeleteAll();
 368                         Blog.DeleteAll();
 369
 370                         Blog[] blogs = Blog.FindAll();
 371
 372                         Assert.IsNotNull(blogs);
 373                         Assert.AreEqual(0, blogs.Length);
 374
 375                         Blog blog = new Blog();
 376                         blog.Name = "hammett's blog";
 377                         blog.Author = "hamilton verissimo";
 378                         blog.Save();
 379
 380                         blogs = Blog.FindAll();
 381
 382                         Assert.IsNotNull(blogs);
 383                         Assert.AreEqual(1, blogs.Length);
 384
 385                         blog.Delete();
 386
 387                         blogs = Blog.FindAll();
 388
 389                         Assert.IsNotNull(blogs);
 390                         Assert.AreEqual(0, blogs.Length);
 391                 }
 392
 393                 [Test]
 394                 public void DeleteAll()
 395                 {
 396                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 397                         Recreate();
 398
 399                         Post.DeleteAll();
 400                         Blog.DeleteAll();
 401
 402                         Blog[] blogs = Blog.FindAll();
 403
 404                         Assert.IsNotNull(blogs);
 405                         Assert.AreEqual(0, blogs.Length);
 406
 407                         Blog blog1 = new Blog();
 408                         blog1.Name = "hammett's blog";
 409                         blog1.Author = "hamilton verissimo";
 410                         blog1.Save();
 411
 412                         Blog blog2 = new Blog();
 413                         blog2.Name = "richard's blog";
 414                         blog2.Author = "g. richard bellamy";
 415                         blog2.Save();
 416
 417                         blogs = Blog.FindAll();
 418
 419                         Assert.IsNotNull(blogs);
 420                         Assert.AreEqual(2, blogs.Length);
 421
 422                         Blog.DeleteAll("Author = 'g. richard bellamy'");
 423
 424                         blogs = Blog.FindAll();
 425
 426                         Assert.IsNotNull(blogs);
 427                         Assert.AreEqual(1, blogs.Length);
 428                         Assert.AreEqual("hamilton verissimo", blogs[0].Author);
 429
 430                         blog1.Delete();
 431
 432                         blogs = Blog.FindAll();
 433
 434                         Assert.IsNotNull(blogs);
 435                         Assert.AreEqual(0, blogs.Length);
 436                 }
 437
 438                 [Test]
 439                 public void ExecuteAndCallback()
 440                 {
 441                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 442                         Recreate();
 443
 444                         Post.DeleteAll();
 445                         Blog.DeleteAll();
 446
 447                         Blog[] blogs = Blog.FindAll();
 448
 449                         Assert.IsNotNull(blogs);
 450                         Assert.AreEqual(0, blogs.Length);
 451
 452                         Blog blog = new Blog();
 453                         blog.Name = "hammett's blog";
 454                         blog.Author = "hamilton verissimo";
 455                         blog.Save();
 456
 457                         blogs = Blog.FindAll();
 458
 459                         Assert.IsNotNull(blogs);
 460                         Assert.AreEqual(1, blogs.Length);
 461
 462                         blog.CustomAction();
 463
 464                         blogs = Blog.FindAll();
 465
 466                         Assert.IsNotNull(blogs);
 467                         Assert.AreEqual(0, blogs.Length);
 468                 }
 469
 470                 [Test]
 471                 [Ignore("Need to complete this test case!")]
 472                 public void RelationMap()
 473                 {
 474                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(IntlName), typeof(Snippet));
 475                         Recreate();
 476
 477                         IntlName n1 = new IntlName();
 478                         n1.AddSnippet("pt-br", "bom dia");
 479                         n1.AddSnippet("en-us", "good morning");
 480                         n1.Save();
 481                 }
 482
 483                 [Test]
 484                 public void TestTimestampedClass()
 485                 {
 486                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(TimeStamped));
 487                         Recreate();
 488
 489                         TimeStamped ts = new TimeStamped();
 490                         ts.name = "a timestamped record";
 491
 492                         Assert.IsTrue(ts.LastSaved == DateTime.MinValue);
 493                         ts.Save();
 494                         Assert.IsFalse(ts.LastSaved == DateTime.MinValue);
 495
 496                         //DateTime origional_lastsaved = ts.LastSaved;
 497
 498                         ts.name = "another name";
 499                         ts.Save();
 500
 501                         // Assert.IsFalse(ts.LastSaved == origional_lastsaved);
 502                 }
 503
 504                 [Test]
 505                 public void FetchCount()
 506                 {
 507                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 508                         Recreate();
 509
 510                         Post.DeleteAll();
 511                         Blog.DeleteAll();
 512
 513                         Assert.AreEqual(0, Post.FetchCount());
 514                         Assert.AreEqual(0, Blog.FetchCount());
 515
 516                         Blog[] blogs = Blog.FindAll();
 517
 518                         Assert.IsNotNull(blogs);
 519                         Assert.AreEqual(0, blogs.Length);
 520                         Assert.IsFalse(Blog.Exists());
 521
 522                         Blog blog = new Blog();
 523                         blog.Name = "hammett's blog";
 524                         blog.Author = "hamilton verissimo";
 525                         blog.Save();
 526
 527                         Assert.AreEqual(1, Blog.FetchCount());
 528                         Assert.IsTrue(Blog.Exists());
 529
 530                         blogs = Blog.FindAll();
 531                         Assert.IsNotNull(blogs);
 532                         Assert.AreEqual(1, blogs.Length);
 533
 534                         Blog blog2 = new Blog();
 535                         blog2.Name = "joe's blog";
 536                         blog2.Author = "joe doe";
 537                         blog2.Save();
 538
 539                         Assert.AreEqual(2, Blog.FetchCount());
 540                         Assert.AreEqual(1, Blog.FetchCount("name=?", "hammett's blog"));
 541                         Assert.IsTrue(Blog.Exists("name=?", "hammett's blog"));
 542
 543                         Blog retrieved = blogs[0];
 544                         Assert.IsNotNull(retrieved);
 545
 546                         Assert.AreEqual(blog.Name, retrieved.Name);
 547                         Assert.AreEqual(blog.Author, retrieved.Author);
 548
 549                         Assert.AreEqual(1, Blog.FetchCount(
 550                                                 Expression.Eq("Name", blog.Name),
 551                                                 Expression.Eq("Author", blog.Author)));
 552
 553                         Assert.AreEqual(0, Blog.FetchCount(
 554                                                 Expression.Eq("Name", "/\ndrew's Blog"),
 555                                                 Expression.Eq("Author", "Andrew Peters")));
 556                 }
 557
 558                 [Test]
 559                 public void LifecycleMethods()
 560                 {
 561                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
 562                         Recreate();
 563
 564                         Post.DeleteAll();
 565                         Blog.DeleteAll();
 566
 567                         Blog blog = new Blog();
 568
 569                         Assert.IsTrue(blog.OnDeleteCalled == blog.OnLoadCalled == blog.OnSaveCalled == blog.OnUpdateCalled);
 570
 571                         blog.Name = "hammett's blog";
 572                         blog.Author = "hamilton verissimo";
 573                         blog.Save();
 574
 575                         Assert.IsTrue(blog.OnSaveCalled);
 576                         Assert.IsFalse(blog.OnDeleteCalled);
 577                         Assert.IsFalse(blog.OnLoadCalled);
 578                         Assert.IsFalse(blog.OnUpdateCalled);
 579
 580                         blog.Name = "hammett's blog x";
 581                         blog.Author = "hamilton verissimo x";
 582                         blog.Save();
 583                         Assert.IsTrue(blog.OnUpdateCalled);
 584
 585                         blog = Blog.Find(blog.Id);
 586                         Assert.IsTrue(blog.OnLoadCalled);
 587
 588                         blog.Delete();
 589                         Assert.IsTrue(blog.OnDeleteCalled);
 590                 }
 591
 592                 [Test]
 593                 public void RegisterTypeTest()
 594                 {
 595                         ActiveRecordStarter.Initialize(GetConfigSource());
 596                         ActiveRecordStarter.RegisterTypes(typeof(Blog), typeof(Post));
 597                         Recreate();
 598
 599                         Post.DeleteAll();
 600                         Blog.DeleteAll();
 601
 602                         Blog[] blogs = Blog.FindAll();
 603
 604                         Assert.IsNotNull(blogs);
 605                         Assert.AreEqual(0, blogs.Length);
 606
 607                         Blog blog = new Blog();
 608                         blog.Name = "hammett's blog";
 609                         blog.Author = "hamilton verissimo";
 610                         blog.Save();
 611
 612                         blogs = Blog.FindAll();
 613                         Assert.IsNotNull(blogs);
 614                         Assert.AreEqual(1, blogs.Length);
 615
 616                         Blog retrieved = blogs[0];
 617                         Assert.IsNotNull(retrieved);
 618
 619                         Assert.AreEqual(blog.Name, retrieved.Name);
 620                         Assert.AreEqual(blog.Author, retrieved.Author);
 621                 }
 622
 623                 [Test]
 624                 public void TestName()
 625                 {
 626                         ActiveRecordStarter.Initialize(GetConfigSource());
 627                         ActiveRecordStarter.RegisterTypes(typeof(Blog), typeof(Post));
 628                         Recreate();
 629
 630                         Blog blog = new Blog();
 631                         blog.Name = null;
 632                         blog.Author = "hamilton verissimo";
 633                         blog.Save();
 634
 635                         Blog[] blogs = Blog.FindByProperty("Name", null);
 636
 637                         Assert.IsTrue(blogs.Length == 1);
 638
 639                         using(new SessionScope())
 640                         {
 641                                 blog.Name = "Hammetts blog";
 642                                 blog.Save();
 643                         }
 644
 645                         blogs = Blog.FindByProperty("Name", null);
 646
 647                         Assert.IsTrue(blogs.Length == 0);
 648
 649                         blogs = Blog.FindByProperty("Name", "Hammetts blog");
 650
 651                         Assert.IsTrue(blogs.Length == 1);
 652                 }
 653
 654                 [Test]
 655                 public void ExistsTest()
 656                 {
 657                         ActiveRecordStarter.Initialize(GetConfigSource());
 658                         ActiveRecordStarter.RegisterTypes(typeof(Blog), typeof(Post));
 659                         Recreate();
 660
 661                         Blog blog = new Blog();
 662                         blog.Name = "hammett's blog";
 663                         blog.Author = "hamilton verissimo";
 664                         blog.Save();
 665
 666                         Assert.IsTrue(blog.Id > 0);
 667                         Assert.IsTrue(Blog.Exists(blog.Id));
 668
 669                         blog = new Blog();
 670                         blog.Name = "chad's blog";
 671                         blog.Author = "chad humphries";
 672                         blog.Save();
 673
 674                         Assert.IsTrue(Blog.Exists(blog.Id));
 675
 676                         Assert.IsFalse(Blog.Exists(1000));
 677                 }
 678
 679                 [Test]
 680                 public void ExistsByCriterion()
 681                 {
 682                         ActiveRecordStarter.Initialize(GetConfigSource());
 683                         ActiveRecordStarter.RegisterTypes(typeof(Blog), typeof(Post));
 684                         Recreate();
 685
 686                         Blog[] blogs = Blog.FindAll();
 687
 688                         Assert.IsNotNull(blogs);
 689                         Assert.AreEqual(0, blogs.Length);
 690
 691                         Blog blog = new Blog();
 692                         blog.Name = "hammett's blog";
 693                         blog.Author = "hamilton verissimo";
 694                         blog.Save();
 695
 696                         Assert.IsTrue(blog.Id > 0);
 697                         Assert.IsTrue(Blog.Exists(
 698                                         Expression.Eq("Name", blog.Name),
 699                                         Expression.Eq("Author", blog.Author)));
 700
 701                         blog = new Blog();
 702                         blog.Name = "chad's blog";
 703                         blog.Author = "chad humphries";
 704                         blog.Save();
 705
 706                         Assert.IsTrue(Blog.Exists(
 707                                         Expression.Eq("Name", blog.Name),
 708                                         Expression.Eq("Author", blog.Author)));
 709
 710                         Assert.IsFalse(Blog.Exists(
 711                                         Expression.Eq("Name", "/\ndrew's Blog"),
 712                                         Expression.Eq("Author", "Andrew Peters")));
 713                 }
 714
 715                 [Test, ExpectedExceptionAttribute(typeof(ActiveRecordException), "Could not perform Save for ModelClassWithBrokenField")]
 716                 public void SaveWithBadTableSchemaThrowsException()
 717                 {
 718                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(ModelClassUsedToCreateTableForClassWithBrokenField));
 719                         Recreate();
 720
 721                         ActiveRecordStarter.ResetInitializationFlag();
 722                         ActiveRecordStarter.Initialize(GetConfigSource(), typeof(ModelClassWithBrokenField));
 723
 724                         ModelClassWithBrokenField brokenClass = new ModelClassWithBrokenField();
 725                         brokenClass.Broken = true;
 726                         brokenClass.Save();
 727                 }
 728
 729         }
 730 }