mongo_mapper 0.12.0 → 0.13.0.beta1

data/spec/unit/identity_map_middleware_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+require 'rack/test'
+
+module IdentityMapSpec
+  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 "" do
+      before do
+        @enabled = MongoMapper::Plugins::IdentityMap.enabled
+        MongoMapper::Plugins::IdentityMap.enabled = false
+      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 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
+      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 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
+
+        body.close
+
+        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
+      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
+  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

data/{test/unit/test_inspect.rb → spec/unit/inspect_spec.rb}

@@ -1,8 +1,8 @@
-require 'test_helper'
+require 'spec_helper'
 
-class InspectTest < Test::Unit::TestCase
+describe "Inspect" do
   context "#inspect" do
-    setup do
+    before do
       @document = Doc('User') do
         key :name,  String
         key :age,   Integer
@@ -12,19 +12,19 @@ class InspectTest < Test::Unit::TestCase
       @doc = @document.new(:name => 'John', :age => 29)
     end
 
-    should "print out non-nil attributes in alpha sorted order" do
+    it "should print out non-nil attributes in alpha sorted order" do
       @doc.inspect.should =~ /_id:.*, age: 29, name: "John"/
     end
     
-    should "print out all attributes when (optional) include_super argument is true" do
+    it "should print out all attributes when (optional) include_super argument is true" do
       @doc.inspect(true).should =~ /_id:.*, age: 29, email: nil, name: "John"/
     end
 
-    should "include class name" do
+    it "should include class name" do
       @doc.inspect.should =~ /^#<User/
     end
     
-    should "include embedded documents" do
+    it "should include embedded documents" do
       klass = Doc()
       pets = EDoc()
 
@@ -34,7 +34,7 @@ class InspectTest < Test::Unit::TestCase
       doc.inspect.should =~ /_id:.*, pets: \[.*_id.*, name: "Kitten".*\]/
     end
     
-    should "include embedded document" do
+    it "should include embedded document" do
       klass = Doc()
       pet = EDoc()
 

data/{test/unit/test_key.rb → spec/unit/key_spec.rb}

@@ -1,5 +1,5 @@
-require 'test_helper'
-require 'models'
+require 'spec_helper'
+
 
 class FooType < Struct.new(:bar)
   def self.to_mongo(value)
@@ -11,147 +11,159 @@ class FooType < Struct.new(:bar)
   end
 end
 
-class KeyTest < Test::Unit::TestCase
+describe "Key" do
   Key = MongoMapper::Plugins::Keys::Key
 
   context "Initializing a new key" do
-    should "allow setting the name" do
+    it "should allow setting the name" do
       Key.new(:foo, String).name.should == 'foo'
     end
 
-    should "allow setting the type" do
+    it "should allow setting the type" do
       Key.new(:foo, Integer).type.should be(Integer)
     end
 
-    should "allow setting options" do
+    it "should allow setting options" do
       Key.new(:foo, Integer, :required => true).options[:required].should be(true)
     end
 
-    should "default options to {}" do
+    it "should default options to {}" do
       Key.new(:foo, Integer, nil).options.should == {}
     end
 
-    should "symbolize option keys" do
+    it "should symbolize option keys" do
       Key.new(:foo, Integer, 'required' => true).options[:required].should be(true)
     end
 
-    should "work with just name" do
+    it "should work with just name" do
       key = Key.new(:foo)
       key.name.should == 'foo'
     end
 
-    should "work with name and type" do
+    it "should work with name and type" do
       key = Key.new(:foo, String)
       key.name.should == 'foo'
       key.type.should == String
     end
 
-    should "work with name, type, and options" do
+    it "should work with name, type, and options" do
       key = Key.new(:foo, String, :required => true)
       key.name.should == 'foo'
       key.type.should == String
       key.options[:required].should be_true
     end
 
-    should "work with name and options" do
+    it "should work with name and options" do
       key = Key.new(:foo, :required => true)
       key.name.should == 'foo'
       key.options[:required].should be_true
     end
+
+    it "should not permit reserved names" do
+      expect { Key.new(:id) }.to raise_error(/reserved/)
+    end
+
+    it "should not permit bad names" do
+      expect { Key.new(:"id.bar") }.to raise_error(/must match/)
+    end
+
+    it "should permit bad names if __dynamic" do
+      expect { Key.new(:"id.bar", :__dynamic => true) }.to_not raise_error
+    end
   end
 
   context "A key" do
-    should "be equal to another key with same name and type" do
+    it "should be equal to another key with same name and type" do
       Key.new(:name, String).should == Key.new(:name, String)
     end
 
-    should "not be equal to another key with different name" do
+    it "should not be equal to another key with different name" do
       Key.new(:name, String).should_not == Key.new(:foo, String)
     end
 
-    should "not be equal to another key with different type" do
+    it "should not be equal to another key with different type" do
       Key.new(:name, String).should_not == Key.new(:name, Integer)
     end
 
-    should "know if it is a embedded_document" do
+    it "should know if it is a embedded_document" do
       Key.new(:name, EDoc()).embeddable?.should be_true
     end
 
-    should "know if it is not a embedded_document" do
+    it "should know if it is not a embedded_document" do
       Key.new(:name, String).embeddable?.should be_false
     end
 
-    should "know if it is a number" do
+    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
     end
 
-    should "know if it is not a number" do
+    it "should know if it is not a number" do
       Key.new(:age, String).number?.should be_false
     end
   end
 
   context "for an array with :typecast option" do
-    setup   { @key = Key.new(:user_ids, Array, :typecast => 'ObjectId') }
+    before  { @key = Key.new(:user_ids, Array, :typecast => 'ObjectId') }
     subject { @key }
 
-    should "cast each element correctly" do
+    it "should cast each element correctly" do
       ids = [BSON::ObjectId.new, BSON::ObjectId.new, BSON::ObjectId.new.to_s, BSON::ObjectId.new.to_s]
       subject.set(ids).should == ids.map { |id| ObjectId.to_mongo(id) }
     end
   end
 
   context "for an array with :typecast option of Date" do
-    setup   { @key = Key.new(:dates, Array, :typecast => 'Date') }
+    before  { @key = Key.new(:dates, Array, :typecast => 'Date') }
     subject { @key }
 
-    should "cast each element correctly when get" do
+    it "should cast each element correctly when get" do
       dates = [Date.yesterday, Date.today, Date.tomorrow.to_s]
       subject.get(dates).should == dates.map { |date| Date.from_mongo(date) }
     end
 
-    should "cast each element correctly when set" do
+    it "should cast each element correctly when set" do
       dates = [Date.yesterday, Date.today, Date.tomorrow.to_s]
       subject.set(dates).should == dates.map { |date| Date.to_mongo(date) }
     end
   end
 
   context "for a set with :typecast option" do
-    setup   { @key = Key.new(:user_ids, Set, :typecast => 'ObjectId') }
+    before  { @key = Key.new(:user_ids, Set, :typecast => 'ObjectId') }
     subject { @key }
 
-    should "cast each element correctly" do
+    it "should cast each element correctly" do
       ids = [BSON::ObjectId.new, BSON::ObjectId.new, BSON::ObjectId.new.to_s, BSON::ObjectId.new.to_s]
       subject.set(ids).should == ids.map { |id| ObjectId.to_mongo(id) }
     end
   end
 
   context "setting a value with a custom type" do
-    should "correctly typecast" do
+    it "should correctly typecast" do
       key = Key.new(:foo, FooType)
       key.set("something").should == 'to_mongo'
     end
 
-    should "correctly typecast if object of that type is given" do
+    it "should correctly typecast if object of that type is given" do
       key = Key.new(:foo, FooType)
       key.set(FooType.new('something')).should == 'to_mongo'
     end
   end
 
   context "getting a value with a custom type" do
-    should "use #from_mongo to convert back to custom type" do
+    it "should use #from_mongo to convert back to custom type" do
       key = Key.new(:foo, FooType)
       key.get('something').should == 'from_mongo'
     end
   end
 
   context "getting a value" do
-    should "work with a type" do
+    it "should work with a type" do
       key = Key.new(:foo, String)
       key.get('bar').should == 'bar'
     end
 
-    should "work without type" do
+    it "should work without type" do
       key = Key.new(:foo)
       key.get([1, '2']).should == [1, '2']
       key.get(false).should == false
@@ -159,12 +171,12 @@ class KeyTest < Test::Unit::TestCase
     end
 
     context "for a embedded_document" do
-      should "default to nil" do
+      it "should default to nil" do
         key = Key.new(:foo, Address)
         key.get(nil).should be_nil
       end
 
-      should "return instance if instance" do
+      it "should return instance if instance" do
         address = Address.new(:city => 'South Bend', :state => 'IN', :zip => 46544)
         key = Key.new(:foo, Address)
         key.get(address).should == address
@@ -172,34 +184,52 @@ class KeyTest < Test::Unit::TestCase
     end
   end
 
-  context "getting a value with a default set" do
-    setup do
+  context "with a default set" do
+    before do
       @key = Key.new(:foo, String, :default => 'baz')
     end
 
-    should "return default value if value nil" do
-      @key.get(nil).should == 'baz'
-    end
+    context "#get" do
+      it "should return nil" do
+        @key.get(nil).should == nil
+      end
 
-    should "return a dup of the default value" do
-      @key.get(nil).replace('bar')
-      @key.get(nil).should == 'baz'
-    end
+      it "should return value if not blank" do
+        @key.get('foobar').should == 'foobar'
+      end
 
-    should "return value if not blank" do
-      @key.get('foobar').should == 'foobar'
+      it "should return default value if name is _id and value nil" do
+        id = BSON::ObjectId.new
+        key = Key.new(:_id, ObjectId, :default => lambda { id })
+        key.get(nil).should == id
+      end
     end
 
-    should "work with Boolean type and false value" do
-      Key.new(:active, Boolean, :default => false).get(nil).should be_false
-    end
+    context "#default_value" do
+      it "should return default value" do
+        @key.default_value.should == 'baz'
+      end
 
-    should "work with Boolean type and true value" do
-      Key.new(:active, Boolean, :default => true).get(nil).should be_true
-    end
+      it "should return a dup of the default value" do
+        @key.default_value.replace('bar')
+        @key.default_value.should == 'baz'
+      end
+
+      it "should work with Boolean type and false value" do
+        Key.new(:active, Boolean, :default => false).default_value.should be_false
+      end
 
-    should "work with procs" do
-       Key.new(:foo, String, :default => lambda { return 'hello world' }).get(nil).should == "hello world"
+      it "should work with Boolean type and true value" do
+        Key.new(:active, Boolean, :default => true).default_value.should be_true
+      end
+
+      it "should work with Array values" do
+        Key.new(:active, Array, :default => []).default_value.should == []
+      end
+
+      it "should work with procs" do
+         Key.new(:foo, String, :default => lambda { return 'hello world' }).default_value.should == "hello world"
+      end
     end
   end
 end # KeyTest