factory_bot

factory_bot is a fixtures replacement library for Ruby. It provides a straightforward definition syntax and supports several key features:

• Multiple build strategies: Create saved instances, unsaved instances, attribute hashes, and stubbed objects.
• Multiple factories per class: Define different factories for the same class (e.g., user, admin_user).
• Factory inheritance: Build new factories based on existing ones.

factory_bot is a fixtures replacement for Ruby that provides a straightforward definition syntax. It supports:

• Multiple build strategies: including saved instances, unsaved instances, attribute hashes, and stubbed objects.
• Multiple factories for the same class: allowing you to define different variations (e.g., user, admin_user) for a single model.
• Factory inheritance: enabling specialized factories to inherit attributes from base factories.

When setting up associations within a factory, if the name of the association matches the name of the factory being associated, you can omit the factory name. This is known as an implicit definition.

factory :post do
  # ...
  author
end

After defining a custom strategy class, register it with FactoryBot using register_strategy. Once registered, you can invoke the strategy by calling a method named after the strategy symbol on FactoryBot.

# 1. Define the strategy
class JsonStrategy
  def initialize
    @strategy = FactoryBot.strategy_by_name(:create).new
  end

  delegate :association, to: :@strategy

  def result(evaluation)
    @strategy.result(evaluation).to_json
  end

  def to_sym
    :json
  end
end

# 2. Register the strategy
FactoryBot.register_strategy(:json, JsonStrategy)

# 3. Use the strategy
FactoryBot.json(:user)

If you want to create an instance without calling any persistence method at all (for example, when working with a model that does not have a database backing), use skip_create within the factory definition.

factory :user_without_database do
  skip_create
end

When building or creating objects, you can link associated objects by passing an existing instance as an attribute override. This allows you to specify exactly which associated object should be used instead of letting factory_bot create a new one via the default association definition.

FactoryBot.define do
  factory :author do
    name { 'Taylor' }
  end

  factory :post do
    author
  end
end

eunji = build(:author, name: 'Eunji')
post = build(:post, author: eunji)

To manipulate specific sequences—such as generating values with generate, generating lists with generate_list, setting values with FactoryBot.set_sequence, or rewinding with rewind_sequence—you must reference them using a unique URI.

A URI is composed of up to three components:

1. Factory name: Required if the sequence is defined within a Factory or a Factory Trait.
2. Trait name: Required if the sequence is defined within a Trait.
3. Sequence name: Always required.

You can provide the URI as individual symbols, individual strings, or a single slash-separated resource string.

You can reference transient attributes when defining the values of other attributes in a factory. This allows you to use transient state to conditionally modify or construct standard attributes.

factory :user do
  transient do
    rockstar { true }
  end

  name { "John Doe#{" - Rockstar" if rockstar}" }
end

create(:user).name
#=> "John Doe - ROCKSTAR"

create(:user, rockstar: false).name
#=> "John Doe"

To automate factory linting, you can create a Rake task. The following implementation uses an ActiveRecord transaction to ensure that the records created during linting are rolled back, leaving your test database clean. It also includes logic to handle different environments.

# lib/tasks/factory_bot.rake
namespace :factory_bot do
  desc "Verify that all FactoryBot factories are valid"
  task lint: :environment do
    if Rails.env.test?
      conn = ActiveRecord::Base.connection
      conn.transaction do
        FactoryBot.lint
        raise ActiveRecord::Rollback
      end
    else
      system("bundle exec rake factory_bot:lint RAILS_ENV='test'")
      fail if $?.exitstatus.nonzero?
    end
  end
end

In Rails applications using factory_bot_rails, FactoryBot.find_definitions is called automatically after initialization. You can customize the file paths used for loading definitions in two ways:

1. Set .definition_file_paths within a Rails initializer (e.g., config/initializers/factory_bot.rb).
2. Use the Rails configuration object: Rails.application.config.factory_bot.definition_file_paths.