http_monkey 0.0.1 → 0.0.2

data/Rakefile

@@ -5,7 +5,7 @@ ENV["RUBYOPT"] = "rubygems" if ENV["RUBYOPT"].nil?
 
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.test_files = FileList['test/http_monkey/*_test.rb']
+  t.test_files = FileList['test/http_monkey/**/*_test.rb']
 end
 
 Rake::TestTask.new("test:integration") do |t|

data/Readme.md

@@ -2,8 +2,6 @@
 
 A fluent interface to do HTTP calls, free of fat dependencies and at same time, powered by middlewares rack.
 
-It's an awesome client with an awful name.
-
 ## Light and powerful
 
 ``` ruby
@@ -44,9 +42,19 @@ It's an awesome client with an awful name.
       req.auth.ssl.ssl_version       = :TLSv1             # or one of [:SSLv2, :SSLv3]
     end.get
 
-    # Default HTTP Headers (to all requests)
+    # HttpMonkey "built-in" middlewares
     HttpMonkey.configure do
-      middlewares.use HttpMonkey::Middlewares::DefaultHeaders, {"Content-Type" => "application/json"}
+      # Default HTTP Headers (to all requests)
+      middlewares.use HttpMonkey::M::DefaultHeaders, {"Content-Type" => "application/json"}
+
+      # Filter ALL requests (access to env and request objects)
+      middlewares.use HttpMonkey::M::RequestFilter do |env, request|
+        # HTTPI::Request, you can set proxy, timeouts, authentication etc.
+        # req.proxy = "http://proxy.com"
+      end
+
+      # Enable automatic follow redirect
+      middlewares.use HttpMonkey::M::FollowRedirect, :max_tries => 3
     end
 ```
 
@@ -156,12 +164,14 @@ Easy to extend, using the power of Rack middleware interface.
     end
 ```
 
-Some ideas:
+Some ideas to future:
+
+* Cache? Finish [cachebag](https://github.com/abril/cachebag)
+* Support Cookies with http_monkey-cookies (to do).
+* Logger? Maybe a built-in middleware? Apache/Custom format.
+* Cool ways to support asynchronous calls.
 
-* Cache? [rack-cache](https://github.com/rtomayko/rack-cache)
-* Logger? [http://rack.rubyforge.org/doc/Rack/Logger.html]
-* Profile?
-* Support to specific Media Type?
+You can see my [presentation](http://www.slideshare.net/rogerleite14/http-monkey) in *pt-br* at Editora Abril.
 
 ## Easy to contribute
 

data/http_monkey.gemspec

@@ -24,4 +24,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "minitest", "~> 3"
   gem.add_development_dependency "minitest-reporters", "~> 0.7.0"
   gem.add_development_dependency "mocha"
+  gem.add_development_dependency "minion_server"
 end

data/lib/http_monkey.rb

@@ -33,15 +33,6 @@ module HttpMonkey
     @@default_client ||= build do
       net_adapter :net_http
       behaviours do
-        # Follow redirects
-        on([301, 302, 303, 307]) do |client, request, response|
-          if (location = response.headers["location"])
-            request.url = location
-            client.http_request(:get, request)
-          else
-            raise "HTTP status #{response.code} not supported (or location not found)"
-          end
-        end
         # By default, always return response
         on_unknown do |client, request, response|
           response

data/lib/http_monkey/client/environment.rb

@@ -1,23 +1,27 @@
 module HttpMonkey
 
-  # Rack environment with helpers.
-  class Client::Environment
+  # Rack environment on steroids! -_-
+  # This Hash with super powers is passed to Middlewares.
+  #
+  # "Snaky" middlewares always remember! "With great power comes great responsibility"
+  class Client::Environment < ::Hash
 
-    def initialize(env)
-      @env = env
+    def initialize(obj = nil, &block)
+      super
+      self.merge!(obj) unless obj.nil?  # better idea? pull please.
+      self.default = nil
     end
 
-    def [](key)
-      @env[key]
-    end
-
-    def []=(key, value)
-      @env[key] = value
-    end
-
-    # From {"HTTP_CONTENT_TYPE" => "text/html"} to {"Content-Type" => "text/html"}
+    # Extracts HTTP_ headers from rack environment.
+    #
+    # Example
+    #
+    #   env = Client::Environment.new({"HTTP_X_CUSTOM" => "custom"})
+    #   env.http_headers  # => {"X-Custom" => "custom"}
+    #
+    # Returns Hash with normalized http headers.
     def http_headers
-      req_headers = @env.reject {|k,v| !k.start_with? "HTTP_" }
+      req_headers = self.reject {|k,v| !k.start_with? "HTTP_" }
       normalized = req_headers.map do |key, value|
         new_key = key.sub("HTTP_",'').split('_').map(&:capitalize).join('-')
         [new_key, value]
@@ -25,6 +29,70 @@ module HttpMonkey
       Hash[normalized]
     end
 
+    # Sets HTTP header in rack standard way of life.
+    #
+    # Example
+    #
+    #   env = Client::Environment.new
+    #   env.add_http_header("Content-Type" => "text/html")
+    #   env.inspect  # => {"HTTP_CONTENT_TYPE" => "text/html"}
+    #
+    # Returns nothing important.
+    def add_http_header(headers = {})
+      headers.each do |key, value|
+        self["HTTP_#{key.to_s.upcase.gsub("-", "_")}"] = value
+      end
+    end
+
+    # Returns HTTPI::Request instance or nil.
+    def monkey_request
+      if (data = self['http_monkey.request'])
+        data[1]
+      end
+    end
+
+    # Returns HttpMonkey::Client instance or nil.
+    def monkey_client
+      if (data = self['http_monkey.request'])
+        data[2]
+      end
+    end
+
+    # Sets uri as Rack wants.
+    def uri=(uri)
+      self['SERVER_NAME'] = uri.host
+      self['SERVER_PORT'] = uri.port.to_s
+      self['QUERY_STRING'] = (uri.query || "")
+      self['PATH_INFO'] = (!uri.path || uri.path.empty?) ? "/" : uri.path
+      self['rack.url_scheme'] = uri.scheme
+      self['HTTPS'] = (uri.scheme == "https" ? "on" : "off")
+      self['REQUEST_URI'] = uri.request_uri
+      self['HTTP_HOST'] = uri.host
+    end
+
+    # Returns uri from Rack environment.
+    # Throws ArgumentError for invalid uri.
+    def uri
+      uri = %Q{#{self['rack.url_scheme']}://#{self['SERVER_NAME']}:#{self['SERVER_PORT']}#{self['REQUEST_URI']}}
+      begin
+        URI.parse(uri)
+      rescue StandardError => e
+        raise ArgumentError, "Invalid #{uri}", e.backtrace
+      end
+    end
+
+    # Returns normalized request method.
+    #
+    # Example
+    #
+    #   env = Client::Environment.new('REQUEST_METHOD' => 'GET')
+    #   env.request_method  # => :get
+    #
+    def request_method
+      method = self['REQUEST_METHOD'].to_s
+      (method.empty? ? nil : method.downcase.to_sym)
+    end
+
   end
 
 end

data/lib/http_monkey/client/environment_builder.rb

@@ -11,6 +11,7 @@ module HttpMonkey
       "rack.multithread" => true,
       "rack.multiprocess" => false,
       "rack.run_once" => false,
+      'SCRIPT_NAME'     => "" # call me Suzy
     }
 
     def initialize(client, method, request)
@@ -19,41 +20,29 @@ module HttpMonkey
       @request = request
     end
 
+    # Returns a instance of HttpMonkey::Client::Environment with
+    # rack like headers.
     def to_env
       uri = @request.url
       rack_input = normalize_body(@request.body)
 
-      env = DEFAULT_ENV.dup
-      env = env.merge({
+      env = HttpMonkey::Client::Environment.new(DEFAULT_ENV)
+      env.uri = @request.url
+
+      env.update({
         # request info
         'REQUEST_METHOD'  => @method.to_s.upcase,
-        'SERVER_NAME'     => uri.host,
-        'SERVER_PORT'     => (uri.port || uri.inferred_port).to_s,
-        'QUERY_STRING'    => uri.query || "",
-        'PATH_INFO'       => (!uri.path || uri.path.empty?) ? "/" : uri.path,
-        'rack.url_scheme' => uri.scheme,
-        'HTTPS'           => (uri.scheme == "https" ? "on" : "off"),
-        'SCRIPT_NAME'     => "", # call me Suzy
 
-        'REQUEST_URI'     => uri.request_uri,
-        'HTTP_HOST'       => uri.host,
         'rack.input'      => rack_input,
         'CONTENT_LENGTH'  => rack_input.length.to_s,
 
         # custom info
-        'http_monkey.request' => [@method, @request, @client.net_adapter]
-      }).update(http_headers)
+        'http_monkey.request' => [@method, @request, @client]
+      })
+      env.add_http_header(@request.headers)
       env
     end
 
-    # From {"Content-Type" => "text/html"} to {"HTTP_CONTENT_TYPE" => "text/html"}
-    def http_headers
-      env_headers = @request.headers.map do |key, value|
-        ["HTTP_#{key.to_s.upcase.gsub("-", "_")}", value]
-      end
-      Hash[env_headers]
-    end
-
     def normalize_body(body)
       return "" if body.nil?
       input = body.dup

data/lib/http_monkey/client/http_request.rb

@@ -5,13 +5,15 @@ module HttpMonkey
   class Client::HttpRequest
 
     def self.call(env)
-      env = Client::Environment.new(env)
-      method, request, net_adapter = env['http_monkey.request']
+      env = Client::Environment.new(env) unless env.is_a?(Client::Environment)
+      _, request, client = env['http_monkey.request']
 
+      method = env.request_method
+      request.url = env.uri
       request.headers = env.http_headers
       request.body = env['rack.input']
 
-      response = HTTPI.request(method, request, net_adapter)
+      response = HTTPI.request(method, request, client.net_adapter)
       [response.code, response.headers, response.body]
     end
 

data/lib/http_monkey/middlewares.rb

@@ -1,5 +1,8 @@
 module HttpMonkey
   module Middlewares
     autoload :DefaultHeaders, "http_monkey/middlewares/default_headers"
+    autoload :RequestFilter, "http_monkey/middlewares/request_filter"
+    autoload :FollowRedirect, "http_monkey/middlewares/follow_redirect"
   end
+  M = Middlewares
 end

data/lib/http_monkey/middlewares/follow_redirect.rb

@@ -0,0 +1,41 @@
+module HttpMonkey::Middlewares
+
+  # Follow Redirects
+  # For response codes [301, 302, 303, 307], follow Location header.
+  # If header not found or tries is bigger than +max_tries+, throw RuntimeError.
+  #
+  # Example
+  #
+  #   HttpMonkey.configure do
+  #     middlewares.use HttpMonkey::M::FollowRedirect, :max_tries => 5 # default: 3
+  #   end
+  #
+  class FollowRedirect
+
+    InfiniteRedirectError = Class.new(StandardError)
+
+    def initialize(app, options = {})
+      @app = app
+      @max_tries = options.fetch(:max_tries, 3)
+      @follow_headers = options.fetch(:headers, [301, 302, 303, 307])
+    end
+
+    def call(env)
+      current_try = 0
+      begin
+        code, headers, body = @app.call(env)
+        break unless @follow_headers.include?(code)
+
+        location = (headers["Location"] || headers["location"])
+        raise RuntimeError, "HTTP status #{code}. No Location header." unless location
+
+        env.uri = URI.parse(location) # change uri and submit again
+        current_try += 1
+        raise RuntimeError, "Reached the maximum number of attempts in following url." if current_try > @max_tries
+      end while true
+      [code, headers, body]
+    end
+
+  end
+
+end

data/lib/http_monkey/middlewares/request_filter.rb

@@ -0,0 +1,33 @@
+module HttpMonkey::Middlewares
+
+  # Intercept all requests
+  #
+  # Example
+  #
+  #   HttpMonkey.configure do
+  #     middlewares.use HttpMonkey::Middlewares::RequestFilter do |env, request|
+  #       # HttpMonkey::Client::Environment, hash rack on steroids
+  #       # You can use "snaky" methods like:
+  #       # env.http_headers  # => {"Content-Type" => "text/html"}
+  #       # env.add_http_header("X-Custom" => "custom")
+  #
+  #       # HTTPI::Request, you can set proxy, timeouts, authentication etc.
+  #       # req.proxy = "http://example.com"
+  #     end
+  #   end
+  #
+  class RequestFilter
+
+    def initialize(app, &block)
+      @app = app
+      @block = (block || lambda {|env, req| })
+    end
+
+    def call(env)
+      @block.call(env, env.monkey_request)
+      @app.call(env)
+    end
+
+  end
+
+end

data/lib/http_monkey/version.rb

@@ -1,3 +1,3 @@
 module HttpMonkey
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/http_monkey/client/environment_test.rb

@@ -4,25 +4,125 @@ describe HttpMonkey::Client::Environment do
 
   subject { HttpMonkey::Client::Environment }
 
-  describe "#accessor" do
-    it "gets like Hash" do
-      env = subject.new(:test => "value")
-      env[:test].must_equal("value")
+  it "must be kind of Hash" do
+    subject.new.must_be_kind_of(Hash)
+  end
+
+  describe "hash default" do
+    it "default non key be nil" do
+      env = subject.new("HTTP_CONTENT_TYPE" => "text/html",
+                        "HTTP_X_CUSTOM" => "custom")
+      env["HTTP_X_CUSTOM"].must_equal("custom")
+      env["NON_EXIST"].must_be_nil
+    end
+  end
+
+  describe "#http_headers" do
+    it "empty env must return empty Hash" do
+      http_headers = subject.new.http_headers
+      http_headers.must_be_empty
+    end
+    it "must list HTTP Headers" do
+      env = subject.new("HTTP_CONTENT_TYPE" => "text/html",
+                        "HTTP_X_CUSTOM" => "custom")
+
+      http_headers = env.http_headers
+      http_headers["Content-Type"].must_equal("text/html")
+      http_headers["X-Custom"].must_equal("custom")
+    end
+  end
+
+  it "#add_http_header" do
+    env = subject.new("HTTP_CONTENT_TYPE" => "text/html")
+
+    env.add_http_header("Content-Type" => "application/json",
+                        "X-Custom" => "custom")
+    env["HTTP_CONTENT_TYPE"].must_equal("application/json")
+    env["HTTP_X_CUSTOM"].must_equal("custom")
+  end
+
+  describe "#monkey_request" do
+    it "with object" do
+      stub_req = stub("request")
+      env = subject.new("http_monkey.request" => [nil, stub_req, nil])
+      env.monkey_request.must_be_same_as(stub_req)
     end
-    it "sets like Hash" do
-      env = subject.new(:test => "value")
-      env[:test] = "owned"
-      env[:test].must_equal("owned")
+    it "without object" do
+      env = subject.new
+      env.monkey_request.must_be_nil
     end
   end
 
-  it "#http_headers" do
-    env = subject.new("HTTP_CONTENT_TYPE" => "text/html",
-                      "HTTP_X_CUSTOM" => "custom")
+  describe "#monkey_client" do
+    it "with object" do
+      stub_client = stub("request")
+      env = subject.new("http_monkey.request" => [nil, nil, stub_client])
+      env.monkey_client.must_be_same_as(stub_client)
+    end
+    it "without object" do
+      env = subject.new
+      env.monkey_client.must_be_nil
+    end
+  end
 
-    env.http_headers.must_be_instance_of(Hash)
-    env.http_headers["Content-Type"].must_equal("text/html")
-    env.http_headers["X-Custom"].must_equal("custom")
+  describe "#uri=" do
+    it "complete url" do
+      env = subject.new
+      env.uri = URI.parse("http://localhost:3000/path?q=query")
+
+      env['SERVER_NAME'].must_equal("localhost")
+      env['SERVER_PORT'].must_equal("3000")
+      env['QUERY_STRING'].must_equal("q=query")
+      env['PATH_INFO'].must_equal("/path")
+      env['rack.url_scheme'].must_equal("http")
+      env['HTTPS'].must_equal("off")
+      env['REQUEST_URI'].must_equal("/path?q=query")
+      env['HTTP_HOST'].must_equal("localhost")
+    end
+    it "simple url" do
+      env = subject.new
+      env.uri = URI.parse("http://localhost")
+
+      env['SERVER_PORT'].must_equal("80")
+      env['QUERY_STRING'].must_equal("")
+      env['PATH_INFO'].must_equal("/")
+    end
+    it "https url" do
+      env = subject.new
+      env.uri = URI.parse("https://localhost:3000")
+
+      env['HTTPS'].must_equal("on")
+    end
+  end
+
+  describe "#uri" do
+    it "valid url" do
+      env = subject.new
+      env['SERVER_NAME'] = "localhost"
+      env['SERVER_PORT'] = "3000"
+      env['rack.url_scheme'] = "http"
+      env['REQUEST_URI'] = "/path?q=query"
+
+      uri = env.uri
+      uri.to_s.must_equal("http://localhost:3000/path?q=query")
+    end
+    it "invalid url" do
+      env = subject.new
+      lambda do
+        env.uri
+      end.must_raise(ArgumentError)
+    end
+  end
+
+  describe "#request_method" do
+    it "with value" do
+      env = subject.new('REQUEST_METHOD' => "GET")
+      env.request_method.must_equal(:get)
+    end
+    it "empty" do
+      env = subject.new
+      env.request_method.must_be_nil
+    end
   end
 
 end

data/test/http_monkey/middlewares/default_headers_test.rb

@@ -7,7 +7,7 @@ describe HttpMonkey::Middlewares::DefaultHeaders do
   end
 
   let(:fake_env) { Hash.new }
-  subject { HttpMonkey::Middlewares::DefaultHeaders }
+  subject { HttpMonkey::M::DefaultHeaders }
 
   it "always call app" do
     @mock_app.expects(:call).with(fake_env)

data/test/http_monkey/middlewares/follow_redirect_test.rb

@@ -0,0 +1,7 @@
+require "test_helper"
+
+describe HttpMonkey::Middlewares::FollowRedirect do
+
+  it "tests on integration only"
+
+end

data/test/http_monkey/middlewares/request_filter_test.rb

@@ -0,0 +1,31 @@
+require "test_helper"
+
+describe HttpMonkey::Middlewares::RequestFilter do
+
+  include HttpMonkey::Support::FakeEnvironment
+
+  before do
+    @mock_app = stub("app", :call => "stubbed")
+  end
+
+  subject { HttpMonkey::M::RequestFilter }
+
+  it "always call app" do
+    @mock_app.expects(:call).with(fake_env)
+    subject.new(@mock_app).call(fake_env)
+  end
+
+  it "executes block" do
+    flag = "out block"
+
+    middle = subject.new(@mock_app) do |env, req|
+      env.must_be_same_as(fake_env)
+      req.must_be_same_as(fake_request)
+      flag = "inside block"
+    end
+    middle.call(fake_env)
+
+    flag.must_equal("inside block")
+  end
+
+end

data/test/http_monkey/middlewares_test.rb

@@ -0,0 +1,7 @@
+require "test_helper"
+
+describe HttpMonkey::Middlewares do
+  it "alias to M" do
+    HttpMonkey::Middlewares.must_be_same_as(HttpMonkey::M)
+  end
+end

data/test/integration/follow_redirect_test.rb

@@ -0,0 +1,89 @@
+require "test_helper"
+
+class Counter
+  @@counter = 0
+  def self.value
+    @@counter
+  end
+  def self.increment
+    @@counter += 1
+  end
+end
+
+RedirectApp = Rack::Builder.new do
+  map "/" do
+    run lambda { |env|
+      [301, {"Content-Type" => "text/plain", "Location" => "http://localhost:4000/home"}, ["Redirecting ..."]]
+    }
+  end
+
+  map "/home" do
+    run lambda { |env|
+      [200, {"Content-Type" => "text/plain"}, ["home sweet home"]]
+    }
+  end
+
+  map "/redirect3times" do
+    run lambda { |e| [301, {"Location" => "http://localhost:4000/redirect2times"}, ["Should Redirect"]]}
+  end
+  map "/redirect2times" do
+    run lambda { |e| [301, {"Location" => "http://localhost:4000/redirect1times"}, ["Should Redirect"]]}
+  end
+  map "/redirect1times" do
+    run lambda { |e| [301, {"Location" => "http://localhost:4000/home"}, ["Should Redirect"]]}
+  end
+
+  map "/infinite-redirect" do
+    run lambda { |env|
+      Counter.increment
+      if Counter.value > 10
+        [200, {}, ["Give up, i can't blow yu machine"]]
+      else
+        [301, {"Location" => "http://localhost:4000/infinite-redirect"}, ["Stop with you can"]]
+      end
+    }
+  end
+
+  map "/no-location" do
+    run lambda { |env| [301, {}, ["no location header"]] }
+  end
+end
+
+describe "Integration Specs - Middleware Follow Redirects" do
+
+  def self.before_suite
+    @server = MinionServer.new(RedirectApp).start
+  end
+
+  def self.after_suite
+    @server.shutdown
+  end
+
+  let(:client) do
+    HttpMonkey.build do
+      middlewares.use HttpMonkey::M::FollowRedirect, :max_tries => 3
+    end
+  end
+
+  it "follow redirects" do
+    response = client.at("http://localhost:4000").get
+    response.body.must_equal("home sweet home")
+  end
+
+  it "follow redirects in chain" do
+    response = client.at("http://localhost:4000/redirect3times").get
+    response.body.must_equal("home sweet home")
+  end
+
+  it "respect max_tries" do
+    lambda {
+      response = client.at("http://localhost:4000/infinite-redirect").get
+    }.must_raise(RuntimeError)
+  end
+
+  it "raises exception in lack of Location" do
+    lambda {
+      response = client.at("http://localhost:4000/no-location").get
+    }.must_raise(RuntimeError)
+  end
+end

data/test/integration/verbs_test.rb

@@ -1,7 +1,6 @@
-require "integration/server"
+require "test_helper"
 
 VerbsApp = Rack::Builder.new do
-  #use IntegrationServer::InspectEnv # i can see clear now the rain is gone ...
   map "/" do
     run lambda { |env|
       env['rack.input'] = env['rack.input'].read if env['rack.input'].respond_to?(:read)
@@ -11,25 +10,29 @@ VerbsApp = Rack::Builder.new do
   end
 end
 
-IntegrationServer.new(VerbsApp).start
-
 describe "Integration Specs - Verbs" do
 
-  describe "#get" do
-    it "no parameter" do
-      response = HttpMonkey.at("http://localhost:4000").get
-      server_env = YAML.load(response.body)
-
-      server_env["REQUEST_METHOD"].must_equal("GET")
-      server_env["QUERY_STRING"].must_be_empty
-    end
-    it "with parameters" do
-      response = HttpMonkey.at("http://localhost:4000").get(:q => "query")
-      server_env = YAML.load(response.body)
-
-      server_env["REQUEST_METHOD"].must_equal("GET")
-      server_env["QUERY_STRING"].must_equal("q=query")
-    end
+  def self.before_suite
+    @@server = MinionServer.new(VerbsApp).start
+  end
+
+  def self.after_suite
+    @@server.shutdown
+  end
+
+  it "#get - no parameter" do
+    response = HttpMonkey.at("http://localhost:4000").get
+    server_env = YAML.load(response.body)
+
+    server_env["REQUEST_METHOD"].must_equal("GET")
+    server_env["QUERY_STRING"].must_be_empty
+  end
+  it "#get - with parameters" do
+    response = HttpMonkey.at("http://localhost:4000").get(:q => "query")
+    server_env = YAML.load(response.body)
+
+    server_env["REQUEST_METHOD"].must_equal("GET")
+    server_env["QUERY_STRING"].must_equal("q=query")
   end
 
   it "#post" do

data/test/support/captain_hook.rb

@@ -0,0 +1,42 @@
+module HttpMonkey::Support
+
+  # Add *before_suite* and *after_suite* on tests.
+  #
+  # Examples
+  #
+  #  describe "Sample spec" do
+  #
+  #    def self.before_suite
+  #      puts "before all"
+  #    end
+  #    def self.after_suite
+  #      puts "after all"
+  #    end
+  #
+  #    it "should test something"
+  #  end
+class CaptainHook
+
+    def before_suites(suites, type); end
+    def after_suites(suites, type); end
+
+    def before_suite(suite)
+      suite.before_suite if suite.respond_to?(:before_suite)
+    end
+    def after_suite(suite)
+      suite.after_suite if suite.respond_to?(:after_suite)
+    end
+
+    def before_test(suite, test); end
+    # methods "pass, skip, failure, error" should call this
+    #def after_test(suite, test, test_runner)
+    #end
+
+    def pass(suite, test, test_runner); end
+    def skip(suite, test, test_runner); end
+    def failure(suite, test, test_runner); end
+    def error(suite, test, test_runner); end
+
+  end
+
+end

data/test/support/fake_environment.rb

@@ -0,0 +1,22 @@
+module HttpMonkey::Support
+
+  module FakeEnvironment
+
+    def fake_request
+      @fake_request ||= stub("request")
+    end
+
+    def fake_client
+      @fake_client ||= stub("client")
+    end
+
+    def fake_env
+      @fake_env ||= begin
+                      env = {'http_monkey.request' => [nil, fake_request, fake_client]}
+                      HttpMonkey::Client::Environment.new(env)
+                    end
+    end
+
+  end
+
+end

data/test/test_helper.rb

@@ -5,5 +5,11 @@ require "minitest/reporters"
 
 require "mocha"
 
+require "support/fake_environment"
+require "support/captain_hook"
+
 MiniTest::Unit.runner = MiniTest::SuiteRunner.new
 MiniTest::Unit.runner.reporters << MiniTest::Reporters::SpecReporter.new
+MiniTest::Unit.runner.reporters << HttpMonkey::Support::CaptainHook.new
+
+require "minion_server"

metadata

@@ -1,119 +1,101 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: http_monkey
-version: !ruby/object:Gem::Version 
-  hash: 29
+version: !ruby/object:Gem::Version
+  version: 0.0.2
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 1
-  version: 0.0.1
 platform: ruby
-authors: 
+authors:
 - Roger Leite
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-11-12 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-11-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rack
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70184962553820 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: httpi
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70184962553820
+- !ruby/object:Gem::Dependency
+  name: httpi
+  requirement: &70184962553260 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 13
-        segments: 
-        - 1
-        - 1
-        version: "1.1"
+      - !ruby/object:Gem::Version
+        version: '1.1'
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rake
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *70184962553260
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70184962552740 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: minitest
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: *70184962552740
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &70184962552180 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 5
-        segments: 
-        - 3
-        version: "3"
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :development
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: minitest-reporters
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: *70184962552180
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: &70184962551620 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        - 7
-        - 0
+      - !ruby/object:Gem::Version
         version: 0.7.0
   type: :development
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: *70184962551620
+- !ruby/object:Gem::Dependency
   name: mocha
+  requirement: &70184962551220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  version_requirements: *70184962551220
+- !ruby/object:Gem::Dependency
+  name: minion_server
+  requirement: &70184962550760 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id006
-description: A fluent interface to do HTTP calls, free of fat dependencies and at same time, powered by middlewares rack.
-email: 
+  prerelease: false
+  version_requirements: *70184962550760
+description: A fluent interface to do HTTP calls, free of fat dependencies and at
+  same time, powered by middlewares rack.
+email:
 - roger.barreto@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - .travis.yml
 - Gemfile
@@ -132,6 +114,8 @@ files:
 - lib/http_monkey/entry_point.rb
 - lib/http_monkey/middlewares.rb
 - lib/http_monkey/middlewares/default_headers.rb
+- lib/http_monkey/middlewares/follow_redirect.rb
+- lib/http_monkey/middlewares/request_filter.rb
 - lib/http_monkey/version.rb
 - test/http_monkey/client/environment_test.rb
 - test/http_monkey/client_test.rb
@@ -141,43 +125,40 @@ files:
 - test/http_monkey/entry_point_test.rb
 - test/http_monkey/http_monkey_test.rb
 - test/http_monkey/middlewares/default_headers_test.rb
-- test/integration/server.rb
+- test/http_monkey/middlewares/follow_redirect_test.rb
+- test/http_monkey/middlewares/request_filter_test.rb
+- test/http_monkey/middlewares_test.rb
+- test/integration/follow_redirect_test.rb
 - test/integration/verbs_test.rb
+- test/support/captain_hook.rb
+- test/support/fake_environment.rb
 - test/test_helper.rb
 homepage: https://github.com/rogerleite/http_monkey
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
 rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
-summary: A fluent interface to do HTTP calls, free of fat dependencies and at same time, powered by middlewares rack.
-test_files: 
+summary: A fluent interface to do HTTP calls, free of fat dependencies and at same
+  time, powered by middlewares rack.
+test_files:
 - test/http_monkey/client/environment_test.rb
 - test/http_monkey/client_test.rb
 - test/http_monkey/configuration/behaviours_test.rb
@@ -186,6 +167,11 @@ test_files:
 - test/http_monkey/entry_point_test.rb
 - test/http_monkey/http_monkey_test.rb
 - test/http_monkey/middlewares/default_headers_test.rb
-- test/integration/server.rb
+- test/http_monkey/middlewares/follow_redirect_test.rb
+- test/http_monkey/middlewares/request_filter_test.rb
+- test/http_monkey/middlewares_test.rb
+- test/integration/follow_redirect_test.rb
 - test/integration/verbs_test.rb
+- test/support/captain_hook.rb
+- test/support/fake_environment.rb
 - test/test_helper.rb

data/test/integration/server.rb

@@ -1,73 +0,0 @@
-require "test_helper"
-
-# Inspiration from https://github.com/djanowski/mock-server
-class IntegrationServer
-
-  def initialize(app)
-    @app = app
-  end
-
-  def start(host = "localhost", port = 4000)
-    Thread.new do
-      silence_output do  # comment this if you want information
-        Rack::Server.start(
-          :app => @app,
-          :server => 'webrick',
-          :environment => :none,
-          :daemonize => false,
-          :Host => host,
-          :Port => port
-        )
-      end
-    end
-    wait_for_service(host, port)
-    true
-  end
-
-  protected
-
-  # quick and dirty
-  def silence_output
-    $stdout = File.new('/dev/null', 'w')
-    $stderr = File.new('/dev/null', 'w')
-    yield
-  ensure
-    $stdout = STDOUT
-    $stderr = STDERR
-  end
-
-  def listening?(host, port)
-    begin
-      socket = TCPSocket.new(host, port)
-      socket.close unless socket.nil?
-      true
-    rescue Errno::ECONNREFUSED,
-      Errno::EBADF,           # Windows
-      Errno::EADDRNOTAVAIL    # Windows
-      false
-    end
-  end
-
-  def wait_for_service(host, port, timeout = 5)
-    start_time = Time.now
-
-    until listening?(host, port)
-      if timeout && (Time.now > (start_time + timeout))
-        raise SocketError.new("Socket did not open within #{timeout} seconds")
-      end
-    end
-
-    true
-  end
-
-end
-
-class IntegrationServer::InspectEnv
-  def initialize(app)
-    @app = app
-  end
-  def call(env)
-    puts "-> #{env.inspect}"
-    @app.call(env)
-  end
-end