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

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:005:57

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

Curso de Creación de APIs con Ruby on Rails

Clase 16 de 33

Clase 16 / 33

Recursos

Implementa una búsqueda por título confiable usando TDD. Aquí verás cómo preparar datos controlados con Factory Bot, validar query params en el request y afirmar que el response solo incluya los posts esperados. Con un enfoque práctico, cada paso asegura precisión y mantiene el código comprobable.

¿Cuál es el objetivo de la búsqueda por título?

La meta es filtrar posts por coincidencias en el título y comprobar que la respuesta de la API refleje ese criterio. Se trabaja con query params en la URL para enviar el término a filtrar y con aserciones claras que validan el resultado.

¿Qué valida la prueba con query params?

Que el payload no sea vacío.
Que el tamaño sea el esperado (por ejemplo, dos resultados).
Que los IDs sean exactamente los de los posts que contienen la palabra buscada.
Que el orden no afecte la comparación al usar ordenamiento previo.

¿Cómo aislar efectos en pruebas?

Incluir el request solo en la prueba que lo necesita.
Quitar inclusiones o configuraciones globales innecesarias que afectan otras pruebas.

¿Cómo preparar datos de prueba con Factory Bot?

Para evitar aleatoriedad en el atributo de publicación, se define una factory específica que garantice un estado estable. Así, las pruebas operan con posts publicados y títulos controlados.

¿Cómo controlar el atributo publish en la factory?

Crear una factory nombrada, por ejemplo, published_post.
Especificar la clase y fijar publish en true para asegurar consistencia.

# factory de posts con una variante publicada
FactoryBot.define do
  factory :published_post, class: 'Post' do
    publish { true }
    # otros atributos según el factory base
  end
end

Luego, se crean tres registros con títulos similares y uno distinto para verificar el filtrado por coincidencia parcial:

post1 = create(:published_post, title: 'Hola mundo')
post2 = create(:published_post, title: 'Hola Rails')
post3 = create(:published_post, title: 'Curso Rails')

¿Cómo validar el filtrado con TDD?

Se agrega un query param en la URL con el término "hola" para que el request retorne solo los posts que contienen esa palabra en el título. Con TDD, primero se ejecuta la prueba esperando que falle y luego se implementa la lógica hasta que pase.

¿Qué aserciones garantizan el comportamiento correcto?

Verificar que el payload no esté vacío.
Verificar que el tamaño sea dos cuando se busca "hola".
Mapear y ordenar IDs para comparar sin depender del orden de llegada.

# suponer que el response ya está parseado a json
expect(json).not_to be_empty
expect(json.size).to eq(2)

returned_ids = json.map { |p| p['id'] }.sort
expected_ids = [post1.id, post2.id].sort
expect(returned_ids).to eq(expected_ids)

Además, se confirma el flujo propio de TDD: primero la prueba falla porque aún se regresan los tres posts creados y no existe la lógica de filtrado; luego se implementa el comportamiento para que solo lleguen los dos relevantes.

¿Tienes una estrategia distinta para probar búsquedas por título? Cuéntala en los comentarios y enriquezcamos la práctica de pruebas entre todos.

  factory :post do
    title { Faker::Lorem.sentence }
    content { Faker::Lorem.paragraph }
    published {
      r = rand(0..1)
      if r == 0
        false
      else
        true
      end
    }
    user
  end```

FactoryBot.define do
  factory :post do
    title { 'Example title'}
    content { 'Example content' }
    published { false }
    user
  end

  trait :published_post do
    published { true }
  end
end

# GET /posts
    def index
        if params[:search].present?
            @posts = Post.where("title LIKE ?", "%#{params[:search]}%")
          else
            @posts = Post.where(published: true)
          end
        
        render json: @posts, status: :ok
    end
```Ejemplo de prueba "search":


```js
describe "Search" do
            let!(:example_post_1) { create :post, :published_post, title: 'example_post_1'}
            let!(:example_post_2) { create :post, :published_post, title: 'example_post_2' }
            let!(:post_3) { create :post, :published_post, title: 'post_3' }

            it "should return posts by title"  do
                get '/posts?search=post'
                payload = JSON.parse(response.body)
                expect(payload).to_not be_empty
                expect(payload.size).to eq(2)
                expect(payload.map { |p| p["id"]}.sort).to eq([example_post_1.id, example_post_2.id].sort)
                expect(response).to have_http_status(200)
           end
        end

Resumen

¿Cuál es el objetivo de la búsqueda por título?

¿Qué valida la prueba con query params?

Que el payload no sea vacío.
Que el tamaño sea el esperado (por ejemplo, dos resultados).
Que los IDs sean exactamente los de los posts que contienen la palabra buscada.
Que el orden no afecte la comparación al usar ordenamiento previo.

¿Cómo aislar efectos en pruebas?

Incluir el request solo en la prueba que lo necesita.
Quitar inclusiones o configuraciones globales innecesarias que afectan otras pruebas.

¿Cómo preparar datos de prueba con Factory Bot?

Para evitar aleatoriedad en el atributo de publicación, se define una factory específica que garantice un estado estable. Así, las pruebas operan con posts publicados y títulos controlados.

¿Cómo controlar el atributo publish en la factory?

Crear una factory nombrada, por ejemplo, published_post.
Especificar la clase y fijar publish en true para asegurar consistencia.

# factory de posts con una variante publicada
FactoryBot.define do
  factory :published_post, class: 'Post' do
    publish { true }
    # otros atributos según el factory base
  end
end

Luego, se crean tres registros con títulos similares y uno distinto para verificar el filtrado por coincidencia parcial:

post1 = create(:published_post, title: 'Hola mundo')
post2 = create(:published_post, title: 'Hola Rails')
post3 = create(:published_post, title: 'Curso Rails')

¿Cómo validar el filtrado con TDD?

¿Qué aserciones garantizan el comportamiento correcto?

Verificar que el payload no esté vacío.
Verificar que el tamaño sea dos cuando se busca "hola".
Mapear y ordenar IDs para comparar sin depender del orden de llegada.

# suponer que el response ya está parseado a json
expect(json).not_to be_empty
expect(json.size).to eq(2)

returned_ids = json.map { |p| p['id'] }.sort
expected_ids = [post1.id, post2.id].sort
expect(returned_ids).to eq(expected_ids)

¿Tienes una estrategia distinta para probar búsquedas por título? Cuéntala en los comentarios y enriquezcamos la práctica de pruebas entre todos.

Comentarios (3)3 comentarios

Victor Manuel Franco Cañon

Hace 8 años

Podría utilizarse un operador ternario en esta condicional?

Nos ahorramos unas lineas de codigo ademas de ser mucho mas legible al implementar la prueba de la siguiente forma?

  factory :post do
    title { Faker::Lorem.sentence }
    content { Faker::Lorem.paragraph }
    published {
      r = rand(0..1)
      r == 0 ? false : true
    }
    user
  end

Original

Luis Rogelio Reyes Hernandez

yo use

0 == rand(0..1)

y funciona, ya que el resultado sera un booleano

Mark Harmsen

@vifrac y @luis_reyesh98 gracias por sus comentarios mucachos!

Antonio de Jesús Pérez Maldonado

Hace 4 años

Espero sirva.

Tambien para implementar caracteristicas especificas, se pueden usar traits, para especificar y ser explicito en ciertas necesidades que debe de cumplir el factory:

Y asi ya solo especificar el trait o traits que debera de cumplir el factory al momento de crear el objeto:

let(:example_post) { create :post, :published_post }

Piero Nolte

Hace 2 años

Alguien entiende cual el motivo de agregar get '/posts?search=Hola' si al final no esta utilizan el query param?

Porque en el caso que lo utilizaría debería darle solo 2 post y no 3.

En el caso que te interese en esta prueba la utilidad de un query param puedes en agregar lo siguiente:

En "application_controller.rb":

Si generas esta prueba teniendo en cuenta un query param "search", el valor de "payload.size" seria igual 2 y buscarías que la prueba tenga éxito. En el caso que quieres que falle cambiar : expect(payload.size).to eq(3).

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

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