mongo_mapper 0.13.1 → 0.15.2

data/spec/functional/sci_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 describe "Single collection inheritance (document)" do
   context "without a connection", :without_connection => true do
     it "should attempt to create a connection during inheritance" do
-      Mongo::MongoClient.should_not_receive(:new)
+      Mongo::Client.should_not_receive(:new)
       doc = Class.new
       doc.send(:include, MongoMapper::Document)
-      expect {
+      lambda {
         Class.new(doc)
-      }.to_not raise_error
+      }.should_not raise_error
     end
 
     it "should pick up a connection if one wasn't set" do
@@ -17,7 +17,7 @@ describe "Single collection inheritance (document)" do
       klass = Class.new(doc)
       klass.connection.should be_nil
       MongoMapper.connection
-      klass.connection.should be_a Mongo::MongoClient
+      klass.connection.should be_a Mongo::Client
     end
   end
 
@@ -27,7 +27,7 @@ describe "Single collection inheritance (document)" do
         include MongoMapper::Document
         key :name, String
       end
-      DocParent.collection.remove
+      DocParent.collection.drop
 
       class ::DocDaughter < ::DocParent; end
       class ::DocSon < ::DocParent; end
@@ -49,7 +49,7 @@ describe "Single collection inheritance (document)" do
     end
 
     it "should automatically add _type key to store class" do
-      DocParent.key?(:_type).should be_true
+      DocParent.key?(:_type).should be_truthy
     end
 
     it "should use modifiers properly" do
@@ -61,7 +61,7 @@ describe "Single collection inheritance (document)" do
     it "should use the same connection in the subclass" do
       parent_class = Class.new do
         include MongoMapper::Document
-        connection Mongo::MongoClient.new
+        connection Mongo::Client.new(['127.0.0.1:27017'])
       end
 
       child_class = Class.new(parent_class) do
@@ -323,7 +323,7 @@ describe "Single collection inheritance (document)" do
     end
 
     it "should automatically add _type key" do
-      Grandparent.key?(:_type).should be_true
+      Grandparent.key?(:_type).should be_truthy
     end
 
     context ".single_collection_inherited?" do
@@ -377,4 +377,4 @@ describe "Single collection inheritance (document)" do
       p.reload.article_parent.sci_polymorphic_posts.all.should include(p)
     end
   end
-end
+end

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
@@ -200,5 +200,326 @@ describe "Scopes" do
         Blog.scopes.keys.map(&:to_s).should =~ %w(by_slug by_title published)
       end
     end
+
+    context 'with predefined class method name' do
+      it 'should raise ArgumentError' do
+        bad_names = %i(private public protected allocate new name parent superclass reload)
+        bad_names.each do |bad_name|
+          -> {
+            Doc() do
+              scope bad_name, -> {}
+            end
+          }.should raise_error(ArgumentError, /You tried to define a scope named "#{bad_name}"/)
+        end
+      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
+
+  describe "thread safety" do
+    before do
+      @klass = Doc do
+        key :name, String
+      end
+
+      @threads = []
+    end
+
+    after do
+      @threads.each do |thread|
+        thread.kill
+      end
+    end
+
+    def make_thread(&block)
+      Thread.new(&block).tap do |thread|
+        @threads << thread
+      end
+    end
+
+    def wait_for_threads!
+      @threads.each { |t| t.join }
+    end
+
+    it "should not taint another thread's active scopes" do
+      count_active_scopes = nil
+      second_thread_run = false
+
+      make_thread do
+        @klass.with_scope(name: 'foo') do
+          loop do
+            sleep Float::EPSILON
+            break if second_thread_run
+          end
+        end
+      end
+
+      make_thread do
+        count_active_scopes = @klass.active_scopes.length
+        second_thread_run = true
+      end
+
+      wait_for_threads!
+
+      count_active_scopes.should == 0
+    end
+
+    it "should not taint another thread's count method" do
+      @klass.create!(name: 'foo')
+      @klass.create!(name: 'bar')
+
+      klass_count = nil
+      second_thread_run = false
+
+      make_thread do
+        @klass.with_scope(name: 'foo') do
+          loop do
+            sleep Float::EPSILON
+            break if second_thread_run
+          end
+        end
+      end
+
+      make_thread do
+        klass_count = @klass.count
+        second_thread_run = true
+      end
+
+      wait_for_threads!
+
+      klass_count.should == 2
+    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