rack-client 0.3.0 → 0.3.1.pre.a

data/spec/cookie_jar_spec.rb

@@ -1,37 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe Rack::Client::CookieJar do
-  let(:client) do
-    Rack::Client.new("http://localhost:#{server.port}") do
-      use Rack::Client::CookieJar
-      run Rack::Client::Handler::NetHTTP
-    end
-  end
-
-  context 'Synchronous API' do
-    it 'serves the cookie in future responses' do
-      response = client.get("http://localhost:#{server.port}/cookied")
-      response['Set-Cookie'].should_not be_nil
-      response['rack-client-cookiejar.cookies'].should_not be_nil
-
-      response = client.get("http://localhost:#{server.port}/cookied")
-      response['Set-Cookie'].should be_nil
-      response['rack-client-cookiejar.cookies'].should_not be_nil
-    end
-  end
-
-  context 'Asynchronous API' do
-    it 'serves the cookie in future responses' do
-      client.get("http://localhost:#{server.port}/cookied") do |response|
-        response['Set-Cookie'].should_not be_nil
-        response['rack-client-cookiejar.cookies'].should_not be_nil
-
-        client.get("http://localhost:#{server.port}/cookied") do |response|
-          response['Set-Cookie'].should be_nil
-          response['rack-client-cookiejar.cookies'].should_not be_nil
-        end
-      end
-    end
-  end
-end
-

data/spec/endpoint_spec.rb

@@ -1,30 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-require 'sinatra/base'
-
-class MyApp < Sinatra::Base
-  get "/awesome" do
-    "test"
-  end
-end
-
-describe Rack::Client, "with an Rack app endpoint" do
-  let(:client) do
-    Rack::Client.new("http://localhost:#{server.port}") do
-      run Rack::URLMap.new("http://example.org/" => MyApp)
-    end
-  end
-
-  describe "with a custom domain" do
-    it "returns the body" do
-      response = client.get("http://example.org/awesome")
-      response.status.should == 200
-      response.body.to_s.should == "test"
-    end
-
-    it "only functions for that domain" do
-      response = client.get("http://example.org/")
-      response.status.should == 404
-    end
-  end
-end

data/spec/follow_redirect_spec.rb

@@ -1,27 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe Rack::Client::FollowRedirects do
-  let(:client) do
-    Rack::Client.new("http://localhost:#{server.port}") do
-      use Rack::Client::FollowRedirects
-      run Rack::Client::Handler::NetHTTP
-    end
-  end
-
-  context 'Synchronous API' do
-    it "follows redirects" do
-      response = client.get("http://localhost:#{server.port}/redirect")
-      response.status.should == 200
-      response.body.to_s.should == "after redirect"
-    end
-  end
-
-  context 'Asynchronous API' do
-    it "follows redirects" do
-      client.get("http://localhost:#{server.port}/redirect") do |response|
-        response.status.should == 200
-        response.body.to_s.should == "after redirect"
-      end
-    end
-  end
-end

data/spec/handler/async_api_spec.rb

@@ -1,69 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-share_examples_for "Asynchronous Request API" do
-  context 'DELETE request' do
-    it 'can handle a No Content response' do
-      client.delete("/shelf/ctm") do |response|
-        response.status.should == 204
-        finish
-      end
-    end
-  end
-
-  context 'GET request' do
-    it 'has the proper response for a basic request' do
-      client.get("/ping") do |response|
-        response.status.should == 200
-        response.body.to_s.should == 'pong'
-        response["Content-Type"].should == 'text/html'
-        response["Content-Length"].to_i.should == 4
-        finish
-      end
-    end
-
-    it 'can handle a temporary redirect response' do
-      client.get("/redirect") do |response|
-        response.status.should == 302
-        response["Location"].should == "/after-redirect"
-        finish
-      end
-    end
-
-    it 'can return an empty body' do
-      client.get("/empty") do |response|
-        response.body.should be_empty
-        finish
-      end
-    end
-  end
-
-  context 'HEAD request' do
-    it 'can handle ETag headers' do
-      client.head("/shelf") do |response|
-        response.status.should == 200
-        response["ETag"].should == "828ef3fdfa96f00ad9f27c383fc9ac7f"
-        finish
-      end
-    end
-  end
-
-  context 'POST request' do
-    it 'can send a request body' do
-      client.post("/posted", {}, "some data") do |response|
-        response.status.should == 201
-        response["Created"].should == "awesome"
-        finish
-      end
-    end
-  end
-
-  context 'PUT request' do
-    it 'can send a request body' do
-      client.put("/shelf/ctm", {}, "some data") do |response|
-        response.status.should == 200
-        response["Location"].should == "/shelf/ctm"
-        finish
-      end
-    end
-  end
-end

data/spec/handler/sync_api_spec.rb

@@ -1,55 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-share_examples_for "Synchronous Request API" do
-  context 'DELETE request' do
-    it 'can handle a No Content response' do
-      response = client.delete("/shelf/ctm")
-      response.status.should == 204
-    end
-  end
-
-  context 'GET request' do
-    it 'has the proper response for a basic request' do
-      response = client.get("/ping")
-      response.status.should == 200
-      response.body.to_s.should == 'pong'
-      response["Content-Type"].should == 'text/html'
-      response["Content-Length"].to_i.should == 4
-    end
-
-    it 'can handle a temporary redirect response' do
-      response = client.get("/redirect")
-      response.status.should == 302
-      response["Location"].should == "/after-redirect"
-    end
-
-    it 'can return an empty body' do
-      response = client.get("/empty")
-      response.body.should be_empty
-    end
-  end
-
-  context 'HEAD request' do
-    it 'can handle ETag headers' do
-      response = client.head("/shelf")
-      response.status.should == 200
-      response["ETag"].should == "828ef3fdfa96f00ad9f27c383fc9ac7f"
-    end
-  end
-
-  context 'POST request' do
-    it 'can send a request body' do
-      response = client.post("/posted", {}, "some data")
-      response.status.should == 201
-      response["Created"].should == "awesome"
-    end
-  end
-
-  context 'PUT request' do
-    it 'can send a request body' do
-      response = client.put("/shelf/ctm", {}, "some data")
-      response.status.should == 200
-      response["Location"].should == "/shelf/ctm"
-    end
-  end
-end

data/spec/middleware_helper.rb

@@ -1,37 +0,0 @@
-class LoggerCheck
-  def initialize(app, &block)
-    @app, @block = app, block
-  end
-
-  def call(env)
-    logger = env['rack.logger']
-
-    @app.call(env)
-  ensure
-    @block.call(logger)
-  end
-end
-
-class ETagFixed < Rack::ETag
-  def call(env)
-    status, headers, body = @app.call(env)
-
-    if !headers.has_key?('ETag')
-      digest, body = digest_body(body)
-      headers['ETag'] = %("#{digest}")
-    end
-
-    [status, headers, body]
-  end
-
-  private
-  def digest_body(body)
-    digest = Digest::MD5.new
-    parts = []
-    body.each do |part|
-      digest << part
-      parts << part
-    end
-    [digest.hexdigest, parts]
-  end
-end

data/spec/middleware_spec.rb

@@ -1,53 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe Rack::Client, "with a standard piece of Rack middleware" do
-  context "Rack::ETag" do
-    let(:client) do
-      Rack::Client.new("http://localhost:#{server.port}") do
-        use Rack::ETag
-        run Rack::Client::Handler::NetHTTP
-      end
-    end
-
-    it "successfully uses that middleware" do
-      pending "Rack::ETag fixes streaming bodies (http://github.com/rack/rack/commit/f10713cce876d370ee5f1018928521d4b43e0dce)"
-
-      response = client.get("http://localhost:#{server.port}/no-etag")
-      response.status.should == 200
-      response.headers["ETag"].should_not be_empty
-    end
-  end
-
-  context "Rack::ETag (fixed for streaming)" do
-    let(:client) do
-      Rack::Client.new("http://localhost:#{server.port}") do
-        use ETagFixed
-        run Rack::Client::Handler::NetHTTP
-      end
-    end
-
-    it "successfully uses that middleware" do
-      response = client.get("http://localhost:#{server.port}/no-etag")
-      response.status.should == 200
-      response.headers["ETag"].should_not be_empty
-    end
-  end
-
-  context "Rack::Logger" do
-    let(:client) do
-      Rack::Client.new("http://localhost:#{server.port}") do
-        use Rack::Logger
-        use LoggerCheck do |logger|
-          logger.class.should == Logger
-        end
-        run Rack::Client::Handler::NetHTTP
-      end
-    end
-
-    it "successfully uses that middleware" do
-      response = client.get("http://localhost:#{server.port}/no-etag")
-      response.status.should == 200
-    end
-  end
-end
-

data/spec/parser/json_spec.rb

@@ -1,22 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Rack::Client::Parser::JSON do
-  let(:client) do
-    Rack::Client.new("http://localhost:#{server.port}") do
-      use Rack::Client::Parser
-      run Rack::Client::Handler::NetHTTP
-    end
-  end
-
-  context 'Synchronous API' do
-    it "injects the parsed body into the response" do
-      response = client.get("http://localhost:#{server.port}/hash.json")
-      response.headers['rack-client.body_collection'].should == [{'foo' => 'bar'}]
-    end
-
-    it "injects the dumped body into the request" do
-      response = client.post("http://localhost:#{server.port}/echo", {'rack-client.body_collection' => [{'foo' => 'bar'}], 'Content-Type' => 'application/json'}, {})
-      response.headers['rack-client.body_collection'].should == [{'foo' => 'bar'}]
-    end
-  end
-end

data/spec/parser/yaml_spec.rb

@@ -1,22 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Rack::Client::Parser::YAML do
-  let(:client) do
-    Rack::Client.new("http://localhost:#{server.port}") do
-      use Rack::Client::Parser
-      run Rack::Client::Handler::NetHTTP
-    end
-  end
-
-  context 'Synchronous API' do
-    it "injects the parsed body into the response" do
-      response = client.get("http://localhost:#{server.port}/hash.yml")
-      response.headers['rack-client.body_collection'].should == [{:foo => :bar}]
-    end
-
-    it "injects the dumped body into the request" do
-      response = client.post("http://localhost:#{server.port}/echo", {'rack-client.body_collection' => [{:foo => :bar}], 'Content-Type' => 'application/x-yaml'}, {})
-      response.headers['rack-client.body_collection'].should == [{:foo => :bar}]
-    end
-  end
-end

data/spec/server_helper.rb

@@ -1,72 +0,0 @@
-class InThreadServer
-  def self.rackup(*a)
-    server = new(*a)
-    server.start
-    server
-  end
-
-  attr_accessor :port, :port_range, :pre_spawn_callback, :config_ru, :running
-
-  def initialize(config_ru, pre_spawn_callback = nil, port_range = 8000..10000)
-    @config_ru, @pre_spawn_callback, @port_range = config_ru, pre_spawn_callback, port_range
-  end
-
-  def start
-    return if running
-    find_port
-    pre_spawn
-    spawn_server_thread
-    wait_for_server
-    @running = true
-  end
-
-  def stop
-    @thread.kill
-    @running= false
-  end
-
-  def find_port
-    return if @port
-
-    @port = @port_range.min
-
-    while(system("lsof -i tcp:#{self.port} > /dev/null")) do
-      @port += 1
-    end
-  end
-
-  def pre_spawn
-    pre_spawn_callback.call(self) if pre_spawn_callback
-  end
-
-  def spawn_server_thread
-    @thread ||= Thread.new {
-      begin
-        Rack::Server.new(:Port => @port, :config => @config_ru, :server => 'mongrel').start
-      rescue
-        $stderr.puts "Failed to start server"
-        $stderr.puts $!.inspect
-        $stderr.puts $!.backtrace
-        abort
-      end
-    }
-  end
-
-  def wait_for_server
-    loop do
-      begin
-        Rack::Client.get("http://127.0.0.1:#{@port}/")
-        break
-      rescue Errno::ECONNREFUSED
-        sleep 1
-      end
-    end
-  end
-end
-
-class DigestServer < Rack::Auth::Digest::MD5
-  def initialize(*)
-    super
-    self.opaque = '12345'
-  end
-end