mdub-sham_rack 1.0.0

data/README.markdown

@@ -0,0 +1,69 @@
+ShamRack
+========
+
+ShamRack plumbs Net:HTTP into [Rack][rack], providing infrastructure for testing arbitrary Rack-based apps using arbitrary HTTP clients, all from the comfort of your own Ruby VM.
+
+What's it for, again?
+---------------------
+
+Well, you can _test your HTTP client code_, using ShamRack to fake out an external web-service ([Sinatra][sinatra] helps, here).
+
+Or, you can `ShamRack.mount` your actual Sinatra/Rails/Merb/Rack app, which is handy if you want to _test access using an HTTP client library_ such as:
+
+* [`rest-client`][rest-client]
+* [`httparty`][httparty]
+* [`oauth`][oauth]
+
+Installing it
+-------------
+
+    gem sources -a http://gems.github.com
+    sudo gem install mdub-sham_rack
+
+Using it
+--------
+
+    require 'sham_rack'
+    
+    rack_app = lambda { |env| ["200 OK", { "Content-type" => "text/plain" }, "Hello, world!"] }
+    ShamRack.mount(rack_app, "www.example.com")
+      
+    require 'open-uri'
+    open("http://www.example.com/").read            #=> "Hello, world!"
+
+### Sinatra integration
+
+    ShamRack.sinatra("sinatra.xyz") do
+      get "/hello/:subject" do
+        "Hello, #{params[:subject]}"
+      end
+    end
+
+    open("http://sinatra.xyz/hello/stranger").read  #=> "Hello, stranger"
+
+### Rackup support
+
+    ShamRack.rackup("rackup.xyz") do
+      use Some::Middleware
+      use Some::Other::Middleware
+      run MyApp.new
+    end
+
+What's the catch?
+-----------------
+
+* It's brand new! (there will be dragons)
+* Your Rack request-handling code runs in the same Ruby VM, in fact the same Thread, as your request.
+
+Thanks to
+---------
+
+* Blaine Cook for [FakeWeb][fakeweb], which was an inspiration for ShamRack.
+* Christian Neukirchen et al for the chewy goodness that is [Rack][rack].
+
+[rack]: http://rack.rubyforge.org/
+[sinatra]: http://www.sinatrarb.com/
+[rest-client]: http://github.com/adamwiggins/rest-client
+[httparty]: http://github.com/jnunemaker/httparty
+[oauth]: http://oauth.rubyforge.org/
+[fakeweb]: http://fakeweb.rubyforge.org/

data/Rakefile

@@ -0,0 +1,22 @@
+require "spec/rake/spectask"
+
+task "default" => "spec"
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ["--colour", "--format", "progress"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "sham_rack"
+    gemspec.summary = "Net::HTTP-to-Rack plumbing"
+    gemspec.email = "mdub@dogbiscuit.org"
+    gemspec.homepage = "http://github.com/mdub/sham_rack"
+    gemspec.description = "ShamRack plumbs Net::HTTP directly into Rack, for quick and easy HTTP testing."
+    gemspec.authors = ["Mike Williams"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 0
+:major: 1
+:minor: 0

data/lib/sham_rack/core_ext/net/http.rb

@@ -0,0 +1,17 @@
+require "net/http"
+require "sham_rack/registry"
+require "sham_rack/http"
+
+module Net
+
+  def HTTP.new(address, port = nil, *proxy_args)
+    port ||= HTTP.default_port
+    rack_app = ShamRack.application_for(address, port)
+    if rack_app
+      ShamRack::HTTP.new(address, port, rack_app)
+    else
+      super(address, port, *proxy_args)
+    end
+  end
+
+end

data/lib/sham_rack/http.rb

@@ -0,0 +1,106 @@
+module ShamRack
+  
+  # a sham version of Net::HTTP
+  class HTTP
+
+    def initialize(address, port, rack_app)
+      @address = address
+      @port = port
+      @rack_app = rack_app
+    end
+    
+    def start
+      yield self
+    end
+    
+    attr_accessor :use_ssl, :verify_mode, :read_timeout, :open_timeout
+    
+    def request(req, body = nil)
+      env = default_env
+      env.merge!(path_env(req.path))
+      env.merge!(method_env(req))
+      env.merge!(header_env(req))
+      env.merge!(io_env(req, body))
+      response = build_response(@rack_app.call(env))
+      yield response if block_given?
+      return response
+    end
+    
+    private
+
+    def default_env
+      {
+        "SCRIPT_NAME" => "",
+        "SERVER_NAME" => @address,
+        "SERVER_PORT" => @port.to_s,   
+        "rack.version" => [0,1],
+        "rack.url_scheme" => "http",
+        "rack.multithread" => true,
+        "rack.multiprocess" => true,
+        "rack.run_once" => false
+      }
+    end
+    
+    def method_env(request)
+      {
+        "REQUEST_METHOD" => request.method
+      }
+    end
+    
+    def io_env(request, body)
+      raise(ArgumentError, "both request.body and body argument were provided") if (request.body && body)
+      body ||= request.body || ""
+      { 
+        "rack.input" => StringIO.new(body),
+        "rack.errors" => $stderr
+      }
+    end
+    
+    def path_env(path)
+      uri = URI.parse(path)
+      {
+        "PATH_INFO" => uri.path,
+        "QUERY_STRING" => (uri.query || ""),
+      }
+    end
+    
+    def header_env(request)
+      result = {}
+      request.each do |header, content|
+        result["HTTP_" + header.upcase.gsub('-', '_')] = content
+      end
+      %w(TYPE LENGTH).each do |x|
+        result["CONTENT_#{x}"] = result.delete("HTTP_CONTENT_#{x}") if result.has_key?("HTTP_CONTENT_#{x}")
+      end
+      return result
+    end
+    
+    def build_response(rack_response)
+      status, headers, body = rack_response
+      code, message = status.to_s.split(" ", 2)
+      response = Net::HTTPResponse.send(:response_class, code).new("Sham", code, message)
+      response.instance_variable_set(:@body, assemble_body(body))
+      response.instance_variable_set(:@read, true)
+      response.extend ShamRack::ResponseExtensions
+      return response
+    end
+
+    def assemble_body(body)
+      content = ""
+      body.each { |fragment| content << fragment }
+      return content
+    end
+    
+  end
+  
+  module ResponseExtensions
+
+    def read_body(dest = nil)
+      yield @body if block_given?
+      dest << @body if dest
+      return @body
+    end
+    
+  end
+
+end

data/lib/sham_rack/registry.rb

@@ -0,0 +1,45 @@
+module ShamRack
+
+  module Registry
+  
+    def mount(rack_app, address, port = nil)
+      port ||= Net::HTTP.default_port
+      registry[[address, port]] = rack_app
+    end
+    
+    def rackup(address, port = nil, &block)
+      app = Rack::Builder.new(&block).to_app
+      mount(app, address, port)
+    end
+    
+    def lambda(address, port = nil, &block)
+      mount(block, address, port)
+    end
+    
+    def sinatra(address, port = nil, &block)
+      require "sinatra/base"
+      sinatra_app = Class.new(Sinatra::Base)
+      sinatra_app.class_eval(&block)
+      mount(sinatra_app.new, address, port)
+    end
+
+    def unmount_all
+      registry.clear
+    end
+    
+    def application_for(address, port = nil)
+      port ||= Net::HTTP.default_port
+      registry[[address, port]]
+    end
+
+    private
+    
+    def registry
+      @registry ||= {}
+    end
+    
+  end
+    
+  extend Registry
+
+end

data/lib/sham_rack.rb

@@ -0,0 +1 @@
+require "sham_rack/core_ext/net/http"

data/spec/sham_rack_spec.rb

@@ -0,0 +1,214 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require "sham_rack"
+require "open-uri"
+require "restclient"
+require "rack"
+
+class PlainTextApp
+
+  def call(env)
+    [
+      "200 OK", 
+      { "Content-Type" => "text/plain", "Content-Length" => message.length.to_s },
+      [message]
+    ]
+  end
+
+end
+
+class SimpleMessageApp < PlainTextApp
+
+  def initialize(message)
+    @message = message
+  end
+
+  attr_reader :message
+
+end
+
+class EnvRecordingApp < PlainTextApp
+
+  def call(env)
+    @last_env = env
+    super
+  end
+
+  attr_reader :last_env
+
+  def message
+    "env stored for later perusal"
+  end
+
+end
+
+class UpcaseBody
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    status, headers, body = @app.call(env)
+    upcased_body = Array(body).map { |x| x.upcase }
+    [status, headers, upcased_body]
+  end
+
+end
+
+describe ShamRack do
+
+  after(:each) do
+    ShamRack.unmount_all
+  end
+
+  describe "mounted Rack application" do
+
+    before(:each) do
+      ShamRack.mount(SimpleMessageApp.new("Hello, world"), "www.test.xyz")
+    end
+
+    it "can be accessed using Net::HTTP" do
+      response = Net::HTTP.start("www.test.xyz") do |http|
+        http.request(Net::HTTP::Get.new("/"))
+      end
+      response.body.should == "Hello, world"
+    end
+
+    it "can be accessed using open-uri" do
+      response = open("http://www.test.xyz")
+      response.status.should == ["200", "OK"]
+      response.read.should == "Hello, world"
+    end
+
+    it "can be accessed using RestClient" do
+      response = RestClient.get("http://www.test.xyz")
+      response.code.should == 200
+      response.to_s.should == "Hello, world"
+    end
+
+  end
+
+  describe "#rackup" do
+
+    it "mounts an app created using Rack::Builder" do
+
+      ShamRack.rackup("rackup.xyz") do
+        use UpcaseBody
+        run SimpleMessageApp.new("Racked!")
+      end
+
+      open("http://rackup.xyz").read.should == "RACKED!"
+
+    end
+
+  end
+
+  describe "#lambda" do
+
+    it "mounts associated block as an app" do
+
+      ShamRack.lambda("simple.xyz") do |env|
+        ["200 OK", { "Content-type" => "text/plain" }, "Easy, huh?"]
+      end
+
+      open("http://simple.xyz").read.should == "Easy, huh?"
+
+    end
+
+  end
+
+  describe "#sinatra" do
+
+    it "mounts associated block as a Sinatra app" do
+
+      ShamRack.sinatra("sinatra.xyz") do
+        get "/hello/:subject" do
+          "Hello, #{params[:subject]}"
+        end
+      end
+
+      open("http://sinatra.xyz/hello/stranger").read.should == "Hello, stranger"
+
+    end
+
+  end
+
+  describe "Rack environment" do
+
+    before(:each) do
+      @env_recorder = recorder = EnvRecordingApp.new
+      ShamRack.rackup("env.xyz") do
+        use Rack::Lint
+        run recorder
+      end
+    end
+
+    def env
+      @env_recorder.last_env
+    end
+
+    it "is valid" do
+
+      open("http://env.xyz/blah?q=abc")
+
+      env["REQUEST_METHOD"].should == "GET"
+      env["SCRIPT_NAME"].should == ""
+      env["PATH_INFO"].should == "/blah"
+      env["QUERY_STRING"].should == "q=abc"
+      env["SERVER_NAME"].should == "env.xyz"
+      env["SERVER_PORT"].should == "80"
+
+      env["rack.version"].should == [0,1]
+      env["rack.url_scheme"].should == "http"
+
+      env["rack.multithread"].should == true
+      env["rack.multiprocess"].should == true
+      env["rack.run_once"].should == false
+
+    end
+
+    it "provides request headers" do
+
+      Net::HTTP.start("env.xyz") do |http|
+        request = Net::HTTP::Get.new("/")
+        request["Foo-bar"] = "baz"
+        http.request(request)
+      end
+
+      env["HTTP_FOO_BAR"].should == "baz"
+
+    end
+
+    it "supports POST" do
+
+      RestClient.post("http://env.xyz/resource", "q" => "rack")
+
+      env["REQUEST_METHOD"].should == "POST"
+      env["CONTENT_TYPE"].should == "application/x-www-form-urlencoded"
+      env["rack.input"].read.should == "q=rack"
+
+    end
+
+    it "supports PUT" do
+
+      RestClient.put("http://env.xyz/thing1", "stuff", :content_type => "text/plain")
+
+      env["REQUEST_METHOD"].should == "PUT"
+      env["CONTENT_TYPE"].should == "text/plain"
+      env["rack.input"].read.should == "stuff"
+
+    end
+
+    it "supports DELETE" do
+
+      RestClient.delete("http://env.xyz/thing/1")
+
+      env["REQUEST_METHOD"].should == "DELETE"
+      env["PATH_INFO"].should == "/thing/1"
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require "rubygems"
+require "spec"
+require "rr"
+require "ruby-debug"
+
+project_root = File.expand_path("#{__FILE__}/../..")
+$LOAD_PATH << "#{project_root}/lib"
+$LOAD_PATH << "#{project_root}/spec/support/lib"
+
+Spec::Runner.configure do |config|
+  config.mock_with RR::Adapters::Rspec
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: mdub-sham_rack
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Mike Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-06 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: ShamRack plumbs Net::HTTP directly into Rack, for quick and easy HTTP testing.
+email: mdub@dogbiscuit.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- README.markdown
+- Rakefile
+- VERSION.yml
+- lib/sham_rack.rb
+- lib/sham_rack/core_ext/net/http.rb
+- lib/sham_rack/http.rb
+- lib/sham_rack/registry.rb
+- spec/sham_rack_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/mdub/sham_rack
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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.2.0
+signing_key: 
+specification_version: 3
+summary: Net::HTTP-to-Rack plumbing
+test_files: 
+- spec/sham_rack_spec.rb
+- spec/spec_helper.rb