lookout-mongo_mapper 0.11.3

data/test/functional/test_safe.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+class SafeTest < Test::Unit::TestCase
+  context "A Document" do
+    should "default safe to off" do
+      Doc().should_not be_safe
+    end
+
+    should "allow turning safe on" do
+      Doc() { safe }.should be_safe
+    end
+
+    context "inherited with safe setting on" do
+      should "set subclass safe setting on" do
+        inherited = Class.new(Doc() { safe })
+        inherited.should be_safe
+      end
+    end
+
+    context "inherited with safe setting off" do
+      should "leave subclass safe setting off" do
+        inherited = Class.new(Doc())
+        inherited.should_not be_safe
+      end
+    end
+  end
+
+  context "A safe document" do
+    setup do
+      @klass = Doc() do
+        safe
+      end
+    end
+    teardown { drop_indexes(@klass) }
+
+    context "#save" do
+      setup do
+        @klass.ensure_index :email, :unique => true
+      end
+
+      context "using safe setting from class" do
+        should "work fine when all is well" do
+          assert_nothing_raised do
+            @klass.new(:email => 'john@doe.com').save
+          end
+        end
+
+        should "raise error when operation fails" do
+          assert_raises(Mongo::OperationFailure) do
+            2.times do
+              @klass.new(:email => 'john@doe.com').save
+            end
+          end
+        end
+      end
+
+      context "overriding safe setting" do
+        should "raise error if safe is true" do
+          assert_raises(Mongo::OperationFailure) do
+            2.times do
+              @klass.new(:email => 'john@doe.com').save(:safe => true)
+            end
+          end
+        end
+
+        should "not raise error if safe is false" do
+          assert_nothing_raised do
+            2.times do
+              @klass.new(:email => 'john@doe.com').save(:safe => false)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/functional/test_sci.rb

@@ -0,0 +1,240 @@
+require 'test_helper'
+
+class SciTest < Test::Unit::TestCase
+  context "Single collection inheritance (document)" do
+    setup do
+      class ::DocParent
+        include MongoMapper::Document
+        key :name, String
+      end
+      DocParent.collection.remove
+
+      class ::DocDaughter < ::DocParent; end
+      class ::DocSon < ::DocParent; end
+      class ::DocGrandSon < ::DocSon; end
+      class ::DocGrandGrandSon < ::DocGrandSon; end
+
+      DocSon.many :children, :class_name => 'DocGrandSon'
+
+      @parent = DocParent.new({:name => "Daddy Warbucks"})
+      @daughter = DocDaughter.new({:name => "Little Orphan Annie"})
+    end
+
+    teardown do
+      Object.send :remove_const, 'DocParent'   if defined?(::DocParent)
+      Object.send :remove_const, 'DocDaughter' if defined?(::DocDaughter)
+      Object.send :remove_const, 'DocSon'      if defined?(::DocSon)
+      Object.send :remove_const, 'DocGrandSon' if defined?(::DocGrandSon)
+      Object.send :remove_const, 'DocGrandGrandSon' if defined?(::DocGrandGrandSon)
+    end
+
+    should "automatically add _type key to store class" do
+      DocParent.key?(:_type).should be_true
+    end
+
+    should "use the same collection in the subclass" do
+      DocDaughter.collection.name.should == DocParent.collection.name
+    end
+
+    context ".single_collection_inherited?" do
+      should "be false if has not inherited" do
+        DocParent.should_not be_single_collection_inherited
+      end
+
+      should "be true if inherited" do
+        DocDaughter.should be_single_collection_inherited
+        DocSon.should be_single_collection_inherited
+        DocGrandSon.should be_single_collection_inherited
+      end
+    end
+
+    should "set _type on initialize" do
+      DocDaughter.new._type.should  == 'DocDaughter'
+      DocSon.new._type.should       == 'DocSon'
+      DocGrandSon.new._type.should  == 'DocGrandSon'
+    end
+
+    should "set _type based on class and ignore assigned values" do
+      DocSon.new(:_type => 'DocDaughter')._type.should == 'DocSon'
+    end
+
+    context "loading" do
+      should "be based on _type" do
+        @parent.save
+        @daughter.save
+
+        collection = DocParent.all
+        collection.size.should == 2
+        collection.first.should be_kind_of(DocParent)
+        collection.first.name.should == "Daddy Warbucks"
+        collection.last.should be_kind_of(DocDaughter)
+        collection.last.name.should == "Little Orphan Annie"
+      end
+
+      should "gracefully handle when _type cannot be constantized" do
+        doc = DocParent.new(:name => 'Nunes')
+        doc._type = 'FoobarBaz'
+        doc.save
+
+        collection = DocParent.all
+        collection.last.should == doc
+        collection.last.should be_kind_of(DocParent)
+      end
+    end
+
+    context "querying" do
+      should "find scoped to class" do
+        john = DocSon.create(:name => 'John')
+        steve = DocSon.create(:name => 'Steve')
+        steph = DocDaughter.create(:name => 'Steph')
+        carrie = DocDaughter.create(:name => 'Carrie')
+        boris = DocGrandSon.create(:name => 'Boris')
+
+        DocGrandGrandSon.all(:order => 'name').should  == []
+        DocGrandSon.all(:order => 'name').should  == [boris]
+        DocSon.all(:order => 'name').should       == [boris, john, steve]
+        DocDaughter.all(:order => 'name').should  == [carrie, steph]
+        DocParent.all(:order => 'name').should    == [boris, carrie, john, steph, steve]
+
+        sigmund = DocGrandGrandSon.create(:name => 'Sigmund')
+
+        DocGrandSon.all(:order => 'name').should  == [boris, sigmund]
+        DocSon.all(:order => 'name').should       == [boris, john, sigmund, steve]
+        DocParent.all(:order => 'name').should    == [boris, carrie, john, sigmund, steph, steve]
+      end
+
+      should "work with nested hash conditions" do
+        john = DocSon.create(:name => 'John')
+        steve = DocSon.create(:name => 'Steve')
+        DocSon.all(:name => {'$ne' => 'Steve'}).should == [john]
+      end
+
+      should "raise error if not found scoped to class" do
+        john = DocSon.create(:name => 'John')
+        steph = DocDaughter.create(:name => 'Steph')
+
+        lambda {
+          DocSon.find!(steph._id)
+        }.should raise_error(MongoMapper::DocumentNotFound)
+      end
+
+      should "not raise error for find with parent" do
+        john = DocSon.create(:name => 'John')
+
+        DocParent.find!(john._id).should == john
+      end
+
+      should "count scoped to class" do
+        john = DocSon.create(:name => 'John')
+        steve = DocSon.create(:name => 'Steve')
+        steph = DocDaughter.create(:name => 'Steph')
+        carrie = DocDaughter.create(:name => 'Carrie')
+
+        DocGrandSon.count.should  == 0
+        DocSon.count.should       == 2
+        DocDaughter.count.should  == 2
+        DocParent.count.should    == 4
+      end
+
+      should "not be able to destroy each other" do
+        john = DocSon.create(:name => 'John')
+        steph = DocDaughter.create(:name => 'Steph')
+
+        lambda {
+          DocSon.destroy(steph._id)
+        }.should raise_error(MongoMapper::DocumentNotFound)
+      end
+
+      should "not be able to delete each other" do
+        john = DocSon.create(:name => 'John')
+        steph = DocDaughter.create(:name => 'Steph')
+
+        lambda {
+          DocSon.delete(steph._id)
+        }.should_not change { DocParent.count }
+      end
+
+      should "be able to destroy using parent" do
+        john = DocSon.create(:name => 'John')
+        steph = DocDaughter.create(:name => 'Steph')
+
+        lambda {
+          DocParent.destroy_all
+        }.should change { DocParent.count }.by(-2)
+      end
+
+      should "be able to delete using parent" do
+        john = DocSon.create(:name => 'John')
+        steph = DocDaughter.create(:name => 'Steph')
+
+        lambda {
+          DocParent.delete_all
+        }.should change { DocParent.count }.by(-2)
+      end
+    end
+
+    should "be able to reload single collection inherited parent class" do
+      brian = DocParent.create(:name => 'Brian')
+      brian.name = 'B-Dawg'
+      brian.reload
+      brian.name.should == 'Brian'
+    end
+  end
+
+  context "Single collection inheritance (embedded document)" do
+    setup do
+      class ::Grandparent
+        include MongoMapper::EmbeddedDocument
+        key :grandparent, String
+      end
+
+      class ::Parent < ::Grandparent
+        include MongoMapper::EmbeddedDocument
+        key :parent, String
+      end
+
+      class ::Child < ::Parent
+        include MongoMapper::EmbeddedDocument
+        key :child, String
+      end
+
+      class ::OtherChild < ::Parent
+        include MongoMapper::EmbeddedDocument
+        key :other_child, String
+      end
+    end
+
+    teardown do
+      Object.send :remove_const, 'Grandparent' if defined?(::Grandparent)
+      Object.send :remove_const, 'Parent'      if defined?(::Parent)
+      Object.send :remove_const, 'Child'       if defined?(::Child)
+      Object.send :remove_const, 'OtherChild'  if defined?(::OtherChild)
+    end
+
+    should "automatically add _type key" do
+      Grandparent.key?(:_type).should be_true
+    end
+
+    context ".single_collection_inherited?" do
+      should "be false if has not inherited" do
+        Grandparent.should_not be_single_collection_inherited
+      end
+
+      should "be true if inherited" do
+        Parent.should be_single_collection_inherited
+        Child.should be_single_collection_inherited
+        OtherChild.should be_single_collection_inherited
+      end
+    end
+
+    should "set _type on initialize" do
+      Parent.new._type.should     == 'Parent'
+      Child.new._type.should      == 'Child'
+      OtherChild.new._type.should == 'OtherChild'
+    end
+
+    should "set _type based on class and ignore assigned values" do
+      Child.new(:_type => 'OtherChild')._type.should == 'Child'
+    end
+  end
+end

data/test/functional/test_scopes.rb

@@ -0,0 +1,171 @@
+require 'test_helper'
+
+class ScopesTest < Test::Unit::TestCase
+  context "Scopes" do
+    setup do
+      @document = Doc() do
+        key :name, String
+        key :age, Integer
+        timestamps!
+      end
+    end
+
+    context "basic scopes" do
+      setup do
+        @document.class_eval do
+          scope :old, :age.gt => 60
+          scope :teens, :age.gte => 13, :age.lte => 19
+        end
+      end
+
+      should "know what scopes have been added" do
+        @document.scopes.size.should == 2
+        @document.scopes.keys.map(&:to_s).sort.should == %w(old teens)
+      end
+
+      should "return a plucky query" do
+        @document.old.should be_instance_of(Plucky::Query)
+      end
+
+      should "work" do
+        @document.create(:name => 'John', :age => 99)
+        @document.create(:name => 'Frank', :age => 15)
+        docs = @document.old.all
+        docs.size.should == 1
+        docs[0].name.should == 'John'
+      end
+    end
+
+    context "dynamic scopes" do
+      setup do
+        @document.class_eval do
+          scope :age,     lambda { |age| {:age => age} }
+          scope :ages,    lambda { |low, high| {:age.gte => low, :age.lte => high} }
+          scope :ordered, lambda { |sort| sort(sort) }
+        end
+      end
+
+      should "work with single argument" do
+        @document.create(:name => 'John', :age => 60)
+        @document.create(:name => 'Frank', :age => 50)
+        docs = @document.age(60).all
+        docs.size.should == 1
+        docs.first.name.should == 'John'
+      end
+
+      should "work with multiple arguments" do
+        @document.create(:name => 'John', :age => 60)
+        @document.create(:name => 'Frank', :age => 50)
+        @document.create(:name => 'Bill', :age => 40)
+        docs = @document.ages(50, 70).all
+        docs.size.should == 2
+        docs.map(&:name).sort.should == %w(Frank John)
+      end
+
+      should "work with queries" do
+        john  = @document.create(:name => 'John', :age => 60)
+        frank = @document.create(:name => 'Frank', :age => 50)
+        bill  = @document.create(:name => 'Bill', :age => 40)
+        @document.ordered(:age).all.should == [bill, frank, john]
+      end
+    end
+
+    context "query scopes" do
+      setup do
+        @document.class_eval do
+          scope :boomers, where(:age.gte => 60).sort(:age)
+        end
+      end
+
+      should "work" do
+        todd = @document.create(:name => 'Todd', :age => 65)
+        john = @document.create(:name => 'John', :age => 60)
+        @document.create(:name => 'Frank', :age => 50)
+        @document.create(:name => 'Bill', :age => 40)
+        docs = @document.boomers.all
+        docs[0].should == john
+        docs[1].should == todd
+      end
+    end
+
+    context "chaining" do
+      setup do
+        @document.class_eval do
+          scope :by_age,  lambda { |age| {:age => age} }
+          scope :by_name, lambda { |name| {:name => name} }
+        end
+      end
+
+      should "work with scope methods" do
+        @document.create(:name => 'John', :age => 60)
+        @document.create(:name => 'Frank', :age => 60)
+        @document.create(:name => 'Bill', :age => 50)
+        docs = @document.by_age(60).by_name('John').all
+        docs.size.should == 1
+        docs.first.name.should == 'John'
+      end
+
+      should "work on query methods" do
+        @document.create(:name => 'John', :age => 60)
+        @document.create(:name => 'John', :age => 50)
+        @document.create(:name => 'Bill', :age => 50)
+        docs = @document.where(:name => 'John').by_age(50).all
+        docs.size.should == 1
+        docs.first.age.should == 50
+      end
+
+      context "with model methods" do
+        should "work if method returns a query" do
+          @document.create(:name => 'John', :age => 10)
+          @document.create(:name => 'John', :age => 20)
+          @document.class_eval do
+            def self.young
+              query(:age.lte => 12)
+            end
+          end
+          docs = @document.by_name('John').young.all
+          docs.size.should == 1
+          docs.first.age.should == 10
+        end
+
+        should "not work if method does not return a query" do
+          @document.class_eval { def self.age; 20 end }
+          lambda { @document.by_name('John').age }.should raise_error(NoMethodError)
+        end
+      end
+    end
+
+    context "with single collection inheritance" do
+      setup do
+        class ::Item
+          include MongoMapper::Document
+          scope :by_title,  lambda { |title| {:title => title} }
+          scope :published, lambda { {:published_at.lte => Time.now.utc} }
+
+          key   :title, String
+          key   :published_at, Time
+        end
+        Item.collection.remove
+
+        class ::Page < ::Item; end
+        class ::Blog < ::Item; end
+      end
+
+      teardown do
+        Object.send :remove_const, 'Item' if defined?(::Item)
+        Object.send :remove_const, 'Page' if defined?(::Page)
+        Object.send :remove_const, 'Blog' if defined?(::Blog)
+      end
+
+      should "inherit scopes" do
+        Page.scopes.keys.map(&:to_s).sort.should == %w(by_title published)
+      end
+
+      should "work with _type" do
+        item = Item.create(:title => 'Home')
+        page = Page.create(:title => 'Home')
+        Page.by_title('Home').first.should == page
+      end
+    end
+  end
+end