active_record_change_matchers 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3e26db33cc55cb3efca1b3ef9824ce2e2c363636ef781f355e907afba1b68402
+  data.tar.gz: d322588b1fd5464acf44cdd75d5593fa64325cc5690d0d69f7eb002feacfff9c
+SHA512:
+  metadata.gz: 84e0d2efa264f21de6648b8fe8ed80591eec15376b56904115c48b0ea1123d759a1908c328736d1a4271a4b9e11cae255c67af61871167c987eb3ac4df2f5060
+  data.tar.gz: 2095854b7ff7cfc1f26ef4e052b282af373432d5d079c192bf57d2e23b8e0a401421f958776cc82413f9c2ecca633a029b70593bd1b03e9046a662e5cfbb1550

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+*.sqlite3
+.idea/

data/.rspec

@@ -0,0 +1,3 @@
+--format progress
+--color
+--order random

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+rvm:
+  - 2.2.2
+  - 2.2.3
+  - 2.2.4
+  - 2.2.5
+  - 2.2.6
+  - 2.3.0
+  - 2.3.1
+  - 2.3.2
+  - 2.3.3
+before_install:
+  - gem install bundler -v 1.13
+script: rake travis

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## Master (Unreleased)
+
+## 1.0.0 (2024-07-03)
+
+Hard fork. Changes since the original version:
+- Support for frozen time when working with the Timestamp strategy ([original issue](https://github.com/nwallace/active_record_block_matchers/issues/10))
+- which_is_expected_to modifier modifier ([original issue](https://github.com/nwallace/active_record_block_matchers/issues/9))

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in active_record_change_matchers.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Nathan Wallace
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,215 @@
+# 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.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_record_change_matchers'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_record_change_matchers
+
+## Quick Examples
+
+```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 }
+
+expect {
+  post :create, user: { username: "bob", password: "BlueSteel45" }
+}.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
+  }
+```
+
+## Detailed Examples
+
+#### `create_a`
+
+aliases: `create_an`, `create_a_new`
+
+Example:
+
+```ruby
+expect { User.create! }.to create_a(User)
+```
+
+This can be very useful for controller tests:
+
+```ruby
+expect { post :create, user: user_params }.to create_a(User)
+```
+
+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.
+
+```ruby
+expect { User.create!(username: "bob") }
+  .to create_a(User)
+  .with_attributes(username: "bob")
+```
+
+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:
+
+```ruby
+expect { User.create!(username: "BOB") }
+  .to create_a(User)
+  .with_attributes(username: "bob")
+```
+
+You can even use RSpec's [composable matchers][^1]:
+
+```ruby
+expect { User.create!(username: "bob") }
+  .to create_a(User)
+  .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:
+
+```ruby
+expect { User.create!(username: "BOB", password: "BlueSteel45") }
+  .to create_a(User)
+  .which_is_expected_to(
+    have_attributes(encrypted_password: be_present)
+    .and(eq(AuthLibrary.authenticate("bob", "BlueSteel45")))
+  )
+```
+
+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:
+
+```ruby
+expect { User.create!(username: "BOB", password: "BlueSteel45") }
+  .to create_a(User)
+  .which { |user|
+    expect(user.encrypted_password).to be_present
+    expect(AuthLibrary.authenticate("bob", "BlueSteel45")).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.
+
+#### `create`
+
+aliases: `create_records`
+
+Example:
+
+```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:
+
+```ruby
+expect { UserService.sign_up!(username: "bob", password: "BlueSteel45") }
+  .to create(User => 1, Profile => 1)
+  .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
+  }
+```
+
+As noted, the `which` block yields a hash containing the new records whose counts were specified.
+
+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
+# This is correct:
+expect { User.create!(username: "bob"); User.create!(username: "rhonda") }
+  .to create(User => 2)
+  .with_attributes(
+    User => [{username: "rhonda"}, {username: "bob"}]
+  )
+
+# This will raise an error:
+expect { User.create!(username: "bob"); User.create!(username: "rhonda") }
+  .to create(User => 2)
+  .with_attributes(
+    User => [{username: "rhonda"}]
+  )
+
+# 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)
+  .with_attributes(
+    User => [{username: "rhonda"}, {}]
+  )
+```
+
+## Record Retrieval Strategies
+
+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)).
+
+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.
+
+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.
+
+## 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:
+
+```ruby
+ActiveRecordChangeMatchers::Config.configure do |config|
+
+  # default value is "id"
+  config.id_column_name = "primary_key"
+
+  # default value is "created_at"
+  config.created_at_column_name = "created_timestamp"
+
+  # default value is :id
+  # must be one of [:id, :timestamp]
+  config.default_strategy = :timestamp
+end
+```
+
+You can also override the default strategy for individual assertions if needed:
+
+```ruby
+expect { Person.create! }.to create_a(Person, strategy: :id)
+```
+
+
+## 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.
+
+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]: https://rspec.info/features/3-13/rspec-expectations/composing-matchers/

data/Rakefile

@@ -0,0 +1,16 @@
+require "bundler/gem_tasks"
+require "standalone_migrations"
+require 'rspec/core/rake_task'
+
+StandaloneMigrations::Tasks.load_tasks
+
+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_block_matchers.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "active_record_change_matchers/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_record_change_matchers"
+  spec.version       = ActiveRecordChangeMatchers::VERSION
+  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.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  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.add_dependency "activerecord", ">= 3.2.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"
+end

data/active_record_change_matchers.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "active_record_change_matchers/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_record_change_matchers"
+  spec.version       = ActiveRecordChangeMatchers::VERSION
+  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.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  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.add_dependency "activerecord", ">= 3.2.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"
+end

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "active_record_change_matchers"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+RAILS_ENV=test rake db:setup

data/db/config.yml

@@ -0,0 +1,11 @@
+development:
+  adapter: sqlite3
+  database: db/development.sqlite3
+  pool: 5
+  timeout: 5000
+
+test: &test
+  adapter: sqlite3
+  database: db/test.sqlite3
+  pool: 5
+  timeout: 5000

data/db/migrate/20150225014908_create_people.rb

@@ -0,0 +1,9 @@
+class CreatePeople < ActiveRecord::Migration
+  def change
+    create_table :people do |t|
+      t.string :first_name
+      t.string :last_name
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20151017231107_create_dogs.rb

@@ -0,0 +1,9 @@
+class CreateDogs < ActiveRecord::Migration
+  def change
+    create_table :dogs do |t|
+      t.string :name
+      t.string :breed
+      t.timestamps
+    end
+  end
+end

data/db/schema.rb

@@ -0,0 +1,29 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema.define(version: 20151017231107) do
+
+  create_table "dogs", force: :cascade do |t|
+    t.string   "name"
+    t.string   "breed"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "people", force: :cascade do |t|
+    t.string   "first_name"
+    t.string   "last_name"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+end

data/lib/active_record_block_matchers.rb

@@ -0,0 +1,7 @@
+require "rspec/expectations"
+require "active_record"
+
+Dir[File.dirname(__FILE__) + "/active_record_change_matchers/**/*.rb"].each {|file| require file }
+
+module ActiveRecordChangeMatchers
+end

data/lib/active_record_change_matchers/config.rb

@@ -0,0 +1,32 @@
+module ActiveRecordChangeMatchers
+  class Config
+
+    def self.configure
+      yield self
+    end
+
+    def self.default_strategy
+      @default_strategy || :id
+    end
+
+    def self.default_strategy=(strategy_key)
+      @default_strategy = strategy_key.to_sym
+    end
+
+    def self.created_at_column_name
+      @created_at_column_name || "created_at"
+    end
+
+    def self.created_at_column_name=(column_name)
+      @created_at_column_name = column_name
+    end
+
+    def self.id_column_name
+      @id_column_name || "id"
+    end
+
+    def self.id_column_name=(column_name)
+      @id_column_name = column_name
+    end
+  end
+end

data/lib/active_record_change_matchers/create_a_new_matcher.rb

@@ -0,0 +1,94 @@
+RSpec::Matchers.define :create_a_new do |klass|
+  supports_block_expectations
+
+  description do
+    "create a #{klass}, optionally verifying attributes"
+  end
+
+  chain(:with_attributes) do |attributes|
+    @attributes = attributes
+  end
+
+  chain(:which) do |&block|
+    @which_block = block
+  end
+
+  chain(:which_is_expected_to) do |matcher|
+    @which_matcher = matcher
+  end
+
+  match do |options={}, block|
+    fetching_strategy =
+      ActiveRecordChangeMatchers::Strategies.for_key(options[:strategy]).new(block)
+
+    @created_records = fetching_strategy.new_records([klass])[klass]
+
+    return false unless @created_records.count == 1 # ? this shouldn't be necessary for all strategies...
+
+    record = @created_records.first
+
+    @attribute_mismatches = []
+
+    @attributes && @attributes.each do |field, value|
+      unless values_match?(value, record.public_send(field))
+        @attribute_mismatches << [field, value, record.public_send(field)]
+      end
+    end
+ 
+    if @attribute_mismatches.none? && @which_block
+      begin
+        @which_block.call(record)
+      rescue RSpec::Expectations::ExpectationNotMetError => e
+        @which_failure = e
+      end
+    end
+
+    if @attribute_mismatches.none? && @which_matcher
+      unless @which_matcher.matches?(record)
+        @matcher_failure = @which_matcher.failure_message
+      end
+    end
+
+    @attribute_mismatches.empty? && @which_failure.nil? && @matcher_failure.nil?
+  end
+
+  failure_message do
+    if @created_records.count != 1
+      "the block should have created 1 #{klass}, but created #{@created_records.count}"
+    elsif @attribute_mismatches.any?
+      @attribute_mismatches.map do |field, expected, actual|
+        expected_description = is_composable_matcher?(expected) ? expected.description : expected.inspect
+        "Expected #{field.inspect} to be #{expected_description}, but was #{actual.inspect}"
+      end.join("\n")
+    elsif @which_failure
+      @which_failure.message
+    else
+      @matcher_failure
+    end
+  end
+
+  failure_message_when_negated do
+    if @created_records.count == 1 && @attributes && @attribute_mismatches.none?
+      "the block should not have created a #{klass} with attributes #{format_attributes_hash(@attributes).inspect}, but did"
+    elsif @created_records.count == 1 && @which_block && !@which_failure
+      "the newly created #{klass} should have failed an expectation in the given block, but didn't"
+    elsif @created_records.count == 1
+      "the block should not have created a #{klass}, but created #{@created_records.count}: #{@created_records.inspect}"
+    else
+      "the block created a #{klass} that matched all given criteria"
+    end
+  end
+
+  def is_composable_matcher?(value)
+    value.respond_to?(:failure_message_when_negated)
+  end
+
+  def format_attributes_hash(attributes)
+    attributes.each_with_object({}) do |(field,value), memo|
+      memo[field] = is_composable_matcher?(value) ? value.description : value
+    end
+  end
+end
+
+RSpec::Matchers.alias_matcher :create_a,  :create_a_new
+RSpec::Matchers.alias_matcher :create_an, :create_a_new

data/lib/active_record_change_matchers/create_records_matcher.rb

@@ -0,0 +1,112 @@
+RSpec::Matchers.define :create_records do |record_counts|
+  include ActiveSupport::Inflector
+
+  supports_block_expectations
+
+  description do
+    counts_strs = record_counts.map { |klass, count| count_str(klass, count) }
+    "create #{counts_strs.join(", ")}"
+  end
+
+  chain(:with_attributes) do |attributes|
+    if mismatch=attributes.find {|klass, hashes| hashes.size != record_counts[klass]}
+      mismatched_class, hashes = mismatch
+      raise ArgumentError, "Specified the block should create #{record_counts[mismatched_class]} #{mismatched_class}, but provided #{hashes.size} #{mismatched_class} attribute specifications"
+    end
+    @expected_attributes = attributes
+  end
+
+  chain(:which) do |&block|
+    @which_block = block
+  end
+
+  match do |options={}, block|
+    fetching_strategy =
+      ActiveRecordChangeMatchers::Strategies.for_key(options[:strategy]).new(block)
+
+    @new_records = fetching_strategy.new_records(record_counts.keys)
+
+    @incorrect_counts =
+      @new_records.each_with_object({}) do |(klass, new_records), incorrect|
+        actual_count = new_records.count
+        expected_count = record_counts[klass]
+        if actual_count != expected_count
+          incorrect[klass] = { expected: expected_count, actual: actual_count }
+        end
+      end
+
+    return false if @incorrect_counts.any?
+
+    if @expected_attributes
+      @matched_records = Hash.new {|hash, key| hash[key] = []}
+      @all_attributes = Hash.new {|hash, key| hash[key] = []}
+      @incorrect_attributes =
+        @expected_attributes.each_with_object(Hash.new {|hash, key| hash[key] = []}) do |(klass, expected_attributes), incorrect|
+          @all_attributes[klass] = expected_attributes.map(&:keys).flatten.uniq
+          expected_attributes.each do |expected_attrs|
+            matched_record = (@new_records.fetch(klass) - @matched_records[klass]).find do |record|
+              expected_attrs.all? {|k,v| values_match?(v, record.public_send(k))}
+            end
+            if matched_record
+              @matched_records[klass] << matched_record
+            else
+              incorrect[klass] << expected_attrs
+            end
+          end
+        end
+      @unmatched_records = @matched_records.map {|klass, records| [klass, @new_records[klass] - records]}.to_h.reject {|k,v| v.empty?}
+      return false if @incorrect_attributes.any?
+    end
+
+
+    begin
+      @which_block && @which_block.call(@new_records)
+    rescue RSpec::Expectations::ExpectationNotMetError => e
+      @which_failure = e
+    end
+
+    @which_failure.nil?
+  end
+
+  failure_message do
+    if @incorrect_counts.present?
+      @incorrect_counts.map do |klass, counts|
+        "The block should have created #{count_str(klass, counts[:expected])}, but created #{counts[:actual]}."
+      end.join(" ")
+    elsif @incorrect_attributes.present?
+      "The block should have created:\n" +
+        @expected_attributes.map do |klass, attrs|
+          "    #{attrs.count} #{klass} with these attributes:\n" +
+          attrs.map{|a| "        #{a.inspect}"}.join("\n")
+        end.join("\n") +
+        "\nDiff:" +
+        @incorrect_attributes.map do |klass, attrs|
+          "\n    Missing #{attrs.count} #{klass} with these attributes:\n" +
+          attrs.map{|a| "        #{a.inspect}"}.join("\n")
+        end.join("\n") +
+        @unmatched_records.map do |klass, records|
+          "\n    Extra #{records.count} #{klass} with these attributes:\n" +
+          records.map do |r|
+            attrs = @all_attributes[klass].each_with_object({}) {|attr, attrs| attrs[attr] = r.public_send(attr)}
+            "        #{attrs.inspect}"
+          end.join("\n")
+        end.join("\n")
+    elsif @which_failure
+      @which_failure
+    else
+      "Unknown error"
+    end
+  end
+
+  failure_message_when_negated do
+    record_counts.map do |klass, expected_count|
+      "The block should not have created #{count_str(klass, expected_count)}, but created #{expected_count}."
+    end.join(" ")
+  end
+
+  def count_str(klass, count)
+    "#{count} #{klass.name.pluralize(count)}"
+  end
+end
+
+RSpec::Matchers.alias_matcher :create, :create_records

data/lib/active_record_change_matchers/strategies/id_strategy.rb

@@ -0,0 +1,29 @@
+module ActiveRecordChangeMatchers
+  class IdStrategy
+
+    def initialize(block)
+      @block = block
+    end
+
+    def new_records(classes)
+      ids_before = classes.each_with_object({}) do |klass, ids_before|
+        ids_before[klass] = klass.select("MAX(#{column_name}) as max_id").take.try(:max_id) || 0
+      end
+
+      block.call
+
+      classes.each_with_object({}) do |klass, new_records|
+        id_before = ids_before[klass]
+        new_records[klass] = klass.where("#{column_name} > ?", id_before).to_a
+      end
+    end
+
+    private
+
+    attr_reader :block
+
+    def column_name
+      @column_name ||= ActiveRecordChangeMatchers::Config.id_column_name
+    end
+  end
+end

data/lib/active_record_change_matchers/strategies/timestamp_strategy.rb

@@ -0,0 +1,32 @@
+module ActiveRecordChangeMatchers
+  class TimestampStrategy
+
+    def initialize(block)
+      @block = block
+    end
+
+    def new_records(classes)
+      time_before = Time.current
+
+      existing_records = classes.each_with_object({}) do |klass, hash|
+        hash[klass] = klass.where("#{column_name} = ?", time_before).to_a
+      end
+
+      block.call
+
+      classes.each_with_object({}) do |klass, new_records|
+        new_records[klass] = klass.where("#{column_name} > ?", time_before).to_a +
+        new_records[klass] += klass.where("#{column_name} = ?", time_before).where.not(klass.primary_key => existing_records[klass]).to_a
+      end
+    end
+
+    private
+
+    attr_reader :block
+
+    def column_name
+      @column_name ||= ActiveRecordChangeMatchers::Config.created_at_column_name
+    end
+    
+  end
+end

data/lib/active_record_change_matchers/strategies.rb

@@ -0,0 +1,31 @@
+module ActiveRecordChangeMatchers
+  class Strategies
+
+    def self.all_strategies
+      @all_strategies ||= {
+        id: IdStrategy,
+        timestamp: TimestampStrategy,
+      }
+    end
+
+    def self.default
+      get_strategy!(Config.default_strategy)
+    end
+
+    def self.for_key(strategy_key)
+      if strategy_key.nil?
+        default
+      else
+        get_strategy!(strategy_key)
+      end
+    end
+
+    private
+
+    def self.get_strategy!(strategy_key)
+      all_strategies.fetch(strategy_key)
+    rescue KeyError
+      raise UnknownStrategyError, "#{strategy_key.inspect} is not a known strategy (known strategies are #{all_strategies.keys})"
+    end
+  end
+end

data/lib/active_record_change_matchers/version.rb

@@ -0,0 +1,3 @@
+module ActiveRecordChangeMatchers
+  VERSION = "1.0.0"
+end

data/lib/active_record_change_matchers.rb

@@ -0,0 +1,7 @@
+require "rspec/expectations"
+require "active_record"
+
+Dir[File.dirname(__FILE__) + "/active_record_change_matchers/**/*.rb"].each {|file| require file }
+
+module ActiveRecordChangeMatchers
+end

metadata

@@ -0,0 +1,196 @@
+--- !ruby/object:Gem::Specification
+name: active_record_change_matchers
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Maxim Krizhanovski
+- Nathan Wallace
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: standalone_migrations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: This gem adds custom block expectation matchers for RSpec, such as `expect
+  { ... }.to create_a_new(User)`
+email:
+- maxim.krizhanovski@hey.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_record_block_matchers.gemspec
+- active_record_change_matchers.gemspec
+- bin/console
+- bin/setup
+- db/config.yml
+- db/migrate/20150225014908_create_people.rb
+- db/migrate/20151017231107_create_dogs.rb
+- db/schema.rb
+- lib/active_record_block_matchers.rb
+- lib/active_record_change_matchers.rb
+- lib/active_record_change_matchers/config.rb
+- lib/active_record_change_matchers/create_a_new_matcher.rb
+- lib/active_record_change_matchers/create_records_matcher.rb
+- lib/active_record_change_matchers/strategies.rb
+- lib/active_record_change_matchers/strategies/id_strategy.rb
+- lib/active_record_change_matchers/strategies/timestamp_strategy.rb
+- lib/active_record_change_matchers/version.rb
+homepage: https://github.com/Darhazer/active_record_change_matchers
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Additional RSpec custom matchers for ActiveRecord
+test_files: []