akamai_bookmarklet 0.1.0

data/vendor/gems/ruby/1.8/gems/sinatra-0.9.4/test/options_test.rb

@@ -0,0 +1,372 @@
+require File.dirname(__FILE__) + '/helper'
+
+class OptionsTest < Test::Unit::TestCase
+  setup do
+    @base    = Sinatra.new(Sinatra::Base)
+    @default = Sinatra.new(Sinatra::Default)
+    @base.set    :environment, :development
+    @default.set :environment, :development
+  end
+
+  it 'sets options to literal values' do
+    @base.set(:foo, 'bar')
+    assert @base.respond_to?(:foo)
+    assert_equal 'bar', @base.foo
+  end
+
+  it 'sets options to Procs' do
+    @base.set(:foo, Proc.new { 'baz' })
+    assert @base.respond_to?(:foo)
+    assert_equal 'baz', @base.foo
+  end
+
+  it "sets multiple options with a Hash" do
+    @base.set :foo => 1234,
+        :bar => 'Hello World',
+        :baz => Proc.new { 'bizzle' }
+    assert_equal 1234, @base.foo
+    assert_equal 'Hello World', @base.bar
+    assert_equal 'bizzle', @base.baz
+  end
+
+  it 'inherits option methods when subclassed' do
+    @base.set :foo, 'bar'
+    @base.set :biz, Proc.new { 'baz' }
+
+    sub = Class.new(@base)
+    assert sub.respond_to?(:foo)
+    assert_equal 'bar', sub.foo
+    assert sub.respond_to?(:biz)
+    assert_equal 'baz', sub.biz
+  end
+
+  it 'overrides options in subclass' do
+    @base.set :foo, 'bar'
+    @base.set :biz, Proc.new { 'baz' }
+    sub = Class.new(@base)
+    sub.set :foo, 'bling'
+    assert_equal 'bling', sub.foo
+    assert_equal 'bar', @base.foo
+  end
+
+  it 'creates setter methods when first defined' do
+    @base.set :foo, 'bar'
+    assert @base.respond_to?('foo=')
+    @base.foo = 'biz'
+    assert_equal 'biz', @base.foo
+  end
+
+  it 'creates predicate methods when first defined' do
+    @base.set :foo, 'hello world'
+    assert @base.respond_to?(:foo?)
+    assert @base.foo?
+    @base.set :foo, nil
+    assert !@base.foo?
+  end
+
+  it 'uses existing setter methods if detected' do
+    class << @base
+      def foo
+        @foo
+      end
+      def foo=(value)
+        @foo = 'oops'
+      end
+    end
+
+    @base.set :foo, 'bam'
+    assert_equal 'oops', @base.foo
+  end
+
+  it "sets multiple options to true with #enable" do
+    @base.enable :sessions, :foo, :bar
+    assert @base.sessions
+    assert @base.foo
+    assert @base.bar
+  end
+
+  it "sets multiple options to false with #disable" do
+    @base.disable :sessions, :foo, :bar
+    assert !@base.sessions
+    assert !@base.foo
+    assert !@base.bar
+  end
+
+  it 'enables MethodOverride middleware when :methodoverride is enabled' do
+    @base.set :methodoverride, true
+    @base.put('/') { 'okay' }
+    @app = @base
+    post '/', {'_method'=>'PUT'}, {}
+    assert_equal 200, status
+    assert_equal 'okay', body
+  end
+
+  describe 'clean_trace' do
+    def clean_backtrace(trace)
+      Sinatra::Base.new.send(:clean_backtrace, trace)
+    end
+
+    it 'is enabled on Base' do
+      assert @base.clean_trace?
+    end
+
+    it 'is enabled on Default' do
+      assert @default.clean_trace?
+    end
+
+    it 'does nothing when disabled' do
+      backtrace = [
+        "./lib/sinatra/base.rb",
+        "./myapp:42",
+        ("#{Gem.dir}/some/lib.rb" if defined?(Gem))
+      ].compact
+
+      klass = Class.new(Sinatra::Base)
+      klass.disable :clean_trace
+
+      assert_equal backtrace, klass.new.send(:clean_backtrace, backtrace)
+    end
+
+    it 'removes sinatra lib paths from backtrace when enabled' do
+      backtrace = [
+        "./lib/sinatra/base.rb",
+        "./lib/sinatra/compat.rb:42",
+        "./lib/sinatra/main.rb:55 in `foo'"
+      ]
+      assert clean_backtrace(backtrace).empty?
+    end
+
+    it 'removes ./ prefix from backtrace paths when enabled' do
+      assert_equal ['myapp.rb:42'], clean_backtrace(['./myapp.rb:42'])
+    end
+
+    if defined?(Gem)
+      it 'removes gem lib paths from backtrace when enabled' do
+        assert clean_backtrace(["#{Gem.dir}/some/lib"]).empty?
+      end
+    end
+  end
+
+  describe 'run' do
+    it 'is disabled on Base' do
+      assert ! @base.run?
+    end
+
+    it 'is enabled on Default when not in test environment' do
+      @default.set :environment, :development
+      assert @default.development?
+      assert @default.run?
+
+      @default.set :environment, :development
+      assert @default.run?
+    end
+
+    # TODO: it 'is enabled when $0 == app_file'
+  end
+
+  describe 'raise_errors' do
+    it 'is enabled on Base' do
+      assert @base.raise_errors?
+    end
+
+    it 'is enabled on Default only in test' do
+      @default.set(:environment, :development)
+      assert @default.development?
+      assert ! @default.raise_errors?
+
+      @default.set(:environment, :production)
+      assert ! @default.raise_errors?
+
+      @default.set(:environment, :test)
+      assert @default.raise_errors?
+    end
+  end
+
+  describe 'show_exceptions' do
+    %w[development test production none].each do |environment|
+      it "is disabled on Base in #{environment} environments" do
+        @base.set(:environment, environment)
+        assert ! @base.show_exceptions?
+      end
+    end
+
+    it 'is enabled on Default only in development' do
+      @base.set(:environment, :development)
+      assert @default.development?
+      assert @default.show_exceptions?
+
+      @default.set(:environment, :test)
+      assert ! @default.show_exceptions?
+
+      @base.set(:environment, :production)
+      assert ! @base.show_exceptions?
+    end
+
+    it 'returns a friendly 500' do
+      klass = Sinatra.new(Sinatra::Default)
+      mock_app(klass) {
+        enable :show_exceptions
+
+        get '/' do
+          raise StandardError
+        end
+      }
+
+      get '/'
+      assert_equal 500, status
+      assert body.include?("StandardError")
+      assert body.include?("<code>show_exceptions</code> option")
+    end
+  end
+
+  describe 'dump_errors' do
+    it 'is disabled on Base' do
+      assert ! @base.dump_errors?
+    end
+
+    it 'is enabled on Default' do
+      assert @default.dump_errors?
+    end
+
+    it 'dumps exception with backtrace to rack.errors' do
+      klass = Sinatra.new(Sinatra::Default)
+
+      mock_app(klass) {
+        disable :raise_errors
+
+        error do
+          error = @env['rack.errors'].instance_variable_get(:@error)
+          error.rewind
+
+          error.read
+        end
+
+        get '/' do
+          raise
+        end
+      }
+
+      get '/'
+      assert body.include?("RuntimeError") && body.include?("options_test.rb")
+    end
+  end
+
+  describe 'sessions' do
+    it 'is disabled on Base' do
+      assert ! @base.sessions?
+    end
+
+    it 'is disabled on Default' do
+      assert ! @default.sessions?
+    end
+
+    # TODO: it 'uses Rack::Session::Cookie when enabled' do
+  end
+
+  describe 'logging' do
+    it 'is disabled on Base' do
+      assert ! @base.logging?
+    end
+
+    it 'is enabled on Default when not in test environment' do
+      assert @default.logging?
+
+      @default.set :environment, :test
+      assert ! @default.logging
+    end
+
+    # TODO: it 'uses Rack::CommonLogger when enabled' do
+  end
+
+  describe 'static' do
+    it 'is disabled on Base' do
+      assert ! @base.static?
+    end
+
+    it 'is enabled on Default' do
+      assert @default.static?
+    end
+
+    # TODO: it setup static routes if public is enabled
+    # TODO: however, that's already tested in static_test so...
+  end
+
+  describe 'host' do
+    it 'defaults to 0.0.0.0' do
+      assert_equal '0.0.0.0', @base.host
+      assert_equal '0.0.0.0', @default.host
+    end
+  end
+
+  describe 'port' do
+    it 'defaults to 4567' do
+      assert_equal 4567, @base.port
+      assert_equal 4567, @default.port
+    end
+  end
+
+  describe 'server' do
+    it 'is one of thin, mongrel, webrick' do
+      assert_equal %w[thin mongrel webrick], @base.server
+      assert_equal %w[thin mongrel webrick], @default.server
+    end
+  end
+
+  describe 'app_file' do
+    it 'is nil' do
+      assert @base.app_file.nil?
+      assert @default.app_file.nil?
+    end
+  end
+
+  describe 'root' do
+    it 'is nil if app_file is not set' do
+      assert @base.root.nil?
+      assert @default.root.nil?
+    end
+
+    it 'is equal to the expanded basename of app_file' do
+      @base.app_file = __FILE__
+      assert_equal File.expand_path(File.dirname(__FILE__)), @base.root
+
+      @default.app_file = __FILE__
+      assert_equal File.expand_path(File.dirname(__FILE__)), @default.root
+    end
+  end
+
+  describe 'views' do
+    it 'is nil if root is not set' do
+      assert @base.views.nil?
+      assert @default.views.nil?
+    end
+
+    it 'is set to root joined with views/' do
+      @base.root = File.dirname(__FILE__)
+      assert_equal File.dirname(__FILE__) + "/views", @base.views
+
+      @default.root = File.dirname(__FILE__)
+      assert_equal File.dirname(__FILE__) + "/views", @default.views
+    end
+  end
+
+  describe 'public' do
+    it 'is nil if root is not set' do
+      assert @base.public.nil?
+      assert @default.public.nil?
+    end
+
+    it 'is set to root joined with public/' do
+      @base.root = File.dirname(__FILE__)
+      assert_equal File.dirname(__FILE__) + "/public", @base.public
+
+      @default.root = File.dirname(__FILE__)
+      assert_equal File.dirname(__FILE__) + "/public", @default.public
+    end
+  end
+
+  describe 'lock' do
+    it 'is disabled by default' do
+      assert ! @base.lock?
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/sinatra-0.9.4/test/render_backtrace_test.rb

@@ -0,0 +1,145 @@
+require File.dirname(__FILE__) + '/helper'
+
+require 'sass/error'
+
+class RenderBacktraceTest < Test::Unit::TestCase
+  VIEWS = File.dirname(__FILE__) + '/views'
+
+  def assert_raise_at(filename, line, exception = RuntimeError)
+    f, l = nil
+    assert_raise(exception) do
+      begin
+        get('/')
+      rescue => e
+        f, l = e.backtrace.first.split(':')
+        raise
+      end
+    end
+    assert_equal(filename, f, "expected #{exception.name} in #{filename}, was #{f}")
+    assert_equal(line, l.to_i, "expected #{exception.name} in #{filename} at line #{line}, was at line #{l}")
+  end
+
+  def backtrace_app(&block)
+    mock_app {
+      use_in_file_templates!
+      set :views, RenderBacktraceTest::VIEWS
+      template :builder_template do
+        'raise "error"'
+      end
+      template :erb_template do
+        '<% raise "error" %>'
+      end
+      template :haml_template do
+        '%h1= raise "error"'
+      end
+      template :sass_template do
+        '+syntax-error'
+      end
+      get '/', &block
+    }
+  end
+
+  it "provides backtrace for Builder template" do
+    backtrace_app { builder :error }
+    assert_raise_at(File.join(VIEWS,'error.builder'), 2)
+  end
+
+  it "provides backtrace for ERB template" do
+    backtrace_app { erb :error }
+    assert_raise_at(File.join(VIEWS,'error.erb'), 2)
+  end
+
+  it "provides backtrace for HAML template" do
+    backtrace_app { haml :error }
+    assert_raise_at(File.join(VIEWS,'error.haml'), 2)
+  end
+
+  it "provides backtrace for Sass template" do
+    backtrace_app { sass :error }
+    assert_raise_at(File.join(VIEWS,'error.sass'), 2, Sass::SyntaxError)
+  end
+
+  it "provides backtrace for ERB template with locals" do
+    backtrace_app { erb :error, {}, :french => true }
+    assert_raise_at(File.join(VIEWS,'error.erb'), 3)
+  end
+
+  it "provides backtrace for HAML template with locals" do
+    backtrace_app { haml :error, {}, :french => true }
+    assert_raise_at(File.join(VIEWS,'error.haml'), 3)
+  end
+
+  it "provides backtrace for inline Builder string" do
+    backtrace_app { builder "raise 'Ack! Thbbbt!'"}
+    assert_raise_at(__FILE__, (__LINE__-1))
+  end
+
+  it "provides backtrace for inline ERB string" do
+    backtrace_app { erb "<% raise 'bidi-bidi-bidi' %>" }
+    assert_raise_at(__FILE__, (__LINE__-1))
+  end
+
+  it "provides backtrace for inline HAML string" do
+    backtrace_app { haml "%h1= raise 'Lions and tigers and bears! Oh, my!'" }
+    assert_raise_at(__FILE__, (__LINE__-1))
+  end
+
+  # it "provides backtrace for inline Sass string" do
+  #   backtrace_app { sass '+buh-bye' }
+  #   assert_raise_at(__FILE__, (__LINE__-1), Sass::SyntaxError)
+  # end
+
+  it "provides backtrace for named Builder template" do
+    backtrace_app { builder :builder_template }
+    assert_raise_at(__FILE__, (__LINE__-68))
+  end
+
+  it "provides backtrace for named ERB template" do
+    backtrace_app { erb :erb_template }
+    assert_raise_at(__FILE__, (__LINE__-70))
+  end
+
+  it "provides backtrace for named HAML template" do
+    backtrace_app { haml :haml_template }
+    assert_raise_at(__FILE__, (__LINE__-72))
+  end
+
+  # it "provides backtrace for named Sass template" do
+  #   backtrace_app { sass :sass_template }
+  #   assert_raise_at(__FILE__, (__LINE__-74), Sass::SyntaxError)
+  # end
+
+  it "provides backtrace for in file Builder template" do
+    backtrace_app { builder :builder_in_file }
+    assert_raise_at(__FILE__, (__LINE__+22))
+  end
+
+  it "provides backtrace for in file ERB template" do
+    backtrace_app { erb :erb_in_file }
+    assert_raise_at(__FILE__, (__LINE__+20))
+  end
+
+  it "provides backtrace for in file HAML template" do
+    backtrace_app { haml :haml_in_file }
+    assert_raise_at(__FILE__, (__LINE__+18))
+  end
+
+  # it "provides backtrace for in file Sass template" do
+  #   backtrace_app { sass :sass_in_file }
+  #   assert_raise_at(__FILE__, (__LINE__+16), Sass::SyntaxError)
+  # end
+end
+
+__END__
+
+@@ builder_in_file
+raise "bif"
+
+@@ erb_in_file
+<% raise "bam" %>
+
+@@ haml_in_file
+%h1= raise "pow"
+
+@@ sass_in_file
++blam

data/vendor/gems/ruby/1.8/gems/sinatra-0.9.4/test/request_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/helper'
+
+class RequestTest < Test::Unit::TestCase
+  it 'responds to #user_agent' do
+    request = Sinatra::Request.new({'HTTP_USER_AGENT' => 'Test'})
+    assert request.respond_to?(:user_agent)
+    assert_equal 'Test', request.user_agent
+  end
+
+  it 'parses POST params when Content-Type is form-dataish' do
+    request = Sinatra::Request.new(
+      'REQUEST_METHOD' => 'PUT',
+      'CONTENT_TYPE' => 'application/x-www-form-urlencoded',
+      'rack.input' => StringIO.new('foo=bar')
+    )
+    assert_equal 'bar', request.params['foo']
+  end
+end

data/vendor/gems/ruby/1.8/gems/sinatra-0.9.4/test/response_test.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/helper'
+
+class ResponseTest < Test::Unit::TestCase
+  setup do
+    @response = Sinatra::Response.new
+  end
+
+  it "initializes with 200, text/html, and empty body" do
+    assert_equal 200, @response.status
+    assert_equal 'text/html', @response['Content-Type']
+    assert_equal [], @response.body
+  end
+
+  it 'uses case insensitive headers' do
+    @response['content-type'] = 'application/foo'
+    assert_equal 'application/foo', @response['Content-Type']
+    assert_equal 'application/foo', @response['CONTENT-TYPE']
+  end
+
+  it 'writes to body' do
+    @response.body = 'Hello'
+    @response.write ' World'
+    assert_equal 'Hello World', @response.body
+  end
+
+  [204, 304].each do |status_code|
+    it "removes the Content-Type header and body when response status is #{status_code}" do
+      @response.status = status_code
+      @response.body = ['Hello World']
+      assert_equal [status_code, {}, []], @response.finish
+    end
+  end
+
+  it 'Calculates the Content-Length using the bytesize of the body' do
+    @response.body = ['Hello', 'World!', '✈']
+    status, headers, body = @response.finish
+    assert_equal '14', headers['Content-Length']
+    assert_equal @response.body, body
+  end
+end

data/vendor/gems/ruby/1.8/gems/sinatra-0.9.4/test/result_test.rb

@@ -0,0 +1,98 @@
+require File.dirname(__FILE__) + '/helper'
+
+class ResultTest < Test::Unit::TestCase
+  it "sets response.body when result is a String" do
+    mock_app {
+      get '/' do
+        'Hello World'
+      end
+    }
+
+    get '/'
+    assert ok?
+    assert_equal 'Hello World', body
+  end
+
+  it "sets response.body when result is an Array of Strings" do
+    mock_app {
+      get '/' do
+        ['Hello', 'World']
+      end
+    }
+
+    get '/'
+    assert ok?
+    assert_equal 'HelloWorld', body
+  end
+
+  it "sets response.body when result responds to #each" do
+    mock_app {
+      get '/' do
+        res = lambda { 'Hello World' }
+        def res.each ; yield call ; end
+        res
+      end
+    }
+
+    get '/'
+    assert ok?
+    assert_equal 'Hello World', body
+  end
+
+  it "sets response.body to [] when result is nil" do
+    mock_app {
+      get '/' do
+        nil
+      end
+    }
+
+    get '/'
+    assert ok?
+    assert_equal '', body
+  end
+
+  it "sets status, headers, and body when result is a Rack response tuple" do
+    mock_app {
+      get '/' do
+        [205, {'Content-Type' => 'foo/bar'}, 'Hello World']
+      end
+    }
+
+    get '/'
+    assert_equal 205, status
+    assert_equal 'foo/bar', response['Content-Type']
+    assert_equal 'Hello World', body
+  end
+
+  it "sets status and body when result is a two-tuple" do
+    mock_app {
+      get '/' do
+        [409, 'formula of']
+      end
+    }
+
+    get '/'
+    assert_equal 409, status
+    assert_equal 'formula of', body
+  end
+
+  it "raises a TypeError when result is a non two or three tuple Array" do
+    mock_app {
+      get '/' do
+        [409, 'formula of', 'something else', 'even more']
+      end
+    }
+
+    assert_raise(TypeError) { get '/' }
+  end
+
+  it "sets status when result is a Fixnum status code" do
+    mock_app {
+      get('/') { 205 }
+    }
+
+    get '/'
+    assert_equal 205, status
+    assert_equal '', body
+  end
+end