mutant 0.8.8 → 0.8.9

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

@@ -1,6 +1,6 @@
 RSpec.describe Mutant::Actor::Env do
-  let(:thread)      { double('Thread')      }
-  let(:thread_root) { double('Thread Root') }
+  let(:thread)      { instance_double(Thread)                 }
+  let(:thread_root) { instance_double(Thread.singleton_class) }
 
   let(:object) { described_class.new(thread_root) }
 

data/spec/unit/mutant/actor/mailbox_spec.rb

@@ -1,6 +1,6 @@
 RSpec.describe Mutant::Actor::Mailbox do
-  let(:mutex)              { double('Mutex') }
-  let(:condition_variable) { double('Mutex') }
+  let(:mutex)              { instance_double(Mutex)             }
+  let(:condition_variable) { instance_double(ConditionVariable) }
 
   before do
     allow(Mutex).to receive(:new).and_return(mutex)
@@ -10,8 +10,8 @@ RSpec.describe Mutant::Actor::Mailbox do
   describe '.new' do
     subject { described_class.new }
 
-    let(:object) { described_class.new }
-    let(:thread) { double('Thread')    }
+    let(:object) { described_class.new     }
+    let(:thread) { instance_double(Thread) }
 
     its(:sender) { should eql(Mutant::Actor::Sender.new(condition_variable, mutex, [])) }
     its(:receiver) { should eql(Mutant::Actor::Receiver.new(condition_variable, mutex, [])) }
@@ -19,8 +19,8 @@ RSpec.describe Mutant::Actor::Mailbox do
   end
 
   describe '#bind' do
-    let(:object) { described_class.new }
-    let(:other)  { double('Sender')    }
+    let(:object) { described_class.new                    }
+    let(:other)  { instance_double(Mutant::Actor::Sender) }
 
     subject { object.bind(other) }
 

data/spec/unit/mutant/actor/message_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe Mutant::Actor::Message do
 
-  let(:type)    { double('Type')    }
-  let(:payload) { double('Payload') }
+  let(:type)    { instance_double(Symbol) }
+  let(:payload) { instance_double(Object) }
 
   describe '.new' do
     subject { described_class.new(*arguments) }

data/spec/unit/mutant/actor/receiver_spec.rb

@@ -1,8 +1,8 @@
 RSpec.describe Mutant::Actor::Receiver do
-  let(:messages)           { double('Messages')           }
-  let(:mutex)              { double('Mutex')              }
-  let(:condition_variable) { double('Condition Variable') }
-  let(:message)            { double('Message')            }
+  let(:messages)           { instance_double(Array)             }
+  let(:mutex)              { instance_double(Mutex)             }
+  let(:condition_variable) { instance_double(ConditionVariable) }
+  let(:message)            { instance_double(Object)            }
 
   let(:object) { described_class.new(condition_variable, mutex, messages) }
 

data/spec/unit/mutant/actor/sender_spec.rb

@@ -1,12 +1,12 @@
 RSpec.describe Mutant::Actor::Sender do
   let(:object)   { described_class.new(condition_variable, mutex, messages) }
 
-  let(:condition_variable) { double('Condition Variable') }
-  let(:mutex)              { double('Mutex')              }
-  let(:messages)           { double('Messages')           }
-  let(:type)               { double('Type')               }
-  let(:payload)            { double('Payload')            }
-  let(:_message)           { message(type, payload)       }
+  let(:condition_variable) { instance_double(ConditionVariable) }
+  let(:mutex)              { instance_double(Mutex)             }
+  let(:messages)           { instance_double(Array)             }
+  let(:type)               { instance_double(Symbol)            }
+  let(:payload)            { instance_double(Object)            }
+  let(:_message)           { message(type, payload)             }
 
   describe '#call' do
     subject { object.call(_message) }

data/spec/unit/mutant/ast_spec.rb

@@ -27,6 +27,15 @@ RSpec.describe Mutant::AST do
       end
     end
 
+    context 'on non Parser::AST::Node child' do
+      let(:block)   { ->(node) { fail if node.equal?(child_a) } }
+      let(:child_a) { AST::Node.new(:foo) }
+
+      it 'does not yield that node' do
+        expect(path).to eql([])
+      end
+    end
+
     context 'when one node matches' do
       let(:block) { ->(node) { node.equal?(child_a) } }
 

data/spec/unit/mutant/cli_spec.rb

@@ -18,10 +18,10 @@ RSpec.describe Mutant::CLI do
   describe '.run' do
     subject { object.run(arguments) }
 
-    let(:arguments) { double('arguments')                        }
-    let(:report)    { double('Report', success?: report_success) }
-    let(:config)    { double('Config')                           }
-    let(:env)       { double('env')                              }
+    let(:arguments) { instance_double(Array)                                         }
+    let(:report)    { instance_double(Mutant::Result::Env, success?: report_success) }
+    let(:config)    { instance_double(Mutant::Config)                                }
+    let(:env)       { instance_double(Mutant::Env)                                   }
 
     before do
       expect(Mutant::CLI).to receive(:call).with(arguments).and_return(config)
@@ -33,7 +33,7 @@ RSpec.describe Mutant::CLI do
       let(:report_success) { true }
 
       it 'exits failure' do
-        expect(subject).to be(0)
+        expect(subject).to be(true)
       end
     end
 
@@ -41,7 +41,7 @@ RSpec.describe Mutant::CLI do
       let(:report_success) { false }
 
       it 'exits failure' do
-        expect(subject).to be(1)
+        expect(subject).to be(false)
       end
     end
 
@@ -55,7 +55,7 @@ RSpec.describe Mutant::CLI do
 
       it 'exits failure' do
         expect($stderr).to receive(:puts).with('test-error')
-        expect(subject).to be(1)
+        expect(subject).to be(false)
       end
     end
   end
@@ -110,7 +110,7 @@ RSpec.describe Mutant::CLI do
 
       before do
         expect($stdout).to receive(:puts).with(expected_message)
-        expect(Kernel).to receive(:exit).with(0)
+        expect(Kernel).to receive(:exit)
       end
 
       it_should_behave_like 'a cli parser'
@@ -172,7 +172,7 @@ Options:
       let(:flags) { %w[--version] }
 
       before do
-        expect(Kernel).to receive(:exit).with(0)
+        expect(Kernel).to receive(:exit)
         expect($stdout).to receive(:puts).with("mutant-#{Mutant::VERSION}")
       end
 
@@ -237,7 +237,13 @@ Options:
       let(:expected_matcher_config) do
         default_matcher_config.with(
           subject_filters: [
-            Mutant::Repository::SubjectFilter.new(Mutant::Repository::Diff.new('HEAD', 'master'))
+            Mutant::Repository::SubjectFilter.new(
+              Mutant::Repository::Diff.new(
+                config: Mutant::Config::DEFAULT,
+                from:   'HEAD',
+                to:     'master'
+              )
+            )
           ]
         )
       end

data/spec/unit/mutant/context/scope/root_spec.rb

@@ -2,7 +2,7 @@ RSpec.describe Mutant::Context::Scope, '#root' do
   subject { object.root(node) }
 
   let(:object) { described_class.new(TestApp::Literal, path) }
-  let(:path)   { double('Path')                              }
+  let(:path)   { instance_double(Pathname)                   }
   let(:node)   { parse(':node')                              }
 
   let(:scope)      { subject.body }

data/spec/unit/mutant/context/scope/unqualified_name_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe Mutant::Context::Scope, '#unqualified_name' do
   subject { object.unqualified_name }
 
-  let(:path)   { double('Path') }
+  let(:path) { instance_double(Pathname) }
 
   context 'with top level constant name' do
     let(:object) { described_class.new(TestApp, path) }

data/spec/unit/mutant/context/scope_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe Mutant::Context::Scope do
-  let(:object)      { described_class.new(scope, source_path) }
-  let(:scope)       { double('scope', name: double('name'))   }
-  let(:source_path) { double('source path')                   }
+  let(:object)      { described_class.new(scope, source_path)               }
+  let(:scope)       { instance_double(Class, name: instance_double(String)) }
+  let(:source_path) { instance_double(Pathname)                             }
 
   describe '#identification' do
     subject { object.identification }

data/spec/unit/mutant/context_spec.rb

@@ -31,27 +31,5 @@ RSpec.describe Mutant::Context::Scope do
 
       it { should eql(expected) }
     end
-
-    context 'with Class as scope' do
-      let(:scope) { Mutant::Context }
-
-      let(:expected) do
-        s(:class,
-          s(:const, nil, :Context),
-          nil,
-          s(:str, 'test')
-        )
-      end
-
-      it { should eql(expected) }
-    end
-
-    context 'with anything else as scope' do
-      let(:scope) { double(name: 'Foo') }
-
-      it 'raises exception' do
-        expect { subject }.to raise_error(RuntimeError, "Cannot wrap scope: #{scope.inspect}")
-      end
-    end
   end
 end

data/spec/unit/mutant/env/boostrap_spec.rb

@@ -15,25 +15,25 @@ RSpec.describe Mutant::Env::Bootstrap do
 
   let(:config) do
     Mutant::Config::DEFAULT.with(
-      jobs:        1,
-      reporter:    Mutant::Reporter::Trace.new,
       includes:    [],
-      requires:    [],
       integration: integration_class,
-      matcher:     matcher_config
+      jobs:        1,
+      matcher:     matcher_config,
+      reporter:    instance_double(Mutant::Reporter),
+      requires:    []
     )
   end
 
   let(:expected_env) do
     Mutant::Env.new(
-      cache:            Mutant::Cache.new,
-      subjects:         [],
+      actor_env:        Mutant::Actor::Env.new(Thread),
+      config:           config,
+      integration:      integration,
       matchable_scopes: [],
       mutations:        [],
-      config:           config,
+      parser:           Mutant::Parser.new,
       selector:         Mutant::Selector::Expression.new(integration),
-      actor_env:        Mutant::Actor::Env.new(Thread),
-      integration:      integration
+      subjects:         []
     )
   end
 
@@ -41,12 +41,18 @@ RSpec.describe Mutant::Env::Bootstrap do
     it { should eql(expected_env) }
   end
 
+  def expect_warning
+    expect(config.reporter).to receive(:warn)
+      .with(expected_warning)
+      .and_return(config.reporter)
+  end
+
   before do
     expect(integration_class).to receive(:new)
       .with(config)
       .and_return(integration)
 
-    expect(integration).to receive(:setup).and_return(integration)
+    expect(integration).to receive_messages(setup: integration)
 
     expect(ObjectSpace).to receive(:each_object)
       .with(Module)
@@ -54,17 +60,12 @@ RSpec.describe Mutant::Env::Bootstrap do
   end
 
   describe '#warn' do
-    let(:object)  { described_class.new(config) }
-    let(:message) { instance_double(String)     }
+    let(:object)           { described_class.new(config) }
+    let(:expected_warning) { instance_double(String)     }
 
-    subject { object.warn(message) }
+    subject { object.warn(expected_warning) }
 
-    it 'reports a warning' do
-      expect { subject }
-        .to change { object.config.reporter.warn_calls }
-        .from([])
-        .to([message])
-    end
+    before { expect_warning }
 
     it_behaves_like 'a command method'
   end
@@ -75,6 +76,11 @@ RSpec.describe Mutant::Env::Bootstrap do
     context 'when Module#name calls result in exceptions' do
       let(:object_space_modules) { [invalid_class] }
 
+      let(:expected_warning) do
+        "Class#name from: #{invalid_class} raised an error: " \
+        "RuntimeError. #{Mutant::Env::SEMANTICS_MESSAGE}"
+      end
+
       let(:invalid_class) do
         Class.new do
           def self.name
@@ -92,17 +98,7 @@ RSpec.describe Mutant::Env::Bootstrap do
         end
       end
 
-      it 'warns via reporter' do
-        expected_warnings = [
-          "Class#name from: #{invalid_class} raised an error: " \
-          "RuntimeError. #{Mutant::Env::SEMANTICS_MESSAGE}"
-        ]
-
-        expect { subject }
-          .to change { config.reporter.warn_calls }
-          .from([])
-          .to(expected_warnings)
-      end
+      before { expect_warning }
 
       include_examples 'bootstrap call'
     end
@@ -146,6 +142,11 @@ RSpec.describe Mutant::Env::Bootstrap do
         end
       end
 
+      let(:expected_warning) do
+        "Class#name from: #{invalid_class} " \
+        "returned Object. #{Mutant::Env::SEMANTICS_MESSAGE}"
+      end
+
       after do
         # Fix Class#name so other specs do not see this one
         class << invalid_class
@@ -155,15 +156,7 @@ RSpec.describe Mutant::Env::Bootstrap do
         end
       end
 
-      it 'warns via reporter' do
-        expected_warnings = [
-          "Class#name from: #{invalid_class.inspect} returned Object. #{Mutant::Env::SEMANTICS_MESSAGE}"
-        ]
-
-        expect { subject }
-          .to change { config.reporter.warn_calls }
-          .from([]).to(expected_warnings)
-      end
+      before { expect_warning }
 
       include_examples 'bootstrap call'
     end
@@ -184,8 +177,8 @@ RSpec.describe Mutant::Env::Bootstrap do
             Mutant::Scope.new(TestApp::Empty,   match_expressions.last),
             Mutant::Scope.new(TestApp::Literal, match_expressions.first)
           ],
-          subjects:         subjects,
-          mutations:        subjects.flat_map(&:mutations)
+          mutations: subjects.flat_map(&:mutations),
+          subjects:  subjects
         )
       end
 

data/spec/unit/mutant/env_spec.rb

@@ -2,62 +2,96 @@ RSpec.describe Mutant::Env do
   context '#kill' do
     let(:object) do
       described_class.new(
-        config:           config,
         actor_env:        Mutant::Actor::Env.new(Thread),
-        cache:            Mutant::Cache.new,
+        config:           config,
+        integration:      integration,
+        matchable_scopes: [],
+        mutations:        [],
         selector:         selector,
         subjects:         [],
-        mutations:        [],
-        matchable_scopes: [],
-        integration:      integration
+        parser:           Mutant::Parser.new
       )
     end
 
-    let(:integration) { integration_class.new(config) }
+    let(:integration)       { instance_double(Mutant::Integration) }
+    let(:wrapped_node)      { instance_double(Parser::AST::Node)   }
+    let(:context)           { instance_double(Mutant::Context)     }
+    let(:test_a)            { instance_double(Mutant::Test)        }
+    let(:test_b)            { instance_double(Mutant::Test)        }
+    let(:tests)             { [test_a, test_b]                     }
+    let(:selector)          { instance_double(Mutant::Selector)    }
+    let(:integration_class) { Mutant::Integration::Null            }
 
-    let(:config) do
-      Mutant::Config::DEFAULT.with(isolation: isolation, integration: integration_class)
+    let(:isolation) do
+      instance_double(Mutant::Isolation::Fork.singleton_class)
     end
 
-    let(:isolation)         { double('Isolation')                                                     }
-    let(:mutation)          { Mutant::Mutation::Evil.new(mutation_subject, Mutant::AST::Nodes::N_NIL) }
-    let(:wrapped_node)      { double('Wrapped Node')                                                  }
-    let(:context)           { double('Context')                                                       }
-    let(:test_a)            { double('Test A')                                                        }
-    let(:test_b)            { double('Test B')                                                        }
-    let(:tests)             { [test_a, test_b]                                                        }
-    let(:selector)          { double('Selector')                                                      }
-    let(:integration_class) { Mutant::Integration::Null                                               }
+    let(:mutation) do
+      instance_double(
+        Mutant::Mutation,
+        subject: mutation_subject
+      )
+    end
+
+    let(:config) do
+      Mutant::Config::DEFAULT.with(
+        isolation:   isolation,
+        integration: integration_class,
+        kernel:      instance_double(Kernel.singleton_class)
+      )
+    end
 
     let(:mutation_subject) do
-      double(
-        'Subject',
-        identification: 'subject',
+      instance_double(
+        Mutant::Subject,
         context: context,
-        source: 'original',
-        tests:  tests
+        identification: 'subject',
+        source: 'original'
       )
     end
 
     subject { object.kill(mutation) }
 
     shared_examples_for 'mutation kill' do
-      it { should eql(Mutant::Result::Mutation.new(mutation: mutation, test_result: test_result)) }
+      specify do
+        should eql(
+          Mutant::Result::Mutation.new(
+            mutation: mutation,
+            test_result: test_result
+          )
+        )
+      end
     end
 
     before do
-      expect(selector).to receive(:call).with(mutation_subject).and_return(tests)
-      allow(Time).to receive(:now).and_return(Time.at(0))
+      expect(selector).to receive(:call)
+        .with(mutation_subject)
+        .and_return(tests)
+
+      allow(Time).to receive_messages(now: Time.at(0))
     end
 
     context 'when isolation does not raise error' do
-      let(:test_result)  { double('Test Result A', passed: false) }
+      let(:test_result) do
+        instance_double(
+          Mutant::Result::Test,
+          passed: false
+        )
+      end
 
       before do
-        expect(isolation).to receive(:call).and_yield.and_return(test_result)
-        expect(mutation_subject).to receive(:prepare).and_return(mutation_subject).ordered
-        expect(context).to receive(:root).with(s(:nil)).and_return(wrapped_node).ordered
-        expect(Mutant::Loader::Eval).to receive(:call).with(wrapped_node, mutation_subject).and_return(nil).ordered
+        expect(isolation).to receive(:call)
+          .ordered
+          .and_yield
+
+        expect(mutation).to receive(:insert)
+          .ordered
+          .with(config.kernel)
+
+        expect(integration).to receive(:call)
+          .ordered
+          .with(tests)
+          .and_return(test_result)
       end
 
       include_examples 'mutation kill'
@@ -65,10 +99,18 @@ RSpec.describe Mutant::Env do
 
     context 'when isolation does raise error' do
       before do
-        expect(isolation).to receive(:call).and_raise(Mutant::Isolation::Error, 'test-error')
+        expect(isolation).to receive(:call)
+          .and_raise(Mutant::Isolation::Error, 'test-error')
       end
 
-      let(:test_result) { Mutant::Result::Test.new(tests: tests, output: 'test-error', passed: false, runtime: 0.0) }
+      let(:test_result) do
+        Mutant::Result::Test.new(
+          output:  'test-error',
+          passed:  false,
+          runtime: 0.0,
+          tests:   tests
+        )
+      end
 
       include_examples 'mutation kill'
     end