Provide a boilerplate for a Ruby on Rails API with RSpec testing.
- User
Provide a boilerplate for a Ruby on Rails API with RSpec testing.
Assistant
Focusing on Backend API
I've been drilling down on what this boilerplate needs to be. The core requirement is a solid foundation for a Ruby on Rails API. Specifically, RSpec integration is key. We're talking about a bare-bones structure focused on API endpoints and backend logic, stripping away anything related to views or UI. I'm visualizing the essential elements of this starting point.
Refining the Core Gems
I'm now zeroing in on the specific gem dependencies. I'm prioritizing essential components like FactoryBot for data fixtures, Faker for test data, and DatabaseCleaner to ensure clean test environments. I'm also considering gems to help with JSON response formatting. PostgreSQL is the database of choice, though SQLite for development might be acceptable. CORS is a must for front-end interaction.
Establishing the Rails Skeleton
I'm solidifying the initial project structure, starting with
rails new my_api --api --database=postgresql -T. The focus now shifts to the Gemfile. I've pinpointed RSpec as the cornerstone, with FactoryBot and Faker for data generation.shoulda-matcherswill be included, and I'll consider database cleaning options likedatabase_cleaner-active_record. Standard Request specs are preferred over controller tests. I'll configure RSpec to streamline testing, specifically FactoryBot and Shoulda Matchers syntax.Outlining the Core Features
I'm now outlining the fundamental elements: model, controller, and serializer for an example API endpoint. Focusing on best practices, I've decided to incorporate API versioning. I'll emphasize that for a basic setup, standard JSON rendering is sufficient, though serializers like
jsonapi-serializerare a logical progression. The example will useArticleas a model, and its associated controller, along with request specs and model specs.Enhancing the Output Details
I'm now integrating more specific details into the generated output. I'm making sure to format the responses clearly using Markdown and code blocks for shell commands and file contents, complete with filenames. I'm also adding a "Next Steps" section to guide the user after they copy and paste the code. I've included
pry-railsas a debugging tool and ensured to remind users aboutrails db:create.Here is a comprehensive boilerplate guide to setting up a Ruby on Rails API with a robust RSpec testing suite.
Prerequisites
- Ruby installed
- Rails installed
- PostgreSQL installed (recommended for production-grade APIs)
1. Initialize the Project
Create a new Rails app in API mode (
--api) and skip the default test suite (-T) so we can install RSpec manually.rails new my_api --api --database=postgresql -T cd my_api2. Configure the Gemfile
Open your
Gemfileand add the following gems. This setup includes RSpec, tools to generate fake data, and easier assertion syntax.# Gemfile group :development, :test do # The testing framework gem 'rspec-rails' # For generating test data gem 'factory_bot_rails' # For generating fake data (names, emails, etc.) gem 'faker' # Debugging tool gem 'pry-rails' end group :test do # Simplifies one-liner tests (e.g., is_expected.to validate_presence_of) gem 'shoulda-matchers' # Helps clean database between tests (optional, but good precaution) gem 'database_cleaner-active_record' endRun the installation:
bundle install3. Install and Configure RSpec
Run the generator to create the
specdirectory and configuration files.rails generate rspec:installConfigure
spec/rails_helper.rbOpen
spec/rails_helper.rbto configure FactoryBot and Shoulda Matchers. Add the following configuration blocks inside the file:# spec/rails_helper.rb require 'spec_helper' ENV['RAILS_ENV'] ||= 'test' require_relative '../config/environment' abort("The Rails environment is running in production mode!") if Rails.env.production? require 'rspec/rails' # Add this to easily use FactoryBot methods (create, build) without the class prefix Dir[Rails.root.join('spec/support/**/*.rb')].each { |f| require f } begin ActiveRecord::Migration.maintain_test_schema! rescue ActiveRecord::PendingMigrationError => e puts e.to_s.strip exit 1 end RSpec.configure do |config| config.fixture_path = "#{::Rails.root}/spec/fixtures" config.use_transactional_fixtures = true config.infer_spec_type_from_file_location! config.filter_rails_from_backtrace! # --- ADD THIS BLOCK --- # Include FactoryBot methods config.include FactoryBot::Syntax::Methods end # --- ADD THIS BLOCK AT THE BOTTOM --- # Configure Shoulda Matchers Shoulda::Matchers.configure do |config| config.integrate do |with| with.test_framework :rspec with.library :rails end end4. Configure CORS
To allow frontend applications (React, Vue, etc.) to consume your API, you must enable CORS.
Uncomment
gem 'rack-cors'in yourGemfile, runbundle install, and then configureconfig/initializers/cors.rb:# config/initializers/cors.rb Rails.application.config.middleware.insert_before 0, Rack::Cors do allow do origins '*' # change this to your specific frontend URL in production resource '*', headers: :any, methods: [:get, :post, :put, :patch, :delete, :options, :head] end end5. Example Workflow (Model, Controller, & Tests)
Here is a standard workflow for creating a versioned API endpoint.
A. Create a Model
rails g model Post title:string body:text rails db:create db:migrateB. Define the Factory
Edit the generated file in
spec/factories/posts.rb:# spec/factories/posts.rb FactoryBot.define do factory :post do title { Faker::Book.title } body { Faker::Lorem.paragraph } end endC. Write the Model Spec
Edit
spec/models/post_spec.rb:# spec/models/post_spec.rb require 'rails_helper' RSpec.describe Post, type: :model do context 'validations' do # Using Shoulda Matchers it { should validate_presence_of(:title) } it { should validate_presence_of(:body) } end endNote: You will need to add
validates :title, :body, presence: trueto your Post model for this to pass.D. Create the Controller
It is best practice to version APIs.
mkdir -p app/controllers/api/v1 touch app/controllers/api/v1/posts_controller.rbThe Controller Logic:
# app/controllers/api/v1/posts_controller.rb class Api::V1::PostsController < ApplicationController def index posts = Post.all render json: posts, status: :ok end def create post = Post.new(post_params) if post.save render json: post, status: :created else render json: post.errors, status: :unprocessable_entity end end private def post_params params.require(:post).permit(:title, :body) end endThe Routes:
# config/routes.rb Rails.application.routes.draw do namespace :api do namespace :v1 do resources :posts, only: [:index, :create] end end endE. Write the Request Spec (Integration Test)
In Rails APIs, Request Specs are preferred over Controller specs.
mkdir -p spec/requests/api/v1 touch spec/requests/api/v1/posts_spec.rb# spec/requests/api/v1/posts_spec.rb require 'rails_helper' RSpec.describe "Api::V1::Posts", type: :request do describe "GET /index" do it "returns a successful response" do create_list(:post, 3) # Creates 3 posts using FactoryBot get "/api/v1/posts" expect(response).to be_successful expect(JSON.parse(response.body).size).to eq(3) end end describe "POST /create" do context "with valid parameters" do let(:valid_params) { { post: { title: 'My API', body: 'Is cool' } } } it "creates a new Post" do expect { post "/api/v1/posts", params: valid_params }.to change(Post, :count).by(1) expect(response).to have_http_status(:created) end end context "with invalid parameters" do let(:invalid_params) { { post: { title: '', body: '' } } } it "does not create a new Post" do expect { post "/api/v1/posts", params: invalid_params }.to change(Post, :count).by(0) expect(response).to have_http_status(:unprocessable_entity) end end end end6. Running Tests
To run the entire suite:
bundle exec rspecTo run specific file:
bundle exec rspec spec/requests/api/v1/posts_spec.rb7. Recommended Next Steps
For a production-ready API, consider adding these gems:
- Serialization:
gem 'jsonapi-serializer'orgem 'blueprinter'(To format JSON responses cleanly). - Authentication:
gem 'devise'withgem 'devise-jwt'. - Documentation:
gem 'rswag'(Generates Swagger/OpenAPI docs from your RSpec tests).
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.