DEV Community: Isadora Rocha

Utilizando Jbuilder no Rails - Parte 1

Isadora Rocha — Tue, 17 Sep 2024 14:57:35 +0000

Jbuilder

Facilitar a criação de response em formato JSON a partir dos dados de modelos do Rails. Utilizado em APIs para serializar dados e construir documentos JSON complexos de maneira eficiente e legível.
Para os familiarizados de Java, é semelhante ao Serializable.

Jbuilder em Rails

json.data! @articles do |article|
  json.extract! article, :id, :title, :content
end

Serializable em Java

import java.io.Serializable;

public class Article implements Serializable {
    private int id;
    private String title;
    private String content;

    // Getters e Setters
}

ESSE POST É UMA CONTINUAÇÃO DO REspec Estrutura de Teste em Ruby on Rails

No CONTROLLER, em articles_controller.rb:

Foi alterado a linha render JSON - que está comentado na imagem acima - pois o controller não deve fazer duas coisas ao mesmo tempo, quebrando o princípio DRY (Don't Repeat Yourself).

ANTES

render json: Article.all, status: :ok

Aqui, o JSON é gerado diretamente no controller, o que faz com que ele cuide de duas coisas: buscar os dados e formatar a resposta, o que quebra o princípio de responsabilidade única.

DEPOIS

@articles = Article.all

Agora, o controller apenas busca os dados. A renderização e formatação JSON devem ser tratadas no view.

Na VIEW, em views >> api >> v1 >> articles >> index.json.jbuilder:

OBS: Para funcionar corretamente, é importante deixar o namespace corretamente, dentro das pastas api/v1

Bizu para que eu me lembre: json.bloco/nome 'retorna'

Como assim?

Por exemplo, o meu JSON de nome batata, retorna ‘BaTaTa’ no meu body.

OUTRO EXEMPLO

json.array! @articles do |article|
  json.id article
end

A função array! de JSON de Articles(do controller), faça que cada article retorne um bloco JSON chamado id, e dentro desse bloco, está dizendo que para cada article, o Jbuilderdeve criar uma chave chamada id.

Segue a imagem para melhor visualização:

RECOMENDAÇÃO
Ao invés de utilizar o json.array!, utilize o json.data para não haver atritos em utilizar outros componentes do jbuilder.

DEFINIR RETORNO SOMENTE DO TITLE DOS ARTICLES PARA O JSON

json.data @articles do |article|
  json.title article.title
end

Segue a imagem para melhor visualização:

CRÉDITOS e RECOMENDAÇÃO: puts_dev

Esse post tem somente a finalidade de consolidar o que aprendi. Qualquer dúvida ou erro que tenha visto, pode me avisar!

REspec Estrutura de Teste em Ruby on Rails

Isadora Rocha — Tue, 03 Sep 2024 22:15:56 +0000

Considere a aplicação já criada

Nosso model é Article, com os atributos title(string) e content(text)

⇾ Utilizando rails c no terminal

Criaremos um array de hashes utilizando rails c para um teste rápido

blog(dev)* articles = [
blog(dev)*   {title: 'art 1', content: 'conteudo do art 1'},
blog(dev)*   {title: 'art 2', content: 'conteudo do art 2'},
blog(dev)*   {title: 'art 3', content: 'conteudo do art 3'}
blog(dev)> ]

⇾ Utilizando arquivo seeds.rb

O arquivo seeds.rb é usado para configurar um ambiente de desenvolvimento ou teste com dados de exemplo, ou para fornecer dados iniciais ao banco de dados de produção. Ao executar o comando rails db:seed, ele rodará o arquivo e insere os dados no banco de dados.

No caso, o uso do rails c, os dados são imediatamente criados no banco de dados, mas essa ação não fica registrada em nenhum arquivo. Portanto, é adequado para testes rápidos ou manipulações de dados interativas que você não precisa necessariamente registrar para uso futuro.

Agora, deve-se colocar o mesmo array de hashes dentro do arquivo seeds.rbpara ficar registrado.

E, por fim, executar Article.create(articles) no rails c.

⇾ Agora, vamos ao controller

Criar uma pasta, dentro da pasta controllers, chamada api. Logo após, criar outra pasta chamada v1.
É uma boa prática para não deixar tudo junto na aplicação.
Agora, no arquivo articles_controller.rb, devemos alterar a class ArticlesController < AplicattionController para:

class Api::V1::ArticlesController < ActionController::API

Dentro do método index, adicionar um render json - um retorno para a requisição GET da aplicação.

def index
    render json: { message: 'carregado'}
end

CÓDIGO COMPLETO

class Api::V1::ArticlesController < ActionController::API
  def index
    Article.all
    render json: { message: 'carregado'}
  end
end

GET 127.0.0.1:3000/articles no POSTMAN.

OBS.: talvez tenha ocorrido um erro, deve-se configurar as rotas no arquivo routes.rb.

resources :articles, only: :index

⇾ Agora, vamos ao routes

Como não iremos utilizar as views, precisamos especificar um formato obrigatório (constraints), no caso utilizaremos json e xml, como exemplo.

Em config > routes.rb, vamos precisar definir namespaces e constraints.

namespace :api, constraints: ->(req) { %w[json].include? req.format } do
    namespace :v1 do
      resources :articles, only: :index
    end
  end

O constraints ficará na mesma linha do no namespace :api para que todas as rotas dentro dessa pasta sigam a mesma regra.

⇾ GEMFILE
Dentro do group :development do end, adicionar a gem do RSpec

# Testes - [https://github.com/rspec/rspec-rails]
  gem 'rspec-rails', '~> 7.0.0'

Em seguida, no terminal rodar bundle install para atualizar a gem. E por fim, executar rails g rspec:install.

⇾ SPEC
Dentro da pasta spec, criaremos uma pasta chamada request, e dentro dessa pasta, criaremos um arquivo chamada: articles_spec.rb.

require 'rails_helper'

Importar o arquivo rails_helper.rb, carrega o ambiente de teste e configurações necessárias para rodar os testes.

RSpec.describe 'Articles' do
end

Definir um grupo de testes para a entidade Articles.
RSpec.describe é a forma de agrupar e descrever testes em RSpec.

before(:each) { Article.create(title: 'art 2', content: 'conteudo do art 2') }

Criar um article com o título 'art 2' e o content 'conteúdo do art 2' antes de cada teste ser executado.

*Por quê?: * garantir que cada teste dentro desse grupo comece com um estado consistente, com pelo menos um artigo salvo no banco de dados.

require 'rails_helper'

RSpec.describe 'Articles' do
  before(:each) { Article.create(title: 'art 2', content: 'conteudo do art 2') }

(você está aqui)
  context "GET api/v1/articles" do

  end
end

Dentro do bloco RSpec.describe, adicionar o bloco context "GET api/v1/articles" do end

Serve para agrupar testes relacionados à rota **GET api/v1/articles**. contexté usado para organizar os testes em torno de um cenário ou contexto específico.

Agora, adicionaremos outro bloco **it 'responds with status Ok' do end**

...
context "GET api/v1/articles" do
(você está aqui)
    it 'responds with status Ok' do

    end
  end

Esse bloco define um teste individual. Dentro do bloco it é uma descrição do que o teste deve verificar, neste caso, se a resposta da rota GET api/v1/articles.json retorna um status Ok (200).

Dentro do bloco it, deve adicionar essas duas linhas:

context "GET api/v1/articles" do
    it 'responds with status Ok' do
(você está aqui)
      get '/api/v1/articles.json'
      expect(response).to have_http_status(:ok)
    end

O get '/api/v1/articles.json', faz uma requisição HTTP GET para a rota /api/v1/articles.json.. Esse método simula uma chamada à API.

O expect(response).to have_http_status(:ok), verifica se a resposta da requisição tem o status :ok (200). Se a API responder com um status diferente, o teste falhará.

Por fim, adicionar mais um bloco it (não é dentro do bloco it anterior).

...
it 'responds with correct persistes article json' do
      get '/api/v1/articles.json'
      expect(response.body).to include('art 2')
      expect(response.body).to include('conteudo do art 2')
end

O it 'responds with correct persisted article json' do, define outro teste individual, que verifica se o JSON retornado pela API contém os dados do artigo que foi criado no before.

O expect(response.body).to include('art 2'), verifica se o corpo da resposta (response.body) inclui o título 'art 2'.

*⇾ CÓDIGO COMPLETO *

require 'rails_helper'

RSpec.describe 'Articles' do
  before(:each) { Article.create(title: 'art 2', content: 'conteudo do art 2') }

  context "GET api/v1/articles" do
    it 'responds with status Ok' do
      get '/api/v1/articles.json'
      expect(response).to have_http_status(:ok)
    end

    it 'responds with correct persistes article json' do
      get '/api/v1/articles.json'
      expect(response.body).to include('art 2')
      expect(response.body).to include('conteudo do art 2')
    end
  end
end

RETORNANDO AO CONTROLLER
Ao invés de:

class Api::V1::ArticlesController < ActionController::API
  def index
    Article.all
    render json: { message: 'carregado'}
  end
end

Vamos alterar para que a API retorne todos os dados, e que seja status OK.

class Api::V1::ArticlesController < ActionController::API
  def index
    render json: Article.all, status: :ok
  end
end

⇾ Para testar o RSpec
No terminal, executar rspec

➜  blog git:(main) ✗ rspec
.

Finished in 0.05506 seconds (files took 2.19 seconds to load)
1 example, 0 failures

➜  blog git:(main) ✗

Essa mensagem indica que ocorreu tudo correto.

*⇾ Para testar no Postman *
Como definimos como json e xml, as rotas devem ser:

GET 127.0.0.1:3000/articles.json ou,
GET 127.0.0.1:3000/articles.xml

É isso. Obrigada!

REFERÊNCIAS:
Api app/Rails (Rails Guides): https://guides.rubyonrails.org/api_app.html
Routing/Rotas (Rails Guides): https://guides.rubyonrails.org/routing.html
RSpec Rails: https://github.com/rspec/rspec-rails
Rails Status codes: http://www.railsstatuscodes.com/
**Action Controller API: **https://api.rubyonrails.org/classes/ActionController/API.html
**Introdução a Api com Rails - primeiros passos: **https://www.youtube.com/watch?v=cj3GIO2CETo