FactoryBot for Rails testing

Dive into FactoryBot to ensure your testing data is reliable and consistent.

In the Ruby community, there's near-unanimous agreement on the importance of testing. Tests act as a safeguard, ensuring that the digital experiences we craft remain consistent, reliable, and of high quality. Many in the Ruby community claim that no code change is complete without tests.

They are an integral part of the development workflow. Regular testing ensures that new features, refactors, or bug fixes do not introduce unforeseen issues or regressions. It's a proactive approach that bolsters the reliability of applications and, by extension, the trust of end-users.

During testing, there's often a need to produce specific sets of data or objects during the test run. This is where factories come into play. Unlike manually crafting test data or resorting to static test fixtures, factories offer the dynamic creation of object instances tailored for specific scenarios. The end result is a more streamlined, precise, and maintainable testing setup.

FactoryBot is the de facto tool for crafting these factories in a Rails environment. It offers an intuitive interface and powerful features to define and deploy factories with minimal overhead. FactoryBot enhances test setups, optimizing them for both efficiency and readability.

Setting up FactoryBot

Integrating FactoryBot into an existing Rails project is a straightforward process.

FactoryBot operates as a gem, so the first step is adding it to your Gemfile. If you're using Rails with Active Record, you'll want the factory_bot_rails gem, which offers Rails-specific integrations. You only need these gems in development and testing, so put them in that dependency group in your Gemfile. You can add a combined section like this:

group :development, :test do
  gem 'factory_bot_rails'

Next, install the new gem:


For Rails to automatically use FactoryBot methods in tests, some configuration is required.

If you're using RSpec, add the following to your spec/rails_helper.rb:

config.include FactoryBot::Syntax::Methods

For other testing frameworks, like Minitest, you'll need to include FactoryBot methods in the appropriate test helper file.

Understanding the basics of FactoryBot

At its core, FactoryBot is a mechanism used to create test data, but with its nuanced capabilities, it can do much more. Let's break it down step by step.

A factory in FactoryBot is a blueprint for creating objects. Instead of manually instantiating an object and filling it with data inside your test, factories help you to define a template for a particular object type and then produce instances of that object with data filled in as specified.

At its most basic level, a factory defines a particular type of object (usually, Rails a model) and sets default values for its attributes. Let's say you have a course model with attributes like title, description, and duration. Here's how you might set up a factory for it:

FactoryBot.define do
  factory :course do
    title "Testing with Rails 101"
    description "An introductory course to testing in Ruby on Rails."
    duration 40

You would put this in a new factories directory under your spec directory, and give it the same name as the model. In this case, the file path would be ./spec/factories/course.rb.

FactoryBot also comes with a suite of methods that aid in creating and managing test data. You can use build in your tests to construct a new instance of a model without saving it to the database. This is useful when you want to test attributes or methods without database interaction. Meanwhile, the create method not only builds an instance but also saves it to the database. Using these methods in your test file might look like this:

unsaved_user = build(:user)
saved_user = create(:user)

The attributes_for method returns a hash of attributes that can be used to build an object. It's handy when you want the attributes but don't need the actual object. You can call it like this:

user_attributes = attributes_for(:user)

Advanced usage of FactoryBot

While the basic features of FactoryBot provide a solid foundation for efficient test setup, there are several more advanced practices that can further enhance your testing workflow. The first, which we've already seen in use, is traits. Traits allow you to create variations of a base factory. They are particularly useful for defining features or characteristics that aren’t required for every instance but are necessary under specific scenarios. The second is sequences. Sequences help in generating unique values for attributes. This is especially handy for attributes like emails, which must be unique in most applications. Sequences look like this:

FactoryBot.define do
  sequence :email do |n|

  factory :user do

Another incredibly common feature of Factorybot is associations. Rails models often have associations, and Factorybot can help you associate factories. Let’s say you have a course model associated with a user. You can set up factories to create these associations automatically.

FactoryBot.define do
  factory :user do
    name { "Jeff Morhous" }

  factory :course do
    name { "A Sample Course" }

# This will also create a user instance associated with the course
course_1 = create(:course)

Organizing factories

As you grow and evolve your application, your testing needs also change. Over time, you will find yourself with many factories. It's crucial to maintain their organization for readability and maintainability. Next, we’ll explain some best practices to guide you in effectively organizing factories.

At the core of effective testing lies simplicity. You should keep factories as minimal as possible. Stick to essential attributes required for the model's validity. If a user only needs a name and email to be valid, don't add unnecessary attributes like an address or phone number unless they're explicitly needed for specific tests.

It might be tempting to create a 'one-size-fits-all' factory with every conceivable trait and attribute. However, this can lead to bloated test setups. Instead, create lean base factories and use traits for variations. Traits allow you to group and name specific sets of attributes, making it easier to produce variations of a factory.

A factory with a trait looks like this:

FactoryBot.define do
  factory :user do
    name "Jeff Morhous"
    email "jeffmorhous@example.com"

    trait :admin do
      role "admin"

Beyond these principles, keeping the build_stubbed method in mind will enhance your tests. The build_stubbed method is an underutilized gem in FactoryBot's arsenal. It provides the appearance of a persisted record without hitting the database, making tests faster.

Organizing factories with the above principles in mind ensures that your test suite remains nimble and maintainable. As always, keep the broader testing goals in view: clarity, efficiency, and accuracy. Database operations can be time-consuming. If you don't need to test database-specific logic (like callbacks or database constraints), build_stubbed can provide a noticeable speed boost to your test suite. Using build_stubbed helps ensure that tests remain isolated from database side-effects, reducing the risk of one test inadvertently affecting another.

Writing unit tests using factories

In the Rails ecosystem, the unit testing of models often revolves around validating attributes, associations, callbacks, and methods. Factories play a crucial role in this arena, offering a convenient and efficient way to generate the necessary test data. Next, we’ll cover how to leverage factories in unit tests.

Imagine we have a user model with a method full_name that concatenates the user's first name and last name. Let's say the user model looks like this:

class User < ApplicationRecord
  def full_name
    "#{first_name} #{last_name}"

Your factory might look like this:

FactoryBot.define do
  factory :user do
    first_name { "John" }
    last_name { "Doe" }

Now, let's write a unit test for this method using RSpec and FactoryBot:

require 'rails_helper'

RSpec.describe User, type: :model do
  describe '#full_name' do
    it 'returns the concatenated first and last name' do
      user = build(:user, first_name: "Jeff", last_name: "Morhous")
      expect(user.full_name).to eq("Jeff Morhous")


The importance of factories in testing cannot be understated. Factories simplify the process of generating test data and ensuring consistency. By having a dependable and standardized way to create data, you eliminate potential variables that could skew test results or result in flaky tests.

FactoryBot, in particular, shines in its adaptability and ease of use. This flexibility means that as your testing needs evolve, FactoryBot scales, ensuring that you're always equipped to write efficient and effective tests.

Invest in your testing suite by incorporating factories. The initial setup introduces overhead, but the dividends it pays in the long run — in terms of test clarity, speed, and reliability — are invaluable.

What to do next:
  1. Try Honeybadger for FREE
    Honeybadger helps you find and fix errors before your users can even report them. Get set up in minutes and check monitoring off your to-do list.
    Start free trial
    Easy 5-minute setup — No credit card required
  2. Get the Honeybadger newsletter
    Each month we share news, best practices, and stories from the DevOps & monitoring community—exclusively for developers like you.
    author photo

    Jeffery Morhous

    Jeff is a Software Engineer working in healtcare technology using Ruby on Rails, React, and plenty more tools. He loves making things that make life more interesting and learning as much he can on the way. In his spare time, he loves to play guitar, hike, and tinker with cars.

    More articles by Jeffery Morhous
    Stop wasting time manually checking logs for errors!

    Try the only application health monitoring tool that allows you to track application errors, uptime, and cron jobs in one simple platform.

    • Know when critical errors occur, and which customers are affected.
    • Respond instantly when your systems go down.
    • Improve the health of your systems over time.
    • Fix problems before your customers can report them!

    As developers ourselves, we hated wasting time tracking down errors—so we built the system we always wanted.

    Honeybadger tracks everything you need and nothing you don't, creating one simple solution to keep your application running and error free so you can do what you do best—release new code. Try it free and see for yourself.

    Start free trial
    Simple 5-minute setup — No credit card required

    Learn more

    "We've looked at a lot of error management systems. Honeybadger is head and shoulders above the rest and somehow gets better with every new release."
    — Michael Smith, Cofounder & CTO of YvesBlue

    Honeybadger is trusted by top companies like:

    “Everyone is in love with Honeybadger ... the UI is spot on.”
    Molly Struve, Sr. Site Reliability Engineer, Netflix
    Start free trial
    Are you using Sentry, Rollbar, Bugsnag, or Airbrake for your monitoring? Honeybadger includes error tracking with a whole suite of amazing monitoring tools — all for probably less than you're paying now. Discover why so many companies are switching to Honeybadger here.
    Start free trial
    Stop digging through chat logs to find the bug-fix someone mentioned last month. Honeybadger's built-in issue tracker keeps discussion central to each error, so that if it pops up again you'll be able to pick up right where you left off.
    Start free trial