Testando prestação de um determinado layout com RSpec & Rails
-
01-07-2019 - |
Pergunta
É possível testar o uso de um determinado layout usando RSpec com Rails, por exemplo, eu gostaria de um matcher que faz o seguinte:
response.should use_layout('my_layout_name')
Eu encontrei um matcher use_layout quando pesquisando, mas ele não funciona como nem a resposta ou controlador parecem ter uma propriedade layout que matcher estava procurando.
Solução
Eu encontrei um exemplo de como escrever um use_layout
correspondência que vai fazer exatamente isso. Aqui está o código em caso que apontam vai embora:
# in spec_helper.rb
class UseLayout
def initialize(expected)
@expected = 'layouts/' + expected
end
def matches?(controller)
@actual = controller.layout
#@actual.equal?(@expected)
@actual == @expected
end
def failure_message
return "use_layout expected #{@expected.inspect}, got #
{@actual.inspect}", @expected, @actual
end
def negeative_failure_message
return "use_layout expected #{@expected.inspect} not to equal #
{@actual.inspect}", @expected, @actual
end
end
def use_layout(expected)
UseLayout.new(expected)
end
# in controller spec
response.should use_layout("application")
Outras dicas
David Chelimsky postou uma resposta boa ao longo do href="http://www.ruby-forum.com/topic/216851" rel="noreferrer"> Rubi Fórum :
response.should render_template("layouts/some_layout")
Isso funciona para mim com Rails ponta e borda RSpec on Rails:
response.layout.should == 'layouts/application'
não deve ser difícil transformar isso em uma correspondência adequada para você.
Já existe uma correspondência perfeitamente funcional para isso:
response.should render_template(:layout => 'fooo')
(Rspec 2.6.4)
Eu tive que escrever o seguinte para fazer este trabalho:
response.should render_template("layouts/some_folder/some_layout", "template-name")
Aqui está uma versão atualizada da correspondência. Eu atualizei-lo em conformidade com a última versão do RSpec. Eu adicionei a leitura relevante apenas atributos e remover formato de retorno de idade.
# in spec_helper.rb
class UseLayout
attr_reader :expected
attr_reader :actual
def initialize(expected)
@expected = 'layouts/' + expected
end
def matches?(controller)
if controller.is_a?(ActionController::Base)
@actual = 'layouts/' + controller.class.read_inheritable_attribute(:layout)
else
@actual = controller.layout
end
@actual ||= "layouts/application"
@actual == @expected
end
def description
"Determines if a controller uses a layout"
end
def failure_message
return "use_layout expected #{@expected.inspect}, got #{@actual.inspect}"
end
def negeative_failure_message
return "use_layout expected #{@expected.inspect} not to equal #{@actual.inspect}"
end
end
def use_layout(expected)
UseLayout.new(expected)
end
Além disso, a correspondência agora também trabalha com layouts especificados no nível de classe do controlador e pode ser usado da seguinte maneira:
class PostsController < ApplicationController
layout "posts"
end
E na especificação controlador você pode simplesmente usar:
it { should use_layout("posts") }
Aqui está a solução que eu acabei indo com. Seu para rpsec 2 e trilhos 3.
Acabei de adicionar este arquivo no diretório spec / apoio.
O link é: https://gist.github.com/971342
# spec/support/matchers/render_layout.rb
ActionView::Base.class_eval do unless instance_methods.include?('_render_layout_with_tracking') def _render_layout_with_tracking(layout, locals, &block) controller.instance_variable_set(:@_rendered_layout, layout) _render_layout_without_tracking(layout, locals, &block) end alias_method_chain :_render_layout, :tracking end end
# You can use this matcher anywhere that you have access to the controller instance, # like in controller or integration specs. # # == Example Usage # # Expects no layout to be rendered: # controller.should_not render_layout # Expects any layout to be rendered: # controller.should render_layout # Expects app/views/layouts/application.html.erb to be rendered: # controller.should render_layout('application') # Expects app/views/layouts/application.html.erb not to be rendered: # controller.should_not render_layout('application') # Expects app/views/layouts/mobile/application.html.erb to be rendered: # controller.should_not render_layout('mobile/application') RSpec::Matchers.define :render_layout do |*args| expected = args.first match do |c| actual = get_layout(c) if expected.nil? !actual.nil? # actual must be nil for the test to pass. Usage: should_not render_layout elsif actual actual == expected.to_s else false end end
failure_message_for_should do |c| actual = get_layout(c) if actual.nil? && expected.nil? "expected a layout to be rendered but none was" elsif actual.nil? "expected layout #{expected.inspect} but no layout was rendered" else "expected layout #{expected.inspect} but #{actual.inspect} was rendered" end end
failure_message_for_should_not do |c| actual = get_layout(c) if expected.nil? "expected no layout but #{actual.inspect} was rendered" else "expected #{expected.inspect} not to be rendered but it was" end end
def get_layout(controller) if template = controller.instance_variable_get(:@_rendered_layout) template.virtual_path.sub(/layouts\//, '') end end end
response.should render_template("layouts/some_folder/some_layout")
response.should render_template("template-name")
controller.active_layout.name
funciona para mim.
Aqui está uma versão do código do dmcnally que permite que há argumentos a serem passados, tornando "deve use_layout" e "should_not use_layout" de trabalho (para afirmar que o controlador está usando qualquer layout, ou nenhuma layout, respectivamente - da qual eu esperaria apenas o segundo a ser útil como você deve ser mais específico, se é usando um layout):
class UseLayout
def initialize(expected = nil)
if expected.nil?
@expected = nil
else
@expected = 'layouts/' + expected
end
end
def matches?(controller)
@actual = controller.layout
#@actual.equal?(@expected)
if @expected.nil?
@actual
else
@actual == @expected
end
end
def failure_message
if @expected.nil?
return 'use_layout expected a layout to be used, but none was', 'any', @actual
else
return "use_layout expected #{@expected.inspect}, got #{@actual.inspect}", @expected, @actual
end
end
def negative_failure_message
if @expected.nil?
return "use_layout expected no layout to be used, but #{@actual.inspect} found", 'any', @actual
else
return "use_layout expected #{@expected.inspect} not to equal #{@actual.inspect}", @expected, @actual
end
end
end
def use_layout(expected = nil)
UseLayout.new(expected)
end
Shoulda Matchers fornece uma correspondência para este cenário. ( Documentação) Isso parece funcionar:
expect(response).to render_with_layout('my_layout')
que produz mensagens de falha apropriadas como:
Espera-se render com o layout "calendar_layout", mas renderizados com "aplicação", "aplicação"
Testado com rails 4.2
, rspec 3.3
e shoulda-matchers 2.8.0
Editar: shoulda-matchers fornece este método. Shoulda :: Matchers :: ActionController :: RenderWithLayoutMatcher