factory_bot 6.1.0 → 6.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe33ad3bb5d907e38ceac543f969484fb0ec67a4708a701cdfea0696d4a292c4
-  data.tar.gz: 54cdb44f4ac7782360c8e9efd02ac46f40336d00c34a5767d5d7fc0f86f8d7a5
+  metadata.gz: a928c94babd835a0756175aa3d7a1f03d4dae15b0782818a8c9688489f6e18d3
+  data.tar.gz: e2875eca60137531b83267dcdfd87ba1329ed8a52e460a0e609fa5fb04f39244
 SHA512:
-  metadata.gz: cdc3ec9def71e797058fb13cff95b911eceb61d1488f193ef1bfb6bdf12c6c7835d1f67dc1885d5539e6da7135f04e4a417a16fbc60cbc0c4d60056a1948c89d
-  data.tar.gz: 2f04ab1a184266a86cf8510be688b8a01b0dd570615d25e314176b4492f9635053596636aa4ec9ab8133e86e4c9f630acdb52468c01ea1bfd2fb8777fc27b2ab
+  metadata.gz: bf8f7006ff4e0f34533259c6e747bb61cd8ebcd6d68b7a9076b811bf4b152662997f18ad467953c07f3a0c7c10585b48b4f0489ce6aa1a16b42ad02641e7169b
+  data.tar.gz: a80c3ed49517c2cee0dc7bdafc9dd3459d7fcd83443873e2a8c72db8a3c96b6d902975c8a586ecbfb1cd6b8dab9513a4bdfaa22f84c297f81b2736a8f4317e8d

data/CONTRIBUTING.md

@@ -51,6 +51,12 @@ Here are some ways *you* can contribute:
   asking for help. We love helping!
 * Please don't update the Gem version.
 
+## Setting up
+
+```sh
+bundle install
+```
+
 ## Running the test suite
 
 The default rake task will run the full test suite and [standard]:

data/GETTING_STARTED.md

@@ -37,12 +37,15 @@ Getting Started
 * [Associations](#associations)
   + [Implicit definition](#implicit-definition)
   + [Explicit definition](#explicit-definition)
+  + [Inline definition](#inline-definition)
   + [Specifying the factory](#specifying-the-factory)
   + [Overriding attributes](#overriding-attributes)
+  + [Association overrides](#association-overrides)
   + [Build strategies](#build-strategies-1)
   + [`has_many` associations](#has_many-associations)
   + [`has_and_belongs_to_many` associations](#has_and_belongs_to_many-associations)
   + [Polymorphic associations](#polymorphic-associations)
+  + [Interconnected associations](#interconnected-associations)
 * [Sequences](#sequences)
   + [Global sequences](#global-sequences)
   + [With dynamic attributes](#with-dynamic-attributes)
@@ -197,17 +200,15 @@ It is also possible to explicitly specify the class:
 
 ```ruby
 # This will use the User class (otherwise Admin would have been guessed)
-factory :admin, class: User
+factory :admin, class: "User"
 ```
 
-If the constant is not available
-(if you are using a Rails engine that waits to load models, for example),
-you can also pass a symbol or string,
-which factory\_bot will constantize later, once you start building objects:
+You can pass a constant as well, if the constant is available (note that this
+can cause test performance problems in large Rails applications, since
+referring to the constant will cause it to be eagerly loaded).
 
 ```ruby
-# It's OK if Doorkeeper::AccessToken isn't loaded yet
-factory :access_token, class: "Doorkeeper::AccessToken"
+factory :access_token, class: User
 ```
 
 ### Hash attributes
@@ -312,17 +313,17 @@ factory :user, aliases: [:author, :commenter] do
 end
 
 factory :post do
-  author
-  # instead of
+  # The alias allows us to write author instead of
   # association :author, factory: :user
+  author
   title { "How to read a book effectively" }
   body { "There are five steps involved." }
 end
 
 factory :comment do
-  commenter
-  # instead of
+  # The alias allows us to write commenter instead of
   # association :commenter, factory: :user
+  commenter
   body { "Great article!" }
 end
 ```
@@ -346,6 +347,7 @@ create(:user, last_name: "Doe").email
 
 Transient Attributes
 --------------------
+Transient attributes are attributes only available within the factory definition, and not set on the object being built. This allows for more complex logic inside factories.
 
 ### With other attributes
 
@@ -505,6 +507,19 @@ factory :post do
 end
 ```
 
+### Inline definition
+
+You can also define associations inline within regular attributes,
+but note that the value will be `nil`
+when using the `attributes_for` strategy.
+
+```ruby
+factory :post do
+  # ...
+  author { association :author }
+end
+```
+
 ### Specifying the factory
 
 You can specify a different factory (although [Aliases](#aliases) might also
@@ -528,6 +543,15 @@ factory :post do
 end
 ```
 
+Inline:
+
+```ruby
+factory :post do
+  # ...
+  author { association :user }
+end
+```
+
 ### Overriding attributes
 
 You can also override attributes.
@@ -551,6 +575,35 @@ factory :post do
 end
 ```
 
+Or inline using attributes from the factory:
+
+```rb
+factory :post do
+  # ...
+  author_last_name { "Writely" }
+  author { association :author, last_name: author_last_name }
+end
+```
+
+### Association overrides
+
+Attribute overrides can be used to link associated objects:
+
+```ruby
+FactoryBot.define do
+  factory :author do
+    author_last_name { 'Taylor' }
+  end
+
+  factory :post do
+    author
+  end
+end
+
+eunji = build(:author, name: 'Eunji')
+post = build(:post, author: eunji)
+```
+
 ### Build strategies
 
 In factory\_bot 5, associations default to using the same build strategy as
@@ -620,27 +673,51 @@ factory :post do
 
 ### `has_many` associations
 
-Generating data for a `has_many` relationship is a bit more involved,
-depending on the amount of flexibility desired, but here's a surefire example
-of generating associated data.
+There are a few ways to generate data for a `has_many` relationship. The
+simplest approach is to write a helper method in plain Ruby to tie together the
+different records:
 
 ```ruby
 FactoryBot.define do
+  factory :post do
+    title { "Through the Looking Glass" }
+    user
+  end
+
+  factory :user do
+    name { "Rachel Sanchez" }
+  end
+end
+
+def user_with_posts(posts_count: 5)
+  FactoryBot.create(:user) do |user|
+    FactoryBot.create_list(:post, posts_count, user: user)
+  end
+end
+
+create(:user).posts.length # 0
+user_with_posts.posts.length # 5
+user_with_posts(posts_count: 15).posts.length # 15
+```
+
+If you prefer to keep the object creation fully within factory\_bot, you can
+build the posts in an `after(:create)` callback.
 
-  # post factory with a `belongs_to` association for the user
+
+```ruby
+FactoryBot.define do
   factory :post do
     title { "Through the Looking Glass" }
     user
   end
 
-  # user factory without associated posts
   factory :user do
     name { "John Doe" }
 
     # user_with_posts will create post data after the user has been created
     factory :user_with_posts do
-      # posts_count is declared as a transient attribute and available in
-      # attributes on the factory, as well as the callback via the evaluator
+      # posts_count is declared as a transient attribute available in the
+      # callback via the evaluator
       transient do
         posts_count { 5 }
       end
@@ -651,71 +728,122 @@ FactoryBot.define do
       # to create and we make sure the user is associated properly to the post
       after(:create) do |user, evaluator|
         create_list(:post, evaluator.posts_count, user: user)
+
+        # You may need to reload the record here, depending on your application
+        user.reload
       end
     end
   end
 end
+
+create(:user).posts.length # 0
+create(:user_with_posts).posts.length # 5
+create(:user_with_posts, posts_count: 15).posts.length # 15
 ```
 
-This allows us to do:
+Or, for a solution that works with `build`, `build_stubbed`, and `create`
+(although it doesn't work well with `attributes_for`), you can use inline
+associations:
 
 ```ruby
+FactoryBot.define do
+  factory :post do
+    title { "Through the Looking Glass" }
+    user
+  end
+
+  factory :user do
+    name { "Taylor Kim" }
+
+    factory :user_with_posts do
+      posts { [association(:post)] }
+    end
+  end
+end
+
 create(:user).posts.length # 0
+create(:user_with_posts).posts.length # 1
+build(:user_with_posts).posts.length # 1
+build_stubbed(:user_with_posts).posts.length # 1
+```
+
+For more flexibility you can combine this with the `posts_count` transient
+attribute from the callback example:
+
+```ruby
+FactoryBot.define do
+  factory :post do
+    title { "Through the Looking Glass" }
+    user
+  end
+
+  factory :user do
+    name { "Adiza Kumato" }
+
+    factory :user_with_posts do
+      transient do
+        posts_count { 5 }
+      end
+
+      posts do
+        Array.new(posts_count) { association(:post) }
+      end
+    end
+  end
+end
+
 create(:user_with_posts).posts.length # 5
 create(:user_with_posts, posts_count: 15).posts.length # 15
+build(:user_with_posts, posts_count: 15).posts.length # 15
+build_stubbed(:user_with_posts, posts_count: 15).posts.length # 15
 ```
 
 ### `has_and_belongs_to_many` associations
 
 Generating data for a `has_and_belongs_to_many` relationship is very similar
-to the above `has_many` relationship, with a small change, you need to pass an
+to the above `has_many` relationship, with a small change: you need to pass an
 array of objects to the model's pluralized attribute name rather than a single
 object to the singular version of the attribute name.
 
-Here's an example with two models that are related via
- `has_and_belongs_to_many`:
 
 ```ruby
-FactoryBot.define do
-
-  # language factory with a `belongs_to` association for the profile
-  factory :language do
-    title { "Through the Looking Glass" }
-    profile
+def profile_with_languages(languages_count: 2)
+  FactoryBot.create(:profile) do |profile|
+    FactoryBot.create_list(:language, languages_count, profiles: [profile])
   end
+end
+```
 
-  # profile factory without associated languages
-  factory :profile do
-    name { "John Doe" }
+Or with the callback approach:
 
-    # profile_with_languages will create language data after the profile has
-    # been created
-    factory :profile_with_languages do
-      # languages_count is declared as an ignored attribute and available in
-      # attributes on the factory, as well as the callback via the evaluator
-      transient do
-        languages_count { 5 }
-      end
+```ruby
+factory :profile_with_languages do
+  transient do
+    languages_count { 2 }
+  end
 
-      # the after(:create) yields two values; the profile instance itself and
-      # the evaluator, which stores all values from the factory, including
-      # ignored attributes; `create_list`'s second argument is the number of
-      # records to create and we make sure the profile is associated properly
-      # to the language
-      after(:create) do |profile, evaluator|
-        create_list(:language, evaluator.languages_count, profiles: [profile])
-      end
-    end
+  after(:create) do |profile, evaluator|
+    create_list(:language, evaluator.languages_count, profiles: [profile])
+    profile.reload
   end
 end
 ```
 
-This allows us to do:
+Or the inline association approach (note the use of the `instance` method here
+to refer to the profile being built):
 
 ```ruby
-create(:profile).languages.length # 0
-create(:profile_with_languages).languages.length # 5
-create(:profile_with_languages, languages_count: 15).languages.length # 15
+factory :profile_with_languages do
+  transient do
+    languages_count { 2 }
+  end
+
+  languages do
+    Array.new(languages_count) do
+      association(:language, profiles: [instance])
+    end
+  end
+end
 ```
 
 ### Polymorphic associations
@@ -749,6 +877,61 @@ create(:comment, :for_video)
 create(:comment, :for_photo)
 ```
 
+### Interconnected associations
+
+There are limitless ways objects might be interconnected, and
+factory\_bot may not always be suited to handle those relationships. In some
+cases it makes sense to use factory\_bot to build each individual object, and
+then to write helper methods in plain Ruby to tie those objects together.
+
+That said, some more complex, interconnected relationships can be built in factory\_bot
+using inline associations with reference to the `instance` being built.
+
+Let's say your models look like this, where an associated `Student` and
+`Profile` should both belong to the same `School`:
+
+```ruby
+class Student < ApplicationRecord
+  belongs_to :school
+  has_one :profile
+end
+
+class Profile < ApplicationRecord
+  belongs_to :school
+  belongs_to :student
+end
+
+class School < ApplicationRecord
+  has_many :students
+  has_many :profiles
+end
+```
+
+We can ensure the student and profile are connected to each other and to the
+same school with a factory like this:
+
+```ruby
+FactoryBot.define do
+  factory :student do
+    school
+    profile { association :profile, student: instance, school: school }
+  end
+
+  factory :profile do
+    school
+    student { association :student, profile: instance, school: school }
+  end
+
+  factory :school
+end
+```
+
+Note that this approach works with `build`, `build_stubbed`, and `create`, but
+the associations will return `nil` when using `attributes_for`.
+
+Also, note that if you assign any attributes inside a custom `initialize_with` 
+(e.g. `initialize_with { new(**attributes) }`), those attributes should not refer to `instance`,
+since it will be `nil`.
 
 Sequences
 ---------
@@ -811,7 +994,7 @@ end
 
 ### Initial value
 
-You can override the initial value. Any value that response to the `#next`
+You can override the initial value. Any value that responds to the `#next`
 method will work (e.g. 1, 2, 3, 'a', 'b', 'c')
 
 ```ruby
@@ -960,16 +1143,16 @@ factory :user do
   name { "Friendly User" }
   login { name }
 
-  trait :male do
+  trait :active do
     name { "John Doe" }
-    gender { "Male" }
-    login { "#{name} (M)" }
+    status { :active }
+    login { "#{name} (active)" }
   end
 
-  trait :female do
+  trait :inactive do
     name { "Jane Doe" }
-    gender { "Female" }
-    login { "#{name} (F)" }
+    status { :inactive }
+    login { "#{name} (inactive)" }
   end
 
   trait :admin do
@@ -977,8 +1160,8 @@ factory :user do
     login { "admin-#{name}" }
   end
 
-  factory :male_admin,   traits: [:male, :admin]   # login will be "admin-John Doe"
-  factory :female_admin, traits: [:admin, :female] # login will be "Jane Doe (F)"
+  factory :active_admin,   traits: [:active, :admin]   # login will be "admin-John Doe"
+  factory :inactive_admin, traits: [:admin, :inactive] # login will be "Jane Doe (inactive)"
 end
 ```
 
@@ -991,14 +1174,14 @@ factory :user do
   name { "Friendly User" }
   login { name }
 
-  trait :male do
+  trait :active do
     name { "John Doe" }
-    gender { "Male" }
+    status { :active }
     login { "#{name} (M)" }
   end
 
   factory :brandon do
-    male
+    active
     name { "Brandon" }
   end
 end
@@ -1013,9 +1196,9 @@ from factory\_bot.
 factory :user do
   name { "Friendly User" }
 
-  trait :male do
+  trait :active do
     name { "John Doe" }
-    gender { "Male" }
+    status { :active }
   end
 
   trait :admin do
@@ -1023,8 +1206,8 @@ factory :user do
   end
 end
 
-# creates an admin user with gender "Male" and name "Jon Snow"
-create(:user, :admin, :male, name: "Jon Snow")
+# creates an admin user with :active status and name "Jon Snow"
+create(:user, :admin, :active, name: "Jon Snow")
 ```
 
 This ability works with `build`, `build_stubbed`, `attributes_for`, and `create`.
@@ -1042,8 +1225,8 @@ factory :user do
   end
 end
 
-# creates 3 admin users with gender "Male" and name "Jon Snow"
-create_list(:user, 3, :admin, :male, name: "Jon Snow")
+# creates 3 admin users with :active status and name "Jon Snow"
+create_list(:user, 3, :admin, :active, name: "Jon Snow")
 ```
 
 ### With associations
@@ -1342,7 +1525,6 @@ FactoryBot.define do
   factory :application_user, parent: :user do
     full_name { "Jane Doe" }
     date_of_birth { 21.years.ago }
-    gender { "Female" }
     health { 90 }
   end
 end
@@ -1355,7 +1537,6 @@ FactoryBot.modify do
   factory :user do
     full_name { "Jane Doe" }
     date_of_birth { 21.years.ago }
-    gender { "Female" }
     health { 90 }
   end
 end
@@ -1567,7 +1748,7 @@ factory :user do
 
   name "John Doe"
 
-  initialize_with { new(attributes) }
+  initialize_with { new(**attributes) }
 end
 ```
 

data/NEWS.md

@@ -1,5 +1,11 @@
 # News
 
+## 6.2.0 (May 7, 2021)
+  * Added: support for Ruby 3.0
+  * Changed: Include factory or trait name in error messages for missing traits. d05a9a3c
+  * Changed: Switched from Travis CI to GitHub Actions
+  * Fixed: More Ruby 2.7 kwarg deprecation warnings
+
 ## 6.1.0 (July 8, 2020)
   * Added: public reader for the evaluation instance, helpful for building interrelated associations
   * Changed: raise a more helpful error when passing an invalid argument to an association
@@ -20,6 +26,7 @@
   * Added: `build_stubbed_starting_id=` option to define the starting id for `build_stubbed`
   * Removed: deprecated methods on the top-level `FactoryBot` module meant only for internal use
   * Removed: support for EOL versions of Ruby (2.3, 2.4) and Rails (4.2)
+  * Removed: support for "abstract" factories with no associated class; use traits instead.
 
 ## 5.2.0 (April 24, 2020)
   * Added: Pass index to block for `*_list` methods

data/README.md

@@ -43,7 +43,7 @@ gem install factory_bot
 Supported Ruby versions
 -----------------------
 
-Supported Ruby versions are listed in [`.travis.yml`](https://github.com/thoughtbot/factory_bot/blob/master/.travis.yml)
+Supported Ruby versions are listed in [`.github/workflows/build.yml`](https://github.com/thoughtbot/factory_bot/blob/master/.github/workflows/build.yml)
 
 More Information
 ----------------
@@ -94,8 +94,8 @@ See [our other projects][community] or
 
 [community]: https://thoughtbot.com/community?utm_source=github
 [hire]: https://thoughtbot.com/hire-us?utm_source=github
-[ci-image]: https://travis-ci.org/thoughtbot/factory_bot.svg
-[ci]: https://travis-ci.org/thoughtbot/factory_bot?branch=master
+[ci-image]: https://github.com/thoughtbot/factory_bot/actions/workflows/build.yml/badge.svg
+[ci]: https://github.com/thoughtbot/factory_bot/actions?query=workflow%3A.github%2Fworkflows%2Fbuild.yml+branch%3Amaster++
 [grade-image]: https://codeclimate.com/github/thoughtbot/factory_bot/badges/gpa.svg
 [grade]: https://codeclimate.com/github/thoughtbot/factory_bot
 [version-image]: https://badge.fury.io/rb/factory_bot.svg

data/lib/factory_bot/attribute/dynamic.rb

@@ -12,7 +12,7 @@ module FactoryBot
 
         -> {
           value = case block.arity
-                  when 1, -1 then instance_exec(self, &block)
+                  when 1, -1, -2 then instance_exec(self, &block)
                   else instance_exec(&block)
           end
           raise SequenceAbuseError if FactoryBot::Sequence === value

data/lib/factory_bot/callback.rb

@@ -9,7 +9,7 @@ module FactoryBot
 
     def run(instance, evaluator)
       case block.arity
-      when 1, -1 then syntax_runner.instance_exec(instance, &block)
+      when 1, -1, -2 then syntax_runner.instance_exec(instance, &block)
       when 2 then syntax_runner.instance_exec(instance, evaluator, &block)
       else syntax_runner.instance_exec(&block)
       end

data/lib/factory_bot/decorator/invocation_tracker.rb

@@ -6,17 +6,11 @@ module FactoryBot
         @invoked_methods = []
       end
 
-      if ::Gem::Version.new(::RUBY_VERSION) >= ::Gem::Version.new("2.7")
-        def method_missing(name, *args, **kwargs, &block) # rubocop:disable Style/MissingRespondToMissing
-          @invoked_methods << name
-          super
-        end
-      else
-        def method_missing(name, *args, &block) # rubocop:disable Style/MissingRespondToMissing
-          @invoked_methods << name
-          super
-        end
+      def method_missing(name, *args, &block) # rubocop:disable Style/MissingRespondToMissing
+        @invoked_methods << name
+        super
       end
+      ruby2_keywords :method_missing if respond_to?(:ruby2_keywords, true)
 
       def __invoked_methods__
         @invoked_methods.uniq

data/lib/factory_bot/definition.rb

@@ -30,7 +30,7 @@ module FactoryBot
     end
 
     def to_create(&block)
-      if block_given?
+      if block
         @to_create = block
       else
         aggregate_from_traits_and_self(:to_create) { @to_create }.last
@@ -111,6 +111,20 @@ module FactoryBot
 
     def base_traits
       @base_traits.map { |name| trait_by_name(name) }
+    rescue KeyError => error
+      raise error_with_definition_name(error)
+    end
+
+    def error_with_definition_name(error)
+      message = error.message
+      message.insert(
+        message.index("\nDid you mean?") || message.length,
+        " referenced within \"#{name}\" definition"
+      )
+
+      error.class.new(message).tap do |new_error|
+        new_error.set_backtrace(error.backtrace)
+      end
     end
 
     def additional_traits

data/lib/factory_bot/evaluator.rb

@@ -35,23 +35,14 @@ module FactoryBot
 
     attr_accessor :instance
 
-    if ::Gem::Version.new(::RUBY_VERSION) >= ::Gem::Version.new("2.7")
-      def method_missing(method_name, *args, **kwargs, &block) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
-        if @instance.respond_to?(method_name)
-          @instance.send(method_name, *args, **kwargs, &block)
-        else
-          SyntaxRunner.new.send(method_name, *args, **kwargs, &block)
-        end
-      end
-    else
-      def method_missing(method_name, *args, &block) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
-        if @instance.respond_to?(method_name)
-          @instance.send(method_name, *args, &block)
-        else
-          SyntaxRunner.new.send(method_name, *args, &block)
-        end
+    def method_missing(method_name, *args, &block) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
+      if @instance.respond_to?(method_name)
+        @instance.send(method_name, *args, &block)
+      else
+        SyntaxRunner.new.send(method_name, *args, &block)
       end
     end
+    ruby2_keywords :method_missing if respond_to?(:ruby2_keywords, true)
 
     def respond_to_missing?(method_name, _include_private = false)
       @instance.respond_to?(method_name) || SyntaxRunner.new.respond_to?(method_name)

data/lib/factory_bot/registry.rb

@@ -25,7 +25,7 @@ module FactoryBot
       raise key_error_with_custom_message(e)
     end
 
-    alias [] find
+    alias_method :[], :find
 
     def register(name, item)
       @items[name] = item

data/lib/factory_bot/syntax/default.rb

@@ -15,7 +15,7 @@ module FactoryBot
         def factory(name, options = {}, &block)
           factory = Factory.new(name, options)
           proxy = FactoryBot::DefinitionProxy.new(factory.definition)
-          proxy.instance_eval(&block) if block_given?
+          proxy.instance_eval(&block) if block
 
           Internal.register_factory(factory)
 

data/lib/factory_bot/trait.rb

@@ -9,7 +9,7 @@ module FactoryBot
       @definition = Definition.new(@name)
       proxy = FactoryBot::DefinitionProxy.new(@definition)
 
-      if block_given?
+      if block
         proxy.instance_eval(&@block)
       end
     end

data/lib/factory_bot/version.rb

@@ -1,3 +1,3 @@
 module FactoryBot
-  VERSION = "6.1.0".freeze
+  VERSION = "6.2.0".freeze
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: factory_bot
 version: !ruby/object:Gem::Version
-  version: 6.1.0
+  version: 6.2.0
 platform: ruby
 authors:
 - Josh Clayton
 - Joe Ferris
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-08 00:00:00.000000000 Z
+date: 2021-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -237,7 +237,7 @@ homepage: https://github.com/thoughtbot/factory_bot
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -252,8 +252,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.16
+signing_key:
 specification_version: 4
 summary: factory_bot provides a framework and DSL for defining and using model instance
   factories.