mongo_mapper 0.13.0.beta2 → 0.15.0

data/spec/functional/scopes_spec.rb

@@ -66,7 +66,7 @@ describe "Scopes" 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) }
+          scope :ordered, lambda { |s| sort(s) }
         end
       end
 
@@ -170,7 +170,7 @@ describe "Scopes" do
           key   :title, String
           key   :published_at, Time
         end
-        Item.collection.remove
+        Item.collection.drop
 
         class ::Page < ::Item; end
         class ::Blog < ::Item
@@ -201,4 +201,237 @@ describe "Scopes" do
       end
     end
   end
+
+  describe "with_scope" do
+    describe "with a base query" do
+      before do
+        @klass = Doc do
+        end
+      end
+
+      it "should scope" do
+        u1 = @klass.create!(:first_name => "Scott")
+        u2 = @klass.create!(:first_name => "Andrew")
+
+        run = false
+
+        @klass.with_scope(:first_name => "Scott") do
+          run = true
+          @klass.all.should == [u1]
+        end
+
+        run.should == true
+      end
+
+      it "should return the scope at the end of the block" do
+        u1 = @klass.create!(:first_name => "Scott")
+        u2 = @klass.create!(:first_name => "Andrew")
+
+        run = false
+
+        @klass.with_scope(:first_name => "Scott") do
+          run = true
+          @klass.all.should == [u1]
+        end
+
+        run.should == true
+
+        @klass.all.should include(u1)
+        @klass.all.should include(u2)
+      end
+
+      it "should be able to use an unscoped query" do
+        u1 = @klass.create!(:first_name => "Scott")
+        u2 = @klass.create!(:first_name => "Andrew")
+
+        run = false
+
+        @klass.with_scope(:first_name => "Scott") do
+          @klass.unscoped do
+            run = true
+            @klass.all.should include(u1)
+            @klass.all.should include(u2)
+          end
+
+          @klass.all.should == [u1]
+        end
+
+        run.should == true
+
+        @klass.all.should include(u1)
+        @klass.all.should include(u2)
+      end
+
+      it "should return the value of the block" do
+        u1 = @klass.create!(:first_name => "Scott")
+        u2 = @klass.create!(:first_name => "Andrew")
+
+        result = @klass.with_scope(:first_name => "Scott") do
+          @klass.all
+        end
+
+        result.should == [u1]
+      end
+
+      it "should have an empty list of default scope" do
+        @klass.default_scopes.should == []
+      end
+
+      it "should apply the default scope to all queries" do
+        @klass.key :active, Boolean, :default => true
+
+        normal = @klass.create!
+        inactive = @klass.create!(:active => false)
+
+        @klass.default_scope do
+          {
+            :active => true
+          }
+        end
+
+        @klass.all.should == [normal]
+      end
+
+      it "should allow multiple default scopes" do
+        @klass.key :active, Boolean, :default => true
+        @klass.key :soft_deleted, Boolean, :default => false
+
+        normal = @klass.create!
+        inactive = @klass.create!(:active => false)
+        deleted = @klass.create!(:soft_deleted => true)
+
+        @klass.default_scope do
+          {
+            :active => true,
+          }
+        end
+
+        @klass.default_scope do
+          {
+            :soft_deleted => false
+          }
+        end
+
+        @klass.all.should == [normal]
+      end
+
+      it "should allow a where inside a default_scope" do
+        @klass.key :active, Boolean, :default => true
+
+        normal = @klass.create!
+        inactive = @klass.create!(:active => false)
+
+        @klass.default_scope do
+          where(:active => true)
+        end
+
+        @klass.all.should == [normal]
+      end
+
+      it "should allow a hash directly" do
+        @klass.key :active, Boolean, :default => true
+
+        normal = @klass.create!
+        inactive = @klass.create!(:active => false)
+
+        @klass.default_scope :active => true
+
+        @klass.all.should == [normal]
+      end
+
+      it "should inherit default scopes, but only downwards" do
+        @klass.default_scope do
+          where(:active => true)
+        end
+        @subclass = Class.new(@klass)
+        @subclass.default_scopes.length.should == 1
+
+        @subclass.default_scope do
+          {
+            :foo => :bar
+          }
+        end
+
+        @subclass.default_scopes.length.should == 2
+        @klass.default_scopes.length.should == 1
+      end
+    end
+  end
+
+  describe "regression - multiple named scopes" do
+    it "should merge the hashes from multiple scopes" do
+      klass = Doc do
+        key :a, Boolean
+        key :b, Boolean
+        key :c, Boolean
+
+        scope :one, where(:a => true, :b => true)
+        scope :two, where(:c => true)
+      end
+
+      obj = klass.create!(:a => false, :b => true, :c => true)
+      klass.one.two.all.should == []
+
+      obj2 = klass.create(:a => true, :b => true, :c => true)
+      klass.one.two.all.should == [obj2]
+    end
+  end
+
+  describe "regression - with multiple scopes that set a key to nil" do
+    it "should still have the query as nil" do
+      klass = Doc do
+        key :a, Boolean
+
+        scope :one, lambda {
+          {
+            :a => nil
+          }
+        }
+        scope :two, lambda {
+          {
+            :a => nil
+          }
+        }
+      end
+
+      obj = klass.create!(:a => nil)
+      klass.one.two.all.should == [obj]
+    end
+  end
+
+  describe "regression - multiple scopes leading to empty query (array bug?)" do
+    before do
+      @klass = Doc do
+        key :send_at, Time
+
+        scope :unsent, lambda {
+          now = Time.now
+
+          {
+            send_at: {
+              '$lte' => now,
+              '$gte' => now - 30.days,
+            },
+            sent_at: nil,
+          }
+        }
+
+        scope :sorted, lambda {
+          sort(send_at: 1)
+        }
+      end
+    end
+
+    it "should filter properly by dates" do
+      old_obj = @klass.create(send_at: 3.months.ago)
+      one_day_ago = @klass.create(send_at: 1.day.ago)
+      two_days_ago = @klass.create(send_at: 2.days.ago)
+
+      all_unsorted = @klass.unsent.all
+
+      all_unsorted.should include(one_day_ago)
+      all_unsorted.should include(two_days_ago)
+      @klass.unsent.sorted.all.should == [two_days_ago, one_day_ago]
+    end
+  end
 end

data/spec/functional/static_keys_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe MongoMapper::Plugins::Keys::Static do
+  before do
+    @klass = Class.new do
+      include MongoMapper::Document
+    end
+  end
+
+  it "is off by default" do
+    @klass.static_keys.should == false
+  end
+
+  it "can be turned on" do
+    @klass.static_keys = true
+    @klass.static_keys.should == true
+  end
+
+  describe "a class with static keys" do
+    before do
+      @klass = Class.new do
+        include MongoMapper::Document
+
+        self.static_keys = true
+
+        attr_accessor :an_accessor
+
+        key "valid_key", String
+      end
+
+      @obj = @klass.new
+    end
+
+    it "should be able to assign to a valid key" do
+      @obj.valid_key = "foo"
+      @obj.valid_key.should == "foo"
+    end
+
+    it "should raise a MissingKeyError if trying to assign to a field that does not exist" do
+      lambda {
+        @obj['foo'] = "foo"
+      }.should raise_error(MongoMapper::Plugins::Keys::Static::MissingKeyError)
+    end
+
+    it "should raise a MissingKeyError if trying to read from a field that does not exist" do
+      lambda {
+        @obj['foo']
+      }.should raise_error(MongoMapper::Plugins::Keys::Static::MissingKeyError)
+    end
+
+    it "should raise a MissingKeyError if trying to set attributes= to a field that does not exist" do
+      lambda {
+        @obj.attributes = {:foo => "foo"}
+      }.should raise_error(MongoMapper::Plugins::Keys::Static::MissingKeyError)
+    end
+
+    it "should be able to call a method" do
+      @obj.an_accessor = :bar
+      @obj.an_accessor.should == :bar
+    end
+
+    it "should raise a NoMethodError if trying to call the non-existant key method" do
+      lambda {
+        @obj.foo
+      }.should raise_error(NoMethodError)
+    end
+
+    it "should raise for read_key" do
+      lambda {
+        @obj.read_key('foo')
+      }.should raise_error(MongoMapper::Plugins::Keys::Static::MissingKeyError)
+    end
+
+    it "should raise for attribute" do
+      lambda {
+        @obj.attribute('foo')
+      }.should raise_error(MongoMapper::Plugins::Keys::Static::MissingKeyError)
+    end
+
+    it "should not raise if trying to assign to a field that exists (but with a symbol instead of a string)" do
+      lambda {
+        @obj.write_key(:valid_key, "foo")
+      }.should_not raise_error
+
+      @obj.valid_key.should == "foo"
+    end
+
+    it "should not raise a MissingKeyError if trying to read from a field that exists (but with a symbol instead of a string)" do
+      lambda {
+        @obj[:valid_key]
+      }.should_not raise_error
+    end
+
+    it "should not blow up when loading if there is a key defined in the db that has not been defined (but it should not load it)" do
+      @klass.collection.insert_one({ :foo => "bar", :valid_key => "something" })
+      @obj = @klass.first
+      @obj.valid_key.should == "something"
+
+      lambda {
+        @obj.foo
+      }.should raise_error(NoMethodError)
+    end
+  end
+
+  describe "a class without static keys" do
+    before do
+      @klass = Class.new do
+        include MongoMapper::Document
+        key :valid_key, String
+      end
+
+      @obj = @klass.new
+    end
+
+    it "should be able to assign to a valid key" do
+      @obj.valid_key = "foo"
+      @obj.valid_key.should == "foo"
+    end
+
+    it "should be able to read and assign a dynamic key" do
+      @obj['foo'].should be_nil
+      @obj['foo'] = "bar"
+      @obj['foo'].should == "bar"
+    end
+  end
+
+  describe "with mixed static + non static models" do
+    before do
+      @static_model = Class.new do
+        include MongoMapper::Document
+        self.static_keys = true
+      end
+
+      @non_static_model = Class.new do
+        include MongoMapper::Document
+        self.static_keys = false
+      end
+
+      @static_key_object = @static_model.new
+      @non_static_key_object = @non_static_model.new
+    end
+
+    it "should allow non-static key assignment to one, only static assignment to the other" do
+      @non_static_key_object['foo'] = 'bar'
+      @non_static_key_object.foo.should == 'bar'
+      @non_static_key_object['foo'].should == 'bar'
+
+      lambda {
+        @static_key_object['foo'] = 'bar'
+      }.should raise_error(MongoMapper::Plugins::Keys::Static::MissingKeyError)
+    end
+  end
+end

data/spec/functional/stats_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe "Stats" do
+  before(:each) do
+    class ::Docs
+      include MongoMapper::Document
+      key   :title, String
+      key   :published_at, Time
+    end
+
+    Docs.collection.drop
+  end
+
+  context "with no documents present" do
+    it "should return nil" do
+      if Docs.stats == nil
+        Docs.stats.should == nil
+      else
+        Docs.stats['count'].should == 0
+      end
+    end
+  end
+
+  context "with documents present" do
+    before do
+      # Make sure that there is at least one document stored
+      Docs.create!
+    end
+
+    def get_stats
+      MongoMapper.database.command(:collstats => 'docs').documents[0]
+    end
+
+    it "should have the correct count" do
+      Docs.stats.count.should == get_stats['count']
+    end
+
+    it "should have the correct namespace" do
+      Docs.stats.ns.should == get_stats['ns']
+    end
+
+    it "should have the correct size" do
+      Docs.stats.size.should == get_stats['size']
+    end
+
+    it "should have the correct storage size" do
+      Docs.stats.storage_size.should == get_stats['storageSize']
+    end
+
+    it "should have the correct average object size" do
+      Docs.stats.avg_obj_size.should == get_stats['avgObjSize']
+    end
+
+    it "should have the correct number of extents" do
+      if get_stats['numExtents']
+        Docs.stats.num_extents.should == get_stats['numExtents']
+      end
+    end
+
+    it "should have the correct number of indexes" do
+      Docs.stats.nindexes.should == get_stats['nindexes']
+    end
+
+    it "should have the correct last extent size" do
+      if get_stats['lastExtentSize']
+        Docs.stats.last_extent_size.should == get_stats['lastExtentSize']
+      end
+    end
+
+    it "should have the correct padding factor" do
+      if get_stats['paddingFactor']
+        Docs.stats.padding_factor.should == get_stats['paddingFactor']
+      end
+    end
+
+    it "should have the correct user flags" do
+      if get_stats['userFlags']
+        Docs.stats.user_flags.should == get_stats['userFlags']
+      end
+    end
+
+    it "should have the correct total index size" do
+      Docs.stats.total_index_size.should == get_stats['totalIndexSize']
+    end
+  end
+end