mongomodel 0.5.5 → 0.5.6

data/spec/mongomodel/concerns/attribute_methods_spec.rb

@@ -5,58 +5,58 @@ module MongoModel
     describe "generating attribute methods" do
       define_class(:TestDocument, described_class) do
         property :foo, String
-        
+
         def foo(a); "from method"; end
       end
-      
+
       subject { TestDocument.new }
-      
+
       it "does not overwrite an existing method" do
         subject.foo(1).should == "from method"
       end
-      
+
       context "on a subclass" do
         define_class(:SubDocument, :TestDocument)
         subject { SubDocument.new }
-      
+
         it "does not overwrite methods defined on the superclass" do
           subject.foo(1).should == "from method"
         end
       end
-      
+
       context "on a class with an included module" do
         module TestModule
           def foo(a); "from method"; end
         end
-        
+
         it "does not overwrite methods defined on the included module" do
           TestDocument.send(:include, TestModule)
           subject.foo(1).should == "from method"
         end
       end
-      
+
       context "on a class with an included concern that defines the property" do
         define_module(:TestConcern) do
           extend ActiveSupport::Concern
-          
+
           included do
             property :bar, String
           end
-          
+
           def bar(a); "from concern"; end
         end
-        
+
         context "the base class" do
           it "does not overwrite methods defined within the concern" do
             TestDocument.send(:include, TestConcern)
             subject.bar(1).should == "from concern"
           end
         end
-        
+
         context "subclasses" do
           define_class(:SubDocument, :TestDocument)
           subject { SubDocument.new }
-          
+
           it "does not overwrite methods defined within the concern" do
             SubDocument.send(:include, TestConcern)
             subject.bar(1).should == "from concern"

data/spec/mongomodel/concerns/attributes_spec.rb

@@ -16,109 +16,109 @@ module MongoModel
     Time => Types::Time.new.cast(Time.now),
     DateTime => Types::DateTime.new.cast(DateTime.now.in_time_zone)
   }
-  
+
   specs_for(Document, EmbeddedDocument) do
     define_class(:TestDocument, described_class)
-    
+
     it "has an attributes store on the instance" do
       doc = TestDocument.new
       doc.attributes.should be_an_instance_of(MongoModel::Attributes::Store)
     end
-    
+
     it "converts to mongo representation" do
       doc = TestDocument.new
       doc.to_mongo.should == doc.attributes.to_mongo
     end
-    
+
     AttributeTypes.each do |type, value|
       describe "setting #{type} attributes" do
         define_class(:TestDocument, described_class) do
           property :test_property, type
         end
-        
+
         if specing?(EmbeddedDocument)
           define_class(:ParentDocument, Document) do
             property :child, TestDocument
           end
-          
+
           let(:parent) { ParentDocument.create!(:child => TestDocument.new(:test_property => value)) }
           let(:child) { parent.child }
           let(:reloaded) { ParentDocument.find(parent.id).child }
-          
+
           subject { child }
         else
           subject { TestDocument.create!(:test_property => value) }
-          
+
           let(:reloaded) { TestDocument.find(subject.id) }
         end
-        
+
         it "reads the correct value from attributes" do
           subject.test_property.should == value
         end
-      
+
         it "reads the correct value after reloading" do
           reloaded.test_property.should == subject.test_property
         end
       end
     end
-    
+
     it "has an attributes store" do
       doc = TestDocument.new
       doc.attributes.should be_an_instance_of(MongoModel::Attributes::Store)
     end
-    
+
     it "duplicates attributes when duplicating object" do
       original = TestDocument.new
       duplicate = original.dup
-      
+
       duplicate.attributes.should_not equal(original.attributes)
     end
-    
+
     describe "initializing" do
       define_class(:Person, EmbeddedDocument) do
         property :name, String
         property :age, Integer, :default => 21
       end
-      
+
       it "is initializable with attributes hash" do
         doc = Person.new(:name => 'Fred', :age => 42)
         doc.name.should == 'Fred'
         doc.age.should == 42
       end
-      
+
       it "uses default attributes when initializing with partial attributes hash" do
         doc = Person.new(:name => 'Maurice')
         doc.age.should == 21
       end
-      
+
       it "loads from mongo representation" do
         doc = Person.from_mongo({ 'name' => 'James', 'age' => 15 })
         doc.name.should == 'James'
         doc.age.should == 15
       end
     end
-    
+
     describe "setting attributes with hash" do
       define_class(:TestDocument, described_class) do
         property :test_property, String
-        
+
         def test_property=(value)
           write_attribute(:test_property, 'set from method')
         end
       end
-      
+
       subject { TestDocument.new }
-      
+
       it "calls custom property methods" do
         subject.attributes = { :test_property => 'property value' }
         subject.test_property.should == 'set from method'
       end
-      
+
       it "uses write_attribute if no such property" do
         subject.attributes = { :non_property => 'property value' }
         subject.read_attribute(:non_property).should == 'property value'
       end
-      
+
       if defined?(ActiveModel::ForbiddenAttributesProtection)
         it "raises ActiveModel::ForbiddenAttributesError when passed an unpermitted strong_params hash" do
           expect {
@@ -127,35 +127,35 @@ module MongoModel
         end
       end
     end
-    
+
     describe "#new" do
       define_class(:TestDocument, described_class)
-      
+
       it "yields the instance to a block if provided" do
         block_called = false
-        
+
         TestDocument.new do |doc|
           block_called = true
           doc.should be_an_instance_of(TestDocument)
         end
-        
-        block_called.should be_true
+
+        block_called.should be true
       end
     end
-    
+
     context "a frozen instance" do
       define_class(:TestDocument, described_class) do
         property :test_property, String
       end
-      
+
       subject { TestDocument.new(:test_property => 'Test') }
-      
+
       before(:each) { subject.freeze }
-      
+
       it { should be_frozen }
-      
+
       it "does not allow changes to the attributes hash" do
-        lambda { subject.attributes[:test_property] = 'Change' }.should raise_error
+        lambda { subject.attributes[:test_property] = 'Change' }.should raise_error(RuntimeError)
       end
     end
   end

data/spec/mongomodel/concerns/callbacks_spec.rb

@@ -7,11 +7,11 @@ module MongoModel
         include MongoModel::CallbackHelpers
         property :name, String
       end
-      
+
       define_class(:ParentDocument, Document) do
         property :things, Collection[ChildThingDocument]
       end
-            
+
       it "calls callbacks on all embedded documents when adding a new one" do
         parent = ParentDocument.create!
         parent.things = Collection[ChildThingDocument].new
@@ -22,84 +22,88 @@ module MongoModel
         parent.save!
       end
     end
-    
+
     describe "callbacks" do
       define_class(:ChildDocument, EmbeddedDocument) do
         include MongoModel::CallbackHelpers
       end
-      
+
       define_class(:ParentDocument, Document) do
         property :child, ChildDocument
       end
-      
+
       let(:child) { ChildDocument.new }
       let(:parent) { ParentDocument.create!(:child => child) }
-      
+
       it "runs each type of callback when initializing" do
         instance = ChildDocument.new
         instance.should run_callbacks(:after_initialize)
       end
-      
+
       it "runs each type of callback on find" do
         instance = ParentDocument.find(parent.id).child
         instance.should run_callbacks(:after_initialize, :after_find)
       end
-      
+
       it "runs each type of callback when validating a new document" do
         instance = ChildDocument.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 = ParentDocument.find(parent.id).child
         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 = ParentDocument.create!(:child => ChildDocument.new)
         instance.child.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 = ParentDocument.find(parent.id)
         instance.save
         instance.child.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 = ParentDocument.find(parent.id)
         instance.destroy
         instance.child.should run_callbacks(:after_initialize, :after_find, :before_destroy, :after_destroy)
       end
-      
+
       it "does not run destroy callbacks when deleting a document" do
         instance = ParentDocument.find(parent.id)
         instance.delete
         instance.child.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(:ChildDocument, EmbeddedDocument) 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
-    
+
         define_class(:ParentDocument, Document) do
           property :child, ChildDocument
         end
-    
+
         let(:child) { ChildDocument.new }
         let(:parent) { ParentDocument.new(:child => child) }
-        
+
         describe "#save" do
           it "returns false" do
-            parent.save.should be_false
+            parent.save.should be false
           end
         end
-      
+
         describe "#save!" do
           it "raises a MongoModel::DocumentNotSaved exception" do
             lambda { parent.save! }.should raise_error(MongoModel::DocumentNotSaved)

data/spec/mongomodel/concerns/logging_spec.rb

@@ -4,14 +4,16 @@ module MongoModel
   specs_for(Document, EmbeddedDocument) do
     describe "logging" do
       define_class(:TestDocument, described_class)
-      
+
       let(:logger) { double('logger').as_null_object }
+
       before(:each) { MongoModel.logger = logger }
-      
+      after(:each) { MongoModel.logger = nil }
+
       it "has a logger reader on the class" do
         TestDocument.logger.should == logger
       end
-      
+
       it "has a logger reader on the instance" do
         TestDocument.new.logger.should == logger
       end

data/spec/mongomodel/concerns/map_reduce_spec.rb

@@ -5,20 +5,20 @@ module MongoModel
     describe "counting tags" do
       # This example is extracted from the Counting Tags pattern in the
       # MongoDB Cookbook: http://cookbook.mongodb.org/patterns/count_tags/
-      
+
       define_class(:Article, Document) do
         property :tags, Collection[String]
       end
-    
+
       define_class(:Tag, Struct.new(:name, :count)) do
         include MongoModel::MapReduce
-      
+
         self.parent_collection = Article.collection
-      
+
         def initialize(name, count)
           super(name, count.to_i)
         end
-      
+
         def self.map_function
           <<-MAP
           function() {
@@ -45,58 +45,58 @@ module MongoModel
           REDUCE
         end
       end
-    
+
       specify "tag comparison" do
         Tag.new("Tag 1", 1).should == Tag.new("Tag 1", 1)
         Tag.new("Tag 2", 1).should_not == Tag.new("Tag 1", 1)
         Tag.new("Tag 1", 1).should_not == Tag.new("Tag 1", 2)
       end
-    
+
       before do
         Article.create!(:tags => ["Tag 1", "Tag 2"])
         Article.create!(:tags => ["Tag 2"])
         Article.create!(:tags => ["Tag 3"])
       end
-    
+
       it "has a default collection name based on the parent collection" do
         Tag.collection_name.should == "articles._tags"
       end
-    
+
       it "stores the result in a named collection" do
         Tag.collection.name.should == Tag.collection_name
       end
-    
+
       it "allows use of scope methods" do
         Tag.all.should == [Tag.new("Tag 1", 1), Tag.new("Tag 2", 2), Tag.new("Tag 3", 1)]
         Tag.order(:value.desc).first.should == Tag.new("Tag 2", 2)
         Tag.where(:value.gt => 1).should == [Tag.new("Tag 2", 2)]
       end
-    
+
       it "loads previously computed results" do
         expected = Tag.all
         Article.create!(:tags => ["Tag 1"])
         Tag.cached.should == expected
       end
     end
-    
+
     describe "pivot data" do
       # This example is similar to the Pivot Data pattern in the
       # MongoDB Cookbook: http://cookbook.mongodb.org/patterns/pivot/
-      
+
       define_class(:Actor, Document) do
         property :name, String
         property :movies, Collection[String]
       end
-      
+
       define_class(:Movie, Struct.new(:name, :actors)) do
         include MongoModel::MapReduce
-      
+
         self.parent_collection = Actor.collection
-        
+
         def self.from_mongo(attrs)
           new(attrs['_id'], attrs['value']['actors'].sort)
         end
-        
+
         def self.map_function
           <<-MAP
           function() {
@@ -121,12 +121,12 @@ module MongoModel
           REDUCE
         end
       end
-      
+
       before do
         Actor.create!(:name => "Richard Gere", :movies => ['Pretty Woman', 'Runaway Bride', 'Chicago'])
         Actor.create!(:name => "Julia Roberts", :movies => ['Pretty Woman', 'Runaway Bride', 'Erin Brockovich'])
       end
-      
+
       it "pivots data" do
         Movie.all.should include(
           Movie.new("Pretty Woman", ["Julia Roberts", "Richard Gere"]),