hurley 0.1

data/lib/hurley/test.rb

@@ -0,0 +1,101 @@
+module Hurley
+  class Test
+    def initialize
+      @handlers = []
+      yield self if block_given?
+    end
+
+    def head(url)
+      handle(:head, url, &Proc.new)
+    end
+
+    def get(url)
+      handle(:get, url, &Proc.new)
+    end
+
+    def put(url)
+      handle(:put, url, &Proc.new)
+    end
+
+    def post(url)
+      handle(:post, url, &Proc.new)
+    end
+
+    def patch(url)
+      handle(:patch, url, &Proc.new)
+    end
+
+    def delete(url)
+      handle(:delete, url, &Proc.new)
+    end
+
+    def options(url)
+      handle(:options, url, &Proc.new)
+    end
+
+    def handle(verb, url)
+      @handlers << Handler.new(Request.new(verb, Url.parse(url)), Proc.new)
+    end
+
+    def call(request)
+      handler = @handlers.detect { |h| h.matches?(request) } ||
+        Handler.method(:not_found)
+      # Create a new url with fresh state from the url string
+      request.url = Url.parse(request.url.to_s)
+      handler.call(request)
+    end
+
+    def all_run?
+      @handlers.all?(&:run?)
+    end
+
+    class Handler
+      attr_reader :request
+      attr_reader :callback
+
+      def self.not_found(request)
+        Response.new(request, 404, Header.new) do |res|
+          res.receive_body("no test handler")
+        end
+      end
+
+      def initialize(request, callback)
+        @request = request
+        @callback = callback
+        @path_regex = %r{\A#{@request.url.path}(/|\z)}
+      end
+
+      def call(request)
+        @run = true
+        status, header, body = @callback.call(request)
+        Response.new(request, status, Header.new(header)) do |res|
+          Array(body).each do |chunk|
+            res.receive_body(chunk)
+          end
+        end
+      end
+
+      def matches?(request)
+        return false unless @request.verb == request.verb
+
+        handler_url = @request.url
+        request_url = request.url
+
+        URL_ATTRS.each do |attr|
+          value = handler_url.send(attr)
+          return false if value && value != request_url.send(attr)
+        end
+
+        handler_url.query.subset_of?(request_url.query) &&
+          (handler_url.path =~ EMPTY_OR_SLASH || request_url.path =~ @path_regex)
+      end
+
+      def run?
+        !!@run
+      end
+
+      EMPTY_OR_SLASH = %r{\A/?\z}
+      URL_ATTRS = [:scheme, :host, :port]
+    end
+  end
+end

data/lib/hurley/test/integration.rb

@@ -0,0 +1,249 @@
+module Hurley
+  class Test
+    module Integration
+      class << self
+        attr_writer :live_endpoint
+        attr_writer :ssl_file
+
+        def live_endpoint
+          @live_endpoint ||= ENV["HURLEY_LIVE"].to_s
+        end
+
+        def ssl_file
+          @ssl_file ||= ENV["HURLEY_SSL_FILE"].to_s
+        end
+
+        def ssl?
+          live_endpoint.start_with?(Hurley::HTTPS)
+        end
+      end
+
+      def self.apply(base, *extra_features)
+        features = [:Common, *extra_features]
+        features << :SSL if Integration.ssl?
+        features.each do |name|
+          base.send(:include, const_get(name))
+        end
+      end
+
+      module Common
+        def test_GET_retrieves_the_response_body
+          assert_equal "get", client.get("echo").body
+        end
+
+        def test_GET_send_url_encoded_params
+          assert_equal %(get ?{"name"=>"zack"}), client.get("echo", :name => :zack).body
+        end
+
+        def test_GET_retrieves_the_response_headers
+          response = client.get("echo")
+          assert_match(/text\/plain/, response.header["Content-Type"])
+          assert_match(/text\/plain/, response.header["content-type"])
+          assert_match(/text\/plain/, response.header[:content_type])
+        end
+
+        def test_GET_sends_user_agent
+          assert_equal Hurley::USER_AGENT, client.get("echo_header", :name => :user_agent).body
+        end
+
+        def test_GET_ssl
+          expected = Integration.ssl?.to_s
+          assert_equal expected, client.get("ssl").body
+        end
+
+        def test_POST_send_url_encoded_params
+          res = client.post "echo" do |req|
+            req.body = "name=zack"
+            req.header[:content_type] = "application/x-www-form-urlencoded"
+          end
+          assert_equal %(post {"name"=>"zack"}), res.body
+        end
+
+        def test_POST_send_url_encoded_nested_params
+          res = client.post "echo" do |req|
+            req.body = "name[first]=zack"
+            req.header[:content_type] = "application/x-www-form-urlencoded"
+          end
+          assert_equal %(post {"name"=>{"first"=>"zack"}}), res.body
+        end
+
+        def test_POST_retrieves_the_response_headers
+          assert_match(/text\/plain/, client.post("echo").header[:content_type])
+        end
+
+        def test_POST_sends_files_as_multipart
+          resp = client.post("file") do |req|
+            ctype, body = Query::Flat.new(
+              :uploaded_file => UploadIO.new(__FILE__, "text/x-ruby"),
+            ).to_form
+            req.header[:content_type] = ctype
+            req.body = body
+          end
+          assert_equal "file integration.rb text/x-ruby #{File.size(__FILE__)}", resp.body
+        end
+
+        def test_PUT_sends_files
+          resp = client.put("raw") do |req|
+            req.header[:content_length] = File.size(__FILE__)
+            req.body = File.open(__FILE__)
+          end
+          assert_equal "raw application/octet-stream #{File.size(__FILE__)} #{File.size(__FILE__)}", resp.body
+        end
+
+        def test_PUT_sends_io
+          resp = client.put("raw") do |req|
+            req.body = GenericIO.new("READ")
+            req.header[:content_length] = 4
+          end
+          assert_equal "raw application/octet-stream 4 4", resp.body
+        end
+
+        def test_PUT_sends_io_with_chunked_encoding
+          resp = client.put("raw") do |req|
+            req.body = GenericIO.new("READ")
+          end
+          assert_equal "raw application/octet-stream -1 4", resp.body
+        end
+
+        def test_PUT_send_url_encoded_params
+          res = client.put "echo" do |req|
+            req.body = "name=zack"
+            req.header[:content_type] = "application/x-www-form-urlencoded"
+          end
+          assert_equal %(put {"name"=>"zack"}), res.body
+        end
+
+        def test_PUT_send_url_encoded_nested_params
+          res = client.put "echo" do |req|
+            req.body = "name[first]=zack"
+            req.header[:content_type] = "application/x-www-form-urlencoded"
+          end
+          assert_equal %(put {"name"=>{"first"=>"zack"}}), res.body
+        end
+
+        def test_PUT_retrieves_the_response_headers
+          assert_match(/text\/plain/, client.put("echo").header[:content_type])
+        end
+
+        def test_PATCH_send_url_encoded_params
+          res = client.patch "echo" do |req|
+            req.header[:content_type] = "application/x-www-form-urlencoded"
+            req.body = "name=zack"
+          end
+          assert_equal %(patch {"name"=>"zack"}), res.body
+        end
+
+        def test_OPTIONS
+          assert_equal "options", client.options("echo").body
+        end
+
+        def test_HEAD_retrieves_no_response_body
+          assert_nil client.head("echo").body
+        end
+
+        def test_HEAD_retrieves_the_response_headers
+          assert_match(/text\/plain/, client.head("echo").header[:content_type])
+        end
+
+        def test_DELETE_retrieves_the_response_headers
+          assert_match(/text\/plain/, client.delete("echo").header[:content_type])
+        end
+
+        def test_DELETE_retrieves_the_body
+          assert_equal %(delete), client.delete("echo").body
+        end
+
+        def test_timeout
+          client.request_options.timeout = 0.5
+          assert_raises Hurley::Timeout do
+            client.get "/slow"
+          end
+        end
+
+        def test_connection_error
+          assert_raises Hurley::ConnectionFailed do
+            client.get "http://localhost:4"
+          end
+        end
+
+        def test_empty_body_response_represented_as_nil
+          res = client.get("204")
+          assert_equal 204, res.status_code
+          assert_nil res.body
+        end
+
+        def test_proxy
+          return unless client.request_options.proxy = proxy_url
+
+          res = client.get("/echo")
+          assert_equal "get", res.body
+
+          unless Integration.ssl?
+            # proxy can't append "Via" header for HTTPS responses
+            assert_match(/:#{proxy_url.port}$/, res.header[:Via])
+          end
+        end
+
+        def test_proxy_auth_fail
+          return unless client.request_options.proxy = proxy_url
+          client.request_options.proxy.password = "WRONG"
+          assert_equal 407, client.put("/echo").status_code
+        rescue Hurley::ConnectionFailed
+          # this exception is allowed too
+        end
+
+        def client
+          @client ||= Client.new(Integration.live_endpoint) do |cli|
+            cli.header["X-Hurley-Connection"] = connection.class.name
+            cli.connection = connection
+
+            if Integration.ssl?
+              cli.ssl_options.ca_file = Integration.ssl_file
+            end
+          end
+        end
+
+        def proxy_url
+          @proxy_url ||= if raw_url = ENV["HURLEY_PROXY"]
+            Url.parse(raw_url)
+          end
+        end
+      end
+
+      module Compression
+        def test_GET_handles_compression
+          res = client.get("echo_header", :name => :accept_encoding)
+          assert_match(/gzip;.+\bdeflate\b/, res.body)
+        end
+      end
+
+      module SSL
+        def test_GET_ssl_fails_with_bad_cert
+          client.ssl_options.ca_file = "tmp/hurley-different-ca-cert.crt"
+
+          err = assert_raises Hurley::SSLError do
+            client.get("/ssl")
+          end
+
+          assert_includes err.message, "certificate"
+        end
+
+        def test_GET_ssl_skips_verification
+          client.ssl_options.ca_file = "tmp/hurley-different-ca-cert.crt"
+          client.ssl_options.skip_verification = true
+          assert_equal "true", client.get("/ssl").body
+        end
+      end
+
+      class GenericIO
+        def initialize(str)
+          @io = StringIO.new(str)
+        end
+
+        def read(*args)
+          @io.read(*args)
+        end
+      end
+    end
+  end
+end

data/lib/hurley/test/server.rb

@@ -0,0 +1,102 @@
+require "sinatra/base"
+
+module Hurley
+  module Live
+    class Server < Sinatra::Base
+      set :environment, :test
+      disable :logging
+      disable :protection
+
+      [:get, :post, :put, :patch, :delete, :options].each do |method|
+        send(method, "/echo") do
+          out = [request.request_method.downcase]
+
+          if request.GET.any?
+            out << "?#{request.GET.inspect}"
+          end
+
+          if request.POST.any?
+            out << request.POST.inspect
+          end
+
+          content_type "text/plain"
+          out.join(" ")
+        end
+      end
+
+      get "/echo_header" do
+        header = "HTTP_#{params[:name].tr("-", "_").upcase}"
+        request.env.fetch(header) { "NONE" }
+      end
+
+      post "/file" do
+        if params[:uploaded_file].respond_to? :each_key
+          "file %s %s %d" % [
+            params[:uploaded_file][:filename],
+            params[:uploaded_file][:type],
+            params[:uploaded_file][:tempfile].size
+          ]
+        else
+          status 400
+        end
+      end
+
+      put "/raw" do
+        body = env["rack.input"]
+        "raw #{request.env.fetch("CONTENT_TYPE") { "NONE" }} #{request.env.fetch("CONTENT_LENGTH") { -1 }} #{body.size}"
+      end
+
+      get "/ssl" do
+        request.secure?.to_s
+      end
+
+      get "/slow" do
+        sleep 1
+        [200, {}, "ok"]
+      end
+
+      get "/204" do
+        status 204 # no content
+      end
+
+      error do |e|
+        "#{e.class}\n#{e.to_s}\n#{e.backtrace.join("\n")}"
+      end
+    end
+
+    def self.start_server(options = nil)
+      require "webrick"
+
+      options ||= {}
+      port = options[:port] || 4000
+
+      log_io = $stdout
+      log_io.sync = true
+
+      webrick_opts = {
+        :Port => port, :Logger => WEBrick::Log::new(log_io),
+        :AccessLog => [[log_io, "[%{X-Hurley-Connection}i] %m  %U  ->  %s %b"]],
+      }
+
+      if options[:ssl_key]
+        require "openssl"
+        require "webrick/https"
+        webrick_opts.update(
+          :SSLEnable       => true,
+          :SSLPrivateKey   => OpenSSL::PKey::RSA.new(File.read(options[:ssl_key])),
+          :SSLCertificate  => OpenSSL::X509::Certificate.new(File.read(options[:ssl_file])),
+          :SSLVerifyClient => OpenSSL::SSL::VERIFY_NONE,
+        )
+      end
+
+      Rack::Handler::WEBrick.run(Server, webrick_opts) do |server|
+        trap(:INT)  { server.stop }
+        trap(:TERM) { server.stop }
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  Hurley::Server.run!
+end