ti-enxame.com

Como redirecionar para um 404 no Rails?

Eu gostaria de 'fingir' uma página 404 no Rails. No PHP, gostaria apenas de enviar um cabeçalho com o código de erro como tal:

header("HTTP/1.0 404 Not Found");

Como isso é feito com o Rails?

468
Yuval Karmi

Não renderize 404 você mesmo, não há razão para isso; O Rails já possui essa funcionalidade incorporada. Se você quiser mostrar uma página 404, crie um método render_404 (ou not_found como eu chamei) em ApplicationController assim:

def not_found
  raise ActionController::RoutingError.new('Not Found')
end

O Rails também lida com AbstractController::ActionNotFound e ActiveRecord::RecordNotFound da mesma maneira.

Isso faz duas coisas melhores:

1) Ele usa o manipulador rescue_from embutido do Rails para renderizar a página 404, e 2) interrompe a execução do seu código, permitindo que você faça coisas legais como:

  user = User.find_by_email(params[:email]) or not_found
  user.do_something!

sem ter que escrever declarações condicionais feias.

Como bônus, também é super fácil de manusear nos testes. Por exemplo, em um teste de integração rspec:

# RSpec 1

lambda {
  visit '/something/you/want/to/404'
}.should raise_error(ActionController::RoutingError)

# RSpec 2+

expect {
  get '/something/you/want/to/404'
}.to raise_error(ActionController::RoutingError)

E minitest:

assert_raises(ActionController::RoutingError) do 
  get '/something/you/want/to/404'
end

OU consulte mais informações em Rails render 404 não encontrados em uma ação do controller

1034
Steven Soroka

Status HTTP 404

Para retornar um cabeçalho 404, basta usar a opção :status para o método render.

def action
  # here the code

  render :status => 404
end

Se você deseja renderizar a página 404 padrão, você pode extrair o recurso em um método.

def render_404
  respond_to do |format|
    format.html { render :file => "#{Rails.root}/public/404", :layout => false, :status => :not_found }
    format.xml  { head :not_found }
    format.any  { head :not_found }
  end
end

e chame isso em sua ação

def action
  # here the code

  render_404
end

Se você quiser que a ação renderize a página de erro e pare, simplesmente use uma instrução de retorno.

def action
  render_404 and return if params[:something].blank?

  # here the code that will never be executed
end

ActiveRecord e HTTP 404

Lembre-se também que o Rails resgata alguns erros do ActiveRecord, como o ActiveRecord::RecordNotFound exibindo a página de erro 404.

Isso significa que você não precisa salvar essa ação sozinho

def show
  user = User.find(params[:id])
end

User.find gera um ActiveRecord::RecordNotFound quando o usuário não existe. Este é um recurso muito poderoso. Olhe o seguinte código

def show
  user = User.find_by_email(params[:email]) or raise("not found")
  # ...
end

Você pode simplificá-lo delegando ao Rails a verificação. Basta usar a versão bang.

def show
  user = User.find_by_email!(params[:email])
  # ...
end
238
Simone Carletti

A resposta recentemente selecionada enviada por Steven Soroka está próxima, mas não completa. O teste em si esconde o fato de que isso não está retornando um verdadeiro 404 - está retornando um status de 200 - "sucesso". A resposta original foi mais próxima, mas tentou renderizar o layout como se nenhuma falha tivesse ocorrido. Isso corrige tudo:

render :text => 'Not Found', :status => '404'

Aqui está um conjunto de testes típico para algo que eu espero retornar 404, usando matchers RSpec e Shoulda:

describe "user view" do
  before do
    get :show, :id => 'nonsense'
  end

  it { should_not assign_to :user }

  it { should respond_with :not_found }
  it { should respond_with_content_type :html }

  it { should_not render_template :show }
  it { should_not render_with_layout }

  it { should_not set_the_flash }
end

Essa saudável paranoia me permitiu detectar a incompatibilidade de tipo de conteúdo quando tudo parecia mais atraente. Eu verifiquei todos esses elementos: variáveis ​​designadas, código de resposta, tipo de conteúdo de resposta, modelo renderizado, layout renderizado, mensagens flash.

Vou pular a verificação do tipo de conteúdo em aplicativos que são estritamente html ... às vezes. Afinal, "um cético verifica TODAS as gavetas" :)

http://dilbert.com/strips/comic/1998-01-20/

FYI: Eu não recomendo testar coisas que estão acontecendo no controller, ie "should_raise". O que te interessa é a saída. Meus testes acima permitiram que eu tentasse várias soluções, e os testes permanecem os mesmos, quer a solução esteja levantando uma exceção, renderização especial, etc.

58
Jaime Bellmyer

Você também pode usar o arquivo de renderização:

render file: "#{Rails.root}/public/404.html", layout: false, status: 404

Onde você pode optar por usar o layout ou não.

Outra opção é usar as exceções para controlá-lo:

raise ActiveRecord::RecordNotFound, "Record not found."
18
Paulo Fidalgo

A resposta selecionada não funciona no Rails 3.1+, pois o manipulador de erros foi movido para um middleware (veja questão github ).

Aqui está a solução que encontrei e estou muito feliz com isso.

Em ApplicationController:

  unless Rails.application.config.consider_all_requests_local
    rescue_from Exception, with: :handle_exception
  end

  def not_found
    raise ActionController::RoutingError.new('Not Found')
  end

  def handle_exception(exception=nil)
    if exception
      logger = Logger.new(STDOUT)
      logger.debug "Exception Message: #{exception.message} \n"
      logger.debug "Exception Class: #{exception.class} \n"
      logger.debug "Exception Backtrace: \n"
      logger.debug exception.backtrace.join("\n")
      if [ActionController::RoutingError, ActionController::UnknownController, ActionController::UnknownAction].include?(exception.class)
        return render_404
      else
        return render_500
      end
    end
  end

  def render_404
    respond_to do |format|
      format.html { render template: 'errors/not_found', layout: 'layouts/application', status: 404 }
      format.all { render nothing: true, status: 404 }
    end
  end

  def render_500
    respond_to do |format|
      format.html { render template: 'errors/internal_server_error', layout: 'layouts/application', status: 500 }
      format.all { render nothing: true, status: 500}
    end
  end

e em application.rb:

config.after_initialize do |app|
  app.routes.append{ match '*a', :to => 'application#not_found' } unless config.consider_all_requests_local
end

E nos meus recursos (mostrar, editar, atualizar, excluir):

@resource = Resource.find(params[:id]) or not_found

Isso certamente poderia ser melhorado, mas pelo menos eu tenho visões diferentes para not_found e internal_error sem sobrescrever as principais funções do Rails.

12
Augustin Riedinger

estes irão ajudá-lo ...

Controlador de aplicativos

class ApplicationController < ActionController::Base
  protect_from_forgery
  unless Rails.application.config.consider_all_requests_local             
    rescue_from ActionController::RoutingError, ActionController::UnknownController, ::AbstractController::ActionNotFound, ActiveRecord::RecordNotFound, with: lambda { |exception| render_error 404, exception }
  end

  private
    def render_error(status, exception)
      Rails.logger.error status.to_s + " " + exception.message.to_s
      Rails.logger.error exception.backtrace.join("\n") 
      respond_to do |format|
        format.html { render template: "errors/error_#{status}",status: status }
        format.all { render nothing: true, status: status }
      end
    end
end

controlador de erros

class ErrorsController < ApplicationController
  def error_404
    @not_found_path = params[:not_found]
  end
end

visualizações/erros/error_404.html.haml

.site
  .services-page 
    .error-template
      %h1
        Oops!
      %h2
        404 Not Found
      .error-details
        Sorry, an error has occured, Requested page not found!
        You tried to access '#{@not_found_path}', which is not a valid page.
      .error-actions
        %a.button_simple_orange.btn.btn-primary.btn-lg{href: root_path}
          %span.glyphicon.glyphicon-home
          Take Me Home
7
Caner Çakmak

Eu queria lançar um 'normal' 404 para qualquer usuário logado que não fosse um administrador, então acabei escrevendo algo assim no Rails 5:

class AdminController < ApplicationController
  before_action :blackhole_admin

  private

  def blackhole_admin
    return if current_user.admin?

    raise ActionController::RoutingError, 'Not Found'
  rescue ActionController::RoutingError
    render file: "#{Rails.root}/public/404", layout: false, status: :not_found
  end
end
1
emptywalls
<%= render file: 'public/404', status: 404, formats: [:html] %>

basta adicionar isso à página que deseja renderizar na página de erro 404 e pronto.

1
Ahmed Reza

Para testar o tratamento de erros, você pode fazer algo assim:

feature ErrorHandling do
  before do
    Rails.application.config.consider_all_requests_local = false
    Rails.application.config.action_dispatch.show_exceptions = true
  end

  scenario 'renders not_found template' do
    visit '/blah'
    expect(page).to have_content "The page you were looking for doesn't exist."
  end
end
0
maprihoda

Se você quiser lidar com diferentes 404s de maneiras diferentes, considere pegá-los em seus controladores. Isso permitirá que você faça coisas como controlar o número de 404s gerados por diferentes grupos de usuários, ter suporte para interagir com os usuários para descobrir o que deu errado/que parte da experiência do usuário pode precisar de ajustes, testes A/B, etc.

Eu coloquei aqui a lógica base no ApplicationController, mas ela também pode ser colocada em controladores mais específicos, para ter uma lógica especial apenas para um controlador.

A razão pela qual estou usando um if com ENV ['RESCUE_404'] é para poder testar o levantamento de AR :: RecordNotFound isoladamente. Nos testes, eu posso configurar este ENV var para false e meu rescue_from não dispararia. Desta forma eu posso testar o raise separado da lógica 404 condicional.

class ApplicationController < ActionController::Base

  rescue_from ActiveRecord::RecordNotFound, with: :conditional_404_redirect if ENV['RESCUE_404']

private

  def conditional_404_redirect
    track_404(@current_user)
    if @current_user.present?
      redirect_to_user_home          
    else
      redirect_to_front
    end
  end

end
0
Houen