This allows us to call stub_method_unnecessarily in the default case without a
treatment

if RUBY_VERSION < '2.2.0', there's no point defining a test class that
does just setup and teardown. Instead, let's not define the test class
at all.

... following the same structure and logic as in the case of
stubbing_method_unnecessarily

...to reduce diff between StubbingMethod{Unnecessarily,OnNil}Test to
prep to extract common module

...to furter reduce diff betwee StubbingMethod{Unnecessarily,OnNil}Test
to prep to extract common module

...to furter reduce diff betwee StubbingMethod{Unnecessarily,OnNil}Test
to prep to extract common module

This seems to have been an artifact of copy-paste

... pulling up all the identical methods between
Stubbing{MethodUnnecessarily,Nil}Test

We can now start using the 'framework' we've extracted in the form of a
shared test module customizable via configure_violation,
potenial_violation and message_on_violation.
StubbingNonExistentAnyInstanceMethodTest varies only in those 3 things.
It checks the same things as in the shared module (viz. allow, warn,
prevent and default).

... just as in the case of StubbingNonExistentAnyInstanceMethodTest

... just as in case of StubbingNonExistent{AnyInstance,Class}MethodTest

... just as in all the StubbingNonExistent*MethodTest

so we can include the module rather than a test calling the same
assertion in multiple test classes

... to reduce diff between and prep to DRY up
test_should_allow_stubbing_existing_*_any_instance_method

... this will allow us to extract a parameterizable method to DRY up

... to prep for extracting both into a single method

... since those tests don't use the same fixture and 'framework' as the
tests for checking stubbing non-existent methods, and the class and
superclass tests follow the same structure, so separating them
highlights the similarity and affords an opportunity for abstraction.

... between
test_should_allow_stubbing_existing_*_any_instance_{,super}class_method

... to allow class or superclass to be the method owner

into assert_allows_stubbing_existing_any_instance_method

The earlier design had something like a double dispatch going on between
the test classes and the shared module as follows:
SharedModule#assert_allows_stubbing_existing_method ->
TestClass#stubbee_with_method -> SharedModule#class_with_method. We now
replace the ping-pong style with a unidirectional method call sequence:
SharedModule#assert_allows_stubbing_existing_method ->
TestClass#method_owner, TestClass#stubbee

The new design also puts the names of the defined method and the stubbed
method together in a single method body, so the correlation is more
obvious and in a single location, rather than the earlier connascence of
name between two methods

We were using stubbee as the class whose methods would be stubbed, and
then stubbing stubbee.any_instance. However, for class method tests, we
would want an object (the class) that can be stubbed by calling .stubs
on it directly. We call that object the stub_owner, which in case of
AnyInstance tests will be stubbee.any_instance (or, after the rename
here, stubbed_instance.any_instance

... by specifying custom method_owner and stub_owner

... by specifying custom method_owner and stub_owner

from AllowStubbingNonExistent{AnyInstance,Class,Instance}{,Superclass}MethodTest
after a rename to make it more generic. This also adds the respond_to? check to
superclass tests. It wasn't clear why we should check for existing methods on a
class and its superclass, but skip the superclass check for a method to which we
the object responds

Just as in the case of stubbing non-existent method tests, we break the
single StubbingNonPublicAnyInstanceMethodTest into:

- StubbingNonPublicAnyInstanceMethodTest - with just
test_should_allow_stubbing_public_any_instance_method
- StubbingPrivateAnyInstanceMethodTest - checks that stubbing private
methods is checked (allow/warn/prevent)
- StubbingProtectedAnyInstanceMethodTest - checks that stubbing private
methods is checked (allow/warn/prevent)

by using the same method names, and setting visibility programmatically
rather than declaratively

... in StubbingNonPublic{Class,Instance}MethodTest

for use in StubbingNonPublic{Class,Instance}MethodTest with overridable
method_owner and stubbed_owner later

following the same structure as StubbingNonPublicAnyInstanceMethodTest
- StubbingNonPublicClassMethodTest
- StubbingPrivateClassMethodTest
- StubbingProtectedClassMethodTest

following the same structure as
StubbingNonPublic{AnyInstance,Class}MethodTest
- StubbingNonPublicInstanceMethodTest
- StubbingPrivateInstanceMethodTest
- StubbingProtectedInstanceMethodTest

and use it in StubbingNonPublic{AnyInstance,Class,Instance}MethodTest.
This also adds the check for stubbing method that's responded to for
AnyInstance since it's more consistent with the other two and it wasn't
clear why the check didn't exist for AnyInstance while it did for Class
and Instance methods

... and to make duplication more obvious