http_monkey 0.0.1

data/lib/http_monkey.rb

@@ -0,0 +1,64 @@
+require "net/http"
+require "rack"
+require "httpi"
+
+require "http_monkey/version"
+require "http_monkey/entry_point"
+require "http_monkey/configuration"
+require "http_monkey/configuration/behaviours"
+require "http_monkey/configuration/middlewares"
+require "http_monkey/client"
+require "http_monkey/client/http_request"
+require "http_monkey/client/environment"
+require "http_monkey/client/environment_builder"
+require "http_monkey/middlewares"
+
+module HttpMonkey
+
+  def self.at(url)
+    default_client.at(url)
+  end
+
+  def self.configure(&block)
+    default_client.configure(&block)
+  end
+
+  def self.build(&block)
+    HttpMonkey::Client.new.configure(&block)
+  end
+
+  protected
+
+  def self.default_client
+    @@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
+        end
+      end
+    end
+  end
+
+end
+
+HTTPI.log = false
+
+# This monkey patch is to avoid a bug from httpi (1.1.1) on ruby 1.8.7
+# that raises "undefined method `use_ssl=' for Net::HTTP"
+if RUBY_VERSION =~ /1\.8/
+  class Net::HTTPSession
+    def use_ssl=(flag)
+    end
+  end
+end

data/test/http_monkey/client/environment_test.rb

@@ -0,0 +1,28 @@
+require "test_helper"
+
+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")
+    end
+    it "sets like Hash" do
+      env = subject.new(:test => "value")
+      env[:test] = "owned"
+      env[:test].must_equal("owned")
+    end
+  end
+
+  it "#http_headers" do
+    env = subject.new("HTTP_CONTENT_TYPE" => "text/html",
+                      "HTTP_X_CUSTOM" => "custom")
+
+    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")
+  end
+
+end

data/test/http_monkey/client_test.rb

@@ -0,0 +1,28 @@
+require "test_helper"
+
+describe HttpMonkey::Client do
+
+  subject do
+    HttpMonkey::Client.new
+  end
+
+  it "#at" do
+    subject.at("http://server.com").must_be_instance_of(HttpMonkey::EntryPoint)
+  end
+
+  describe "default values" do
+    it "#net_adapter" do
+      subject.net_adapter.must_equal(:net_http)
+    end
+  end
+
+  describe "#configure" do
+    it "#net_adapter" do
+      subject.configure do
+        net_adapter(:curb)
+      end
+      subject.net_adapter.must_equal(:curb)
+    end
+  end
+
+end

data/test/http_monkey/configuration/behaviours_test.rb

@@ -0,0 +1,34 @@
+require "test_helper"
+
+describe HttpMonkey::Configuration::Behaviours do
+
+  subject { HttpMonkey::Configuration::Behaviours.new }
+
+  describe "#on" do
+    it "support Integer code" do
+      subject.on(1) { "test int" }
+
+      subject.find(1).call.must_equal("test int")
+      subject.find(2).must_be_nil
+    end
+    it "support Range code" do
+      subject.on(90...100) { "test range" }
+
+      subject.find(90).call.must_equal("test range")
+      subject.find(99).call.must_equal("test range")
+      subject.find(100).must_be_nil
+    end
+    it "support Array code (or anything that respond_to include?)" do
+      subject.on([2,3]) { "test array" }
+
+      subject.find(2).call.must_equal("test array")
+      subject.find(3).call.must_equal("test array")
+      subject.find(1).must_be_nil
+    end
+  end
+
+  it "#on_unknown" do
+    subject.on_unknown { "ok" }
+    subject.unknown_behaviour.call.must_equal("ok")
+  end
+end

data/test/http_monkey/configuration/middlewares_test.rb

@@ -0,0 +1,73 @@
+require "test_helper"
+
+describe HttpMonkey::Configuration::Middlewares do
+
+  subject { HttpMonkey::Configuration::Middlewares.new }
+
+  class MiddleBase
+    def initialize(app, args = {}, &block)
+      @app = app
+      @args = args
+      @block = block
+    end
+    def call(env)
+      env[:args] = @args
+      env[:block] = @block
+      env[:app] ||= []
+      env[:app] << "before #{self.class.to_s}"
+      result = @app.call(env)
+      env[:app] << "after #{self.class.to_s}"
+      result
+    end
+  end
+
+  class Middle1 < MiddleBase; end
+  class Middle2 < MiddleBase; end
+
+  let(:app) do
+    Proc.new do |env|
+      env[:app] << "app"
+      "OK"
+    end
+  end
+
+  let(:env) do
+    {:app => []}
+  end
+
+  describe "#use" do
+    it "delegate args" do
+      subject.use Middle1, :arg1 =>'arg1', :arg2 => "arg2"
+      subject.execute(app, env)
+      env[:args].must_equal({:arg1 =>'arg1', :arg2 => "arg2"})
+    end
+    it "delegate block" do
+      subject.use Middle1 do
+        "Middle1 block"
+      end
+      subject.execute(app, env)
+      env[:block].call.must_equal("Middle1 block")
+    end
+  end
+
+  describe "#execute" do
+    it "without chain" do
+      result = subject.execute(app, env)
+      result.must_equal("OK")
+    end
+    it "chain of one" do
+      subject.use Middle1
+      subject.execute(app, env)
+
+      env[:app].must_equal(["before Middle1", "app", "after Middle1"])
+    end
+    it "chain of many (maintain order)" do
+      subject.use Middle1
+      subject.use Middle2
+      subject.execute(app, env)
+
+      env[:app].must_equal(["before Middle1", "before Middle2", "app", "after Middle2", "after Middle1"])
+    end
+  end
+
+end

data/test/http_monkey/configuration_test.rb

@@ -0,0 +1,64 @@
+require "test_helper"
+
+describe HttpMonkey::Configuration do
+
+  subject do
+    HttpMonkey::Configuration.new
+  end
+
+  describe "#clone" do
+    it "#behaviours" do
+      clone = subject.clone
+      subject.behaviours.wont_be_same_as(clone.behaviours)
+    end
+    it "#middlewares" do
+      clone = subject.clone
+      subject.middlewares.wont_be_same_as(clone.middlewares)
+    end
+  end
+
+  describe "#net_adapter" do
+    it "returns value" do
+      subject.net_adapter.must_equal(:net_http)
+    end
+    it "sets value" do
+      subject.net_adapter(:curb)
+      subject.net_adapter.must_equal(:curb)
+    end
+  end
+
+  describe "#behaviours" do
+    it "respond_to" do
+      subject.must_respond_to(:behaviours)
+    end
+    it "returns value" do
+      subject.behaviours.must_be_instance_of(HttpMonkey::Configuration::Behaviours)
+    end
+    it "sets value using block" do
+      flag = "out block"
+      subject.behaviours do
+        self.must_be_instance_of(HttpMonkey::Configuration::Behaviours)
+        flag = "inside block"
+      end
+      flag.must_equal("inside block")
+    end
+  end
+
+  describe "#middlewares" do
+    it "respond_to" do
+      subject.must_respond_to(:middlewares)
+    end
+    it "returns value" do
+      subject.middlewares.must_be_instance_of(HttpMonkey::Configuration::Middlewares)
+    end
+    it "sets value using block" do
+      flag = "out block"
+      subject.middlewares do
+        self.must_be_instance_of(HttpMonkey::Configuration::Middlewares)
+        flag = "inside block"
+      end
+      flag.must_equal("inside block")
+    end
+  end
+
+end

data/test/http_monkey/entry_point_test.rb

@@ -0,0 +1,135 @@
+require "test_helper"
+
+describe HttpMonkey::EntryPoint do
+
+  TEST_URL = "https://www.google.com.br"
+
+  before do
+    @mock_client = stub("client")
+  end
+
+  subject do
+    HttpMonkey::EntryPoint.new(@mock_client, TEST_URL)
+  end
+
+  def expects_request_on(client, method, body, &block)
+    client.expects(:http_request).with do |method, request|
+      if block.respond_to?(:call)
+        block_assertion = block.call(method, request)
+      else
+        block_assertion = true
+      end
+
+      request_url = request.url.select(:scheme, :host).join("://")
+
+      body_assertion = false
+      if body.nil?
+        body_assertion = request.body.must_be_nil
+      elsif body.is_a?(String)
+        body_assertion = request.body.must_equal(body)
+      elsif body.is_a?(Regexp)
+        body_assertion = request.body.must_match(body)
+      end
+
+      block_assertion && \
+        method.must_equal(method) && \
+        request_url.must_equal(TEST_URL) && \
+        request.must_be_instance_of(HTTPI::Request) && \
+        body_assertion
+    end
+  end
+
+  it "#get" do
+    expects_request_on(@mock_client, :get, nil)
+    subject.get
+  end
+
+  it "#get with parameters" do
+    expects_request_on(@mock_client, :get, nil) do |method, request|
+      request.url.query.must_match(/(p1=param1&p2=param2)|(p2=param2&p1=param1)/)
+    end
+
+    subject.get(:p1 => "param1", :p2 => "param2")
+  end
+
+  it "#post with parameters" do
+    expects_request_on(@mock_client, :post, /(b1=param1&b2=param2)|(b2=param2&b1=param1)/)
+    subject.post(:b1 => "param1", :b2 => "param2")
+  end
+
+  it "#put with parameters" do
+    expects_request_on(@mock_client, :put, /(p1=param1&p2=param2)|(p2=param2&p1=param1)/)
+    subject.put(:p1 => "param1", :p2 => "param2")
+  end
+
+  it "#delete" do
+    expects_request_on(@mock_client, :delete, nil)
+    subject.delete
+  end
+
+  it "HTTP requests should accept configuration block" do
+    block = lambda { raise "Not to be raised" }
+    @mock_client.expects(:clone).returns(@mock_client)
+    @mock_client.expects(:configure).returns(@mock_client)
+    expects_request_on(@mock_client, :get, nil)
+
+    subject.get(&block)
+  end
+
+  describe "FluentInterface -_-" do
+
+    it "#with_header" do
+      expects_request_on(@mock_client, :get, nil) do |method, request|
+        request.headers.must_equal({"Content-Type" => "text/html", "X-Custom" => "sample"})
+      end
+      subject.with_header("Content-Type" => "text/html").
+        with_header("X-Custom" => "sample").
+        get
+    end
+
+    it "#with_headers" do
+      expects_request_on(@mock_client, :get, nil) do |method, request|
+        request.headers.must_equal({"Content-Type" => "text/html", "X-Custom" => "sample"})
+      end
+      subject.with_headers("Content-Type" => "text/html",
+                           "X-Custom" => "sample").get
+    end
+
+    it "#set_cookie" do
+      expects_request_on(@mock_client, :get, nil) do |method, request|
+        request.headers["Cookie"].must_equal("name=value;name2=value2")
+      end
+      subject.set_cookie("name=value;name2=value2").get
+    end
+
+    it "#basic_auth" do
+      expects_request_on(@mock_client, :get, nil) do |method, request|
+        request.auth.type.must_equal(:basic) && \
+          request.auth.credentials.must_equal(["mad", "max"])
+      end
+      subject.basic_auth("mad", "max").get
+    end
+
+    it "#digest_auth" do
+      expects_request_on(@mock_client, :get, nil) do |method, request|
+        request.auth.type.must_equal(:digest) && \
+          request.auth.credentials.must_equal(["mad", "max"])
+      end
+      subject.digest_auth("mad", "max").get
+    end
+
+    it "#yield_request" do
+      expects_request_on(@mock_client, :get, nil) do |method, request|
+        request.proxy.to_s.must_equal("http://proxy.com") && \
+          request.open_timeout.must_equal(30) && \
+          request.read_timeout.must_equal(15)
+      end
+      subject.yield_request do |req|
+        req.proxy = "http://proxy.com"
+        req.open_timeout = 30
+        req.read_timeout = 15
+      end.get
+    end
+  end
+
+end

data/test/http_monkey/http_monkey_test.rb

@@ -0,0 +1,26 @@
+require "test_helper"
+
+describe HttpMonkey do
+
+  subject { HttpMonkey }
+
+  it "#at" do
+    subject.at("http://google.com.br").must_be_instance_of(HttpMonkey::EntryPoint)
+  end
+
+  it "#configure" do
+    flag = "out block"
+    subject.configure do
+      self.must_be_instance_of(HttpMonkey::Configuration)
+      flag = "inside block"
+    end
+    flag.must_equal("inside block")
+  end
+
+  describe "#build" do
+    it "wont be same client" do
+      subject.build.wont_be_same_as(HttpMonkey.default_client)
+    end
+  end
+
+end

data/test/http_monkey/middlewares/default_headers_test.rb

@@ -0,0 +1,32 @@
+require "test_helper"
+
+describe HttpMonkey::Middlewares::DefaultHeaders do
+
+  before do
+    @mock_app = stub("app", :call => "stubbed")
+  end
+
+  let(:fake_env) { Hash.new }
+  subject { HttpMonkey::Middlewares::DefaultHeaders }
+
+  it "always call app" do
+    @mock_app.expects(:call).with(fake_env)
+    subject.new(@mock_app).call(fake_env)
+  end
+
+  it "sets header" do
+    middle = subject.new(@mock_app, {"X-Custom" => "value"})
+    middle.call(fake_env)
+
+    fake_env["HTTP_X_CUSTOM"].must_equal("value")
+  end
+
+  it "not overwrite header" do
+    fake_env["HTTP_X_CUSTOM"] = "request"
+    middle = subject.new(@mock_app, {"X-Custom" => "value"})
+    middle.call(fake_env)
+
+    fake_env["HTTP_X_CUSTOM"].must_equal("request")
+  end
+
+end

data/test/integration/server.rb

@@ -0,0 +1,73 @@
+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

data/test/integration/verbs_test.rb

@@ -0,0 +1,58 @@
+require "integration/server"
+
+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)
+      body = YAML.dump(env)
+      [200, {"Content-Type" => "text/plain", "Content-Length" => body.size.to_s}, [body]]
+    }
+  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
+  end
+
+  it "#post" do
+    response = HttpMonkey.at("http://localhost:4000").post(:var => "post_var")
+    server_env = YAML.load(response.body)
+
+    server_env["REQUEST_METHOD"].must_equal("POST")
+    server_env["rack.input"].must_equal("var=post_var")
+  end
+
+  it "#put" do
+    response = HttpMonkey.at("http://localhost:4000").put(:var => "put_var")
+    server_env = YAML.load(response.body)
+
+    server_env["REQUEST_METHOD"].must_equal("PUT")
+    server_env["rack.input"].must_equal("var=put_var")
+  end
+
+  it "#delete" do
+    response = HttpMonkey.at("http://localhost:4000").delete
+    server_env = YAML.load(response.body)
+
+    server_env["REQUEST_METHOD"].must_equal("DELETE")
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require "http_monkey"
+
+require "minitest/autorun"
+require "minitest/reporters"
+
+require "mocha"
+
+MiniTest::Unit.runner = MiniTest::SuiteRunner.new
+MiniTest::Unit.runner.reporters << MiniTest::Reporters::SpecReporter.new