rack-client 0.1.1 → 0.3.0

data/lib/rack/client/response.rb

@@ -0,0 +1,9 @@
+module Rack
+  module Client
+    class Response < Rack::Response
+      def initialize(status, headers, body)
+        super(body, status, headers)
+      end
+    end
+  end
+end

data/lib/rack/client/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  module Client
+    VERSION = "0.3.0"
+  end
+end

data/spec/apps/example.org.ru

@@ -23,8 +23,12 @@ class ExampleOrg < Sinatra::Base
   end
 
   put "/shelf/:book" do
-    response["Location"] = "/shelf/#{params[:book]}"
-    ""
+    if request.body.read == "some data"
+      response["Location"] = "/shelf/#{params[:book]}"
+      ""
+    else
+      raise "Not valid"
+    end
   end
 
   delete "/shelf/:book" do
@@ -45,6 +49,39 @@ class ExampleOrg < Sinatra::Base
   get "/no-etag" do
     ""
   end
+
+  get '/cacheable' do
+    if env['HTTP_IF_NONE_MATCH'] == '123456789abcde'
+      status 304
+    else
+      response['ETag'] = '123456789abcde'
+      Time.now.to_f.to_s
+    end
+  end
+
+  get '/cookied' do
+    if request.cookies.empty?
+      response.set_cookie('time', :domain => 'localhost', :path => '/', :value => Time.now.to_f)
+      response.set_cookie('time2', :domain => 'localhost', :path => '/cookied', :value => Time.now.to_f)
+    end
+    ''
+  end
+
+  get '/hash.:content_type' do |type|
+    case type
+    when 'json' then
+      content_type 'application/json'
+      {:foo => :bar}.to_json
+    when 'yaml', 'yml' then
+      content_type 'application/x-yaml'
+      {:foo => :bar}.to_yaml
+    end
+  end
+
+  post '/echo' do
+    content_type request.content_type
+    request.body.read
+  end
 end
 
 require 'pp'
@@ -69,13 +106,20 @@ use Rack::CommonLogger
 use Debug if ENV["DEBUG"]
 
 map "http://localhost/" do
-  map "/auth/" do
+  map "/auth/basic/" do
     use Rack::Auth::Basic do |username,password|
       username == "username" && password == "password"
     end
     run ExampleOrg
   end
 
+  map "/auth/digest/" do
+    use DigestServer, 'My Realm' do |username|
+      {"username" => "password"}[username]
+    end
+    run ExampleOrg
+  end
+
   map "/" do
     run ExampleOrg
   end

data/spec/auth/basic_spec.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Rack::Client::Auth::Basic do
+  context 'Synchronous API' do
+    context 'with basic auth middleware' do
+      let(:client) do
+        Rack::Client.new("http://localhost:#{server.port}") do
+          use Rack::Client::Auth::Basic, "username", "password"
+          run Rack::Client::Handler::NetHTTP
+        end
+      end
+
+      it "succeeds with authorization" do
+        response = client.get("http://localhost:#{server.port}/auth/basic/ping")
+        response.status.should == 200
+        response.headers["Content-Type"].should == "text/html"
+        response.body.to_s.should == "pong"
+      end
+    end
+
+    context 'without basic auth middleware' do
+      let(:client) do
+        Rack::Client.new("http://localhost:#{server.port}") do
+          run Rack::Client::Handler::NetHTTP
+        end
+      end
+
+      it "fails with authorization" do
+        response = client.get("http://localhost:#{server.port}/auth/basic/ping")
+        response.status.should == 401
+        response.body.to_s.should == ""
+      end
+    end
+  end
+
+  context 'Asynchronous API' do
+    context 'with basic auth middleware' do
+      let(:client) do
+        Rack::Client.new("http://localhost:#{server.port}") do
+          use Rack::Client::Auth::Basic, "username", "password"
+          run Rack::Client::Handler::NetHTTP
+        end
+      end
+
+      it "succeeds with authorization" do
+        client.get("http://localhost:#{server.port}/auth/basic/ping") do |response|
+          response.status.should == 200
+          response.headers["Content-Type"].should == "text/html"
+          response.body.to_s.should == "pong"
+        end
+      end
+    end
+
+    context 'without basic auth middleware' do
+      let(:client) do
+        Rack::Client.new("http://localhost:#{server.port}") do
+          run Rack::Client::Handler::NetHTTP
+        end
+      end
+
+      it "fails with authorization" do
+        client.get("http://localhost:#{server.port}/auth/basic/ping") do |response|
+          response.status.should == 401
+          response.body.to_s.should == ""
+        end
+      end
+    end
+  end
+end

data/spec/auth/digest/md5_spec.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Rack::Client::Auth::Basic do
+  context 'Synchronous API' do
+    context 'with digest auth middleware' do
+      let(:client) do
+        Rack::Client.new("http://localhost:#{server.port}") do
+          use Rack::Client::Auth::Digest::MD5, "My Realm", "username", "password"
+          run Rack::Client::Handler::NetHTTP
+        end
+      end
+
+      it "succeeds with authorization" do
+        response = client.get("http://localhost:#{server.port}/auth/digest/ping")
+        response.status.should == 200
+        response.headers["Content-Type"].should == "text/html"
+        response.body.to_s.should == "pong"
+      end
+    end
+
+    context 'without digest auth middleware' do
+      let(:client) do
+        Rack::Client.new("http://localhost:#{server.port}") do
+          run Rack::Client::Handler::NetHTTP
+        end
+      end
+
+      it "fails with authorization" do
+        response = client.get("http://localhost:#{server.port}/auth/digest/ping")
+        response.status.should == 401
+        response.body.to_s.should == ""
+      end
+    end
+  end
+
+  context 'Asynchronous API' do
+    context 'with digest auth middleware' do
+      let(:client) do
+        Rack::Client.new("http://localhost:#{server.port}") do
+          use Rack::Client::Auth::Digest::MD5, "My Realm", "username", "password"
+          run Rack::Client::Handler::NetHTTP
+        end
+      end
+
+      it "succeeds with authorization" do
+        response = client.get("http://localhost:#{server.port}/auth/digest/ping") do |response|
+          response.status.should == 200
+          response.headers["Content-Type"].should == "text/html"
+          response.body.to_s.should == "pong"
+        end
+      end
+    end
+
+    context 'without digest auth middleware' do
+      let(:client) do
+        Rack::Client.new("http://localhost:#{server.port}") do
+          run Rack::Client::Handler::NetHTTP
+        end
+      end
+
+      it "fails with authorization" do
+        response = client.get("http://localhost:#{server.port}/auth/digest/ping") do |response|
+          response.status.should == 401
+          response.body.to_s.should == ""
+        end
+      end
+    end
+  end
+end

data/spec/cache_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Rack::Client::Cache do
+  let(:client) do
+    Rack::Client.new("http://localhost:#{server.port}") do
+      use Rack::Client::Cache
+      run Rack::Client::Handler::NetHTTP
+    end
+  end
+
+  after(:each) do
+    Rack::Client::Cache::Storage.instance.clear
+  end
+
+  context 'Synchronous API' do
+    it "successfully retrieves cache hits" do
+      response = client.get("http://localhost:#{server.port}/cacheable")
+      response.headers['X-Rack-Client-Cache'].should include('store')
+      original_body = response.body
+
+      response = client.get("http://localhost:#{server.port}/cacheable")
+      response.headers['X-Rack-Client-Cache'].should include('fresh')
+      response.body.should == original_body
+    end
+  end
+
+  context 'Asynchronous API' do
+    it "successfully retrieves cache hits" do
+      client.get("http://localhost:#{server.port}/cacheable") do |response|
+        response.headers['X-Rack-Client-Cache'].should include('store')
+        original_body = response.body
+
+        client.get("http://localhost:#{server.port}/cacheable") do |response|
+          response.headers['X-Rack-Client-Cache'].should include('fresh')
+          response.body.should == original_body
+        end
+      end
+    end
+  end
+end

data/spec/cookie_jar_spec.rb

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

@@ -9,29 +9,20 @@ class MyApp < Sinatra::Base
 end
 
 describe Rack::Client, "with an Rack app endpoint" do
-  it "returns the body" do
-    client = Rack::Client.new do
+  let(:client) do
+    Rack::Client.new("http://localhost:#{server.port}") do
       run Rack::URLMap.new("http://example.org/" => MyApp)
     end
-    response = client.get("http://example.org/awesome")
-    response.status.should == 200
-    response.body.should == "test"
   end
 
   describe "with a custom domain" do
     it "returns the body" do
-      client = Rack::Client.new do
-        run Rack::URLMap.new("http://google.com/" => MyApp)
-      end
-      response = client.get("http://google.com/awesome")
+      response = client.get("http://example.org/awesome")
       response.status.should == 200
-      response.body.should == "test"
+      response.body.to_s.should == "test"
     end
 
     it "only functions for that domain" do
-      client = Rack::Client.new do
-        run Rack::URLMap.new("http://google.com/" => MyApp)        
-      end
       response = client.get("http://example.org/")
       response.status.should == 404
     end

data/spec/follow_redirect_spec.rb

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

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