mutant 0.8.8 → 0.8.9

data/spec/unit/mutant/integration/rspec_spec.rb

@@ -3,8 +3,8 @@ require 'mutant/integration/rspec'
 RSpec.describe Mutant::Integration::Rspec do
   let(:object) { described_class.new(Mutant::Config::DEFAULT) }
 
-  let(:options) { double('options') }
-  let(:runner)  { double('runner')  }
+  let(:rspec_options) { instance_double(RSpec::Core::ConfigurationOptions) }
+  let(:rspec_runner)  { instance_double(RSpec::Core::Runner)               }
 
   let(:example_a) do
     double(
@@ -115,10 +115,16 @@ RSpec.describe Mutant::Integration::Rspec do
   end
 
   before do
-    expect(RSpec::Core::ConfigurationOptions).to receive(:new).with(%w[spec --fail-fast]).and_return(options)
-    expect(RSpec::Core::Runner).to receive(:new).with(options).and_return(runner)
-    expect(RSpec).to receive(:world).with(no_args).and_return(world)
-    allow(Time).to receive(:now).and_return(Time.now)
+    expect(RSpec::Core::ConfigurationOptions).to receive(:new)
+      .with(%w[spec --fail-fast])
+      .and_return(rspec_options)
+
+    expect(RSpec::Core::Runner).to receive(:new)
+      .with(rspec_options)
+      .and_return(rspec_runner)
+
+    expect(RSpec).to receive_messages(world: world)
+    allow(Time).to receive_messages(now: Time.now)
   end
 
   describe '#all_tests' do
@@ -131,7 +137,7 @@ RSpec.describe Mutant::Integration::Rspec do
     subject { object.setup }
 
     before do
-      expect(runner).to receive(:setup) do |error, output|
+      expect(rspec_runner).to receive(:setup) do |error, output|
         expect(error).to be($stderr)
         output.write('foo')
       end
@@ -144,7 +150,7 @@ RSpec.describe Mutant::Integration::Rspec do
     subject { object.call(tests) }
 
     before do
-      expect(runner).to receive(:setup) do |_errors, output|
+      expect(rspec_runner).to receive(:setup) do |_errors, output|
         output.write('the-test-output')
       end
 
@@ -157,7 +163,7 @@ RSpec.describe Mutant::Integration::Rspec do
       expect(world).to receive(:ordered_example_groups) do
         filtered_examples.values.flatten
       end
-      expect(runner).to receive(:run_specs).with([example_a]).and_return(exit_status)
+      expect(rspec_runner).to receive(:run_specs).with([example_a]).and_return(exit_status)
     end
 
     context 'on unsuccessful exit' do
@@ -166,10 +172,10 @@ RSpec.describe Mutant::Integration::Rspec do
       it 'should return failed result' do
         expect(subject).to eql(
           Mutant::Result::Test.new(
-            tests: tests,
-            output: 'the-test-output',
-            passed: false,
-            runtime: 0.0
+            output:  'the-test-output',
+            passed:  false,
+            runtime: 0.0,
+            tests:   tests
           )
         )
       end
@@ -181,10 +187,10 @@ RSpec.describe Mutant::Integration::Rspec do
       it 'should return passed result' do
         expect(subject).to eql(
           Mutant::Result::Test.new(
-            tests: tests,
-            output: 'the-test-output',
-            passed: true,
-            runtime: 0.0
+            output:  'the-test-output',
+            passed:  true,
+            runtime: 0.0,
+            tests:   tests
           )
         )
       end

data/spec/unit/mutant/integration_spec.rb

@@ -25,17 +25,17 @@ RSpec.describe Mutant::Integration::Null do
   end
 
   describe '#call' do
-    let(:tests) { double('Tests') }
+    let(:tests) { instance_double(Array) }
 
     subject { object.call(tests) }
 
     it 'returns test result' do
       should eql(
         Mutant::Result::Test.new(
-          tests:   tests,
-          runtime: 0.0,
+          output:  '',
           passed:  true,
-          output:  ''
+          runtime: 0.0,
+          tests:   tests
         )
       )
     end

data/spec/unit/mutant/isolation_spec.rb

@@ -65,8 +65,8 @@ RSpec.describe Mutant::Isolation::Fork do
     end
 
     context 'uses primitives in correct order' do
-      let(:reader) { double('reader') }
-      let(:writer) { double('writer') }
+      let(:reader) { instance_double(IO) }
+      let(:writer) { instance_double(IO) }
 
       before do
         expect(IO).to receive(:pipe).with(binmode: true).ordered do |&block|
@@ -76,9 +76,9 @@ RSpec.describe Mutant::Isolation::Fork do
       end
 
       it 'when fork succeeds' do
-        pid = double('PID')
+        pid = instance_double(Fixnum)
         expect(Process).to receive(:fork).ordered.and_yield.and_return(pid)
-        file = double('file')
+        file = instance_double(File)
         expect(File).to receive(:open).ordered
           .with(File::NULL, File::WRONLY).and_yield(file)
         expect($stderr).to receive(:reopen).ordered.with(file)

data/spec/unit/mutant/loader_spec.rb

@@ -0,0 +1,42 @@
+RSpec.describe Mutant::Loader, '.call' do
+  subject do
+    described_class.call(
+      binding: binding,
+      kernel:  kernel,
+      node:    node,
+      subject: mutation_subject
+    )
+  end
+
+  let(:path)     { instance_double(Pathname, to_s: path_str) }
+  let(:path_str) { instance_double(String)                   }
+  let(:line)     { instance_double(Fixnum)                   }
+  let(:kernel)   { instance_double(Kernel.singleton_class)   }
+  let(:binding)  { instance_double(Binding)                  }
+  let(:source)   { instance_double(String)                   }
+  let(:node)     { instance_double(Parser::AST::Node)        }
+
+  let(:mutation_subject) do
+    instance_double(
+      Mutant::Subject,
+      source_path: path,
+      source_line: line
+    )
+  end
+
+  it 'performs expected kernel interaction' do
+    expect(Unparser).to receive(:unparse)
+      .with(node)
+      .and_return(source)
+
+    expect(kernel).to receive(:eval)
+      .with(
+        source,
+        binding,
+        path_str,
+        line
+      )
+
+    subject
+  end
+end

data/spec/unit/mutant/matcher/compiler_spec.rb

@@ -62,14 +62,14 @@ RSpec.describe Mutant::Matcher::Compiler, '#call' do
     end
 
     context 'and subject filters' do
-      let(:filter) { double('filter') }
+      let(:subject_filter) { instance_double(Mutant::Matcher) }
 
       let(:attributes) do
-        super().merge(subject_filters: [filter])
+        super().merge(subject_filters: [subject_filter])
       end
 
       let(:subject_filter_predicates) do
-        [filter]
+        [subject_filter]
       end
 
       it { should eql(expected_matcher) }

data/spec/unit/mutant/matcher/config_spec.rb

@@ -30,7 +30,7 @@ RSpec.describe Mutant::Matcher::Config do
           .add(:ignore_expressions, parse_expression('Bar'))
       end
 
-      it { should eql('#<Mutant::Matcher::Config match_expressions: [Foo] ignore_expressions: [Bar]>') }
+      it { should eql('#<Mutant::Matcher::Config ignore_expressions: [Bar] match_expressions: [Foo]>') }
     end
 
     context 'with subject filter' do

data/spec/unit/mutant/matcher/method/instance_spec.rb

@@ -2,7 +2,6 @@ RSpec.describe Mutant::Matcher::Method::Instance, '#call' do
   subject { object.call(env) }
 
   let(:object)       { described_class.new(scope, method)                }
-  let(:env)          { test_env                                          }
   let(:method_name)  { :foo                                              }
   let(:source_path)  { MutantSpec::ROOT.join('test_app/lib/test_app.rb') }
   let(:method)       { scope.instance_method(method_name)                }
@@ -11,6 +10,14 @@ RSpec.describe Mutant::Matcher::Method::Instance, '#call' do
   let(:method_arity) { 0                                                 }
   let(:base)         { TestApp::InstanceMethodTests                      }
 
+  let(:env) do
+    instance_double(
+      Mutant::Env::Bootstrap,
+      config: Mutant::Config::DEFAULT,
+      parser: Fixtures::TEST_ENV.parser
+    )
+  end
+
   def name
     node.children.fetch(0)
   end

data/spec/unit/mutant/matcher/method/singleton_spec.rb

@@ -2,7 +2,6 @@ RSpec.describe Mutant::Matcher::Method::Singleton, '#call' do
   subject { object.call(env) }
 
   let(:object)       { described_class.new(scope, method)                }
-  let(:env)          { test_env                                          }
   let(:method)       { scope.method(method_name)                         }
   let(:type)         { :defs                                             }
   let(:method_name)  { :foo                                              }
@@ -10,6 +9,14 @@ RSpec.describe Mutant::Matcher::Method::Singleton, '#call' do
   let(:base)         { TestApp::SingletonMethodTests                     }
   let(:source_path)  { MutantSpec::ROOT.join('test_app/lib/test_app.rb') }
 
+  let(:env) do
+    instance_double(
+      Mutant::Env::Bootstrap,
+      config: Mutant::Config::DEFAULT,
+      parser: Fixtures::TEST_ENV.parser
+    )
+  end
+
   def name
     node.children.fetch(1)
   end

data/spec/unit/mutant/matcher/namespace_spec.rb

@@ -1,12 +1,11 @@
 RSpec.describe Mutant::Matcher::Namespace, '#call' do
-  let(:object) { described_class.new(parse_expression('TestApp*')) }
-  let(:env)    { instance_double(Mutant::Env)                      }
-  let(:raw_scope_a) { double('SingletonA', name: 'TestApp::Literal') }
-
-  let(:raw_scope_b) { double('SingletonB', name: 'TestApp::Foo')     }
-  let(:raw_scope_c) { double('SingletonC', name: 'TestAppOther')     }
-  let(:subject_a)   { double('SubjectA')                             }
-  let(:subject_b)   { double('SubjectB')                             }
+  let(:object)      { described_class.new(parse_expression('TestApp*')) }
+  let(:env)         { instance_double(Mutant::Env)                      }
+  let(:raw_scope_a) { instance_double(Class, name: 'TestApp::Literal')  }
+  let(:raw_scope_b) { instance_double(Class, name: 'TestApp::Foo')      }
+  let(:raw_scope_c) { instance_double(Class, name: 'TestAppOther')      }
+  let(:subject_a)   { instance_double(Mutant::Subject)                  }
+  let(:subject_b)   { instance_double(Mutant::Subject)                  }
 
   before do
     [

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

@@ -1,6 +1,7 @@
 RSpec.describe Mutant::Matcher::Null, '#call' do
-  let(:object) { described_class.new }
-  let(:env) { instance_double(Mutant::Env) }
+  let(:object) { described_class.new          }
+  let(:env)    { instance_double(Mutant::Env) }
+
   subject { object.call(env) }
 
   it 'returns no subjects' do

data/spec/unit/mutant/mutation_spec.rb

@@ -19,9 +19,10 @@ RSpec.describe Mutant::Mutation do
   let(:test_b) { instance_double(Mutant::Test) }
 
   describe '#insert' do
-    subject { object.insert }
+    subject { object.insert(kernel) }
 
-    let(:root_node) { s(:foo) }
+    let(:root_node) { s(:foo)                 }
+    let(:kernel)    { instance_double(Kernel) }
 
     before do
       expect(context).to receive(:root)
@@ -32,10 +33,15 @@ RSpec.describe Mutant::Mutation do
         .ordered
         .and_return(mutation_subject)
 
-      expect(Mutant::Loader::Eval).to receive(:call)
+      expect(Mutant::Loader).to receive(:call)
         .ordered
-        .with(root_node, mutation_subject)
-        .and_return(Mutant::Loader::Eval)
+        .with(
+          binding: TOPLEVEL_BINDING,
+          kernel:  kernel,
+          node:    root_node,
+          subject: mutation_subject
+        )
+        .and_return(Mutant::Loader)
     end
 
     it_should_behave_like 'a command method'

data/spec/unit/mutant/mutator/registry_spec.rb

@@ -20,7 +20,7 @@ RSpec.describe Mutant::Mutator::Registry do
   describe '#register' do
     let(:object) { described_class.new }
 
-    let(:mutator) { double('Mutator') }
+    let(:mutator) { instance_double(Mutant::Mutator) }
 
     subject { object.register(type, mutator) }
 

data/spec/unit/mutant/parallel/master_spec.rb

@@ -1,16 +1,16 @@
 RSpec.describe Mutant::Parallel::Master do
   let(:message_sequence)     { FakeActor::MessageSequence.new                                             }
   let(:actor_names)          { %i[master worker_a worker_b]                                               }
-  let(:status)               { double('Status')                                                           }
+  let(:status)               { instance_double(Mutant::Result::Status)                                    }
   let(:sink)                 { FakeSink.new                                                               }
-  let(:processor)            { double('Processor')                                                        }
+  let(:processor)            { instance_double(Proc)                                                      }
   let(:worker_a)             { actor_env.mailbox(:worker_a).sender                                        }
   let(:worker_b)             { actor_env.mailbox(:worker_b).sender                                        }
   let(:parent)               { actor_env.mailbox(:parent).sender                                          }
-  let(:job_payload_a)        { double('Job Payload A')                                                    }
-  let(:job_payload_b)        { double('Job Payload B')                                                    }
-  let(:job_result_payload_a) { double('Job Result Payload A')                                             }
-  let(:job_result_payload_b) { double('Job Result Payload B')                                             }
+  let(:job_payload_a)        { instance_double(Object)                                                    }
+  let(:job_payload_b)        { instance_double(Object)                                                    }
+  let(:job_result_payload_a) { instance_double(Object)                                                    }
+  let(:job_result_payload_b) { instance_double(Object)                                                    }
   let(:job_a)                { Mutant::Parallel::Job.new(index: 0, payload: job_payload_a)                }
   let(:job_b)                { Mutant::Parallel::Job.new(index: 1, payload: job_payload_b)                }
   let(:job_result_a)         { Mutant::Parallel::JobResult.new(job: job_a, payload: job_result_payload_a) }
@@ -36,11 +36,11 @@ RSpec.describe Mutant::Parallel::Master do
 
   let(:config) do
     Mutant::Parallel::Config.new(
-      jobs:      1,
       env:       actor_env,
-      source:    Mutant::Parallel::Source::Array.new([job_payload_a, job_payload_b]),
+      jobs:      1,
+      processor: processor,
       sink:      sink,
-      processor: processor
+      source:    Mutant::Parallel::Source::Array.new([job_payload_a, job_payload_b])
     )
   end
 

data/spec/unit/mutant/parallel/source/array_spec.rb

@@ -1,9 +1,9 @@
 RSpec.describe Mutant::Parallel::Source::Array do
   let(:object) { described_class.new(jobs) }
 
-  let(:job_a) { double('Job A') }
-  let(:job_b) { double('Job B') }
-  let(:job_c) { double('Job B') }
+  let(:job_a) { instance_double(Mutant::Parallel::Job) }
+  let(:job_b) { instance_double(Mutant::Parallel::Job) }
+  let(:job_c) { instance_double(Mutant::Parallel::Job) }
 
   let(:jobs) { [job_a, job_b, job_c] }
 

data/spec/unit/mutant/parallel/worker_spec.rb

@@ -4,11 +4,11 @@ RSpec.describe Mutant::Parallel::Worker do
   end
 
   let(:message_sequence) { FakeActor::MessageSequence.new    }
-  let(:processor)        { double('Processor')               }
+  let(:processor)        { instance_double(Proc)             }
   let(:mailbox)          { actor_env.mailbox(:worker)        }
   let(:parent)           { actor_env.mailbox(:parent).sender }
-  let(:payload)          { double('Payload')                 }
-  let(:result_payload)   { double('Result Payload')          }
+  let(:payload)          { instance_double(Object)           }
+  let(:result_payload)   { instance_double(Object)           }
 
   let(:attributes) do
     {
@@ -38,8 +38,8 @@ RSpec.describe Mutant::Parallel::Worker do
         message_sequence.add(:worker, :stop)
       end
 
-      let(:index)           { double('Index')                                                     }
-      let(:test_result)     { double('Test Result')                                               }
+      let(:index)           { instance_double(Fixnum)                                             }
+      let(:test_result)     { instance_double(Mutant::Result::Test)                               }
       let(:job_result)      { Mutant::Parallel::JobResult.new(job: job, payload: result_payload)  }
       let(:job)             { Mutant::Parallel::Job.new(index: index, payload: payload)           }
 

data/spec/unit/mutant/parallel_spec.rb

@@ -2,10 +2,10 @@ RSpec.describe Mutant::Parallel do
   describe '.async' do
     subject { described_class.async(config) }
 
-    let(:config)  { double('Config', env: env)          }
-    let(:env)     { double('ENV', new_mailbox: mailbox) }
-    let(:mailbox) { Mutant::Actor::Mailbox.new          }
-    let(:master)  { double('Master')                    }
+    let(:config)  { instance_double(Mutant::Parallel::Config, env: env)       }
+    let(:env)     { instance_double(Mutant::Actor::Env, new_mailbox: mailbox) }
+    let(:mailbox) { Mutant::Actor::Mailbox.new                                }
+    let(:master)  { instance_double(Mutant::Parallel::Master)                 }
 
     before do
       expect(described_class::Master).to receive(:call).with(config).and_return(master)

data/spec/unit/mutant/parser_spec.rb

@@ -0,0 +1,24 @@
+RSpec.describe Mutant::Parser do
+  let(:object) { described_class.new }
+
+  describe '#call' do
+    let(:path) { instance_double(Pathname) }
+
+    subject { object.call(path) }
+
+    before do
+      expect(path).to receive(:read)
+        .with(no_args)
+        .and_return(':source')
+    end
+
+    it 'returns parsed source' do
+      expect(subject).to eql(s(:sym, :source))
+    end
+
+    it 'is idempotent' do
+      source = object.call(path)
+      expect(subject).to be(source)
+    end
+  end
+end

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

@@ -12,9 +12,9 @@ RSpec.describe Mutant::Reporter::CLI::Printer do
     end
   end
 
-  let(:reportable) { double('Reportable', success?: success?) }
-  let(:tty?)       { true }
-  let(:success?)   { true }
+  let(:reportable) { instance_double(Mutant::Result::Env, success?: success?) }
+  let(:tty?)       { true                                                     }
+  let(:success?)   { true                                                     }
 
   context '.call' do
     let(:class_under_test) do