rack 1.0.1 → 2.2.21

data/test/spec_rack_mock.rb

@@ -1,157 +0,0 @@
-require 'yaml'
-require 'rack/mock'
-require 'rack/request'
-require 'rack/response'
-
-app = lambda { |env|
-  req = Rack::Request.new(env)
-  
-  env["mock.postdata"] = env["rack.input"].read
-  if req.GET["error"]
-    env["rack.errors"].puts req.GET["error"]
-    env["rack.errors"].flush
-  end
-  
-  Rack::Response.new(env.to_yaml,
-                     req.GET["status"] || 200,
-                     "Content-Type" => "text/yaml").finish
-}
-
-context "Rack::MockRequest" do
-  specify "should return a MockResponse" do
-    res = Rack::MockRequest.new(app).get("")
-    res.should.be.kind_of Rack::MockResponse
-  end
-
-  specify "should be able to only return the environment" do
-    env = Rack::MockRequest.env_for("")
-    env.should.be.kind_of Hash
-    env.should.include "rack.version"
-  end
-
-  specify "should provide sensible defaults" do
-    res = Rack::MockRequest.new(app).request
-
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "GET"
-    env["SERVER_NAME"].should.equal "example.org"
-    env["SERVER_PORT"].should.equal "80"
-    env["QUERY_STRING"].should.equal ""
-    env["PATH_INFO"].should.equal "/"
-    env["SCRIPT_NAME"].should.equal ""
-    env["rack.url_scheme"].should.equal "http"
-    env["mock.postdata"].should.be.empty
-  end
-
-  specify "should allow GET/POST/PUT/DELETE" do
-    res = Rack::MockRequest.new(app).get("", :input => "foo")
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "GET"
-
-    res = Rack::MockRequest.new(app).post("", :input => "foo")
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "POST"
-
-    res = Rack::MockRequest.new(app).put("", :input => "foo")
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "PUT"
-
-    res = Rack::MockRequest.new(app).delete("", :input => "foo")
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "DELETE"
-
-    Rack::MockRequest.env_for("/", :method => "OPTIONS")["REQUEST_METHOD"].
-      should.equal "OPTIONS"
-  end
-
-  specify "should set content length" do
-    env = Rack::MockRequest.env_for("/", :input => "foo")
-    env["CONTENT_LENGTH"].should.equal "3"
-  end
-
-  specify "should allow posting" do
-    res = Rack::MockRequest.new(app).get("", :input => "foo")
-    env = YAML.load(res.body)
-    env["mock.postdata"].should.equal "foo"
-
-    res = Rack::MockRequest.new(app).post("", :input => StringIO.new("foo"))
-    env = YAML.load(res.body)
-    env["mock.postdata"].should.equal "foo"
-  end
-
-  specify "should use all parts of an URL" do
-    res = Rack::MockRequest.new(app).
-      get("https://bla.example.org:9292/meh/foo?bar")
-    res.should.be.kind_of Rack::MockResponse
-
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "GET"
-    env["SERVER_NAME"].should.equal "bla.example.org"
-    env["SERVER_PORT"].should.equal "9292"
-    env["QUERY_STRING"].should.equal "bar"
-    env["PATH_INFO"].should.equal "/meh/foo"
-    env["rack.url_scheme"].should.equal "https"
-  end
-
-  specify "should behave valid according to the Rack spec" do
-    lambda {
-      res = Rack::MockRequest.new(app).
-        get("https://bla.example.org:9292/meh/foo?bar", :lint => true)
-    }.should.not.raise(Rack::Lint::LintError)
-  end
-end
-
-context "Rack::MockResponse" do
-  specify "should provide access to the HTTP status" do
-    res = Rack::MockRequest.new(app).get("")
-    res.should.be.successful
-    res.should.be.ok
-
-    res = Rack::MockRequest.new(app).get("/?status=404")
-    res.should.not.be.successful
-    res.should.be.client_error
-    res.should.be.not_found
-
-    res = Rack::MockRequest.new(app).get("/?status=501")
-    res.should.not.be.successful
-    res.should.be.server_error
-
-    res = Rack::MockRequest.new(app).get("/?status=307")
-    res.should.be.redirect
-
-    res = Rack::MockRequest.new(app).get("/?status=201", :lint => true)
-    res.should.be.empty
-  end
-
-  specify "should provide access to the HTTP headers" do
-    res = Rack::MockRequest.new(app).get("")
-    res.should.include "Content-Type"
-    res.headers["Content-Type"].should.equal "text/yaml"
-    res.original_headers["Content-Type"].should.equal "text/yaml"
-    res["Content-Type"].should.equal "text/yaml"
-    res.content_type.should.equal "text/yaml"
-    res.content_length.should.be 401  # needs change often.
-    res.location.should.be.nil
-  end
-
-  specify "should provide access to the HTTP body" do
-    res = Rack::MockRequest.new(app).get("")
-    res.body.should =~ /rack/
-    res.should =~ /rack/
-    res.should.match(/rack/)
-    res.should.satisfy { |r| r.match(/rack/) }
-  end
-
-  specify "should provide access to the Rack errors" do
-    res = Rack::MockRequest.new(app).get("/?error=foo", :lint => true)
-    res.should.be.ok
-    res.errors.should.not.be.empty
-    res.errors.should.include "foo"
-  end
-
-  specify "should optionally make Rack errors fatal" do
-    lambda {
-      Rack::MockRequest.new(app).get("/?error=foo", :fatal => true)
-    }.should.raise(Rack::MockRequest::FatalWarning)
-  end
-end

data/test/spec_rack_mongrel.rb

@@ -1,189 +0,0 @@
-require 'test/spec'
-
-begin
-require 'rack/handler/mongrel'
-require 'rack/urlmap'
-require 'rack/lint'
-require 'testrequest'
-require 'timeout'
-  
-Thread.abort_on_exception = true
-$tcp_defer_accept_opts = nil
-$tcp_cork_opts = nil
-
-context "Rack::Handler::Mongrel" do
-  include TestRequest::Helpers
-  
-  setup do
-    server = Mongrel::HttpServer.new(@host='0.0.0.0', @port=9201)
-    server.register('/test',
-                    Rack::Handler::Mongrel.new(Rack::Lint.new(TestRequest.new)))
-    server.register('/stream',
-                    Rack::Handler::Mongrel.new(Rack::Lint.new(StreamingRequest)))
-    @acc = server.run
-  end
-
-  specify "should respond" do
-    lambda {
-      GET("/test")
-    }.should.not.raise
-  end
-
-  specify "should be a Mongrel" do
-    GET("/test")
-    status.should.be 200
-    response["SERVER_SOFTWARE"].should =~ /Mongrel/
-    response["HTTP_VERSION"].should.equal "HTTP/1.1"
-    response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
-    response["SERVER_PORT"].should.equal "9201"
-    response["SERVER_NAME"].should.equal "0.0.0.0"
-  end
-
-  specify "should have rack headers" do
-    GET("/test")
-    response["rack.version"].should.equal [1,0]
-    response["rack.multithread"].should.be true
-    response["rack.multiprocess"].should.be false
-    response["rack.run_once"].should.be false
-  end
-
-  specify "should have CGI headers on GET" do
-    GET("/test")
-    response["REQUEST_METHOD"].should.equal "GET"
-    response["SCRIPT_NAME"].should.equal "/test"
-    response["REQUEST_PATH"].should.equal "/test"
-    response["PATH_INFO"].should.be.nil
-    response["QUERY_STRING"].should.equal ""
-    response["test.postdata"].should.equal ""
-
-    GET("/test/foo?quux=1")
-    response["REQUEST_METHOD"].should.equal "GET"
-    response["SCRIPT_NAME"].should.equal "/test"
-    response["REQUEST_PATH"].should.equal "/test/foo"
-    response["PATH_INFO"].should.equal "/foo"
-    response["QUERY_STRING"].should.equal "quux=1"
-  end
-
-  specify "should have CGI headers on POST" do
-    POST("/test", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
-    status.should.equal 200
-    response["REQUEST_METHOD"].should.equal "POST"
-    response["SCRIPT_NAME"].should.equal "/test"
-    response["REQUEST_PATH"].should.equal "/test"
-    response["QUERY_STRING"].should.equal ""
-    response["HTTP_X_TEST_HEADER"].should.equal "42"
-    response["test.postdata"].should.equal "rack-form-data=23"
-  end
-
-  specify "should support HTTP auth" do
-    GET("/test", {:user => "ruth", :passwd => "secret"})
-    response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
-  end
-
-  specify "should set status" do
-    GET("/test?secret")
-    status.should.equal 403
-    response["rack.url_scheme"].should.equal "http"
-  end
-
-  specify "should provide a .run" do
-    block_ran = false
-    Thread.new {
-      Rack::Handler::Mongrel.run(lambda {}, {:Port => 9211}) { |server|
-        server.should.be.kind_of Mongrel::HttpServer
-        block_ran = true
-      }
-    }
-    sleep 1
-    block_ran.should.be true
-  end
-
-  specify "should provide a .run that maps a hash" do
-    block_ran = false
-    Thread.new {
-      map = {'/'=>lambda{},'/foo'=>lambda{}}
-      Rack::Handler::Mongrel.run(map, :map => true, :Port => 9221) { |server|
-        server.should.be.kind_of Mongrel::HttpServer
-        server.classifier.uris.size.should.be 2
-        server.classifier.uris.should.not.include '/arf'
-        server.classifier.uris.should.include '/'
-        server.classifier.uris.should.include '/foo'
-        block_ran = true
-      }
-    }
-    sleep 1
-    block_ran.should.be true
-  end
-
-  specify "should provide a .run that maps a urlmap" do
-    block_ran = false
-    Thread.new {
-      map = Rack::URLMap.new({'/'=>lambda{},'/bar'=>lambda{}})
-      Rack::Handler::Mongrel.run(map, {:map => true, :Port => 9231}) { |server|
-        server.should.be.kind_of Mongrel::HttpServer
-        server.classifier.uris.size.should.be 2
-        server.classifier.uris.should.not.include '/arf'
-        server.classifier.uris.should.include '/'
-        server.classifier.uris.should.include '/bar'
-        block_ran = true
-      }
-    }
-    sleep 1
-    block_ran.should.be true
-  end
-
-  specify "should provide a .run that maps a urlmap restricting by host" do
-    block_ran = false
-    Thread.new {
-      map = Rack::URLMap.new({
-        '/' => lambda{},
-        '/foo' => lambda{},
-        '/bar' => lambda{},
-        'http://localhost/' => lambda{},
-        'http://localhost/bar' => lambda{},
-        'http://falsehost/arf' => lambda{},
-        'http://falsehost/qux' => lambda{}
-      })
-      opt = {:map => true, :Port => 9241, :Host => 'localhost'}
-      Rack::Handler::Mongrel.run(map, opt) { |server|
-        server.should.be.kind_of Mongrel::HttpServer
-        server.classifier.uris.should.include '/'
-        server.classifier.handler_map['/'].size.should.be 2
-        server.classifier.uris.should.include '/foo'
-        server.classifier.handler_map['/foo'].size.should.be 1
-        server.classifier.uris.should.include '/bar'
-        server.classifier.handler_map['/bar'].size.should.be 2
-        server.classifier.uris.should.not.include '/qux'
-        server.classifier.uris.should.not.include '/arf'
-        server.classifier.uris.size.should.be 3
-        block_ran = true
-      }
-    }
-    sleep 1
-    block_ran.should.be true
-  end
-
-  specify "should stream #each part of the response" do
-    body = ''
-    begin
-      Timeout.timeout(1) do
-        Net::HTTP.start(@host, @port) do |http|
-          get = Net::HTTP::Get.new('/stream')
-          http.request(get) do |response|
-            response.read_body { |part| body << part }
-          end
-        end
-      end
-    rescue Timeout::Error
-    end
-    body.should.not.be.empty
-  end
-
-  teardown do
-    @acc.raise Mongrel::StopServer
-  end
-end
-
-rescue LoadError
-  $stderr.puts "Skipping Rack::Handler::Mongrel tests (Mongrel is required). `gem install mongrel` and try again."
-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