mongo_mapper 0.14.0.rc1 → 0.15.3

data/spec/quality_spec.rb

@@ -46,6 +46,6 @@ describe "The library itself" do
         error_messages << check_for_extra_spaces(filename)
       end
     end
-    expect(error_messages.compact).to be_well_formed
+    error_messages.compact.should be_well_formed
   end
 end

data/spec/spec_helper.rb

@@ -2,10 +2,21 @@ $:.unshift(File.expand_path('../../lib', __FILE__))
 
 require 'rubygems'
 require 'bundler/setup'
+
+# workaround for https://github.com/jruby/jruby/issues/6547
+if RUBY_PLATFORM == 'java'
+  require 'i18n/backend'
+  require 'i18n/backend/simple'
+end
+
+Bundler.require(:default)
 require 'fileutils'
 require 'timecop'
 require "generator_spec/test_case"
-# require 'ruby-debug'
+
+if RUBY_ENGINE == "ruby" && RUBY_VERSION >= '2.3'
+  require 'byebug'
+end
 
 if RUBY_PLATFORM != "java"
   if ENV['TRAVIS']
@@ -40,7 +51,7 @@ def Doc(name='Class', &block)
   end
 
   klass.class_eval(&block) if block_given?
-  klass.collection.remove
+  klass.collection.drop
   klass
 end
 
@@ -59,21 +70,28 @@ def EDoc(name='Class', &block)
 end
 
 def drop_indexes(klass)
-  klass.collection.drop_indexes if klass.database.collection_names.include?(klass.collection.name)
+  klass.collection.indexes.drop_all if klass.database.collection_names.include?(klass.collection.name)
 end
 
 log_dir = File.expand_path('../../log', __FILE__)
 FileUtils.mkdir_p(log_dir) unless File.exist?(log_dir)
 logger = Logger.new(log_dir + '/test.log')
 
-MongoMapper.connection = Mongo::MongoClient.new('127.0.0.1', 27017, :logger => logger)
-MongoMapper.database = "test"
-MongoMapper.database.collections.each { |c| c.drop_indexes }
+Mongo::Logger.logger = logger
+
+MongoMapper.connection = Mongo::Client.new(['127.0.0.1:27017'], :database => 'test')
+MongoMapper.database.collections.each { |c| c.indexes.drop_all }
 Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|
+  config.example_status_persistence_file_path = "./spec/examples.txt"
+
   config.expect_with :rspec do |c|
-    c.syntax = [:should, :expect]
+    c.syntax = :should
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :should
   end
 
   config.around(:each, :without_connection) do |example|
@@ -81,5 +99,18 @@ RSpec.configure do |config|
     example.run
     MongoMapper.connection = old
   end
-end
 
+  def suppress_stderr
+    begin
+      original_stderr = $stderr.clone
+      $stderr.reopen(File.new('/dev/null', 'w'))
+      retval = yield
+    rescue Exception => e
+      $stderr.reopen(original_stderr)
+      raise e
+    ensure
+      $stderr.reopen(original_stderr)
+    end
+    retval
+  end
+end

data/spec/support/matchers.rb

@@ -10,6 +10,6 @@ end
 
 RSpec::Matchers.define :have_index do |index_name|
   match do |model|
-    model.collection.index_information.detect { |index| index[0] == index_name }.present?
+    model.collection.indexes.get(index_name).present?
   end
 end

data/spec/unit/associations/proxy_spec.rb

@@ -77,10 +77,6 @@ describe "Proxy" do
     @proxy.proxy_owner.should == @owner
   end
 
-  it "should alias proxy target to target" do
-    @proxy.proxy_target.should == @target
-  end
-
   context "send" do
     it "should work if proxy responds to method" do
       @proxy.send(:reset)
@@ -92,12 +88,24 @@ describe "Proxy" do
     end
 
     it "should not work if neither the proxy or target respond to method" do
-      lambda { @proxy.send(:gsub) }.should raise_error
+      lambda { @proxy.send(:gsub) }.should raise_error(NoMethodError)
     end
 
     it "should work if a proc is passed" do
       p = Proc.new {|x| x+1}
       @proxy.send(:collect, &p).should == [2,3]
     end
+
+    it "should not respond to private method" do
+      @proxy.reload # To load @proxy.target
+      @proxy.target.extend(Module.new do
+        private
+
+          def private_foo
+          end
+      end)
+
+      lambda { @proxy.private_foo }.should raise_error(NoMethodError, /private method `private_foo' called/)
+    end
   end
 end

data/spec/unit/clone_spec.rb

@@ -45,7 +45,7 @@ describe "Clone" do
       end
 
       it "should clone a cloned document" do
-        expect { @doc.clone.clone }.to_not raise_error
+        lambda { @doc.clone.clone }.should_not raise_error
         @doc.clone.clone.id.should be_a BSON::ObjectId
       end
     end

data/spec/unit/document_spec.rb

@@ -21,11 +21,11 @@ describe "Document" do
     end
 
     it "should have a connection" do
-      @document.connection.should be_instance_of(Mongo::MongoClient)
+      @document.connection.should be_instance_of(Mongo::Client)
     end
 
     it "should allow setting different connection without affecting the default" do
-      conn = Mongo::MongoClient.new
+      conn = Mongo::Client.new(['127.0.0.1:27001'])
       @document.connection conn
       @document.connection.should == conn
       @document.connection.should_not == MongoMapper.connection
@@ -152,7 +152,7 @@ describe "Document" do
 
       it "should be true if id but using custom id and not saved yet" do
         @document.key :_id, String
-        doc = silence_stderr { @document.new }
+        doc = suppress_stderr { @document.new }
         doc.id = '1234'
         doc.new?.should be_truthy
       end

data/spec/unit/embedded_document_spec.rb

@@ -210,7 +210,7 @@ describe "EmbeddedDocument" do
         end
 
         it "should not include descendant keys" do
-          lambda { Parent.new.other_child }.should raise_error
+          lambda { Parent.new.other_child }.should raise_error(NoMethodError)
         end
       end
 
@@ -308,7 +308,7 @@ describe "EmbeddedDocument" do
         end
 
         it "should not throw error if initialized with nil" do
-          expect { @document.new(nil) }.to_not raise_error
+          lambda { @document.new(nil) }.should_not raise_error
         end
       end
 
@@ -661,16 +661,15 @@ describe "EmbeddedDocument" do
 
          it "should should raise errors when invalid" do
            @doc.name = ''
-           expect { @doc.save! }.to raise_error(MongoMapper::DocumentNotValid)
+           lambda { @doc.save! }.should raise_error(MongoMapper::DocumentNotValid)
          end
 
          it "should should raise errors when root document is invalid" do
            @root.name = ''
            @root.save(:validate => false)
-           expect{ @doc.save! }.to raise_error(MongoMapper::DocumentNotValid)
+           lambda { @doc.save! }.should raise_error(MongoMapper::DocumentNotValid)
          end
        end
     end # instance of a embedded document
   end
 end
-

data/spec/unit/extensions_spec.rb

@@ -207,7 +207,7 @@ describe "Support" do
   context "ObjectId#to_mongo" do
     it "should call class to_mongo with self" do
       object = Object.new
-      expect(object.class).to receive(:to_mongo).with(object)
+      object.class.should_receive(:to_mongo).with(object)
       object.to_mongo
     end
   end
@@ -387,7 +387,7 @@ describe "Support" do
 
       it "should support ruby driver syntax also" do
         id = BSON::ObjectId.new
-        id.original_to_json.should == %Q({"$oid": "#{id}"})
+        id.original_to_json.should == %Q({"$oid":"#{id}"})
       end
     end
   end

data/spec/unit/identity_map_middleware_spec.rb

@@ -19,116 +19,85 @@ module IdentityMapSpec
       end.to_app
     end
 
-    context "" do
-      before do
-        @enabled = MongoMapper::Plugins::IdentityMap.enabled
-        MongoMapper::Plugins::IdentityMap.enabled = false
-      end
+    before do
+      @enabled = MongoMapper::Plugins::IdentityMap.enabled
+      MongoMapper::Plugins::IdentityMap.enabled = false
+    end
 
-      after do
-        MongoMapper::Plugins::IdentityMap.enabled = @enabled
-      end
+    after do
+      MongoMapper::Plugins::IdentityMap.enabled = @enabled
+    end
 
-      it "should delegate" do
-        called = false
-        mw = MongoMapper::Middleware::IdentityMap.new lambda { |env|
-          called = true
-          [200, {}, nil]
-        }
-        mw.call({})
-        called.should be_truthy
-      end
+    it "should delegate" do
+      called = false
+      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env|
+        called = true
+        [200, {}, nil]
+      }
+      mw.call({})
+      called.should be_truthy
+    end
 
-      it "should enable identity map during delegation" do
-        mw = MongoMapper::Middleware::IdentityMap.new lambda { |env|
-          MongoMapper::Plugins::IdentityMap.should be_enabled
-          [200, {}, nil]
-        }
-        mw.call({})
-      end
+    it "should enable identity map during delegation" do
+      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env|
+        MongoMapper::Plugins::IdentityMap.should be_enabled
+        [200, {}, nil]
+      }
+      mw.call({})
+    end
 
-      class Enum < Struct.new(:iter)
-        def each(&b)
-          iter.call(&b)
-        end
+    class Enum < Struct.new(:iter)
+      def each(&b)
+        iter.call(&b)
       end
+    end
 
-      it "should enable IM for body each" do
-        mw = MongoMapper::Middleware::IdentityMap.new lambda { |env|
-          [200, {}, Enum.new(lambda { |&b|
-            MongoMapper::Plugins::IdentityMap.should be_enabled
-            b.call "hello"
-          })]
-        }
-        body = mw.call({}).last
-        body.each { |x| x.should eql('hello') }
-      end
+    it "should enable IM for body each" do
+      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env|
+        [200, {}, Enum.new(lambda { |&b|
+          MongoMapper::Plugins::IdentityMap.should be_enabled
+          b.call "hello"
+        })]
+      }
+      body = mw.call({}).last
+      body.each { |x| x.should eql('hello') }
+    end
 
-      it "should disable IM after body close" do
-        mw = MongoMapper::Middleware::IdentityMap.new lambda { |env| [200, {}, []] }
-        body = mw.call({}).last
-        MongoMapper::Plugins::IdentityMap.should be_enabled
-        body.close
-        MongoMapper::Plugins::IdentityMap.should_not be_enabled
-      end
+    it "should disable IM after body close" do
+      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env| [200, {}, []] }
+      body = mw.call({}).last
+      MongoMapper::Plugins::IdentityMap.should be_enabled
+      body.close
+      MongoMapper::Plugins::IdentityMap.should_not be_enabled
+    end
 
-      it "should clear IM after body close" do
-        mw = MongoMapper::Middleware::IdentityMap.new lambda { |env| [200, {}, []] }
-        body = mw.call({}).last
+    it "should clear IM after body close" do
+      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env| [200, {}, []] }
+      body = mw.call({}).last
 
-        MongoMapper::Plugins::IdentityMap.repository['hello'] = 'world'
-        MongoMapper::Plugins::IdentityMap.repository.should_not be_empty
+      MongoMapper::Plugins::IdentityMap.repository['hello'] = 'world'
+      MongoMapper::Plugins::IdentityMap.repository.should_not be_empty
 
-        body.close
+      body.close
 
-        MongoMapper::Plugins::IdentityMap.repository.should be_empty
-      end
+      MongoMapper::Plugins::IdentityMap.repository.should be_empty
+    end
 
-      context "with a successful request" do
-        it "should clear the identity map" do
-          expect(MongoMapper::Plugins::IdentityMap).to receive(:clear).twice
-          get '/'
-        end
+    context "with a successful request" do
+      it "should clear the identity map" do
+        # for some reason, body.close gets called twice - once in rack-2.2.3/lib/rack/response.rb:281
+        # the other time rack-test-0.8.3/lib/rack/mock_session.rb:32
+        # use at_least(:twice) here to handle the error happening more than twice
+        MongoMapper::Plugins::IdentityMap.should_receive(:clear).at_least(:twice)
+        get '/'
       end
+    end
 
-      context "when the request raises an error" do
-        it "should clear the identity map" do
-          expect(MongoMapper::Plugins::IdentityMap).to receive(:clear).once
-          get '/fail' rescue nil
-        end
+    context "when the request raises an error" do
+      it "should clear the identity map" do
+        MongoMapper::Plugins::IdentityMap.should_receive(:clear).once
+        get '/fail' rescue nil
       end
     end
   end
-
-  # describe "IdentityMapMiddleware" do
-  #   include Rack::Test::Methods
-
-  #   def app
-  #     @app ||= Rack::Builder.new do
-  #       use MongoMapper::Middleware::IdentityMap
-  #       map "/" do
-  #         run lambda {|env| [200, {}, []] }
-  #       end
-  #       map "/fail" do
-  #         run lambda {|env| raise "FAIL!" }
-  #       end
-  #     end.to_app
-  #   end
-
-  #   context "with a successful request" do
-  #     it "should clear the identity map" do
-  #       expect(MongoMapper::Plugins::IdentityMap).to receive(:clear).twice
-  #       get '/'
-  #     end
-  #   end
-
-  #   context "when the request raises an error" do
-  #     it "should clear the identity map" do
-  #       expect(MongoMapper::Plugins::IdentityMap).to receive(:clear).twice
-  #       get '/fail' rescue nil
-  #     end
-  #   end
-
-
-  # end
-end
+end

data/spec/unit/key_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 
-
 class FooType < Struct.new(:bar)
   def self.to_mongo(value)
     'to_mongo'
@@ -60,19 +59,19 @@ describe "Key" do
     end
 
     it "should not permit reserved names" do
-      expect { Key.new(:id) }.to raise_error(/reserved/)
+      lambda { Key.new(:id) }.should raise_error(/reserved/)
     end
 
     it "should not permit bad names" do
-      expect { Key.new(:"id.bar") }.to raise_error(/must match/)
+      lambda { Key.new(:"id.bar") }.should raise_error(/must match/)
     end
 
     it "should permit bad names if __dynamic" do
-      expect { Key.new(:"id.bar", :__dynamic => true) }.to_not raise_error
+      lambda { Key.new(:"id.bar", :__dynamic => true) }.should_not raise_error
     end
 
     it "should permit bad names if it is not to create accessors" do
-      expect { Key.new(:"id.bar", :accessors => :skip) }.to_not raise_error
+      lambda { Key.new(:"id.bar", :accessors => :skip) }.should_not raise_error
     end
   end
 
@@ -149,33 +148,33 @@ describe "Key" do
     context "with :read" do
       let(:accessor) { :read }
 
-      it { expect( subject.read_accessor? ).to be_truthy }
-      it { expect( subject.write_accessor? ).to be_falsey }
-      it { expect( subject.predicate_accessor? ).to be_falsey }
+      it { subject.read_accessor?.should be_truthy }
+      it { subject.write_accessor?.should be_falsey }
+      it { subject.predicate_accessor?.should be_falsey }
     end
 
     context "with :write" do
       let(:accessor) { :write }
 
-      it { expect( subject.read_accessor? ).to be_falsey }
-      it { expect( subject.write_accessor? ).to be_truthy }
-      it { expect( subject.predicate_accessor? ).to be_falsey }
+      it { subject.read_accessor?.should be_falsey }
+      it { subject.write_accessor?.should be_truthy }
+      it { subject.predicate_accessor?.should be_falsey }
     end
 
     context "with :predicate" do
       let(:accessor) { :predicate }
 
-      it { expect( subject.read_accessor? ).to be_falsey }
-      it { expect( subject.write_accessor? ).to be_falsey }
-      it { expect( subject.predicate_accessor? ).to be_truthy }
+      it { subject.read_accessor?.should be_falsey }
+      it { subject.write_accessor?.should be_falsey }
+      it { subject.predicate_accessor?.should be_truthy }
     end
 
     context "with an array of options" do
       let(:accessor) { [:read, :write] }
 
-      it { expect( subject.read_accessor? ).to be_truthy }
-      it { expect( subject.write_accessor? ).to be_truthy }
-      it { expect( subject.predicate_accessor? ).to be_falsey }
+      it { subject.read_accessor?.should be_truthy }
+      it { subject.write_accessor?.should be_truthy }
+      it { subject.predicate_accessor?.should be_falsey }
     end
   end