sham_rack 1.1.1

data/.gitignore

@@ -0,0 +1,2 @@
+pkg
+rdoc

data/CHANGES.markdown

@@ -0,0 +1,8 @@
+## 3-Jun-2009 [mdub@dogbiscuit.org]
+
+* Introduced ShamRack#at to simplify registration of apps.
+
+## 13-May-2009 [mdub@dogbiscuit.org]
+
+* Added accessors on HTTP object for address, port and rack_app.
+* Added accessors to imitate "net/https".

data/README.markdown

@@ -0,0 +1,77 @@
+ShamRack
+========
+
+ShamRack plumbs Net:HTTP into [Rack][rack].
+
+What's it for, again?
+---------------------
+
+Well, you can _test your HTTP client code_, using ShamRack to stub out an external web-service. Think of it as [FakeWeb][fakeweb] on steriods.
+
+Or, you can _test your Rack application_ (or Sinatra, or Rails, or Merb) using arbitrary HTTP client libraries, to check interoperability. For instance, you could hit a local app using:
+
+* [`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
+--------
+
+### A simple inline application
+
+    require 'sham_rack'
+
+    ShamRack.at("www.example.com") do |env|
+      ["200 OK", { "Content-type" => "text/plain" }, "Hello, world!"]
+    end
+      
+    require 'open-uri'
+    open("http://www.example.com/").read            #=> "Hello, world!"
+
+### Sinatra integration
+
+    ShamRack.at("sinatra.xyz").sinatra do
+      get "/hello/:subject" do
+        "Hello, #{params[:subject]}"
+      end
+    end
+
+    open("http://sinatra.xyz/hello/stranger").read  #=> "Hello, stranger"
+
+### Rackup support
+
+    ShamRack.at("rackup.xyz").rackup do
+      use Some::Middleware
+      use Some::Other::Middleware
+      run MyApp.new
+    end
+
+### Any old app
+
+    ShamRack.mount(my_google_stub, "google.com")
+
+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.
+* Perryn Fowler for his efforts plumbing Net::HTTP into ActionController::TestProcess.
+* 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,40 @@
+require "rubygems"
+require "rake"
+
+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
+
+require "jeweler"
+
+Jeweler::Tasks.new do |g|
+  g.name = "sham_rack"
+  g.summary = "Net::HTTP-to-Rack plumbing"
+  g.email = "mdub@dogbiscuit.org"
+  g.homepage = "http://github.com/mdub/sham_rack"
+  g.description = "ShamRack plumbs Net::HTTP directly into Rack, for quick and easy HTTP testing."
+  g.authors = ["Mike Williams"]
+  g.rubyforge_project = "shamrack"
+end
+
+Jeweler::RubyforgeTasks.new
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ShamRack #{version}"
+  rdoc.main = "ShamRack"
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION.yml

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

data/lib/sham_rack.rb

@@ -0,0 +1,7 @@
+# ShamRack allows access to Rack applications using Net::Http, but without network traffic.
+#
+# For more detail, see http://github.com/mdub/sham_rack
+#
+module ShamRack; end
+
+require "sham_rack/core_ext/net/http"

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,109 @@
+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
+
+    attr_reader :address, :port, :rack_app
+    
+    attr_accessor :read_timeout, :open_timeout
+    attr_accessor :use_ssl,:key, :cert, :ca_file, :ca_path, :verify_mode, :verify_callback, :verify_depth, :cert_store
+
+    def start
+      yield self
+    end
+
+    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,59 @@
+module ShamRack
+
+  module Registry
+  
+    def mount(rack_app, address, port = nil)
+      port ||= Net::HTTP.default_port
+      registry[[address, port]] = rack_app
+    end
+    
+    def unmount_all
+      registry.clear
+    end
+
+    def at(address, port = nil, &block)
+      if block
+        mount(block, address, port)
+      else
+        Registrar.new(address, port)
+      end
+    end
+    
+    def application_for(address, port = nil)
+      port ||= Net::HTTP.default_port
+      registry[[address, port]]
+    end
+
+    private
+    
+    def registry
+      @registry ||= {}
+    end
+    
+  end
+    
+  extend Registry
+
+  class Registrar
+    
+    def initialize(address, port = nil)
+      @address = address
+      @port = port
+    end
+
+    def rackup(&block)
+      require "rack"
+      app = Rack::Builder.new(&block).to_app
+      ShamRack.mount(app, @address, @port)
+    end
+    
+    def sinatra(&block)
+      require "sinatra/base"
+      sinatra_app = Class.new(Sinatra::Base)
+      sinatra_app.class_eval(&block)
+      ShamRack.mount(sinatra_app.new, @address, @port)
+    end
+
+  end
+
+end

data/sham_rack.gemspec

@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sham_rack}
+  s.version = "1.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Mike Williams"]
+  s.date = %q{2009-06-03}
+  s.description = %q{ShamRack plumbs Net::HTTP directly into Rack, for quick and easy HTTP testing.}
+  s.email = %q{mdub@dogbiscuit.org}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "CHANGES.markdown",
+     "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",
+     "sham_rack.gemspec",
+     "spec/sham_rack_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/mdub/sham_rack}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{shamrack}
+  s.rubygems_version = %q{1.3.2}
+  s.summary = %q{Net::HTTP-to-Rack plumbing}
+  s.test_files = [
+    "spec/sham_rack_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/spec/sham_rack_spec.rb

@@ -0,0 +1,226 @@
+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 "#at" do
+
+    describe "with a block" do
+
+      it "mounts associated block as an app" do
+
+        ShamRack.at("simple.xyz") do |env|
+          ["200 OK", { "Content-type" => "text/plain" }, "Easy, huh?"]
+        end
+
+        open("http://simple.xyz").read.should == "Easy, huh?"
+
+      end
+
+    end
+
+    describe "#rackup" do
+
+      before do
+        @return_value = ShamRack.at("rackup.xyz").rackup do
+          use UpcaseBody
+          run SimpleMessageApp.new("Racked!")
+        end
+      end
+
+      it "mounts an app created using Rack::Builder" do
+        open("http://rackup.xyz").read.should == "RACKED!"
+      end
+
+      it "returns the app" do
+        @return_value.should respond_to(:call)
+      end
+
+    end
+
+    describe "#sinatra" do
+
+      before do
+        @return_value = ShamRack.at("sinatra.xyz").sinatra do
+          get "/hello/:subject" do
+            "Hello, #{params[:subject]}"
+          end
+        end
+      end
+      
+      it "mounts associated block as a Sinatra app" do
+        open("http://sinatra.xyz/hello/stranger").read.should == "Hello, stranger"
+      end
+
+      it "returns the app" do
+        @return_value.should respond_to(:call)
+      end
+      
+    end
+
+  end
+
+  describe "Rack environment" do
+
+    before(:each) do
+      @env_recorder = recorder = EnvRecordingApp.new
+      ShamRack.at("env.xyz").rackup 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,67 @@
+--- !ruby/object:Gem::Specification 
+name: sham_rack
+version: !ruby/object:Gem::Version 
+  version: 1.1.1
+platform: ruby
+authors: 
+- Mike Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-03 00:00:00 +10: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: 
+- .gitignore
+- CHANGES.markdown
+- 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
+- sham_rack.gemspec
+- spec/sham_rack_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/mdub/sham_rack
+licenses: []
+
+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: shamrack
+rubygems_version: 1.3.2
+signing_key: 
+specification_version: 3
+summary: Net::HTTP-to-Rack plumbing
+test_files: 
+- spec/sham_rack_spec.rb
+- spec/spec_helper.rb