mongo_mapper 0.13.0 → 0.15.1

data/spec/unit/extensions_spec.rb

@@ -21,11 +21,11 @@ describe "Support" do
 
   context "Binary.to_mongo" do
     it "should convert to binary if not binary" do
-      Binary.to_mongo('asdfsadasdfs').is_a?(BSON::Binary).should be_true
+      Binary.to_mongo('asdfsadasdfs').is_a?(BSON::Binary).should be_truthy
     end
 
     it "should be binary if binary" do
-      Binary.to_mongo(BSON::Binary.new('asdfsadasdfs')).is_a?(BSON::Binary).should be_true
+      Binary.to_mongo(BSON::Binary.new('asdfsadasdfs')).is_a?(BSON::Binary).should be_truthy
     end
 
     it "should be nil if nil" do
@@ -42,23 +42,23 @@ describe "Support" do
 
   context "Boolean.to_mongo" do
     it "should be true for true" do
-      Boolean.to_mongo(true).should be_true
+      Boolean.to_mongo(true).should be_truthy
     end
 
     it "should be false for false" do
-      Boolean.to_mongo(false).should be_false
+      Boolean.to_mongo(false).should be_falsey
     end
 
     it "should handle odd assortment of other values" do
-      Boolean.to_mongo('true').should be_true
-      Boolean.to_mongo('t').should be_true
-      Boolean.to_mongo('1').should be_true
-      Boolean.to_mongo(1).should be_true
+      Boolean.to_mongo('true').should be_truthy
+      Boolean.to_mongo('t').should be_truthy
+      Boolean.to_mongo('1').should be_truthy
+      Boolean.to_mongo(1).should be_truthy
 
-      Boolean.to_mongo('false').should be_false
-      Boolean.to_mongo('f').should be_false
-      Boolean.to_mongo('0').should be_false
-      Boolean.to_mongo(0).should be_false
+      Boolean.to_mongo('false').should be_falsey
+      Boolean.to_mongo('f').should be_falsey
+      Boolean.to_mongo('0').should be_falsey
+      Boolean.to_mongo(0).should be_falsey
     end
 
     it "should be nil for nil" do
@@ -68,11 +68,11 @@ describe "Support" do
 
   context "Boolean.from_mongo" do
     it "should be true for true" do
-      Boolean.from_mongo(true).should be_true
+      Boolean.from_mongo(true).should be_truthy
     end
 
     it "should be false for false" do
-      Boolean.from_mongo(false).should be_false
+      Boolean.from_mongo(false).should be_falsey
     end
 
     it "should be nil for nil" do
@@ -153,7 +153,7 @@ describe "Support" do
     it "should be hash if nil" do
       hash = Hash.from_mongo(nil)
       hash.should == {}
-      hash.is_a?(HashWithIndifferentAccess).should be_true
+      hash.is_a?(HashWithIndifferentAccess).should be_truthy
     end
   end
 
@@ -359,7 +359,7 @@ describe "Support" do
 
       time = Time.from_mongo(Time.utc(2009, 10, 1))
       time.should == Time.zone.local(2009, 9, 30, 14)
-      time.is_a?(ActiveSupport::TimeWithZone).should be_true
+      time.is_a?(ActiveSupport::TimeWithZone).should be_truthy
 
       Time.zone = nil
     end
@@ -387,8 +387,32 @@ 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
+
+  context "Symbol.to_mongo" do
+    it "should convert value to_sym" do
+      Symbol.to_mongo('asdfasdfasdf').should == :asdfasdfasdf
+    end
+
+    it "should convert string if not string" do
+      Symbol.to_mongo(123).should == :'123'
+    end
+
+    it "should return nil for nil" do
+      Symbol.to_mongo(nil).should be_nil
+    end
+  end
+
+  context "Symbol.from_mongo" do
+    it "should convert value to_sym" do
+      Symbol.from_mongo(:asdfasdfasdf).should == :asdfasdfasdf
+    end
+
+    it "should return nil for nil" do
+      Symbol.from_mongo(nil).should be_nil
+    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_true
-      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
-          MongoMapper::Plugins::IdentityMap.should_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
-          MongoMapper::Plugins::IdentityMap.should_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
-  #       MongoMapper::Plugins::IdentityMap.should_receive(:clear).twice
-  #       get '/'
-  #     end
-  #   end
-
-  #   context "when the request raises an error" do
-  #     it "should clear the identity map" do
-  #       MongoMapper::Plugins::IdentityMap.should_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'
@@ -50,29 +49,29 @@ describe "Key" do
       key = Key.new(:foo, String, :required => true)
       key.name.should == 'foo'
       key.type.should == String
-      key.options[:required].should be_true
+      key.options[:required].should be_truthy
     end
 
     it "should work with name and options" do
       key = Key.new(:foo, :required => true)
       key.name.should == 'foo'
-      key.options[:required].should be_true
+      key.options[:required].should be_truthy
     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
 
@@ -90,20 +89,20 @@ describe "Key" do
     end
 
     it "should know if it is a embedded_document" do
-      Key.new(:name, EDoc()).embeddable?.should be_true
+      Key.new(:name, EDoc()).embeddable?.should be_truthy
     end
 
     it "should know if it is not a embedded_document" do
-      Key.new(:name, String).embeddable?.should be_false
+      Key.new(:name, String).embeddable?.should be_falsey
     end
 
     it "should know if it is a number" do
-      Key.new(:age, Integer).number?.should be_true
-      Key.new(:age, Float).number?.should be_true
+      Key.new(:age, Integer).number?.should be_truthy
+      Key.new(:age, Float).number?.should be_truthy
     end
 
     it "should know if it is not a number" do
-      Key.new(:age, String).number?.should be_false
+      Key.new(:age, String).number?.should be_falsey
     end
   end
 
@@ -148,31 +147,34 @@ describe "Key" do
 
     context "with :read" do
       let(:accessor) { :read }
-      its(:read_accessor?) { should be_true }
-      its(:write_accessor?) { should be_false }
-      its(:predicate_accessor?) { should be_false }
+
+      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 }
-      its(:read_accessor?) { should be_false }
-      its(:write_accessor?) { should be_true }
-      its(:predicate_accessor?) { should be_false }
+
+      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 }
-      its(:read_accessor?) { should be_false }
-      its(:write_accessor?) { should be_false }
-      its(:predicate_accessor?) { should be_true }
+
+      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] }
 
-      its(:read_accessor?) { should be_true }
-      its(:write_accessor?) { should be_true }
-      its(:predicate_accessor?) { should be_false }
+      it { subject.read_accessor?.should be_truthy }
+      it { subject.write_accessor?.should be_truthy }
+      it { subject.predicate_accessor?.should be_falsey }
     end
   end
 
@@ -254,11 +256,11 @@ describe "Key" do
       end
 
       it "should work with Boolean type and false value" do
-        Key.new(:active, Boolean, :default => false).default_value.should be_false
+        Key.new(:active, Boolean, :default => false).default_value.should be_falsey
       end
 
       it "should work with Boolean type and true value" do
-        Key.new(:active, Boolean, :default => true).default_value.should be_true
+        Key.new(:active, Boolean, :default => true).default_value.should be_truthy
       end
 
       it "should work with Array values" do

data/spec/unit/keys_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 
-
 describe "Key" do
   context ".new with no id and _id of type integer" do
     it "should not error" do
@@ -9,18 +8,18 @@ describe "Key" do
           key :_id, Integer
         end
         # No sensible default id for integer, people better pass them in if they user this
-        silence_stderr { klass.new.id.should be_nil }
+        suppress_stderr { klass.new.id.should be_nil }
       }.should_not raise_error
     end
   end
 
   context ".key?(:symbol)" do
     it "should be true if document has key" do
-      Address.key?(:city).should be_true
+      Address.key?(:city).should be_truthy
     end
 
     it "should be false if document does not have key" do
-      Address.key?(:foo).should be_false
+      Address.key?(:foo).should be_falsey
     end
   end
 
@@ -59,11 +58,11 @@ describe "Key" do
 
   context ".key?('string')" do
     it "should be true if document has key" do
-      Address.key?('city').should be_true
+      Address.key?('city').should be_truthy
     end
 
     it "should be false if document does not have key" do
-      Address.key?('foo').should be_false
+      Address.key?('foo').should be_falsey
     end
   end
 
@@ -82,11 +81,11 @@ describe "Key" do
     end
 
     it "should use []= for keys instead of public writer" do
-      expect {
+      lambda {
         doc = @klass.first
         doc.user['id'].should   == 1
         doc.user['name'].should == 'John Nunemaker'
-      }.to_not raise_error
+      }.should_not raise_error
     end
   end
 
@@ -141,15 +140,25 @@ describe "Key" do
         key :value, Integer, :default => lambda { counter += 1 }
       end
 
-      expect { instance = klass.create }.to change { counter }.by(1)
-      expect {
+      lambda { instance = klass.create }.should change { counter }.by(1)
+      lambda {
         instance.reload.value.should == 1
 
         instance.value = 10
         instance.save
 
         instance.reload.value.should == 10
-      }.to_not change { counter }
+      }.should_not change { counter }
+    end
+  end
+
+  context "with attributes key" do
+    it "should raise an error" do
+      lambda do
+        klass = Doc do
+          key :attributes, Hash
+        end
+      end.should raise_error("`attributes` is a reserved key name")
     end
   end
 end # KeyTest