rack 1.1.6 → 1.6.9

data/test/spec_rack_webrick.rb

@@ -1,130 +0,0 @@
-require 'test/spec'
-
-require 'rack/handler/webrick'
-require 'rack/lint'
-require 'rack/response'
-require 'testrequest'
-
-Thread.abort_on_exception = true
-
-context "Rack::Handler::WEBrick" do
-  include TestRequest::Helpers
-
-  setup do
-    @server = WEBrick::HTTPServer.new(:Host => @host='0.0.0.0',
-                                      :Port => @port=9202,
-                                      :Logger => WEBrick::Log.new(nil, WEBrick::BasicLog::WARN),
-                                      :AccessLog => [])
-    @server.mount "/test", Rack::Handler::WEBrick,
-      Rack::Lint.new(TestRequest.new)
-    Thread.new { @server.start }
-    trap(:INT) { @server.shutdown }
-  end
-
-  specify "should respond" do
-    lambda {
-      GET("/test")
-    }.should.not.raise
-  end
-
-  specify "should be a WEBrick" do
-    GET("/test")
-    status.should.be 200
-    response["SERVER_SOFTWARE"].should =~ /WEBrick/
-    response["HTTP_VERSION"].should.equal "HTTP/1.1"
-    response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
-    response["SERVER_PORT"].should.equal "9202"
-    response["SERVER_NAME"].should.equal "0.0.0.0"
-  end
-
-  specify "should have rack headers" do
-    GET("/test")
-    response["rack.version"].should.equal [1,1]
-    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 "/"
-    response["PATH_INFO"].should.be.equal ""
-    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 "/"
-    response["PATH_INFO"].should.equal "/foo"
-    response["QUERY_STRING"].should.equal "quux=1"
-
-    GET("/test/foo%25encoding?quux=1")
-    response["REQUEST_METHOD"].should.equal "GET"
-    response["SCRIPT_NAME"].should.equal "/test"
-    response["REQUEST_PATH"].should.equal "/"
-    response["PATH_INFO"].should.equal "/foo%25encoding"
-    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 "/"
-    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 correctly set cookies" do
-    @server.mount "/cookie-test", Rack::Handler::WEBrick,
-    Rack::Lint.new(lambda { |req|
-                     res = Rack::Response.new
-                     res.set_cookie "one", "1"
-                     res.set_cookie "two", "2"
-                     res.finish
-                   })
-
-    Net::HTTP.start(@host, @port) { |http|
-      res = http.get("/cookie-test")
-      res.code.to_i.should.equal 200
-      res.get_fields("set-cookie").should.equal ["one=1", "two=2"]
-    }
-  end
-
-  specify "should provide a .run" do
-    block_ran = false
-    catch(:done) {
-      Rack::Handler::WEBrick.run(lambda {},
-                                 {:Port => 9210,
-                                   :Logger => WEBrick::Log.new(nil, WEBrick::BasicLog::WARN),
-                                   :AccessLog => []}) { |server|
-        block_ran = true
-        server.should.be.kind_of WEBrick::HTTPServer
-        @s = server
-        throw :done
-      }
-    }
-    block_ran.should.be true
-    @s.shutdown
-  end
-
-  teardown do
-    @server.shutdown
-  end
-end

data/test/spec_rackup.rb

@@ -1,164 +0,0 @@
-require 'test/spec'
-require 'testrequest'
-require 'rack/server'
-require 'open3'
-
-begin
-require "mongrel"
-
-context "rackup" do
-  include TestRequest::Helpers
-
-  def run_rackup(*args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    flags   = args.first
-    @host = options[:host] || "0.0.0.0"
-    @port = options[:port] || 9292
-
-    Dir.chdir("#{root}/test/rackup") do
-      @in, @rackup, @err = Open3.popen3("#{ruby} -S #{rackup} #{flags}")
-    end
-
-    return if options[:port] == false
-
-    # Wait until the server is available
-    i = 0
-    begin
-      GET("/")
-    rescue
-      i += 1
-      if i > 40
-        Dir["#{root}/**/*.pid"].each {|f|
-          Process.kill(9, File.read(f)) rescue nil
-          File.delete(f)
-        }
-        raise "Server did not start"
-      end
-      sleep 0.05
-      retry
-    end
-  end
-
-  def output
-    @rackup.read
-  end
-
-  after do
-    # This doesn't actually return a response, so we rescue
-    GET "/die" rescue nil
-
-    Dir["#{root}/**/*.pid"].each do |file|
-      Process.kill(9, File.read(file).strip.to_i) rescue nil
-      File.delete(file)
-    end
-
-    File.delete("#{root}/log_output") if File.exist?("#{root}/log_output")
-  end
-
-  specify "rackup" do
-    run_rackup
-    response["PATH_INFO"].should.equal '/'
-    response["test.$DEBUG"].should.be false
-    response["test.$EVAL"].should.be nil
-    response["test.$VERBOSE"].should.be false
-    response["test.Ping"].should.be nil
-    response["SERVER_SOFTWARE"].should.not =~ /webrick/
-  end
-
-  specify "rackup --help" do
-    run_rackup "--help", :port => false
-    output.should.match /--port/
-  end
-
-  specify "rackup --port" do
-    run_rackup "--port 9000", :port => 9000
-    response["SERVER_PORT"].should.equal "9000"
-  end
-
-  specify "rackup --debug" do
-    run_rackup "--debug"
-    response["test.$DEBUG"].should.be true
-  end
-
-  specify "rackup --eval" do
-    run_rackup %{--eval "BUKKIT = 'BUKKIT'"}
-    response["test.$EVAL"].should.equal "BUKKIT"
-  end
-
-  specify "rackup --warn" do
-    run_rackup %{--warn}
-    response["test.$VERBOSE"].should.be true
-  end
-
-  specify "rackup --include" do
-    run_rackup %{--include /foo/bar}
-    response["test.$LOAD_PATH"].should.include "/foo/bar"
-  end
-
-  specify "rackup --require" do
-    run_rackup %{--require ping}
-    response["test.Ping"].should.equal "constant"
-  end
-
-  specify "rackup --server" do
-    run_rackup %{--server webrick}
-    response["SERVER_SOFTWARE"].should =~ /webrick/i
-  end
-
-  specify "rackup --host" do
-    run_rackup %{--host 127.0.0.1}, :host => "127.0.0.1"
-    response["REMOTE_ADDR"].should.equal "127.0.0.1"
-  end
-
-  specify "rackup --daemonize --pid" do
-    run_rackup "--daemonize --pid testing.pid"
-    status.should.be 200
-    @rackup.should.be.eof?
-    Dir["#{root}/**/testing.pid"].should.not.be.empty?
-  end
-
-  specify "rackup --pid" do
-    run_rackup %{--pid testing.pid}
-    status.should.be 200
-    Dir["#{root}/**/testing.pid"].should.not.be.empty?
-  end
-
-  specify "rackup --version" do
-    run_rackup %{--version}, :port => false
-    output.should =~ /Rack 1.1/
-  end
-
-  specify "rackup --env development includes lint" do
-    run_rackup
-    GET("/broken_lint")
-    status.should.be 500
-  end
-
-  specify "rackup --env deployment does not include lint" do
-    run_rackup %{--env deployment}
-    GET("/broken_lint")
-    status.should.be 200
-  end
-
-  specify "rackup --env none does not include lint" do
-    run_rackup %{--env none}
-    GET("/broken_lint")
-    status.should.be 200
-  end
-
-  specify "rackup --env deployment does log" do
-    run_rackup %{--env deployment}
-    log = File.read(response["test.stderr"])
-    log.should.be.empty?
-  end
-
-  specify "rackup --env none does not log" do
-    run_rackup %{--env none}
-    GET("/")
-    log = File.read(response["test.stderr"])
-    log.should.be.empty?
-  end
-end
-rescue LoadError
-  $stderr.puts "Skipping rackup --server tests (mongrel is required). `gem install thin` and try again."
-end