mutant 0.5.24 → 0.5.25

data/lib/mutant/subject.rb

@@ -2,16 +2,17 @@ module Mutant
   # Subject of a mutation
   class Subject
     include AbstractType, Adamantium::Flat, Enumerable
-    include Concord::Public.new(:context, :node)
+    include Concord::Public.new(:config, :context, :node)
 
     # Return mutations
     #
     # @return [Enumerable<Mutation>]
+    # @return [undefined]
     #
     # @api private
     #
     def mutations
-      mutations = []
+      mutations = [neutral_mutation]
       generate_mutations(mutations)
       mutations
     end
@@ -27,6 +28,28 @@ module Mutant
       context.source_path
     end
 
+    # Return tests for mutation
+    #
+    # TODO: This logic is now centralized but still fucked.
+    #
+    # @param [Mutation] mutation
+    #
+    # @return [Array<Test>]
+    #
+    # @api private
+    #
+    def tests
+      match_expressions.each do |match_expression|
+        tests = config.integration.all_tests.select do |test|
+          match_expression.prefix?(test.expression)
+        end
+        return tests if tests.any?
+      end
+
+      EMPTY_ARRAY
+    end
+    memoize :tests
+
     # Prepare the subject for the insertion of mutation
     #
     # @return [self]
@@ -81,17 +104,6 @@ module Mutant
       context.root(node)
     end
 
-    # Return root AST node for original AST ndoe
-    #
-    # @return [Parser::AST::Node]
-    #
-    # @api private
-    #
-    def original_root
-      root(node)
-    end
-    memoize :original_root
-
     # Return match expression
     #
     # @return [Expression]
@@ -119,8 +131,8 @@ module Mutant
     #
     # @api private
     #
-    def noop_mutation
-      Mutation::Neutral::Noop.new(self, node)
+    def neutral_mutation
+      Mutation::Neutral.new(self, node)
     end
 
     # Generate mutations
@@ -131,7 +143,11 @@ module Mutant
     #
     # @api private
     #
-    abstract_method :generate_mutations
+    def generate_mutations(emitter)
+      Mutator.each(node) do |mutant|
+        emitter << Mutation::Evil.new(self, mutant)
+      end
+    end
 
   end # Subject
 end # Mutant

data/lib/mutant/subject/method.rb

@@ -34,21 +34,6 @@ module Mutant
 
     private
 
-      # Return mutations
-      #
-      # @param [#<<] emitter
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def generate_mutations(emitter)
-        emitter << noop_mutation
-        Mutator.each(node) do |mutant|
-          emitter << Mutation::Evil.new(self, mutant)
-        end
-      end
-
       # Return scope
       #
       # @return [Class, Module]

data/lib/mutant/subject/method/instance.rb

@@ -75,7 +75,7 @@ module Mutant
           # @api private
           #
           def generate_mutations(emitter)
-            emitter << noop_mutation
+            emitter << neutral_mutation
             Mutator.each(node) do |mutant|
               emitter << Mutation::Evil.new(self, memoizer_node(mutant))
             end
@@ -87,8 +87,8 @@ module Mutant
           #
           # @api private
           #
-          def noop_mutation
-            Mutation::Neutral::Noop.new(self, memoizer_node(node))
+          def neutral_mutation
+            Mutation::Neutral.new(self, memoizer_node(node))
           end
 
           # Return memoizer node for mutant

data/lib/mutant/version.rb

@@ -1,4 +1,4 @@
 module Mutant
   # The current mutant version
-  VERSION = '0.5.24'.freeze
+  VERSION = '0.5.25'.freeze
 end # Mutant

data/lib/mutant/warning_expectation.rb

@@ -5,7 +5,7 @@ module Mutant
 
     # Error raised on expectation miss
     class ExpectationError < RuntimeError
-      include Concord.new(:unexpected, :missing)
+      include Concord.new(:unexpected)
 
       # Return exception message
       #
@@ -14,7 +14,7 @@ module Mutant
       # @api private
       #
       def message
-        "Unexpected warnings: #{unexpected.inspect} missing warnigns: #{missing.inspect}"
+        "Unexpected warnings: #{unexpected.inspect}"
       end
     end
 
@@ -28,11 +28,18 @@ module Mutant
       warnings = WarningFilter.use do
         block.call
       end
-      missing = expected - warnings
+
+      missing    = expected - warnings
       unexpected = warnings - expected
-      if missing.any? or unexpected.any?
-        fail ExpectationError.new(unexpected, missing)
+
+      if unexpected.any?
+        fail ExpectationError, unexpected
       end
+
+      if missing.any?
+        $stderr.puts("Expected but missing warnings: #{missing}")
+      end
+
       self
     end
 

data/spec/integration/mutant/corpus_spec.rb

@@ -160,7 +160,7 @@ describe 'Mutant on ruby corpus' do
       if block_given?
         yield
       else
-        raise 'System command failed!'
+        fail 'System command failed!'
       end
     end
 

data/spec/spec_helper.rb

@@ -13,6 +13,8 @@ if ENV['COVERAGE'] == 'true'
     add_filter 'vendor'
     add_filter 'test_app'
     add_filter 'lib/mutant/meta/*'
+    add_filter 'lib/mutant/zombifier'
+    add_filter 'lib/mutant/zombifier/*'
 
     minimum_coverage 89.77  # TODO: raise this to 100, then mutation test
   end
@@ -30,7 +32,9 @@ $LOAD_PATH << File.join(TestApp.root, 'lib')
 require 'test_app'
 
 module Fixtures
-  BOOT_ENV = Mutant::Env::Boot.new(Mutant::Reporter::CLI.new(STDERR), Mutant::Cache.new)
+  TEST_CONFIG = Mutant::Config::DEFAULT.update(reporter: Mutant::Reporter::Trace.new)
+  TEST_CACHE  = Mutant::Cache.new
+  TEST_ENV    = Mutant::Env.new(TEST_CONFIG, TEST_CACHE)
 end # Fixtures
 
 module ParserHelper

data/spec/unit/mutant/cli_spec.rb

@@ -0,0 +1,248 @@
+require 'spec_helper'
+
+shared_examples_for 'an invalid cli run' do
+  it 'raises error' do
+    expect do
+      subject
+    end.to raise_error(Mutant::CLI::Error, expected_message)
+  end
+end
+
+shared_examples_for 'a cli parser' do
+  it { expect(subject.config.integration).to eql(expected_integration)       }
+  it { expect(subject.config.reporter).to eql(expected_reporter)             }
+  it { expect(subject.config.matcher_config).to eql(expected_matcher_config) }
+end
+
+describe Mutant::CLI do
+  let(:object) { described_class }
+
+  describe '.run' do
+    subject { object.run(arguments) }
+
+    let(:arguments) { double('arguments') }
+
+    let(:report) { double('Report', success?: report_success) }
+    let(:config) { double('Config') }
+
+    before do
+      expect(Mutant::CLI).to receive(:call).with(arguments).and_return(config)
+      expect(Mutant::Env).to receive(:call).with(config).and_return(report)
+    end
+
+    context 'when report signalls success' do
+      let(:report_success) { true }
+
+      it 'exits failure' do
+        expect(subject).to be(0)
+      end
+    end
+
+    context 'when report signalls error' do
+      let(:report_success) { false }
+
+      it 'exits failure' do
+        expect(subject).to be(1)
+      end
+    end
+
+    context 'when execution raises an Mutant::CLI::Error' do
+      let(:exception) { Mutant::CLI::Error.new('test-error') }
+      let(:report_success) { nil }
+
+      before do
+        expect(report).to receive(:success?).and_raise(exception)
+      end
+
+      it 'exits failure' do
+        expect($stderr).to receive(:puts).with('test-error')
+        expect(subject).to be(1)
+      end
+    end
+  end
+
+  describe '.new' do
+    let(:object) { described_class }
+
+    subject { object.new(arguments) }
+
+    # Defaults
+    let(:expected_filter)         { Morpher.evaluator(s(:true))        }
+    let(:expected_integration)    { Mutant::Integration::Null.new      }
+    let(:expected_reporter)       { Mutant::Reporter::CLI.new($stdout) }
+    let(:expected_matcher_config) { default_matcher_config             }
+
+    let(:default_matcher_config) do
+      Mutant::Matcher::Config::DEFAULT
+        .update(match_expressions: expressions.map(&Mutant::Expression.method(:parse)))
+    end
+
+    let(:ns)    { Mutant::Matcher    }
+
+    let(:flags)       { []           }
+    let(:expressions) { %w[TestApp*] }
+
+    let(:arguments) { flags + expressions }
+
+    context 'with unknown flag' do
+      let(:flags) { %w[--invalid] }
+
+      let(:expected_message) { 'invalid option: --invalid' }
+
+      it_should_behave_like 'an invalid cli run'
+    end
+
+    context 'with unknown option' do
+      let(:flags) { %w[--invalid Foo] }
+
+      let(:expected_message) { 'invalid option: --invalid' }
+
+      it_should_behave_like 'an invalid cli run'
+    end
+
+    context 'without expressions' do
+      let(:expressions) { [] }
+
+      let(:expected_message) { 'No expressions given' }
+
+      it_should_behave_like 'an invalid cli run'
+    end
+
+    context 'with code filter and missing argument' do
+      let(:arguments)        { %w[--code]                 }
+      let(:expected_message) { 'missing argument: --code' }
+
+      it_should_behave_like 'an invalid cli run'
+    end
+
+    context 'with include help flag' do
+      let(:flags) { %w[--help] }
+
+      before do
+        expect($stdout).to receive(:puts).with(expected_message)
+        expect(Kernel).to receive(:exit).with(0)
+      end
+
+      it_should_behave_like 'a cli parser'
+
+      let(:expected_message) do
+        strip_indent(<<-MESSAGE)
+usage: mutant [options] MATCH_EXPRESSION ...
+Environment:
+        --zombie                     Run mutant zombified
+    -I, --include DIRECTORY          Add DIRECTORY to $LOAD_PATH
+    -r, --require NAME               Require file with NAME
+
+Options:
+        --score COVERAGE             Fail unless COVERAGE is not reached exactly
+        --use STRATEGY               Use STRATEGY for killing mutations
+        --ignore-subject PATTERN     Ignore subjects that match PATTERN
+        --code CODE                  Scope execution to subjects with CODE
+        --fail-fast                  Fail fast
+        --version                    Print mutants version
+    -d, --debug                      Enable debugging output
+    -h, --help                       Show this message
+        MESSAGE
+      end
+    end
+
+    context 'with include flag' do
+      let(:flags) { %w[--include foo] }
+
+      it_should_behave_like 'a cli parser'
+
+      it 'configures includes' do
+        expect(subject.config.includes).to eql(%w[foo])
+      end
+    end
+
+    context 'with use flag' do
+      let(:flags) { %w[--use rspec] }
+
+      it_should_behave_like 'a cli parser'
+
+      let(:expected_integration) { Mutant::Integration::Rspec2.new }
+    end
+
+    context 'with version flag' do
+      let(:flags) { %w[--version] }
+
+      before do
+        expect(Kernel).to receive(:exit).with(0)
+        expect($stdout).to receive(:puts).with("mutant-#{Mutant::VERSION}")
+      end
+
+      it_should_behave_like 'a cli parser'
+    end
+
+    context 'with score flag' do
+      let(:flags) { %w[--score 99.5] }
+
+      it_should_behave_like 'a cli parser'
+
+      it 'configures expected coverage' do
+        expect(subject.config.expected_coverage).to eql(99.5)
+      end
+    end
+
+    context 'with require flag' do
+      let(:flags) { %w[--require foo] }
+
+      it_should_behave_like 'a cli parser'
+
+      it 'configures requires' do
+        expect(subject.config.requires).to eql(%w[foo])
+      end
+    end
+
+    context 'with subject-ignore flag' do
+      let(:flags) { %w[--ignore-subject Foo::Bar] }
+
+      let(:expected_matcher_config) do
+        default_matcher_config.update(subject_ignores: [Mutant::Expression.parse('Foo::Bar')])
+      end
+
+      it_should_behave_like 'a cli parser'
+    end
+
+    context 'with fail-fast flag' do
+      let(:flags) { %w[--fail-fast] }
+
+      it_should_behave_like 'a cli parser'
+
+      it 'sets the fail fast option' do
+        expect(subject.config.fail_fast).to be(true)
+      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] }
+
+      it_should_behave_like 'a cli parser'
+
+      it 'sets the zombie option' do
+        expect(subject.config.zombie).to be(true)
+      end
+    end
+
+    context 'with subject code filter' do
+      let(:flags) { %w[--code faa --code bbb] }
+
+      let(:expected_matcher_config) do
+        default_matcher_config.update(subject_selects: [[:code, 'faa'], [:code, 'bbb']])
+      end
+
+      it_should_behave_like 'a cli parser'
+    end
+  end
+end