4ad15205a5
Secondary author: Elliot Winkler <elliot.winkler@gmail.com> This commit fixes `validate_uniqueness_of` when used with `scoped_to` so that when one of the scope attributes is a polymorphic *_type attribute and the model has another validation on the same attribute, the matcher does not fail with an error. As a part of the matching process, `validate_uniqueness_of` tries to create two records that have the same values for each of the attributes passed to `scoped_to`, except one of the attributes has a different value. This way, the second record should be valid because it shouldn't clash with the first one. It does this one attribute at a time. Let's say the attribute in question is a polymorphic *_type attribute. The value of this attribute is intended to be the name of a model as a string. Let's assume the first record has a meaningful value for this attribute already and we're trying to find a value for the second record. In order to produce such a value, `validate_uniqueness_of` generally calls #next (a common method in Ruby to generate a succeeding version of an object sequentially) on the first object's corresponding value. So in the case of a *_type attribute, since it's a string, it would call #next on that string. For instance, "User" would become "Uses". You might have noticed a problem with this, which is "what if Uses is not a valid model?" This is okay as long as there's nothing that is trying to access the polymorphic association. Because as soon as this happens, Rails will attempt to find a record using the polymorphic type -- in other words, it will try to find the model that the *_type attribute corresponds to. One of the ways this can happen is if the *_type attribute in question has a validation on it itself. Let's look at an example. Given these models: ``` ruby class User < ActiveRecord::Base end class Favorite < ActiveRecord::Base belongs_to :favoriteable, polymorphic: true validates :favoriteable, presence: true validates :favoriteable_id, uniqueness: { scope: [:favoriteable_type] } end FactoryGirl.define do factory :user factory :favorite do association :favoriteable, factory: :user end end ``` and the following test: ``` ruby require 'rails_helper' describe Favorite do context 'validations' do before { FactoryGirl.create(:favorite) } it do should validate_uniqueness_of(:favoriteable_id). scoped_to(:favoriteable_type) end end end ``` prior to this commit, the test would have failed with: ``` Failures: 1) Favorite validations should require case sensitive unique value for favoriteable_id scoped to favoriteable_type Failure/Error: should validate_uniqueness_of(:favoriteable_id). NameError: uninitialized constant Uses # ./spec/models/favorite_spec.rb:6:in `block (3 levels) in <top (required)>' ``` Here, a Favorite record is created where `favoriteable_type` is set to "Uses", and then validations are run on that record. The presence validation on `favoriteable_type` is run which tries to access a "Uses" model. But that model doesn't exist, so the test raises an error. Now `validates_uniqueness_of` will set the *_type attribute to a meaningful value. It still does this by calling #next on the first record's value, but then it makes a new model that is simply an alias for the original model. Hence, in our example, Uses would become a model that is aliased to User. |
||
---|---|---|
doc_config | ||
features | ||
gemfiles | ||
lib | ||
script | ||
spec | ||
.gitignore | ||
.travis.yml | ||
.yardopts | ||
Appraisals | ||
CONTRIBUTING.md | ||
Gemfile | ||
Gemfile.lock | ||
MIT-LICENSE | ||
NEWS.md | ||
README.md | ||
Rakefile | ||
cucumber.yml | ||
docs.watchr | ||
shoulda-matchers.gemspec |
README.md
shoulda-matchers
shoulda-matchers provides Test::Unit- and RSpec-compatible one-liners that test common Rails functionality. These tests would otherwise be much longer, more complex, and error-prone.
ActiveModel Matchers
- allow_mass_assignment_of
tests usage of Rails 3's
attr_accessible
andattr_protected
macros. - allow_value tests usage of
the
validates_format_of
validation. - validate_inclusion_of
tests usage of
validates_inclusion_of
. - validate_exclusion_of
tests usage of
validates_exclusion_of
. - ensure_length_of tests usage
of
validates_length_of
. - have_secure_password tests
usage of
has_secure_password
. - validate_confirmation_of
tests usage of
validates_confirmation_of
. - validate_numericality_of
tests usage of
validates_numericality_of
. - validate_presence_of tests
usage of
validates_presence_of
. - validate_uniqueness_of tests
usage of
validates_uniqueness_of
.
ActiveRecord Matchers
- accept_nested_attributes_for
tests usage of the
accepts_nested_attributes_for
macro. - belong_to tests
your
belongs_to
associations. - define_enum_for
tests usage of the
enum
macro. - have_many tests
your
has_many
associations. - have_one tests your
has_one
associations. - have_and_belong_to_many
tests your
has_and_belongs_to_many
associations. - have_db_column tests that the table that backs your model has a specific column.
- have_db_index tests that the table that backs your model has an index on a specific column.
- have_readonly_attribute
tests usage of the
attr_readonly
macro. - serialize tests usage of the
serialize
macro.
ActionController Matchers
- filter_param tests parameter filtering configuration.
- redirect_to tests that an action redirects to a certain location.
- render_template tests that an action renders a template.
- render_with_layout tests that an action is rendereed with a certain layout.
- rescue_from tests usage
of the
rescue_from
macro. - respond_with tests that an action responds with a certain status code.
- route tests your routes.
- set_session makes
assertions on the
session
hash. - set_the_flash makes
assertions on the
flash
hash.
Independent Matchers
- delegate_method tests that an object forwards messages to other, internal objects by way of delegation.
Installation
RSpec
Include the gem in your Gemfile:
group :test do
gem 'shoulda-matchers', require: false
end
Then require the gem following rspec-rails in your rails_helper (or spec_helper if you're using RSpec 2.x):
require 'rspec/rails'
require 'shoulda/matchers'
Test::Unit
shoulda-matchers was originally a component of
Shoulda -- it's what provides the nice
should
syntax which is demonstrated below. For this reason, include it in
your Gemfile instead:
group :test do
gem 'shoulda'
end
Non-Rails apps
Once it is loaded, shoulda-matchers automatically includes itself into your test framework. It will mix in the appropriate matchers for ActiveRecord, ActiveModel, and ActionController depending on the modules that are available at runtime. For instance, in order to use the ActiveRecord matchers, ActiveRecord must be available beforehand.
If your application is on Rails, everything should "just work", as shoulda-matchers will most likely be declared after Rails in your Gemfile. If your application is on another framework such as Sinatra or Padrino, you may have a different setup, so you will want to ensure that you are requiring shoulda-matchers after the components of Rails you are using. For instance, if you wanted to use and test against ActiveModel, you'd say:
gem 'activemodel'
gem 'shoulda-matchers'
and not:
gem 'shoulda-matchers'
gem 'activemodel'
Generating documentation
YARD is used to generate documentation, which can be viewed online. You can preview changes you make to the documentation locally by running
yard doc
from this directory. Then, open doc/index.html
in your browser.
If you want to see a live preview as you work without having to run yard
over
and over again, keep this command running in a separate terminal session:
watchr docs.watchr
Versioning
shoulda-matchers follows Semantic Versioning 2.0 as defined at http://semver.org.
Credits
shoulda-matchers is maintained and funded by thoughtbot. Thank you to all the contributors.
License
shoulda-matchers is copyright © 2006-2014 thoughtbot, inc. It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.