mutant 0.8.8 → 0.8.9

data/spec/unit/mutant/reporter/cli/tput_spec.rb

@@ -6,8 +6,8 @@ RSpec.describe Mutant::Reporter::CLI::Tput do
       allow(Open3).to receive(:capture3).with(command).ordered.and_return(
         [
           stdout,
-          double('Stderr'),
-          double('Exitstatus', success?: success)
+          instance_double(IO),
+          instance_double(Process::Status, success?: success)
         ]
       )
     end

data/spec/unit/mutant/reporter/cli_spec.rb

@@ -5,8 +5,8 @@ RSpec.describe Mutant::Reporter::CLI do
   let(:output) { StringIO.new                        }
 
   let(:tput) do
-    double(
-      'tput',
+    instance_double(
+      Mutant::Reporter::CLI::Tput,
       restore: '[tput-restore]',
       prepare: '[tput-prepare]'
     )
@@ -61,9 +61,9 @@ RSpec.describe Mutant::Reporter::CLI do
       expect(ENV).to receive(:key?).with('CI').and_return(ci?)
     end
 
-    let(:output) { double('Output', tty?: tty?) }
-    let(:tty?)   { true                         }
-    let(:ci?)    { false                        }
+    let(:output) { instance_double(IO, tty?: tty?) }
+    let(:tty?)   { true                            }
+    let(:ci?)    { false                           }
 
     context 'when not on CI and on a tty' do
       before do
@@ -92,8 +92,8 @@ RSpec.describe Mutant::Reporter::CLI do
     end
 
     context 'when output does not respond to #tty?' do
-      let(:output) { double('Output') }
-      let(:tty?)   { false }
+      let(:output) { instance_double(IO) }
+      let(:tty?)   { false               }
 
       it { should eql(described_class.new(output, progressive_format)) }
     end

data/spec/unit/mutant/reporter/null_spec.rb

@@ -1,20 +1,21 @@
 RSpec.describe Mutant::Reporter::Null do
-  let(:object) { described_class.new }
+  let(:object) { described_class.new     }
+  let(:value)  { instance_double(Object) }
 
   describe '#report' do
-    subject { object.report(double('some input')) }
+    subject { object.report(value) }
 
     it_should_behave_like 'a command method'
   end
 
   describe '#warn' do
-    subject { object.warn(double('some input')) }
+    subject { object.warn(value) }
 
     it_should_behave_like 'a command method'
   end
 
   describe '#progress' do
-    subject { object.progress(double('some input')) }
+    subject { object.progress(value) }
 
     it_should_behave_like 'a command method'
   end

data/spec/unit/mutant/repository/diff_spec.rb

@@ -1,22 +1,34 @@
 describe Mutant::Repository::Diff do
-  describe '.from_head' do
-    subject { described_class.from_head(to_revision) }
-
-    let(:to_revision) { double('to revision') }
+  describe '#touches?' do
+    let(:object) do
+      described_class.new(
+        config: config,
+        from:   'from_rev',
+        to:     'to_rev'
+      )
+    end
 
-    it { should eql(described_class.new('HEAD', to_revision)) }
-  end
+    let(:config) do
+      instance_double(
+        Mutant::Config,
+        kernel:   kernel,
+        open3:    open3,
+        pathname: pathname
+      )
+    end
 
-  describe '#touches?' do
-    let(:object)     { described_class.new('from_rev', 'to_rev') }
-    let(:path)       { Pathname.pwd.join('foo.rb')               }
-    let(:line_range) { 1..2                                      }
+    let(:pathname)   { instance_double(Pathname.singleton_class, pwd: pwd) }
+    let(:open3)      { instance_double(Open3.singleton_class)              }
+    let(:kernel)     { instance_double(Kernel.singleton_class)             }
+    let(:pwd)        { Pathname.new('/foo')                                }
+    let(:path)       { Pathname.new('/foo/bar.rb')                         }
+    let(:line_range) { 1..2                                                }
 
     subject { object.touches?(path, line_range) }
 
     shared_context 'test if git tracks the file' do
       before do
-        expect(Kernel).to receive(:system)
+        expect(config.kernel).to receive(:system)
           .ordered
           .with(
             *%W[git ls-files --error-unmatch -- #{path}],
@@ -27,10 +39,10 @@ describe Mutant::Repository::Diff do
     end
 
     context 'when file is in a different subdirectory' do
-      let(:path) { Pathname.new('/foo.rb') }
+      let(:path) { Pathname.new('/baz/bar.rb') }
 
       before do
-        expect(Kernel).to_not receive(:system)
+        expect(config.kernel).to_not receive(:system)
       end
 
       it { should be(false) }
@@ -45,15 +57,15 @@ describe Mutant::Repository::Diff do
     end
 
     context 'when file is tracked in repository' do
-      let(:git_ls_success?) { true                                    }
-      let(:status)          { double('Status', success?: success?)    }
-      let(:stdout)          { double('Stdout', empty?: stdout_empty?) }
-      let(:stdout_empty?)   { false                                   }
+      let(:git_ls_success?) { true                                                 }
+      let(:status)          { instance_double(Process::Status, success?: success?) }
+      let(:stdout)          { instance_double(String, empty?: stdout_empty?)       }
+      let(:stdout_empty?)   { false                                                }
 
       include_context 'test if git tracks the file'
 
       before do
-        expect(Open3).to receive(:capture2)
+        expect(config.open3).to receive(:capture2)
           .ordered
           .with(*expected_git_log_command, binmode: true)
           .and_return([stdout, status])

data/spec/unit/mutant/repository/subject_filter_spec.rb

@@ -2,9 +2,9 @@ RSpec.describe Mutant::Repository::SubjectFilter do
   context '#call' do
     subject { object.call(mutant_subject) }
 
-    let(:object)       { described_class.new(diff) }
-    let(:diff)         { double('Diff')            }
-    let(:return_value) { double('Return Value')    }
+    let(:object) { described_class.new(diff)                 }
+    let(:diff)   { instance_double(Mutant::Repository::Diff) }
+    let(:value)  { instance_double(Object, 'value')          }
 
     let(:mutant_subject) do
       double(
@@ -18,11 +18,11 @@ RSpec.describe Mutant::Repository::SubjectFilter do
       expect(diff).to receive(:touches?).with(
         mutant_subject.source_path,
         mutant_subject.source_lines
-      ).and_return(return_value)
+      ).and_return(value)
     end
 
     it 'connects return value to repository diff API' do
-      expect(subject).to be(return_value)
+      expect(subject).to be(value)
     end
   end
 end

data/spec/unit/mutant/require_highjack_spec.rb

@@ -17,7 +17,7 @@ RSpec.describe Mutant::RequireHighjack do
   end
 
   describe '.call' do
-    let(:logical_name) { double('Logical Name') }
+    let(:logical_name) { instance_double(String) }
 
     def apply
       described_class.call(target_module, highjacked_calls.method(:<<))

data/spec/unit/mutant/result/env_spec.rb

@@ -1,31 +1,31 @@
 RSpec.describe Mutant::Result::Env do
   let(:object) do
     described_class.new(
-      runtime:         double('Runtime'),
+      runtime:         instance_double(Float),
       env:             env,
       subject_results: [subject_result]
     )
   end
 
   let(:env) do
-    double(
-      'Env',
+    instance_double(
+      Mutant::Env,
       config:    config,
-      subjects:  [double('Subject')],
-      mutations: [double('Mutation')]
+      subjects:  [instance_double(Mutant::Subject)],
+      mutations: [instance_double(Mutant::Mutation)]
     )
   end
 
   let(:config) do
-    double(
-      'Config',
+    instance_double(
+      Mutant::Config,
       expected_coverage: Rational(1, 1)
     )
   end
 
   let(:subject_result) do
-    double(
-      'Subject Result',
+    instance_double(
+      Mutant::Result::Subject,
       amount_mutation_results: results,
       amount_mutations_killed: killed,
       success?:                true

data/spec/unit/mutant/result/subject_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe Mutant::Result::Subject do
     )
   end
 
-  let(:mutation_subject) { double('Subject') }
+  let(:mutation_subject) { instance_double(Mutant::Subject) }
 
   describe '#continue?' do
     subject { object.continue? }
@@ -19,13 +19,13 @@ RSpec.describe Mutant::Result::Subject do
     end
 
     context 'with failing mutation result' do
-      let(:mutation_results) { [double('Mutation Result', success?: false)] }
+      let(:mutation_results) { [instance_double(Mutant::Result::Mutation, success?: false)] }
 
       it { should be(false) }
     end
 
     context 'with successful mutation result' do
-      let(:mutation_results) { [double('Mutation Result', success?: true)] }
+      let(:mutation_results) { [instance_double(Mutant::Result::Mutation, success?: true)] }
 
       it { should be(true) }
     end
@@ -33,8 +33,8 @@ RSpec.describe Mutant::Result::Subject do
     context 'with failed and successful mutation result' do
       let(:mutation_results) do
         [
-          double('Mutation Result', success?: true),
-          double('Mutation Result', success?: false)
+          instance_double(Mutant::Result::Mutation, success?: true),
+          instance_double(Mutant::Result::Mutation, success?: false)
         ]
       end
 

data/spec/unit/mutant/runner/driver_spec.rb

@@ -1,8 +1,8 @@
 RSpec.describe Mutant::Parallel::Driver do
   let(:object) { described_class.new(binding) }
 
-  let(:binding) { double('Binding') }
-  let(:result)  { double('Result') }
+  let(:binding) { instance_double(Mutant::Actor::Binding) }
+  let(:value)   { instance_double(Object, 'value')        }
 
   describe '#stop' do
     subject { object.stop }
@@ -18,9 +18,9 @@ RSpec.describe Mutant::Parallel::Driver do
     subject { object.status }
 
     before do
-      expect(binding).to receive(:call).with(:status).and_return(result)
+      expect(binding).to receive(:call).with(:status).and_return(value)
     end
 
-    it { should be(result) }
+    it { should be(value) }
   end
 end

data/spec/unit/mutant/runner/{sink/mutation_spec.rb → sink_spec.rb}

@@ -1,4 +1,4 @@
-describe Mutant::Runner::Sink::Mutation do
+describe Mutant::Runner::Sink do
   setup_shared_context
 
   shared_context 'one result' do
@@ -43,7 +43,11 @@ describe Mutant::Runner::Sink::Mutation do
 
     context 'no results' do
       let(:expected_status) do
-        Mutant::Result::Env.new(env: env, runtime: 0.0, subject_results: [])
+        Mutant::Result::Env.new(
+          env:             env,
+          runtime:         0.0,
+          subject_results: []
+        )
       end
 
       it { should eql(expected_status) }
@@ -55,7 +59,11 @@ describe Mutant::Runner::Sink::Mutation do
       with(:subject_a_result) { { mutation_results: [mutation_a_result] } }
 
       let(:expected_status) do
-        Mutant::Result::Env.new(env: env, runtime: 0.0, subject_results: [subject_a_result])
+        Mutant::Result::Env.new(
+          env:             env,
+          runtime:         0.0,
+          subject_results: [subject_a_result]
+        )
       end
 
       it { should eql(expected_status) }
@@ -65,7 +73,11 @@ describe Mutant::Runner::Sink::Mutation do
       include_context 'two results'
 
       let(:expected_status) do
-        Mutant::Result::Env.new(env: env, runtime: 0.0, subject_results: [subject_a_result])
+        Mutant::Result::Env.new(
+          env:             env,
+          runtime:         0.0,
+          subject_results: [subject_a_result]
+        )
       end
 
       it { should eql(expected_status) }

data/spec/unit/mutant/runner_spec.rb

@@ -1,45 +1,45 @@
 RSpec.describe Mutant::Runner do
-  # setup_shared_context
-  class FakeEnv
-    def self.kill
-    end
+  describe '.call' do
+    let(:integration) { instance_double(Mutant::Integration)            }
+    let(:reporter)    { instance_double(Mutant::Reporter, delay: delay) }
+    let(:driver)      { instance_double(Mutant::Parallel::Driver)       }
+    let(:delay)       { instance_double(Float)                          }
+    let(:env_result)  { instance_double(Mutant::Result::Env)            }
+    let(:actor_env)   { instance_double(Mutant::Actor::Env)             }
+    let(:kernel)      { instance_double(Kernel.singleton_class)         }
+    let(:sleep)       { instance_double(Method)                         }
 
-    def self.mutations
-      []
+    let(:env) do
+      instance_double(
+        Mutant::Env,
+        actor_env: actor_env,
+        config:    config,
+        mutations: []
+      )
     end
-  end
-
-  describe '.call' do
-    let(:integration) { double('Integration')            }
-    let(:reporter)    { double('Reporter', delay: delay) }
-    let(:driver)      { double('Driver')                 }
-    let(:delay)       { double('Delay')                  }
-    let(:env)         { FakeEnv                          }
-    let(:env_result)  { double('Env Result')             }
-    let(:actor_env)   { double('Actor ENV')              }
 
     let(:config) do
-      double(
-        'Config',
+      instance_double(
+        Mutant::Config,
         integration: integration,
-        reporter:    reporter,
-        actor_env:   actor_env,
-        jobs:        1
+        jobs:        1,
+        kernel:      kernel,
+        reporter:    reporter
       )
     end
 
     before do
-      allow(FakeEnv).to receive(:config).and_return(config)
-      allow(FakeEnv).to receive(:actor_env).and_return(actor_env)
+      allow(env).to receive(:method).with(:kill).and_return(parallel_config.processor)
+      allow(kernel).to receive(:method).with(:sleep).and_return(sleep)
     end
 
     let(:parallel_config) do
       Mutant::Parallel::Config.new(
-        jobs:      1,
         env:       actor_env,
-        source:    Mutant::Parallel::Source::Array.new(env.mutations),
-        sink:      Mutant::Runner::Sink::Mutation.new(env),
-        processor: env.method(:kill)
+        jobs:      1,
+        processor: ->(_object) { fail },
+        sink:      Mutant::Runner::Sink.new(env),
+        source:    Mutant::Parallel::Source::Array.new(env.mutations)
       )
     end
 
@@ -51,7 +51,7 @@ RSpec.describe Mutant::Runner do
     subject { described_class.call(env) }
 
     context 'when runner finishes immediately' do
-      let(:status) { double('Status', done: true, payload: env_result) }
+      let(:status) { instance_double(Mutant::Parallel::Status, done: true, payload: env_result) }
 
       before do
         expect(driver).to receive(:status).and_return(status)
@@ -62,13 +62,13 @@ RSpec.describe Mutant::Runner do
     end
 
     context 'when report iterations are done' do
-      let(:status_a) { double('Status A', done: false)                     }
-      let(:status_b) { double('Status B', done: true, payload: env_result) }
+      let(:status_a) { instance_double(Mutant::Parallel::Status, done: false)                     }
+      let(:status_b) { instance_double(Mutant::Parallel::Status, done: true, payload: env_result) }
 
       before do
         expect(driver).to receive(:status).and_return(status_a).ordered
         expect(reporter).to receive(:progress).with(status_a).ordered
-        expect(Kernel).to receive(:sleep).with(reporter.delay).ordered
+        expect(sleep).to receive(:call).with(reporter.delay).ordered
 
         expect(driver).to receive(:status).and_return(status_b).ordered
         expect(reporter).to receive(:progress).with(status_b).ordered

data/spec/unit/mutant/selector/expression_spec.rb

@@ -16,14 +16,14 @@ RSpec.describe Mutant::Selector::Expression do
       end
     end
 
-    let(:mutation_subject) { subject_class.new(context, node)                           }
-    let(:context)          { double('Context')                                          }
-    let(:node)             { double('Node')                                             }
-    let(:config)           { Mutant::Config::DEFAULT.with(integration: integration)     }
-    let(:integration)      { double('Integration', all_tests: all_tests)                }
-    let(:test_a)           { double('test a', expression: parse_expression('SubjectA')) }
-    let(:test_b)           { double('test b', expression: parse_expression('SubjectB')) }
-    let(:test_c)           { double('test c', expression: parse_expression('SubjectC')) }
+    let(:mutation_subject) { subject_class.new(context, node)                                        }
+    let(:context)          { instance_double(Mutant::Context)                                        }
+    let(:node)             { instance_double(Parser::AST::Node)                                      }
+    let(:config)           { Mutant::Config::DEFAULT.with(integration: integration)                  }
+    let(:integration)      { instance_double(Mutant::Integration, all_tests: all_tests)              }
+    let(:test_a)           { instance_double(Mutant::Test, expression: parse_expression('SubjectA')) }
+    let(:test_b)           { instance_double(Mutant::Test, expression: parse_expression('SubjectB')) }
+    let(:test_c)           { instance_double(Mutant::Test, expression: parse_expression('SubjectC')) }
 
     subject { object.call(mutation_subject) }