lookout-mongo_mapper 0.11.3

data/test/functional/test_accessible.rb

@@ -0,0 +1,198 @@
+require 'test_helper'
+
+class AccessibleTest < Test::Unit::TestCase
+  context 'A document with accessible attributes' do
+    setup do
+      @doc_class = Doc do
+        key :name, String
+        key :admin, Boolean, :default => false
+
+        attr_accessible :name
+      end
+
+      @doc = @doc_class.create(:name => 'Steve Sloan')
+    end
+
+    should 'have accessible attributes class method' do
+      @doc_class.accessible_attributes.should == [:name].to_set
+    end
+
+    should "default accessible attributes to nil" do
+      Doc().accessible_attributes.should be_nil
+    end
+
+    should "have accessible_attributes instance method" do
+      @doc.accessible_attributes.should equal(@doc_class.accessible_attributes)
+    end
+
+    should "raise error if there are protected attributes" do
+      doc = Doc('Post')
+      doc.attr_protected :admin
+      lambda { doc.attr_accessible :name }.
+        should raise_error(/Declare either attr_protected or attr_accessible for Post/)
+    end
+
+    should "know if using accessible attributes" do
+      @doc_class.accessible_attributes?.should be(true)
+      Doc().accessible_attributes?.should be(false)
+    end
+
+    should "assign inaccessible attribute through accessor" do
+      @doc.admin = true
+      @doc.admin.should be_true
+    end
+
+    should "ignore inaccessible attribute on #initialize" do
+      doc = @doc_class.new(:name => 'John', :admin => true)
+      doc.admin.should be_false
+      doc.name.should == 'John'
+    end
+
+    should "not ignore inaccessible attributes on #initialize from the database" do
+      doc = @doc_class.new(:name => 'John')
+      doc.admin = true
+      doc.save!
+
+      doc = @doc_class.first(:name => 'John')
+      doc.admin.should be_true
+      doc.name.should == 'John'
+    end
+
+    should "not ignore inaccessible attributes on #reload" do
+      doc = @doc_class.new(:name => 'John')
+      doc.admin = true
+      doc.save!
+
+      doc.reload
+      doc.admin.should be_true
+      doc.name.should == 'John'
+    end
+
+    should "not ignore inaccessible attribute on #update_attribute" do
+      @doc.update_attribute('admin', true)
+      @doc.admin.should be_true
+    end
+
+    should "ignore inaccessible attribute on #update_attributes" do
+      @doc.update_attributes(:name => 'Ren Hoek', :admin => true)
+      @doc.name.should == 'Ren Hoek'
+      @doc.admin.should be_false
+    end
+
+    should "ignore inaccessible attribute on #update_attributes!" do
+      @doc.update_attributes!(:name => 'Stimpson J. Cat', :admin => true)
+      @doc.name.should == 'Stimpson J. Cat'
+      @doc.admin.should be_false
+    end
+
+    should "ignore inaccessible attribute on #attributes=" do
+      @doc.attributes = {:name => 'Ren Hoek', :admin => true}
+      @doc.name.should == 'Ren Hoek'
+      @doc.admin.should be_false
+    end
+
+    should "be indifferent to whether the accessible keys are strings or symbols" do
+      @doc.update_attributes!("name" => 'Stimpson J. Cat', "admin" => true)
+      @doc.name.should == 'Stimpson J. Cat'
+      @doc.admin.should be_false
+    end
+
+    should "accept nil as constructor's argument without raising exception" do
+      lambda { @doc_class.new(nil) }.should_not raise_error
+    end
+
+    should "ignore all attributes if called with no args" do
+      @doc_class = Doc do
+        key :name
+        attr_accessible
+      end
+
+      @doc_class.new(:name => 'Steve Sloan').name.should be_nil
+    end
+  end
+
+  context "Single collection inherited accessible attributes" do
+    setup do
+      class ::GrandParent
+        include MongoMapper::Document
+        attr_accessible :name
+        key :name, String
+        key :site_id, ObjectId
+      end
+      GrandParent.collection.remove
+
+      class ::Child < ::GrandParent
+        attr_accessible :position
+        key :position, Integer
+      end
+
+      class ::GrandChild < ::Child; end
+
+      class ::OtherChild < ::GrandParent
+        attr_accessible :favorite_color
+        key :favorite_color, String
+        key :blog_id, ObjectId
+      end
+    end
+
+    teardown do
+      Object.send :remove_const, 'GrandParent' if defined?(::GrandParent)
+      Object.send :remove_const, 'Child'       if defined?(::Child)
+      Object.send :remove_const, 'GrandChild'  if defined?(::GrandChild)
+      Object.send :remove_const, 'OtherChild'  if defined?(::OtherChild)
+    end
+
+    should "share keys down the inheritance trail" do
+      GrandParent.accessible_attributes.should == [:name].to_set
+      Child.accessible_attributes.should == [:name, :position].to_set
+      GrandChild.accessible_attributes.should == [:name, :position].to_set
+      OtherChild.accessible_attributes.should == [:name, :favorite_color].to_set
+    end
+  end
+
+  context "An embedded document with accessible attributes" do
+    setup do
+      @doc_class = Doc('Project')
+      @edoc_class = EDoc('Person') do
+        key :name, String
+        key :admin, Boolean, :default => false
+
+        attr_accessible :name
+      end
+      @doc_class.many :people, :class => @edoc_class
+
+      @doc = @doc_class.create(:title => 'MongoMapper')
+      @edoc = @edoc_class.new(:name => 'Steve Sloan')
+      @doc.people << @edoc
+    end
+
+    should "have accessible attributes class method" do
+      @edoc_class.accessible_attributes.should == [:name].to_set
+    end
+
+    should "default accessible attributes to nil" do
+      EDoc().accessible_attributes.should be_nil
+    end
+
+    should "have accessible attributes instance method" do
+      @edoc.accessible_attributes.should equal(@edoc_class.accessible_attributes)
+    end
+
+    should "assign inaccessible attribute through accessor" do
+      @edoc.admin = true
+      @edoc.admin.should be_true
+    end
+
+    should "ignore inaccessible attribute on #update_attributes" do
+      @edoc.update_attributes(:name => 'Ren Hoek', :admin => true)
+      @edoc.name.should == 'Ren Hoek'
+      @edoc.admin.should be_false
+    end
+
+    should "ignore inaccessible attribute on #update_attributes!" do
+      @edoc.update_attributes!(:name => 'Stimpson J. Cat', :admin => true)
+      @edoc.name.should == 'Stimpson J. Cat'
+      @edoc.admin.should be_false
+    end
+  end
+end

data/test/functional/test_associations.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+require 'models'
+
+class AssociationsTest < Test::Unit::TestCase
+  should "allow changing class names" do
+    class AwesomeUser
+      include MongoMapper::Document
+
+      many :posts, :class_name => 'AssociationsTest::AwesomePost', :foreign_key => :creator_id
+    end
+    AwesomeUser.collection.remove
+
+    class AwesomeTag
+      include MongoMapper::EmbeddedDocument
+
+      key :name, String
+      key :post_id, ObjectId
+
+      belongs_to :post, :class_name => 'AssociationsTest::AwesomeUser'
+    end
+
+    class AwesomePost
+      include MongoMapper::Document
+
+      key :creator_id, ObjectId
+
+      belongs_to :creator, :class_name => 'AssociationsTest::AwesomeUser'
+      many :tags, :class_name => 'AssociationsTest::AwesomeTag', :foreign_key => :post_id
+    end
+
+    AwesomeUser.collection.remove
+    AwesomePost.collection.remove
+
+    user = AwesomeUser.create
+    tag1 = AwesomeTag.new(:name => 'awesome')
+    tag2 = AwesomeTag.new(:name => 'grand')
+    post1 = AwesomePost.create(:creator => user, :tags => [tag1])
+    post2 = AwesomePost.create(:creator => user, :tags => [tag2])
+
+    user.reload
+    user.posts.should == [post1, post2]
+
+    post1 = post1.reload
+    post1.tags.should == [tag1]
+  end
+end

data/test/functional/test_binary.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class BinaryTest < Test::Unit::TestCase
+  should "serialize and deserialize correctly" do
+    klass = Doc do
+      key :contents, Binary
+    end
+
+    doc = klass.new(:contents => '010101')
+    doc.save
+
+    doc = doc.reload
+    doc.contents.to_s.should == BSON::Binary.new('010101').to_s
+  end
+
+  context "Saving a document with a blank binary value" do
+    setup do
+      @document = Doc do
+        key :file, Binary
+      end
+    end
+
+    should "not fail" do
+      assert_nothing_raised { @document.new(:file => nil).save }
+    end
+  end
+end

data/test/functional/test_caching.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+
+class CachingTest < Test::Unit::TestCase
+  context "Caching" do
+    setup do
+      @klass = Class.new do
+        extend MongoMapper::Plugins
+        plugin MongoMapper::Plugins::Caching
+      end
+      @klass.stubs(:name).returns('Post')
+      @klass.any_instance.stubs(:persisted?).returns(true)
+      @klass.any_instance.stubs(:[]).returns(nil)
+      @klass.any_instance.stubs(:[]=).returns(nil)
+    end
+
+    context "new" do
+      setup do
+        @doc = @klass.new
+        @doc.stubs(:persisted?).returns(false)
+      end
+
+      should "be class/new" do
+        @doc.cache_key.should == 'Post/new'
+      end
+
+      should "work with suffix" do
+        @doc.cache_key(:foo).
+          should == 'Post/new/foo'
+
+        @doc.cache_key(:foo, :bar).
+          should == 'Post/new/foo/bar'
+      end
+    end
+
+    context "not new" do
+      setup do
+        @object_id = BSON::ObjectId.new
+        @doc = @klass.new
+        @doc.stubs(:persisted).returns(true)
+        @doc.stubs(:id).returns(@object_id)
+      end
+
+      context "with updated_at" do
+        setup do
+          time = Time.utc(2010, 6, 20, 8, 10, 7)
+          @doc.stubs(:[]).with(:updated_at).returns(time)
+        end
+
+        should "be class/id-timestamp" do
+          @doc.cache_key.should == "Post/#{@object_id}-20100620081007"
+        end
+
+        should "work with suffix" do
+          @doc.cache_key(:foo).
+            should == "Post/#{@object_id}-20100620081007/foo"
+
+          @doc.cache_key(:foo, :bar).
+            should == "Post/#{@object_id}-20100620081007/foo/bar"
+        end
+      end
+
+      context "without updated_at" do
+        should "be class/id" do
+          @doc.cache_key.should == "Post/#{@object_id}"
+        end
+
+        should "work with suffix" do
+          @doc.cache_key(:foo).
+            should == "Post/#{@object_id}/foo"
+
+          @doc.cache_key(:foo, :bar, :baz).
+            should == "Post/#{@object_id}/foo/bar/baz"
+        end
+      end
+    end
+  end
+end

data/test/functional/test_callbacks.rb

@@ -0,0 +1,232 @@
+require 'test_helper'
+
+module CallbacksSupport
+  def self.included base
+    base.key :name, String
+
+    [ :before_validation, :after_validation,
+      :before_create,     :after_create,
+      :before_update,     :after_update,
+      :before_save,       :after_save,
+      :before_destroy,    :after_destroy
+    ].each do |callback|
+      base.send(callback) do
+        history << callback.to_sym
+      end
+    end
+  end
+
+  def history
+    @history ||= []
+  end
+
+  def clear_history
+    embedded_associations.each { |a| self.send(a.name).each(&:clear_history) }
+    @history = nil
+  end
+end
+
+class CallbacksTest < Test::Unit::TestCase
+  CreateCallbackOrder = [
+    :before_validation,
+    :after_validation,
+    :before_save,
+    :before_create,
+    :after_create,
+    :after_save
+  ]
+
+  UpdateCallbackOrder = [
+    :before_validation,
+    :after_validation,
+    :before_save,
+    :before_update,
+    :after_update,
+    :after_save
+  ]
+
+  context "Defining and running callbacks on documents" do
+    setup do
+      @document = Doc { include CallbacksSupport }
+    end
+
+    should "get the order right for creating documents" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.history.should == CreateCallbackOrder
+    end
+
+    should "get the order right for updating documents" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.clear_history
+      doc.name = 'John'
+      doc.save
+      doc.history.should == UpdateCallbackOrder
+    end
+
+    should "work for before and after validation" do
+      doc = @document.new(:name => 'John Nunemaker')
+      doc.valid?
+      doc.history.should include(:before_validation)
+      doc.history.should include(:after_validation)
+    end
+
+    should "work for before and after create" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.history.should include(:before_create)
+      doc.history.should include(:after_create)
+    end
+
+    should "work for before and after update" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.name = 'John Doe'
+      doc.save
+      doc.history.should include(:before_update)
+      doc.history.should include(:after_update)
+    end
+
+    should "work for before and after save" do
+      doc = @document.new
+      doc.name = 'John Doe'
+      doc.save
+      doc.history.should include(:before_save)
+      doc.history.should include(:after_save)
+    end
+
+    should "work for before and after destroy" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.destroy
+      doc.history.should include(:before_destroy)
+      doc.history.should include(:after_destroy)
+    end
+  end
+
+  context "Defining and running callbacks on many embedded documents" do
+    setup do
+      @root_class        = Doc  { include CallbacksSupport }
+      @child_class       = EDoc { include CallbacksSupport }
+      @grand_child_class = EDoc { include CallbacksSupport }
+
+      @root_class.many  :children, :class => @child_class
+      @child_class.many :children, :class => @grand_child_class
+    end
+
+    should "get the order right based on root document creation" do
+      grand = @grand_child_class.new(:name => 'Grand Child')
+      child = @child_class.new(:name => 'Child', :children => [grand])
+      root  = @root_class.create(:name => 'Parent', :children => [child])
+
+      root.children.first.history.should == CreateCallbackOrder
+      root.children.first.children.first.history.should == CreateCallbackOrder
+    end
+
+    should "get the order right based on root document updating" do
+      grand = @grand_child_class.new(:name => 'Grand Child')
+      child = @child_class.new(:name => 'Child', :children => [grand])
+      root  = @root_class.create(:name => 'Parent', :children => [child])
+      root.clear_history
+      root.update_attributes(:name => 'Updated Parent')
+
+      root.children.first.history.should == UpdateCallbackOrder
+      root.children.first.children.first.history.should == UpdateCallbackOrder
+    end
+
+    should "work for before and after destroy" do
+      grand = @grand_child_class.new(:name => 'Grand Child')
+      child = @child_class.new(:name => 'Child', :children => [grand])
+      root  = @root_class.create(:name => 'Parent', :children => [child])
+      root.destroy
+      child = root.children.first
+      child.history.should include(:before_destroy)
+      child.history.should include(:after_destroy)
+
+      grand = root.children.first.children.first
+      grand.history.should include(:before_destroy)
+      grand.history.should include(:after_destroy)
+    end
+
+    should "not attempt to run callback defined on root that is not defined on embedded association" do
+      @root_class.define_callbacks :after_publish
+      @root_class.after_save { |d| d.run_callbacks(:after_publish) }
+
+      assert_nothing_raised do
+        child = @child_class.new(:name => 'Child')
+        root  = @root_class.create(:name => 'Parent', :children => [child])
+        child.history.should_not include(:after_publish)
+      end
+    end
+  end
+
+  context "Turning embedded callbacks off" do
+    setup do
+      @root_class        = Doc  { include CallbacksSupport; embedded_callbacks_off }
+      @child_class       = EDoc { include CallbacksSupport; embedded_callbacks_off }
+      @grand_child_class = EDoc { include CallbacksSupport; embedded_callbacks_off }
+
+      @root_class.many  :children, :class => @child_class
+      @child_class.many :children, :class => @grand_child_class
+
+      @root_class.many  :children, :class => @child_class
+      @child_class.many :children, :class => @grand_child_class
+    end
+
+    should "not run create callbacks" do
+      grand = @grand_child_class.new(:name => 'Grand Child')
+      child = @child_class.new(:name => 'Child', :children => [grand])
+      root  = @root_class.create(:name => 'Parent', :children => [child])
+
+      root.children.first.history.should == []
+      root.children.first.children.first.history.should == []
+    end
+
+    should "not run update callbacks" do
+      grand = @grand_child_class.new(:name => 'Grand Child')
+      child = @child_class.new(:name => 'Child', :children => [grand])
+      root  = @root_class.create(:name => 'Parent', :children => [child])
+      root.clear_history
+      root.update_attributes(:name => 'Updated Parent')
+
+      root.children.first.history.should == []
+      root.children.first.children.first.history.should == []
+    end
+
+    should "not run destroy callbacks" do
+      grand = @grand_child_class.new(:name => 'Grand Child')
+      child = @child_class.new(:name => 'Child', :children => [grand])
+      root  = @root_class.create(:name => 'Parent', :children => [child])
+      root.destroy
+      child = root.children.first
+      child.history.should == []
+
+      grand = root.children.first.children.first
+      grand.history.should == []
+    end
+  end
+
+  context "Running validation callbacks with conditional execution" do
+    setup do
+      @document = Doc do
+        include CallbacksSupport
+        key :message, String
+
+        before_validation :set_message, :on => 'create'
+
+        def set_message
+          self['message'] = 'Hi!'
+        end
+      end
+    end
+
+    should 'run callback on create' do
+      doc = @document.create
+      doc.history.should include(:before_validation)
+      doc.message.should == 'Hi!'
+    end
+
+    should 'skip callback on update' do
+      doc = @document.create
+      doc.message = 'Ho!'
+      doc.save
+      doc.message.should == 'Ho!'
+    end
+  end
+end