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.
Why:
* When debugging #permit it's been helpful to loop through all of the
doubles that Doublespeak has registered and spit out all of the calls
on those doubles (specifically which arguments they've received).
* It's also been helpful to know where the methods the doubles represent
have been called.
To satisfy the above:
* Add #calls_by_method_name to DoubleCollection
* Add #caller to MethodCall
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)
This provides a robust solution for temporarily stubbing (and
unstubbing) methods. It will be internally by the strong parameters and
delegation matchers.
