Why:
* There were architectural issues with how the permit matcher kept track
of params instances on which doubles had been placed. Previously we
were starting off by taking the ActionController::Parameters class and
stubbing the #permit and #require instance method on it -- in other
words, we were stubbing #require for all instances of
ActionController::Parameters -- then we would stub #permit on a
particular instance of ActionController::Parameters that #require
returned. What this means is that if for some reason the #permit stub
on an individual instance isn't working properly, then the #permit
stub on ActionController::Parameters will respond to the invocation.
This is exactly what happened for the issue we recently fixed --
if the stubbing were done a different way we wouldn't have run into
that issue.
* Also, there's no reason to have both ParametersDoubles and
SliceOfParametersDoubles classes around. While it's nice that we have
a simpler option to use if we don't need the more complex one, we
actually don't need a distinction here, and we can afford one class
that does both.
To satisfy the above:
* When stubbing #permit or #require, always do so on an instance of
ActionController::Parameters and not the whole class. This way we know
exactly which methods are being doubled and it's easier to debug things
in the future.
* This means that we now stub ActionController::Parameters.new and then
place stubs on the returned instance.
* Refactor ParametersDoubles and SliceOfParametersDoubles: combine them
into a ParametersDoubleRegistry class, but extract the code that stubs
ActionController::Parameters.new into
a CompositeParametersDoubleRegistry class.
* Since this broke one of the tests, modify DoubleCollection so that a
method cannot be doubled more than once -- if the method is already
doubled then `register_stub` or `register_proxy` does nothing and
returns the original Double.
If a method for a class is doubled more than once within the same test
run, the original implementation of that method will change from double
to double, even if the double is deactivated correctly. Say we have two
distinct tests that both double the same method. Here is how that method
will be overridden as it goes along:
A) START: original method
B) ACTIVATE (1st test): method is doubled
C) DEACTIVATE (1st test): calls original method (A)
D) ACTIVATE (2nd test): original method (C) stored; method is again
doubled
E) DEACTIVATE (2nd test): calls original method (C)
With this commit, this changes to:
A) START: original method
B) ACTIVATE (1st test): method is doubled
C) DEACTIVATE (1st test): calls original method (A)
D) ACTIVATE (2nd test): original method not stored again; method is
again doubled
E) DEACTIVATE (2nd test): calls original method (A)
* Change 'spec' Rake task to 'spec:unit'
* Require unit_spec_helper.rb in unit tests, not spec_helper.rb
* Re-namespace files in spec/support/unit under UnitTests
* Files in spec/support/unit/helpers no longer automatically add
themselves to RSpec - this happens in unit_spec_helper.rb
* Extract RecordWithDifferentErrorAttributeBuilder and
RecordValidatingConfirmationBuilder to separate files
* Move spec/shoulda to spec/unit_tests/shoulda
* Move spec/support/*.rb to spec/support/unit_tests/{helpers,matchers}
* Move spec_helper.rb to unit_spec_helper.rb
2014-11-04 14:43:59 -07:00
Renamed from spec/shoulda/matchers/doublespeak/double_collection_spec.rb (Browse further)
Elliot Winkler