mutant 0.8.10 → 0.8.11

data/spec/unit/mutant/cli_spec.rb

@@ -125,13 +125,11 @@ Environment:
     -j, --jobs NUMBER                Number of kill jobs. Defaults to number of processors.
 
 Options:
-        --expected-coverage COVERAGE Fail unless COVERAGE is not reached exactly, parsed via Rational()
         --use INTEGRATION            Use INTEGRATION to kill mutations
         --ignore-subject EXPRESSION  Ignore subjects that match EXPRESSION as prefix
         --since REVISION             Only select subjects touched since REVISION
         --fail-fast                  Fail fast
         --version                    Print mutants version
-    -d, --debug                      Enable debugging output
     -h, --help                       Show this message
         MESSAGE
       end
@@ -151,6 +149,12 @@ Options:
       context 'when integration exists' do
         let(:flags) { %w[--use rspec] }
 
+        before do
+          expect(Kernel).to receive(:require)
+            .with('mutant/integration/rspec')
+            .and_call_original
+        end
+
         it_should_behave_like 'a cli parser'
 
         let(:expected_integration) { Mutant::Integration::Rspec }
@@ -189,38 +193,6 @@ Options:
       end
     end
 
-    context 'with expected-coverage flag' do
-      context 'given as decimal' do
-        let(:flags) { %w[--expected-coverage 0.1] }
-
-        it_should_behave_like 'a cli parser'
-
-        it 'configures expected coverage' do
-          expect(subject.config.expected_coverage).to eql(Rational(1, 10))
-        end
-      end
-
-      context 'given as scientific' do
-        let(:flags) { %w[--expected-coverage 1e-1] }
-
-        it_should_behave_like 'a cli parser'
-
-        it 'configures expected coverage' do
-          expect(subject.config.expected_coverage).to eql(Rational(1, 10))
-        end
-      end
-
-      context 'given as rational' do
-        let(:flags) { %w[--expected-coverage 1/10] }
-
-        it_should_behave_like 'a cli parser'
-
-        it 'configures expected coverage' do
-          expect(subject.config.expected_coverage).to eql(Rational(1, 10))
-        end
-      end
-    end
-
     context 'with require flags' do
       let(:flags) { %w[--require foo --require bar] }
 
@@ -271,18 +243,8 @@ Options:
       end
     end
 
-    context 'with debug flag' do
-      let(:flags) { %w[--debug] }
-
-      it_should_behave_like 'a cli parser'
-
-      it 'sets the debug option' do
-        expect(subject.config.debug).to be(true)
-      end
-    end
-
     context 'with zombie flag' do
-      let(:flags)   { %w[--zombie] }
+      let(:flags) { %w[--zombie] }
 
       it_should_behave_like 'a cli parser'
 

data/spec/unit/mutant/context_spec.rb

@@ -1,18 +1,16 @@
-# rubocop:disable ClosingParenthesisIndentation
 RSpec.describe Mutant::Context do
   describe '.wrap' do
     subject { described_class.wrap(scope, node) }
 
-    let(:node)  { s(:str, 'test') }
+    let(:node) { s(:str, 'test') }
 
     context 'with Module as scope' do
-      let(:scope) { Mutant          }
+      let(:scope) { Mutant }
 
       let(:expected) do
         s(:module,
           s(:const, nil, :Mutant),
-          s(:str, 'test')
-        )
+          s(:str, 'test'))
       end
 
       it { should eql(expected) }
@@ -25,8 +23,7 @@ RSpec.describe Mutant::Context do
         s(:class,
           s(:const, nil, :Context),
           nil,
-          s(:str, 'test')
-        )
+          s(:str, 'test'))
       end
 
       it { should eql(expected) }

data/spec/unit/mutant/env/{boostrap_spec.rb → bootstrap_spec.rb}

@@ -177,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)
           ],
-          mutations: subjects.flat_map(&:mutations),
-          subjects:  subjects
+          mutations:        subjects.flat_map(&:mutations),
+          subjects:         subjects
         )
       end
 

data/spec/unit/mutant/env_spec.rb

@@ -13,18 +13,15 @@ RSpec.describe Mutant::Env do
       )
     end
 
-    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(:isolation) do
-      instance_double(Mutant::Isolation::Fork.singleton_class)
-    end
+    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(:isolation)         { instance_double(Mutant::Isolation::Fork) }
 
     let(:mutation) do
       instance_double(
@@ -37,16 +34,16 @@ RSpec.describe Mutant::Env do
       Mutant::Config::DEFAULT.with(
         isolation:   isolation,
         integration: integration_class,
-        kernel:      instance_double(Kernel.singleton_class)
+        kernel:      class_double(Kernel)
       )
     end
 
     let(:mutation_subject) do
       instance_double(
         Mutant::Subject,
-        context: context,
+        context:        context,
         identification: 'subject',
-        source: 'original'
+        source:         'original'
       )
     end
 
@@ -56,7 +53,7 @@ RSpec.describe Mutant::Env do
       specify do
         should eql(
           Mutant::Result::Mutation.new(
-            mutation: mutation,
+            mutation:    mutation,
             test_result: test_result
           )
         )

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

@@ -88,8 +88,8 @@ RSpec.describe Mutant::Integration::Rspec do
   let(:world) do
     double(
       'world',
-      example_groups:         example_groups,
-      filtered_examples:      filtered_examples
+      example_groups:    example_groups,
+      filtered_examples: filtered_examples
     )
   end
 

data/spec/unit/mutant/integration_spec.rb

@@ -10,6 +10,20 @@ RSpec.describe Mutant::Integration do
     subject { object.setup }
     it_should_behave_like 'a command method'
   end
+
+  describe '.setup' do
+    subject { described_class.setup(kernel, name) }
+
+    let(:name)   { 'null'               }
+    let(:kernel) { class_double(Kernel) }
+
+    before do
+      expect(kernel).to receive(:require)
+        .with('mutant/integration/null')
+    end
+
+    it { should be(Mutant::Integration::Null) }
+  end
 end
 
 RSpec.describe Mutant::Integration::Null do

data/spec/unit/mutant/isolation/fork_spec.rb

@@ -0,0 +1,155 @@
+# The fork isolation is all about managing a series of systemcalls with proper error handling
+#
+# So creating a unit spec for this is challenging. Especially under mutation testing.
+# Hence we even have to implement our own message expectation mechanism, as rspec build in
+# expectations are not able to correctly specify a sequence of expectations where a specific
+# message is send twice.
+#
+# Also our replacement for rspec-expectations used here allows easier deduplication.
+RSpec.describe Mutant::Isolation::Fork do
+  let(:block_return)      { instance_double(Object, :block_return)      }
+  let(:block_return_blob) { instance_double(String, :block_return_blob) }
+  let(:devnull)           { instance_double(Proc, :devnull)             }
+  let(:io)                { class_double(IO)                            }
+  let(:isolated_block)    { -> { block_return }                         }
+  let(:marshal)           { class_double(Marshal)                       }
+  let(:process)           { class_double(Process)                       }
+  let(:pid)               { class_double(Fixnum)                        }
+  let(:reader)            { instance_double(IO, :reader)                }
+  let(:stderr)            { instance_double(IO, :stderr)                }
+  let(:stdout)            { instance_double(IO, :stdout)                }
+  let(:writer)            { instance_double(IO, :writer)                }
+  let(:nullio)            { instance_double(IO, :nullio)                }
+
+  describe '#call' do
+    let(:object) do
+      described_class.new(
+        devnull: devnull,
+        io:      io,
+        marshal: marshal,
+        process: process,
+        stderr:  stderr,
+        stdout:  stdout
+      )
+    end
+
+    subject { object.call(&isolated_block) }
+
+    let(:prefork_expectations) do
+      [
+        {
+          receiver:  io,
+          selector:  :pipe,
+          arguments: [binmode: true],
+          reaction:  {
+            yields: [[reader, writer]]
+          }
+        }
+      ]
+    end
+
+    context 'when no IO operation fails' do
+      let(:expectations) do
+        [
+          *prefork_expectations,
+          {
+            receiver: process,
+            selector: :fork,
+            reaction: {
+              yields: [],
+              return: pid
+            }
+          },
+          # Inside the killfork
+          {
+            receiver: reader,
+            selector: :close
+          },
+          {
+            receiver: writer,
+            selector: :binmode
+          },
+          {
+            receiver: devnull,
+            selector: :call,
+            reaction: {
+              yields: [nullio]
+            }
+          },
+          {
+            receiver:  stderr,
+            selector:  :reopen,
+            arguments: [nullio]
+          },
+          {
+            receiver:  stdout,
+            selector:  :reopen,
+            arguments: [nullio]
+          },
+          {
+            receiver:  marshal,
+            selector:  :dump,
+            arguments: [block_return],
+            reaction:  {
+              return: block_return_blob
+            }
+          },
+          {
+            receiver:  writer,
+            selector:  :syswrite,
+            arguments: [block_return_blob]
+          },
+          {
+            receiver: writer,
+            selector: :close
+          },
+          # Outside the killfork
+          {
+            receiver: writer,
+            selector: :close
+          },
+          {
+            receiver:  marshal,
+            selector:  :load,
+            arguments: [reader],
+            reaction:  {
+              return: block_return
+            }
+          },
+          {
+            receiver:  process,
+            selector:  :waitpid,
+            arguments: [pid]
+          }
+        ].map(&XSpec::MessageExpectation.method(:parse))
+      end
+
+      specify do
+        XSpec::ExpectationVerifier.verify(self, expectations) do
+          expect(subject).to be(block_return)
+        end
+      end
+    end
+
+    context 'when fork fails' do
+      let(:expectations) do
+        [
+          *prefork_expectations,
+          {
+            receiver: process,
+            selector: :fork,
+            reaction: {
+              exception: RuntimeError.new('fork(2)')
+            }
+          }
+        ].map(&XSpec::MessageExpectation.method(:parse))
+      end
+
+      specify do
+        XSpec::ExpectationVerifier.verify(self, expectations) do
+          expect { expect(subject) }.to raise_error(described_class::Error, 'fork(2)')
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutant/isolation/none_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe Mutant::Isolation::None do
+  describe '.call' do
+    let(:object) { described_class.new }
+
+    it 'return block value' do
+      expect(object.call { :foo }).to be(:foo)
+    end
+
+    it 'wraps *all* exceptions' do
+      expect { object.call { fail 'foo' } }.to raise_error(
+        Mutant::Isolation::Error,
+        'foo'
+      )
+    end
+  end
+end

data/spec/unit/mutant/loader_spec.rb

@@ -11,7 +11,7 @@ RSpec.describe Mutant::Loader, '.call' do
   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(:kernel)   { class_double(Kernel)                      }
   let(:binding)  { instance_double(Binding)                  }
   let(:source)   { instance_double(String)                   }
   let(:node)     { instance_double(Parser::AST::Node)        }

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

@@ -16,17 +16,15 @@ RSpec.describe Mutant::Matcher::Methods::Instance, '#call' do
 
       private :method_d
 
-      public
-
       def method_a
       end
 
-      protected
+    protected
 
       def method_b
       end
 
-      private
+    private
 
       def method_c
       end

data/spec/unit/mutant/meta/example/dsl_spec.rb

@@ -0,0 +1,106 @@
+RSpec.describe Mutant::Meta::Example::DSL do
+  describe '.call' do
+    subject { described_class.call(file, type, block) }
+
+    let(:file)     { 'foo.rb'  }
+    let(:node)     { s(:false) }
+    let(:type)     { node.type }
+    let(:expected) { []        }
+
+    let(:expected_example) do
+      Mutant::Meta::Example.new(
+        file:      file,
+        node:      node,
+        node_type: type,
+        expected:  expected
+      )
+    end
+
+    def self.expect_example(&block)
+      let(:block) { block }
+
+      specify do
+        # Kill mutations to warnings
+        warnings = Mutant::WarningFilter.use do
+          should eql(expected_example)
+        end
+        expect(warnings).to eql([])
+      end
+    end
+
+    def self.expect_error(message, &block)
+      let(:block) { block }
+
+      specify do
+        expect { subject }.to raise_error(RuntimeError, message)
+      end
+    end
+
+    context 'source as node' do
+      expect_example do
+        source s(:false)
+      end
+    end
+
+    context 'source as string' do
+      expect_example do
+        source 'false'
+      end
+    end
+
+    context 'on node that needs unparser preprocessing to be normalized' do
+      let(:node) { s(:send, s(:float, -1.0), :/, s(:float, 0.0)) }
+
+      expect_example do
+        source '(-1.0) / 0.0'
+      end
+    end
+
+    context 'using #mutation' do
+      let(:expected) { [s(:nil)] }
+
+      expect_example do
+        source 'false'
+
+        mutation 'nil'
+      end
+    end
+
+    context 'using #singleton_mutations' do
+      let(:expected) { [s(:nil), s(:self)] }
+
+      expect_example do
+        source 'false'
+
+        singleton_mutations
+      end
+    end
+
+    context 'no definition of source' do
+      expect_error('source not defined') do
+      end
+    end
+
+    context 'duplicate definition of source' do
+      expect_error('source already defined') do
+        source 'true'
+        source 'false'
+      end
+    end
+
+    context 'uncoercable source' do
+      expect_error('Cannot coerce to node: nil') do
+        source nil
+      end
+    end
+
+    context 'duplicate mutation expectation' do
+      expect_error('Mutation for input: "true" is already expected') do
+        source 'false'
+
+        mutation 'true'
+        mutation 'true'
+      end
+    end
+  end
+end