Autenticación y Seguridad en CRUD de Posts en Rails

Curso de Creación de APIs con Ruby on Rails

Contenido del curso

Introducción

Proyecto

Cierre

33
Creación de APIs con Rails: Buenas Prácticas y Features Avanzados
00:43 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:009:17

Autenticación y Seguridad en CRUD de Posts en Rails

Curso de Creación de APIs con Ruby on Rails

Clase 24 de 33

Clase 24 / 33

Recursos

Proteger endpoints en Rails requiere unir autenticación, autorización y pruebas claras. Aquí verás cómo asociar posts al usuario autenticado, controlar la visibilidad en show y resolver errores comunes en specs con with_indifferent_access y byebug. El enfoque: seguridad primero, pruebas confiables y correcciones puntuales.

Implementación con current user

La base es el método authenticate user que valida el header de autorización y el token. Con esto activo, se refuerzan las acciones que modifican datos y se evita pasar el user_id desde parámetros.

¿Cómo asegurar create y update con current_user?

Usar la asociación: user has_many posts para crear en contexto del usuario.
Evitar recibir user_id en params para no exponer asignaciones indebidas.
En update, buscar el post dentro de los del usuario autenticado.

# create
def create
  post = current_user.posts.create(post_params)
  render json: post
end

# update
def update
  post = current_user.posts.find(params[:id])
  post.update(update_params)
  render json: post
end

¿Qué pasa con los parámetros en create params?

Quitar el permiso de :user_id.
Confiar en current user y su relación con posts para la autoría.
Mantener solo los atributos del post que sí se pueden modificar.

Visibilidad y autorización en show

La lectura no siempre requiere autenticación, pero sí control de visibilidad. Se permite ver si el post es público. Si no lo es, solo el usuario autenticado propietario puede acceder; de lo contrario, devolver 404 not found con un error "Not found".

¿Cuándo mostrar un post público o privado?

Si el post es público: permitir render directo.
Si no es público y hay current user dueño: permitir render.
En cualquier otro caso: responder con status not_found (404).

if post_public || (current_user && post.user == current_user)
  render json: post
else
  render json: { error: "Not found" }, status: :not_found
end

Pruebas y debugging en Rails

Ajustar specs evita falsos negativos. Aquí se corrigen desajustes de tipos (símbolos vs cadenas), se crea un helper para el payload y se depura un 500 ocasionado por un método mal escrito.

¿Cómo resolver el error de ID símbolo vs string?

El payload respondió con "id" como cadena, la prueba esperaba símbolo.
Ajustar aserciones para aceptar ambos formatos de clave.
Crear un helper reutilizable para analizar la respuesta.

# Helper en la prueba
private

def payload
  # hash_response es el cuerpo parseado de la respuesta
  hash_response.with_indifferent_access
end

¿Cómo usar with_indifferent_access en un helper payload?

Aplicarlo al hash del payload para acceder con símbolo o cadena.
Beneficio: aserciones más robustas y legibles.
Clave en Rails: with_indifferent_access sobre hashes de respuesta.

expect(payload[:id]).to be_present
expect(payload["id"]).to be_present

¿Cómo depurar un 500 y corregir attribute vs attributes?

Fallo: se esperaba 404 not found, se obtuvo 500.
Estrategia: insertar byebug en el controller y ejecutar la spec por línea.
Detectado: uso incorrecto de attributes en lugar de attribute en el flujo de current.
Corrección: cambiar al método correcto y re-ejecutar, las pruebas pasan.

# En el controller
require 'byebug'
byebug  # punto de parada para inspección

# En terminal (ejemplo de ejecución por línea)
rspec spec/path/private_post_spec.rb:36

¿Te quedó alguna duda sobre el flujo con current user o el manejo de errores 404/500? Comparte tus preguntas o el fragmento de código donde te atascaste, y lo revisamos juntos.

Jhonnatan Alexander Casas Leon

Hace 8 años

me salen 4 errores y no 3 como en el video

private_posts_spec.rb

require "rails_helper"

RSpec.describe "Posts with Authentication", type: :request do
  let!(:user) { create(:user) }
  let!(:other_user) { create(:user) }
  let!(:user_post) { create(:post, user_id: user.id) }
  let!(:other_user_post) { create(:post, user_id: other_user.id, published: true) }
  let!(:other_user_post_draft) { create(:post, user_id: other_user.id, published: false) }
  let!(:auth_headers) { { 'Authorization' => "Bearer #{user.auth.token}" } }
  let!(:other_auth_headers) { { 'Authorization' => "Bearer #{other_user.auth.token}" } }

  describe "GET /posts/{id}" do
    context 'with valid auth' do
      context 'when requisting others author post' do
        context "when post is public" do
          before {get "/posts/#{other_user_post.id}", headers: auth_headers }

            context "payload" do
              subject { payload }
              it { is_expected.to include(:id) }
            end
            context "response" do
            subject { response }
            it { is_expected.to have_http_status(:ok) }
            end
        end
        context "when post is draft" do
          before {get "/posts/#{other_user_post_draft.id}", headers: auth_headers }

            context "payload draft" do
              subject { payload }
              it { is_expected.to include(:error) }
            end
            context "response draft" do
            subject { response }
            it { is_expected.to have_http_status(:not_found) }
            end
          end
      end
      context 'when requisting users post' do
        
      end
    end 
  end
  describe "POST /posts" do

  end
  describe "PUT /posts" do

  end
      # it "should return OK" do
      #   get '/posts'
      #  payload = JSON.parse(response.body)
      #  expect(payload).to be_empty
      #  expect(response).to have_http_status(200)
      # end

      private

      def payload
        JSON.parse(response.body).with_indifferent_access
      end
  end

controlller

class PostsController < ApplicationController
  before_action :authenticate_user!, only: [:create, :update]
#general exception
  rescue_from Exception do |e|
    render json:  { error: e.message }, status: :internal_error
  end

# exception handler
rescue_from ActiveRecord::RecordInvalid do |e|
  render json:  { error: e.message }, status: :unprocessable_entity
end
#GET /posts
def index
  @posts = Post.where(published: true)
  if !params[:search].nil? && params[:search].present?
    @posts = PostsSearchService.search(@posts, params[:search])
  end
  #includes other module like user that is relationated with posts, this made 1 query to the db 
  #solution n+1 query problem
  render json: @posts.includes(:user), status: :ok
end

#GET /posts/{id}
def show
  @post = Post.find(params[:id])
  if (@post.published? || (Current.user && @post.user_id == Current.user.id))
  render json: @post, status: :ok
  else 
    render json: { error: 'Not_Found' }, status: :not_found
  end
end

#POST /posts
def create
  @post = Current.user.posts.create!(create_params)
  render json: @post, status: :created
end

#PUT /posts/{id}
def update
  @post = Current.user.posts.find(params[:id])
  @post.update!(update_params)
  render json: @post, status: :ok
end

private

def create_params
  params.require(:post).permit(:title,:content,:published) 
end

def update_params
  params.require(:post).permit(:title,:content,:published) 
end

def authenticate_user!
  #Bearer 'token'
  token_regex = /Bearer (\W+)/
  #read HEADER de auth
  headers = request.headers
  #verificar que sea valido
  if ['Authorization'].present? && headers['Authorization'].match(token_regex)
    token = headers['Authorization'].match(token_regex)[1]
  #debemos verificar que el user corresponda a un user
    if (Current.user = User.find_by_auth_token(token))
        return
  end
end
render json: { error: 'unauthorized'}, status: :unauthorized
end

end

Pero no me pasan las pruebas

Diego Ortiz

Hace 8 años

Debiste poner los errores que te salen en las pruebas para encontrar la respuesta más fácil. De lo que se alcanza a ver que en esos dos archivos veo:

Tú let!(:auth_headers) estás usando un user.auth.token cuando en verdad el auth_token es la columna, así que debe ser user.auth_token
La W de tu token_regex es mayúscula y no minúscula como la de Simon
En el primer if del authenticate_user tiene un ['Authorization'].present? en vez de headers['Authorization'].present?

Introducción

API de blog con Ruby on Rails y TDD

Verificar herramientas antes del proyecto Rails

Proyecto

Creación de APIs con Rails: Proyecto Blog API paso a paso

Configuración de Gemas para Pruebas en Proyectos Rails

Configuración de Gemas en Proyectos Rails: Arspec, Factory Bot y Database Cleaner

Implementación de un Health Check Endpoint en API con RSpec

Diseño de Casos de Uso y Diagramas de Entidad para Aplicaciones

Diagrama entidad relación: usuario y post

Modelado de Aplicaciones con TDD en Rails

Validaciones y Pruebas TDD en Rails: Modelos USR y Post

Implementación de Endpoints para Listar y Mostrar Posts con TDD

Implementar controlador Posts con TDD

Pruebas TDD para crear y actualizar posts

Implementación de Métodos y Manejo de Excepciones en Rails API

Active Model serializers: control total de JSON en Rails

Búsqueda y Filtrado de Posts por Título con TDD

Implementación de Búsqueda de Posts con Servicios en Rails

Problema N+1 en Rails: Detección y Solución Eficaz

Identificación y solución del problema N+1 en Rails

Flujo de Autenticación en APIs con Tokens y Proveedores

Tests con RSpec para autenticación de tokens

Autenticación con Tokens: Implementación en Rails API

Autenticación de Usuarios en Controladores Rails

Autenticación y Seguridad en CRUD de Posts en Rails

Pruebas de Creación y Actualización con Autenticación en Rails

Probando API Ruby on Rails con Postman

Caching en Aplicaciones Web: Funciones y Niveles

Aceleración de Búsquedas en Rails con Caching

Background Jobs en Rails: Conceptos y Funcionalidades

Procesamiento en Background y Envío de Correos con Rails

Envío de Correos en Rails con ActionMailer y Background Jobs

Autenticación y Autorización con JWT y Auth0 en Aplicaciones Web

Cierre

Creación de APIs con Rails: Buenas Prácticas y Features Avanzados

Autenticación y Seguridad en CRUD de Posts en Rails