rack 1.1.6 → 1.6.9

data/test/spec_rack_lobster.rb

@@ -1,45 +0,0 @@
-require 'test/spec'
-
-require 'rack/lobster'
-require 'rack/mock'
-
-context "Rack::Lobster::LambdaLobster" do
-  specify "should be a single lambda" do
-    Rack::Lobster::LambdaLobster.should.be.kind_of Proc
-  end
-  
-  specify "should look like a lobster" do
-    res = Rack::MockRequest.new(Rack::Lobster::LambdaLobster).get("/")
-    res.should.be.ok
-    res.body.should.include "(,(,,(,,,("
-    res.body.should.include "?flip"
-  end
-
-  specify "should be flippable" do
-    res = Rack::MockRequest.new(Rack::Lobster::LambdaLobster).get("/?flip")
-    res.should.be.ok
-    res.body.should.include "(,,,(,,(,("
-  end
-end
-
-context "Rack::Lobster" do
-  specify "should look like a lobster" do
-    res = Rack::MockRequest.new(Rack::Lobster.new).get("/")
-    res.should.be.ok
-    res.body.should.include "(,(,,(,,,("
-    res.body.should.include "?flip"
-    res.body.should.include "crash"
-  end
-
-  specify "should be flippable" do
-    res = Rack::MockRequest.new(Rack::Lobster.new).get("/?flip=left")
-    res.should.be.ok
-    res.body.should.include "(,,,(,,(,("
-  end
-
-  specify "should provide crashing for testing purposes" do
-    lambda {
-      Rack::MockRequest.new(Rack::Lobster.new).get("/?flip=crash")
-    }.should.raise
-  end
-end

data/test/spec_rack_lock.rb

@@ -1,38 +0,0 @@
-require 'test/spec'
-
-require 'rack/mock'
-require 'rack/lock'
-
-context "Rack::Lock" do
-  class Lock
-    attr_reader :synchronized
-
-    def initialize
-      @synchronized = false
-    end
-
-    def synchronize
-      @synchronized = true
-      yield
-    end
-  end
-
-  specify "should call synchronize on lock" do
-    lock = Lock.new
-    env = Rack::MockRequest.env_for("/")
-    app = Rack::Lock.new(lambda { |env| }, lock)
-    lock.synchronized.should.equal false
-    app.call(env)
-    lock.synchronized.should.equal true
-  end
-
-  specify "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
-  end
-
-  specify "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
-  end
-end

data/test/spec_rack_logger.rb

@@ -1,21 +0,0 @@
-require 'rack/logger'
-require 'rack/lint'
-require 'stringio'
-
-context "Rack::Logger" do
-  specify "logs to rack.errors" do
-    app = lambda { |env|
-      log = env['rack.logger']
-      log.debug("Created logger")
-      log.info("Program started")
-      log.warn("Nothing to do!")
-
-      [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]]
-    }
-
-    errors = StringIO.new
-    Rack::Logger.new(app).call({'rack.errors' => errors})
-    errors.string.should.match "Program started"
-    errors.string.should.match "Nothing to do"
-  end
-end

data/test/spec_rack_methodoverride.rb

@@ -1,60 +0,0 @@
-require 'test/spec'
-
-require 'rack/mock'
-require 'rack/methodoverride'
-require 'stringio'
-
-context "Rack::MethodOverride" do
-  specify "should not affect GET requests" do
-    env = Rack::MockRequest.env_for("/?_method=delete", :method => "GET")
-    app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) })
-    req = app.call(env)
-
-    req.env["REQUEST_METHOD"].should.equal "GET"
-  end
-
-  specify "_method parameter should modify REQUEST_METHOD for POST requests" do
-    env = Rack::MockRequest.env_for("/", :method => "POST", :input => "_method=put")
-    app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) })
-    req = app.call(env)
-
-    req.env["REQUEST_METHOD"].should.equal "PUT"
-  end
-
-  specify "X-HTTP-Method-Override header should modify REQUEST_METHOD for POST requests" do
-    env = Rack::MockRequest.env_for("/",
-            :method => "POST",
-            "HTTP_X_HTTP_METHOD_OVERRIDE" => "PUT"
-          )
-    app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) })
-    req = app.call(env)
-
-    req.env["REQUEST_METHOD"].should.equal "PUT"
-  end
-
-  specify "should not modify REQUEST_METHOD if the method is unknown" do
-    env = Rack::MockRequest.env_for("/", :method => "POST", :input => "_method=foo")
-    app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) })
-    req = app.call(env)
-
-    req.env["REQUEST_METHOD"].should.equal "POST"
-  end
-
-  specify "should not modify REQUEST_METHOD when _method is nil" do
-    env = Rack::MockRequest.env_for("/", :method => "POST", :input => "foo=bar")
-    app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) })
-    req = app.call(env)
-
-    req.env["REQUEST_METHOD"].should.equal "POST"
-  end
-
-  specify "should store the original REQUEST_METHOD prior to overriding" do
-    env = Rack::MockRequest.env_for("/",
-            :method => "POST",
-            :input  => "_method=options")
-    app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) })
-    req = app.call(env)
-
-    req.env["rack.methodoverride.original_method"].should.equal "POST"
-  end
-end

data/test/spec_rack_nulllogger.rb

@@ -1,13 +0,0 @@
-require 'rack/nulllogger'
-require 'rack/lint'
-require 'rack/mock'
-
-context "Rack::NullLogger" do
-  specify "acks as a nop logger" do
-    app = lambda { |env|
-      env['rack.logger'].warn "b00m"
-      [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]]
-    }
-    Rack::NullLogger.new(app).call({})
-  end
-end

data/test/spec_rack_recursive.rb

@@ -1,77 +0,0 @@
-require 'test/spec'
-
-require 'rack/recursive'
-require 'rack/urlmap'
-require 'rack/response'
-require 'rack/mock'
-
-context "Rack::Recursive" do
-  setup do
-
-    @app1 = lambda { |env|
-      res = Rack::Response.new
-      res["X-Path-Info"] = env["PATH_INFO"]
-      res["X-Query-String"] = env["QUERY_STRING"]
-      res.finish do |res|
-        res.write "App1"
-      end
-    }
-
-    @app2 = lambda { |env|
-      Rack::Response.new.finish do |res|
-        res.write "App2"
-        _, _, body = env['rack.recursive.include'].call(env, "/app1")
-        body.each { |b|
-          res.write b
-        }
-      end
-    }
-
-    @app3 = lambda { |env|
-      raise Rack::ForwardRequest.new("/app1")
-    }
-
-    @app4 = lambda { |env|
-      raise Rack::ForwardRequest.new("http://example.org/app1/quux?meh")
-    }
-
-  end
-
-  specify "should allow for subrequests" do
-    res = Rack::MockRequest.new(Rack::Recursive.new(
-                                  Rack::URLMap.new("/app1" => @app1,
-                                                   "/app2" => @app2))).
-      get("/app2")
-
-    res.should.be.ok
-    res.body.should.equal "App2App1"    
-  end
-
-  specify "should raise error on requests not below the app" do
-    app = Rack::URLMap.new("/app1" => @app1,
-                           "/app" => Rack::Recursive.new(
-                              Rack::URLMap.new("/1" => @app1,
-                                               "/2" => @app2)))
-
-    lambda {
-      Rack::MockRequest.new(app).get("/app/2")
-    }.should.raise(ArgumentError).
-      message.should =~ /can only include below/
-  end
-
-  specify "should support forwarding" do
-    app = Rack::Recursive.new(Rack::URLMap.new("/app1" => @app1,
-                                               "/app3" => @app3,
-                                               "/app4" => @app4))
-
-    res = Rack::MockRequest.new(app).get("/app3")
-    res.should.be.ok
-    res.body.should.equal "App1"
-
-    res = Rack::MockRequest.new(app).get("/app4")
-    res.should.be.ok
-    res.body.should.equal "App1"
-    res["X-Path-Info"].should.equal "/quux"
-    res["X-Query-String"].should.equal "meh"
-  end
-end