sinatra 1.4.8 → 2.0.0.beta1

data/test/sass_test.rb

@@ -1,115 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-begin
-require 'sass'
-
-class SassTest < Minitest::Test
-  def sass_app(options = {}, &block)
-    mock_app do
-      set :views, File.dirname(__FILE__) + '/views'
-      set options
-      get('/', &block)
-    end
-    get '/'
-  end
-
-  it 'renders inline Sass strings' do
-    sass_app { sass "#sass\n  :background-color white\n" }
-    assert ok?
-    assert_equal "#sass {\n  background-color: white; }\n", body
-  end
-
-  it 'defaults content type to css' do
-    sass_app { sass "#sass\n  :background-color white\n" }
-    assert ok?
-    assert_equal "text/css;charset=utf-8", response['Content-Type']
-  end
-
-  it 'defaults allows setting content type per route' do
-    sass_app do
-      content_type :html
-      sass "#sass\n  :background-color white\n"
-    end
-    assert ok?
-    assert_equal "text/html;charset=utf-8", response['Content-Type']
-  end
-
-  it 'defaults allows setting content type globally' do
-    sass_app(:sass => { :content_type => 'html' }) {
-      sass "#sass\n  :background-color white\n"
-    }
-    assert ok?
-    assert_equal "text/html;charset=utf-8", response['Content-Type']
-  end
-
-  it 'renders .sass files in views path' do
-    sass_app { sass :hello }
-    assert ok?
-    assert_equal "#sass {\n  background-color: white; }\n", body
-  end
-
-  it 'ignores the layout option' do
-    sass_app { sass :hello, :layout => :layout2 }
-    assert ok?
-    assert_equal "#sass {\n  background-color: white; }\n", body
-  end
-
-  it "raises error if template not found" do
-    mock_app { get('/') { sass :no_such_template } }
-    assert_raises(Errno::ENOENT) { get('/') }
-  end
-
-  it "passes SASS options to the Sass engine" do
-    sass_app do
-      sass(
-        "#sass\n  :background-color white\n  :color black\n",
-        :style => :compact
-      )
-    end
-    assert ok?
-    assert_equal("#sass { background-color: white; color: black; }\n", body)
-  end
-
-  it "passes default SASS options to the Sass engine" do
-    mock_app do
-      set :sass, {:style => :compact} # default Sass style is :nested
-      get('/') { sass("#sass\n  :background-color white\n  :color black\n") }
-    end
-    get '/'
-    assert ok?
-    assert_equal "#sass { background-color: white; color: black; }\n", body
-  end
-
-  it "merges the default SASS options with the overrides" do
-    mock_app do
-      # default Sass attribute_syntax is :normal (with : in front)
-      set :sass, {:style => :compact, :attribute_syntax => :alternate }
-      get('/') { sass("#sass\n  background-color: white\n  color: black\n") }
-      get('/raised') do
-        # retains global attribute_syntax settings
-        sass(
-          "#sass\n  :background-color white\n  :color black\n",
-          :style => :expanded
-        )
-      end
-      get('/expanded_normal') do
-        sass(
-          "#sass\n  :background-color white\n  :color black\n",
-          :style => :expanded, :attribute_syntax => :normal
-        )
-      end
-    end
-    get '/'
-    assert ok?
-    assert_equal "#sass { background-color: white; color: black; }\n", body
-    assert_raises(Sass::SyntaxError) { get('/raised') }
-    get '/expanded_normal'
-    assert ok?
-    assert_equal "#sass {\n  background-color: white;\n  color: black;\n}\n",
-      body
-  end
-end
-
-rescue LoadError
-  warn "#{$!.to_s}: skipping sass tests"
-end

data/test/scss_test.rb

@@ -1,88 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-begin
-require 'sass'
-
-class ScssTest < Minitest::Test
-  def scss_app(options = {}, &block)
-    mock_app do
-      set :views, File.dirname(__FILE__) + '/views'
-      set options
-      get('/', &block)
-    end
-    get '/'
-  end
-
-  it 'renders inline Scss strings' do
-    scss_app { scss "#scss {\n  background-color: white; }\n" }
-    assert ok?
-    assert_equal "#scss {\n  background-color: white; }\n", body
-  end
-
-  it 'defaults content type to css' do
-    scss_app { scss "#scss {\n  background-color: white; }\n" }
-    assert ok?
-    assert_equal "text/css;charset=utf-8", response['Content-Type']
-  end
-
-  it 'defaults allows setting content type per route' do
-    scss_app do
-      content_type :html
-      scss "#scss {\n  background-color: white; }\n"
-    end
-    assert ok?
-    assert_equal "text/html;charset=utf-8", response['Content-Type']
-  end
-
-  it 'defaults allows setting content type globally' do
-    scss_app(:scss => { :content_type => 'html' }) {
-      scss "#scss {\n  background-color: white; }\n"
-    }
-    assert ok?
-    assert_equal "text/html;charset=utf-8", response['Content-Type']
-  end
-
-  it 'renders .scss files in views path' do
-    scss_app { scss :hello }
-    assert ok?
-    assert_equal "#scss {\n  background-color: white; }\n", body
-  end
-
-  it 'ignores the layout option' do
-    scss_app { scss :hello, :layout => :layout2 }
-    assert ok?
-    assert_equal "#scss {\n  background-color: white; }\n", body
-  end
-
-  it "raises error if template not found" do
-    mock_app { get('/') { scss(:no_such_template) } }
-    assert_raises(Errno::ENOENT) { get('/') }
-  end
-
-  it "passes scss options to the scss engine" do
-    scss_app do
-      scss(
-        "#scss {\n  background-color: white;\n  color: black\n}",
-        :style => :compact
-      )
-    end
-    assert ok?
-    assert_equal "#scss { background-color: white; color: black; }\n", body
-  end
-
-  it "passes default scss options to the scss engine" do
-    mock_app do
-      set :scss, {:style => :compact} # default scss style is :nested
-      get('/') {
-        scss("#scss {\n  background-color: white;\n  color: black;\n}")
-      }
-    end
-    get '/'
-    assert ok?
-    assert_equal "#scss { background-color: white; color: black; }\n", body
-  end
-end
-
-rescue LoadError
-  warn "#{$!.to_s}: skipping scss tests"
-end

data/test/server_test.rb

@@ -1,56 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'stringio'
-
-module Rack::Handler
-  class Mock
-    extend Minitest::Assertions
-    # Allow assertions in request context
-    def self.assertions
-      @assertions ||= 0
-    end
-
-    def self.assertions= assertions
-      @assertions = assertions
-    end
-
-    def self.run(app, options={})
-      assert(app < Sinatra::Base)
-      assert_equal 9001, options[:Port]
-      assert_equal 'foo.local', options[:Host]
-      yield new
-    end
-
-    def stop
-    end
-  end
-
-  register 'mock', 'Rack::Handler::Mock'
-end
-
-class ServerTest < Minitest::Test
-  setup do
-    mock_app do
-      set :server, 'mock'
-      set :bind, 'foo.local'
-      set :port, 9001
-    end
-    $stderr = StringIO.new
-  end
-
-  def teardown
-    $stderr = STDERR
-  end
-
-  it "locates the appropriate Rack handler and calls ::run" do
-    @app.run!
-  end
-
-  it "sets options on the app before running" do
-    @app.run! :sessions => true
-    assert @app.sessions?
-  end
-
-  it "falls back on the next server handler when not found" do
-    @app.run! :server => %w[foo bar mock]
-  end
-end

data/test/settings_test.rb

@@ -1,582 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class SettingsTest < Minitest::Test
-  setup do
-    @base = Sinatra.new(Sinatra::Base)
-    @base.set :environment => :foo, :app_file => nil
-
-    @application = Sinatra.new(Sinatra::Application)
-    @application.set :environment => :foo, :app_file => nil
-  end
-
-  it 'sets settings to literal values' do
-    @base.set(:foo, 'bar')
-    assert @base.respond_to?(:foo)
-    assert_equal 'bar', @base.foo
-  end
-
-  it 'sets settings to Procs' do
-    @base.set(:foo, Proc.new { 'baz' })
-    assert @base.respond_to?(:foo)
-    assert_equal 'baz', @base.foo
-  end
-
-  it 'sets settings using a block' do
-    @base.set(:foo){ 'baz' }
-    assert @base.respond_to?(:foo)
-    assert_equal 'baz', @base.foo
-  end
-
-  it 'raises an error with a value and a block' do
-    assert_raises ArgumentError do
-      @base.set(:fiz, 'boom!'){ 'baz' }
-    end
-    assert !@base.respond_to?(:fiz)
-  end
-
-  it 'raises an error without value and block' do
-    assert_raises(ArgumentError) { @base.set(:fiz) }
-    assert !@base.respond_to?(:fiz)
-  end
-
-  it 'allows setting a value to the app class' do
-    @base.set :base, @base
-    assert @base.respond_to?(:base)
-    assert_equal @base, @base.base
-  end
-
-  it 'raises an error with the app class as value and a block' do
-    assert_raises ArgumentError do
-      @base.set(:fiz, @base) { 'baz' }
-    end
-    assert !@base.respond_to?(:fiz)
-  end
-
-  it "sets multiple settings 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 'sets multiple settings using #each' do
-    @base.set [["foo", "bar"]]
-    assert_equal "bar", @base.foo
-  end
-
-  it 'inherits settings 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 settings 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 'merges values of multiple set calls if those are hashes' do
-    @base.set :foo, :a => 1
-    sub = Class.new(@base)
-    sub.set :foo, :b => 2
-    assert_equal({:a => 1, :b => 2}, sub.foo)
-  end
-
-  it 'merging does not affect the superclass' do
-    @base.set :foo, :a => 1
-    sub = Class.new(@base)
-    sub.set :foo, :b => 2
-    assert_equal({:a => 1}, @base.foo)
-  end
-
-  it 'is possible to change a value from a hash to something else' do
-    @base.set :foo, :a => 1
-    @base.set :foo, :bar
-    assert_equal(:bar, @base.foo)
-  end
-
-  it 'merges values with values of the superclass if those are hashes' do
-    @base.set :foo, :a => 1
-    @base.set :foo, :b => 2
-    assert_equal({:a => 1, :b => 2}, @base.foo)
-  end
-
-  it "sets multiple settings to true with #enable" do
-    @base.enable :sessions, :foo, :bar
-    assert @base.sessions
-    assert @base.foo
-    assert @base.bar
-  end
-
-  it "sets multiple settings to false with #disable" do
-    @base.disable :sessions, :foo, :bar
-    assert !@base.sessions
-    assert !@base.foo
-    assert !@base.bar
-  end
-
-  it 'is accessible from instances via #settings' do
-    assert_equal :foo, @base.new!.settings.environment
-  end
-
-  it 'is accessible from class via #settings' do
-    assert_equal :foo, @base.settings.environment
-  end
-
-  describe 'methodoverride' do
-    it 'is disabled on Base' do
-      assert ! @base.method_override?
-    end
-
-    it 'is enabled on Application' do
-      assert @application.method_override?
-    end
-
-    it 'enables MethodOverride middleware' do
-      @base.set :method_override, true
-      @base.put('/') { 'okay' }
-      @app = @base
-      post '/', {'_method'=>'PUT'}, {}
-      assert_equal 200, status
-      assert_equal 'okay', body
-    end
-
-    it 'is backward compatible with methodoverride' do
-      assert ! @base.methodoverride?
-      @base.enable :methodoverride
-      assert @base.methodoverride?
-    end
-  end
-
-  describe 'run' do
-    it 'is disabled on Base' do
-      assert ! @base.run?
-    end
-
-    it 'is enabled on Application except in test environment' do
-      assert @application.run?
-
-      @application.set :environment, :test
-      assert ! @application.run?
-    end
-  end
-
-  describe 'raise_errors' do
-    it 'is enabled on Base only in test' do
-      assert ! @base.raise_errors?
-
-      @base.set(:environment, :test)
-      assert @base.raise_errors?
-    end
-
-    it 'is enabled on Application only in test' do
-      assert ! @application.raise_errors?
-
-      @application.set(:environment, :test)
-      assert @application.raise_errors?
-    end
-  end
-
-  describe 'show_exceptions' do
-    it 'is disabled on Base except under development' do
-      assert ! @base.show_exceptions?
-      @base.environment = :development
-      assert @base.show_exceptions?
-    end
-
-    it 'is disabled on Application except in development' do
-      assert ! @application.show_exceptions?
-
-      @application.set(:environment, :development)
-      assert @application.show_exceptions?
-    end
-
-    it 'returns a friendly 500' do
-      klass = Sinatra.new(Sinatra::Application)
-      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> setting")
-    end
-
-    it 'does not override app-specified error handling when set to :after_handler' do
-      ran = false
-      mock_app do
-        set :show_exceptions, :after_handler
-        error(RuntimeError) { ran = true }
-        get('/') { raise RuntimeError }
-      end
-
-      get '/'
-      assert_equal 500, status
-      assert ran
-    end
-
-    it 'does catch any other exceptions when set to :after_handler' do
-      ran = false
-      mock_app do
-        set :show_exceptions, :after_handler
-        error(RuntimeError) { ran = true }
-        get('/') { raise ArgumentError }
-      end
-
-      get '/'
-      assert_equal 500, status
-      assert !ran
-    end
-  end
-
-  describe 'dump_errors' do
-    it 'is disabled on Base in test' do
-      @base.environment = :test
-      assert ! @base.dump_errors?
-      @base.environment = :development
-      assert @base.dump_errors?
-      @base.environment = :production
-      assert @base.dump_errors?
-    end
-
-    it 'dumps exception with backtrace to rack.errors' do
-      klass = Sinatra.new(Sinatra::Application)
-
-      mock_app(klass) {
-        enable :dump_errors
-        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?("settings_test.rb")
-    end
-
-    it 'does not dump 404 errors' do
-      klass = Sinatra.new(Sinatra::Application)
-
-      mock_app(klass) {
-        enable :dump_errors
-        disable :raise_errors
-
-        error do
-          error = @env['rack.errors'].instance_variable_get(:@error)
-          error.rewind
-
-          error.read
-        end
-
-        get '/' do
-          raise Sinatra::NotFound
-        end
-      }
-
-      get '/'
-      assert !body.include?("NotFound") && !body.include?("settings_test.rb")
-    end
-  end
-
-  describe 'sessions' do
-    it 'is disabled on Base' do
-      assert ! @base.sessions?
-    end
-
-    it 'is disabled on Application' do
-      assert ! @application.sessions?
-    end
-  end
-
-  describe 'logging' do
-    it 'is disabled on Base' do
-      assert ! @base.logging?
-    end
-
-    it 'is enabled on Application except in test environment' do
-      assert @application.logging?
-
-      @application.set :environment, :test
-      assert ! @application.logging
-    end
-  end
-
-  describe 'static' do
-    it 'is disabled on Base by default' do
-      assert ! @base.static?
-    end
-
-    it 'is enabled on Base when public_folder is set and exists' do
-      @base.set :environment, :development
-      @base.set :public_folder, File.dirname(__FILE__)
-      assert @base.static?
-    end
-
-    it 'is enabled on Base when root is set and root/public_folder exists' do
-      @base.set :environment, :development
-      @base.set :root, File.dirname(__FILE__)
-      assert @base.static?
-    end
-
-    it 'is disabled on Application by default' do
-      assert ! @application.static?
-    end
-
-    it 'is enabled on Application when public_folder is set and exists' do
-      @application.set :environment, :development
-      @application.set :public_folder, File.dirname(__FILE__)
-      assert @application.static?
-    end
-
-    it 'is enabled on Application when root is set and root/public_folder exists' do
-      @application.set :environment, :development
-      @application.set :root, File.dirname(__FILE__)
-      assert @application.static?
-    end
-
-    it 'is possible to use Module#public' do
-      @base.send(:define_method, :foo) { }
-      @base.send(:private, :foo)
-      assert !@base.public_method_defined?(:foo)
-      @base.send(:public, :foo)
-      assert @base.public_method_defined?(:foo)
-    end
-
-    it 'is possible to use the keyword public in a sinatra app' do
-      app = Sinatra.new do
-        private
-        def priv; end
-        public
-        def pub; end
-      end
-      assert !app.public_method_defined?(:priv)
-      assert app.public_method_defined?(:pub)
-    end
-  end
-
-  describe 'bind' do
-    it 'defaults to 0.0.0.0' do
-      assert_equal '0.0.0.0', @base.bind
-      assert_equal '0.0.0.0', @application.bind
-    end
-  end
-
-  describe 'port' do
-    it 'defaults to 4567' do
-      assert_equal 4567, @base.port
-      assert_equal 4567, @application.port
-    end
-  end
-
-  describe 'server' do
-    it 'includes webrick' do
-      assert @base.server.include?('webrick')
-      assert @application.server.include?('webrick')
-    end
-
-    it 'includes puma' do
-      assert @base.server.include?('puma')
-      assert @application.server.include?('puma')
-    end
-
-    it 'includes thin' do
-      next if RUBY_ENGINE == 'jruby'
-      assert @base.server.include?('thin')
-      assert @application.server.include?('thin')
-    end
-  end
-
-  describe 'app_file' do
-    it 'is nil for base classes' do
-      assert_nil Sinatra::Base.app_file
-      assert_nil Sinatra::Application.app_file
-    end
-
-    it 'defaults to the file subclassing' do
-      assert_equal File.expand_path(__FILE__), Sinatra.new.app_file
-    end
-  end
-
-  describe 'root' do
-    it 'is nil if app_file is not set' do
-      assert @base.root.nil?
-      assert @application.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
-
-      @application.app_file = __FILE__
-      assert_equal File.expand_path(File.dirname(__FILE__)), @application.root
-    end
-  end
-
-  describe 'views' do
-    it 'is nil if root is not set' do
-      assert @base.views.nil?
-      assert @application.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
-
-      @application.root = File.dirname(__FILE__)
-      assert_equal File.dirname(__FILE__) + "/views", @application.views
-    end
-  end
-
-  describe 'public_folder' do
-    it 'is nil if root is not set' do
-      assert @base.public_folder.nil?
-      assert @application.public_folder.nil?
-    end
-
-    it 'is set to root joined with public/' do
-      @base.root = File.dirname(__FILE__)
-      assert_equal File.dirname(__FILE__) + "/public", @base.public_folder
-
-      @application.root = File.dirname(__FILE__)
-      assert_equal File.dirname(__FILE__) + "/public", @application.public_folder
-    end
-  end
-
-  describe 'public_dir' do
-    it 'is an alias for public_folder' do
-      @base.public_dir = File.dirname(__FILE__)
-      assert_equal File.dirname(__FILE__), @base.public_dir
-      assert_equal @base.public_folder, @base.public_dir
-
-      @application.public_dir = File.dirname(__FILE__)
-      assert_equal File.dirname(__FILE__), @application.public_dir
-      assert_equal @application.public_folder, @application.public_dir
-    end
-  end
-
-  describe 'lock' do
-    it 'is disabled by default' do
-      assert ! @base.lock?
-      assert ! @application.lock?
-    end
-  end
-
-  describe 'protection' do
-    class MiddlewareTracker < Rack::Builder
-      def self.track
-        Rack.send :remove_const, :Builder
-        Rack.const_set :Builder, MiddlewareTracker
-        MiddlewareTracker.used.clear
-        yield
-      ensure
-        Rack.send :remove_const, :Builder
-        Rack.const_set :Builder, MiddlewareTracker.superclass
-      end
-
-      def self.used
-        @used ||= []
-      end
-
-      def use(middleware, *)
-        MiddlewareTracker.used << middleware
-        super
-      end
-    end
-
-    it 'sets up Rack::Protection' do
-      MiddlewareTracker.track do
-        Sinatra::Base.new
-        assert_include MiddlewareTracker.used, Rack::Protection
-      end
-    end
-
-    it 'sets up Rack::Protection::PathTraversal' do
-      MiddlewareTracker.track do
-        Sinatra::Base.new
-        assert_include MiddlewareTracker.used, Rack::Protection::PathTraversal
-      end
-    end
-
-    it 'does not set up Rack::Protection::PathTraversal when disabling it' do
-      MiddlewareTracker.track do
-        Sinatra.new { set :protection, :except => :path_traversal }.new
-        assert_include MiddlewareTracker.used, Rack::Protection
-        assert !MiddlewareTracker.used.include?(Rack::Protection::PathTraversal)
-      end
-    end
-
-    it 'sets up RemoteToken if sessions are enabled' do
-      MiddlewareTracker.track do
-        Sinatra.new { enable :sessions }.new
-        assert_include MiddlewareTracker.used, Rack::Protection::RemoteToken
-      end
-    end
-
-    it 'does not set up RemoteToken if sessions are disabled' do
-      MiddlewareTracker.track do
-        Sinatra.new.new
-        assert !MiddlewareTracker.used.include?(Rack::Protection::RemoteToken)
-      end
-    end
-
-    it 'sets up RemoteToken if it is configured to' do
-      MiddlewareTracker.track do
-        Sinatra.new { set :protection, :session => true }.new
-        assert_include MiddlewareTracker.used, Rack::Protection::RemoteToken
-      end
-    end
-  end
-end