remockable 0.1.2 → 0.2.0

data/CHANGELOG.md

@@ -0,0 +1,83 @@
+# Changelog
+
+## 0.2.0 (2013-10-18)
+
+  * Remove support Rails 3 ([Tyler Hunt][tylerhunt])
+  * Support Rails 4 ([Tyler Hunt][tylerhunt])
+
+## 0.1.2 (2013-06-17)
+
+  * Specify license in gemspec ([Tyler Hunt][tylerhunt])
+  * Add missing dependency require statements ([Tyler Hunt][tylerhunt])
+  * Restore support for Ruby 1.8 ([Tyler Hunt][tylerhunt])
+
+## 0.1.1 (2012-04-25)
+
+  * Do not rely on a `:with` option having `#to_a` ([Tyler Hunt][tylerhunt])
+  * Update `:if`/`:unless` support to use instance ([Tyler Hunt][tylerhunt])
+
+## 0.1.0 (2012-02-26)
+
+  * Support `:if` and `:unless` options ([Tyler Hunt][tylerhunt])
+  * Remove support for multiple attributes ([Tyler Hunt][tylerhunt])
+
+## 0.0.12 (2012-01-18)
+
+  * Use the subject instead of making a new instance ([Tyler Hunt][tylerhunt])
+  * Make rspec-mocks a runtime dependency ([Tyler Hunt][tylerhunt])
+
+## 0.0.11 (2012-01-18)
+
+  * Support role-based mass-assignment security ([Tyler Hunt][tylerhunt])
+  * Fix issue with instance variables in matchers ([Tyler Hunt][tylerhunt])
+
+## 0.0.10 (2011-10-29)
+
+  * Add `accept_nested_attributes_for` matcher ([Tyler Hunt][tylerhunt])
+  * Add `allow_values_for` matcher ([Tyler Hunt][tylerhunt])
+  * Remove unsupported default scope query methods ([Tyler Hunt][tylerhunt])
+  * Update mass-assignment matcher for Rails 3.1 ([Tyler Hunt][tylerhunt])
+
+## 0.0.9 (2011-07-12)
+
+  * Ensure that the association types are matched ([Tyler Hunt][tylerhunt])
+  * Fix an issue in the matching logic ([Tyler Hunt][tylerhunt])
+
+## 0.0.8 (2011-07-06)
+
+  * Support Rails 3.1 ([Jacob Swanner][jswanner])
+
+## 0.0.7 (2011-07-05)
+
+  * Add `have_default_scope` matcher ([Tyler Hunt][tylerhunt])
+
+## 0.0.6 (2011-05-09)
+
+  * Add Active Record validation matchers ([Tyler Hunt][tylerhunt])
+
+## 0.0.5 (2011-05-07)
+
+  * Add association matchers ([Tyler Hunt][tylerhunt])
+
+## 0.0.4 (2011-05-07)
+
+  * Add `allow_mass_assignment_of` matcher ([Tyler Hunt][tylerhunt])
+  * Add missing dependency require statement ([Tyler Hunt][tylerhunt])
+  * Fix a bug in the matcher logic ([Tyler Hunt][tylerhunt])
+
+## 0.0.3 (2011-03-11)
+
+  * Update matchers to assume subject is an instance ([Tyler Hunt][tylerhunt])
+
+## 0.0.2 (2011-03-11)
+
+  * Add additional matchers ([Tyler Hunt][tylerhunt])
+  * Require RSpec 2.5 ([Tyler Hunt][tylerhunt])
+  * Support multiple attributes ([Tyler Hunt][tylerhunt])
+
+## 0.0.1 (2011-02-21)
+
+  * Initial release ([Tyler Hunt][tylerhunt])
+
+[jswanner]: https://github.com/jswanner
+[tylerhunt]: https://github.com/tylerhunt

data/Gemfile

@@ -1,3 +1,3 @@
-source :rubygems
+source 'https://rubygems.org/'
 
 gemspec

data/README.markdown

@@ -7,13 +7,15 @@
 
 A collection of RSpec 2 matchers to simplify your web app specs.
 
+*Note:* Rails 3 support was dropped in version 0.2.
+
 
 ## Background
 
 The goal of this project is to provide a modern replacement to the now
 unmaintained Remarkable project. Remarkable was a great asset when Rails 2.3
-was current, but now that Rails 3 has become mainstream, a gap has been left
-by still unreleased Remarkable 4.0.
+was current, but a gap has been left by the unreleased Remarkable 4.0 since the
+release of Rails 3 and 4.
 
 In looking at the code for Remarkable to determine the feasibility of continuing
 work on Remarkable itself, it seems clear that the scope of that project has
@@ -24,7 +26,7 @@ the original goal of Remarkable in spirit.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add this line to your application's `Gemfile`:
 
 ``` ruby
 gem 'remockable'
@@ -48,7 +50,6 @@ classes.
 
 The following Active Model matchers are supported:
 
-  * `allow_mass_assignment_of`
   * `validate_acceptance_of`
   * `validate_confirmation_of`
   * `validate_exclusion_of`
@@ -85,4 +86,4 @@ The following Active Record matchers are supported:
 
 ## Copyright
 
-Copyright © 2010-2012 Tyler Hunt. See LICENSE for details.
+Copyright © 2010-2013 Tyler Hunt. See LICENSE for details.

data/lib/remockable/active_model.rb

@@ -1,7 +1,5 @@
 require 'remockable/active_model/helpers'
 
-require 'remockable/active_model/allow_mass_assignment_of'
-
 require 'remockable/active_model/allow_values_for'
 require 'remockable/active_model/validate_acceptance_of'
 require 'remockable/active_model/validate_confirmation_of'

data/lib/remockable/active_record/belong_to.rb

@@ -4,10 +4,8 @@ RSpec::Matchers.define(:belong_to) do |*association|
   @expected = association.extract_options!
   @association = association.shift
 
-  unsupported_options %w(extend)
-  valid_options %w(class_name conditions select foreign_key primary_key
-    dependent counter_cache include polymorphic readonly validate autosave touch
-    inverse_of)
+  valid_options %w(class_name foreign_key foreign_type primary_key dependent
+    counter_cache polymorphic validate autosave touch inverse_of)
 
   match do |actual|
     if association = subject.class.reflect_on_association(@association)

data/lib/remockable/active_record/have_and_belong_to_many.rb

@@ -4,10 +4,8 @@ RSpec::Matchers.define(:have_and_belong_to_many) do |*association|
   @expected = association.extract_options!
   @association = association.shift
 
-  unsupported_options %w(extend)
   valid_options %w(class_name join_table foreign_key association_foreign_key
-    conditions order uniq finder_sql counter_sql delete_sql insert_sql include
-    group having limit offset select readonly validate autosave)
+    validate autosave)
 
   match do |actual|
     if association = subject.class.reflect_on_association(@association)

data/lib/remockable/active_record/have_default_scope.rb

@@ -7,8 +7,8 @@ RSpec::Matchers.define(:have_default_scope) do |*expected|
   valid_options %w()
 
   match do |actual|
-    if subject.class.respond_to?(:scoped)
-      scope = subject.class.scoped
+    if subject.class.respond_to?(:all)
+      scope = subject.class.all
 
       if scope.is_a?(ActiveRecord::Relation)
         if @relation

data/lib/remockable/active_record/have_many.rb

@@ -4,8 +4,8 @@ RSpec::Matchers.define(:have_many) do |*association|
   @expected = association.extract_options!
   @association = association.shift
 
-  unsupported_options %w(extend)
-  valid_options %w(class_name conditions order foreign_key primary_key dependent finder_sql counter_sql include group having limit offset select as through source source_type uniq readonly validate autosave inverse_of)
+  valid_options %w(class_name foreign_key primary_key dependent counter_cache
+    as through source source_type validate autosave inverse_of)
 
   match do |actual|
     if association = subject.class.reflect_on_association(@association)

data/lib/remockable/active_record/have_one.rb

@@ -4,8 +4,8 @@ RSpec::Matchers.define(:have_one) do |*association|
   @expected = association.extract_options!
   @association = association.shift
 
-  unsupported_options %w(extend)
-  valid_options %w(class_name conditions order dependent foreign_key primary_key include as select through source source_type readonly validate autosave inverse_of)
+  valid_options %w(class_name dependent foreign_key primary_key as through
+    source source_type validate autosave inverse_of)
 
   match do |actual|
     if association = subject.class.reflect_on_association(@association)

data/lib/remockable/active_record/have_scope.rb

@@ -38,7 +38,7 @@ RSpec::Matchers.define(:have_scope) do |*name|
     query_methods = %w(eager_load from group having includes joins limit lock offset order preload readonly reorder select where)
 
     if query_methods.include?(method.to_s)
-      @relation ||= subject.class.scoped
+      @relation ||= subject.class.all
       @relation = @relation.send(method, *args)
       self
     else

data/lib/remockable/version.rb

@@ -1,3 +1,3 @@
 module Remockable
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

data/remockable.gemspec

@@ -8,12 +8,13 @@ Gem::Specification.new do |spec|
   spec.homepage = 'http://github.com/tylerhunt/remockable'
   spec.license = 'MIT'
 
-  spec.add_dependency 'activemodel', '~> 3.0'
-  spec.add_dependency 'activerecord', '~> 3.0'
-  spec.add_dependency 'activesupport', '~> 3.0'
+  spec.add_dependency 'activemodel', '>= 3.0'
+  spec.add_dependency 'activerecord', '>= 3.0'
+  spec.add_dependency 'activesupport', '>= 3.0'
   spec.add_dependency 'rspec-core', '~> 2.0'
   spec.add_dependency 'rspec-expectations', '~> 2.0'
   spec.add_dependency 'rspec-mocks', '~> 2.0'
+  spec.add_development_dependency 'rake'
   spec.add_development_dependency 'sqlite3', '~> 1.3.4'
 
   spec.files = `git ls-files`.split($/)

data/spec/active_model/allow_values_for_spec.rb

@@ -9,7 +9,7 @@ describe :allow_values_for do
     build_class(:User) { include ActiveModel::Validations }
   end
 
-  before { model.validates(attribute, :format => /^\d+$/) }
+  before { model.validates(attribute, :format => /\A\d+\Z/) }
 
   subject { model.new }
 

data/spec/active_record/belong_to_spec.rb

@@ -43,20 +43,15 @@ describe :belong_to do
     end
 
     with_option(:class_name, 'Company', 'Organization')
-    with_option(:conditions, { :id => 1 }, { :id => 2 })
-    with_option(:select, %w(id), %w(name))
     with_option(:foreign_key, :company_id, :organization_id)
+    with_option(:foreign_type, :company_type, :organization_type)
     with_option(:primary_key, :id, :company_id)
     with_option(:dependent, :destroy, :nullify)
     with_option(:counter_cache, true, false)
-    with_option(:include, :users, :employees)
     with_option(:polymorphic, true, false)
-    with_option(:readonly, true, false)
     with_option(:validate, true, false)
     with_option(:autosave, true, false)
     with_option(:touch, true, false)
     with_option(:inverse_of, :users, :employees)
-
-    with_unsupported_option(:extend, Module.new)
   end
 end

data/spec/active_record/have_and_belong_to_many_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe :have_and_belong_to_many do
   let(:macro) { :has_and_belongs_to_many }
-  let(:options) { [:tags, { :order => :name }] }
+  let(:options) { [:tags, { :validate => true }] }
 
   it_behaves_like 'an Active Record matcher' do
     let(:model) { build_class(:User, ActiveRecord::Base) }
@@ -45,23 +45,7 @@ describe :have_and_belong_to_many do
     with_option(:join_table, 'tags_users', 'user_tags')
     with_option(:foreign_key, :user_id, :tagged_id)
     with_option(:association_foreign_key, :tag_id, :role_id)
-    with_option(:conditions, { :active => true }, { :active => false })
-    with_option(:order, :name, :created_at)
-    with_option(:uniq, true, false)
-    with_option(:finder_sql, 'SELECT * FROM user_tags', 'SELECT * FROM tags_users')
-    with_option(:counter_sql, 'SELECT COUNT(*) FROM user_tags', 'SELECT COUNT(*) FROM tags_users')
-    with_option(:delete_sql, 'DELETE FROM user_tags', 'DELETE FROM tags_users')
-    with_option(:insert_sql, 'INSERT INTO user_tags', 'INSERT INTO tags_users')
-    with_option(:include, :statistics, :changes)
-    with_option(:group, 'usage_count', 'changes_count')
-    with_option(:having, 'usage_count > 5', 'changes_count > 5')
-    with_option(:limit, 5, 10)
-    with_option(:offset, 10, 20)
-    with_option(:select, %w(id), %w(name))
-    with_option(:readonly, true, false)
     with_option(:validate, true, false)
     with_option(:autosave, true, false)
-
-    with_unsupported_option(:extend, Module.new)
   end
 end

data/spec/active_record/have_default_scope_spec.rb

@@ -25,7 +25,7 @@ describe :have_default_scope do
 
     context 'without arguments' do
       it 'matches if a default scope exists' do
-        model.instance_eval { default_scope(order(:id)) }
+        model.instance_eval { default_scope(-> { order(:id) }) }
         model.should have_default_scope
       end
 
@@ -36,132 +36,132 @@ describe :have_default_scope do
 
     context 'with a from value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(from('users')) }
+        model.instance_eval { default_scope(-> { from('users') }) }
         model.should have_default_scope.from('users')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(from('users')) }
+        model.instance_eval { default_scope(-> { from('users') }) }
         model.should_not have_default_scope.from('friends')
       end
     end
 
     context 'with a group value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(group('one')) }
+        model.instance_eval { default_scope(-> { group('one') }) }
         model.should have_default_scope.group('one')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(group('one')) }
+        model.instance_eval { default_scope(-> { group('one') }) }
         model.should_not have_default_scope.group('two')
       end
     end
 
     context 'with a having value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(having('COUNT(*) > 1')) }
+        model.instance_eval { default_scope(-> { having('COUNT(*) > 1') }) }
         model.should have_default_scope.having('COUNT(*) > 1')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(having('COUNT(*) > 1')) }
+        model.instance_eval { default_scope(-> { having('COUNT(*) > 1') }) }
         model.should_not have_default_scope.having('COUNT(*) > 2')
       end
     end
 
     context 'with a having value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(having('COUNT(*) > 1')) }
+        model.instance_eval { default_scope(-> { having('COUNT(*) > 1') }) }
         model.should have_default_scope.having('COUNT(*) > 1')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(having('COUNT(*) > 1')) }
+        model.instance_eval { default_scope(-> { having('COUNT(*) > 1') }) }
         model.should_not have_default_scope.having('COUNT(*) > 2')
       end
     end
 
     context 'with a joins value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(joins('INNER JOIN friends')) }
+        model.instance_eval { default_scope(-> { joins('INNER JOIN friends') }) }
         model.should have_default_scope.joins('INNER JOIN friends')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(joins('INNER JOIN friends')) }
+        model.instance_eval { default_scope(-> { joins('INNER JOIN friends') }) }
         model.should_not have_default_scope.joins('INNER JOIN enemies')
       end
     end
 
     context 'with a limit value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(limit(10)) }
+        model.instance_eval { default_scope(-> { limit(10) }) }
         model.should have_default_scope.limit(10)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(limit(10)) }
+        model.instance_eval { default_scope(-> { limit(10) }) }
         model.should_not have_default_scope.limit(15)
       end
     end
 
     context 'with an offset value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(offset(10)) }
+        model.instance_eval { default_scope(-> { offset(10) }) }
         model.should have_default_scope.offset(10)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(offset(10)) }
+        model.instance_eval { default_scope(-> { offset(10) }) }
         model.should_not have_default_scope.offset(15)
       end
     end
 
     context 'with an order value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(order('one')) }
+        model.instance_eval { default_scope(-> { order('one') }) }
         model.should have_default_scope.order('one')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(order('one')) }
+        model.instance_eval { default_scope(-> { order('one') }) }
         model.should_not have_default_scope.order('id')
       end
     end
 
     context 'with a reorder value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(reorder('one')) }
+        model.instance_eval { default_scope(-> { reorder('one') }) }
         model.should have_default_scope.reorder('one')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(reorder('one')) }
+        model.instance_eval { default_scope(-> { reorder('one') }) }
         model.should_not have_default_scope.reorder('id')
       end
     end
 
     context 'with a select value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(select('one')) }
+        model.instance_eval { default_scope(-> { select('one') }) }
         model.should have_default_scope.select('one')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(select('one')) }
+        model.instance_eval { default_scope(-> { select('one') }) }
         model.should_not have_default_scope.select('id')
       end
     end
 
     context 'with a where value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { default_scope(where(:one => nil)) }
+        model.instance_eval { default_scope(-> { where(:one => nil) }) }
         model.should have_default_scope.where(:one => nil)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { default_scope(where(:one => nil)) }
+        model.instance_eval { default_scope(-> { where(:one => nil) }) }
         model.should_not have_default_scope.where(:one => 1)
       end
     end

data/spec/active_record/have_many_spec.rb

@@ -42,29 +42,16 @@ describe :have_many do
     end
 
     with_option(:class_name, 'Post', 'Blog')
-    with_option(:conditions, { :published => true }, { :published => false })
-    with_option(:order, %w(published_at), %w(title))
     with_option(:foreign_key, :post_id, :blog_id)
     with_option(:primary_key, :id, :post_id)
     with_option(:dependent, :destroy, :nullify)
-    with_option(:finder_sql, 'SELECT * FROM posts', 'SELECT * FROM blogs')
-    with_option(:counter_sql, 'SELECT COUNT(*) FROM posts', 'SELECT COUNT(*) FROM blogs')
-    with_option(:include, :comments, :trackbacks)
-    with_option(:group, 'comments_count', 'trackbacks_count')
-    with_option(:having, 'comments_count > 5', 'trackbacks_count > 5')
-    with_option(:limit, 5, 10)
-    with_option(:offset, 10, 20)
-    with_option(:select, %w(id), %w(title))
+    with_option(:counter_cache, :post_count, :posts_count)
     with_option(:as, :postable, :bloggable)
     with_option(:through, :postings, :bloggings)
     with_option(:source, :piece, :work)
     with_option(:source_type, 'Post', 'Blog')
-    with_option(:uniq, true, false)
-    with_option(:readonly, true, false)
     with_option(:validate, true, false)
     with_option(:autosave, true, false)
     with_option(:inverse_of, :users, :employees)
-
-    with_unsupported_option(:extend, Module.new)
   end
 end

data/spec/active_record/have_one_spec.rb

@@ -42,20 +42,15 @@ describe :have_one do
     end
 
     with_option(:class_name, 'Address', 'Location')
-    with_option(:conditions, { :id => 1 }, { :id => 2 })
-    with_option(:order, %w(id), %w(name))
     with_option(:dependent, :destroy, :nullify)
     with_option(:foreign_key, :address_id, :location_id)
     with_option(:primary_key, :id, :address_id)
-    with_option(:include, :country, :state)
     with_option(:as, :addressable, :locatable)
-    with_option(:select, %w(id), %w(name))
     with_option(:through, :offices, :locations)
-    with_option(:readonly, true, false)
+    with_option(:source, :addressable, :contactable, through: :offices)
+    with_option(:source_type, 'Company', 'Organization', through: :offices)
     with_option(:validate, true, false)
     with_option(:autosave, true, false)
     with_option(:inverse_of, :user, :employee)
-
-    with_unsupported_option(:extend, Module.new)
   end
 end

data/spec/active_record/have_scope_spec.rb

@@ -25,7 +25,7 @@ describe :have_scope do
 
     context 'with a scope name' do
       it 'matches if the scope exists' do
-        model.instance_eval { scope(:no_one, where(:one => nil)) }
+        model.instance_eval { scope(:no_one, -> { where(:one => nil) }) }
         model.should have_scope(:no_one)
       end
 
@@ -36,180 +36,180 @@ describe :have_scope do
 
     context 'with an eager_load value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:loaded, eager_load(:order)) }
+        model.instance_eval { scope(:loaded, -> { eager_load(:order) }) }
         model.should have_scope(:loaded).eager_load(:order)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:loaded, eager_load(:order)) }
+        model.instance_eval { scope(:loaded, -> { eager_load(:order) }) }
         model.should_not have_scope(:loaded).eager_load(:from)
       end
     end
 
     context 'with a from value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:used, from('users')) }
+        model.instance_eval { scope(:used, -> { from('users') }) }
         model.should have_scope(:used).from('users')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:used, from('users')) }
+        model.instance_eval { scope(:used, -> { from('users') }) }
         model.should_not have_scope(:used).from('friends')
       end
     end
 
     context 'with a group value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:grouped, group('one')) }
+        model.instance_eval { scope(:grouped, -> { group('one') }) }
         model.should have_scope(:grouped).group('one')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:grouped, group('one')) }
+        model.instance_eval { scope(:grouped, -> { group('one') }) }
         model.should_not have_scope(:grouped).group('two')
       end
     end
 
     context 'with a having value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:had, having('COUNT(*) > 1')) }
+        model.instance_eval { scope(:had, -> { having('COUNT(*) > 1') }) }
         model.should have_scope(:had).having('COUNT(*) > 1')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:had, having('COUNT(*) > 1')) }
+        model.instance_eval { scope(:had, -> { having('COUNT(*) > 1') }) }
         model.should_not have_scope(:had).having('COUNT(*) > 2')
       end
     end
 
     context 'with an includes value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:joined, includes(:company)) }
+        model.instance_eval { scope(:joined, -> { includes(:company) }) }
         model.should have_scope(:joined).includes(:company)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:joined, includes(:company)) }
+        model.instance_eval { scope(:joined, -> { includes(:company) }) }
         model.should_not have_scope(:joined).includes(:address)
       end
     end
 
     context 'with a joins value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:joined, joins('INNER JOIN friends')) }
+        model.instance_eval { scope(:joined, -> { joins('INNER JOIN friends') }) }
         model.should have_scope(:joined).joins('INNER JOIN friends')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:joined, joins('INNER JOIN friends')) }
+        model.instance_eval { scope(:joined, -> { joins('INNER JOIN friends') }) }
         model.should_not have_scope(:joined).joins('INNER JOIN enemies')
       end
     end
 
     context 'with a limit value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:limited, limit(10)) }
+        model.instance_eval { scope(:limited, -> { limit(10) }) }
         model.should have_scope(:limited).limit(10)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:limited, limit(10)) }
+        model.instance_eval { scope(:limited, -> { limit(10) }) }
         model.should_not have_scope(:limited).limit(15)
       end
     end
 
     context 'with a lock value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:locked, lock(true)) }
+        model.instance_eval { scope(:locked, -> { lock(true) }) }
         model.should have_scope(:locked).lock(true)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:locked, lock(true)) }
+        model.instance_eval { scope(:locked, -> { lock(true) }) }
         model.should_not have_scope(:locked).lock(false)
       end
     end
 
     context 'with an offset value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:shifted, offset(10)) }
+        model.instance_eval { scope(:shifted, -> { offset(10) }) }
         model.should have_scope(:shifted).offset(10)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:shifted, offset(10)) }
+        model.instance_eval { scope(:shifted, -> { offset(10) }) }
         model.should_not have_scope(:shifted).offset(15)
       end
     end
 
     context 'with an order value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:ordered, order('one')) }
+        model.instance_eval { scope(:ordered, -> { order('one') }) }
         model.should have_scope(:ordered).order('one')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:ordered, order('one')) }
+        model.instance_eval { scope(:ordered, -> { order('one') }) }
         model.should_not have_scope(:ordered).order('id')
       end
     end
 
     context 'with a preload value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:preloaded, preload(:company)) }
+        model.instance_eval { scope(:preloaded, -> { preload(:company) }) }
         model.should have_scope(:preloaded).preload(:company)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:preloaded, preload(:company)) }
+        model.instance_eval { scope(:preloaded, -> { preload(:company) }) }
         model.should_not have_scope(:preloaded).preload(:address)
       end
     end
 
     context 'with a readonly value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:prepared, readonly(false)) }
+        model.instance_eval { scope(:prepared, -> { readonly(false) }) }
         model.should have_scope(:prepared).readonly(false)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:prepared, readonly(false)) }
+        model.instance_eval { scope(:prepared, -> { readonly(false) }) }
         model.should_not have_scope(:prepared).readonly(true)
       end
     end
 
     context 'with a reorder value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:reordered, reorder('one')) }
+        model.instance_eval { scope(:reordered, -> { reorder('one') }) }
         model.should have_scope(:reordered).reorder('one')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:reordered, reorder('one')) }
+        model.instance_eval { scope(:reordered, -> { reorder('one') }) }
         model.should_not have_scope(:reordered).reorder('id')
       end
     end
 
     context 'with a select value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:ones, select('one')) }
+        model.instance_eval { scope(:ones, -> { select('one') }) }
         model.should have_scope(:ones).select('one')
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:ones, select('one')) }
+        model.instance_eval { scope(:ones, -> { select('one') }) }
         model.should_not have_scope(:ones).select('id')
       end
     end
 
     context 'with a where value' do
       it 'matches if the scope exists and the query matches' do
-        model.instance_eval { scope(:no_one, where(:one => nil)) }
+        model.instance_eval { scope(:no_one, -> { where(:one => nil) }) }
         model.should have_scope(:no_one).where(:one => nil)
       end
 
       it 'does not match if the query does not match' do
-        model.instance_eval { scope(:no_one, where(:one => nil)) }
+        model.instance_eval { scope(:no_one, -> { where(:one => nil) }) }
         model.should_not have_scope(:no_one).where(:one => 1)
       end
     end

data/spec/support/active_record_example_group.rb

@@ -4,10 +4,6 @@ module ActiveRecordExampleGroup
   included do
     metadata[:type] = :active_record
 
-    let(:rake) { Rake::Application.new }
-    let(:task) { rake[self.class.description] }
-    let(:namespace) { self.class.description.split(':').first }
-
     before do
       ActiveRecord::Base.establish_connection(
         :adapter => 'sqlite3',
@@ -17,6 +13,7 @@ module ActiveRecordExampleGroup
   end
 
   RSpec.configure do |config|
-    config.include self, :example_group => { :file_path => /spec\/active_record/ }
+    config.include self,
+      :example_group => { :file_path => /spec\/active_record/ }
   end
 end

data/spec/support/shared/an_active_record_matcher.rb

@@ -1,9 +1,9 @@
 shared_examples_for 'an Active Record matcher' do
   let(:matcher_name) { self.class.parent.parent.description }
 
-  def self.with_option(option_name, positive, negative)
+  def self.with_option(option_name, positive, negative, context={})
     context "with option #{option_name.inspect}" do
-      let(:options) { [:company, { option_name => positive }] }
+      let(:options) { [:company, context.merge(option_name => positive)] }
 
       before { model.send(macro, *options) }
 

metadata

@@ -2,73 +2,73 @@
 name: remockable
 version: !ruby/object:Gem::Version
   prerelease: 
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Tyler Hunt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-17 00:00:00.000000000 Z
+date: 2013-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  prerelease: false
+  name: activemodel
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '3.0'
     none: false
-  name: activemodel
-  type: :runtime
-  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '3.0'
     none: false
 - !ruby/object:Gem::Dependency
+  prerelease: false
+  name: activerecord
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '3.0'
     none: false
-  name: activerecord
-  type: :runtime
-  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '3.0'
     none: false
 - !ruby/object:Gem::Dependency
+  prerelease: false
+  name: activesupport
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '3.0'
     none: false
-  name: activesupport
-  type: :runtime
-  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '3.0'
     none: false
 - !ruby/object:Gem::Dependency
+  prerelease: false
+  name: rspec-core
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.0'
     none: false
-  name: rspec-core
-  type: :runtime
-  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
@@ -76,15 +76,15 @@ dependencies:
         version: '2.0'
     none: false
 - !ruby/object:Gem::Dependency
+  prerelease: false
+  name: rspec-expectations
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.0'
     none: false
-  name: rspec-expectations
-  type: :runtime
-  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
@@ -92,15 +92,15 @@ dependencies:
         version: '2.0'
     none: false
 - !ruby/object:Gem::Dependency
+  prerelease: false
+  name: rspec-mocks
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.0'
     none: false
-  name: rspec-mocks
-  type: :runtime
-  prerelease: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
@@ -108,15 +108,31 @@ dependencies:
         version: '2.0'
     none: false
 - !ruby/object:Gem::Dependency
+  prerelease: false
+  name: rake
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.3.4
+        version: '0'
     none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  prerelease: false
   name: sqlite3
   type: :development
-  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.4
+    none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
@@ -132,13 +148,13 @@ files:
 - .gitignore
 - .rspec
 - .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.markdown
 - Rakefile
 - lib/remockable.rb
 - lib/remockable/active_model.rb
-- lib/remockable/active_model/allow_mass_assignment_of.rb
 - lib/remockable/active_model/allow_values_for.rb
 - lib/remockable/active_model/helpers.rb
 - lib/remockable/active_model/validate_acceptance_of.rb
@@ -165,7 +181,6 @@ files:
 - lib/remockable/helpers.rb
 - lib/remockable/version.rb
 - remockable.gemspec
-- spec/active_model/allow_mass_assignment_of_spec.rb
 - spec/active_model/allow_values_for_spec.rb
 - spec/active_model/validate_acceptance_of_spec.rb
 - spec/active_model/validate_confirmation_of_spec.rb
@@ -202,12 +217,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
+      segments:
+      - 0
+      hash: 770591509696566118
       version: '0'
   none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
+      segments:
+      - 0
+      hash: 770591509696566118
       version: '0'
   none: false
 requirements: []
@@ -217,7 +238,6 @@ signing_key:
 specification_version: 3
 summary: A collection of RSpec matchers for web apps.
 test_files:
-- spec/active_model/allow_mass_assignment_of_spec.rb
 - spec/active_model/allow_values_for_spec.rb
 - spec/active_model/validate_acceptance_of_spec.rb
 - spec/active_model/validate_confirmation_of_spec.rb

data/lib/remockable/active_model/allow_mass_assignment_of.rb

@@ -1,33 +0,0 @@
-RSpec::Matchers.define(:allow_mass_assignment_of) do |*attribute|
-  @options = attribute.extract_options!
-  @attribute = attribute.shift
-
-  @role = @options[:as] || :default
-  @authorizer = nil
-
-  def authorizer(actual)
-    @authorizer ||= actual.class.active_authorizer
-    @authorizer = @authorizer[@role] if @authorizer.is_a?(Hash)
-    @authorizer
-  end
-
-  match_for_should do |actual|
-    !authorizer(actual).deny?(@attribute)
-  end
-
-  match_for_should_not do |actual|
-    authorizer(actual).deny?(@attribute)
-  end
-
-  failure_message_for_should do |actual|
-    "Expected #{actual.class.name} to #{description}"
-  end
-
-  failure_message_for_should_not do |actual|
-    "Did not expect #{actual.class.name} to #{description}"
-  end
-
-  description do
-    "allow mass-assignment of #{@attribute}"
-  end
-end

data/spec/active_model/allow_mass_assignment_of_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-describe :allow_mass_assignment_of do
-  let(:attribute) { :one }
-  let(:options) { {} }
-  let(:matcher_name) { self.class.parent.description }
-
-  let(:model) do
-    build_class(:User) { include ActiveModel::MassAssignmentSecurity }
-  end
-
-  subject { model.new }
-
-  context 'description' do
-    it 'has a custom description' do
-      matcher = allow_mass_assignment_of(attribute)
-      matcher.description.should == "allow mass-assignment of #{attribute}"
-    end
-  end
-
-  context 'failure messages' do
-    let(:matcher) { allow_mass_assignment_of(attribute) }
-
-    before { matcher.matches?(subject) }
-
-    it 'has a custom failure message' do
-      matcher.failure_message_for_should.should ==
-        "Expected #{subject.class.name} to #{matcher.description}"
-    end
-
-    it 'has a custom negative failure message' do
-      matcher.failure_message_for_should_not.should ==
-        "Did not expect #{subject.class.name} to #{matcher.description}"
-    end
-  end
-
-  context 'for accessible' do
-    before { model.attr_accessible(attribute, options) }
-
-    it 'matches if the attribute is accessible' do
-      should allow_mass_assignment_of(:one)
-    end
-
-    it 'does not match if the attribute is protected' do
-      should_not allow_mass_assignment_of(:two)
-    end
-
-    context 'with a role' do
-      let(:options) { { :as => :admin } }
-
-      it 'matches if the attribute is accessible' do
-        should allow_mass_assignment_of(:one, :as => :admin)
-      end
-
-      it 'does not match if the attribute is protected' do
-        should_not allow_mass_assignment_of(:two, :as => :admin)
-      end
-    end
-  end
-
-  context 'for protected' do
-    let(:attribute) { :two }
-
-    before { model.attr_protected(attribute, options) }
-
-    it 'matches if the attribute is accessible' do
-      should allow_mass_assignment_of(:one)
-    end
-
-    it 'does not match if the attribute is protected' do
-      should_not allow_mass_assignment_of(:two)
-    end
-
-    context 'with a role' do
-      let(:options) { { :as => :admin } }
-
-      it 'matches if the attribute is accessible' do
-        should allow_mass_assignment_of(:one, :as => :admin)
-      end
-
-      it 'does not match if the attribute is protected' do
-        should_not allow_mass_assignment_of(:two, :as => :admin)
-      end
-    end
-  end
-end