mongo_mapper 0.7.5 → 0.7.6

data/test/functional/test_pagination.rb

@@ -1,93 +0,0 @@
-require 'test_helper'
-
-class PaginationTest < Test::Unit::TestCase
-  context "Paginating" do
-    setup do
-      @document = Doc do
-        set_collection_name 'users'
-
-        key :first_name, String
-        key :last_name, String
-        key :age, Integer
-        
-        def self.per_page; 1 end
-      end
-      
-      @doc1 = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
-      @doc2 = @document.create({:first_name => 'Steve', :last_name => 'Smith', :age => '28'})
-      @doc3 = @document.create({:first_name => 'Steph', :last_name => 'Nunemaker', :age => '26'})
-    end
-
-    should "return the total pages" do
-      result = @document.paginate(:per_page => 2, :page => 1)
-      result.total_pages.should == 2
-    end
-    
-    should "return the total pages when defaulting to the document class per_page" do
-      result = @document.paginate(:page => 1)
-      result.total_pages.should == 3
-    end
-    
-    should "return the total of records" do
-      result = @document.paginate(:per_page => 2, :page => 1)
-      result.total_entries.should == 3
-    end
-
-    should "return the items" do
-      result = @document.paginate(:per_page => 2, :page => 1, :order => 'first_name')
-      result.size.should == 2
-      result.should == [@doc1, @doc3]
-    end
-
-    should "accept conditions" do
-      result = @document.paginate({
-        :last_name => 'Nunemaker',
-        :order     => "age DESC",
-        :per_page  => 2, 
-        :page      => 1,
-      })
-      result.should == [@doc1, @doc3]
-      result.first.age.should == 27
-
-      result = @document.paginate({
-        :conditions => {:last_name => 'Nunemaker'},
-        :order      => "age DESC",
-        :per_page   => 2,
-        :page       => 1} )
-      result.should == [@doc1, @doc3]
-      result.first.age.should == 27
-    end
-
-    should "withstand rigor" do      
-      result = @document.paginate({
-        :per_page  => 1, 
-        :page      => 1,
-        :order     => 'age desc', 
-        :last_name => 'Nunemaker'
-      })
-      result.should == [@doc1]
-      result.total_entries.should == 2
-      result.total_pages.should == 2
-      
-      result = @document.paginate({
-        :per_page  => 1,
-        :page      => 2,
-        :order     => 'age desc',
-        :last_name => 'Nunemaker'
-      })
-      result.should == [@doc3]
-      result.total_entries.should == 2
-      result.total_pages.should == 2
-      
-      result = @document.paginate({
-        :per_page  => 2,
-        :page      => 1,
-        :order     => 'age desc',
-        :last_name => 'Nunemaker'
-      })
-      result.should == [@doc1, @doc3]
-      result.total_entries.should == 2
-      result.total_pages.should == 1
-    end
-  end
-end

data/test/functional/test_protected.rb

@@ -1,163 +0,0 @@
-require 'test_helper'
-
-class ProtectedTest < Test::Unit::TestCase
-  context 'A document with protected attributes' do
-    setup do
-      @doc_class = Doc do
-        key :name, String
-        key :admin, Boolean, :default => false
-
-        attr_protected :admin
-      end
-
-      @doc = @doc_class.create(:name => 'Steve Sloan')
-    end
-
-    should 'have protected attributes class method' do
-      @doc_class.protected_attributes.should == [:admin].to_set
-    end
-
-    should "default protected attributes to nil" do
-      Doc().protected_attributes.should be_nil
-    end
-
-    should "have protected attributes instance method" do
-      @doc.protected_attributes.should equal(@doc_class.protected_attributes)
-    end
-
-    should "work with :protected shortcut when defining key" do
-      Doc() do
-        key :user_id, ObjectId, :protected => true
-      end.protected_attributes.should == [:user_id].to_set
-    end
-
-    should 'assign protected attribute through accessor' do
-      @doc.admin = true
-      @doc.admin.should be_true
-    end
-
-    should "ignore protected 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 protected 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 protected 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 protected 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 protected 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 protected attributes" do
-    setup do
-      class ::GrandParent
-        include MongoMapper::Document
-
-        key :site_id, ObjectId
-        attr_protected :site_id
-      end
-      GrandParent.collection.remove
-
-      class ::Child < ::GrandParent
-        key :position, Integer
-
-        attr_protected :position
-      end
-
-      class ::GrandChild < ::Child; end
-
-      class ::OtherChild < ::GrandParent
-        key :blog_id, ObjectId
-
-        attr_protected :blog_id
-      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.protected_attributes.should == [:site_id].to_set
-      Child.protected_attributes.should == [:site_id, :position].to_set
-      GrandChild.protected_attributes.should == [:site_id, :position].to_set
-      OtherChild.protected_attributes.should == [:site_id, :blog_id].to_set
-    end
-  end
-
-  context 'An embedded document with protected attributes' do
-    setup do
-      @doc_class = Doc('Project')
-      @edoc_class = EDoc('Person') do
-        key :name, String
-        key :admin, Boolean, :default => false
-
-        attr_protected :admin
-      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 protected attributes class method' do
-      @edoc_class.protected_attributes.should == [:admin].to_set
-    end
-
-    should "default protected attributes to nil" do
-      EDoc().protected_attributes.should be_nil
-    end
-
-    should "have protected attributes instance method" do
-      @edoc.protected_attributes.should equal(@edoc_class.protected_attributes)
-    end
-
-    should 'assign protected attribute through accessor' do
-      @edoc.admin = true
-      @edoc.admin.should be_true
-    end
-
-    should 'ignore protected 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 protected 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_string_id_compatibility.rb

@@ -1,67 +0,0 @@
-require 'test_helper'
-
-class StringIdCompatibilityTest < Test::Unit::TestCase
-  def setup
-    @note_class = EDoc do
-      key :_id, String
-    end
-    
-    @task_class = Doc do
-      key :_id, String
-      key :project_id, String
-      belongs_to :project
-    end
-    
-    @project_class = Doc do
-      include MongoMapper::Document
-      key :_id, String
-    end
-    
-    @task_class.belongs_to :project, :class => @project_class
-    @project_class.many :notes, :class => @note_class
-    @project_class.many :tasks, :class => @task_class, :foreign_key => 'project_id', :order => :position.asc
-  end
-  
-  should "assign correct _id for documents" do
-    project = @project_class.create
-    project._id.should == project.id
-    project._id.should be_instance_of(String)
-    project.id.size.should == 24
-    lambda {
-      BSON::ObjectID.from_string(project.id)
-    }.should_not raise_error
-  end
-  
-  should "assign correct _id for embedded documents" do
-    note = @note_class.new
-    note.id.should == note._id
-    note.id.size.should == 24
-  end
-  
-  should "find records" do
-    project = @project_class.create
-    @project_class.find(project.id).should == project
-  end
-    
-  should "save embedded docs" do
-    n1 = @note_class.new
-    n2 = @note_class.new
-    n3 = @note_class.new
-    project = @project_class.create(:notes => [n1, n2, n3])
-    
-    project = project.reload
-    project.notes.size.should == 3
-    project.notes.should == [n1, n2, n3]
-  end
-  
-  should "be able to associate records" do
-    t1 = @task_class.new(:body => 'First task', :position => 1)
-    t2 = @task_class.new(:body => 'Second task', :position => 2)
-    t3 = @task_class.new(:body => 'Third task', :position => 3)
-    project = @project_class.create(:name => 'MM', :tasks => [t1, t2, t3])
-    
-    project = project.reload
-    project.tasks.count.should == 3
-    project.tasks.should == [t1, t2, t3]
-  end
-end

data/test/functional/test_timestamps.rb

@@ -1,64 +0,0 @@
-require 'test_helper'
-
-class TimestampsTest < Test::Unit::TestCase
-  context "timestamping" do
-    setup do
-      @klass = Doc do
-        set_collection_name 'users'
-
-        key :first_name, String
-        key :last_name, String
-        key :age, Integer
-        key :date, Date
-      end
-      @klass.timestamps!
-    end
-
-    should "set created_at and updated_at on create" do
-      doc = @klass.new(:first_name => 'John', :age => 27)
-      doc.created_at.should be(nil)
-      doc.updated_at.should be(nil)
-      doc.save
-      doc.created_at.should_not be(nil)
-      doc.updated_at.should_not be(nil)
-    end
-
-    should "not overwrite created_at if it already exists" do
-      original_created_at = 1.month.ago
-      doc = @klass.new(:first_name => 'John', :age => 27, :created_at => original_created_at)
-      doc.created_at.to_i.should == original_created_at.to_i
-      doc.updated_at.should be_nil
-      doc.save
-      doc.created_at.to_i.should == original_created_at.to_i
-      doc.updated_at.should_not be_nil
-    end
-
-    should "set updated_at on field update but leave created_at alone" do
-      doc = @klass.create(:first_name => 'John', :age => 27)
-      old_created_at = doc.created_at
-      old_updated_at = doc.updated_at
-      doc.first_name = 'Johnny'
-
-      Timecop.freeze(Time.now + 5.seconds) do
-        doc.save
-      end
-
-      doc.created_at.should == old_created_at
-      doc.updated_at.should_not == old_updated_at
-    end
-
-    should "set updated_at on document update but leave created_at alone" do
-      doc = @klass.create(:first_name => 'John', :age => 27)
-      old_created_at = doc.created_at
-      old_updated_at = doc.updated_at
-
-      Timecop.freeze(Time.now + 5.seconds) do
-        @klass.update(doc._id, { :first_name => 'Johnny' })
-      end
-
-      doc = doc.reload
-      doc.created_at.should == old_created_at
-      doc.updated_at.should_not == old_updated_at
-    end
-  end
-end

data/test/functional/test_userstamps.rb

@@ -1,28 +0,0 @@
-require 'test_helper'
-
-class UserstampsTest < Test::Unit::TestCase
-  context "userstamping" do
-    setup do
-      @document = Doc do
-        set_collection_name 'users'
-        userstamps!
-      end
-    end
-
-    should "add creator_id key" do
-      @document.keys.keys.should include('creator_id')
-    end
-
-    should "add updater_id key" do
-      @document.keys.keys.should include('updater_id')
-    end
-
-    should "add belongs_to creator" do
-      @document.associations.keys.should include('creator')
-    end
-
-    should "add belongs_to updater" do
-      @document.associations.keys.should include('updater')
-    end
-  end
-end

data/test/functional/test_validations.rb

@@ -1,342 +0,0 @@
-require 'test_helper'
-
-class ValidationsTest < Test::Unit::TestCase
-  context "Saving a new document that is invalid" do
-    setup do
-      @document = Doc do
-        key :name, String, :required => true
-      end
-    end
-
-    should "not insert document" do
-      doc = @document.new
-      doc.save
-      @document.count.should == 0
-    end
-
-    should "populate document's errors" do
-      doc = @document.new
-      doc.errors.size.should == 0
-      doc.save
-      doc.errors.full_messages.should == ["Name can't be empty"]
-    end
-  end
-
-  context "Saving a document that is invalid (destructive)" do
-    setup do
-      @document = Doc do
-        key :name, String, :required => true
-      end
-    end
-
-    should "raise error" do
-      doc = @document.new
-      lambda { doc.save! }.should raise_error(MongoMapper::DocumentNotValid)
-    end
-  end
-
-  context "Creating a document that is invalid (destructive)" do
-    setup do
-      @document = Doc do
-        key :name, String, :required => true
-      end
-    end
-
-    should "raise error" do
-      lambda { @document.create! }.should raise_error(MongoMapper::DocumentNotValid)
-    end
-
-    should "create a new document" do
-      instance = @document.create!(:name => "James")
-      instance.new_record?.should be_false
-    end
-  end
-
-  context "Saving an existing document that is invalid" do
-    setup do
-      @document = Doc do
-        key :name, String, :required => true
-      end
-
-      @doc = @document.create(:name => 'John Nunemaker')
-    end
-
-    should "not update document" do
-      @doc.name = nil
-      @doc.save
-      @doc.reload.name.should == 'John Nunemaker'
-    end
-
-    should "populate document's errors" do
-      @doc.name = nil
-      @doc.save
-      @doc.errors.full_messages.should == ["Name can't be empty"]
-    end
-  end
-
-  context "Adding validation errors" do
-    setup do
-      @document = Doc do
-        key :action, String
-        def action_present
-          errors.add(:action, 'is invalid') if action.blank?
-        end
-      end
-    end
-
-    should "work with validate_on_create callback" do
-      @document.validate_on_create :action_present
-
-      doc = @document.new
-      doc.action = nil
-      doc.should have_error_on(:action)
-
-      doc.action = 'kick'
-      doc.should_not have_error_on(:action)
-      doc.save
-
-      doc.action = nil
-      doc.should_not have_error_on(:action)
-    end
-
-    should "work with validate_on_update callback" do
-      @document.validate_on_update :action_present
-
-      doc = @document.new
-      doc.action = nil
-      doc.should_not have_error_on(:action)
-      doc.save
-
-      doc.action = nil
-      doc.should have_error_on(:action)
-
-      doc.action = 'kick'
-      doc.should_not have_error_on(:action)
-    end
-  end
-
-  context "validating uniqueness of" do
-    setup do
-      @document = Doc do
-        key :name, String
-        validates_uniqueness_of :name
-      end
-    end
-
-    should "not fail if object is new" do
-      doc = @document.new
-      doc.should_not have_error_on(:name)
-    end
-
-    should "not fail when new object is out of scope" do
-      document = Doc do
-        key :name
-        key :adult
-        validates_uniqueness_of :name, :scope => :adult
-      end
-      doc = document.new("name" => "joe", :adult => true)
-      doc.save.should be_true
-
-      doc2 = document.new("name" => "joe", :adult => false)
-      doc2.should be_valid
-    end
-
-    should "allow to update an object" do
-      doc = @document.new("name" => "joe")
-      doc.save.should be_true
-
-      @document \
-        .stubs(:first) \
-        .with(:name => 'joe') \
-        .returns(doc)
-
-      doc.name = "joe"
-      doc.valid?.should be_true
-      doc.should_not have_error_on(:name)
-    end
-
-    should "fail if object name is not unique" do
-      doc = @document.new("name" => "joe")
-      doc.save.should be_true
-
-      @document \
-        .stubs(:first) \
-        .with(:name => 'joe') \
-        .returns(doc)
-
-      doc2 = @document.new("name" => "joe")
-      doc2.should have_error_on(:name)
-    end
-
-    should "allow multiple blank entries if :allow_blank => true" do
-      document = Doc do
-        key :name
-        validates_uniqueness_of :name, :allow_blank => :true
-      end
-
-      doc = document.new("name" => "")
-      doc.save.should be_true
-
-      document \
-        .stubs(:first) \
-        .with(:name => '') \
-        .returns(doc)
-
-      doc2 = document.new("name" => "")
-      doc2.should_not have_error_on(:name)
-    end
-
-    should "allow multiple nil entries if :allow_nil => true" do
-      document = Doc do
-        key :name
-        validates_uniqueness_of :name, :allow_nil => :true
-      end
-
-      doc = document.new('name' => nil)
-      doc.save.should be_true
-
-      doc2 = document.new('name' => nil)
-      doc2.should_not have_error_on(:name)
-    end
-
-    should "allow entries that differ only in case by default" do
-      document = Doc do
-        key :name
-        validates_uniqueness_of :name
-      end
-
-      doc = document.new("name" => "BLAMMO")
-      doc.save.should be_true
-
-      doc2 = document.new("name" => "blammo")
-      doc2.should_not have_error_on(:name)
-    end
-
-    context "with :case_sensitive => false" do
-      setup do
-        @document = Doc do
-          key :name
-          validates_uniqueness_of :name, :case_sensitive => false
-        end
-      end
-
-      should "fail on entries that differ only in case" do
-        doc = @document.new("name" => "BLAMMO")
-        doc.save.should be_true
-
-        doc2 = @document.new("name" => "blammo")
-        doc2.should have_error_on(:name)
-      end
-
-      should "not raise an error if value is nil" do
-        doc = @document.new("name" => nil)
-        lambda { doc.valid? }.should_not raise_error
-      end
-
-      should "not raise an error if special Regexp characters used" do
-        doc = @document.new("name" => '?')
-        lambda { doc.valid? }.should_not raise_error
-      end
-
-      should "check for uniqueness using entire string" do
-        doc = @document.new("name" => "John Doe")
-        doc.save.should be_true
-
-        doc2 = @document.new("name" => "John")
-        doc2.valid?.should be_true
-      end
-    end
-
-    context "scoped by a single attribute" do
-      setup do
-        @document = Doc do
-          key :name, String
-          key :scope, String
-          validates_uniqueness_of :name, :scope => :scope
-        end
-      end
-
-      should "fail if the same name exists in the scope" do
-        doc = @document.new("name" => "joe", "scope" => "one")
-        doc.save.should be_true
-
-        @document \
-          .stubs(:first) \
-          .with(:name => 'joe', :scope => "one") \
-          .returns(doc)
-
-        doc2 = @document.new("name" => "joe", "scope" => "one")
-        doc2.should have_error_on(:name)
-      end
-
-      should "pass if the same name exists in a different scope" do
-        doc = @document.new("name" => "joe", "scope" => "one")
-        doc.save.should be_true
-
-        @document \
-          .stubs(:first) \
-          .with(:name => 'joe', :scope => 'two') \
-          .returns(nil)
-
-        doc2 = @document.new("name" => "joe", "scope" => "two")
-        doc2.should_not have_error_on(:name)
-      end
-    end
-
-    context "scoped by a multiple attributes" do
-      setup do
-        @document = Doc do
-          key :name, String
-          key :first_scope, String
-          key :second_scope, String
-          validates_uniqueness_of :name, :scope => [:first_scope, :second_scope]
-        end
-      end
-
-      should "fail if the same name exists in the scope" do
-        doc = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "two")
-        doc.save.should be_true
-
-        @document \
-          .stubs(:first) \
-          .with(:name => 'joe', :first_scope => 'one', :second_scope => 'two') \
-          .returns(doc)
-
-        doc2 = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "two")
-        doc2.should have_error_on(:name)
-      end
-
-      should "pass if the same name exists in a different scope" do
-        doc = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "two")
-        doc.save.should be_true
-
-        @document \
-          .stubs(:first) \
-          .with(:name => 'joe', :first_scope => 'one', :second_scope => 'one') \
-          .returns(nil)
-
-        doc2 = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "one")
-        doc2.should_not have_error_on(:name)
-      end
-    end
-  end
-
-  context "validates uniqueness of with :unique shortcut" do
-    should "work" do
-      @document = Doc do
-        key :name, String, :unique => true
-      end
-
-      doc = @document.create(:name => 'John')
-      doc.should_not have_error_on(:name)
-
-      @document \
-        .stubs(:first) \
-        .with(:name => 'John') \
-        .returns(doc)
-
-      second_john = @document.create(:name => 'John')
-      second_john.should have_error_on(:name, 'has already been taken')
-    end
-  end
-end