middleman 2.0.7 → 2.0.8

data/lib/middleman/vendor/padrino-core-0.10.0/test/test_logger.rb

@@ -1,91 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-class TestPadrinoLogger < Test::Unit::TestCase
-
-  def setup
-    Padrino::Logger::Config[:test][:stream] = :null # The default
-    Padrino::Logger.setup!
-  end
-
-  def setup_logger(options={})
-    @log    = StringIO.new
-    @logger = Padrino::Logger.new(options.merge(:stream => @log))
-  end
-
-  context 'for logger functionality' do
-
-    context 'check stream config' do
-
-      should 'use stdout if stream is nil' do
-        Padrino::Logger::Config[:test][:stream] = nil
-        Padrino::Logger.setup!
-        assert_equal $stdout, Padrino.logger.log
-      end
-
-      should 'use StringIO as default for test' do
-        assert_instance_of StringIO, Padrino.logger.log
-      end
-
-      should 'use a custom stream' do
-        my_stream = StringIO.new
-        Padrino::Logger::Config[:test][:stream] = my_stream
-        Padrino::Logger.setup!
-        assert_equal my_stream, Padrino.logger.log
-      end
-    end
-
-    should 'log something' do
-      setup_logger(:log_level => :error)
-      @logger.error "You log this error?"
-      assert_match(/You log this error?/, @log.string)
-      @logger.debug "You don't log this error!"
-      assert_no_match(/You don't log this error!/, @log.string)
-      @logger << "Yep this can be logged"
-      assert_match(/Yep this can be logged/, @log.string)
-    end
-
-    should 'respond to #write for Rack::CommonLogger' do
-      setup_logger(:log_level => :error)
-      @logger.error "Error message"
-      assert_match /Error message/, @log.string
-      @logger << "logged anyways"
-      assert_match /logged anyways/, @log.string
-      @logger.write "log via alias"
-      assert_match /log via alias/, @log.string
-    end
-
-    should 'log an application' do
-      mock_app do
-        enable :logging
-        get("/"){ "Foo" }
-      end
-      get "/"
-      assert_equal "Foo", body
-      assert_match /GET/, Padrino.logger.log.string
-    end
-
-    context "static asset logging" do
-      should 'not log static assets by default' do
-        mock_app do
-          enable :logging
-          get("/images/something.png"){ env["sinatra.static_file"] = '/public/images/something.png'; "Foo" }
-        end
-        get "/images/something.png"
-        assert_equal "Foo", body
-        assert_match "", Padrino.logger.log.string
-      end
-
-      should 'allow turning on static assets logging' do
-        Padrino.logger.instance_eval{ @log_static = true }
-        mock_app do
-          enable :logging
-          get("/images/something.png"){ env["sinatra.static_file"] = '/public/images/something.png'; "Foo" }
-        end
-        get "/images/something.png"
-        assert_equal "Foo", body
-        assert_match /GET/, Padrino.logger.log.string
-        Padrino.logger.instance_eval{ @log_static = false }
-      end
-    end
-  end
-end

data/lib/middleman/vendor/padrino-core-0.10.0/test/test_mounter.rb

@@ -1,176 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-class TestMounter < Test::Unit::TestCase
-
-  def setup
-    $VERBOSE, @_verbose_was = nil, $VERBOSE
-    Padrino.clear!
-  end
-
-  def teardown
-    $VERBOSE = @_verbose_was
-  end
-
-  context 'for mounter functionality' do
-
-    should 'check methods' do
-      mounter = Padrino::Mounter.new("test", :app_file => "/path/to/test.rb")
-      mounter.to("/test")
-      assert_kind_of Padrino::Mounter, mounter
-      assert_respond_to Padrino::Mounter, :new
-      assert_respond_to mounter, :to
-      assert_respond_to mounter, :map_onto
-      assert_equal "test", mounter.name
-      assert_equal "Test", mounter.app_class
-      assert_equal "/path/to/test.rb", mounter.app_file
-      assert_equal "/test", mounter.uri_root
-      assert_equal File.dirname(mounter.app_file), mounter.app_root
-    end
-
-    should 'check locate_app_file with __FILE__' do
-      mounter = Padrino::Mounter.new("test", :app_file => __FILE__)
-      mounter.to("/test")
-      assert_equal "test", mounter.name
-      assert_equal "Test", mounter.app_class
-      assert_equal __FILE__, mounter.app_file
-      assert_equal "/test", mounter.uri_root
-      assert_equal File.dirname(mounter.app_file), mounter.app_root
-    end
-
-    should 'mount an app' do
-      class ::AnApp < Padrino::Application; end
-      Padrino.mount("an_app").to("/")
-      assert_equal AnApp, Padrino.mounted_apps.first.app_obj
-      assert_equal ["an_app"], Padrino.mounted_apps.map(&:name)
-    end
-
-    should 'correctly mount an app in a namespace' do
-      module ::SomeNamespace
-        class AnApp < Padrino::Application; end
-      end
-      Padrino.mount("some_namespace/an_app").to("/")
-      assert_equal SomeNamespace::AnApp, Padrino.mounted_apps.first.app_obj
-      assert_equal ["some_namespace/an_app"], Padrino.mounted_apps.map(&:name)
-    end
-
-    should 'mount a primary app to root uri' do
-      mounter = Padrino.mount("test", :app_file => __FILE__).to("/")
-      assert_equal "test", mounter.name
-      assert_equal "Test", mounter.app_class
-      assert_equal Test, mounter.app_obj
-      assert_equal __FILE__, mounter.app_file
-      assert_equal "/", mounter.uri_root
-      assert_equal File.dirname(mounter.app_file), mounter.app_root
-    end
-
-    should 'mount a primary app to sub_uri' do
-      mounter = Padrino.mount("test", :app_file => __FILE__).to('/me')
-      assert_equal "test", mounter.name
-      assert_equal "Test", mounter.app_class
-      assert_equal Test, mounter.app_obj
-      assert_equal __FILE__, mounter.app_file
-      assert_equal "/me", mounter.uri_root
-      assert_equal File.dirname(mounter.app_file), mounter.app_root
-    end
-
-    should "raise error when app has no located file" do
-      assert_raise(Padrino::Mounter::MounterException) { Padrino.mount("tester_app").to('/test') }
-      assert_equal 0, Padrino.mounted_apps.size
-    end
-
-    should "raise error when app has no located object" do
-      assert_raise(Padrino::Mounter::MounterException) { Padrino.mount("tester_app", :app_file => "/path/to/file.rb").to('/test') }
-      assert_equal 0, Padrino.mounted_apps.size
-    end
-
-    should 'mount multiple apps' do
-      class ::OneApp < Padrino::Application; end
-      class ::TwoApp < Padrino::Application; end
-
-      Padrino.mount("one_app").to("/one_app")
-      Padrino.mount("two_app").to("/two_app")
-      # And testing no duplicates
-      Padrino.mount("one_app").to("/one_app")
-      Padrino.mount("two_app").to("/two_app")
-
-      assert_equal OneApp, Padrino.mounted_apps[0].app_obj
-      assert_equal TwoApp, Padrino.mounted_apps[1].app_obj
-      assert_equal 2, Padrino.mounted_apps.size, "should not mount duplicate apps"
-      assert_equal ["one_app", "two_app"], Padrino.mounted_apps.map(&:name)
-    end
-
-    should 'change mounted_root' do
-      Padrino.mounted_root = "fixtures"
-      assert_equal Padrino.root("fixtures", "test", "app.rb"), Padrino.mounted_root("test", "app.rb")
-      Padrino.mounted_root = "apps"
-      assert_equal Padrino.root("apps", "test", "app.rb"), Padrino.mounted_root("test", "app.rb")
-      Padrino.mounted_root = nil
-      assert_equal Padrino.root("test", "app.rb"), Padrino.mounted_root("test", "app.rb")
-    end
-
-    should "be able to access routes data for mounted apps" do
-      class ::OneApp < Padrino::Application
-        get("/test") { "test" }
-        get(:index, :provides => [:js, :json]) { "index" }
-        controllers :posts do
-          get(:index) { "index" }
-          get(:new, :provides => :js) { "new" }
-          get(:show, :provides => [:js, :html], :with => :id) { "show" }
-          post(:create, :provides => :js, :with => :id) { "create" }
-        end
-      end
-      class ::TwoApp < Padrino::Application
-        controllers :users do
-          get(:index) { "users" }
-          get(:new) { "users new" }
-          post(:create) { "users create" }
-          put(:update) { "users update" }
-          delete(:destroy) { "users delete" }
-        end
-      end
-
-      Padrino.mount("one_app").to("/")
-      Padrino.mount("two_app").to("/two_app")
-
-      assert_equal 11, Padrino.mounted_apps[0].routes.size
-      assert_equal 7, Padrino.mounted_apps[1].routes.size
-      assert_equal 5, Padrino.mounted_apps[0].named_routes.size
-      assert_equal 5, Padrino.mounted_apps[1].named_routes.size
-
-      first_route = Padrino.mounted_apps[0].named_routes[3]
-      assert_equal "posts_show", first_route.identifier.to_s
-      assert_equal "(:posts, :show)", first_route.name
-      assert_equal "GET", first_route.verb
-      assert_equal "/posts/show/:id(.:format)", first_route.path
-      another_route = Padrino.mounted_apps[1].named_routes[2]
-      assert_equal "users_create", another_route.identifier.to_s
-      assert_equal "(:users, :create)", another_route.name
-      assert_equal "POST", another_route.verb
-      assert_equal "/two_app/users/create", another_route.path
-    end
-
-    should 'correctly instantiate a new padrino application' do
-      mock_app do
-        get("/demo_1"){ "Im Demo 1" }
-        get("/demo_2"){ "Im Demo 2" }
-      end
-
-      get '/demo_1'
-      assert_equal "Im Demo 1", body
-      get '/demo_2'
-      assert_equal "Im Demo 2", body
-    end
-
-    should "not clobber the public setting when mounting an app" do
-      class ::PublicApp < Padrino::Application
-        set :root, "/root"
-        set :public, File.expand_path(File.dirname(__FILE__))
-      end
-
-      Padrino.mount("public_app").to("/public")
-      res = Rack::MockRequest.new(Padrino.application).get("/public/test_mounter.rb")
-      assert res.ok?
-      assert_equal File.read(__FILE__), res.body
-    end
-  end
-end

data/lib/middleman/vendor/padrino-core-0.10.0/test/test_reloader_complex.rb

@@ -1,66 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-require File.expand_path(File.dirname(__FILE__) + '/fixtures/apps/complex')
-
-class TestComplexReloader < Test::Unit::TestCase
-
-  context 'for complex reload functionality' do
-
-    should 'correctly instantiate Complex(1-2)Demo fixture' do
-      Padrino.clear!
-      Padrino.mount("complex_1_demo").to("/complex_1_demo")
-      Padrino.mount("complex_2_demo").to("/complex_2_demo")
-      assert_equal ["/complex_1_demo", "/complex_2_demo"], Padrino.mounted_apps.map(&:uri_root)
-      assert_equal ["complex_1_demo", "complex_2_demo"], Padrino.mounted_apps.map(&:name)
-      assert Complex1Demo.reload?
-      assert Complex2Demo.reload?
-      assert_match %r{fixtures/apps/complex.rb}, Complex1Demo.app_file
-      assert_match %r{fixtures/apps/complex.rb}, Complex2Demo.app_file
-    end
-
-    should 'correctly reload Complex(1-2)Demo fixture' do
-      assert_match %r{fixtures/apps/complex.rb}, Complex1Demo.app_file
-      @app = Padrino.application
-
-      get "/"
-      assert_equal 404, status
-
-      get "/complex_1_demo"
-      assert_equal "Given random #{LibDemo.give_me_a_random}", body
-
-      get "/complex_2_demo"
-      assert_equal 200, status
-
-      get "/complex_1_demo/old"
-      assert_equal 200, status
-
-      get "/complex_2_demo/old"
-      assert_equal 200, status
-
-      new_phrase = "The magick number is: #{rand(2**255)}!"
-      buffer     = File.read(Complex1Demo.app_file)
-      new_buffer = buffer.gsub(/The magick number is: \d+!/, new_phrase)
-      begin
-        File.open(Complex1Demo.app_file, "w") { |f| f.write(new_buffer) }
-        sleep 1.2 # We need at least a cooldown of 1 sec.
-        get "/complex_2_demo"
-        assert_equal new_phrase, body
-
-        # Re-Check that we didn't forget any route
-        get "/complex_1_demo"
-        assert_equal "Given random #{LibDemo.give_me_a_random}", body
-
-        get "/complex_2_demo"
-        assert_equal 200, status
-
-        get "/complex_1_demo/old"
-        assert_equal 200, status
-
-        get "/complex_2_demo/old"
-        assert_equal 200, status
-      ensure
-        # Now we need to prevent to commit a new changed file so we revert it
-        File.open(Complex1Demo.app_file, "w") { |f| f.write(buffer) }
-      end
-    end
-  end
-end

data/lib/middleman/vendor/padrino-core-0.10.0/test/test_reloader_simple.rb

@@ -1,97 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-require File.expand_path(File.dirname(__FILE__) + '/fixtures/apps/simple')
-
-class TestSimpleReloader < Test::Unit::TestCase
-
-  context 'for simple reset functionality' do
-
-    should 'reset routes' do
-      mock_app do
-        (1..10).each do |i|
-          get("/#{i}") { "Foo #{i}" }
-        end
-      end
-      (1..10).each do |i|
-        get "/#{i}"
-        assert_equal "Foo #{i}", body
-      end
-      @app.reset_routes!
-      (1..10).each do |i|
-        get "/#{i}"
-        assert_equal 404, status
-      end
-    end
-
-    should 'keep sinatra routes on development' do
-      mock_app do
-        set :environment, :development
-        get("/"){ "ok" }
-      end
-      assert_equal :development, @app.environment
-      get "/"
-      assert_equal 200, status
-      get "/__sinatra__/404.png"
-      assert_equal 200, status
-      assert_match /image\/png/, response["Content-Type"]
-      @app.reset_routes!
-      get "/"
-      assert_equal 404, status
-      get "/__sinatra__/404.png"
-      assert_equal 200, status
-      assert_match /image\/png/, response["Content-Type"]
-    end
-  end
-
-  context 'for simple reload functionality' do
-
-    should 'correctly instantiate SimpleDemo fixture' do
-      Padrino.clear!
-      Padrino.mount("simple_demo").to("/")
-      assert_equal ["simple_demo"], Padrino.mounted_apps.map(&:name)
-      assert SimpleDemo.reload?
-      assert_match %r{fixtures/apps/simple.rb}, SimpleDemo.app_file
-    end
-
-    should 'correctly reload SimpleDemo fixture' do
-      @app = SimpleDemo
-      get "/"
-      assert ok?
-      new_phrase = "The magick number is: #{rand(2**255)}!"
-      buffer     = File.read(SimpleDemo.app_file)
-      new_buffer = buffer.gsub(/The magick number is: \d+!/, new_phrase)
-      File.open(SimpleDemo.app_file, "w") { |f| f.write(new_buffer) }
-      sleep 1.2 # We need at least a cooldown of 1 sec.
-      get "/"
-      assert_equal new_phrase, body
-
-      # Now we need to prevent to commit a new changed file so we revert it
-      File.open(SimpleDemo.app_file, "w") { |f| f.write(buffer) }
-      Padrino.reload!
-    end
-
-    should 'correctly reset SimpleDemo fixture' do
-      @app = SimpleDemo
-      @app.reload!
-      get "/rand"
-      assert ok?
-      last_body = body
-      assert_equal 2, @app.filters[:before].size # one is ours the other is default_filter for content type
-      assert_equal 1, @app.errors.size
-      assert_equal 1, @app.filters[:after].size
-      assert_equal 1, @app.middleware.size # [Padrino::Reloader::Rack]
-      assert_equal 4, @app.routes.size # GET+HEAD of "/" + GET+HEAD of "/rand" = 4
-      assert_equal 2, @app.extensions.size # [Padrino::Routing, Padrino::Rendering]
-      assert_equal 0, @app.templates.size
-      @app.reload!
-      get "/rand"
-      assert_not_equal last_body, body
-      assert_equal 2, @app.filters[:before].size # one is ours the other is default_filter for content type
-      assert_equal 1, @app.errors.size
-      assert_equal 1, @app.filters[:after].size
-      assert_equal 1, @app.middleware.size
-      assert_equal 4, @app.routes.size # GET+HEAD of "/" = 2
-      assert_equal 2, @app.extensions.size # [Padrino::Routing, Padrino::Rendering]
-      assert_equal 0, @app.templates.size
-    end
-  end
-end

data/lib/middleman/vendor/padrino-core-0.10.0/test/test_rendering.rb

@@ -1,437 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-require 'i18n'
-
-class TestRendering < Test::Unit::TestCase
-  def setup
-    Padrino::Application.send(:register, Padrino::Rendering)
-  end
-
-  def teardown
-    remove_views
-  end
-
-  context 'for application layout functionality' do
-
-    should 'get no layout' do
-      mock_app do
-        get("/"){ "no layout" }
-      end
-
-      get "/"
-      assert_equal "no layout", body
-    end
-
-    should 'be compatible with sinatra layout' do
-      mock_app do
-        layout do
-          "this is a <%= yield %>"
-        end
-
-        get("/"){ render :erb, "sinatra layout" }
-      end
-
-      get "/"
-      assert_equal "this is a sinatra layout", body
-    end
-
-    should 'use rails way layout' do
-      with_layout :application, "this is a <%= yield %>" do
-        mock_app do
-          get("/"){ render :erb, "rails way layout" }
-        end
-
-        get "/"
-        assert_equal "this is a rails way layout", body
-      end
-    end
-
-    should 'use rails way for a custom layout' do
-      with_layout "layouts/custom", "this is a <%= yield %>" do
-        mock_app do
-          layout :custom
-          get("/"){ render :erb, "rails way custom layout" }
-        end
-
-        get "/"
-        assert_equal "this is a rails way custom layout", body
-      end
-    end
-
-    should 'not use layout' do
-      with_layout :application, "this is a <%= yield %>" do
-        with_view :index, "index" do
-          mock_app do
-            get("/with/layout"){ render :index }
-            get("/without/layout"){ render :index, :layout => false }
-          end
-          get "/with/layout"
-          assert_equal "this is a index", body
-          get "/without/layout"
-          assert_equal "index", body
-        end
-      end
-    end
-
-    should 'not use layout with js format' do
-      create_layout :application, "this is an <%= yield %>"
-      create_view :foo, "erb file"
-      create_view :foo, "js file", :format => :js
-      mock_app do
-        get('/layout_test', :provides => [:html, :js]){ render :foo }
-      end
-      get "/layout_test"
-      assert_equal "this is an erb file", body
-      get "/layout_test.js"
-      assert_equal "js file", body
-    end
-
-    should 'use correct layout for each format' do
-      create_layout :application, "this is an <%= yield %>"
-      create_layout :application, "document start <%= yield %> end", :format => :xml
-      create_view :foo, "erb file"
-      create_view :foo, "xml file", :format => :xml
-      mock_app do
-        get('/layout_test', :provides => [:html, :xml]){ render :foo }
-      end
-      get "/layout_test"
-      assert_equal "this is an erb file", body
-      get "/layout_test.xml"
-      assert_equal "document start xml file end", body
-    end
-
-    should 'by default use html file when no other is given' do
-      create_layout :foo, "html file", :format => :html
-
-      mock_app do
-        get('/content_type_test', :provides => [:html, :xml]) { render :foo }
-      end
-
-      get "/content_type_test"
-      assert_equal "html file", body
-      get "/content_type_test.xml"
-      assert_equal "html file", body
-    end
-
-    should 'not use html file when DEFAULT_RENDERING_OPTIONS[:strict_format] == true' do
-      create_layout :foo, "html file", :format => :html
-
-      mock_app do
-        get('/default_rendering_test', :provides => [:html, :xml]) { render :foo }
-      end
-
-      @save = Padrino::Rendering::DEFAULT_RENDERING_OPTIONS
-      Padrino::Rendering::DEFAULT_RENDERING_OPTIONS[:strict_format] = true
-
-      get "/default_rendering_test"
-      assert_equal "html file", body
-      assert_raise Padrino::Rendering::TemplateNotFound do
-        get "/default_rendering_test.xml"
-      end
-
-      Padrino::Rendering::DEFAULT_RENDERING_OPTIONS.merge(@save)
-    end
-
-    should 'use correct layout with each controller' do
-      create_layout :foo, "foo layout at <%= yield %>"
-      create_layout :bar, "bar layout at <%= yield %>"
-      create_layout :application, "default layout at <%= yield %>"
-      mock_app do
-        get("/"){ render :erb, "application" }
-        controller :foo do
-          layout :foo
-          get("/"){ render :erb, "foo" }
-        end
-        controller :bar do
-          layout :bar
-          get("/"){ render :erb, "bar" }
-        end
-        controller :none do
-          get("/") { render :erb, "none" }
-          get("/with_foo_layout")  { render :erb, "none with layout", :layout => :foo }
-        end
-      end
-      get "/foo"
-      assert_equal "foo layout at foo", body
-      get "/bar"
-      assert_equal "bar layout at bar", body
-      get "/none"
-      assert_equal "default layout at none", body
-      get "/none/with_foo_layout"
-      assert_equal "foo layout at none with layout", body
-      get "/"
-      assert_equal "default layout at application", body
-    end
-  end
-
-  should 'solve layout in layouts paths' do
-    create_layout :foo, "foo layout <%= yield %>"
-    create_layout :"layouts/bar", "bar layout <%= yield %>"
-    mock_app do
-      get("/") { render :erb, "none" }
-      get("/foo") { render :erb, "foo", :layout => :foo }
-      get("/bar") { render :erb, "bar", :layout => :bar }
-    end
-    get "/"
-    assert_equal "none", body
-    get "/foo"
-    assert_equal "foo layout foo", body
-    get "/bar"
-    assert_equal "bar layout bar", body
-  end
-
-  should 'render correctly if layout was not found or not exist' do
-    create_layout :application, "application layout for <%= yield %>"
-    create_view :foo, "index", :format => :html
-    create_view :foo, "xml.rss", :format => :rss
-    mock_app do
-      get("/foo", :provides => [:html, :rss]) { render('foo') }
-      get("/baz", :provides => :js) { render(:erb, 'baz') }
-      get("/bar") { render :haml, "haml" }
-    end
-    get "/foo"
-    assert_equal "application layout for index", body
-    get "/foo.rss"
-    assert_equal "<rss/>", body.chomp
-    get "/baz.js"
-    assert_equal "baz", body
-    get "/bar"
-    assert_equal "haml", body.chomp
-  end
-
-  context 'for application render functionality' do
-
-    should 'be compatible with sinatra render' do
-      mock_app do
-        get("/"){ render :erb, "<%= 1+2 %>" }
-      end
-      get "/"
-      assert_equal "3", body
-    end
-
-    should "support passing locals into render" do
-      create_layout :application, "layout <%= yield %>"
-      create_view :index, "<%= foo %>"
-      mock_app do
-        get("/") { render "index", { :layout => true }, { :foo => "bar" } }
-      end
-      get "/"
-      assert_equal "layout bar", body
-    end
-
-    should "support passing locals into sinatra render" do
-      create_layout :application, "layout <%= yield %>"
-      create_view :index, "<%= foo %>"
-      mock_app do
-        get("/") { render :erb, :index, { :layout => true }, { :foo => "bar" } }
-      end
-      get "/"
-      assert_equal "layout bar", body
-    end
-
-    should "support passing locals into special nil engine render" do
-      create_layout :application, "layout <%= yield %>"
-      create_view :index, "<%= foo %>"
-      mock_app do
-        get("/") { render nil, :index, { :layout => true }, { :foo => "bar" } }
-      end
-      get "/"
-      assert_equal "layout bar", body
-    end
-
-    should 'be compatible with sinatra views' do
-      with_view :index, "<%= 1+2 %>" do
-        mock_app do
-          get("/foo") { render :erb, :index }
-          get("/bar") { erb :index }
-          get("/dir") { "3" }
-          get("/inj") { erb "<%= 2+1 %>" }
-          get("/rnj") { render :erb, "<%= 2+1 %>" }
-        end
-        get "/foo"
-        assert_equal "3", body
-        get "/bar"
-        assert_equal "3", body
-        get "/dir"
-        assert_equal "3", body
-        get "/inj"
-        assert_equal "3", body
-        get "/rnj"
-        assert_equal "3", body
-      end
-    end
-
-    should 'resolve template engine' do
-      with_view :index, "<%= 1+2 %>" do
-        mock_app do
-          get("/foo") { render :index }
-          get("/bar") { render "/index" }
-        end
-        get "/foo"
-        assert_equal "3", body
-        get "/bar"
-        assert_equal "3", body
-      end
-    end
-
-    should 'resolve template content type' do
-      create_view :foo, "Im Js", :format => :js
-      create_view :foo, "Im Erb"
-      mock_app do
-        get("/foo", :provides => :js) { render :foo }
-        get("/bar.js") { render :foo }
-      end
-      get "/foo.js"
-      assert_equal "Im Js", body
-      # TODO: implement this!
-      # get "/bar.js"
-      # assert_equal "Im Js", body
-    end
-
-    should 'resolve with explicit template format' do
-      create_view :foo, "Im Js", :format => :js
-      create_view :foo, "Im Haml", :format => :haml
-      create_view :foo, "Im Xml", :format => :xml
-      mock_app do
-        get("/foo_normal", :provides => :js) { render 'foo' }
-        get("/foo_haml", :provides => :js) { render 'foo.haml' }
-        get("/foo_xml", :provides => :js) { render 'foo.xml' }
-      end
-      get "/foo_normal.js"
-      assert_equal "Im Js", body
-      get "/foo_haml.js"
-      assert_equal "Im Haml\n", body
-      get "/foo_xml.js"
-      assert_equal "Im Xml", body
-    end
-
-    should 'resolve without explict template format' do
-      create_view :foo, "Im Html"
-      create_view :foo, "xml.rss", :format => :rss
-      mock_app do
-        get(:index, :map => "/", :provides => [:html, :rss]){ render 'foo' }
-      end
-      get "/", {}, { 'HTTP_ACCEPT' => 'text/html;q=0.9' }
-      assert_equal "Im Html", body
-      get ".rss"
-      assert_equal "<rss/>\n", body
-    end
-
-    should "ignore files ending in tilde and not render them" do
-      create_view :foo, "Im Wrong", :format => 'haml~'
-      create_view :foo, "Im Haml",  :format => :haml
-      create_view :bar, "Im Haml backup", :format => 'haml~'
-      mock_app do
-        get('/foo') { render 'foo' }
-        get('/bar') { render 'bar' }
-      end
-      get '/foo'
-      assert_equal "Im Haml\n", body
-      assert_raises(Padrino::Rendering::TemplateNotFound) { get '/bar' }
-    end
-
-    should 'resolve template locale' do
-      create_view :foo, "Im English", :locale => :en
-      create_view :foo, "Im Italian", :locale => :it
-      mock_app do
-        get("/foo") { render :foo }
-      end
-      I18n.locale = :en
-      get "/foo"
-      assert_equal "Im English", body
-      I18n.locale = :it
-      get "/foo"
-      assert_equal "Im Italian", body
-    end
-
-    should 'resolve template content_type and locale' do
-      create_view :foo, "Im Js",          :format => :js
-      create_view :foo, "Im Erb"
-      create_view :foo, "Im English Erb", :locale => :en
-      create_view :foo, "Im Italian Erb", :locale => :it
-      create_view :foo, "Im English Js",  :format => :js, :locale => :en
-      create_view :foo, "Im Italian Js",  :format => :js, :locale => :it
-      mock_app do
-        get("/foo", :provides => [:html, :js]) { render :foo }
-      end
-      I18n.locale = :none
-      get "/foo.js"
-      assert_equal "Im Js", body
-      get "/foo"
-      assert_equal "Im Erb", body
-      I18n.locale = :en
-      get "/foo"
-      assert_equal "Im English Erb", body
-      I18n.locale = :it
-      get "/foo"
-      assert_equal "Im Italian Erb", body
-      I18n.locale = :en
-      get "/foo.js"
-      assert_equal "Im English Js", body
-      I18n.locale = :it
-      get "/foo.js"
-      assert_equal "Im Italian Js", body
-      I18n.locale = :en
-      get "/foo.pk"
-      assert_equal 405, status
-    end
-
-    should 'resolve template content_type and locale with layout' do
-      create_layout :foo, "Hello <%= yield %> in a Js layout",     :format => :js
-      create_layout :foo, "Hello <%= yield %> in a Js-En layout",  :format => :js, :locale => :en
-      create_layout :foo, "Hello <%= yield %> in a Js-It layout",  :format => :js, :locale => :it
-      create_layout :foo, "Hello <%= yield %> in a Erb-En layout", :locale => :en
-      create_layout :foo, "Hello <%= yield %> in a Erb-It layout", :locale => :it
-      create_layout :foo, "Hello <%= yield %> in a Erb layout"
-      create_view   :bar, "Im Js",          :format => :js
-      create_view   :bar, "Im Erb"
-      create_view   :bar, "Im English Erb", :locale => :en
-      create_view   :bar, "Im Italian Erb", :locale => :it
-      create_view   :bar, "Im English Js",  :format => :js, :locale => :en
-      create_view   :bar, "Im Italian Js",  :format => :js, :locale => :it
-      create_view   :bar, "Im a json",      :format => :json
-      mock_app do
-        layout :foo
-        get("/bar", :provides => [:html, :js, :json]) { render :bar }
-      end
-      I18n.locale = :none
-      get "/bar.js"
-      assert_equal "Hello Im Js in a Js layout", body
-      get "/bar"
-      assert_equal "Hello Im Erb in a Erb layout", body
-      I18n.locale = :en
-      get "/bar"
-      assert_equal "Hello Im English Erb in a Erb-En layout", body
-      I18n.locale = :it
-      get "/bar"
-      assert_equal "Hello Im Italian Erb in a Erb-It layout", body
-      I18n.locale = :en
-      get "/bar.js"
-      assert_equal "Hello Im English Js in a Js-En layout", body
-      I18n.locale = :it
-      get "/bar.js"
-      assert_equal "Hello Im Italian Js in a Js-It layout", body
-      I18n.locale = :en
-      get "/bar.json"
-      assert_equal "Im a json", body
-      get "/bar.pk"
-      assert_equal 405, status
-    end
-
-    should 'renders erb with blocks' do
-      mock_app do
-        def container
-          @_out_buf << "THIS."
-          yield
-          @_out_buf << "SPARTA!"
-        end
-        def is; "IS."; end
-        get '/' do
-          render :erb, '<% container do %> <%= is %> <% end %>'
-        end
-      end
-      get '/'
-      assert ok?
-      assert_equal 'THIS. IS. SPARTA!', body
-    end
-  end
-end