ActiveRecord/Castle.ActiveRecord.Tests/ActiveRecordBaseGenericsTestCase.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.ActiveRecord.Tests
  16 {
  17         using System;
  18         using System.Text;
  19         using System.Reflection;
  20         using System.Collections.Generic;
  21
  22         using NUnit.Framework;
  23
  24         using Castle.ActiveRecord.Tests.Model.GenericModel;
  25
  26         using NHibernate.Criterion;
  27
  28         [TestFixture]
  29         public class ActiveRecordBaseGenericsTestCase : AbstractActiveRecordTest
  30         {
  31                 [SetUp]
  32                 public void Setup()
  33                 {
  34                         ActiveRecordStarter.ResetInitializationFlag();
  35
  36             ActiveRecordStarter.Initialize(GetConfigSource(),
  37                                 typeof(Blog),
  38                                 typeof(Post),
  39                                 typeof(Company),
  40                                 typeof(Award),
  41                                 typeof(Employee),
  42                                 typeof(Person));
  43
  44                         Recreate();
  45
  46             Post.DeleteAll();
  47             Blog.DeleteAll();
  48             Company.DeleteAll();
  49             Award.DeleteAll();
  50             Employee.DeleteAll();
  51                 }
  52
  53                 [Test]
  54                 public void SimpleOperations()
  55                 {
  56             Blog[] blogs = Blog.FindAll();
  57
  58                         Assert.IsNotNull(blogs);
  59                         Assert.AreEqual(0, blogs.Length);
  60
  61                         Blog blog = new Blog();
  62                         blog.Name = "hammett's blog";
  63                         blog.Author = "hamilton verissimo";
  64                         blog.Save();
  65
  66             blogs = Blog.FindAll();
  67
  68                         Assert.IsNotNull(blogs);
  69                         Assert.AreEqual(1, blogs.Length);
  70
  71                         Blog retrieved = blogs[0];
  72                         Assert.IsNotNull(retrieved);
  73
  74                         Assert.AreEqual(blog.Name, retrieved.Name);
  75                         Assert.AreEqual(blog.Author, retrieved.Author);
  76                 }
  77
  78                 [Test]
  79                 public void SlicedOperation()
  80                 {
  81                         Blog blog = new Blog();
  82                         blog.Name = "hammett's blog";
  83                         blog.Author = "hamilton verissimo";
  84                         blog.Save();
  85
  86                         Post post1 = new Post(blog, "title1", "contents", "category1");
  87                         Post post2 = new Post(blog, "title2", "contents", "category2");
  88                         Post post3 = new Post(blog, "title3", "contents", "category3");
  89
  90                         post1.Save();
  91                         post2.Save();
  92                         post3.Published = true;
  93                         post3.Save();
  94             Post[] posts = Post.CustomSlicedFind(Expression.Eq("Blog", blog), 1, 2);
  95                         Assert.AreEqual(2, posts.Length);
  96                 }
  97
  98                 [Test]
  99                 public void SimpleOperations2()
 100                 {
 101                         Blog[] blogs = Blog.FindAll();
 102
 103                         Assert.IsNotNull(blogs);
 104                         Assert.AreEqual(0, blogs.Length);
 105
 106                         Blog blog = new Blog();
 107                         blog.Name = "hammett's blog";
 108                         blog.Author = "hamilton verissimo";
 109                         blog.Create();
 110
 111                         blogs = Blog.FindAll();
 112                         Assert.AreEqual(blog.Name, blogs[0].Name);
 113                         Assert.AreEqual(blog.Author, blogs[0].Author);
 114
 115                         Assert.IsNotNull(blogs);
 116                         Assert.AreEqual(1, blogs.Length);
 117
 118                         blog.Name = "something else1";
 119                         blog.Author = "something else2";
 120                         blog.Update();
 121
 122                         blogs = Blog.FindAll();
 123
 124                         Assert.IsNotNull(blogs);
 125                         Assert.AreEqual(1, blogs.Length);
 126                         Assert.AreEqual(blog.Name, blogs[0].Name);
 127                         Assert.AreEqual(blog.Author, blogs[0].Author);
 128                 }
 129
 130                 [Test]
 131                 public void HasManyAndBelongsToMany()
 132                 {
 133                         Company company = new Company("Castle Corp.");
 134                         company.Address = new PostalAddress(
 135                                 "Embau St., 102", "Sao Paulo", "SP", "040390-060");
 136                         company.Save();
 137
 138                         Person person = new Person();
 139                         person.Name = "ayende";
 140                         person.Companies.Add(company);
 141                         company.People.Add(person);
 142
 143                         person.Save();
 144
 145                         Company fromDB = Company.FindFirst();
 146                         Assert.AreEqual(1, fromDB.People.Count);
 147
 148                         Assert.AreEqual("ayende", new List<Person>(fromDB.People)[0].Name);
 149                 }
 150
 151                 [Test]
 152                 public void ComponentAttribute()
 153                 {
 154                         Company company = new Company("Castle Corp.");
 155                         company.Address = new PostalAddress(
 156                                 "Embau St., 102", "Sao Paulo", "SP", "040390-060");
 157                         company.Save();
 158
 159                         Company[] companies = Company.FindAll();
 160                         Assert.IsNotNull(companies);
 161                         Assert.AreEqual(1, companies.Length);
 162
 163                         Company corp = companies[0];
 164                         Assert.IsNotNull(corp.Address);
 165                         Assert.AreEqual(corp.Address.Address, company.Address.Address);
 166                         Assert.AreEqual(corp.Address.City, company.Address.City);
 167                         Assert.AreEqual(corp.Address.State, company.Address.State);
 168                         Assert.AreEqual(corp.Address.ZipCode, company.Address.ZipCode);
 169                 }
 170
 171                 [Test]
 172                 public void RelationsOneToMany()
 173                 {
 174                         Blog blog = new Blog();
 175                         blog.Name = "hammett's blog";
 176                         blog.Author = "hamilton verissimo";
 177                         blog.Save();
 178
 179                         Post post1 = new Post(blog, "title1", "contents", "category1");
 180                         Post post2 = new Post(blog, "title2", "contents", "category2");
 181
 182                         post1.Save();
 183                         post2.Save();
 184
 185                         blog = Blog.Find(blog.Id);
 186
 187                         Assert.IsNotNull(blog);
 188                         Assert.IsNotNull(blog.Posts, "posts collection is null");
 189                         Assert.AreEqual(2, blog.Posts.Count);
 190
 191                         foreach (Post post in blog.Posts)
 192                         {
 193                                 Assert.AreEqual(blog.Id, post.Blog.Id);
 194                         }
 195                 }
 196
 197                 [Test]
 198                 public void RelationsOneToManyWithWhereAndOrder()
 199                 {
 200                         Blog blog = new Blog();
 201                         blog.Name = "hammett's blog";
 202                         blog.Author = "hamilton verissimo";
 203                         blog.Save();
 204
 205                         Post post1 = new Post(blog, "title1", "contents", "category1");
 206                         Post post2 = new Post(blog, "title2", "contents", "category2");
 207                         Post post3 = new Post(blog, "title3", "contents", "category3");
 208
 209                         post1.Save();
 210                         System.Threading.Thread.Sleep(1000); // Its a smalldatetime (small precision)
 211                         post2.Save();
 212                         System.Threading.Thread.Sleep(1000); // Its a smalldatetime (small precision)
 213                         post3.Published = true;
 214                         post3.Save();
 215
 216                         blog = Blog.Find(blog.Id);
 217
 218                         Assert.IsNotNull(blog);
 219                         Assert.AreEqual(2, blog.UnPublishedPosts.Count);
 220                         Assert.AreEqual(1, blog.PublishedPosts.Count);
 221
 222                         Assert.AreEqual(3, blog.RecentPosts.Count);
 223                         Assert.AreEqual(post3.Id, (blog.RecentPosts[0] as Post).Id);
 224                         Assert.AreEqual(post2.Id, (blog.RecentPosts[1] as Post).Id);
 225                         Assert.AreEqual(post1.Id, (blog.RecentPosts[2] as Post).Id);
 226                 }
 227
 228                 [Test]
 229                 public void RelationsOneToOne()
 230                 {
 231                         Employee emp = new Employee();
 232                         emp.FirstName = "john";
 233                         emp.LastName = "doe";
 234                         emp.Save();
 235
 236                         Assert.AreEqual(1, Employee.FindAll().Length);
 237
 238                         Award award = new Award(emp);
 239                         award.Description = "Invisible employee";
 240                         award.Save();
 241
 242             Assert.AreEqual(1, Award.FindAll().Length);
 243
 244             Employee emp2 = Employee.Find(emp.ID);
 245                         Assert.IsNotNull(emp2);
 246                         Assert.IsNotNull(emp2.Award);
 247                         Assert.AreEqual(emp.FirstName, emp2.FirstName);
 248                         Assert.AreEqual(emp.LastName, emp2.LastName);
 249                         Assert.AreEqual(award.Description, emp2.Award.Description);
 250                 }
 251
 252                 [Test]
 253                 [ExpectedException(typeof(NotFoundException))]
 254                 public void FindLoad()
 255                 {
 256                         Blog.Find(1);
 257                 }
 258
 259                 [Test]
 260                 public void SaveUpdate()
 261                 {
 262                         Blog[] blogs = Blog.FindAll();
 263
 264                         Assert.IsNotNull(blogs);
 265                         Assert.AreEqual(0, blogs.Length);
 266
 267                         Blog blog = new Blog();
 268                         blog.Name = "hammett's blog";
 269                         blog.Author = "hamilton verissimo";
 270                         blog.Save();
 271
 272                         blogs = Blog.FindAll();
 273
 274                         Assert.IsNotNull(blogs);
 275                         Assert.AreEqual(1, blogs.Length);
 276
 277                         blog.Name = "Something else";
 278                         blog.Author = "changed too";
 279                         blog.Save();
 280
 281                         blogs = Blog.FindAll();
 282
 283                         Assert.IsNotNull(blogs);
 284                         Assert.AreEqual(1, blogs.Length);
 285
 286                         Assert.AreEqual(blog.Name, blogs[0].Name);
 287                         Assert.AreEqual(blog.Author, blogs[0].Author);
 288                 }
 289
 290                 [Test]
 291                 public void Delete()
 292                 {
 293                         Blog[] blogs = Blog.FindAll();
 294
 295                         Assert.IsNotNull(blogs);
 296                         Assert.AreEqual(0, blogs.Length);
 297
 298                         Blog blog = new Blog();
 299                         blog.Name = "hammett's blog";
 300                         blog.Author = "hamilton verissimo";
 301                         blog.Save();
 302
 303                         blogs = Blog.FindAll();
 304
 305                         Assert.IsNotNull(blogs);
 306                         Assert.AreEqual(1, blogs.Length);
 307
 308                         blog.Delete();
 309
 310                         blogs = Blog.FindAll();
 311
 312                         Assert.IsNotNull(blogs);
 313                         Assert.AreEqual(0, blogs.Length);
 314                 }
 315         }
 316 }