mutant 0.5.12 → 0.5.13

data/lib/mutant/runner/subject.rb

@@ -63,6 +63,17 @@ module Mutant
         failed_mutations.empty?
       end
 
+      # Return tests used to kill mutations on this subject
+      #
+      # @return [Enumerable<Test>]
+      #
+      # @api private
+      #
+      def tests
+        config.strategy.tests(subject)
+      end
+      memoize :tests
+
     private
 
       # Perform operation
@@ -72,10 +83,9 @@ module Mutant
       # @api private
       #
       def run
-        subject = self.subject
-        report(subject)
-        @mutations = dispatch(subject.mutations)
-        report(self)
+        progress(subject)
+        @mutations = visit_collection(subject.mutations, tests)
+        progress(self)
       end
 
     end # Subject

data/lib/mutant/strategy.rb

@@ -54,39 +54,53 @@ module Mutant
       self
     end
 
-    # Kill mutation
+    # Return all available tests by strategy
     #
-    # @param [Mutation] mutation
-    #
-    # @return [Killer]
+    # @return [Enumerable<Test>]
     #
     # @api private
     #
-    def kill(mutation)
-      killer.new(self, mutation)
-    end
+    abstract_method :all_tests
 
-  private
-
-    # Return killer
+    # Return tests for mutation
+    #
+    # TODO: This logic is now centralized but still fucked.
     #
-    # @return [Class:Killer]
+    # @param [Mutation] mutation
+    #
+    # @return [Enumerable<Test>]
     #
     # @api private
     #
-    def killer
-      self.class::KILLER
+    def tests(subject)
+      subject.match_prefixes.map do |match_expression|
+        tests = all_tests.select do |test|
+          test.subject_identification.start_with?(match_expression)
+        end
+        return tests if tests.any?
+      end
+
+      []
     end
 
+  private
+
     # Null strategy that never kills a mutation
     class Null < self
 
-      register 'null'
+      register('null')
 
-      KILLER = Killer::Null
+      # Return all tests
+      #
+      # @return [Enumerable<Test>]
+      #
+      # @api private
+      #
+      def all_tests
+        EMPTY_ARRAY
+      end
 
     end # Null
 
   end # Strategy
-
 end # Mutant

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

@@ -68,7 +68,7 @@ module Mutant
           #
           def prepare
             scope.send(:memoized_methods).instance_variable_get(:@memory).delete(name)
-            scope.send(:undef_method, name)
+            super
             self
           end
 

data/lib/mutant/test.rb

@@ -0,0 +1,86 @@
+module Mutant
+  # Abstract base class for test that might kill a mutation
+  class Test
+    include AbstractType, Adamantium::Flat
+
+    # Object to report test status
+    class Report
+      include Adamantium::Flat, Anima::Update, Anima.new(
+        :test,
+        :output,
+        :success
+      )
+
+      alias_method :success?, :success
+
+      # Test if test failed
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def failed?
+        !success?
+      end
+
+      # Return marshallable data
+      #
+      # NOTE:
+      #
+      #  The test is intentionally NOT part of the mashalled data.
+      #  In rspec the example group cannot deterministically being marshalled, because
+      #  they reference a crazy mix of IO objects, global objects etc.
+      #
+      # @return [Array]
+      #
+      # @api private
+      #
+      def marshal_dump
+        [@output, @success]
+      end
+
+      # Load marshalled data
+      #
+      # @param [Array] arry
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def marshal_load(array)
+        @output, @success = array
+      end
+
+    end # Report
+
+    # Run tests
+    #
+    # @return [Test::Result]
+    #
+    # @api private
+    #
+    abstract_method :run
+
+    # Return test identification
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def identification
+      "#{self.class::PREFIX}:#{subject_identification}"
+    end
+    memoize :identification
+
+    # Return subject identification
+    #
+    # This method is used for current mutants primitive test selection.
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    abstract_method :subject_identification
+
+  end # Test
+end # Mutant

data/lib/mutant/version.rb

@@ -2,5 +2,5 @@
 
 module Mutant
   # The current mutant version
-  VERSION = '0.5.12'.freeze
+  VERSION = '0.5.13'.freeze
 end # Mutant

data/spec/integration/mutant/null_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'null integration' do
+
+  let(:base_cmd) { 'bundle exec mutant -I lib --require test_app "::TestApp*"' }
+
+  around do |example|
+    Dir.chdir(TestApp.root) do
+      example.run
+    end
+  end
+
+  specify 'it allows to kill mutations' do
+    expect(Kernel.system(base_cmd)).to be(false)
+  end
+end

data/spec/integration/mutant/rspec_spec.rb

@@ -10,7 +10,7 @@ describe 'rspec integration' do
     around do |example|
       Bundler.with_clean_env do
         Dir.chdir(TestApp.root) do
-          Kernel.system("bundle install --gemfile=#{gemfile}")
+          Kernel.system("bundle install --gemfile=#{gemfile}") || fail('Bundle install failed!')
           ENV['BUNDLE_GEMFILE'] = gemfile
           example.run
         end

data/spec/spec_helper.rb

@@ -2,11 +2,9 @@
 
 if ENV['COVERAGE'] == 'true'
   require 'simplecov'
-  require 'coveralls'
 
   SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
     SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
  ]
 
   SimpleCov.start do

data/spec/unit/mutant/diff_spec.rb

@@ -0,0 +1,162 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mutant::Diff do
+  let(:object) { described_class }
+
+  describe '.build' do
+
+    subject { object.build(old_string, new_string) }
+
+    let(:old_string) { "foo\nbar" }
+    let(:new_string) { "bar\nbaz" }
+
+    it { should eql(Mutant::Diff.new(%w(foo bar), %w(bar baz))) }
+
+  end
+
+  describe '.colorize_line' do
+    let(:object) { described_class }
+
+    subject { object.colorize_line(line) }
+
+    context 'line beginning with "+"' do
+      let(:line) { '+line' }
+
+      it { should eql(Mutant::Color::GREEN.format(line)) }
+    end
+
+    context 'line beginning with "-"' do
+      let(:line) { '-line' }
+
+      it { should eql(Mutant::Color::RED.format(line)) }
+    end
+
+    context 'line beginning in other char' do
+      let(:line) { ' line' }
+
+      it { should eql(line) }
+    end
+  end
+
+  describe '#diff' do
+    let(:object) { described_class.new(old, new) }
+
+    subject { object.diff }
+
+    context 'when there is a diff at begin of hunk' do
+      let(:old) { %w(foo bar) }
+      let(:new) { %w(baz bar) }
+
+      let(:expectation) do
+        strip_indent(<<-STR)
+          @@ -1,3 +1,3 @@
+          -foo
+          +baz
+           bar
+        STR
+      end
+
+      it { should eql(expectation) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+
+    context 'when there is a diff NOT at begin of hunk' do
+      let(:old) { %w(foo bar)     }
+      let(:new) { %w(foo baz bar) }
+
+      let(:expectation) do
+        strip_indent(<<-STR)
+          @@ -1,3 +1,4 @@
+           foo
+          +baz
+           bar
+        STR
+      end
+
+      it { should eql(expectation) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+
+    context 'when the diff has a long context at begin' do
+      let(:old) { %w(foo bar baz boz a b c)       }
+      let(:new) { %w(foo bar baz boz a b c other) }
+
+      let(:expectation) do
+        strip_indent(<<-STR)
+          @@ -1,8 +1,9 @@
+           foo
+           bar
+           baz
+           boz
+           a
+           b
+           c
+          +other
+        STR
+      end
+
+      it { should eql(expectation) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+
+    context 'when the diff has a long context at end, deleting' do
+      let(:old) { %w(other foo bar baz boz a b c) }
+      let(:new) { %w(foo bar baz boz a b c)       }
+
+      let(:expectation) do
+        strip_indent(<<-STR)
+          @@ -1,9 +1,8 @@
+          -other
+           foo
+           bar
+           baz
+           boz
+           a
+           b
+           c
+        STR
+      end
+
+      it { should eql(expectation) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+
+    context 'when the diff has a long context at end, inserting' do
+      let(:old) { %w(foo bar baz boz a b c)       }
+      let(:new) { %w(other foo bar baz boz a b c) }
+
+      let(:expectation) do
+        strip_indent(<<-STR)
+          @@ -1,8 +1,9 @@
+          +other
+           foo
+           bar
+           baz
+           boz
+           a
+           b
+           c
+        STR
+      end
+
+      it { should eql(expectation) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+
+    context 'when there is no diff' do
+      let(:old) { '' }
+      let(:new) { '' }
+
+      it { should be(nil) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+  end
+end

data/spec/unit/mutant/mutation_spec.rb

@@ -4,10 +4,13 @@ require 'spec_helper'
 
 describe Mutant::Mutation do
 
-  let(:class_under_test) { Class.new(described_class) { memoize :identification }             }
-  let(:object)           { class_under_test.new(mutation_subject, Mutant::NodeHelpers::N_NIL) }
-  let(:mutation_subject) { double('Subject', identification: 'subject', source: 'original')   }
-  let(:node)             { double('Node')                                                     }
+  class TestMutation < Mutant::Mutation
+    SYMBOL = 'test'
+  end
+
+  let(:object)           { TestMutation.new(mutation_subject, Mutant::NodeHelpers::N_NIL)   }
+  let(:mutation_subject) { double('Subject', identification: 'subject', source: 'original') }
+  let(:node)             { double('Node')                                                   }
 
   describe '#code' do
     subject { object.code }
@@ -37,7 +40,7 @@ describe Mutant::Mutation do
 
     subject { object.identification }
 
-    it { should eql('subject:8771a') }
+    it { should eql('test:subject:8771a') }
 
     it_should_behave_like 'an idempotent method'
   end

data/spec/unit/mutant/mutator/node/and_asgn_spec.rb

@@ -3,25 +3,17 @@
 require 'spec_helper'
 
 describe Mutant::Mutator::Node::OpAsgn, 'and_asgn' do
-  let(:random_fixnum) { 5        }
-  let(:random_string) { 'random' }
-
   let(:source)  { 'a &&= 1' }
 
   let(:mutations) do
     mutations = []
-    mutations << 'srandom &&= 1'
+    mutations << 'a__mutant__ &&= 1'
     mutations << 'a &&= nil'
     mutations << 'a &&= 0'
     mutations << 'a &&= -1'
     mutations << 'a &&= 2'
-    mutations << 'a &&= 5'
     mutations << 'nil'
   end
 
-  before do
-    Mutant::Random.stub(fixnum: random_fixnum, hex_string: random_string)
-  end
-
   it_should_behave_like 'a mutator'
 end