edgar-rack 1.2.1

data/test/spec_lobster.rb

@@ -0,0 +1,43 @@
+require 'rack/lobster'
+require 'rack/mock'
+
+describe Rack::Lobster::LambdaLobster do
+  should "be a single lambda" do
+    Rack::Lobster::LambdaLobster.should.be.kind_of Proc
+  end
+
+  should "look like a lobster" do
+    res = Rack::MockRequest.new(Rack::Lobster::LambdaLobster).get("/")
+    res.should.be.ok
+    res.body.should.include "(,(,,(,,,("
+    res.body.should.include "?flip"
+  end
+
+  should "be flippable" do
+    res = Rack::MockRequest.new(Rack::Lobster::LambdaLobster).get("/?flip")
+    res.should.be.ok
+    res.body.should.include "(,,,(,,(,("
+  end
+end
+
+describe Rack::Lobster do
+  should "look like a lobster" do
+    res = Rack::MockRequest.new(Rack::Lobster.new).get("/")
+    res.should.be.ok
+    res.body.should.include "(,(,,(,,,("
+    res.body.should.include "?flip"
+    res.body.should.include "crash"
+  end
+
+  should "be flippable" do
+    res = Rack::MockRequest.new(Rack::Lobster.new).get("/?flip=left")
+    res.should.be.ok
+    res.body.should.include "(,,,(,,(,("
+  end
+
+  should "provide crashing for testing purposes" do
+    lambda {
+      Rack::MockRequest.new(Rack::Lobster.new).get("/?flip=crash")
+    }.should.raise
+  end
+end

data/test/spec_lock.rb

@@ -0,0 +1,142 @@
+require 'rack/lock'
+require 'rack/mock'
+
+class Lock
+  attr_reader :synchronized
+
+  def initialize
+    @synchronized = false
+  end
+
+  def synchronize
+    @synchronized = true
+    yield
+  end
+
+  def lock
+    @synchronized = true
+  end
+
+  def unlock
+    @synchronized = false
+  end
+end
+
+describe Rack::Lock do
+  describe 'Proxy' do
+    should 'delegate each' do
+      lock     = Lock.new
+      env      = Rack::MockRequest.env_for("/")
+      response = Class.new {
+        attr_accessor :close_called
+        def initialize; @close_called = false; end
+        def each; %w{ hi mom }.each { |x| yield x }; end
+      }.new
+
+      app = Rack::Lock.new(lambda { |inner_env| [200, {}, response] }, lock)
+      response = app.call(env)[2]
+      list = []
+      response.each { |x| list << x }
+      list.should.equal %w{ hi mom }
+    end
+
+    should 'delegate to_path' do
+      lock = Lock.new
+      env  = Rack::MockRequest.env_for("/")
+
+      res = ['Hello World']
+      def res.to_path ; "/tmp/hello.txt" ; end
+
+      app = Rack::Lock.new(lambda { |inner_env| [200, {}, res] }, lock)
+      body = app.call(env)[2]
+
+      body.should.respond_to :to_path
+      body.to_path.should.equal "/tmp/hello.txt"
+    end
+
+    should 'not delegate to_path if body does not implement it' do
+      lock = Lock.new
+      env  = Rack::MockRequest.env_for("/")
+
+      res = ['Hello World']
+
+      app = Rack::Lock.new(lambda { |inner_env| [200, {}, res] }, lock)
+      body = app.call(env)[2]
+
+      body.should.not.respond_to :to_path
+    end
+  end
+
+  should 'call super on close' do
+    lock     = Lock.new
+    env      = Rack::MockRequest.env_for("/")
+    response = Class.new {
+      attr_accessor :close_called
+      def initialize; @close_called = false; end
+      def close; @close_called = true; end
+    }.new
+
+    app = Rack::Lock.new(lambda { |inner_env| [200, {}, response] }, lock)
+    app.call(env)
+    response.close_called.should.equal false
+    response.close
+    response.close_called.should.equal true
+  end
+
+  should "not unlock until body is closed" do
+    lock     = Lock.new
+    env      = Rack::MockRequest.env_for("/")
+    response = Object.new
+    app      = Rack::Lock.new(lambda { |inner_env| [200, {}, response] }, lock)
+    lock.synchronized.should.equal false
+    response = app.call(env)[2]
+    lock.synchronized.should.equal true
+    response.close
+    lock.synchronized.should.equal false
+  end
+
+  should "return value from app" do
+    lock = Lock.new
+    env  = Rack::MockRequest.env_for("/")
+    body = [200, {}, %w{ hi mom }]
+    app  = Rack::Lock.new(lambda { |inner_env| body }, lock)
+    app.call(env).should.equal body
+  end
+
+  should "call synchronize on lock" do
+    lock = Lock.new
+    env = Rack::MockRequest.env_for("/")
+    app = Rack::Lock.new(lambda { |inner_env|
+      [200, {}, %w{ a b c }]
+    }, lock)
+    lock.synchronized.should.equal false
+    app.call(env)
+    lock.synchronized.should.equal true
+  end
+
+  should "unlock if the app raises" do
+    lock = Lock.new
+    env = Rack::MockRequest.env_for("/")
+    app = Rack::Lock.new(lambda { raise Exception }, lock)
+    lambda { app.call(env) }.should.raise(Exception)
+    lock.synchronized.should.equal false
+  end
+
+  should "set multithread flag to false" do
+    app = Rack::Lock.new(lambda { |env|
+      env['rack.multithread'].should.equal false
+      [200, {}, %w{ a b c }]
+    })
+    app.call(Rack::MockRequest.env_for("/"))
+  end
+
+  should "reset original multithread flag when exiting lock" do
+    app = Class.new(Rack::Lock) {
+      def call(env)
+        env['rack.multithread'].should.equal true
+        super
+      end
+    }.new(lambda { |env| [200, {}, %w{ a b c }] })
+    app.call(Rack::MockRequest.env_for("/"))
+  end
+end

data/test/spec_logger.rb

@@ -0,0 +1,28 @@
+require 'stringio'
+require 'rack/logger'
+
+describe Rack::Logger do
+  app = lambda { |env|
+    log = env['rack.logger']
+    log.debug("Created logger")
+    log.info("Program started")
+    log.warn("Nothing to do!")
+
+    [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]]
+  }
+
+  should "log to rack.errors" do
+    errors = StringIO.new
+    Rack::Logger.new(app).call('rack.errors' => errors)
+    errors.string.should.match(/INFO -- : Program started/)
+    errors.string.should.match(/WARN -- : Nothing to do/)
+  end
+
+  should "conform to Rack::Lint" do
+    errors = StringIO.new
+    a = Rack::Lint.new(Rack::Logger.new(app))
+    Rack::MockRequest.new(a).get('/', 'rack.errors' => errors)
+    errors.string.should.match(/INFO -- : Program started/)
+    errors.string.should.match(/WARN -- : Nothing to do/)
+  end
+end

data/test/spec_methodoverride.rb

@@ -0,0 +1,58 @@
+require 'stringio'
+require 'rack/methodoverride'
+require 'rack/mock'
+
+describe Rack::MethodOverride do
+  should "not affect GET requests" do
+    env = Rack::MockRequest.env_for("/?_method=delete", :method => "GET")
+    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
+    req = app.call(env)
+
+    req.env["REQUEST_METHOD"].should.equal "GET"
+  end
+
+  should "modify REQUEST_METHOD for POST requests when _method parameter is set" do
+    env = Rack::MockRequest.env_for("/", :method => "POST", :input => "_method=put")
+    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
+    req = app.call(env)
+
+    req.env["REQUEST_METHOD"].should.equal "PUT"
+  end
+
+  should "modify REQUEST_METHOD for POST requests when X-HTTP-Method-Override is set" do
+    env = Rack::MockRequest.env_for("/",
+            :method => "POST",
+            "HTTP_X_HTTP_METHOD_OVERRIDE" => "PUT"
+          )
+    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
+    req = app.call(env)
+
+    req.env["REQUEST_METHOD"].should.equal "PUT"
+  end
+
+  should "not modify REQUEST_METHOD if the method is unknown" do
+    env = Rack::MockRequest.env_for("/", :method => "POST", :input => "_method=foo")
+    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
+    req = app.call(env)
+
+    req.env["REQUEST_METHOD"].should.equal "POST"
+  end
+
+  should "not modify REQUEST_METHOD when _method is nil" do
+    env = Rack::MockRequest.env_for("/", :method => "POST", :input => "foo=bar")
+    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
+    req = app.call(env)
+
+    req.env["REQUEST_METHOD"].should.equal "POST"
+  end
+
+  should "store the original REQUEST_METHOD prior to overriding" do
+    env = Rack::MockRequest.env_for("/",
+            :method => "POST",
+            :input  => "_method=options")
+    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
+    req = app.call(env)
+
+    req.env["rack.methodoverride.original_method"].should.equal "POST"
+  end
+end

data/test/spec_mock.rb

@@ -0,0 +1,241 @@
+require 'yaml'
+require 'rack/mock'
+
+app = lambda { |env|
+  req = Rack::Request.new(env)
+
+  env["mock.postdata"] = env["rack.input"].read
+  if req.GET["error"]
+    env["rack.errors"].puts req.GET["error"]
+    env["rack.errors"].flush
+  end
+
+  Rack::Response.new(env.to_yaml,
+                     req.GET["status"] || 200,
+                     "Content-Type" => "text/yaml").finish
+}
+
+describe Rack::MockRequest do
+  should "return a MockResponse" do
+    res = Rack::MockRequest.new(app).get("")
+    res.should.be.kind_of Rack::MockResponse
+  end
+
+  should "be able to only return the environment" do
+    env = Rack::MockRequest.env_for("")
+    env.should.be.kind_of Hash
+    env.should.include "rack.version"
+  end
+
+  should "provide sensible defaults" do
+    res = Rack::MockRequest.new(app).request
+
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "GET"
+    env["SERVER_NAME"].should.equal "example.org"
+    env["SERVER_PORT"].should.equal "80"
+    env["QUERY_STRING"].should.equal ""
+    env["PATH_INFO"].should.equal "/"
+    env["SCRIPT_NAME"].should.equal ""
+    env["rack.url_scheme"].should.equal "http"
+    env["mock.postdata"].should.be.empty
+  end
+
+  should "allow GET/POST/PUT/DELETE" do
+    res = Rack::MockRequest.new(app).get("", :input => "foo")
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "GET"
+
+    res = Rack::MockRequest.new(app).post("", :input => "foo")
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "POST"
+
+    res = Rack::MockRequest.new(app).put("", :input => "foo")
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "PUT"
+
+    res = Rack::MockRequest.new(app).delete("", :input => "foo")
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "DELETE"
+
+    Rack::MockRequest.env_for("/", :method => "OPTIONS")["REQUEST_METHOD"].
+      should.equal "OPTIONS"
+  end
+
+  should "set content length" do
+    env = Rack::MockRequest.env_for("/", :input => "foo")
+    env["CONTENT_LENGTH"].should.equal "3"
+  end
+
+  should "allow posting" do
+    res = Rack::MockRequest.new(app).get("", :input => "foo")
+    env = YAML.load(res.body)
+    env["mock.postdata"].should.equal "foo"
+
+    res = Rack::MockRequest.new(app).post("", :input => StringIO.new("foo"))
+    env = YAML.load(res.body)
+    env["mock.postdata"].should.equal "foo"
+  end
+
+  should "use all parts of an URL" do
+    res = Rack::MockRequest.new(app).
+      get("https://bla.example.org:9292/meh/foo?bar")
+    res.should.be.kind_of Rack::MockResponse
+
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "GET"
+    env["SERVER_NAME"].should.equal "bla.example.org"
+    env["SERVER_PORT"].should.equal "9292"
+    env["QUERY_STRING"].should.equal "bar"
+    env["PATH_INFO"].should.equal "/meh/foo"
+    env["rack.url_scheme"].should.equal "https"
+  end
+
+  should "set SSL port and HTTP flag on when using https" do
+    res = Rack::MockRequest.new(app).
+      get("https://example.org/foo")
+    res.should.be.kind_of Rack::MockResponse
+
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "GET"
+    env["SERVER_NAME"].should.equal "example.org"
+    env["SERVER_PORT"].should.equal "443"
+    env["QUERY_STRING"].should.equal ""
+    env["PATH_INFO"].should.equal "/foo"
+    env["rack.url_scheme"].should.equal "https"
+    env["HTTPS"].should.equal "on"
+  end
+
+  should "prepend slash to uri path" do
+    res = Rack::MockRequest.new(app).
+      get("foo")
+    res.should.be.kind_of Rack::MockResponse
+
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "GET"
+    env["SERVER_NAME"].should.equal "example.org"
+    env["SERVER_PORT"].should.equal "80"
+    env["QUERY_STRING"].should.equal ""
+    env["PATH_INFO"].should.equal "/foo"
+    env["rack.url_scheme"].should.equal "http"
+  end
+
+  should "properly convert method name to an uppercase string" do
+    res = Rack::MockRequest.new(app).request(:get)
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "GET"
+  end
+
+  should "accept params and build query string for GET requests" do
+    res = Rack::MockRequest.new(app).get("/foo?baz=2", :params => {:foo => {:bar => "1"}})
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "GET"
+    env["QUERY_STRING"].should.include "baz=2"
+    env["QUERY_STRING"].should.include "foo[bar]=1"
+    env["PATH_INFO"].should.equal "/foo"
+    env["mock.postdata"].should.equal ""
+  end
+
+  should "accept raw input in params for GET requests" do
+    res = Rack::MockRequest.new(app).get("/foo?baz=2", :params => "foo[bar]=1")
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "GET"
+    env["QUERY_STRING"].should.include "baz=2"
+    env["QUERY_STRING"].should.include "foo[bar]=1"
+    env["PATH_INFO"].should.equal "/foo"
+    env["mock.postdata"].should.equal ""
+  end
+
+  should "accept params and build url encoded params for POST requests" do
+    res = Rack::MockRequest.new(app).post("/foo", :params => {:foo => {:bar => "1"}})
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "POST"
+    env["QUERY_STRING"].should.equal ""
+    env["PATH_INFO"].should.equal "/foo"
+    env["CONTENT_TYPE"].should.equal "application/x-www-form-urlencoded"
+    env["mock.postdata"].should.equal "foo[bar]=1"
+  end
+
+  should "accept raw input in params for POST requests" do
+    res = Rack::MockRequest.new(app).post("/foo", :params => "foo[bar]=1")
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "POST"
+    env["QUERY_STRING"].should.equal ""
+    env["PATH_INFO"].should.equal "/foo"
+    env["CONTENT_TYPE"].should.equal "application/x-www-form-urlencoded"
+    env["mock.postdata"].should.equal "foo[bar]=1"
+  end
+
+  should "accept params and build multipart encoded params for POST requests" do
+    files = Rack::Utils::Multipart::UploadedFile.new(File.join(File.dirname(__FILE__), "multipart", "file1.txt"))
+    res = Rack::MockRequest.new(app).post("/foo", :params => { "submit-name" => "Larry", "files" => files })
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "POST"
+    env["QUERY_STRING"].should.equal ""
+    env["PATH_INFO"].should.equal "/foo"
+    env["CONTENT_TYPE"].should.equal "multipart/form-data; boundary=AaB03x"
+    env["mock.postdata"].length.should.equal 206
+  end
+
+  should "behave valid according to the Rack spec" do
+    lambda {
+      Rack::MockRequest.new(app).
+        get("https://bla.example.org:9292/meh/foo?bar", :lint => true)
+    }.should.not.raise(Rack::Lint::LintError)
+  end
+end
+
+describe Rack::MockResponse do
+  should "provide access to the HTTP status" do
+    res = Rack::MockRequest.new(app).get("")
+    res.should.be.successful
+    res.should.be.ok
+
+    res = Rack::MockRequest.new(app).get("/?status=404")
+    res.should.not.be.successful
+    res.should.be.client_error
+    res.should.be.not_found
+
+    res = Rack::MockRequest.new(app).get("/?status=501")
+    res.should.not.be.successful
+    res.should.be.server_error
+
+    res = Rack::MockRequest.new(app).get("/?status=307")
+    res.should.be.redirect
+
+    res = Rack::MockRequest.new(app).get("/?status=201", :lint => true)
+    res.should.be.empty
+  end
+
+  should "provide access to the HTTP headers" do
+    res = Rack::MockRequest.new(app).get("")
+    res.should.include "Content-Type"
+    res.headers["Content-Type"].should.equal "text/yaml"
+    res.original_headers["Content-Type"].should.equal "text/yaml"
+    res["Content-Type"].should.equal "text/yaml"
+    res.content_type.should.equal "text/yaml"
+    res.content_length.should.not.equal 0
+    res.location.should.be.nil
+  end
+
+  should "provide access to the HTTP body" do
+    res = Rack::MockRequest.new(app).get("")
+    res.body.should =~ /rack/
+    res.should =~ /rack/
+    res.should.match(/rack/)
+    res.should.satisfy { |r| r.match(/rack/) }
+  end
+
+  should "provide access to the Rack errors" do
+    res = Rack::MockRequest.new(app).get("/?error=foo", :lint => true)
+    res.should.be.ok
+    res.errors.should.not.be.empty
+    res.errors.should.include "foo"
+  end
+
+  should "optionally make Rack errors fatal" do
+    lambda {
+      Rack::MockRequest.new(app).get("/?error=foo", :fatal => true)
+    }.should.raise(Rack::MockRequest::FatalWarning)
+  end
+end