jonbell-mongo_mapper 0.8.6

data/test/functional/associations/test_one_embedded_proxy.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+class OneEmbeddedProxyTest < Test::Unit::TestCase
+  def setup
+    @post_class = Doc('Post') do
+      key :title, String
+    end
+    @author_class = EDoc('Author') do
+      key :name, String
+      embedded_in :post
+    end
+  end
+
+  should "default to nil" do
+    @post_class.one :author, :class => @author_class
+    @post_class.new.author.should be_nil
+  end
+
+  should "be able to build" do
+    @post_class.one :author, :class => @author_class
+
+    post = @post_class.create
+    author = post.author.build(:name => "John")
+    post.author.should be_instance_of(@author_class)
+    post.author.should be_new
+    post.author.name.should == 'John'
+    post.author.should == author
+    post.author.post.should == post
+  end
+
+  should "be able to replace the association" do
+    @post_class.one :author, :class => @author_class
+
+    post = @post_class.new
+    author = @author_class.new(:name => 'Frank')
+    post.author = author
+    post.save
+    post.reload
+
+    post.author.should == author
+    post.author.nil?.should be_false
+
+    new_author = @author_class.new(:name => 'Emily')
+    post.author = new_author
+    post.author.should == new_author
+  end
+
+  should "not have problem loading root document if embedded one is nil" do
+    @post_class.one :author, :class => @author_class
+    post = @post_class.create
+    
+    lambda {
+      @post_class.find(post.id)
+    }.should_not raise_error
+  end
+
+  should "load the parent and root documents for nested embedded documents" do
+    @address_class = EDoc('Address') do
+      key :city, String
+      key :state, String
+    end
+    @author_class.one :address, :class => @address_class
+    @post_class.one :author, :class => @author_class
+
+    post = @post_class.create(:title => 'Post Title', :author => { :name => 'Frank', :address => { :city => 'Boston', :state => 'MA' } })
+
+    post.author.address._parent_document.should == post.author
+    post.author.address._root_document.should == post
+  end
+
+  should "have boolean method for testing presence" do
+    @post_class.one :author, :class => @author_class
+
+    post = @post_class.new
+    post.author?.should be_false
+
+    post.author = @author_class.new(:name => 'Frank')
+    post.author?.should be_true
+  end
+
+end

data/test/functional/associations/test_one_proxy.rb

@@ -0,0 +1,181 @@
+require 'test_helper'
+
+class OneProxyTest < Test::Unit::TestCase
+  def setup
+    @post_class = Doc('Post')
+    @author_class = Doc do
+      key :post_id, ObjectId
+    end
+  end
+
+  should "default to nil" do
+    @post_class.one :author, :class => @author_class
+    @post_class.new.author.nil?.should be_true
+  end
+
+  should "allow assignment of associated document using a hash" do
+    @post_class.one :author, :class => @author_class
+
+    post = @post_class.new('author' => { 'name' => 'Frank' })
+    post.author.name.should == 'Frank'
+
+    post.save.should be_true
+    post.reload
+
+    post.author.name.should == 'Frank'
+  end
+
+  context "replacing the association" do
+    context "with an object of the class" do
+      should "work" do
+        @post_class.one :author, :class => @author_class
+
+        post = @post_class.new
+        author = @author_class.new(:name => 'Frank')
+        post.author = author
+        post.reload
+
+        post.author.should == author
+        post.author.nil?.should be_false
+
+        new_author = @author_class.new(:name => 'Emily')
+        post.author = new_author
+        post.author.should == new_author
+      end
+    end
+
+    context "with a Hash" do
+      should "convert to an object of the class and work" do
+        @post_class.one :author, :class => @author_class
+
+        post = @post_class.new
+        post.author = {'name' => 'Frank'}
+        post.reload
+
+        post.author.name.should == 'Frank'
+        post.author.nil?.should be_false
+
+        post.author = {'name' => 'Emily'}
+        post.author.name.should == 'Emily'
+      end
+    end
+  end
+
+  should "have boolean method for testing presence" do
+    @post_class.one :author, :class => @author_class
+
+    post = @post_class.new
+    post.author?.should be_false
+
+    post.author = @author_class.new(:name => 'Frank')
+    post.author?.should be_true
+  end
+
+  should "work with criteria" do
+    @post_class.one :primary_author, :class => @author_class, :primary => true
+    @post_class.one :author, :class => @author_class, :primary => false
+
+    post = @post_class.create
+    author = @author_class.create(:name => 'Frank', :primary => false, :post_id => post.id)
+    primary = @author_class.create(:name => 'Bill', :primary => true, :post_id => post.id)
+    post.reload
+    post.author.should == author
+    post.primary_author.should == primary
+  end
+
+  should "unset the association" do
+    @post_class.one :author, :class => @author_class
+    post = @post_class.create
+    author = @author_class.create
+    post.update_attributes!(:author => author)
+    post.reload
+    post.author = nil
+    post.author.nil?.should be_true
+  end
+
+  should "work with :dependent delete" do
+    @post_class.one :author, :class => @author_class, :dependent => :delete
+
+    post = @post_class.create
+    author = @author_class.new
+    post.author = author
+    post.reload
+
+    @author_class.any_instance.expects(:delete).once
+    post.author = @author_class.new
+  end
+
+  should "work with :dependent destroy" do
+    @post_class.one :author, :class => @author_class, :dependent => :destroy
+
+    post = @post_class.create
+    author = @author_class.new
+    post.author = author
+    post.reload
+
+    @author_class.any_instance.expects(:destroy).once
+    post.author = @author_class.new
+  end
+
+  should "work with :dependent nullify" do
+    @post_class.one :author, :class => @author_class, :dependent => :nullify
+
+    post = @post_class.create
+    author = @author_class.new
+    post.author = author
+    post.reload
+
+    post.author = @author_class.new
+
+    author.reload
+    author.post_id.should be_nil
+  end
+
+  should "be able to build" do
+    @post_class.one :author, :class => @author_class
+
+    post = @post_class.create
+    author = post.author.build(:name => 'John')
+    post.author.should be_instance_of(@author_class)
+    post.author.should be_new
+    post.author.name.should == 'John'
+    post.author.should == author
+    post.author.post_id.should == post.id
+  end
+
+  should "be able to create" do
+    @post_class.one :author, :class => @author_class
+
+    post = @post_class.create
+    author = post.author.create(:name => 'John')
+    post.author.should be_instance_of(@author_class)
+    post.author.should_not be_new
+    post.author.name.should == 'John'
+    post.author.should == author
+    post.author.post_id.should == post.id
+  end
+
+  context "#create!" do
+    setup do
+      @author_class.key :name, String, :required => true
+      @post_class.one :author, :class => @author_class
+    end
+
+    should "raise exception if invalid" do
+      post = @post_class.create
+      assert_raises(MongoMapper::DocumentNotValid) do
+        post.author.create!
+      end
+    end
+
+    should "work if valid" do
+      post = @post_class.create
+      author = post.author.create!(:name => 'John')
+      post.author.should be_instance_of(@author_class)
+      post.author.should_not be_new
+      post.author.name.should == 'John'
+      post.author.should == author
+      post.author.post_id.should == post.id
+    end
+  end
+end

data/test/functional/test_accessible.rb

@@ -0,0 +1,168 @@
+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 "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 "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
+  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,44 @@
+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.posts.should == [post1, post2]
+
+    post1 = post1.reload
+    post1.tags.should == [tag1]
+  end
+end