active_record_block_matchers 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d4300a69d179e6d1179829142e265a79dfca842
-  data.tar.gz: bd6f73e84dc9d9530d6f7771f478e413b68ba91f
+  metadata.gz: 56549819eb77b8a9e445755d2ed4d66c8a7c78d7
+  data.tar.gz: 5eae4e2fbe09eff5486f783ff296b437b92c84bd
 SHA512:
-  metadata.gz: 764d8f289679718c85409795111582ed667c7c6e0844cace7a402829f4dace7e63b7e94b12b70e0761e4bb80b99acae71ce6ae96e57348a3bf27b021c365064c
-  data.tar.gz: 700dbeb4e9890cb99da19301725c2fbd723edaa5e8aabf127e7157429dc5862314339e3543ad00f896656cfece516b3a838cfb55086d898239fde578dd9b780f
+  metadata.gz: a8702eb8afc69876c8b15bb624124de2aae8c0735e8c05a9f6faf67fc7cf470c3163e2332c1fee2faf6c97dec8d7a3d8695e74e0264f550eaa465e87ab210316
+  data.tar.gz: 4f957401eac7b5b596bf04dbe6a402f2ba0c88d12facf8e7f017c29ba1bee72b410de8834dc1f3e4c2ac9849664f761aba6b77ce88122b946320d1967965363b

data/.rspec

@@ -1,2 +1,3 @@
---format documentation
+--format progress
 --color
+--order random

data/README.md

@@ -21,29 +21,51 @@ Or install it yourself as:
 
     $ gem install active_record_block_matchers
 
-## Custom Matchers
+## Quick Examples
 
-#### `create_a_new`
+```
+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_a`, `create_an`
+aliases: `create_an`, `create_a_new`
 
 Example:
 
 ```ruby
-expect { User.create! }.to create_a_new(User)
+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_new(User)
+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_new(User)
+  .to create_a(User)
   .with_attributes(username: "bob")
 ```
 
@@ -51,7 +73,7 @@ This is a great way to test ActiveReocrd hooks on your model.  For example, if y
 
 ```ruby
 expect { User.create!(username: "BOB") }
-  .to create_a_new(User)
+  .to create_a(User)
   .with_attributes(username: "bob")
 ```
 
@@ -59,7 +81,7 @@ You can even use RSpec's [composable matchers][1]:
 
 ```ruby
 expect { User.create!(username: "bob") }
-  .to create_a_new(User)
+  .to create_a(User)
   .with_attributes(username: a_string_starting_with("b"))
 ```
 
@@ -67,17 +89,74 @@ If you need to make assertions about things other than attribute equality, you c
 
 ```ruby
 expect { User.create!(username: "BOB", password: "BlueSteel45") }
-  .to create_a_new(User)
+  .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_new(User).which) do |user| ... end`, so your block will not execute, and it may appear that your test is passing, when it is not.
+**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.
 
 This matcher relies on a `created_at` column existing on the given model class.  The name of this column can be configured via `ActiveRecordBlockMatchers::Config.created_at_column_name = "your_column_name"`
 
+#### `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"}, {}]
+  )
+```
+
+
 ## 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.

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

@@ -11,7 +11,14 @@
 #
 # It's strongly recommended to check this file into your version control system.
 
-ActiveRecord::Schema.define(:version => 20150225014908) do
+ActiveRecord::Schema.define(:version => 20151017231107) do
+
+  create_table "dogs", :force => true do |t|
+    t.string   "name"
+    t.string   "breed"
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
+  end
 
   create_table "people", :force => true do |t|
     t.string   "first_name"

data/lib/active_record_block_matchers.rb

@@ -1,8 +1,7 @@
-require "active_record_block_matchers/version"
 require "rspec/expectations"
 require "active_record"
-require "active_record_block_matchers/config"
-require "active_record_block_matchers/create_a_matcher"
+
+Dir[File.dirname(__FILE__) + "/active_record_block_matchers/**/*.rb"].each {|file| require file }
 
 module ActiveRecordBlockMatchers
 end

data/lib/active_record_block_matchers/create_records_matcher.rb

@@ -0,0 +1,117 @@
+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 |block|
+    time_before = Time.current
+
+    block.call
+
+    @new_records =
+      record_counts.keys.each_with_object({}) do |klass, new_records|
+        column_name = ActiveRecordBlockMatchers::Config.created_at_column_name
+        new_records[klass] = klass.where("#{column_name} > ?", time_before).to_a
+      end
+
+    @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_block_matchers/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordBlockMatchers
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record_block_matchers
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Nathan Wallace
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-11-19 00:00:00.000000000 Z
+date: 2016-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -142,10 +142,12 @@ files:
 - 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_block_matchers/config.rb
-- lib/active_record_block_matchers/create_a_matcher.rb
+- lib/active_record_block_matchers/create_a_new_matcher.rb
+- lib/active_record_block_matchers/create_records_matcher.rb
 - lib/active_record_block_matchers/version.rb
 homepage: https://github.com/nwallace/active_record_block_matchers
 licenses:
@@ -167,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Additional RSpec custom matchers for ActiveRecord