remockable 0.1.1 → 0.1.2

data/.gitignore

@@ -0,0 +1,6 @@
+*.swp
+.bundle
+.rvmrc
+Gemfile.lock
+bin
+pkg

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+script: bundle exec rspec
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2011 Tyler Hunt
+Copyright (c) 2010-2012 Tyler Hunt
 
 MIT License
 

data/README.markdown

@@ -1,5 +1,10 @@
 # Remockable
 
+[![Build Status][travis-image]][travis]
+
+[travis]: http://travis-ci.org/tylerhunt/remockable
+[travis-image]: https://secure.travis-ci.org/tylerhunt/remockable.png
+
 A collection of RSpec 2 matchers to simplify your web app specs.
 
 
@@ -7,7 +12,7 @@ A collection of RSpec 2 matchers to simplify your web app specs.
 
 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.0 has become mainstream, a gap has been left
+was current, but now that Rails 3 has become mainstream, a gap has been left
 by still unreleased Remarkable 4.0.
 
 In looking at the code for Remarkable to determine the feasibility of continuing
@@ -17,58 +22,67 @@ Remockable was born. It's an attempt to start with a clean slate but maintain
 the original goal of Remarkable in spirit.
 
 
-## Active Model Matchers
+## Installation
 
-The following Active Model matchers are supported:
+Add this line to your application's Gemfile:
 
-  * allow_mass_assignment_of
-  * validate_acceptance_of
-  * validate_confirmation_of
-  * validate_exclusion_of
-  * validate_format_of
-  * validate_inclusion_of
-  * validate_length_of
-  * validate_numericality_of
-  * validate_presence_of
+``` ruby
+gem 'remockable'
+```
 
+And then execute:
 
-## Active Record Matchers
+    $ bundle
 
-The following Active Record matchers are supported:
+Or install it yourself as:
 
-  * have_column
-  * have_index
-  * have_scope
-  * have_default_scope
-  * belong_to
-  * have_one
-  * have_many
-  * have_and_belong_to_many
-  * validate_associated
-  * validate_uniqueness_of
+    $ gem install remockable
 
 
-## Installation
+## Usage
+
+Remockable provides matchers for use with Active Model and Active Record
+classes.
 
-Add the `remockable` gem to your `Gemfile`:
+### Active Model Matchers
 
-    gem 'remockable'
+The following Active Model matchers are supported:
 
-Then run `bundle install` to install the gem.
+  * `allow_mass_assignment_of`
+  * `validate_acceptance_of`
+  * `validate_confirmation_of`
+  * `validate_exclusion_of`
+  * `validate_format_of`
+  * `validate_inclusion_of`
+  * `validate_length_of`
+  * `validate_numericality_of`
+  * `validate_presence_of`
 
-You'll also want to make sure the library is required by RSpec, so add the
-following to your `spec_helper.rb` or someone else where it will get loaded
-when your specs do:
+### Active Record Matchers
+
+The following Active Record matchers are supported:
 
-    require 'remockable'
+  * `have_column`
+  * `have_index`
+  * `have_scope`
+  * `have_default_scope`
+  * `belong_to`
+  * `have_one`
+  * `have_many`
+  * `have_and_belong_to_many`
+  * `validate_associated`
+  * `validate_uniqueness_of`
 
 
-## Compatibility
+## Contributing
 
-Remockable is compatible with Rails 3.0, but it has also been tested against
-3.1 and appears to be working fine there, too.
+1. Fork it.
+2. Create your feature branch (`git checkout -b my-new-feature`).
+3. Commit your changes (`git commit -am 'Added some feature'`).
+4. Push to the branch (`git push origin my-new-feature`).
+5. Create a new Pull Request.
 
 
 ## Copyright
 
-Copyright © 2010-2011 Tyler Hunt. See LICENSE for details.
+Copyright © 2010-2012 Tyler Hunt. See LICENSE for details.

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/remockable/active_model/helpers.rb

@@ -1,3 +1,5 @@
+require 'remockable/helpers'
+
 module Remockable
   module ActiveModel
     module Helpers

data/lib/remockable/active_record/helpers.rb

@@ -1,3 +1,5 @@
+require 'remockable/helpers'
+
 module Remockable
   module ActiveRecord
     module Helpers

data/lib/remockable/version.rb

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

data/remockable.gemspec

@@ -0,0 +1,23 @@
+require './lib/remockable/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'remockable'
+  spec.version = Remockable::VERSION
+  spec.authors = ['Tyler Hunt']
+  spec.summary = 'A collection of RSpec matchers for web apps.'
+  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 'rspec-core', '~> 2.0'
+  spec.add_dependency 'rspec-expectations', '~> 2.0'
+  spec.add_dependency 'rspec-mocks', '~> 2.0'
+  spec.add_development_dependency 'sqlite3', '~> 1.3.4'
+
+  spec.files = `git ls-files`.split($/)
+  spec.executables = spec.files.grep(%r{^bin/}) { |file| File.basename(file) }
+  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+end

data/spec/active_model/allow_mass_assignment_of_spec.rb

@@ -0,0 +1,86 @@
+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

data/spec/active_model/allow_values_for_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe :allow_values_for do
+  let(:attribute) { :one }
+  let(:values) { ['123'] }
+  let(:matcher_name) { self.class.parent.description }
+
+  let(:model) do
+    build_class(:User) { include ActiveModel::Validations }
+  end
+
+  before { model.validates(attribute, :format => /^\d+$/) }
+
+  subject { model.new }
+
+  context 'description' do
+    it 'has a custom description' do
+      matcher = allow_values_for(attribute, *values)
+      matcher.description.should == "allow the values #{values.collect(&:inspect).to_sentence} for #{attribute}"
+    end
+  end
+
+  context 'failure messages' do
+    let(:matcher) { allow_values_for(attribute, *values) }
+
+    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
+
+  it 'matches if the values are valid' do
+    should allow_values_for(:one, '123', '4567890')
+  end
+
+  it 'does not match if the values are invalid' do
+    should_not allow_values_for(:one, 'abc', 'abc123')
+  end
+end

data/spec/active_model/validate_acceptance_of_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe :validate_acceptance_of do
+  let(:validator_name) { :acceptance }
+  let(:default_options) { true }
+
+  it_behaves_like 'a validation matcher' do
+    with_option(:accept, 'TRUE', 'FALSE')
+    with_option(:allow_nil, true, false)
+    with_option(:message, 'must agree!', 'invalid')
+    with_option(:on, :create, :update)
+
+    with_conditional_option(:if)
+    with_conditional_option(:unless)
+  end
+end

data/spec/active_model/validate_confirmation_of_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe :validate_confirmation_of do
+  let(:validator_name) { :confirmation }
+  let(:default_options) { true }
+
+  it_behaves_like 'a validation matcher' do
+    with_option(:message, 'must match!', 'invalid')
+    with_option(:on, :create, :update)
+
+    with_conditional_option(:if)
+    with_conditional_option(:unless)
+  end
+end

data/spec/active_model/validate_exclusion_of_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe :validate_exclusion_of do
+  let(:validator_name) { :exclusion }
+  let(:default_options) { { :in => [true, false] } }
+
+  it_behaves_like 'a validation matcher' do
+    with_option(:allow_blank, true, false)
+    with_option(:allow_nil, true, false)
+    with_option(:in, [true, false], %w(male female))
+    with_option(:message, 'is in list!', 'invalid')
+
+    with_conditional_option(:if)
+    with_conditional_option(:unless)
+  end
+end

data/spec/active_model/validate_format_of_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe :validate_format_of do
+  let(:validator_name) { :format }
+  let(:default_options) { { :with => /\d+/ } }
+
+  it_behaves_like 'a validation matcher' do
+    with_option(:allow_blank, true, false)
+    with_option(:allow_nil, true, false)
+    with_option(:message, 'is the wrong format!', 'invalid')
+    with_option(:on, :create, :update)
+    with_option!(:with, /\d+/, /\w+/)
+    with_option!(:without, /\d+/, /\w+/)
+
+    with_conditional_option(:if)
+    with_conditional_option(:unless)
+  end
+end

data/spec/active_model/validate_inclusion_of_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe :validate_inclusion_of do
+  let(:validator_name) { :inclusion }
+  let(:default_options) { { :in => [true, false] } }
+
+  it_behaves_like 'a validation matcher' do
+    with_option(:allow_blank, true, false)
+    with_option(:allow_nil, true, false)
+    with_option(:in, [true, false], %w(male female))
+    with_option(:message, 'is not in list!', 'invalid')
+
+    with_conditional_option(:if)
+    with_conditional_option(:unless)
+  end
+end

data/spec/active_model/validate_length_of_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe :validate_length_of do
+  let(:validator_name) { :length }
+  let(:default_options) { { :is => 5 } }
+
+  it_behaves_like 'a validation matcher' do
+    with_option(:allow_blank, true, false)
+    with_option(:allow_nil, true, false)
+    with_option(:in, 1..10, 1..5)
+    with_option(:is, 5, 10)
+    with_option(:maximum, 5, 10)
+    with_option(:message, 'is the wrong length!', 'invalid')
+    with_option(:minimum, 5, 10)
+    with_option(:on, :create, :update)
+    with_option(:too_long, 'is too long!', 'invalid')
+    with_option(:too_short, 'is too short!', 'invalid')
+    with_option(:within, 1..10, 1..5)
+    with_option(:wrong_length, 'is not five!', 'invalid')
+
+    with_conditional_option(:if)
+    with_conditional_option(:unless)
+
+    with_unsupported_option(:tokenizer, lambda { |string| string.scan(/\w+/) })
+  end
+end

data/spec/active_model/validate_numericality_of_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe :validate_numericality_of do
+  let(:validator_name) { :numericality }
+  let(:default_options) { { :only_integer => true } }
+
+  it_behaves_like 'a validation matcher' do
+    with_option(:allow_nil, true, false)
+    with_option(:equal_to, 5, 10)
+    with_option(:even, true, false)
+    with_option(:greater_than, 5, 10)
+    with_option(:greater_than_or_equal_to, 5, 10)
+    with_option(:less_than, 5, 10)
+    with_option(:less_than_or_equal_to, 5, 10)
+    with_option(:message, 'is the wrong numericality!', 'invalid')
+    with_option(:odd, true, false)
+    with_option(:on, :create, :update)
+    with_option(:only_integer, true, false)
+
+    with_conditional_option(:if)
+    with_conditional_option(:unless)
+  end
+end

data/spec/active_model/validate_presence_of_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe :validate_presence_of do
+  let(:validator_name) { :presence }
+  let(:default_options) { true }
+
+  it_behaves_like 'a validation matcher', :presence do
+    with_option(:message, 'is required!', 'invalid')
+    with_option(:on, :create, :update)
+
+    with_conditional_option(:if)
+    with_conditional_option(:unless)
+  end
+end

data/spec/active_record/accept_nested_attributes_for_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe :accept_nested_attributes_for do
+  let(:macro) { :accepts_nested_attributes_for }
+  let(:options) { [:company, { :allow_destroy => true }] }
+
+  it_behaves_like 'an Active Record matcher' do
+    let(:matcher_name) { :accept_nested_attributes_for }
+
+    let(:model) do
+      build_class(:User, ActiveRecord::Base) { belongs_to :company }
+    end
+
+    before { create_table(:users) }
+
+    subject { model.new }
+
+    context 'description' do
+      let(:matcher) { send(matcher_name, *options) }
+
+      it 'has a custom description' do
+        association = matcher.instance_variable_get(:@association)
+        with = " with #{matcher.expected.inspect}" if matcher.expected.any?
+        matcher.description.should == "accept nested attributes for #{association}#{with}"
+      end
+    end
+
+    context 'with no options' do
+      let(:options) { :company }
+
+      it 'matches if the model accepts the nested attributes' do
+        model.accepts_nested_attributes_for(*options)
+        model.should accept_nested_attributes_for(*options)
+      end
+
+      it 'does not match if the model does not accept the nested attributes' do
+        model.should_not accept_nested_attributes_for(*options)
+      end
+    end
+
+    with_option(:allow_destroy, true, false)
+    with_option(:limit, 1, 2)
+    with_option(:update_only, true, false)
+
+    with_unsupported_option(:reject_if, :all_blank)
+  end
+end

data/spec/active_record/belong_to_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe :belong_to do
+  let(:macro) { :belongs_to }
+  let(:options) { [:company, { :dependent => :destroy }] }
+
+  it_behaves_like 'an Active Record matcher' do
+    let(:model) { build_class(:User, ActiveRecord::Base) }
+
+    before do
+      create_table(:users) { |table| table.integer(:company_id) }
+    end
+
+    subject { model.new }
+
+    context 'description' do
+      let(:matcher) { send(matcher_name, *options) }
+
+      it 'has a custom description' do
+        name = matcher.instance_variable_get(:@name).to_s.gsub(/_/, ' ')
+        association = matcher.instance_variable_get(:@association)
+        with = " with #{matcher.expected.inspect}" if matcher.expected.any?
+        matcher.description.should == "#{name} #{association}#{with}"
+      end
+    end
+
+    context 'with no options' do
+      let(:options) { :company }
+
+      it 'matches if the association exists' do
+        model.belongs_to(*options)
+        model.should belong_to(*options)
+      end
+
+      it 'does not match if the association does not exist' do
+        model.should_not belong_to(*options)
+      end
+
+      it 'does not match if the association is of the wrong type' do
+        model.has_many(*options)
+        model.should_not belong_to(*options)
+      end
+    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(: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

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe :have_and_belong_to_many do
+  let(:macro) { :has_and_belongs_to_many }
+  let(:options) { [:tags, { :order => :name }] }
+
+  it_behaves_like 'an Active Record matcher' do
+    let(:model) { build_class(:User, ActiveRecord::Base) }
+
+    before do
+      create_table(:users) { |table| table.string(:name) }
+    end
+
+    subject { model.new }
+
+    context 'description' do
+      let(:matcher) { send(matcher_name, *options) }
+
+      it 'has a custom description' do
+        association = matcher.instance_variable_get(:@association)
+        with = " with #{matcher.expected.inspect}" if matcher.expected.any?
+        matcher.description.should == "have and belong to #{association}#{with}"
+      end
+    end
+
+    context 'with no options' do
+      let(:options) { :tags }
+
+      it 'matches if the association exists' do
+        model.has_and_belongs_to_many(*options)
+        model.should have_and_belong_to_many(*options)
+      end
+
+      it 'does not match if the association does not exist' do
+        model.should_not have_and_belong_to_many(*options)
+      end
+
+      it 'does not match if the association is of the wrong type' do
+        model.has_many(*options)
+        model.should_not have_and_belong_to_many(*options)
+      end
+    end
+
+    with_option(:class_name, 'Tag', 'Role')
+    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