rack-client 0.1.0

data/History.txt

@@ -0,0 +1,5 @@
+== 0.1.0 / 2009-06-14
+ 
+* 1 major enhancement
+ 
+  * Birthday!

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Tim Carey-Smith
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.textile

@@ -0,0 +1,63 @@
+h1. What's this?
+
+Rack::Client is an HTTP client that aims to be a good Rack
+citizen.
+
+h2. Rack responses
+
+Rack::Client can be used to make HTTP requests to any type of server, not
+just ones using Rack. However, when a request is made then a proper
+Rack response (specifically a Rack::MockResponse) object is returned. 
+For Rubyists, this means you don't need to learn yet another interface 
+and can just stick with Rack both on the server, test, and client side of
+things.
+
+<pre>
+response = Rack::Client.get("http://some-website.com/blah.txt")
+response.code #=> 200
+response.body #=> "some body"
+</pre>
+
+h2. Middleware
+
+Rack::Client is actually a subclass of Rack::Builder. This means that
+Rack::Client objects yield actual Rack apps. More importantly, this
+means you can reuse existing Rack middleware on the client side too
+(but also feel free to make new middleware that only makes sense on
+the client side under the Rack::Client namespace). Note that by default
+Rack::Client will "run" Rack::Client::HTTP as an endpoint, but this
+will not be performed if you specify your own "run" endpoint.
+
+<pre>
+client = Rack::Client.new { use Rack::ETag }
+response = client.get("http://localhost:9292/no-etag")
+</pre>
+
+h2. Rack::Test compatibility
+
+Rack::Client reuses a lot of Rack::Test to provide users with a
+familiar interface. What's even cooler is that you can use a
+Rack::Client object as your "app" in Rack::Test. This means that you
+can test-drive an application with Rack::Test, then when ready
+actually run your Rack app, switch your Rack::Test "app" to a
+Rack::Client, and get free full-blown integration testing! Note that
+the integration-tested server does not need to be all-Rack, so you can
+develop quickly with middleware like Rack::Cache but then remove it
+and integration test with a dedicated cache server like Varnish.
+
+<pre>
+# NOTE: For a complete example, look in the "demo" directory
+describe Demo, "/store resource" do
+  include Rack::Test::Methods
+  def app
+    # replace this with Rack::Client.new
+    # for integration testing
+    Demo::App.new
+  end
+  # ... etc
+end
+</pre>
+
+h1. Contributors
+
+halorgium, larrytheliquid

data/Rakefile

@@ -0,0 +1,34 @@
+require 'rake'
+require "rake/gempackagetask"
+require "rake/clean"
+require "spec/rake/spectask"
+require File.expand_path("./lib/rack/client")
+
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['spec/*_spec.rb']
+  t.spec_opts = ['-c']
+end
+
+task :default  => :spec
+
+spec = Gem::Specification.new do |s|
+  s.name              = "rack-client"
+  s.version           = Rack::Client::VERSION
+  s.author            = "Tim Carey-Smith"
+  s.email             = "time" + "@" + "spork.in"
+  s.homepage          = "http://github.com/halorgium/rack-client"
+  s.summary           = "A client wrapper around a Rack app or HTTP"
+  s.description       = s.summary
+  s.files             = %w[History.txt LICENSE README.textile Rakefile] + Dir["lib/**/*"] + Dir["demo/**/*"]
+  s.test_files        = Dir["spec/**/*"]
+end
+
+Rake::GemPackageTask.new(spec) do |package|
+  package.gem_spec = spec
+end
+
+desc 'Install the package as a gem.'
+task :install => [:clean, :package] do
+  gem = Dir['pkg/*.gem'].first
+  sh "sudo gem install --no-rdoc --no-ri --local #{gem}"
+end

data/demo/client.rb

@@ -0,0 +1,26 @@
+require "rubygems"
+require "rack/client"
+require "rack/contrib"
+
+puts "PUT'ing /store/fruit (with strawberry)"
+puts
+Rack::Client.put "http://localhost:9292/store/fruit", "strawberry"
+
+puts "GET'ing /store/fruit"
+response = Rack::Client.get "http://localhost:9292/store/fruit"
+puts ">> status: #{response.status}"
+puts ">> body: #{response.body.inspect}"
+puts ">> etag: #{response.headers["ETag"].inspect}"
+puts
+
+puts "GET'ing /store/fruit (with ETag middleware)"
+response = Rack::Client.new do
+  use Rack::ETag
+end.get "http://localhost:9292/store/fruit"
+puts ">> status: #{response.status}"
+puts ">> body: #{response.body.inspect}"
+puts ">> etag: #{response.headers["ETag"].inspect}"
+puts
+
+puts "DELETE'ing /store"
+Rack::Client.delete("http://localhost:9292/store")

data/demo/config.ru

@@ -0,0 +1,3 @@
+require File.expand_path(File.dirname(__FILE__) + "/demo")
+
+run Demo::App

data/demo/demo.rb

@@ -0,0 +1,31 @@
+require "rubygems"
+require "rack"
+require "sinatra/base"
+
+module Demo
+  Store = Hash.new
+
+  class App < Sinatra::Base
+    get "/store/:id" do
+      if item = Store[ params[:id] ]
+        item
+      else
+        status 404
+        ""
+      end
+    end
+
+    put "/store/:id" do
+      Store[ params[:id] ] = request.body.read
+    end
+
+    delete "/store" do
+      Store.clear
+      ""
+    end
+
+    delete "/store/:id" do
+      Store.delete params[:id]
+    end
+  end
+end

data/demo/demo_spec.rb

@@ -0,0 +1,54 @@
+require "demo"
+require "rubygems"
+require "spec"
+require "rack"
+require "rack/test"
+require "rack/client"
+
+describe Demo, "/store resource" do
+  include Rack::Test::Methods
+  def app
+    # Be sure to run "rackup" on the config.ru in this demo directory
+    Rack::Client.new
+    # Demo::App.new
+  end
+  before(:all) { delete "http://localhost:9292/store" }  
+  after { delete "http://localhost:9292/store" }
+
+  it "should return a 404 if a resource does not exist" do
+    get "http://localhost:9292/store/does-not-exist"
+    last_response.status.should == 404
+    last_response.body.should be_empty
+  end
+
+  it "should be able to store and retrieve invididual items" do
+    put "http://localhost:9292/store/fruit", "strawberry"
+    put "http://localhost:9292/store/car", "lotus"
+    get "http://localhost:9292/store/fruit"
+    last_response.status.should == 200
+    last_response.body.should == "strawberry"
+    get "http://localhost:9292/store/car"
+    last_response.status.should == 200    
+    last_response.body.should == "lotus"        
+  end
+
+  it "should be able to clear the store of all items" do
+    put "http://localhost:9292/store/fruit", "strawberry"
+    put "http://localhost:9292/store/car", "lotus"
+    delete "http://localhost:9292/store"
+    get "http://localhost:9292/store/fruit"
+    last_response.status.should == 404
+    last_response.body.should be_empty
+    get "http://localhost:9292/store/car"
+    last_response.status.should == 404
+    last_response.body.should be_empty
+  end
+
+  it "should be able to clear the store of an invididual item" do
+    put "http://localhost:9292/store/fruit", "strawberry"
+    delete "http://localhost:9292/store/fruit"
+    get "http://localhost:9292/store/fruit"
+    last_response.status.should == 404
+    last_response.body.should be_empty
+  end
+end

data/lib/rack/client.rb

@@ -0,0 +1,37 @@
+unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__) + "/.."))
+  $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/.."))
+end
+
+require 'rack'
+require 'rack/test'
+require 'forwardable'
+
+module Rack
+  class Client < Rack::Builder
+    VERSION = "0.1.0"
+    include Rack::Test::Methods
+    HTTP_METHODS = [:head, :get, :put, :post, :delete]
+    
+    class << self
+      extend Forwardable
+      def_delegators :new, *HTTP_METHODS
+    end
+
+    def run(*args, &block)
+      @ran = true
+      super(*args, &block)
+    end
+
+    def to_app(*args, &block)
+      run Rack::Client::HTTP unless @ran
+      super(*args, &block)
+    end
+    alias app to_app
+  end
+end
+
+$:.unshift File.dirname(__FILE__)
+
+require 'client/http'
+require 'client/auth'
+require 'client/follow_redirects'

data/lib/rack/client/auth.rb

@@ -0,0 +1,13 @@
+module Rack::Client::Auth
+  class Basic
+    def initialize(app, username, password)
+      @app, @username, @password = app, username, password
+    end
+
+    def call(env)
+      encoded_login = ["#{@username}:#{@password}"].pack("m*")
+      env['HTTP_AUTHORIZATION'] = "Basic #{encoded_login}"
+      @app.call(env)
+    end
+  end
+end

data/lib/rack/client/follow_redirects.rb

@@ -0,0 +1,27 @@
+class Rack::Client::FollowRedirects
+    include Rack::Test::Methods
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      response = Rack::Response.new(body, status, headers)
+      if response.redirect?
+        uri = URI.parse(response["Location"])
+        new_env = {}
+        env.each do |k,v|
+          if %w| HTTP_HOST SERVER_NAME SERVER_PORT |.include?(k)
+            new_env[k] = v
+          end
+        end
+        new_env["REQUEST_METHOD"] = "GET"
+        session = Rack::Test::Session.new(@app)
+        env = session.send(:env_for, uri.to_s, new_env)
+        call(env)
+      else
+        [status, headers, body]
+      end
+    end
+  end

data/lib/rack/client/http.rb

@@ -0,0 +1,77 @@
+require 'net/http'
+
+class Rack::Client::HTTP
+  def self.call(env)
+    new(env).run
+  end
+
+  def initialize(env)
+    @env = env
+  end
+
+  def run
+    case request.request_method
+    when "HEAD"
+      head = Net::HTTP::Head.new(request.path, request_headers)
+      http.request(head) do |response|
+        return parse(response)
+      end      
+    when "GET"
+      get = Net::HTTP::Get.new(request.path, request_headers)
+      http.request(get) do |response|
+        return parse(response)
+      end
+    when "POST"
+      post = Net::HTTP::Post.new(request.path, request_headers)
+      post.body = @env["rack.input"].read
+      http.request(post) do |response|
+        return parse(response)
+      end
+    when "PUT"
+      put = Net::HTTP::Put.new(request.path, request_headers)
+      put.body = @env["rack.input"].read
+      http.request(put) do |response|
+        return parse(response)
+      end
+    when "DELETE"
+      delete = Net::HTTP::Delete.new(request.path, request_headers)
+      http.request(delete) do |response|
+        return parse(response)
+      end           
+    else
+      raise "Unsupported method: #{request.request_method.inspect}"
+    end
+  end
+
+  def http
+    Net::HTTP.new(request.host, request.port)
+  end
+
+  def parse(response)
+    status = response.code.to_i
+    headers = {}
+    response.each do |key,value|
+      key = key.gsub(/(\w+)/) do |matches|
+        matches.sub(/^./) do |char|
+          char.upcase
+        end
+      end
+      headers[key] = value
+    end
+    [status, headers, response.body.to_s]
+  end
+
+  def request
+    @request ||= Rack::Request.new(@env)
+  end
+
+  def request_headers
+    headers = {}
+    @env.each do |k,v|
+      if k =~ /^HTTP_(.*)$/
+        headers[$1] = v
+      end
+    end
+    headers
+  end
+end

data/spec/apps/example.org.ru

@@ -0,0 +1,84 @@
+require 'sinatra/base'
+
+class ExampleOrg < Sinatra::Base
+  get "/empty" do
+    ""
+  end
+
+  get "/ping" do
+    "pong"
+  end
+
+  get "/redirect" do
+    redirect request.script_name + "/after-redirect"
+  end
+
+  get "/after-redirect" do
+    "after redirect"
+  end
+
+  head "/shelf" do
+    response["ETag"] = "828ef3fdfa96f00ad9f27c383fc9ac7f"
+    ""
+  end
+
+  put "/shelf/:book" do
+    response["Location"] = "/shelf/#{params[:book]}"
+    ""
+  end
+
+  delete "/shelf/:book" do
+    status 204
+    ""
+  end
+
+  post "/posted" do
+    if request.body.read == "some data"
+      status 201
+      response["Created"] = "awesome"
+      ""
+    else
+      raise "Not valid"
+    end
+  end
+
+  get "/no-etag" do
+    ""
+  end
+end
+
+require 'pp'
+class Debug
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    puts "*" * 80
+    puts "env is:"
+    pp env
+    res = @app.call(env)
+    puts "response is:"
+    pp res
+    puts "*" * 80
+    res
+  end
+end
+
+use Rack::CommonLogger
+use Debug if ENV["DEBUG"]
+
+map "http://localhost/" do
+  map "/auth/" do
+    use Rack::Auth::Basic do |username,password|
+      username == "username" && password == "password"
+    end
+    run ExampleOrg
+  end
+
+  map "/" do
+    run ExampleOrg
+  end
+end
+
+# vim:filetype=ruby

data/spec/auth_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Rack::Client, "with an Auth::Basic middleware" do
+  it "succeeds with authorization" do
+    client = Rack::Client.new do
+      use Rack::Client::Auth::Basic, "username", "password"
+    end
+    response = client.get("http://localhost:9292/auth/ping")
+    response.status.should == 200
+    response.headers["Content-Type"].should == "text/html"
+    response.body.should == "pong"
+  end
+
+  it "fails with authorization" do
+    client = Rack::Client.new do
+      use Rack::Client::Auth::Basic, "username", "fail"
+    end
+    response = client.get("http://localhost:9292/auth/ping")
+    response.status.should == 401
+    response.body.should == ""
+  end
+end

data/spec/core_spec.rb

@@ -0,0 +1,123 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Rack::Client, "without middleware" do
+  context "at the instance level" do
+    it "returns an empty body" do
+      response = Rack::Client.new.get("http://localhost:9292/empty")
+      response.status.should == 200
+      response.headers["Content-Type"].should == "text/html"
+      response.headers["Content-Length"].should == "0"
+      response.body.should == ""
+    end
+
+    it "returns a 302" do
+      response = Rack::Client.new.get("http://localhost:9292/redirect")
+      response.status.should == 302
+      response["Location"].should == "/after-redirect"
+    end
+
+    it "heads data" do
+      response = Rack::Client.new.head "http://localhost:9292/shelf"
+      response.status.should == 200
+      response["ETag"].should == "828ef3fdfa96f00ad9f27c383fc9ac7f"
+    end
+
+    it "puts data" do
+      response = Rack::Client.new.put "http://localhost:9292/shelf/ctm", "some data"
+      response.status.should == 200
+      response["Location"].should == "/shelf/ctm"
+    end
+
+    it "deletes data" do
+      response = Rack::Client.new.delete "http://localhost:9292/shelf/ctm"
+      response.status.should == 204
+    end
+
+    it "posts data" do
+      response = Rack::Client.new.post("http://localhost:9292/posted", "some data")
+      response.status.should == 201
+      response["Created"].should == "awesome"
+    end
+  end
+
+  context "at the class level" do
+    it "returns an empty body" do
+      response = Rack::Client.get("http://localhost:9292/empty")
+      response.status.should == 200
+      response.headers["Content-Type"].should == "text/html"
+      response.headers["Content-Length"].should == "0"
+      response.body.should == ""
+    end
+
+    it "returns a 302" do
+      response = Rack::Client.get("http://localhost:9292/redirect")
+      response.status.should == 302
+      response["Location"].should == "/after-redirect"
+    end
+
+    it "heads data" do
+      response = Rack::Client.head "http://localhost:9292/shelf"
+      response.status.should == 200
+      response["ETag"].should == "828ef3fdfa96f00ad9f27c383fc9ac7f"
+    end
+
+    it "puts data" do
+      response = Rack::Client.put "http://localhost:9292/shelf/ctm", "some data"
+      response.status.should == 200
+      response["Location"].should == "/shelf/ctm"      
+    end
+
+    it "deletes data" do
+      response = Rack::Client.delete "http://localhost:9292/shelf/ctm"
+      response.status.should == 204
+    end
+
+    it "posts data" do
+      response = Rack::Client.post("http://localhost:9292/posted", "some data")
+      response.status.should == 201
+      response["Created"].should == "awesome"
+    end
+  end
+
+  context "at the rack-test level" do
+    include Rack::Test::Methods
+    def app() Rack::Client.new end
+    
+    it "returns an empty body" do
+      get "http://localhost:9292/empty"
+      last_response.status.should == 200
+      last_response.headers["Content-Type"].should == "text/html"
+      last_response.headers["Content-Length"].should == "0"
+      last_response.body.should == ""
+    end
+
+    it "returns a 302" do
+      get "http://localhost:9292/redirect"
+      last_response.status.should == 302
+      last_response["Location"].should == "/after-redirect"
+    end
+
+    it "heads data" do
+      head "http://localhost:9292/shelf"
+      last_response.status.should == 200
+      last_response["ETag"].should == "828ef3fdfa96f00ad9f27c383fc9ac7f"
+    end
+
+    it "puts data" do
+      put "http://localhost:9292/shelf/ctm", "some data"
+      last_response.status.should == 200
+      last_response["Location"].should == "/shelf/ctm"      
+    end
+
+    it "deletes data" do
+      delete "http://localhost:9292/shelf/ctm"
+      last_response.status.should == 204
+    end
+
+    it "posts data" do
+      post "http://localhost:9292/posted", "some data"
+      last_response.status.should == 201
+      last_response["Created"].should == "awesome"
+    end
+  end
+end

data/spec/endpoint_spec.rb

@@ -0,0 +1,39 @@
+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
+  it "returns the body" do
+    client = Rack::Client.new 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.status.should == 200
+      response.body.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
+  end
+end

data/spec/middleware_spec.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Rack::Client, "with a standard piece of Rack middleware" do
+  it "successfully uses that middleware" do
+    client = Rack::Client.new { use Rack::ETag }
+    response = client.get("http://localhost:9292/no-etag")
+    response.status.should == 200
+    response.headers["ETag"].should_not be_empty
+  end
+end

data/spec/redirect_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Rack::Client, "with a FollowRedirects middleware" do
+  it "follows redirects" do
+    client = Rack::Client.new do
+      use Rack::Client::FollowRedirects
+    end
+    response = client.get("http://localhost:9292/redirect")
+    response.status.should == 200
+    response.body.should == "after redirect"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'spec'
+require 'rack/contrib'
+gem 'rack-test'
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/rack/client")

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: rack-client
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Tim Carey-Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-14 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A client wrapper around a Rack app or HTTP
+email: time@spork.in
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- History.txt
+- LICENSE
+- README.textile
+- Rakefile
+- lib/rack
+- lib/rack/client
+- lib/rack/client/auth.rb
+- lib/rack/client/http.rb
+- lib/rack/client/follow_redirects.rb
+- lib/rack/client.rb
+- demo/config.ru
+- demo/demo_spec.rb
+- demo/client.rb
+- demo/demo.rb
+has_rdoc: false
+homepage: http://github.com/halorgium/rack-client
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A client wrapper around a Rack app or HTTP
+test_files: 
+- spec/redirect_spec.rb
+- spec/auth_spec.rb
+- spec/spec_helper.rb
+- spec/apps
+- spec/apps/example.org.ru
+- spec/endpoint_spec.rb
+- spec/core_spec.rb
+- spec/middleware_spec.rb