mongomodel 0.5.5 → 0.5.6

data/spec/mongomodel/document/callbacks_spec.rb

@@ -6,69 +6,73 @@ module MongoModel
       define_class(:CallbackTestDocument, Document) do
         include MongoModel::CallbackHelpers
       end
-      
+
       let(:doc) { CallbackTestDocument.create! }
-      
+
       it "runs each type of callback when initializing" do
         instance = CallbackTestDocument.new
         instance.should run_callbacks(:after_initialize)
       end
-  
+
       it "runs each type of callback on find" do
         instance = CallbackTestDocument.find(doc.id)
         instance.should run_callbacks(:after_initialize, :after_find)
       end
-  
+
       it "runs each type of callback when validating a new document" do
         instance = CallbackTestDocument.new
         instance.valid?
         instance.should run_callbacks(:after_initialize, :before_validation, :after_validation)
       end
-  
+
       it "runs each type of callback when validating an existing document" do
         instance = CallbackTestDocument.find(doc.id)
         instance.valid?
         instance.should run_callbacks(:after_initialize, :after_find, :before_validation, :after_validation)
       end
-  
+
       it "runs each type of callback when creating a document" do
         instance = CallbackTestDocument.create!
         instance.should run_callbacks(:after_initialize, :before_validation, :after_validation, :before_save, :before_create, :after_create, :after_save)
       end
-  
+
       it "runs each type of callback when saving an existing document" do
         instance = CallbackTestDocument.find(doc.id)
         instance.save
         instance.should run_callbacks(:after_initialize, :after_find, :before_validation, :after_validation, :before_save, :before_update, :after_update, :after_save)
       end
-  
+
       it "runs each type of callback when destroying a document" do
         instance = CallbackTestDocument.find(doc.id)
         instance.destroy
         instance.should run_callbacks(:after_initialize, :after_find, :before_destroy, :after_destroy)
       end
-  
+
       it "does not run destroy callbacks when deleting a document" do
         instance = CallbackTestDocument.find(doc.id)
         instance.delete
         instance.should run_callbacks(:after_initialize, :after_find)
       end
     end
-      
+
     [ :before_save, :before_create ].each do |callback|
-      context "#{callback} callback return false" do
+      context "#{callback} callback halts" do
         define_class(:CallbackTestDocument, Document) do
-          send(callback) { false }
+          if Gem::Version.new(ActiveSupport::VERSION::STRING) >= Gem::Version.new('5.0.0')
+            send(callback) { throw :abort }
+          else
+            send(callback) { false }
+          end
         end
-      
+
         subject { CallbackTestDocument.new }
-      
+
         describe "#save" do
           it "returns false" do
-            subject.save.should be_false
+            subject.save.should be false
           end
         end
-      
+
         describe "#save!" do
           it "raises a MongoModel::DocumentNotSaved exception" do
             lambda { subject.save! }.should raise_error(MongoModel::DocumentNotSaved)

data/spec/mongomodel/document/collection_modifiers_spec.rb

@@ -8,96 +8,96 @@ module MongoModel
         property :available, Integer
         property :tags, Array
       end
-      
+
       let(:collection) { Post.collection }
       subject { Post }
-      
+
       def self.should_update_collection(expression, &block)
         it "updates the collection" do
           collection.should_receive(:update).with(selector, expression, :multi => true)
           instance_eval(&block)
         end
       end
-      
+
       shared_examples_for "collection modifiers" do
         describe "increment!" do
           should_update_collection('$inc' => { 'hits' => 1, 'available' => -1 }) do
             subject.increment!(:hits => 1, :available => -1)
           end
         end
-        
+
         describe "increase! (alias of increment!)" do
           should_update_collection('$inc' => { 'hits' => 1, 'available' => -1 }) do
             subject.increase!(:hits => 1, :available => -1)
           end
         end
-      
+
         describe "set!" do
           should_update_collection('$set' => { 'hits' => 20, 'available' => 100 }) do
             subject.set!(:hits => 20, :available => 100)
           end
         end
-        
+
         describe "unset!" do
           should_update_collection('$unset' => { 'hits' => 1, 'available' => 1 }) do
             subject.unset!(:hits, :available)
           end
         end
-        
+
         describe "push!" do
           should_update_collection('$push' => { 'tags' => 'abc' }) do
             subject.push!(:tags => 'abc')
           end
         end
-        
+
         describe "push_all!" do
           should_update_collection('$pushAll' => { 'tags' => ['xxx', 'yyy', 'zzz'] }) do
             subject.push_all!(:tags => ['xxx', 'yyy', 'zzz'])
           end
         end
-        
+
         describe "add_to_set!" do
           should_update_collection('$addToSet' => { 'tags' => 'xxx' }) do
             subject.add_to_set!(:tags => 'xxx')
           end
         end
-        
+
         describe "pull!" do
           should_update_collection('$pull' => { 'tags' => 'abc' }) do
             subject.pull!(:tags => 'abc')
           end
         end
-        
+
         describe "pull_all!" do
           should_update_collection('$pullAll' => { 'tags' => ['xxx', 'yyy', 'zzz'] }) do
             subject.pull_all!(:tags => ['xxx', 'yyy', 'zzz'])
           end
         end
-        
+
         describe "pop!" do
           should_update_collection('$pop' => { 'tags' => 1 }) do
             subject.pop!(:tags)
           end
         end
-        
+
         describe "shift!" do
           should_update_collection('$pop' => { 'tags' => -1 }) do
             subject.shift!(:tags)
           end
         end
-        
+
         describe "rename!" do
           should_update_collection('$rename' => { 'tags' => :tag_collection }) do
             subject.rename!(:tags => :tag_collection)
           end
         end
       end
-      
+
       describe "class methods" do
         let(:selector) { {} }
         it_should_behave_like "collection modifiers"
       end
-      
+
       describe "instance methods" do
         subject { Post.new }
         before { subject.save }

data/spec/mongomodel/document/dynamic_finders_spec.rb

@@ -7,9 +7,9 @@ module MongoModel
         property :name, String
         property :age, Integer
       end
-      
+
       subject { Person }
-      
+
       before(:each) do
         @john = Person.create!(:name => 'John', :age => 42, :id => '1')
         @young_john = Person.create!(:name => 'John', :age => 12, :id => '2')
@@ -17,163 +17,163 @@ module MongoModel
         @tom2 = Person.create!(:name => 'Tom', :age => 23, :id => '4')
         @mary = Person.create!(:name => 'Mary', :age => 33, :id => '5')
       end
-      
+
       def self.should_find(*args, &block)
         it "returns correct results when called with #{args.inspect}" do
           expected = instance_eval(&block)
           subject.send(valid_finder, *args).should == expected
         end
       end
-      
+
       def self.should_raise(*args, &block)
         it "raises DocumentNotFound exception if results not found" do
           message = instance_eval(&block)
           lambda { subject.send(valid_finder, *args) }.should raise_error(DocumentNotFound, message)
         end
       end
-      
+
       def self.should_initialize(*args, &block)
         it "initializes new instance" do
           result = subject.send(valid_finder, *args)
           result.should be_a_new_record
           result.should be_an_instance_of(Person)
-          yield(result).should be_true
+          yield(result).should be true
         end
       end
-      
+
       def self.should_create(*args, &block)
         it "creates new instance" do
           result = subject.send(valid_finder, *args)
           result.should_not be_a_new_record
           result.should be_an_instance_of(Person)
-          yield(result).should be_true
+          yield(result).should be true
         end
       end
-      
+
       shared_examples_for "a dynamic finder" do
         it { should respond_to(valid_finder) }
         it { should_not respond_to(invalid_finder) }
-        
+
         it "raises NoMethodError calling an invalid finder" do
           lambda { subject.send(invalid_finder, "Foo") }.should raise_error(NoMethodError)
         end
       end
-      
+
       describe "find first by single property" do
         let(:valid_finder) { :find_by_name }
         let(:invalid_finder) { :find_by_something_else }
-        
+
         it_should_behave_like "a dynamic finder"
-        
+
         should_find("John") { @john }
         should_find("Jane") { nil }
       end
-      
+
       describe "find first by single property (bang method)" do
         let(:valid_finder) { :find_by_name! }
         let(:invalid_finder) { :find_by_something_else! }
-        
+
         it_should_behave_like "a dynamic finder"
-        
+
         should_find("John") { @john }
         should_raise("Jane") { 'Couldn\'t find Person with {:name=>"Jane"}' }
       end
-      
+
       describe "find last by single property" do
         let(:valid_finder) { :find_last_by_name }
         let(:invalid_finder) { :find_last_by_something_else }
-        
+
         it_should_behave_like "a dynamic finder"
-        
+
         should_find("John") { @young_john }
         should_find("Jane") { nil }
       end
-      
+
       describe "find all by single property" do
         let(:valid_finder) { :find_all_by_name }
         let(:invalid_finder) { :find_all_by_something_else }
-        
+
         it_should_behave_like "a dynamic finder"
-        
+
         should_find("John") { [@john, @young_john] }
       end
-      
+
       describe "find first by multiple properties" do
         let(:valid_finder) { :find_by_name_and_age }
         let(:invalid_finder) { :find_by_age_and_something_else }
-        
+
         it_should_behave_like "a dynamic finder"
-        
+
         should_find("Tom", 23) { @tom1 }
         should_find("Tom", 5) { nil }
       end
-      
+
       describe "find first by multiple properties (bang method)" do
         let(:valid_finder) { :find_by_name_and_age! }
         let(:invalid_finder) { :find_by_age_and_something_else! }
-        
+
         it_should_behave_like "a dynamic finder"
-        
+
         should_find("Tom", 23) { @tom1 }
         should_raise("Tom", 5) { "Couldn\'t find Person with #{{:name=>"Tom", :age=>5}.inspect}" }
       end
-      
+
       describe "find all by multiple properties" do
         let(:valid_finder) { :find_all_by_name_and_age }
         let(:invalid_finder) { :find_all_by_age_and_something_else }
-        
+
         it_should_behave_like "a dynamic finder"
-        
+
         should_find("Tom", 23) { [@tom1, @tom2] }
         should_find("Tom", 5) { [] }
       end
-      
+
       describe "find last by multiple properties" do
         let(:valid_finder) { :find_last_by_name_and_age }
         let(:invalid_finder) { :find_last_by_age_and_something_else }
-        
+
         it_should_behave_like "a dynamic finder"
-        
+
         should_find("Tom", 23) { @tom2 }
         should_find("Tom", 5) { nil }
       end
-      
+
       describe "find or initialize by single property" do
         let(:valid_finder) { :find_or_initialize_by_name }
         let(:invalid_finder) { :find_or_initialize_by_something_else }
-        
+
         it_should_behave_like "a dynamic finder"
-        
+
         should_find("John") { @john }
         should_initialize("Jane") { |p| p.name == "Jane" }
       end
-      
+
       describe "find or initialize by multiple properties" do
         let(:valid_finder) { :find_or_initialize_by_name_and_age }
         let(:invalid_finder) { :find_or_initialize_by_name_and_something_else }
-        
+
         it_should_behave_like "a dynamic finder"
-        
+
         should_find("John", 42) { @john }
         should_initialize("John", 1) { |p| p.name == "John" && p.age == 1 }
       end
-      
+
       describe "find or create by single property" do
         let(:valid_finder) { :find_or_create_by_name }
         let(:invalid_finder) { :find_or_create_by_something_else }
-        
+
         it_should_behave_like "a dynamic finder"
-        
+
         should_find("John") { @john }
         should_create("Jane") { |p| p.name == "Jane" }
       end
-      
+
       describe "find or create by multiple properties" do
         let(:valid_finder) { :find_or_create_by_name_and_age }
         let(:invalid_finder) { :find_or_create_by_name_and_something_else }
-        
+
         it_should_behave_like "a dynamic finder"
-        
+
         should_find("John", 42) { @john }
         should_create("John", 1) { |p| p.name == "John" && p.age == 1 }
       end

data/spec/mongomodel/document/finders_spec.rb

@@ -6,36 +6,36 @@ module MongoModel
       property :name, String
       property :age, Integer
     end
-    
+
     define_class(:NonUser, Document)
-    
+
     describe "#find" do
       before(:each) do
         User.collection.save({ '_id' => '1', 'name' => 'Fred', :age => 45 })
         User.collection.save({ '_id' => '2', 'name' => 'Alistair', :age => 18 })
         User.collection.save({ '_id' => '3', 'name' => 'Barney', :age => 10 })
       end
-      
+
       describe "by id" do
         context "document exists" do
           subject { User.find('2') }
-          
+
           it "returns a User" do
             subject.should be_a(User)
           end
-          
+
           it "loads the document attributes" do
             subject.id.should == '2'
             subject.name.should == 'Alistair'
           end
-          
+
           it { should_not be_a_new_record }
-          
+
           it "stringifies ids" do
             User.find(2).id.should == '2'
           end
         end
-        
+
         context "document does not exist" do
           it "raises a DocumentNotFound exception" do
             lambda {
@@ -43,37 +43,37 @@ module MongoModel
             }.should raise_error(MongoModel::DocumentNotFound)
           end
         end
-        
+
         context "no id specified" do
           it "raises an ArgumentError" do
-            lambda { 
+            lambda {
               User.find
             }.should raise_error(ArgumentError)
           end
         end
       end
-      
+
       describe "by multiple ids" do
         context "all documents exist" do
           subject { User.find('1', '2') }
-          
+
           it "returns an array of Users" do
             subject[0].should be_a(User)
             subject[1].should be_a(User)
           end
-          
+
           it "loads document attributes" do
             subject[0].name.should == 'Fred'
             subject[1].name.should == 'Alistair'
           end
-          
+
           it "loads documents in correct order" do
             result = User.find('2', '1')
             result[0].id.should == '2'
             result[1].id.should == '1'
           end
         end
-        
+
         context "some documents missing" do
           it "raises a DocumentNotFound exception" do
             lambda {