Warn users when overriding methods (via let, def or define_method) in the same example group.

Author: fabn

features/example_groups/shared_examples.feature

@@ -19,6 +19,50 @@ Feature: shared examples
   anything special (like autoload). Doing so would require a strict naming
   convention for files that would break existing suites.
 
+  **WARNING:** When you include parameterized examples in the current context multiple
+  times, you may override previous method definitions and last declaration wins.
+  So if you have this kind of shared example (or shared context)
+
+  ```ruby
+  RSpec.shared_examples "some example" do |parameter|
+    \# Same behavior is triggered also with either `def something; 'some value'; end`
+    \# or `define_method(:something) { 'some value' }`
+    let(:something) { parameter }
+    it "uses the given parameter" do
+      expect(something).to eq(parameter)
+    end
+  end
+
+  RSpec.describe SomeClass do
+    include_example "some example", "parameter1"
+    include_example "some example", "parameter2"
+  end
+  ```
+
+  You're actually doing this (notice that first example will fail):
+
+  ```ruby
+  RSpec.describe SomeClass do
+    \# Reordered code for better understanding of what is happening
+    let(:something) { "parameter1" }
+    let(:something) { "parameter2" }
+
+    it "uses the given parameter" do
+      \# This example will fail because last let "wins"
+      expect(something).to eq("parameter1")
+    end
+
+    it "uses the given parameter" do
+      expect(something).to eq("parameter2")
+    end
+  end
+  ```
+
+  To prevent this kind of subtle error a warning is emitted if you declare multiple
+  methods with the same name in the same context. Should you get this warning
+  the simplest solution is to replace `include_example` with `it_behaves_like`, in this
+  way method overriding is avoided because of the nested context created by `it_behaves_like`
+
   Conventions:
   ------------
 

lib/rspec/core/example_group.rb

@@ -2,6 +2,8 @@
 
 module RSpec
   module Core
+    # rubocop:disable Style/ClassLength
+
     # ExampleGroup and {Example} are the main structural elements of
     # rspec-core. Consider this example:
     #
@@ -650,6 +652,16 @@ def self.method_missing(name, *args)
       end
       private_class_method :method_missing
 
+      # @private
+      def self.method_added(method_name)
+        if (@__added_methods ||= Set.new).include?(method_name)
+          RSpec.warning "`#{self}##{method_name}` is being redefined " \
+                         "at #{RSpec::CallerFilter.first_non_rspec_line}. The original " \
+                         "definition will never be used and can be removed", :call_site => nil
+        end
+        @__added_methods << method_name
+      end
+
     private
 
       def method_missing(name, *args)
@@ -665,6 +677,8 @@ def method_missing(name, *args)
       end
     end
 
+    # rubocop:enable Style/ClassLength
+
     # @private
     # Unnamed example group used by `SuiteHookContext`.
     class AnonymousExampleGroup < ExampleGroup

spec/rspec/core/example_group_spec.rb

@@ -1306,6 +1306,59 @@ def extract_execution_results(group)
 
     end
 
+    describe "when methods are redefined" do
+
+      context "in the same example group" do
+
+        it 'emits a warning when overriding methods using `let`' do
+          expect {
+            RSpec.describe do
+              let(:foo) { 'first value' }
+              let(:foo) { 'second value' }
+            end
+          }.to output(a_string_including("#foo", "is being redefined at #{__FILE__}:#{__LINE__ - 2}")).to_stderr
+        end
+
+        it 'emits a warning when overriding methods using `def`' do
+          expect {
+            RSpec.describe do
+              let(:foo) { 'first value' }
+              def foo; 'second value'; end
+            end
+          }.to output(a_string_including("#foo", "is being redefined at #{__FILE__}:#{__LINE__ - 2}")).to_stderr
+        end
+
+        it 'emits a warning when overriding methods using `define_method`' do
+          expect {
+            RSpec.describe do
+              let(:foo) { 'first value' }
+              define_method(:foo) { 'second value' }
+            end
+          }.to output(a_string_including("#foo", "is being redefined at #{__FILE__}:#{__LINE__ - 2}")).to_stderr
+        end
+
+      end
+
+      context "in nested example groups" do
+
+        it 'does not emit warnings' do
+          expect {
+            RSpec.describe do
+              let(:foo) { 'first value' }
+              context 'in sub context' do
+                let(:foo) { 'second value' }
+                context 'in sub sub context' do
+                  def foo; 'third value'; end
+                end
+              end
+            end
+          }.to avoid_outputting.to_stdout.and avoid_outputting.to_stderr
+        end
+
+      end
+
+    end
+
     describe "ivars are not shared across examples" do
       it "(first example)" do
         @a = 1