active_record_change_matchers 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e26db33cc55cb3efca1b3ef9824ce2e2c363636ef781f355e907afba1b68402
-  data.tar.gz: d322588b1fd5464acf44cdd75d5593fa64325cc5690d0d69f7eb002feacfff9c
+  metadata.gz: ff783e18ce73bf25fcd53447eefa3062d2b0e5994d20c9766e980522d7adf663
+  data.tar.gz: c34bcc770bdfe89d58cbe11f0f14e2659d55cfa908ba56f624dafba3efb2c5ed
 SHA512:
-  metadata.gz: 84e0d2efa264f21de6648b8fe8ed80591eec15376b56904115c48b0ea1123d759a1908c328736d1a4271a4b9e11cae255c67af61871167c987eb3ac4df2f5060
-  data.tar.gz: 2095854b7ff7cfc1f26ef4e052b282af373432d5d079c192bf57d2e23b8e0a401421f958776cc82413f9c2ecca633a029b70593bd1b03e9046a662e5cfbb1550
+  metadata.gz: 351cf1793f1682f8b3b38e7c4768e34f93622a2c71e9bf116f817692ae7031da0456af12aadaf1aacf9f6ccb68e5d0999ed6254ff38dd51f8f2100976331bf1d
+  data.tar.gz: e2df1ac06efb41a1bcdd1310f681afbf526dd7feb4353d176f610fc93501938dae34451fcf523a93fcd76be397e2be4ac58f1e7339da841bfc07b6c7bcf9309a

data/.github/workflows/main.yml

@@ -0,0 +1,33 @@
+name: Unit tests
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['3.3', '3.4', '4.0']
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+    - name: Prepare test database
+      run: bundle exec rake db:setup
+    - name: Run tests
+      run: bundle exec rspec

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Master (Unreleased)
 
+## 1.1.0 (2026-01-27)
+- Add `create_associated(scope)` matcher: verifies creation of new record(s) within an association scope (e.g. `record.items`). Supports `with_attributes`, `which`, `and_return_it`, and `and_return_them`. Model class is inferred from the scope.
+- Add `and_return_it` / `and_return_them` modifiers.
+- Drop support for Rails < 7
+
+## 1.0.1 (2024-07-03)
+- Fix broken timestamp stategy after adding the frozen time support.
+
 ## 1.0.0 (2024-07-03)
 
 Hard fork. Changes since the original version:

data/README.md

@@ -1,73 +1,113 @@
 # active_record_change_matchers
 
-Custom RSpec matchers for ActiveRecord record creation.
-This is a hard-fork of [active_record_block_matchers](https://github.com/nwallace/active_record_block_matchers). See [the changelog](CHANGELOG.md) for changes since the original gem was written.
+RSpec matchers that assert **exactly which** ActiveRecord records were created inside a block—by count, model, attributes, and association scope.
+
+This is a hard fork of [active_record_block_matchers](https://github.com/nwallace/active_record_block_matchers). See [CHANGELOG](CHANGELOG.md) for changes since the original.
+
+---
+
+## Table of contents
+
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [Matcher reference](#matcher-reference)
+  - [Summary](#matcher-summary)
+  - [create_a / create_a_new](#create_a--create_a_new)
+  - [create / create_records](#create--create_records)
+  - [create_associated](#create_associated)
+- [Record retrieval strategies](#record-retrieval-strategies)
+- [Configuration](#configuration)
+- [Tips and gotchas](#tips-and-gotchas)
+- [Development](#development)
+- [Contributing](#contributing)
+
+---
+
+## Requirements
+
+- **Ruby** ≥ 3.3
+- **Rails** ≥ 7 (ActiveRecord)
+- **RSpec** ≥ 3 (rspec-expectations)
+
+---
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add to your Gemfile:
 
 ```ruby
 gem 'active_record_change_matchers'
 ```
 
-And then execute:
-
-    $ bundle
+Then:
 
-Or install it yourself as:
+```bash
+bundle install
+```
 
-    $ gem install active_record_change_matchers
+---
 
-## Quick Examples
+## Quick start
 
 ```ruby
-expect {
-  post :create, user: { username: "bob", password: "BlueSteel45" }
-}.to create_a(User)
-  .with_attributes(username: "bob")
-  .which {|bob| expect(AuthLibrary.authenticate("bob", "BlueSteel45")).to eq bob }
+# One record of a given model
+expect { post :create, params: { user: { name: "Bob" } } }
+  .to create_a(User)
+  .with_attributes(name: "bob")   # e.g. after downcasing in a callback
 
-expect {
-  post :create, user: { username: "bob", password: "BlueSteel45" }
-}.to create(User => 1, Profile => 1)
+# Several models, exact counts
+expect { sign_up!("bob", "secret") }
+  .to create(User => 1, Profile => 1)
   .with_attributes(
-    User => [{username: "bob"}],
-    Profile => [{avatar_url: Avatar.default_avatar_url}],
-  ).which { |new_records_hash|
-    new_user = new_records_hash[User].first
-    new_profile = new_records_hash[Profile].first
-    expect(new_user.profile).to eq new_profile
+    User    => [{ name: "bob" }],
+    Profile => [{ avatar_url: Profile.default_avatar_url }]
+  )
+  .which { |records|
+    user = records[User].first
+    profile = records[Profile].first
+    expect(user.profile).to eq profile
   }
+
+# New records only within an association
+expect { create_items }
+  .to create_associated(record.items => 2)
+  .with_attributes([{ content: "item1" }, { content: "item2" }])
 ```
 
-## Detailed Examples
+---
 
-#### `create_a`
+## Matcher reference
 
-aliases: `create_an`, `create_a_new`
+### Matcher summary
 
-Example:
+| Matcher              | Aliases           | Use when you want to assert…                          |
+|----------------------|-------------------|--------------------------------------------------------|
+| `create_a(Model)`    | `create_an`, `create_a_new` | Exactly one new record of that model               |
+| `create(Model => n, …)` | `create_records`  | Exact counts of new records per model                 |
+| `create_associated(scope)` | —                | New records only within that association (e.g. `user.posts`) |
 
-```ruby
-expect { User.create! }.to create_a(User)
-```
+All support chaining:
 
-This can be very useful for controller tests:
+- **`.with_attributes(...)`** – attribute (or computed) expectations; works with [composable matchers](https://rspec.info/features/3-13/rspec-expectations/composing-matchers/).
+- **`.which { |record_or_hash| ... }`** – extra expectations in a block (e.g. associations, side effects).
+- **`.and_return_it`** / **`.and_return_them`** – that the block’s return value is the created record(s).
 
-```ruby
-expect { post :create, user: user_params }.to create_a(User)
-```
+`create_a` also supports **`.which_is_expected_to(matcher)`** for a single composable matcher on the new record.
+
+---
+
+### create_a / create_a_new
+
+Asserts the block creates **exactly one** new record of the given model. Ignores records that already existed before the block ran.
 
-You can chain `.with_attributes` as well to define a list of values you expect the new object to have.  This works with both database attributes and computed values.
+**Minimal:**
 
 ```ruby
-expect { User.create!(username: "bob") }
-  .to create_a(User)
-  .with_attributes(username: "bob")
+expect { User.create! }.to create_a(User)
 ```
 
-This is a great way to test ActiveReocrd hooks on your model.  For example, if your User model downcases all usernames before saving them to the database, you can test it like this:
+**With attributes** (DB columns or any reader, e.g. from callbacks):
 
 ```ruby
 expect { User.create!(username: "BOB") }
@@ -75,7 +115,7 @@ expect { User.create!(username: "BOB") }
   .with_attributes(username: "bob")
 ```
 
-You can even use RSpec's [composable matchers][^1]:
+**With composable matchers:**
 
 ```ruby
 expect { User.create!(username: "bob") }
@@ -83,133 +123,270 @@ expect { User.create!(username: "bob") }
   .with_attributes(username: a_string_starting_with("b"))
 ```
 
-If you need to make assertions about things other than attribute equality, you can also chain `.which_is_expected_to` with a (composable) matcher:
+**With a matcher (`.which_is_expected_to`):**
 
 ```ruby
-expect { User.create!(username: "BOB", password: "BlueSteel45") }
+expect { User.create!(username: "BOB", password: "secret") }
   .to create_a(User)
   .which_is_expected_to(
     have_attributes(encrypted_password: be_present)
-    .and(eq(AuthLibrary.authenticate("bob", "BlueSteel45")))
+      .and(eq(Auth.authenticate("bob", "secret")))
   )
 ```
 
-If that's doesn't provide enough flexibility, you can also chain `.which` with a block, and your block will receive the newly created record:
+**With a block (`.which`)** when you need full control:
 
 ```ruby
-expect { User.create!(username: "BOB", password: "BlueSteel45") }
+expect { User.create!(username: "BOB", password: "secret") }
   .to create_a(User)
   .which { |user|
     expect(user.encrypted_password).to be_present
-    expect(AuthLibrary.authenticate("bob", "BlueSteel45")).to eq user
+    expect(Auth.authenticate("bob", "secret")).to eq user
   }
 ```
 
-**Gotcha Warning:** Be careful about your block syntax when chaining `.which` in your tests. If you write the above example with a `do...end`, the example will parse like this: `expect {...}.to(create_a(User).which) do |user| ... end`, so your block will not execute, and it may appear that your test is passing, when it is not.
+**That the block returns the new record (`.and_return_it`):**
+
+```ruby
+expect { create_user(name: "bob") }
+  .to create_a(User)
+  .with_attributes(name: "bob")
+  .and_return_it
+```
+
+**Negated:** use `.not_to create_a(User)` to assert the block did *not* create exactly one `User` (e.g. created zero or more than one).
+
+**Failure cases:**
 
-#### `create`
+- Creates 0 → *"the block should have created 1 User, but created 0"*
+- Creates 2+ → *"the block should have created 1 User, but created 2"*
+- Attribute mismatch → *"Expected :username to be \"bob\", but was \"BOB\""*
+- `.which` or `.which_is_expected_to` fail → their messages are shown
 
-aliases: `create_records`
+---
 
-Example:
+### create / create_records
+
+Asserts the block creates **exactly** the given counts per model. Argument is a hash: `Model => count`.
+
+**Minimal:**
 
 ```ruby
 expect { User.create!; User.create!; Profile.create! }
   .to create(User => 2, Profile => 1)
 ```
 
-Just like the other matcher, you can chain `with_attributes` and `which` to assert about the particulars of the records:
+**With attributes:** provide one hash per created record. Keys are model classes; values are arrays of attribute hashes. Order of hashes need not match creation order.
 
 ```ruby
-expect { UserService.sign_up!(username: "bob", password: "BlueSteel45") }
-  .to create(User => 1, Profile => 1)
+expect { User.create!(username: "bob"); User.create!(username: "rhonda") }
+  .to create(User => 2)
   .with_attributes(
-    User => [{username: "bob"}],
-    Profile => [{avatar_url: Avatar.default_avatar_url}]
-  ).which { |records|
-    # records is a hash with model classes for keys and the new records for values
-    new_user = records[User].first
-    new_profile = records[Profile].first
-    expect(AuthLibrary.authenticate("bob", "BlueSteel45")).to eq new_user
-    expect(new_user.profile).to eq new_profile
-  }
+    User => [{ username: "rhonda" }, { username: "bob" }]
+  )
 ```
 
-As noted, the `which` block yields a hash containing the new records whose counts were specified.
+You must supply **as many attribute hashes as the expected count** for that model. Fewer raises an argument error; you can use empty hashes for records you don’t care to constrain:
 
-Order doesn't matter for the attributes specified in `with_attributes`, but you must provide an attribute hash for every record that was created. This means, if you expect the block to create, say 2 User records, you must provide an attributes hash for each new User record:
+```ruby
+.with_attributes(User => [{ username: "bob" }, {}])
+```
+
+**With a block (`.which`):** the block receives a hash `Model => [records]`:
 
 ```ruby
-# This is correct:
-expect { User.create!(username: "bob"); User.create!(username: "rhonda") }
-  .to create(User => 2)
+expect { sign_up!("bob", "secret") }
+  .to create(User => 1, Profile => 1)
   .with_attributes(
-    User => [{username: "rhonda"}, {username: "bob"}]
+    User    => [{ username: "bob" }],
+    Profile => [{ avatar_url: Profile.default_avatar_url }]
   )
+  .which { |records|
+    user = records[User].first
+    profile = records[Profile].first
+    expect(user.profile).to eq profile
+  }
+```
 
-# This will raise an error:
-expect { User.create!(username: "bob"); User.create!(username: "rhonda") }
-  .to create(User => 2)
-  .with_attributes(
-    User => [{username: "rhonda"}]
-  )
+**That the block returns all created records (`.and_return_them`):** the matcher checks that every created record appears in the block’s return value (array, relation, or any enumerable).
 
-# But this is totally fine if you really need a workaround:
-# Just put the empty hashes last
-expect { User.create!(username: "bob"); User.create!(username: "rhonda") }
-  .to create(User => 2)
+```ruby
+expect { [User.create!, User.create!] }.to create(User => 2).and_return_them
+```
+
+**Negated:** `.not_to create(User => 2)` asserts the block did not create exactly two `User`s.
+
+---
+
+### create_associated
+
+Asserts that new record(s) were created **within the given association scope(s)** only. The model is inferred from the scope (e.g. `user.posts` → `Post`). Other associations and pre-existing records are ignored.
+
+**Scope form (expects exactly one new record in that association):**
+
+```ruby
+expect { user.posts.create!(title: "Hi") }.to create_associated(user.posts)
+```
+
+**Hash form (expects the given count per scope):**
+
+```ruby
+expect {
+  user.posts.create!(title: "A")
+  user.posts.create!(title: "B")
+}.to create_associated(user.posts => 2)
+```
+
+**With attributes**
+
+- One scope, one record: pass a single hash.
+- One scope, many records: pass an array of hashes.
+- Multiple scopes: pass a hash keyed by scope, each value an array of attribute hashes.
+
+```ruby
+# One record, single hash
+expect { user.posts.create!(title: "Hi") }
+  .to create_associated(user.posts)
+  .with_attributes(title: "Hi")
+
+# One scope, multiple records
+expect { add_two_posts }
+  .to create_associated(user.posts => 2)
+  .with_attributes([{ title: "First" }, { title: "Second" }])
+
+# Multiple scopes
+expect { create_mine_and_theirs }
+  .to create_associated(user_a.posts => 1, user_b.posts => 1)
   .with_attributes(
-    User => [{username: "rhonda"}, {}]
+    user_a.posts => [{ title: "a" }],
+    user_b.posts => [{ title: "b" }]
   )
 ```
 
-## Record Retrieval Strategies
+**With `.which`:** the block receives a hash **model class => records** (same shape as `create` / `create_records`):
+
+```ruby
+expect { user.posts.create!(title: "x") }
+  .to create_associated(user.posts)
+  .which { |records_by_klass|
+    expect(records_by_klass[Post].first.title).to eq "x"
+  }
+```
+
+**Return value:**
+
+- Use **`.and_return_it`** only when expecting **exactly one** record (single scope, count 1). It asserts the block returns that record.
+- Use **`.and_return_them`** when expecting multiple records; it asserts the block’s return value contains all created records.
+
+Using `.and_return_it` with multiple records (e.g. `create_associated(scope => 2).and_return_it`) raises `ArgumentError`.
 
-There are currently two retrieval strategies implemented: `:id` and `:timestamp`. `:id` is the default, but this can be configured via the `default_strategy` configuration variable (more details [below](#configuration)).
+**Failure cases:**
 
-The ID and Timestamp Strategies work similarly. The ID Strategy queries the appropriate table(s) to find the highest ID value(s) before the block, then finds new records by looking for records with an ID that higher than that. The Timestamp Strategy uses `Time.current` to record the time before the block. Then it finds new records by looking for records that have a timestamp later than that.
+- No records in scope → *"The block should have created 1 Post within the scope, but created 0."*
+- Records created in a *different* association (or by another owner) are not counted—you’ll get “created 0” if the wrong scope was used.
+- Wrong count or attribute mismatch produces messages similar to `create` / `create_records`.
 
-The ID Strategy is the default because it doesn't rely on time values that may be imprecise or mocked out. The Timestamp Strategy is useful if your tables don't have autoincrementing integer primary keys.
+---
+
+## Record retrieval strategies
+
+The matchers need to know which rows were “new” after the block. Two strategies are built in:
+
+| Strategy    | How it finds new records | Default | When to use it |
+|-------------|--------------------------|----------|-----------------|
+| **`:id`**   | Compares max primary key before/after the block | ✓       | Tables with auto-increment integer PKs (default). |
+| **`:timestamp`** | Compares `created_at` (or configured column) before/after; supports frozen time | — | Non-integer PKs or no `id`. |
+
+**`:id`** is the default because it doesn’t depend on clock precision or time mocking. Use **`:timestamp`** when you don’t have a monotonic `id` (e.g. UUIDs, legacy schemas).
+
+Strategy can be set globally in [configuration](#configuration) or overridden per expectation:
+
+```ruby
+expect { Person.create! }.to create_a(Person, strategy: :timestamp)
+```
+
+`create_associated` uses the configured default strategy only (it has no per-call strategy option).
+
+---
 
 ## Configuration
 
-You can configure the column names used by the ID or Timestamp Strategies. Put code like this in your `spec_helper.rb` or similar file:
+Configure column names and default strategy in your RSpec setup (e.g. `spec/rails_helper.rb` or `spec_helper.rb`):
 
 ```ruby
 ActiveRecordChangeMatchers::Config.configure do |config|
-
-  # default value is "id"
+  # Primary key column for :id strategy (default: "id")
   config.id_column_name = "primary_key"
 
-  # default value is "created_at"
+  # Timestamp column for :timestamp strategy (default: "created_at")
   config.created_at_column_name = "created_timestamp"
 
-  # default value is :id
-  # must be one of [:id, :timestamp]
+  # Default strategy: :id or :timestamp (default: :id)
   config.default_strategy = :timestamp
 end
 ```
 
-You can also override the default strategy for individual assertions if needed:
+---
+
+## Tips and gotchas
+
+**Block syntax with `.which`**
+
+Use braces `{ }` for the block passed to `.which`. With `do ... end`, Ruby binds the block to `expect(...).to(...)` instead of `.which`, so the block may never run and the test can falsely pass:
 
 ```ruby
-expect { Person.create! }.to create_a(Person, strategy: :id)
+# Prefer:
+.to create_a(User).which { |user| expect(user.name).to eq "bob" }
+
+# Parsing trap with do/end:
+.to create_a(User).which do |user|
+  expect(user.name).to eq "bob"   # this block is not passed to .which
+end
+```
+
+**Composable matchers**
+
+`with_attributes` accepts RSpec composable matchers, which keeps specs readable and failure messages clear:
+
+```ruby
+.with_attributes(
+  username: a_string_matching(/\A[a-z]+\z/),
+  age:      be_between(18, 120)
+)
 ```
 
+**Attributes and virtual/derived values**
+
+`with_attributes` uses `record.public_send(field)` for each key, so you can assert on any public reader—database columns, delegations, or methods (e.g. `full_name` built from `first_name` and `last_name`).
+
+---
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+```bash
+git clone https://github.com/Darhazer/active_record_change_matchers
+cd active_record_change_matchers
+bin/setup
+bundle exec rspec
+```
+
+To install the gem locally:
+
+```bash
+bundle exec rake install
+```
 
-To install this gem onto your local machine, run `bundle exec rake install`.
+---
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/active_record_change_matchers/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+1. Fork the repo.
+2. Create a feature branch: `git checkout -b my-feature`
+3. Commit changes: `git commit -am 'Add my feature'`
+4. Push: `git push origin my-feature`
+5. Open a Pull Request against this repository.
 
+---
 
-[^1]: https://rspec.info/features/3-13/rspec-expectations/composing-matchers/
+**License:** MIT.  
+**Changelog:** [CHANGELOG.md](CHANGELOG.md).

data/Rakefile

@@ -8,9 +8,3 @@ RSpec::Core::RakeTask.new(:spec) do |t|
   t.pattern = Dir.glob('spec/**/*_spec.rb')
   t.rspec_opts = '--format documentation'
 end
-
-task :travis do
-  Rake::Task['db:setup'].invoke
-  Rake::Task[:spec].invoke
-end
-

data/active_record_change_matchers.gemspec

@@ -1,33 +1,32 @@
-# coding: utf-8
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "active_record_change_matchers/version"
+require 'active_record_change_matchers/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "active_record_change_matchers"
+  spec.name          = 'active_record_change_matchers'
   spec.version       = ActiveRecordChangeMatchers::VERSION
-  spec.authors       = ["Maxim Krizhanovski", "Nathan Wallace"]
-  spec.email         = ["maxim.krizhanovski@hey.com"]
+  spec.authors       = ['Maxim Krizhanovski', 'Nathan Wallace']
+  spec.email         = ['maxim.krizhanovski@hey.com']
 
-  spec.summary       = %q{Additional RSpec custom matchers for ActiveRecord}
-  spec.description   = %q{This gem adds custom block expectation matchers for RSpec, such as `expect { ... }.to create_a_new(User)`}
-  spec.homepage      = "https://github.com/Darhazer/active_record_change_matchers"
-  spec.license       = "MIT"
+  spec.summary       = 'Additional RSpec custom matchers for ActiveRecord'
+  spec.description   = 'This gem adds custom block expectation matchers for RSpec, such as `expect { ... }.to create_a_new(User)`'
+  spec.homepage      = 'https://github.com/Darhazer/active_record_change_matchers'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 1.9.3"
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 3.3.0'
 
-  spec.add_dependency "activerecord", ">= 3.2.0"
-  spec.add_dependency "rspec-expectations", ">= 3.0.0"
+  spec.add_dependency 'activerecord', '>= 7.0'
+  spec.add_dependency 'rspec-expectations', '>= 3.0.0'
 
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.6"
-  spec.add_development_dependency "pry", "~> 0.10"
-  spec.add_development_dependency "sqlite3", "~> 1.3"
-  spec.add_development_dependency "database_cleaner", "~> 1.6"
-  spec.add_development_dependency "standalone_migrations", "~> 5.2"
-  spec.add_development_dependency "timecop", "~> 0.9"
+  spec.add_development_dependency 'database_cleaner'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'standalone_migrations'
+  spec.add_development_dependency 'timecop'
 end

data/db/migrate/20150225014908_create_people.rb

@@ -1,4 +1,4 @@
-class CreatePeople < ActiveRecord::Migration
+class CreatePeople < ActiveRecord::Migration[6.0]
   def change
     create_table :people do |t|
       t.string :first_name

data/db/migrate/20151017231107_create_dogs.rb

@@ -1,4 +1,4 @@
-class CreateDogs < ActiveRecord::Migration
+class CreateDogs < ActiveRecord::Migration[6.0]
   def change
     create_table :dogs do |t|
       t.string :name

data/db/migrate/20160101000000_create_pets.rb

@@ -0,0 +1,9 @@
+class CreatePets < ActiveRecord::Migration[6.0]
+  def change
+    create_table :pets do |t|
+      t.references :person, null: false, foreign_key: true
+      t.string :name
+      t.timestamps
+    end
+  end
+end