rack-contrib 1.2.0 → 1.2.0.39.g17d21b4

data/test/spec_rack_evil.rb

@@ -1,19 +0,0 @@
-require 'test/spec'
-require 'rack/mock'
-require 'rack/contrib/evil'
-require 'erb'
-
-context "Rack::Evil" do
-  app = lambda do |env|
-    template = ERB.new("<%= throw :response, [404, {'Content-Type' => 'text/html'}, 'Never know where it comes from'] %>")
-    [200, {'Content-Type' => 'text/plain'}, template.result(binding)]
-  end
-
-  specify "should enable the app to return the response from anywhere" do
-    status, headers, body = Rack::Evil.new(app).call({})
-
-    status.should.equal 404
-    headers['Content-Type'].should.equal 'text/html'
-    body.should.equal 'Never know where it comes from'
-  end
-end

data/test/spec_rack_expectation_cascade.rb

@@ -1,72 +0,0 @@
-require 'test/spec'
-require 'rack/mock'
-require 'rack/contrib/expectation_cascade'
-
-context "Rack::ExpectationCascade" do
-  specify "with no apps returns a 404 if no expectation header was set" do
-    app = Rack::ExpectationCascade.new
-    env = {}
-    response = app.call(env)
-    response[0].should.equal 404
-    env.should.equal({})
-  end
-
-  specify "with no apps returns a 417 if expectation header was set" do
-    app = Rack::ExpectationCascade.new
-    env = {"Expect" => "100-continue"}
-    response = app.call(env)
-    response[0].should.equal 417
-    env.should.equal({"Expect" => "100-continue"})
-  end
-
-  specify "returns first successful response" do
-    app = Rack::ExpectationCascade.new do |cascade|
-      cascade << lambda { |env| [417, {"Content-Type" => "text/plain"}, []] }
-      cascade << lambda { |env| [200, {"Content-Type" => "text/plain"}, ["OK"]] }
-    end
-    response = app.call({})
-    response[0].should.equal 200
-    response[2][0].should.equal "OK"
-  end
-
-  specify "expectation is set if it has not been already" do
-    app = Rack::ExpectationCascade.new do |cascade|
-      cascade << lambda { |env| [200, {"Content-Type" => "text/plain"}, ["Expect: #{env["Expect"]}"]] }
-    end
-    response = app.call({})
-    response[0].should.equal 200
-    response[2][0].should.equal "Expect: 100-continue"
-  end
-
-  specify "returns a 404 if no apps where matched and no expectation header was set" do
-    app = Rack::ExpectationCascade.new do |cascade|
-      cascade << lambda { |env| [417, {"Content-Type" => "text/plain"}, []] }
-    end
-    response = app.call({})
-    response[0].should.equal 404
-    response[2][0].should.equal nil
-  end
-
-  specify "returns a 417 if no apps where matched and a expectation header was set" do
-    app = Rack::ExpectationCascade.new do |cascade|
-      cascade << lambda { |env| [417, {"Content-Type" => "text/plain"}, []] }
-    end
-    response = app.call({"Expect" => "100-continue"})
-    response[0].should.equal 417
-    response[2][0].should.equal nil
-  end
-
-  specify "nests expectation cascades" do
-    app = Rack::ExpectationCascade.new do |c1|
-      c1 << Rack::ExpectationCascade.new do |c2|
-        c2 << lambda { |env| [417, {"Content-Type" => "text/plain"}, []] }
-      end
-      c1 << Rack::ExpectationCascade.new do |c2|
-        c2 << lambda { |env| [200, {"Content-Type" => "text/plain"}, ["OK"]] }
-      end
-    end
-    response = app.call({})
-    response[0].should.equal 200
-    response[2][0].should.equal "OK"
-  end
-end

data/test/spec_rack_garbagecollector.rb

@@ -1,13 +0,0 @@
-require 'test/spec'
-require 'rack/mock'
-require 'rack/contrib/garbagecollector'
-
-context 'Rack::GarbageCollector' do
-
-  specify 'starts the garbage collector after each request' do
-    app = lambda { |env|
-      [200, {'Content-Type'=>'text/plain'}, ['Hello World']] }
-    Rack::GarbageCollector.new(app).call({})
-  end
-
-end

data/test/spec_rack_host_meta.rb

@@ -1,50 +0,0 @@
-require 'test/spec'
-require 'rack/mock'
-require 'rack/contrib/host_meta'
-require 'rack/contrib/not_found'
-
-context "Rack::HostMeta" do
-
-  setup do
-    app = Rack::Builder.new do
-      use Rack::Lint
-      use Rack::ContentLength
-      use Rack::HostMeta do
-        link :uri => '/robots.txt', :rel => 'robots'
-        link :uri => '/w3c/p3p.xml', :rel => 'privacy', :type => 'application/p3p.xml'
-        link :pattern => '{uri};json_schema', :rel => 'describedby', :type => 'application/x-schema+json'
-      end
-      run Rack::NotFound.new('test/404.html')
-    end
-    @response = Rack::MockRequest.new(app).get('/host-meta')
-  end
-
-  specify "should respond to /host-meta" do
-    @response.status.should.equal 200
-  end
-
-  specify "should respond with the correct media type" do
-    @response['Content-Type'].should.equal 'application/host-meta'
-  end
-
-  specify "should include a Link entry for each Link item in the config block" do
-    @response.body.should.match(/Link:\s*<\/robots.txt>;.*\n/)
-    @response.body.should.match(/Link:\s*<\/w3c\/p3p.xml>;.*/)
-  end
-
-  specify "should include a Link-Pattern entry for each Link-Pattern item in the config" do
-    @response.body.should.match(/Link-Pattern:\s*<\{uri\};json_schema>;.*/)
-  end
-
-  specify "should include a rel attribute for each Link or Link-Pattern entry where specified" do
-    @response.body.should.match(/rel="robots"/)
-    @response.body.should.match(/rel="privacy"/)
-    @response.body.should.match(/rel="describedby"/)
-  end
-
-  specify "should include a type attribute for each Link or Link-Pattern entry where specified" do
-    @response.body.should.match(/Link:\s*<\/w3c\/p3p.xml>;.*type.*application\/p3p.xml/)
-    @response.body.should.match(/Link-Pattern:\s*<\{uri\};json_schema>;.*type.*application\/x-schema\+json/)
-  end
-
-end

data/test/spec_rack_jsonp.rb

@@ -1,188 +0,0 @@
-require 'test/spec'
-require 'rack/mock'
-require 'rack/contrib/jsonp'
-
-context "Rack::JSONP" do
-
-  context "when a callback parameter is provided" do
-    specify "should wrap the response body in the Javascript callback if JSON" do
-      test_body = '{"bar":"foo"}'
-      callback = 'foo'
-      app = lambda { |env| [200, {'Content-Type' => 'application/json'}, [test_body]] }
-      request = Rack::MockRequest.env_for("/", :params => "foo=bar&callback=#{callback}")
-      body = Rack::JSONP.new(app).call(request).last
-      body.should.equal ["#{callback}(#{test_body})"]
-    end
-    
-    specify "should not wrap the response body in a callback if body is not JSON" do
-      test_body = '{"bar":"foo"}'
-      callback = 'foo'
-      app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, [test_body]] }
-      request = Rack::MockRequest.env_for("/", :params => "foo=bar&callback=#{callback}")
-      body = Rack::JSONP.new(app).call(request).last
-      body.should.equal ['{"bar":"foo"}']
-    end
-    
-    specify "should update content length if it was set" do
-      test_body = '{"bar":"foo"}'
-      callback = 'foo'
-      app = lambda { |env| [200, {'Content-Type' => 'application/json', 'Content-Length' => test_body.length}, [test_body]] }
-      request = Rack::MockRequest.env_for("/", :params => "foo=bar&callback=#{callback}")
-
-      headers = Rack::JSONP.new(app).call(request)[1]
-      expected_length = test_body.length + callback.length + "()".length
-      headers['Content-Length'].should.equal(expected_length.to_s)
-    end
-    
-    specify "should not touch content length if not set" do
-      test_body = '{"bar":"foo"}'
-      callback = 'foo'
-      app = lambda { |env| [200, {'Content-Type' => 'application/json'}, [test_body]] }
-      request = Rack::MockRequest.env_for("/", :params => "foo=bar&callback=#{callback}")
-      headers = Rack::JSONP.new(app).call(request)[1]
-      headers['Content-Length'].should.equal nil
-    end
-    
-    specify "should modify the content type to application/javascript" do
-      test_body = '{"bar":"foo"}'
-      callback = 'foo'
-      app = lambda { |env| [200, {'Content-Type' => 'application/json'}, [test_body]] }
-      request = Rack::MockRequest.env_for("/", :params => "foo=bar&callback=#{callback}")
-      headers = Rack::JSONP.new(app).call(request)[1]
-      headers['Content-Type'].should.equal('application/javascript')
-    end
-
-    specify "should not allow literal U+2028 or U+2029" do
-      test_body = unless "\u2028" == 'u2028'
-        "{\"bar\":\"\u2028 and \u2029\"}"
-      else
-        "{\"bar\":\"\342\200\250 and \342\200\251\"}"
-      end
-      callback = 'foo'
-      app = lambda { |env| [200, {'Content-Type' => 'application/json'}, [test_body]] }
-      request = Rack::MockRequest.env_for("/", :params => "foo=bar&callback=#{callback}")
-      body = Rack::JSONP.new(app).call(request).last
-      unless "\u2028" == 'u2028'
-        body.join.should.not.match(/\u2028|\u2029/)
-      else
-        body.join.should.not.match(/\342\200\250|\342\200\251/)
-      end
-    end
-    
-    context "but is empty" do
-      specify "should " do
-        test_body = '{"bar":"foo"}'
-        callback = ''
-        app = lambda { |env| [200, {'Content-Type' => 'application/json'}, [test_body]] }
-        request = Rack::MockRequest.env_for("/", :params => "foo=bar&callback=#{callback}")
-        body = Rack::JSONP.new(app).call(request).last
-        body.should.equal ['{"bar":"foo"}']
-      end
-    end
-    
-    context 'but is invalid' do
-      context 'with content-type application/json' do
-        specify 'should return "Bad Request"' do
-          test_body = '{"bar":"foo"}'
-          callback = '*'
-          content_type = 'application/json'
-          app = lambda { |env| [200, {'Content-Type' => content_type}, [test_body]] }
-          request = Rack::MockRequest.env_for("/", :params => "foo=bar&callback=#{callback}")
-          body = Rack::JSONP.new(app).call(request).last
-          body.should.equal ['Bad Request']
-        end
-
-        specify 'should return set the response code to 400' do
-          test_body = '{"bar":"foo"}'
-          callback = '*'
-          content_type = 'application/json'
-          app = lambda { |env| [200, {'Content-Type' => content_type}, [test_body]] }
-          request = Rack::MockRequest.env_for("/", :params => "foo=bar&callback=#{callback}")
-          response_code = Rack::JSONP.new(app).call(request).first
-          response_code.should.equal 400
-        end
-      end
-
-      context 'with content-type text/plain' do
-        specify 'should return "Good Request"' do
-          test_body = 'Good Request'
-          callback = '*'
-          content_type = 'text/plain'
-          app = lambda { |env| [200, {'Content-Type' => content_type}, [test_body]] }
-          request = Rack::MockRequest.env_for("/", :params => "foo=bar&callback=#{callback}")
-          body = Rack::JSONP.new(app).call(request).last
-          body.should.equal ['Good Request']
-        end
-
-        specify 'should not change the response code from 200' do
-          test_body = '{"bar":"foo"}'
-          callback = '*'
-          content_type = 'text/plain'
-          app = lambda { |env| [200, {'Content-Type' => content_type}, [test_body]] }
-          request = Rack::MockRequest.env_for("/", :params => "foo=bar&callback=#{callback}")
-          response_code = Rack::JSONP.new(app).call(request).first
-          response_code.should.equal 200
-        end
-      end
-    end
-
-    context "with XSS vulnerability attempts" do
-      def request(callback, body = '{"bar":"foo"}')
-        app = lambda { |env| [200, {'Content-Type' => 'application/json'}, [body]] }
-        request = Rack::MockRequest.env_for("/", :params => "foo=bar&callback=#{callback}")
-        Rack::JSONP.new(app).call(request)
-      end
-      
-      def assert_bad_request(response)
-        response.should.not.equal nil
-        status, headers, body = response
-        status.should.equal 400
-        body.should.equal ["Bad Request"]
-      end
-      
-      specify "should return bad request for callback with invalid characters" do
-        assert_bad_request(request("foo<bar>baz()$"))
-      end
-      
-      specify "should return bad request for callbacks with <script> tags" do
-        assert_bad_request(request("foo<script>alert(1)</script>"))
-      end
-      
-      specify "should return bad requests for callbacks with multiple statements" do
-        assert_bad_request(request("foo%3balert(1)//")) # would render: "foo;alert(1)//"
-      end
-      
-      specify "should not return a bad request for callbacks with dots in the callback" do
-        status, headers, body = request(callback = "foo.bar.baz", test_body = '{"foo":"bar"}')
-        status.should.equal 200
-        body.should.equal ["#{callback}(#{test_body})"]
-      end
-    end
-    
-  end
-
-  specify "should not change anything if no callback param is provided" do
-    test_body = ['{"bar":"foo"}']
-    app = lambda { |env| [200, {'Content-Type' => 'application/json'}, test_body] }
-    request = Rack::MockRequest.env_for("/", :params => "foo=bar")
-    body = Rack::JSONP.new(app).call(request).last
-    body.should.equal test_body
-  end
-
-  specify "should not change anything if it's not a json response" do
-    test_body = '<html><body>404 Not Found</body></html>'
-    app = lambda { |env| [404, {'Content-Type' => 'text/html'}, [test_body]] }
-    request = Rack::MockRequest.env_for("/", :params => "callback=foo", 'HTTP_ACCEPT' => 'application/json')
-    body = Rack::JSONP.new(app).call(request).last
-    body.should.equal [test_body]
-  end
-  
-  specify "should not change anything if there is no Content-Type header" do
-    test_body = '<html><body>404 Not Found</body></html>'
-    app = lambda { |env| [404, {}, [test_body]] }
-    request = Rack::MockRequest.env_for("/", :params => "callback=foo", 'HTTP_ACCEPT' => 'application/json')
-    body = Rack::JSONP.new(app).call(request).last
-    body.should.equal [test_body]
-  end  
-
-end

data/test/spec_rack_lighttpd_script_name_fix.rb

@@ -1,16 +0,0 @@
-require 'test/spec'
-require 'rack/mock'
-require 'rack/contrib/lighttpd_script_name_fix'
-
-context "Rack::LighttpdScriptNameFix" do
-  specify "corrects SCRIPT_NAME and PATH_INFO set by lighttpd " do
-    env = {
-      "PATH_INFO" => "/foo/bar/baz",
-      "SCRIPT_NAME" => "/hello"
-    }
-    app = lambda { |_| [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
-    response = Rack::LighttpdScriptNameFix.new(app).call(env)
-    env['SCRIPT_NAME'].should.be.empty
-    env['PATH_INFO'].should.equal '/hello/foo/bar/baz'
-  end
-end

data/test/spec_rack_mailexceptions.rb

@@ -1,169 +0,0 @@
-require 'test/spec'
-require 'rack/mock'
-
-begin
-  require './lib/rack/contrib/mailexceptions'
-  require './test/mail_settings.rb'
-
-  class TestError < RuntimeError
-  end
-
-  def test_exception
-    raise TestError, 'Suffering Succotash!'
-  rescue => boom
-    return boom
-  end
-
-  context 'Rack::MailExceptions' do
-
-    setup do
-      @app = lambda { |env| raise TestError, 'Why, I say' }
-      @env = Rack::MockRequest.env_for("/foo",
-        'FOO' => 'BAR',
-        :method => 'GET',
-        :input => 'THE BODY'
-      )
-      @smtp_settings = {
-        :server         => 'example.com',
-        :domain         => 'example.com',
-        :port           => 500,
-        :authentication => :login,
-        :user_name      => 'joe',
-        :password       => 'secret'
-      }
-    end
-
-    specify 'yields a configuration object to the block when created' do
-      called = false
-      mailer =
-        Rack::MailExceptions.new(@app) do |mail|
-          called = true
-          mail.to 'foo@example.org'
-          mail.from 'bar@example.org'
-          mail.subject '[ERROR] %s'
-          mail.smtp @smtp_settings
-        end
-      called.should.be == true
-    end
-
-    specify 'generates a TMail object with configured settings' do
-      mailer =
-        Rack::MailExceptions.new(@app) do |mail|
-          mail.to 'foo@example.org'
-          mail.from 'bar@example.org'
-          mail.subject '[ERROR] %s'
-          mail.smtp @smtp_settings
-        end
-
-      mail = mailer.send(:generate_mail, test_exception, @env)
-      mail.to.should.equal ['foo@example.org']
-      mail.from.should.equal ['bar@example.org']
-      mail.subject.should.equal '[ERROR] Suffering Succotash!'
-      mail.body.should.not.be.nil
-      mail.body.should.be =~ /FOO:\s+"BAR"/
-      mail.body.should.be =~ /^\s*THE BODY\s*$/
-    end
-
-    specify 'catches exceptions raised from app, sends mail, and re-raises' do
-      mailer =
-        Rack::MailExceptions.new(@app) do |mail|
-          mail.to 'foo@example.org'
-          mail.from 'bar@example.org'
-          mail.subject '[ERROR] %s'
-          mail.smtp @smtp_settings
-        end
-      lambda { mailer.call(@env) }.should.raise(TestError)
-      @env['mail.sent'].should.be == true
-    end
-
-    if TEST_SMTP && ! TEST_SMTP.empty?
-      specify 'sends mail' do
-        mailer =
-          Rack::MailExceptions.new(@app) do |mail|
-            mail.config.merge! TEST_SMTP
-          end
-        lambda { mailer.call(@env) }.should.raise(TestError)
-        @env['mail.sent'].should.be == true
-      end
-    else
-      STDERR.puts 'WARN: Skipping SMTP tests (edit test/mail_settings.rb to enable)'
-    end
-
-    context 'for tls enabled smtp' do
-      setup do
-        @smtp_settings.merge!(TEST_SMTP_TLS)
-        @mailer = 
-          Rack::MailExceptions.new(@app) do |mail|
-            mail.to TEST_SMTP_TLS.values_at(:user_name, :domain).join('@')
-            mail.from 'bar@example.org'
-            mail.subject '[ERROR] %s'
-            mail.smtp @smtp_settings.merge( :enable_starttls_auto => true)
-          end
-      end
-
-      describe 'with :enable_starttls_auto set to :auto' do
-        specify 'sends mail' do
-          @mailer.smtp.merge(:enable_starttls_auto => :auto)
-          lambda { @mailer.call(@env) }.should.raise(TestError)
-          @env['mail.sent'].should.be true
-        end
-      end
-
-      describe 'with :enable_starttls_auto set to true' do
-        specify 'sends mail' do
-          @mailer.smtp.merge(:enable_starttls_auto => true)
-          lambda { @mailer.call(@env) }.should.raise(TestError)
-          @env['mail.sent'].should.be true
-        end
-      end
-    end if defined?(TEST_SMTP_TLS)
-
-    describe 'for tls enabled fake smtp' do
-      class FakeSMTP
-        def initialize(*args); @@_tls = nil; end
-        def start(*args);  end
-        def enable_starttls_auto; @@_tls = :auto; end
-        def enable_starttls; @@_tls = true; end
-        def send_message(*args); end
-        def self.tls; @@_tls; end
-      end
-
-      setup do
-        Rack::MailExceptions.class_eval { def service; FakeSMTP; end}
-        @mailer = 
-          Rack::MailExceptions.new(@app) do |mail|
-            mail.to 'foo@example.org'
-            mail.from 'bar@example.org'
-            mail.subject '[ERROR] %s'
-            mail.smtp @smtp_settings.merge( :server => 'server.com')
-          end
-      end
-
-      context 'with :enable_starttls_auto unset' do
-        specify 'sends mail' do
-          @mailer.smtp[:enable_starttls_auto] = nil
-          lambda { @mailer.call(@env) }.should.raise(TestError)
-          FakeSMTP.tls.should.be nil
-        end
-      end
-
-      context 'with :enable_starttls_auto set to true' do
-        specify 'sends mail' do
-          @mailer.smtp[:enable_starttls_auto] = true
-          lambda { @mailer.call(@env) }.should.raise(TestError)
-          FakeSMTP.tls.should == true
-        end
-      end
-
-      context 'with :enable_starttls_auto set to :auto' do
-        specify 'sends mail' do
-          @mailer.smtp[:enable_starttls_auto] = :auto
-          lambda { @mailer.call(@env) }.should.raise(TestError)
-          FakeSMTP.tls.should == :auto
-        end
-      end
-    end
-  end
-rescue LoadError => boom
-  STDERR.puts "WARN: Skipping Rack::MailExceptions tests (mail not installed)"
-end