mongo_mapper 0.12.0 → 0.13.0.beta1

data/{test/functional/associations/test_in_array_proxy.rb → spec/functional/associations/in_array_proxy_spec.rb}

@@ -1,8 +1,8 @@
-require 'test_helper'
+require 'spec_helper'
 
-class InArrayProxyTest < Test::Unit::TestCase
+describe "InArrayProxy" do
   context "description" do
-    setup do
+    before do
       class ::List
         include MongoMapper::Document
         key :name, String, :required => true
@@ -18,16 +18,16 @@ class InArrayProxyTest < Test::Unit::TestCase
       List.collection.remove
     end
 
-    teardown do
+    after do
       Object.send :remove_const, 'List' if defined?(::List)
       Object.send :remove_const, 'User' if defined?(::User)
     end
 
-    should "default reader to empty array" do
+    it "should default reader to empty array" do
       User.new.lists.should == []
     end
 
-    should "allow adding to association like it was an array" do
+    it "should allow adding to association like it was an array" do
       user = User.new(:name => 'John')
       user.lists <<     List.new(:name => 'Foo1!')
       user.lists.push   List.new(:name => 'Foo2!')
@@ -35,7 +35,7 @@ class InArrayProxyTest < Test::Unit::TestCase
       user.lists.size.should == 3
     end
 
-    should "ignore adding duplicate ids" do
+    it "should ignore adding duplicate ids" do
       user = User.create(:name => 'John')
       list = List.create(:name => 'Foo')
       user.lists << list
@@ -46,7 +46,7 @@ class InArrayProxyTest < Test::Unit::TestCase
       user.lists.count.should == 1
     end
 
-    should "be able to replace the association" do
+    it "should be able to replace the association" do
       user = User.new(:name => 'John')
       list = List.new(:name => 'Foo')
       user.lists = [list]
@@ -59,29 +59,29 @@ class InArrayProxyTest < Test::Unit::TestCase
     end
 
     context "create" do
-      setup do
+      before do
         @user = User.create(:name => 'John')
         @list = @user.lists.create(:name => 'Foo!')
       end
 
-      should "add id to key" do
+      it "should add id to key" do
         @user.list_ids.should include(@list.id)
       end
 
-      should "persist id addition to key in database" do
+      it "should persist id addition to key in database" do
         @user.reload
         @user.list_ids.should include(@list.id)
       end
 
-      should "add doc to association" do
+      it "should add doc to association" do
         @user.lists.should include(@list)
       end
 
-      should "save doc" do
+      it "should save doc" do
         @list.should_not be_new
       end
 
-      should "reset cache" do
+      it "should reset cache" do
         @user.lists.size.should == 1
         @user.lists.create(:name => 'Moo!')
         @user.lists.size.should == 2
@@ -89,35 +89,35 @@ class InArrayProxyTest < Test::Unit::TestCase
     end
 
     context "create!" do
-      setup do
+      before do
         @user = User.create(:name => 'John')
         @list = @user.lists.create!(:name => 'Foo!')
       end
 
-      should "add id to key" do
+      it "should add id to key" do
         @user.list_ids.should include(@list.id)
       end
 
-      should "persist id addition to key in database" do
+      it "should persist id addition to key in database" do
         @user.reload
         @user.list_ids.should include(@list.id)
       end
 
-      should "add doc to association" do
+      it "should add doc to association" do
         @user.lists.should include(@list)
       end
 
-      should "save doc" do
+      it "should save doc" do
         @list.should_not be_new
       end
 
-      should "raise exception if invalid" do
-        assert_raises(MongoMapper::DocumentNotValid) do
+      it "should raise exception if invalid" do
+        expect {
           @user.lists.create!
-        end
+        }.to raise_error(MongoMapper::DocumentNotValid)
       end
 
-      should "reset cache" do
+      it "should reset cache" do
         @user.lists.size.should == 1
         @user.lists.create!(:name => 'Moo!')
         @user.lists.size.should == 2
@@ -125,7 +125,7 @@ class InArrayProxyTest < Test::Unit::TestCase
     end
 
     context "Finding scoped to association" do
-      setup do
+      before do
         @user = User.create(:name => 'John')
         @user2 = User.create(:name => 'Brandon')
         @list1 = @user.lists.create!(:name => 'Foo 1', :position => 1)
@@ -134,135 +134,135 @@ class InArrayProxyTest < Test::Unit::TestCase
       end
 
       context "all" do
-        should "work" do
+        it "should work" do
           @user.lists.all(:order => :position.asc).should == [@list1, @list2]
         end
 
-        should "work with conditions" do
+        it "should work with conditions" do
           @user.lists.all(:name => 'Foo 1').should == [@list1]
         end
 
-        should "not hit the database if ids key is empty" do
+        it "should not hit the database if ids key is empty" do
           @user.list_ids = []
-          @user.lists.expects(:query).never
+          @user.lists.should_receive(:query).never
           @user.lists.all.should == []
         end
       end
 
       context "first" do
-        should "work" do
+        it "should work" do
           @user.lists.first(:order => 'position').should == @list1
         end
 
-        should "work with conditions" do
+        it "should work with conditions" do
           @user.lists.first(:position => 2).should == @list2
         end
 
-        should "not hit the database if ids key is empty" do
+        it "should not hit the database if ids key is empty" do
           @user.list_ids = []
-          @user.lists.expects(:query).never
+          @user.lists.should_receive(:query).never
           @user.lists.first.should be_nil
         end
       end
 
       context "last" do
-        should "work" do
+        it "should work" do
           @user.lists.last(:order => 'position').should == @list2
         end
 
-        should "work with conditions" do
+        it "should work with conditions" do
           @user.lists.last(:position => 2, :order => 'position').should == @list2
         end
 
-        should "not hit the database if ids key is empty" do
+        it "should not hit the database if ids key is empty" do
           @user.list_ids = []
-          @user.lists.expects(:query).never
+          @user.lists.should_receive(:query).never
           @user.lists.last.should be_nil
         end
       end
 
       context "with one id" do
-        should "work for id in association" do
+        it "should work for id in association" do
           @user.lists.find(@list1.id).should == @list1
         end
 
-        should "work with string ids" do
+        it "should work with string ids" do
           @user.lists.find(@list1.id.to_s).should == @list1
         end
 
-        should "not work for id not in association" do
+        it "should not work for id not in association" do
           @user.lists.find(@list3.id).should be_nil
         end
 
-        should "raise error when using ! and not found" do
-          assert_raises MongoMapper::DocumentNotFound do
+        it "should raise error when using ! and not found" do
+          expect {
             @user.lists.find!(@list3.id)
-          end
+          }.to raise_error(MongoMapper::DocumentNotFound)
         end
       end
 
       context "with multiple ids" do
-        should "work for ids in association" do
+        it "should work for ids in association" do
           @user.lists.find(@list1.id, @list2.id).should == [@list1, @list2]
         end
 
-        should "not work for ids not in association" do
+        it "should not work for ids not in association" do
           @user.lists.find(@list1.id, @list2.id, @list3.id).should == [@list1, @list2]
         end
       end
 
       context "with #paginate" do
-        setup do
+        before do
           @lists = @user.lists.paginate(:per_page => 1, :page => 1, :order => 'position')
         end
 
-        should "return total pages" do
+        it "should return total pages" do
           @lists.total_pages.should == 2
         end
 
-        should "return total entries" do
+        it "should return total entries" do
           @lists.total_entries.should == 2
         end
 
-        should "return the subject" do
+        it "should return the subject" do
           @lists.collect(&:name).should == ['Foo 1']
         end
 
-        should "not hit the database if ids key is empty" do
+        it "should not hit the database if ids key is empty" do
           @user.list_ids = []
-          @user.lists.expects(:query).never
+          @user.lists.should_receive(:query).never
           @user.lists.paginate(:page => 1).should == []
         end
       end
 
       context "dynamic finders" do
-        should "work with single key" do
+        it "should work with single key" do
           @user.lists.find_by_name('Foo 1').should == @list1
           @user.lists.find_by_name!('Foo 1').should == @list1
           @user.lists.find_by_name('Foo 3').should be_nil
         end
 
-        should "work with multiple keys" do
+        it "should work with multiple keys" do
           @user.lists.find_by_name_and_position('Foo 1', 1).should == @list1
           @user.lists.find_by_name_and_position!('Foo 1', 1).should == @list1
           @user.lists.find_by_name_and_position('Foo 3', 1).should be_nil
         end
 
-        should "raise error when using ! and not found" do
-          assert_raises(MongoMapper::DocumentNotFound) do
+        it "should raise error when using ! and not found" do
+          expect {
             @user.lists.find_by_name!('Foo 3')
-          end
+          }.to raise_error(MongoMapper::DocumentNotFound)
         end
 
         context "find_or_create_by" do
-          should "not create document if found" do
+          it "should not create document if found" do
             lambda {
               list = @user.lists.find_or_create_by_name('Foo 1')
               list.should == @list1
             }.should_not change { List.count }
           end
 
-          should "create document if not found" do
+          it "should create document if not found" do
             lambda {
               list = @user.lists.find_or_create_by_name('Home')
               @user.lists.should include(list)
@@ -273,7 +273,7 @@ class InArrayProxyTest < Test::Unit::TestCase
     end
 
     context "count" do
-      setup do
+      before do
         @user = User.create(:name => 'John')
         @user2 = User.create(:name => 'Brandon')
         @list1 = @user.lists.create!(:name => 'Foo 1')
@@ -281,25 +281,25 @@ class InArrayProxyTest < Test::Unit::TestCase
         @list3 = @user2.lists.create!(:name => 'Foo 3')
       end
 
-      should "return number of ids" do
+      it "should return number of ids" do
         @user.lists.count.should == 2
         @user2.lists.count.should == 1
       end
 
-      should "return correct count when given criteria" do
+      it "should return correct count when given criteria" do
         @user.lists.count(:name => 'Foo 1').should == 1
         @user2.lists.count(:name => 'Foo 1').should == 0
       end
 
-      should "not hit the database if ids key is empty" do
+      it "should not hit the database if ids key is empty" do
         @user.list_ids = []
-        @user.lists.expects(:query).never
+        @user.lists.should_receive(:query).never
         @user.lists.count(:name => 'Foo 1').should == 0
       end
     end
 
     context "Removing documents" do
-      setup do
+      before do
         @user = User.create(:name => 'John')
         @user2 = User.create(:name => 'Brandon')
         @list1 = @user.lists.create!(:name => 'Foo 1', :position => 1)
@@ -308,13 +308,13 @@ class InArrayProxyTest < Test::Unit::TestCase
       end
 
       context "destroy_all" do
-        should "work" do
+        it "should work" do
           @user.lists.count.should == 2
           @user.lists.destroy_all
           @user.lists.count.should == 0
         end
 
-        should "work with conditions" do
+        it "should work with conditions" do
           @user.lists.count.should == 2
           @user.lists.destroy_all(:name => 'Foo 1')
           @user.lists.count.should == 1
@@ -322,20 +322,20 @@ class InArrayProxyTest < Test::Unit::TestCase
       end
 
       context "delete_all" do
-        should "work" do
+        it "should work" do
           @user.lists.count.should == 2
           @user.lists.delete_all
           @user.lists.count.should == 0
         end
 
-        should "work with conditions" do
+        it "should work with conditions" do
           @user.lists.count.should == 2
           @user.lists.delete_all(:name => 'Foo 1')
           @user.lists.count.should == 1
         end
       end
 
-      should "work with nullify" do
+      it "should work with nullify" do
         @user.lists.count.should == 2
 
         lambda {

data/{test/functional/associations/test_many_documents_as_proxy.rb → spec/functional/associations/many_documents_as_proxy_spec.rb}

@@ -1,24 +1,23 @@
-require 'test_helper'
-require 'models'
+require 'spec_helper'
 
-class ManyDocumentsAsProxyTest < Test::Unit::TestCase
-  def setup
+describe "ManyDocumentsAsProxy" do
+  before do
     Post.collection.remove
     PostComment.collection.remove
   end
 
-  should "default reader to empty array" do
+  it "should default reader to empty array" do
     Post.new.comments.should == []
   end
 
-  should "add type and id key to polymorphic class base" do
+  it "should add type and id key to polymorphic class base" do
     PostComment.keys.keys.should include('commentable_type')
     PostComment.keys['commentable_type'].type.should == String
     PostComment.keys.keys.should include('commentable_id')
     PostComment.keys['commentable_id'].type.should == ObjectId
   end
 
-  should "allow adding to association like it was an array" do
+  it "should allow adding to association like it was an array" do
     post = Post.new
     post.comments << PostComment.new(:body => 'foo bar')
     post.comments << PostComment.new(:body => 'baz')
@@ -27,7 +26,7 @@ class ManyDocumentsAsProxyTest < Test::Unit::TestCase
     post.comments.size.should == 3
   end
 
-  should "be able to replace the association" do
+  it "should be able to replace the association" do
     post = Post.new
 
     lambda {
@@ -47,19 +46,19 @@ class ManyDocumentsAsProxyTest < Test::Unit::TestCase
   end
 
   context "build" do
-    should "assign foreign key" do
+    it "should assign foreign key" do
       post = Post.new
       comment = post.comments.build
       comment.commentable_id.should == post._id
     end
 
-    should "assign _type" do
+    it "should assign _type" do
       post = Post.new
       comment = post.comments.build
       comment.commentable_type.should == "Post"
     end
 
-    should "allow assigning attributes" do
+    it "should allow assigning attributes" do
       post = Post.new
       comment = post.comments.build(:body => 'foo bar')
       comment.body.should == 'foo bar'
@@ -67,26 +66,26 @@ class ManyDocumentsAsProxyTest < Test::Unit::TestCase
   end
 
   context "create" do
-    should "assign foreign key" do
+    it "should assign foreign key" do
       post = Post.new
       comment = post.comments.create
       comment.commentable_id.should == post._id
     end
 
-    should "assign _type" do
+    it "should assign _type" do
       post = Post.new
       comment = post.comments.create
       comment.commentable_type.should == "Post"
     end
 
-    should "save record" do
+    it "should save record" do
       post = Post.new
       lambda {
         post.comments.create(:body => 'baz')
       }.should change { PostComment.count }
     end
 
-    should "allow passing attributes" do
+    it "should allow passing attributes" do
       post = Post.create
       comment = post.comments.create(:body => 'foo bar')
       comment.body.should == 'foo bar'
@@ -94,7 +93,7 @@ class ManyDocumentsAsProxyTest < Test::Unit::TestCase
   end
 
   context "count" do
-    should "work scoped to association" do
+    it "should work scoped to association" do
       post = Post.create
       3.times { post.comments.create(:body => 'foo bar') }
 
@@ -105,7 +104,7 @@ class ManyDocumentsAsProxyTest < Test::Unit::TestCase
       other_post.comments.count.should == 2
     end
 
-    should "work with conditions" do
+    it "should work with conditions" do
       post = Post.create
       post.comments.create(:body => 'foo bar')
       post.comments.create(:body => 'baz')
@@ -116,7 +115,7 @@ class ManyDocumentsAsProxyTest < Test::Unit::TestCase
   end
 
   context "Finding scoped to association" do
-    setup do
+    before do
       @post = Post.new
 
       @comment1 = PostComment.create(:body => 'comment1', :name => 'John')
@@ -134,66 +133,66 @@ class ManyDocumentsAsProxyTest < Test::Unit::TestCase
     end
 
     context "with #all" do
-      should "work" do
+      it "should work" do
         @post.comments.all.should include(@comment1)
         @post.comments.all.should include(@comment2)
       end
 
-      should "work with conditions" do
+      it "should work with conditions" do
         comments = @post.comments.all(:body => 'comment1')
         comments.should == [@comment1]
       end
 
-      should "work with order" do
+      it "should work with order" do
         comments = @post.comments.all(:order => 'body desc')
         comments.should == [@comment2, @comment1]
       end
     end
 
     context "with one id" do
-      should "work for id in association" do
+      it "should work for id in association" do
         @post.comments.find(@comment2._id).should == @comment2
       end
 
-      should "not work for id not in association" do
-        assert_raises(MongoMapper::DocumentNotFound) do
+      it "should not work for id not in association" do
+        expect {
           @post.comments.find!(@comment5._id)
-        end
+        }.to raise_error(MongoMapper::DocumentNotFound)
       end
     end
 
     context "with multiple ids" do
-      should "work for ids in association" do
+      it "should work for ids in association" do
         posts = @post.comments.find!(@comment1._id, @comment2._id)
         posts.should == [@comment1, @comment2]
       end
 
-      should "not work for ids not in association" do
-        assert_raises(MongoMapper::DocumentNotFound) do
+      it "should not work for ids not in association" do
+        expect {
           @post.comments.find!(@comment1._id, @comment2._id, @comment4._id)
-        end
+        }.to raise_error(MongoMapper::DocumentNotFound)
       end
     end
 
     context "dynamic finders" do
-      should "work with single key" do
+      it "should work with single key" do
         @post.comments.find_by_body('comment1').should == @comment1
         @post2.comments.find_by_body('comment1').should == @comment4
       end
 
-      should "work with multiple keys" do
+      it "should work with multiple keys" do
         @post.comments.find_by_body_and_name('comment1', 'John').should == @comment1
         @post.comments.find_by_body_and_name('comment1', 'Frank').should be_nil
       end
 
-      should "raise error when using !" do
+      it "should raise error when using !" do
         lambda {
           @post.comments.find_by_body!('asdf')
         }.should raise_error(MongoMapper::DocumentNotFound)
       end
 
       context "find_or_create_by" do
-        should "not create document if found" do
+        it "should not create document if found" do
           lambda {
             comment = @post.comments.find_or_create_by_name('Steve')
             comment.commentable.should == @post
@@ -201,7 +200,7 @@ class ManyDocumentsAsProxyTest < Test::Unit::TestCase
           }.should_not change { PostComment.count }
         end
 
-        should "create document if not found" do
+        it "should create document if not found" do
           lambda {
             @post.comments.find_or_create_by_name('Chas')
           }.should change { PostComment.count }.by(1)
@@ -210,19 +209,19 @@ class ManyDocumentsAsProxyTest < Test::Unit::TestCase
     end
 
     context "with #paginate" do
-      setup do
+      before do
         @comments = @post2.comments.paginate(:per_page => 2, :page => 1, :order => 'name')
       end
 
-      should "return total pages" do
+      it "should return total pages" do
         @comments.total_pages.should == 2
       end
 
-      should "return total entries" do
+      it "should return total entries" do
         @comments.total_entries.should == 3
       end
 
-      should "return the subject" do
+      it "should return the subject" do
         @comments.should include(@comment4)
         @comments.should include(@comment5)
       end