rack-contrib 1.2.0 → 1.2.0.39.g17d21b4

data/test/spec_rack_backstage.rb

@@ -1,26 +0,0 @@
-require 'test/spec'
-require 'rack/builder'
-require 'rack/mock'
-require 'rack/contrib/backstage'
-
-context "Rack::Backstage" do
-  specify "shows maintenances page if present" do
-    app = Rack::Builder.new do
-      use Rack::Backstage, 'test/Maintenance.html'
-      run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
-    end
-    response = Rack::MockRequest.new(app).get('/')
-    response.body.should.equal('Under maintenance.')
-    response.status.should.equal(503)
-  end
-
-  specify "passes on request if page is not present" do
-    app = Rack::Builder.new do
-      use Rack::Backstage, 'test/Nonsense.html'
-      run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
-    end
-    response = Rack::MockRequest.new(app).get('/')
-    response.body.should.equal('Hello, World!')
-    response.status.should.equal(200)
-  end
-end

data/test/spec_rack_callbacks.rb

@@ -1,65 +0,0 @@
-require 'test/spec'
-require 'rack/mock'
-
-class Flame
-  def call(env)
-    env['flame'] = 'F Lifo..'
-  end
-end
-
-class Pacify
-  def initialize(with)
-    @with = with
-  end
-
-  def call(env)
-    env['peace'] = @with
-  end
-end
-
-class Finale
-  def call(response)
-    status, headers, body = response
-
-    headers['last'] = 'Finale'
-    $old_status = status
-
-    [201, headers, body]
-  end
-end
-
-class TheEnd
-  def call(response)
-    status, headers, body = response
-
-    headers['last'] = 'TheEnd'
-    [201, headers, body]
-  end
-end
-
-context "Rack::Callbacks" do
-  specify "works for love and small stack trace" do
-    callback_app = Rack::Callbacks.new do
-      before Flame
-      before Pacify, "with love"
-
-      run lambda {|env| [200, {}, [env['flame'], env['peace']]] }
-
-      after Finale
-      after TheEnd
-    end
-
-    app = Rack::Builder.new do
-      run callback_app
-    end.to_app
-
-    response = Rack::MockRequest.new(app).get("/")
-
-    response.body.should.equal 'F Lifo..with love'
-
-    $old_status.should.equal 200
-    response.status.should.equal 201
-
-    response.headers['last'].should.equal 'TheEnd'
-  end
-end

data/test/spec_rack_common_cookies.rb

@@ -1,107 +0,0 @@
-require 'test/spec'
-require 'rack/mock'
-require 'rack/builder'
-require 'rack/contrib/common_cookies'
-
-context Rack::CommonCookies do
-
-  setup do
-    @app = Rack::Builder.new do
-      use Rack::CommonCookies
-      run lambda {|env| [200, {'Set-Cookie' => env['HTTP_COOKIE']}, []] }
-    end
-  end
-
-  def request
-    Rack::MockRequest.new(@app)
-  end
-
-  def make_request(domain, cookies='key=value')
-    request.get '/', 'HTTP_COOKIE' => cookies, 'HTTP_HOST' => domain
-  end
-
-  specify 'should use .domain.com for cookies from domain.com' do
-    response = make_request 'domain.com'
-    response.headers['Set-Cookie'].should == 'key=value; domain=.domain.com'
-  end
-
-  specify 'should use .domain.com for cookies from www.domain.com' do
-    response = make_request 'www.domain.com'
-    response.headers['Set-Cookie'].should == 'key=value; domain=.domain.com'
-  end
-
-  specify 'should use .domain.com for cookies from subdomain.domain.com' do
-    response = make_request 'subdomain.domain.com'
-    response.headers['Set-Cookie'].should == 'key=value; domain=.domain.com'
-  end
-
-  specify 'should use .domain.com for cookies from 0.subdomain1.subdomain2.domain.com' do
-    response = make_request '0.subdomain1.subdomain2.domain.com'
-    response.headers['Set-Cookie'].should == 'key=value; domain=.domain.com'
-  end
-
-  specify 'should use .domain.local for cookies from domain.local' do
-    response = make_request '0.subdomain1.subdomain2.domain.com'
-    response.headers['Set-Cookie'].should == 'key=value; domain=.domain.com'
-  end
-
-  specify 'should use .domain.local for cookies from subdomain.domain.local' do
-    response = make_request 'subdomain.domain.local'
-    response.headers['Set-Cookie'].should == 'key=value; domain=.domain.local'
-  end
-
-  specify 'should use .domain.com.ua for cookies from domain.com.ua' do
-    response = make_request 'domain.com.ua'
-    response.headers['Set-Cookie'].should == 'key=value; domain=.domain.com.ua'
-  end
-
-  specify 'should use .domain.com.ua for cookies from subdomain.domain.com.ua' do
-    response = make_request 'subdomain.domain.com.ua'
-    response.headers['Set-Cookie'].should == 'key=value; domain=.domain.com.ua'
-  end
-
-  specify 'should use .domain.co.uk for cookies from domain.co.uk' do
-    response = make_request 'domain.co.uk'
-    response.headers['Set-Cookie'].should == 'key=value; domain=.domain.co.uk'
-  end
-
-  specify 'should use .domain.co.uk for cookies from subdomain.domain.co.uk' do
-    response = make_request 'subdomain.domain.co.uk'
-    response.headers['Set-Cookie'].should == 'key=value; domain=.domain.co.uk'
-  end
-
-  specify 'should use .domain.eu.com for cookies from domain.eu.com' do
-    response = make_request 'domain.eu.com'
-    response.headers['Set-Cookie'].should == 'key=value; domain=.domain.eu.com'
-  end
-
-  specify 'should use .domain.eu.com for cookies from subdomain.domain.eu.com' do
-    response = make_request 'subdomain.domain.eu.com'
-    response.headers['Set-Cookie'].should == 'key=value; domain=.domain.eu.com'
-  end
-
-  specify 'should work with multiple cookies' do
-    response = make_request 'sub.domain.bz', "key=value\nkey1=value2"
-    response.headers['Set-Cookie'].should == "key=value; domain=.domain.bz\nkey1=value2; domain=.domain.bz"
-  end
-
-  specify 'should work with cookies which have explicit domain' do
-    response = make_request 'sub.domain.bz', "key=value; domain=domain.bz"
-    response.headers['Set-Cookie'].should == "key=value; domain=.domain.bz"
-  end
-
-  specify 'should not touch cookies if domain is localhost' do
-    response = make_request 'localhost'
-    response.headers['Set-Cookie'].should == "key=value"
-  end
-
-  specify 'should not touch cookies if domain is ip address' do
-    response = make_request '127.0.0.1'
-    response.headers['Set-Cookie'].should == "key=value"
-  end
-
-  specify 'should use .domain.com for cookies from subdomain.domain.com:3000' do
-    response = make_request 'subdomain.domain.com:3000'
-    response.headers['Set-Cookie'].should == "key=value; domain=.domain.com"
-  end
-end

data/test/spec_rack_config.rb

@@ -1,22 +0,0 @@
-require 'test/spec'
-require 'rack/mock'
-require 'rack/contrib/config'
-
-context "Rack::Config" do
-
-  specify "should accept a block that modifies the environment" do
-    app = Rack::Builder.new do
-      use Rack::Lint
-      use Rack::ContentLength
-      use Rack::Config do |env|
-        env['greeting'] = 'hello'
-      end
-      run lambda { |env|
-        [200, {'Content-Type' => 'text/plain'}, [env['greeting'] || '']]
-      }
-    end
-    response = Rack::MockRequest.new(app).get('/')
-    response.body.should.equal('hello')
-  end
-
-end

data/test/spec_rack_contrib.rb

@@ -1,8 +0,0 @@
-require 'test/spec'
-require 'rack/contrib'
-
-context "Rack::Contrib" do
-  specify "should expose release" do
-    Rack::Contrib.should.respond_to :release
-  end
-end

data/test/spec_rack_cookies.rb

@@ -1,56 +0,0 @@
-require 'test/spec'
-require 'rack/mock'
-require 'rack/contrib/cookies'
-
-context "Rack::Cookies" do
-  specify "should be able to read received cookies" do
-    app = lambda { |env|
-      cookies = env['rack.cookies']
-      foo, quux = cookies[:foo], cookies['quux']
-      [200, {'Content-Type' => 'text/plain'}, ["foo: #{foo}, quux: #{quux}"]]
-    }
-    app = Rack::Cookies.new(app)
-
-    response = Rack::MockRequest.new(app).get('/', 'HTTP_COOKIE' => 'foo=bar;quux=h&m')
-    response.body.should.equal('foo: bar, quux: h&m')
-  end
-
-  specify "should be able to set new cookies" do
-    app = lambda { |env|
-      cookies = env['rack.cookies']
-      cookies[:foo] = 'bar'
-      cookies['quux'] = 'h&m'
-      [200, {'Content-Type' => 'text/plain'}, []]
-    }
-    app = Rack::Cookies.new(app)
-
-    response = Rack::MockRequest.new(app).get('/')
-    response.headers['Set-Cookie'].should.equal("quux=h%26m; path=/\nfoo=bar; path=/")
-  end
-
-  specify "should be able to set cookie with options" do
-    app = lambda { |env|
-      cookies = env['rack.cookies']
-      cookies['foo'] = { :value => 'bar', :path => '/login', :secure => true }
-      [200, {'Content-Type' => 'text/plain'}, []]
-    }
-    app = Rack::Cookies.new(app)
-
-    response = Rack::MockRequest.new(app).get('/')
-    response.headers['Set-Cookie'].should.equal('foo=bar; path=/login; secure')
-  end
-
-  specify "should be able to delete received cookies" do
-    app = lambda { |env|
-      cookies = env['rack.cookies']
-      cookies.delete(:foo)
-      foo, quux = cookies['foo'], cookies[:quux]
-      [200, {'Content-Type' => 'text/plain'}, ["foo: #{foo}, quux: #{quux}"]]
-    }
-    app = Rack::Cookies.new(app)
-
-    response = Rack::MockRequest.new(app).get('/', 'HTTP_COOKIE' => 'foo=bar;quux=h&m')
-    response.body.should.equal('foo: , quux: h&m')
-    response.headers['Set-Cookie'].should.equal('foo=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT')
-  end
-end

data/test/spec_rack_csshttprequest.rb

@@ -1,66 +0,0 @@
-require 'test/spec'
-require 'rack/mock'
-
-begin
-  require 'csshttprequest'
-  require 'rack/contrib/csshttprequest'
-
-  context "Rack::CSSHTTPRequest" do
-
-    before(:each) do
-      @test_body = '{"bar":"foo"}'
-      @test_headers = {'Content-Type' => 'text/plain'}
-      @encoded_body = CSSHTTPRequest.encode(@test_body)
-      @app = lambda { |env| [200, @test_headers, [@test_body]] }
-    end
-
-    specify "env['csshttprequest.chr'] should be set to true when \
-        PATH_INFO ends with '.chr'" do
-      request = Rack::MockRequest.env_for("/blah.chr", :lint => true, :fatal => true)
-      Rack::CSSHTTPRequest.new(@app).call(request)
-      request['csshttprequest.chr'].should.equal true
-    end
-
-    specify "env['csshttprequest.chr'] should be set to true when \
-        request parameter _format == 'chr'" do
-      request = Rack::MockRequest.env_for("/?_format=chr", :lint => true, :fatal => true)
-      Rack::CSSHTTPRequest.new(@app).call(request)
-      request['csshttprequest.chr'].should.equal true
-    end
-
-    specify "should not change the headers or response when !env['csshttprequest.chr']" do
-      request = Rack::MockRequest.env_for("/", :lint => true, :fatal => true)
-      status, headers, response = Rack::CSSHTTPRequest.new(@app).call(request)
-      headers.should.equal @test_headers
-      response.join.should.equal @test_body
-    end
-
-    context "when env['csshttprequest.chr']" do
-      before(:each) do
-        @request = Rack::MockRequest.env_for("/",
-          'csshttprequest.chr' => true, :lint => true, :fatal => true)
-      end
-
-      specify "should modify the content length to the correct value" do
-        headers = Rack::CSSHTTPRequest.new(@app).call(@request)[1]
-        headers['Content-Length'].should.equal @encoded_body.length.to_s
-      end
-
-      specify "should modify the content type to the correct value" do
-        headers = Rack::CSSHTTPRequest.new(@app).call(@request)[1]
-        headers['Content-Type'].should.equal 'text/css'
-      end
-
-      specify "should not modify any other headers" do
-        headers = Rack::CSSHTTPRequest.new(@app).call(@request)[1]
-        headers.should.equal @test_headers.merge({
-          'Content-Type' => 'text/css',
-          'Content-Length' => @encoded_body.length.to_s
-        })
-      end
-    end
-
-  end
-rescue LoadError => boom
-  STDERR.puts "WARN: Skipping Rack::CSSHTTPRequest tests (nbio-csshttprequest not installed)"
-end

data/test/spec_rack_deflect.rb

@@ -1,107 +0,0 @@
-require 'test/spec'
-require 'rack/mock'
-require 'rack/contrib/deflect'
-
-context "Rack::Deflect" do
-
-  setup do
-    @app = lambda { |env| [200, { 'Content-Type' => 'text/plain' }, ['cookies']] }
-    @mock_addr_1 = '111.111.111.111'
-    @mock_addr_2 = '222.222.222.222'
-    @mock_addr_3 = '333.333.333.333'
-  end
-
-  def mock_env remote_addr, path = '/'
-    Rack::MockRequest.env_for path, { 'REMOTE_ADDR' => remote_addr }
-  end
-
-  def mock_deflect options = {}
-    Rack::Deflect.new @app, options
-  end
-
-  specify "should allow regular requests to follow through" do
-    app = mock_deflect
-    status, headers, body = app.call mock_env(@mock_addr_1)
-    status.should.equal 200
-    body.should.equal ['cookies']
-  end
-
-  specify "should deflect requests exceeding the request threshold" do
-    log = StringIO.new
-    app = mock_deflect :request_threshold => 5, :interval => 10, :block_duration => 10, :log => log
-    env = mock_env @mock_addr_1
-
-    # First 5 should be fine
-    5.times do
-      status, headers, body = app.call env
-      status.should.equal 200
-      body.should.equal ['cookies']
-    end
-
-    # Remaining requests should fail for 10 seconds
-    10.times do
-      status, headers, body = app.call env
-      status.should.equal 403
-      body.should.equal []
-    end
-
-    # Log should reflect that we have blocked an address
-    log.string.should.match(/^deflect\(\d+\/\d+\/\d+\): blocked 111.111.111.111\n/)
-  end
-
-  specify "should expire blocking" do
-    log = StringIO.new
-    app = mock_deflect :request_threshold => 5, :interval => 2, :block_duration => 2, :log => log
-    env = mock_env @mock_addr_1
-
-    # First 5 should be fine
-    5.times do
-      status, headers, body = app.call env
-      status.should.equal 200
-      body.should.equal ['cookies']
-    end
-
-    # Exceeds request threshold
-    status, headers, body = app.call env
-    status.should.equal 403
-    body.should.equal []
-
-    # Allow block to expire
-    sleep 3
-
-    # Another 5 is fine now
-    5.times do
-      status, headers, body = app.call env
-      status.should.equal 200
-      body.should.equal ['cookies']
-    end
-
-    # Log should reflect block and release
-    log.string.should.match(/deflect.*: blocked 111\.111\.111\.111\ndeflect.*: released 111\.111\.111\.111\n/)
-  end
-
-  specify "should allow whitelisting of remote addresses" do
-    app = mock_deflect :whitelist => [@mock_addr_1], :request_threshold => 5, :interval => 2
-    env = mock_env @mock_addr_1
-
-    # Whitelisted addresses are always fine
-    10.times do
-      status, headers, body = app.call env
-      status.should.equal 200
-      body.should.equal ['cookies']
-    end
-  end
-
-  specify "should allow blacklisting of remote addresses" do
-    app = mock_deflect :blacklist => [@mock_addr_2]
-
-    status, headers, body = app.call mock_env(@mock_addr_1)
-    status.should.equal 200
-    body.should.equal ['cookies']
-
-    status, headers, body = app.call mock_env(@mock_addr_2)
-    status.should.equal 403
-    body.should.equal []
-  end
-
-end