httpi 2.0.0.rc1 → 2.0.0

data/spec/integration/em_http_spec.rb

@@ -0,0 +1,81 @@
+require "spec_helper"
+require "integration/support/server"
+
+describe HTTPI::Adapter::EmHttpRequest do
+
+  # em_http is not supported on ruby 1.8
+  unless RUBY_VERSION =~ /1\.8/
+    require "em-synchrony"
+
+    subject(:adapter) { :em_http }
+
+    around :each do |example|
+      EM.synchrony do
+        example.run
+        EM.stop
+      end
+    end
+
+    context "http requests" do
+      before :all do
+        # for some reason, these specs don't work with "localhost". [dh, 2012-12-15]
+        @server = IntegrationServer.run(:host => "127.0.0.1")
+      end
+
+      after :all do
+        @server.stop
+      end
+
+      it "sends and receives HTTP headers" do
+        request = HTTPI::Request.new(@server.url + "x-header")
+        request.headers["X-Header"] = "HTTPI"
+
+        response = HTTPI.get(request, adapter)
+        response.body.should include("HTTPI")
+      end
+
+      it "executes GET requests" do
+        response = HTTPI.get(@server.url, adapter)
+        response.body.should eq("get")
+        response.headers["Content-Type"].should eq("text/plain")
+      end
+
+      it "executes POST requests" do
+        response = HTTPI.post(@server.url, "<some>xml</some>", adapter)
+        response.body.should eq("post")
+        response.headers["Content-Type"].should eq("text/plain")
+      end
+
+      it "executes HEAD requests" do
+        response = HTTPI.head(@server.url, adapter)
+        response.code.should == 200
+        response.headers["Content-Type"].should eq("text/plain")
+      end
+
+      it "executes PUT requests" do
+        response = HTTPI.put(@server.url, "<some>xml</some>", adapter)
+        response.body.should eq("put")
+        response.headers["Content-Type"].should eq("text/plain")
+      end
+
+      it "executes DELETE requests" do
+        response = HTTPI.delete(@server.url, adapter)
+        response.body.should eq("delete")
+        response.headers["Content-Type"].should eq("text/plain")
+      end
+
+      it "supports basic authentication" do
+        request = HTTPI::Request.new(@server.url + "basic-auth")
+        request.auth.basic("admin", "secret")
+
+        response = HTTPI.get(request, adapter)
+        response.body.should eq("basic-auth")
+      end
+
+      # it does not support digest authentication
+    end
+
+    # it does not support ssl authentication
+
+  end
+end

data/spec/integration/httpclient_spec.rb

@@ -0,0 +1,94 @@
+require "spec_helper"
+require "integration/support/server"
+
+describe HTTPI::Adapter::HTTPClient do
+
+  subject(:adapter) { :httpclient }
+
+  context "http requests" do
+    before :all do
+      @server = IntegrationServer.run
+    end
+
+    after :all do
+      @server.stop
+    end
+
+    it "sends and receives HTTP headers" do
+      request = HTTPI::Request.new(@server.url + "x-header")
+      request.headers["X-Header"] = "HTTPI"
+
+      response = HTTPI.get(request, adapter)
+      response.body.should include("HTTPI")
+    end
+
+    it "executes GET requests" do
+      response = HTTPI.get(@server.url, adapter)
+      response.body.should eq("get")
+      response.headers["Content-Type"].should eq("text/plain")
+    end
+
+    it "executes POST requests" do
+      response = HTTPI.post(@server.url, "<some>xml</some>", adapter)
+      response.body.should eq("post")
+      response.headers["Content-Type"].should eq("text/plain")
+    end
+
+    it "executes HEAD requests" do
+      response = HTTPI.head(@server.url, adapter)
+      response.code.should == 200
+      response.headers["Content-Type"].should eq("text/plain")
+    end
+
+    it "executes PUT requests" do
+      response = HTTPI.put(@server.url, "<some>xml</some>", adapter)
+      response.body.should eq("put")
+      response.headers["Content-Type"].should eq("text/plain")
+    end
+
+    it "executes DELETE requests" do
+      response = HTTPI.delete(@server.url, adapter)
+      response.body.should eq("delete")
+      response.headers["Content-Type"].should eq("text/plain")
+    end
+
+    it "supports basic authentication" do
+      request = HTTPI::Request.new(@server.url + "basic-auth")
+      request.auth.basic("admin", "secret")
+
+      response = HTTPI.get(request, adapter)
+      response.body.should eq("basic-auth")
+    end
+
+    it "supports digest authentication" do
+      request = HTTPI::Request.new(@server.url + "digest-auth")
+      request.auth.digest("admin", "secret")
+
+      response = HTTPI.get(request, adapter)
+      response.body.should eq("digest-auth")
+    end
+  end
+
+  context "https requests" do
+    before :all do
+      @server = IntegrationServer.run(:ssl => true)
+    end
+
+    after :all do
+      @server.stop
+    end
+
+    it "raises when no certificate was set up" do
+      expect { HTTPI.post(@server.url, "", adapter) }.to raise_error(HTTPI::SSLError)
+    end
+
+    it "works when set up properly" do
+      request = HTTPI::Request.new(@server.url)
+      request.auth.ssl.ca_cert_file = IntegrationServer.ssl_ca_file
+
+      response = HTTPI.get(request, adapter)
+      expect(response.body).to eq("get")
+    end
+  end
+
+end

data/spec/integration/net_http_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+require "integration/support/server"
+
+describe HTTPI::Adapter::NetHTTP do
+
+  subject(:adapter) { :net_http }
+
+  context "http requests" do
+    before :all do
+      @server = IntegrationServer.run
+    end
+
+    after :all do
+      @server.stop
+    end
+
+    it "sends and receives HTTP headers" do
+      request = HTTPI::Request.new(@server.url + "x-header")
+      request.headers["X-Header"] = "HTTPI"
+
+      response = HTTPI.get(request, adapter)
+      response.body.should include("HTTPI")
+    end
+
+    it "executes GET requests" do
+      response = HTTPI.get(@server.url, adapter)
+      response.body.should eq("get")
+      response.headers["Content-Type"].should eq("text/plain")
+    end
+
+    it "executes POST requests" do
+      response = HTTPI.post(@server.url, "<some>xml</some>", adapter)
+      response.body.should eq("post")
+      response.headers["Content-Type"].should eq("text/plain")
+    end
+
+    it "executes HEAD requests" do
+      response = HTTPI.head(@server.url, adapter)
+      response.code.should == 200
+      response.headers["Content-Type"].should eq("text/plain")
+    end
+
+    it "executes PUT requests" do
+      response = HTTPI.put(@server.url, "<some>xml</some>", adapter)
+      response.body.should eq("put")
+      response.headers["Content-Type"].should eq("text/plain")
+    end
+
+    it "executes DELETE requests" do
+      response = HTTPI.delete(@server.url, adapter)
+      response.body.should eq("delete")
+      response.headers["Content-Type"].should eq("text/plain")
+    end
+
+    it "supports basic authentication" do
+      request = HTTPI::Request.new(@server.url + "basic-auth")
+      request.auth.basic("admin", "secret")
+
+      response = HTTPI.get(request, adapter)
+      response.body.should eq("basic-auth")
+    end
+
+    # it does not support digest authentication
+  end
+
+  context "https requests" do
+    before :all do
+      @server = IntegrationServer.run(:ssl => true)
+    end
+
+    after :all do
+      @server.stop
+    end
+
+    # does not raise when no certificate was set up
+
+    it "works when set up properly" do
+      request = HTTPI::Request.new(@server.url)
+      request.auth.ssl.ca_cert_file = IntegrationServer.ssl_ca_file
+
+      response = HTTPI.get(request, adapter)
+      expect(response.body).to eq("get")
+    end
+  end
+
+end

data/spec/integration/support/application.rb

@@ -0,0 +1,56 @@
+require "rack/builder"
+
+class IntegrationServer
+
+  def self.respond_with(body)
+    [200, { "Content-Type" => "text/plain", "Content-Length" => body.size.to_s }, [body]]
+  end
+
+  Application = Rack::Builder.new do
+
+    map "/" do
+      run lambda { |env|
+        IntegrationServer.respond_with env["REQUEST_METHOD"].downcase
+      }
+    end
+
+    map "/repeat" do
+      run lambda { |env|
+        IntegrationServer.respond_with :body => env["rack.input"].read
+      }
+    end
+
+    map "/x-header" do
+      run lambda { |env|
+        IntegrationServer.respond_with env["HTTP_X_HEADER"]
+      }
+    end
+
+    map "/basic-auth" do
+      use Rack::Auth::Basic, "basic-realm" do |username, password|
+        username == "admin" && password == "secret"
+      end
+
+      run lambda { |env|
+        IntegrationServer.respond_with "basic-auth"
+      }
+    end
+
+    map "/digest-auth" do
+      unprotected_app = lambda { |env|
+        IntegrationServer.respond_with "digest-auth"
+      }
+
+      realm = 'digest-realm'
+      app = Rack::Auth::Digest::MD5.new(unprotected_app) do |username|
+        username == 'admin' ? Digest::MD5.hexdigest("admin:#{realm}:secret") : nil
+      end
+      app.realm = realm
+      app.opaque = 'this-should-be-secret'
+      app.passwords_hashed = true
+
+      run app
+    end
+
+  end
+end

data/spec/integration/support/server.rb

@@ -0,0 +1,84 @@
+require "puma"
+require "puma/minissl"
+
+require "integration/support/application"
+
+class IntegrationServer
+
+  def self.run(options = {})
+    server = new(options)
+    server.run
+    server
+  end
+
+  def self.ssl_ca_file;   integration_fixture("ca_all.pem")  end
+  def self.ssl_key_file;  integration_fixture("server.key")  end
+  def self.ssl_cert_file; integration_fixture("server.cert") end
+
+  def self.integration_fixture(file)
+    file = File.expand_path("../../fixtures/#{file}", __FILE__)
+    raise "No such file '#{file}'" unless File.exist? file
+    file
+  end
+
+  def initialize(options = {})
+    @app  = Application
+    @host = options.fetch(:host, "localhost")
+    @port = options.fetch(:port, 17172)
+    @ssl  = options.fetch(:ssl, false)
+
+    @server = Puma::Server.new(app, events)
+
+    if ssl?
+      add_ssl_listener
+    else
+      add_tcp_listener
+    end
+  end
+
+  attr_reader :app, :host, :port, :server
+
+  def url(path = nil)
+    protocol = ssl? ? "https" : "http"
+    File.join "#{protocol}://#{host}:#{port}/", path.to_s
+  end
+
+  def ssl?
+    @ssl
+  end
+
+  def run
+    server.run
+  end
+
+  def stop
+    server.stop(true)
+  end
+
+  private
+
+  def events
+    Puma::Events.new($stdout, $stderr)
+  end
+
+  def add_tcp_listener
+    server.add_tcp_listener(host, port)
+  rescue Errno::EADDRINUSE
+    raise "Panther is already running at #{url}"
+  end
+
+  def add_ssl_listener
+    server.add_ssl_listener(host, port, ssl_context)
+  end
+
+  def ssl_context
+    context = Puma::MiniSSL::Context.new
+
+    context.key         = IntegrationServer.ssl_key_file
+    context.cert        = IntegrationServer.ssl_cert_file
+    context.verify_mode = Puma::MiniSSL::VERIFY_PEER
+
+    context
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,12 +1,16 @@
 require "bundler"
-Bundler.require :default, :development
+Bundler.setup(:default, :development)
+
+require "httpi"
+
+require "rspec"
+require "mocha/api"
 
 RSpec.configure do |config|
-  config.include WebMock::API
   config.mock_with :mocha
 end
 
-HTTPI.log = false  # disable for specs
+HTTPI.log = false
 
 require "support/fixture"
 require "support/matchers"

data/spec/support/error_helper.rb

@@ -0,0 +1,26 @@
+module ErrorHelper
+
+  class Expectation
+
+    def initialize(error, spec)
+      @error = error
+      @spec = spec
+    end
+
+    def to(tag_error)
+      @spec.expect(@error).to @spec.be_a(tag_error)
+    end
+
+  end
+
+  def expect_error(error_to_raise, message)
+    fake_error(error_to_raise, message)
+  rescue => error
+    Expectation.new(error, self)
+  end
+
+  def be_tagged_with(tag_error)
+    tag_error
+  end
+
+end