simple-http 0.1.5 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 629d4ae6ecbf63473054f8cdc95b88bdae1a5251
-  data.tar.gz: 782dab2622b3d481d9dd5eabc77231707a5b0abe
+SHA256:
+  metadata.gz: c92784b07cf1f548d0c40078b19609308a45788bbc550a42305c1bf26c6e32a0
+  data.tar.gz: e9c7ad66790380696674c6a6566581e87eef1735b2f7dd6656918908600df04c
 SHA512:
-  metadata.gz: 6b6b5133cd3ad03c1f2bf29a96e8c21bfdfd5df97de3c57aaa3dc1da6da3e59dc964085f1e86cf8255ca4126aad3d5871f715f9061f47a36277a53634c0c1a2a
-  data.tar.gz: d6c270201e14f28b6edde03a28571a9bcc46aa792a0751ac07b61a5144331a9f5d07c4c6e548f3f9abc3aa9ee0c48abb2495c3dc38e5b24b81e9bc3525ca78ad
+  metadata.gz: eb4bbedf1338cc0c657e3e1c7ac38d3e243656d5128c25d2f8252eaa8bd5a228e50bc17cf967eac469a5f15db873899dcee187962effe812a15ff05dca007bf0
+  data.tar.gz: ce18010f695ae2be693552cfc41ed001490d47490ecd1be6fc22fa6d6847cc19506c007e3741ef1a8522590529f090247479d8e802aa5e30389d78f229d44898

data/lib/simple/http.rb

@@ -10,197 +10,147 @@ module Simple; end
 class Simple::HTTP; end
 
 require_relative "http/version"
-require_relative "http/result"
-require_relative "http/expires_in"
+require_relative "http/caching"
 require_relative "http/errors"
+require_relative "http/headers"
+require_relative "http/request"
+require_relative "http/response"
+
+require "openssl"
 
 #
-# A very simple, Net::HTTP-based HTTP client. 
+# A very simple, Net::HTTP-based HTTP client.
 #
 # Has some support for transferring JSON data: all data in PUT and POST
 # requests are jsonized, and all data in responses are parsed as JSON if
 # the Content-Type header is set to "application/json".
 class Simple::HTTP
-
   #
   # The logger instance.
-  attr :logger, true
+  attr_accessor :logger
 
   #
-  # The base URL: when set, all requests that do not start with http: or 
-  # https: are done relative to this base URL. 
-  attr :base_url, true
-  
+  # The base URL when set, all requests that do not start with http: or
+  # https: are done relative to this base URL.
+  attr_accessor :base_url
+
   #
-  # When set (default), redirections are followed. Note: When 
+  # When set (default), redirections are followed. Note: When
   # follows_redirections is not set, a HTTP redirection would raise an
   # error - which is probably only useful when testing an interface.
-  attr :follows_redirections, true
+  attr_accessor :follows_redirections
 
   #
   # When set, appends this to all request URLs
-  attr :default_params, true
+  attr_accessor :default_params
 
   #
   # When set, sets Authorization headers to all requests. Must be an
   # array [ username, password ].
-  attr :basic_auth, true
+  attr_accessor :basic_auth
 
   def initialize
     self.follows_redirections = true
-    self.logger = Logger.new(STDERR)
-    self.logger.level = Logger::WARN
+    self.logger = Logger.new(STDERR, level: :warn)
   end
 
-  def get(url, headers = {});               http :GET, url, nil, headers; end
-  def post(url, body = nil, headers = {});  http :POST, url, body, headers; end
-  def put(url, body = nil, headers = {});   http :PUT, url, body, headers; end
-  def delete(url, headers = {});            http :DELETE, url, nil, headers; end
+  def head(url, headers = {})
+    request :HEAD, url, nil, headers
+  end
 
-  #
-  # -- Caching ----------------------------------------------------------------
+  def get(url, headers = {})
+    request :GET, url, nil, headers
+  end
 
-  # When set, and a response is cacheable (as it returns a valid expires_in 
-  # value), the cache object is used to cache responses.
-  attr :cache, true
+  def post(url, body = nil, headers = {})
+    request :POST, url, body, headers
+  end
 
-  #
-  # when does the response expire? By default, calculates expiration based
-  # on response headers. Override as needed.
-  def expires_in(response)
-    response.expires_in
+  def put(url, body = nil, headers = {})
+    request :PUT, url, body, headers
   end
 
-  private
+  def delete(url, headers = {})
+    request :DELETE, url, nil, headers
+  end
+
+  #
+  # -- Caching ----------------------------------------------------------------
+
+  # When set, and a response is cacheable (as it returns a valid expires_in
+  # value), the cache object is used to cache responses.
+  attr_accessor :cache
 
   # -- HTTP request -----------------------------------------------------------
 
-  def http(method, url, body = nil, headers)
+  def request(verb, url, body, headers)
     #
     # normalize url; i.e. prepend base_url if the url itself is incomplete.
     unless url =~ /^(http|https):/
-      url = File.join(base_url, url) 
+      url = File.join(base_url, url)
     end
-    
+
+    uri = URI.parse(url)
+    unless uri.is_a?(URI::HTTP)
+      raise ArgumentError, "Invalid URL: #{url}"
+    end
+
     # append default_params, if set
     if default_params
       url.concat(url.include?("?") ? "&" : "?")
       url.concat default_params
     end
 
-    # "raw" execute request
-    http_ method, url, body, headers
+    request = Request.new(verb: verb, url: url, body: body, headers: headers)
+
+    execute_request(request)
   end
 
-  # 
-  # do a HTTP request, return its response or, when not successful, 
-  # raise an error.
-  def http_(method, url, body, headers, max_redirections = 10)
-    if method == :GET && cache && result = cache.read(url)
-      logger.debug "#{method} #{url}: using cached result"
-      return result
-    end
+  private
 
-    uri = URI.parse(url)
-    unless uri.is_a?(URI::HTTP)
-      raise ArgumentError, "Invalid URL: #{url}"
-    end
+  def execute_request(request, max_redirections: 10)
+    response = execute_request_w_caching(request)
 
-    http = Net::HTTP.new(uri.host, uri.port)
-    if uri.scheme == "https"
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-    end
+    return response unless response.status >= 300 && response.status <= 399
+    return response unless follows_redirections
 
-    #
-    # build request
-    request = build_request method, uri, body, headers
+    raise ::Simple::HTTP::TooManyRedirections, response if max_redirections <= 0
 
-    #
-    # execute request
-    started_at = Time.now
-    response = http.request(request)
-    logger.info "#{method} #{url}: #{response.body.bytesize} byte, #{"%.3f secs" % (Time.now - started_at)}"
+    request = ::Simple::HTTP::Request.new(verb: :GET, url: response.headers["Location"], headers: {})
+    execute_request(request, max_redirections: max_redirections - 1)
+  end
 
-    #
-    # Most of the times Net::HTTP#request returns a response with the :uri
-    # attribute set, but sometimes not. We  make sure that the uri is set 
-    # everytime.
-    response.uri = uri
+  def execute_request_w_caching(request)
+    is_cacheable = request.verb == :GET && cache
 
-    #
-    # handle successful responses.
-    if response.is_a?(Net::HTTPSuccess)
-      result = response.result
-      if cache && method == :GET && expires_in = self.expires_in(response)
-        if response.expires_in == expires_in
-          logger.debug "#{method} #{url}: store in cache, w/expiration of #{expires_in}"
-        else
-          logger.debug "#{method} #{url}: store in cache, w/custom expiration of #{expires_in} (instead #{response.expires_in.inspect})"
-        end
-        cache.write(url, result, expires_in: expires_in)
-      end
-
-      return result
+    if is_cacheable && (cached = Caching.fetch(request))
+      return cached
     end
 
-    #
-    # handle redirections.
-    if response.is_a?(Net::HTTPRedirection) && self.follows_redirections
-      if max_redirections <= 0
-        raise TooManyRedirections.new(method, request, respons)
-      end
-
-      target_url = response["Location"]
-      unless target_url =~ /^(http|https):\/\//
-        base_url = "#{uri.scheme}://#{uri.host}"
-        File.join base_url, target_url
-      end
-
-      return http_(:GET, target_url, nil, {}, max_redirections - 1)
+    response = execute_request_w_logging(request)
+
+    expires_in = Caching.determine_expires_in(response)
+    if is_cacheable && expires_in
+      Caching.store(request, response, expires_in: expires_in)
     end
 
-    #
-    # raise an error in any other case.
-    raise Error.new(method, request, response)
+    response
   end
 
-  private
+  def execute_request_w_logging(request)
+    started_at = Time.now
 
-  REQUEST_CLASSES = {
-    :GET    =>  Net::HTTP::Get,
-    :POST   =>  Net::HTTP::Post,
-    :PUT    =>  Net::HTTP::Put,
-    :DELETE =>  Net::HTTP::Delete
-  }.freeze #:nodoc:
+    response = driver.execute_request(request, client: self)
 
-  #
-  # build a HTTP request object.
-  def build_request(method, uri, body, headers)
-    klass = REQUEST_CLASSES.fetch(method)
-    request = klass.new(uri.request_uri)
-
-    if uri.user
-      request.basic_auth(uri.user, uri.password)
-    elsif basic_auth
-      request.basic_auth(*basic_auth)
+    logger.info do
+      "#{request}: #{response}, #{"%.3f secs" % (Time.now - started_at)}"
     end
 
-    # set request headers
-    # unless headers && !headers.empty?
-    #   # TODO: set headers
-    #   # set_request_headers request, headers
-    # end
-
-    # set request body
-    if request.request_body_permitted? && body
-      request.content_type = "application/json"
-      if body.is_a?(Hash) || body.is_a?(Array)
-        body = JSON.generate(body)
-      end
-      request.body = body
-    end
+    response
+  end
 
-    request
+  def driver
+    require "simple/http/driver/default"
+    ::Simple::HTTP::Driver::Default
   end
 end

data/lib/simple/http/body_builder.rb

@@ -0,0 +1,71 @@
+# This module originally was taken from rack/media_type.rb and modified:
+# we don't want to have a rack (which is a server toolset) dependency
+# in simple-http, which is a client after all.
+
+# parses content_type to return media_type and charset, and can reencode bodies.
+class Simple::HTTP::BodyBuilder
+  SPLIT_PATTERN = %r{\s*[;,]\s*}
+
+  def initialize(content_type)
+    @media_type = content_type.split(SPLIT_PATTERN, 2).first.downcase if content_type
+    @charset = fetch_content_type_param(content_type, "charset", default: nil)
+  end
+
+  # The media type (type/subtype) portion of the CONTENT_TYPE header
+  # without any media type parameters. e.g., when CONTENT_TYPE is
+  # "text/plain;charset=utf-8", the media-type is "text/plain".
+  #
+  # For more information on the use of media types in HTTP, see:
+  # http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7
+  attr_reader :media_type
+
+  # The charset as embedded on the Content-Type header
+  attr_reader :charset
+
+  # returns the body
+  #
+  # This method reencodes the text body into UTF-8. Non-text bodies should be
+  # encoded as ASCII-8BIT (a.k.a. "BINARY")
+  def reencode(body)
+    body&.encode(best_encoding)
+  end
+
+  private
+
+  BINARY = ::Encoding.find "ASCII-8BIT"
+  UTF8 = ::Encoding.find "UTF-8"
+
+  # returns the encoding we want for the body.
+  #
+  # This method makes sure to reencode text bodies into UTF-8, and non-text
+  # bodies as ASCII-8BIT (a.k.a. "BINARY")
+  def best_encoding
+    case media_type
+    when /^application\/json/, /^application\/xml/, /^text\// then UTF8
+    else BINARY
+    end
+  end
+
+  # The media type parameters provided in CONTENT_TYPE as a Hash, or
+  # an empty Hash if no CONTENT_TYPE or media-type parameters were
+  # provided.  e.g., when the CONTENT_TYPE is "text/plain;charset=utf-8",
+  # this method responds with the following Hash:
+  #   { 'charset' => 'utf-8' }
+  def fetch_content_type_param(content_type, parameter_name, default:)
+    return default if content_type.nil?
+
+    parameter_name = parameter_name.downcase
+
+    content_type.split(SPLIT_PATTERN)[1..-1]
+                .each do |s|
+      k, v = s.split("=", 2)
+      return strip_doublequotes(v) if k.downcase == parameter_name
+    end
+
+    default
+  end
+
+  def strip_doublequotes(str)
+    str[0] == '"' && str[-1] == '"' ? str[1..-2] : str
+  end
+end

data/lib/simple/http/caching.rb

@@ -0,0 +1,46 @@
+# This file is part of the simple-http ruby gem.
+#
+# Copyright (c) 2011 - 2015 @radiospiel
+# Distributed under the terms of the modified BSD license, see LICENSE.BSD
+
+module Simple::HTTP::Caching
+  extend self
+
+  #
+  # returns expiration information, in seconds from now.
+  def determine_expires_in(response)
+    return nil unless cacheable_status?(response.status)
+
+    expires_in = parse_cache_control response
+    expires_in ||= parse_expires response
+
+    return expires_in if expires_in && expires_in > 0
+  end
+
+  private
+
+  def cacheable_status?(status)
+    (status >= 200 && status <= 299) || (status >= 400 && status <= 499)
+  end
+
+  # Returns the expiration setting from the "Cache-Control"'s max-age entry
+  def parse_cache_control(response)
+    cache_control = response.headers["Cache-Control"]
+    return unless cache_control
+
+    cache_control.split(/,\s+/).each do |part|
+      next unless part =~ /max-age=(\d+)/
+
+      return Integer($1)
+    end
+    nil
+  end
+
+  # Returns the expiration setting from the "Expires" header
+  def parse_expires(response)
+    expires = response.headers["Expires"]
+    return unless expires
+
+    Time.parse(expires) - Time.now
+  end
+end

data/lib/simple/http/driver/default.rb

@@ -0,0 +1,81 @@
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+module Simple::HTTP::Driver
+end
+
+module Simple::HTTP::Driver::Default
+  extend self
+
+  #
+  # do a HTTP request, return its response or, when not successful,
+  # raise an error.
+  def execute_request(request, client:)
+    verb, url, body, headers =
+      request.verb, request.url, request.body, request.headers
+
+    uri = URI.parse(url)
+
+    # build Net::HTTP request
+    request = build_request verb, uri, body, headers, client: client
+
+    # execute request
+    net_http = load_net_http(uri.scheme, uri.host, uri.port)
+    resp = net_http.request(request)
+
+    ::Simple::HTTP::Response.new request: request,
+                                 status: Integer(resp.code),
+                                 message: resp.message,
+                                 headers: Simple::HTTP::Headers.new(resp),
+                                 body: resp.body
+  end
+
+  private
+
+  # rubocop:disable Style/HashSyntax, Layout/AlignHash
+  REQUEST_CLASSES = {
+    :HEAD   =>  Net::HTTP::Head,
+    :GET    =>  Net::HTTP::Get,
+    :POST   =>  Net::HTTP::Post,
+    :PUT    =>  Net::HTTP::Put,
+    :DELETE =>  Net::HTTP::Delete
+  }.freeze #:nodoc:
+
+  #
+  # build a HTTP request object.
+  def build_request(method, uri, body, _headers, client:)
+    klass = REQUEST_CLASSES.fetch(method)
+    request = klass.new(uri.request_uri)
+
+    if uri.user
+      request.basic_auth(uri.user, uri.password)
+    elsif client.basic_auth
+      request.basic_auth(*client.basic_auth)
+    end
+
+    # set request headers
+    # unless headers && !headers.empty?
+    #   # TODO: set headers
+    #   # set_request_headers request, headers
+    # end
+
+    # set request body
+    if request.request_body_permitted? && body
+      request.content_type = "application/json"
+      if body.is_a?(Hash) || body.is_a?(Array)
+        body = JSON.generate(body)
+      end
+      request.body = body
+    end
+
+    request
+  end
+
+  def load_net_http(scheme, host, port)
+    net_http = Net::HTTP.new(host, port)
+    if scheme == "https"
+      net_http.use_ssl = true
+      net_http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    end
+    net_http
+  end
+end

data/lib/simple/http/errors.rb

@@ -7,27 +7,35 @@ module Simple; end
 class Simple::HTTP; end
 
 class Simple::HTTP::Error < RuntimeError
-  attr :method, :request, :response
+  attr_reader :response
 
-  def initialize(method, request, response)
-    @method, @request, @response = method, request, response
+  def initialize(response)
+    @response = response
   end
 
-  def code
-    response.code.to_i
+  def status
+    response.status
+  end
+
+  def request
+    @response.request
+  end
+
+  def verb
+    request.class::METHOD
   end
 
   def message
-    message = "#{method} #{response.uri} ##{response.code} #{response.message}"
-    if response.is_a?(Net::HTTPRedirection)
-      message += " To #{response["Location"]}"
-    end
-    message
+    "#{verb} #{request.uri} ##{status} #{response.message}"
   end
 end
 
 class Simple::HTTP::TooManyRedirections < Simple::HTTP::Error
+  def location
+    response["Location"]
+  end
+
   def message
-    "Too many redirections; after\n#{super}"
+    "#{super}: too many redirections (latest to #{location})"
   end
 end

data/lib/simple/http/headers.rb

@@ -0,0 +1,34 @@
+class Simple::HTTP::Headers < Hash
+  def initialize(headers)
+    case headers
+    when Net::HTTPHeader
+      headers.each_name.map do |name|
+        values = headers.get_fields(name)
+        self[name] = values.length == 1 ? values.first : values
+      end
+    else
+      headers.each do |name, value|
+        self[name] = value
+      end
+    end
+  end
+
+  def [](key)
+    super key.downcase
+  end
+
+  def value(key)
+    values(key)&.first
+  end
+
+  def values(key)
+    v = self[key]
+    Array(v) if v
+  end
+
+  private
+
+  def []=(key, value)
+    super key.downcase, value
+  end
+end

data/lib/simple/http/request.rb

@@ -0,0 +1,12 @@
+class Simple::HTTP::Request
+  attr_reader :verb, :url, :body, :headers
+
+  def initialize(verb:, url:, body: nil, headers:)
+    @verb, @url, @body, @headers = verb, url, body, headers
+  end
+
+  def to_s
+    scrubbed_url = url.gsub(/\/\/(.*):(.*)@/) { |_| "//#{$1}:xxxxxx@" }
+    "#{verb} #{scrubbed_url}"
+  end
+end

data/lib/simple/http/response.rb

@@ -0,0 +1,63 @@
+require_relative "./body_builder"
+
+class Simple::HTTP::Response
+  BodyBuilder = Simple::HTTP::BodyBuilder
+
+  attr_reader :request
+  attr_reader :status
+  attr_reader :message
+  attr_reader :headers
+  attr_reader :original_body
+
+  def initialize(request:, body:, headers:, status:, message:)
+    @request, @headers = request, headers
+    @status, @message = status, message
+    @original_body = body
+
+    # adjust encoding on original_body
+    @body_builder = BodyBuilder.new(headers["Content-Type"])
+
+    if @original_body && (charset = @body_builder.charset)
+      @original_body.force_encoding(charset)
+    end
+  end
+
+  # e.g "text/plain"
+  def media_type
+    @body_builder.media_type
+  end
+
+  # returns the body
+  #
+  # This method reencodes the text body into UTF-8. Non-text bodies should be
+  # encoded as ASCII-8BIT (a.k.a. "BINARY")
+  def body
+    @body ||= @body_builder.reencode(@original_body)
+  end
+
+  def bytes
+    @original_body&.byte_size || 0
+  end
+
+  def to_s
+    "#{status} #{message.gsub(/\s+$/, "")} (#{bytes} byte)"
+  end
+
+  # evaluate and potentially parses response body.
+  # raises an Simple::Http::Error if the result code is not a 2xx
+  def content!
+    raise Error, self unless status >= 200 && status <= 299
+
+    content
+  end
+
+  # evaluate and potentially parse response
+  def content
+    case media_type
+    when "application/json"
+      JSON.parse(body) unless body.empty?
+    else
+      body
+    end
+  end
+end

data/lib/simple/http/version.rb

@@ -5,5 +5,26 @@
 
 module Simple; end
 class Simple::HTTP
-  VERSION = "0.1.5"
+
+  module GemHelper
+    extend self
+
+    def version(name)
+      spec = Gem.loaded_specs[name]
+      version = spec ? spec.version.to_s : "0.0.0"
+      # version += "+unreleased" if !spec || unreleased?(spec)
+      version
+    end
+
+    private
+
+    def unreleased?(spec)
+      return false unless defined?(Bundler::Source::Gemspec)
+      return true if spec.source.is_a?(::Bundler::Source::Gemspec)
+      return true if spec.source.is_a?(::Bundler::Source::Path)
+      false
+    end
+  end
+
+  VERSION = GemHelper.version "simple-http"
 end

data/test/assertions_test.rb

@@ -7,14 +7,14 @@ require_relative 'test_helper'
 class SimpleHttpTest < Simple::HTTP::TestCase
   def test_assert_http_error
     assert_http_error(456) do
-      http.get "http://eu.httpbin.org/status/456"
+      http.get "/status/456"
     end
   end
 
   def test_assert_http_redirects_to
     http.follows_redirections = false
     assert_http_redirects_to "http://eu.httpbin.org" do
-      http.get "http://eu.httpbin.org/redirect-to?url=http://eu.httpbin.org"
+      http.get "/redirect-to?url=http://eu.httpbin.org"
     end
   end
 end

data/test/basic_auth_test.rb

@@ -6,35 +6,35 @@ require_relative 'test_helper'
 
 class SimpleHttpTest < Simple::HTTP::TestCase
   def test_basic_auth
-    http.basic_auth = [ "user", "passwd" ]
-    http.get "http://eu.httpbin.org/basic-auth/user/passwd"
+    http.basic_auth = [ "admin", "secret" ]
+    http.get "/basic-auth/user/passwd"
   end
 
   def test_basic_auth_invalid
     http.basic_auth = [ "wronguser", "passwd" ]
     assert_http_error 401 do
-      http.get "http://eu.httpbin.org/basic-auth/user/passwd"
+      http.get "/basic-auth/user/passwd"
     end
   end
 
   def test_basic_auth_missing
     http.basic_auth = [ "wronguser", "passwd" ]
     assert_http_error 401 do
-      http.get "http://eu.httpbin.org/basic-auth/user/passwd"
+      http.get "/basic-auth/user/passwd"
     end
   end
 
   def test_url_auth
-    http.get "http://user:passwd@eu.httpbin.org/basic-auth/user/passwd"
+    http.get "http://admin:secret@#{HOST}:#{PORT}/basic-auth/user/passwd"
   end
 
   def test_url_auth_overrides_basic_auth
     http.basic_auth = [ "wronguser", "passwd" ]
-    http.get "http://user:passwd@eu.httpbin.org/basic-auth/user/passwd"
+    http.get "http://admin:secret@#{HOST}:#{PORT}/basic-auth/user/passwd"
 
-    http.basic_auth = [ "user", "passwd" ]
+    http.basic_auth = [ "admin", "secret" ]
     assert_http_error 401 do
-      http.get "http://wronguser:passwd@eu.httpbin.org/basic-auth/user/passwd"
+      http.get "http://wrongadmin:secret@#{HOST}:#{PORT}/basic-auth/user/passwd"
     end
   end
 end

data/test/echo_test.rb

@@ -0,0 +1,67 @@
+# Author::    radiospiel  (mailto:eno@radiospiel.org)
+# Copyright:: Copyright (c) 2011-2015 radiospiel
+# License::   Distributes under the terms  of the Modified BSD License, see LICENSE.BSD for details.
+
+require_relative 'test_helper'
+
+class EchoTest < Simple::HTTP::TestCase
+  def test_get
+    response = http.get "/echo?a=1&b=2"
+    expected = <<~MSG
+      GET
+      a: 1
+      b: 2
+    MSG
+
+    assert_equal(expected, response.content)
+  end
+
+  def test_head
+    response = http.head "/echo?a=1&b=2"
+    assert_equal(nil, response.content)
+    assert_equal(200, response.status)
+  end
+
+  def body_example
+    {
+      foo: "bar"
+    }
+  end
+
+  def test_post
+    response = http.post "/echo?a=1&b=2", body_example
+    expected = <<~MSG
+      POST
+      a: 1
+      b: 2
+      CONTENT_TYPE: application/json
+      {"foo":"bar"}
+    MSG
+
+    assert_equal(expected, response.content)
+  end
+
+  def test_put
+    response = http.put "/echo?a=1&b=2", body_example
+    expected = <<~MSG
+      PUT
+      a: 1
+      b: 2
+      CONTENT_TYPE: application/json
+      {"foo":"bar"}
+    MSG
+
+    assert_equal(expected, response.content)
+  end
+
+  def test_delete
+    response = http.delete "/echo?a=1&b=2"
+    expected = <<~MSG
+      DELETE
+      a: 1
+      b: 2
+    MSG
+
+    assert_equal(expected, response.content)
+  end
+end

data/test/fixtures/httpd/basic-auth.rb

@@ -0,0 +1,7 @@
+use Rack::Auth::Basic do |username, password|
+  [username, password] == %w(admin secret)
+end
+
+get "/user/passwd" do
+  "ok"
+end

data/test/fixtures/httpd/echo.rb

@@ -0,0 +1,54 @@
+helpers do
+  def debug_params
+    params.map { |k, v| "#{k}: #{v}" }.sort.join("\n")
+  end
+
+  def interesting_header(name)
+    return true if name == "CONTENT_TYPE"
+    return true if name =~ /X_/
+    false
+  end
+  
+  def debug_headers
+    headers = request.each_header.select { |header, _| interesting_header(header) }
+    return if headers.empty?
+    headers.map { |k, v| "#{k}: #{v}" }.sort.join("\n")
+  end
+
+  def debug_body
+    verb = request.request_method
+    return unless verb == "POST" || verb == "PUT"
+
+    request.body.rewind
+    request.body.read
+  end
+  
+  def debug
+    [
+      request.request_method,
+      debug_params,
+      debug_headers,
+      debug_body
+    ].compact.map { |s| "#{s}\n" }.join("")
+  end
+end
+ 
+get "/"     do 
+  debug
+   end
+    
+head "/"    do
+  debug
+   end
+    
+post "/"    do
+  debug
+   end
+    
+put "/"     do
+  debug
+   end
+    
+delete "/"  do
+  debug
+   end

data/test/fixtures/httpd/root.rb

@@ -0,0 +1,20 @@
+get "/" do
+end
+
+get "/status/:status" do
+  status params[:status]
+  "No content"
+end
+
+get "/redirect-to" do
+  redirect params[:url]
+end
+
+get "/redirect-to-self" do
+  redirect "/redirect-to-self"
+end
+
+get "/redirection-target" do
+  content_type :html
+  "I am the redirection target"
+end

data/test/redirection_test.rb

@@ -5,14 +5,22 @@
 require_relative 'test_helper'
 
 class RedirectionTest < Simple::HTTP::TestCase
+  def test_limits_redirections
+    assert_raise(Simple::HTTP::TooManyRedirections) {
+      http.get "/redirect-to-self"
+    }
+  end
+
   def test_follows_redirections
-    html = http.get "http://eu.httpbin.org/redirect-to?url=http://eu.httpbin.org"
-    assert_match(/title.*httpbin/, html)
+    response = http.get "/redirect-to?url=http://#{HOST}:#{PORT}/redirection-target"
+    assert_match(/I am the redirection target/, response.content)
   end
 
-  def test_raises_error_on_invalid_redirect_location
+  # We have a hard time to convince the test application to redirect
+  # to an invalid location.. we therefore skip this test. 
+  def skipped_test_raises_error_on_invalid_redirect_location
     assert_raise(ArgumentError) {
-      http.get "http://eu.httpbin.org/redirect-to?url=foo"
+      http.get "/redirect-to?url=foo"
     }
   end
 end

data/test/simple_https_test.rb

@@ -0,0 +1,14 @@
+# Author::    radiospiel  (mailto:eno@radiospiel.org)
+# Copyright:: Copyright (c) 2011-2015 radiospiel
+# License::   Distributes under the terms  of the Modified BSD License, see LICENSE.BSD for details.
+
+ENV['SSL_CERT_FILE'] = '/usr/local/etc/openssl/certs/cert.pem'
+
+require_relative 'test_helper'
+
+class SimpleHttpsTest < Simple::HTTP::TestCase
+  def skipped_test_https
+    response = http.get "https://google.com"
+    assert_match(/doctype/, response)
+  end
+end

data/test/test_helper.rb

@@ -1,22 +1,58 @@
 require 'rubygems'
 require 'bundler/setup'
 
-# require 'simplecov'
+# -- setup a test server serving ./test/fixtures/httpd ------------------------
+#
+# This server uses simple-httpd to serve some static and dynamic test content.
+# Note: for purity reasons this should be reimplemented  via a rack middleware.
+#
+$: << "../rspec-httpd/lib"
+require "rspec/httpd/server"
+
 require 'test/unit'
 
+# require 'simplecov'
+#
 # SimpleCov.start do
 #   add_filter "test/*.rb"
 # end
 
 require 'simple/http'
-require 'simple/http/assertions'
 
 class Simple::HTTP::TestCase < Test::Unit::TestCase
-  include Simple::HTTP::Assertions
+  HOST = "0.0.0.0"
+  PORT = 12345
 
   attr :http
 
+  # start a test server. Note that this starts the server only once, and
+  # automatically cleans up the server when this process finishes.
+  def start_server!
+    httpd_root = "#{__dir__}/fixtures/httpd"
+
+    # The command to start the server must reset the BUNDLE_GEMFILE environment
+    # setting.
+    command = "cd ../simple-httpd/ && BUNDLE_GEMFILE= PORT=12345 bin/simple-httpd #{httpd_root} -q" 
+    command = "#{command} 2> log/simple-httpd.log" 
+
+    ::RSpec::Httpd::Server.start! port: PORT, command: command
+  end
+
   def setup
+    start_server!
+
     @http = Simple::HTTP.new
+    @http.base_url = "http://#{HOST}:#{PORT}"
+  end
+
+  def assert_http_error(expected_status, &block)
+    response = yield
+    assert_equal(expected_status, response.status)
+  end
+
+  def assert_http_redirects_to(expected_location, &block)
+    response = yield
+    assert_includes([301, 302], response.status)
+    assert_equal(expected_location, response.headers["Location"])
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple-http
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.2
 platform: ruby
 authors:
 - radiospiel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-25 00:00:00.000000000 Z
+date: 2019-11-16 00:00:00.000000000 Z
 dependencies: []
 description: Simple code for simple HTTP requests
 email: eno@radiospiel.org
@@ -18,15 +18,22 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/simple/http.rb
-- lib/simple/http/assertions.rb
+- lib/simple/http/body_builder.rb
+- lib/simple/http/caching.rb
+- lib/simple/http/driver/default.rb
 - lib/simple/http/errors.rb
-- lib/simple/http/expires_in.rb
-- lib/simple/http/result.rb
+- lib/simple/http/headers.rb
+- lib/simple/http/request.rb
+- lib/simple/http/response.rb
 - lib/simple/http/version.rb
 - test/assertions_test.rb
 - test/basic_auth_test.rb
+- test/echo_test.rb
+- test/fixtures/httpd/basic-auth.rb
+- test/fixtures/httpd/echo.rb
+- test/fixtures/httpd/root.rb
 - test/redirection_test.rb
-- test/simple_http_test.rb
+- test/simple_https_test.rb
 - test/test_helper.rb
 homepage: http://github.com/radiospiel/simple-http
 licenses: []
@@ -46,8 +53,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
 summary: Simple code for simple HTTP requests

data/lib/simple/http/assertions.rb

@@ -1,16 +0,0 @@
-# Author::    radiospiel  (mailto:eno@radiospiel.org)
-# Copyright:: Copyright (c) 2011-2015 radiospiel
-# License::   Distributes under the terms  of the Modified BSD License, see LICENSE.BSD for details.
-
-module Simple::HTTP::Assertions
-  def assert_http_error(expected_status, &block)
-    http_error = assert_raises(Simple::HTTP::Error, &block)
-    assert_equal(expected_status, http_error.code)
-  end
-
-  def assert_http_redirects_to(expected_location, &block)
-    http_error = assert_raises(Simple::HTTP::Error, &block)
-    assert_includes([301, 302], http_error.code)
-    assert_equal(expected_location, http_error.response["Location"])
-  end
-end

data/lib/simple/http/expires_in.rb

@@ -1,34 +0,0 @@
-# This file is part of the simple-http ruby gem.
-#
-# Copyright (c) 2011 - 2015 @radiospiel
-# Distributed under the terms of the modified BSD license, see LICENSE.BSD
-
-require "net/http"
-
-class Net::HTTPResponse
-  private
-  
-  #
-  # The "max-age" value, in seconds, from the Cache-Control header.
-  def max_age
-    return unless cache_control = header["Cache-Control"]
-    cache_control.split(/, /).each do |part|
-      next unless part =~ /max-age=(\d+)/
-      return Integer($1)
-    end
-    nil
-  end
-
-  public
-  
-  #
-  # returns expiration information, in seconds from now.
-  def expires_in
-    expires_in = max_age
-    if !expires_in && expires = header["Expires"]
-      expires_in = Time.parse(expires) - Time.now
-    end
-
-    return expires_in if expires_in && expires_in > 0
-  end
-end

data/lib/simple/http/result.rb

@@ -1,41 +0,0 @@
-# This file is part of the simple-http ruby gem.
-#
-# Copyright (c) 2011 - 2015 @radiospiel
-# Distributed under the terms of the modified BSD license, see LICENSE.BSD
-
-require "net/http"
-
-class Net::HTTPResponse
-  #
-  # evaluate and potentially parse response
-  def result
-    case response.content_type
-    when "application/json"
-      JSON.parse(body) unless body.empty?
-    else
-      body_string
-    end
-  end
-
-  private
-
-  #
-  # returns a body. The resulting string is encoded in ASCII-8BIT, if the 
-  # content type is binary, and encoded in UTF8 otherwise.
-  def body_string
-    default_encoding = content_is_binary? ? "ASCII-8BIT" : "UTF-8"
-
-    body = self.body
-    if charset = type_params["charset"]
-      body = body.force_encoding(charset)
-    end
-    body.encode(default_encoding)
-  end
-
-  def content_is_binary?
-    case content_type
-    when /^image/ then true
-    else false
-    end
-  end
-end

data/test/simple_http_test.rb

@@ -1,17 +0,0 @@
-# Author::    radiospiel  (mailto:eno@radiospiel.org)
-# Copyright:: Copyright (c) 2011-2015 radiospiel
-# License::   Distributes under the terms  of the Modified BSD License, see LICENSE.BSD for details.
-
-require_relative 'test_helper'
-
-class SimpleHttpTest < Simple::HTTP::TestCase
-  def test_http_google
-    google = http.get "http://google.com"
-    assert_match(/doctype/, google)
-  end
-
-  def test_https_google
-    google = http.get "https://google.com"
-    assert_match(/doctype/, google)
-  end
-end