546 lines
17 KiB
Ruby
546 lines
17 KiB
Ruby
require File.expand_path(File.dirname(__FILE__) + '/helper')
|
|
require 'i18n'
|
|
require 'slim'
|
|
|
|
describe "Rendering" do
|
|
def setup
|
|
Padrino::Application.send(:register, Padrino::Rendering)
|
|
Padrino::Rendering::DEFAULT_RENDERING_OPTIONS[:strict_format] = false
|
|
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", :layout => true }
|
|
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 an <%= 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 an 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 :baz, "html file", :format => :html
|
|
|
|
mock_app do
|
|
get('/content_type_test', :provides => [:html, :xml]) { render :baz }
|
|
end
|
|
|
|
get "/content_type_test"
|
|
assert_equal "html file", body
|
|
get "/content_type_test.html"
|
|
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_raises 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 :baz, "baz 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 :baz do
|
|
layout :baz
|
|
get("/"){ render :erb, "baz", :layout => true }
|
|
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 "/baz"
|
|
assert_equal "baz layout at baz", 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 "work properly with logging and missing layout" do
|
|
create_view :index, "<%= foo %>"
|
|
mock_app do
|
|
enable :logging
|
|
get("/") { render "index", { :layout => nil }, { :foo => "bar" } }
|
|
end
|
|
get "/"
|
|
assert_equal "bar", body
|
|
end
|
|
|
|
should "work properly with logging and layout" do
|
|
create_layout :application, "layout <%= yield %>"
|
|
create_view :index, "<%= foo %>"
|
|
mock_app do
|
|
enable :logging
|
|
get("/") { render "index", { :layout => true }, { :foo => "bar" } }
|
|
end
|
|
get "/"
|
|
assert_equal "layout bar", body
|
|
end
|
|
|
|
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 404, 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 404, 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
|
|
|
|
should 'render erb to a SafeBuffer' do
|
|
mock_app do
|
|
layout do
|
|
"this is a <%= yield %>"
|
|
end
|
|
get '/' do
|
|
render :erb, '<p><%= %q{<script lang="ronin">alert("https://github.com/ronin-ruby/ronin")</script>} %></p>', :layout => false
|
|
end
|
|
get '/with_layout' do
|
|
render :erb, '<span>span</span>', :layout => true
|
|
end
|
|
end
|
|
get '/'
|
|
assert ok?
|
|
assert_equal '<p><script lang="ronin">alert("https://github.com/ronin-ruby/ronin")</script></p>', body
|
|
|
|
get '/with_layout'
|
|
assert ok?
|
|
assert_equal 'this is a <span>span</span>', body
|
|
end
|
|
|
|
should 'render haml to a SafeBuffer' do
|
|
mock_app do
|
|
layout do
|
|
"%p= yield"
|
|
end
|
|
get '/' do
|
|
render :haml, '%p= %s{<script lang="ronin">alert("https://github.com/ronin-ruby/ronin")</script>}', :layout => false
|
|
end
|
|
get '/with_layout' do
|
|
render :haml, "%div\n foo", :layout => true
|
|
end
|
|
end
|
|
get '/'
|
|
assert ok?
|
|
assert_equal '<p><script lang="ronin">alert("https://github.com/ronin-ruby/ronin")</script></p>', body.strip
|
|
|
|
get 'with_layout'
|
|
assert ok?
|
|
assert_equal '<p><div>foo</div></p>', body.gsub(/\s+/, "")
|
|
end
|
|
|
|
should 'render slim to a SafeBuffer' do
|
|
mock_app do
|
|
layout do
|
|
"p= yield"
|
|
end
|
|
get '/' do
|
|
render :slim, 'p = %q{<script lang="ronin">alert("https://github.com/ronin-ruby/ronin")</script>}', :layout => false
|
|
end
|
|
get "/with_layout" do
|
|
render :slim, 'div foo', :layout => true
|
|
end
|
|
end
|
|
get '/'
|
|
assert ok?
|
|
assert_equal '<p><script lang="ronin">alert("https://github.com/ronin-ruby/ronin")</script></p>', body.strip
|
|
|
|
get '/with_layout'
|
|
assert ok?
|
|
assert_equal '<p><div>foo</div></p>', body.strip
|
|
end
|
|
|
|
should "render correct erb when use sinatra as middleware" do
|
|
class Bar < Sinatra::Base
|
|
get "/" do
|
|
render :erb, "<&'>"
|
|
end
|
|
end
|
|
mock_app do
|
|
use Bar
|
|
end
|
|
get "/"
|
|
assert_equal "<&'>", body
|
|
end
|
|
end
|
|
end
|