Refactor bootstrap specs

Author: mbj

spec/spec_helper.rb

@@ -61,6 +61,10 @@ def verify_events
       yield
     end
   end
+
+  def undefined
+    double('undefined')
+  end
 end # XSpecHelper
 
 RSpec.configure do |config|

spec/unit/mutant/cli_spec.rb

@@ -6,7 +6,6 @@
   let(:stderr)         { instance_double(IO, 'stderr', puts: undefined) }
   let(:stdout)         { instance_double(IO, 'stdout', puts: undefined) }
   let(:target_stream)  { stdout                                         }
-  let(:undefined)      { instance_double('undefined')                   }
 
   let(:config) do
     default_config.with(

spec/unit/mutant/env/bootstrap_spec.rb

@@ -8,6 +8,7 @@
   let(:matcher_config)       { Mutant::Matcher::Config::DEFAULT     }
   let(:object_space)         { class_double(ObjectSpace)            }
   let(:object_space_modules) { []                                   }
+  let(:parser)               { instance_double(Mutant::Parser)      }
 
   let(:world) do
     instance_double(
@@ -43,39 +44,65 @@
     )
   end
 
+  shared_examples 'expected warning' do
+    let(:warns) { [] }
+
+    before do
+      allow(config.reporter).to receive(:warn, &warns.method(:<<))
+    end
+
+    it 'warns with expected warning' do
+      expect { apply }.to change(warns, :to_a).from([]).to([expected_warning])
+    end
+  end
+
   shared_examples_for 'bootstrap call' do
     it 'returns expected env' do
       expect(apply).to eql(expected_env)
     end
-  end
 
-  def expect_warning
-    expect(config.reporter).to receive(:warn)
-      .with(expected_warning)
-      .and_return(config.reporter)
+    it 'performs IO in expected sequence' do
+      apply
+
+      expect(object_space)
+        .to have_received(:each_object)
+        .with(Module)
+        .ordered
+
+      expect(integration_class)
+        .to have_received(:new)
+        .with(config)
+        .ordered
+
+      expect(integration)
+        .to have_received(:setup)
+        .ordered
+    end
   end
 
   before do
-    expect(integration_class).to receive(:new)
-      .with(config)
-      .and_return(integration)
-
-    expect(integration).to receive_messages(setup: integration)
+    allow(integration_class).to receive_messages(new: integration)
+    allow(integration).to receive_messages(setup: integration)
 
-    expect(object_space).to receive(:each_object)
-      .with(Module)
-      .and_return(object_space_modules.each)
+    allow(object_space).to receive_messages(
+      each_object: object_space_modules.each
+    )
   end
 
   describe '#warn' do
-    let(:object)           { described_class.new(world, config) }
-    let(:expected_warning) { instance_double(String)            }
+    subject { described_class.new(world, config) }
 
-    subject { object.warn(expected_warning) }
+    def apply
+      subject.warn(expected_warning)
+    end
 
-    before { expect_warning }
+    let(:expected_warning) { instance_double(String) }
 
-    it_behaves_like 'a command method'
+    include_examples 'expected warning'
+
+    it 'returns self' do
+      expect(apply).to be(subject)
+    end
   end
 
   describe '.call' do
@@ -87,27 +114,27 @@ def apply
       let(:object_space_modules) { [invalid_class] }
 
       let(:expected_warning) do
-        "Class#name from: #{invalid_class} raised an error: " \
+        "Object#name from: #{invalid_class} raised an error: " \
         "RuntimeError. #{Mutant::Env::SEMANTICS_MESSAGE}"
       end
 
+      # Not really a class, but does not leak a "wrong" class
+      # into later specs.
       let(:invalid_class) do
-        Class.new do
-          def self.name
+        Object.new.tap do |object|
+          def object.name
             fail
           end
         end
       end
 
-      after do
-        # Fix Class#name so other specs do not see this one
-        class << invalid_class
-          undef :name
-          def name; end
-        end
-      end
+      include_examples 'expected warning'
+      include_examples 'bootstrap call'
+    end
 
-      before { expect_warning }
+    context 'when Module#name calls return nil' do
+      let(:anonymous_class)      { Class.new         }
+      let(:object_space_modules) { [anonymous_class] }
 
       include_examples 'bootstrap call'
     end
@@ -164,8 +191,7 @@ def name; end
         end
       end
 
-      before { expect_warning }
-
+      include_examples 'expected warning'
       include_examples 'bootstrap call'
     end