use a proxy object to call close on the mutex when the body is closed. closes #87

1 files changed, 77 insertions, 5 deletions

diff --git a/test/spec_lock.rb b/test/spec_lock.rb
index 3b3fd45e..43ad8e85 100644
--- a/test/spec_lock.rb
+++ b/test/spec_lock.rb
@@ -12,25 +12,97 @@ class Lock
     @synchronized = true
     yield
   end
+
+  def lock
+    @synchronized = true
+  end
+
+  def unlock
+    @synchronized = false
+  end
 end
 
 describe Rack::Lock do
+  describe 'Proxy' do
+    should 'delegate each' do
+      lock     = Lock.new
+      env      = Rack::MockRequest.env_for("/")
+      response = Class.new {
+        attr_accessor :close_called
+        def initialize; @close_called = false; end
+        def each; %w{ hi mom }.each { |x| yield x }; end
+      }.new
+
+      app = Rack::Lock.new(lambda { |inner_env| [200, {}, response] }, lock)
+      response = app.call(env)[2]
+      list = []
+      response.each { |x| list << x }
+      list.should.equal %w{ hi mom }
+    end
+  end
+
+  should 'call super on close' do
+    lock     = Lock.new
+    env      = Rack::MockRequest.env_for("/")
+    response = Class.new {
+      attr_accessor :close_called
+      def initialize; @close_called = false; end
+      def close; @close_called = true; end
+    }.new
+
+    app = Rack::Lock.new(lambda { |inner_env| [200, {}, response] }, lock)
+    app.call(env)
+    response.close_called.should.equal false
+    response.close
+    response.close_called.should.equal true
+  end
+
+  should "not unlock until body is closed" do
+    lock     = Lock.new
+    env      = Rack::MockRequest.env_for("/")
+    response = Object.new
+    app      = Rack::Lock.new(lambda { |inner_env| [200, {}, response] }, lock)
+    lock.synchronized.should.equal false
+    response = app.call(env)[2]
+    lock.synchronized.should.equal true
+    response.close
+    lock.synchronized.should.equal false
+  end
+
+  should "return value from app" do
+    lock = Lock.new
+    env  = Rack::MockRequest.env_for("/")
+    body = [200, {}, %w{ hi mom }]
+    app  = Rack::Lock.new(lambda { |inner_env| body }, lock)
+    app.call(env).should.equal body
+  end
+
   should "call synchronize on lock" do
     lock = Lock.new
     env = Rack::MockRequest.env_for("/")
-    app = Rack::Lock.new(lambda { |inner_env| }, lock)
+    app = Rack::Lock.new(lambda { |inner_env|
+      [200, {}, %w{ a b c }]
+    }, lock)
     lock.synchronized.should.equal false
     app.call(env)
     lock.synchronized.should.equal true
   end
 
   should "set multithread flag to false" do
-    app = Rack::Lock.new(lambda { |env| env['rack.multithread'] })
-    app.call(Rack::MockRequest.env_for("/")).should.equal false
+    app = Rack::Lock.new(lambda { |env|
+      env['rack.multithread'].should.equal false
+      [200, {}, %w{ a b c }]
+    })
+    app.call(Rack::MockRequest.env_for("/"))
   end
 
   should "reset original multithread flag when exiting lock" do
-    app = Rack::Lock.new(lambda { |env| env })
-    app.call(Rack::MockRequest.env_for("/"))['rack.multithread'].should.equal true
+    app = Class.new(Rack::Lock) {
+      def call(env)
+        env['rack.multithread'].should.equal true
+        super
+      end
+    }.new(lambda { |env| [200, {}, %w{ a b c }] })
+    app.call(Rack::MockRequest.env_for("/"))
   end
 end