mutant 0.6.7 → 0.7.1

data/spec/unit/mutant/mutation_spec.rb

@@ -4,9 +4,58 @@ RSpec.describe Mutant::Mutation do
     SYMBOL = 'test'.freeze
   end
 
-  let(:object)           { TestMutation.new(mutation_subject, Mutant::AST::Nodes::N_NIL)                      }
-  let(:mutation_subject) { double('Subject', identification: 'subject', context: context, source: 'original') }
-  let(:context)          { double('Context')                                                                  }
+  let(:object)  { TestMutation.new(mutation_subject, Mutant::AST::Nodes::N_NIL) }
+  let(:context) { double('Context')                                             }
+
+  let(:mutation_subject) do
+    double(
+      'Subject',
+      identification: 'subject',
+      context: context,
+      source: 'original',
+      tests:  tests
+    )
+  end
+
+  let(:test_a) { double('Test A') }
+  let(:test_b) { double('Test B') }
+  let(:tests)  { [test_a, test_b] }
+
+  describe '#kill' do
+    let(:isolation)    { Mutant::Isolation::None                                                 }
+    let(:integration)  { double('Integration')                                                   }
+    let(:object)       { Mutant::Mutation::Evil.new(mutation_subject, Mutant::AST::Nodes::N_NIL) }
+    let(:wrapped_node) { double('Wrapped Node')                                                  }
+
+    subject { object.kill(isolation, integration) }
+
+    before do
+      allow(Time).to receive(:now).and_return(Time.at(0))
+    end
+
+    context 'when isolation does not raise error' do
+      let(:test_result)  { double('Test Result A', passed: false)                                  }
+
+      before do
+        expect(mutation_subject).to receive(:public?).and_return(true).ordered
+        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(integration).to receive(:call).with(tests).and_return(test_result).ordered
+        expect(test_result).to receive(:update).with(tests: tests).and_return(test_result).ordered
+      end
+
+      it { should eql(test_result) }
+    end
+
+    context 'when isolation does raise error' do
+      before do
+        expect(isolation).to receive(:call).and_raise(Mutant::Isolation::Error, 'test-error')
+      end
+
+      it { should eql(Mutant::Result::Test.new(tests: tests, output: 'test-error', passed: false, runtime: 0.0)) }
+    end
+  end
 
   describe '#code' do
     subject { object.code }
@@ -24,21 +73,6 @@ RSpec.describe Mutant::Mutation do
     it_should_behave_like 'an idempotent method'
   end
 
-  describe '#insert' do
-    subject { object.insert }
-
-    let(:wrapped_node) { double('Wrapped Node') }
-
-    before do
-      expect(mutation_subject).to receive(:public?).ordered.and_return(true)
-      expect(mutation_subject).to receive(:prepare).ordered
-      expect(context).to receive(:root).ordered.with(s(:nil)).and_return(wrapped_node)
-      expect(Mutant::Loader::Eval).to receive(:call).ordered.with(wrapped_node, mutation_subject).and_return(nil)
-    end
-
-    it_should_behave_like 'a command method'
-  end
-
   describe '#source' do
     subject { object.source }
 

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

@@ -2,7 +2,7 @@ RSpec.describe Mutant::Mutator::Registry do
   describe '#lookup' do
     subject { Mutant::Mutator::REGISTRY.lookup(node) }
 
-    context 'on registred node' do
+    context 'on registered node' do
       let(:node) { s(:true) }
 
       it { should eql(Mutant::Mutator::Node::Literal::Boolean) }
@@ -12,7 +12,7 @@ RSpec.describe Mutant::Mutator::Registry do
       let(:node) { s(:unknown) }
 
       it 'raises error' do
-        expect { subject }.to raise_error(described_class::RegistryError, "No mutator to handle: :unknown")
+        expect { subject }.to raise_error(described_class::RegistryError, 'No mutator to handle: :unknown')
       end
     end
   end
@@ -24,7 +24,7 @@ RSpec.describe Mutant::Mutator::Registry do
 
     subject { object.register(type, mutator) }
 
-    context 'when registring an invalid node type' do
+    context 'when registering an invalid node type' do
       let(:type) { :invalid }
 
       it 'raises error' do
@@ -32,7 +32,7 @@ RSpec.describe Mutant::Mutator::Registry do
       end
     end
 
-    context 'when registring a valid node type' do
+    context 'when registering a valid node type' do
       let(:type) { :true }
 
       it 'allows to lookup mutator' do

data/spec/unit/mutant/reporter/cli_spec.rb

@@ -1,4 +1,6 @@
 RSpec.describe Mutant::Reporter::CLI do
+  setup_shared_context
+
   let(:object) { described_class.new(output, format) }
   let(:output) { StringIO.new }
 
@@ -31,110 +33,6 @@ RSpec.describe Mutant::Reporter::CLI do
     allow(Time).to receive(:now).and_return(Time.now)
   end
 
-  let(:result) do
-    Mutant::Result::Env.new(
-      env:             env,
-      runtime:         1.1,
-      subject_results: subject_results
-    )
-  end
-
-  let(:env) do
-    double(
-      'Env',
-      class: Mutant::Env,
-      matchable_scopes: matchable_scopes,
-      config: config,
-      subjects: subjects,
-      mutations: subjects.flat_map(&:mutations)
-    )
-  end
-
-  let(:config)           { Mutant::Config::DEFAULT.update(jobs: 1) }
-  let(:mutation_class)   { Mutant::Mutation::Evil                       }
-  let(:matchable_scopes) { double('Matchable Scopes', length: 10)       }
-
-  before do
-    allow(mutation_a).to receive(:subject).and_return(_subject)
-    allow(mutation_b).to receive(:subject).and_return(_subject)
-  end
-
-  let(:mutation_a) do
-    double(
-      'Mutation',
-      identification:  'mutation_id-a',
-      class:           mutation_class,
-      original_source: 'true',
-      source:          mutation_source
-    )
-  end
-
-  let(:mutation_b) do
-    double(
-      'Mutation',
-      identification:  'mutation_id-b',
-      class:           mutation_class,
-      original_source: 'true',
-      source:          mutation_source
-    )
-  end
-
-  let(:mutation_source) { 'false' }
-
-  let(:_subject) do
-    double(
-      'Subject',
-      class:          Mutant::Subject,
-      node:           s(:true),
-      identification: 'subject_id',
-      mutations:      subject_mutations,
-      tests: [
-        double('Test', identification: 'test_id')
-      ]
-    )
-  end
-
-  let(:subject_mutations) { [mutation_a] }
-
-  let(:test_results) do
-    [
-      double(
-        'Test Result',
-        class: Mutant::Result::Test,
-        test: _subject.tests.first,
-        runtime: 1.0,
-        output: 'test-output',
-        success?: mutation_result_success
-      )
-    ]
-  end
-
-  let(:mutation_a_result) do
-    double(
-      'Mutation Result',
-      class: Mutant::Result::Mutation,
-      mutation: mutation_a,
-      killtime: 0.5,
-      runtime:  1.0,
-      index:    0,
-      success?: mutation_result_success,
-      test_results: test_results,
-      failed_test_results: mutation_result_success ? [] : test_results
-    )
-  end
-
-  let(:subject_results) do
-    [
-      Mutant::Result::Subject.new(
-        subject: _subject,
-        runtime: 1.0,
-        mutation_results: [mutation_a_result]
-      )
-    ]
-  end
-
-  let(:subjects) { [_subject] }
-
   describe '.build' do
     subject { described_class.build(output) }
 
@@ -210,47 +108,35 @@ RSpec.describe Mutant::Reporter::CLI do
   end
 
   describe '#progress' do
-    subject { object.progress(collector) }
-
-    let(:collector) do
-      Mutant::Runner::Collector.new(env)
-    end
-
-    let(:mutation_result_success) { true }
+    subject { object.progress(status) }
 
     context 'on progressive format' do
-
       let(:format) { progressive_format }
 
-      context 'with empty collector' do
+      context 'with empty scheduler' do
+        update(:env_result) { { subject_results: [] } }
 
         it_reports ''
       end
 
       context 'with last mutation present' do
-
-        before do
-          collector.start(mutation_a)
-          collector.finish(mutation_a_result)
-        end
+        update(:env_result) { { subject_results: [subject_a_result] } }
 
         context 'when mutation is successful' do
-          it_reports '.'
+          it_reports '..'
         end
 
         context 'when mutation is NOT successful' do
-          let(:mutation_result_success) { false }
-
-          it_reports 'F'
+          update(:mutation_a_test_result) { { passed: true } }
+          it_reports 'F.'
         end
       end
     end
 
     context 'on framed format' do
+      context 'with empty scheduler' do
+        update(:env_result) { { subject_results: [] } }
 
-      let(:mutation_result_success) { true }
-
-      context 'with empty collector' do
         it_reports <<-REPORT
           Mutant configuration:
           Matcher:            #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
@@ -261,24 +147,21 @@ RSpec.describe Mutant::Reporter::CLI do
           Requires:           []
           Available Subjects: 1
           Subjects:           1
-          Mutations:          1
+          Mutations:          2
           Kills:              0
           Alive:              0
-          Runtime:            0.00s
+          Runtime:            4.00s
           Killtime:           0.00s
-          Overhead:           NaN%
+          Overhead:           Inf%
           Coverage:           0.00%
           Expected:           100.00%
           Active subjects:    0
         REPORT
       end
 
-      context 'with collector active on one subject' do
-        before do
-          collector.start(mutation_a)
-        end
-
+      context 'with scheduler active on one subject' do
         context 'without progress' do
+          update(:status) { { active_jobs: [].to_set } }
 
           it_reports(<<-REPORT)
             Mutant configuration:
@@ -290,32 +173,23 @@ RSpec.describe Mutant::Reporter::CLI do
             Requires:           []
             Available Subjects: 1
             Subjects:           1
-            Mutations:          1
-            Kills:              0
+            Mutations:          2
+            Kills:              2
             Alive:              0
-            Runtime:            0.00s
-            Killtime:           0.00s
-            Overhead:           NaN%
-            Coverage:           0.00%
+            Runtime:            4.00s
+            Killtime:           2.00s
+            Overhead:           100.00%
+            Coverage:           100.00%
             Expected:           100.00%
-            Active subjects:    1
-            subject_id mutations: 1
-            - test_id
-            (00/01)   0% - killtime: 0.00s runtime: 0.00s overhead: 0.00s
+            Active subjects:    0
           REPORT
         end
 
         context 'with progress' do
-
-          let(:subject_mutations) { [mutation_a, mutation_b] }
-
-          before do
-            collector.start(mutation_b)
-            collector.finish(mutation_a_result)
-          end
+          update(:status) { { active_jobs: [job_a].to_set } }
 
           context 'on failure' do
-            let(:mutation_result_success) { false }
+            update(:mutation_a_test_result) { { passed: true } }
 
             it_reports(<<-REPORT)
               Mutant configuration:
@@ -328,18 +202,20 @@ RSpec.describe Mutant::Reporter::CLI do
               Available Subjects: 1
               Subjects:           1
               Mutations:          2
-              Kills:              0
+              Kills:              1
               Alive:              1
-              Runtime:            0.00s
-              Killtime:           0.50s
-              Overhead:           -100.00%
-              Coverage:           0.00%
+              Runtime:            4.00s
+              Killtime:           2.00s
+              Overhead:           100.00%
+              Coverage:           50.00%
               Expected:           100.00%
               Active subjects:    1
-              subject_id mutations: 2
-              - test_id
-              F
-              (00/02)   0% - killtime: 0.50s runtime: 1.00s overhead: 0.50s
+              subject-a mutations: 2
+              - test-a
+              F.
+              (01/02)  50% - killtime: 2.00s runtime: 2.00s overhead: 0.00s
+              Active Jobs:
+              0: evil:subject-a:d27d2
             REPORT
           end
 
@@ -355,18 +231,20 @@ RSpec.describe Mutant::Reporter::CLI do
               Available Subjects: 1
               Subjects:           1
               Mutations:          2
-              Kills:              1
+              Kills:              2
               Alive:              0
-              Runtime:            0.00s
-              Killtime:           0.50s
-              Overhead:           -100.00%
+              Runtime:            4.00s
+              Killtime:           2.00s
+              Overhead:           100.00%
               Coverage:           100.00%
               Expected:           100.00%
               Active subjects:    1
-              subject_id mutations: 2
-              - test_id
-              .
-              (01/02) 100% - killtime: 0.50s runtime: 1.00s overhead: 0.50s
+              subject-a mutations: 2
+              - test-a
+              ..
+              (02/02) 100% - killtime: 2.00s runtime: 2.00s overhead: 0.00s
+              Active Jobs:
+              0: evil:subject-a:d27d2
             REPORT
           end
         end
@@ -374,11 +252,9 @@ RSpec.describe Mutant::Reporter::CLI do
     end
 
     describe '#report' do
-      subject { object.report(result) }
+      subject { object.report(status.env_result) }
 
       context 'with full coverage' do
-        let(:mutation_result_success) { true }
-
         it_reports(<<-REPORT)
           Mutant configuration:
           Matcher:            #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
@@ -389,26 +265,26 @@ RSpec.describe Mutant::Reporter::CLI do
           Requires:           []
           Available Subjects: 1
           Subjects:           1
-          Mutations:          1
-          Kills:              1
+          Mutations:          2
+          Kills:              2
           Alive:              0
-          Runtime:            1.10s
-          Killtime:           0.50s
-          Overhead:           120.00%
+          Runtime:            4.00s
+          Killtime:           2.00s
+          Overhead:           100.00%
           Coverage:           100.00%
           Expected:           100.00%
         REPORT
       end
 
       context 'and partial coverage' do
-        let(:mutation_result_success) { false }
+        update(:mutation_a_test_result) { { passed: true } }
 
         context 'on evil mutation' do
           context 'with a diff' do
             it_reports(<<-REPORT)
-              subject_id
-              - test_id
-              mutation_id-a
+              subject-a
+              - test-a
+              evil:subject-a:d27d2
               @@ -1,2 +1,2 @@
               -true
               +false
@@ -422,29 +298,29 @@ RSpec.describe Mutant::Reporter::CLI do
               Requires:           []
               Available Subjects: 1
               Subjects:           1
-              Mutations:          1
-              Kills:              0
+              Mutations:          2
+              Kills:              1
               Alive:              1
-              Runtime:            1.10s
-              Killtime:           0.50s
-              Overhead:           120.00%
-              Coverage:           0.00%
+              Runtime:            4.00s
+              Killtime:           2.00s
+              Overhead:           100.00%
+              Coverage:           50.00%
               Expected:           100.00%
             REPORT
           end
 
           context 'without a diff' do
-            let(:mutation_source) { 'true' }
+            let(:mutation_a_node) { s(:true) }
 
             it_reports(<<-REPORT)
-              subject_id
-              - test_id
-              mutation_id-a
+              subject-a
+              - test-a
+              evil:subject-a:d5318
               Original source:
               true
               Mutated Source:
               true
-              BUG: Mutation NOT resulted in exactly one diff. Please report a reproduction!
+              BUG: Mutation NOT resulted in exactly one diff hunk. Please report a reproduction!
               -----------------------
               Mutant configuration:
               Matcher:            #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
@@ -455,26 +331,29 @@ RSpec.describe Mutant::Reporter::CLI do
               Requires:           []
               Available Subjects: 1
               Subjects:           1
-              Mutations:          1
-              Kills:              0
+              Mutations:          2
+              Kills:              1
               Alive:              1
-              Runtime:            1.10s
-              Killtime:           0.50s
-              Overhead:           120.00%
-              Coverage:           0.00%
+              Runtime:            4.00s
+              Killtime:           2.00s
+              Overhead:           100.00%
+              Coverage:           50.00%
               Expected:           100.00%
             REPORT
           end
         end
 
         context 'on neutral mutation' do
-          let(:mutation_class)  { Mutant::Mutation::Neutral }
-          let(:mutation_source) { 'true' }
+          update(:mutation_a_test_result) { { passed: false } }
+
+          let(:mutation_a) do
+            Mutant::Mutation::Neutral.new(subject_a, s(:true))
+          end
 
           it_reports(<<-REPORT)
-            subject_id
-            - test_id
-            mutation_id-a
+            subject-a
+            - test-a
+            neutral:subject-a:d5318
             --- Neutral failure ---
             Original code was inserted unmutated. And the test did NOT PASS.
             Your tests do not pass initially or you found a bug in mutant / unparser.
@@ -482,10 +361,25 @@ RSpec.describe Mutant::Reporter::CLI do
             (true)
             Unparsed Source:
             true
-            Test Reports: 1
-            - test_id / runtime: 1.0
+            Test Result:
+            - 1 @ runtime: 1.0
+              - test-a
             Test Output:
-            test-output
+            mutation a test result output
+            -----------------------
+            neutral:subject-a:d5318
+            --- Neutral failure ---
+            Original code was inserted unmutated. And the test did NOT PASS.
+            Your tests do not pass initially or you found a bug in mutant / unparser.
+            Subject AST:
+            (true)
+            Unparsed Source:
+            true
+            Test Result:
+            - 1 @ runtime: 1.0
+              - test-a
+            Test Output:
+            mutation b test result output
             -----------------------
             Mutant configuration:
             Matcher:            #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
@@ -496,31 +390,46 @@ RSpec.describe Mutant::Reporter::CLI do
             Requires:           []
             Available Subjects: 1
             Subjects:           1
-            Mutations:          1
+            Mutations:          2
             Kills:              0
-            Alive:              1
-            Runtime:            1.10s
-            Killtime:           0.50s
-            Overhead:           120.00%
+            Alive:              2
+            Runtime:            4.00s
+            Killtime:           2.00s
+            Overhead:           100.00%
             Coverage:           0.00%
             Expected:           100.00%
           REPORT
         end
 
         context 'on noop mutation' do
-          let(:mutation_class) { Mutant::Mutation::Noop }
+          update(:mutation_a_test_result) { { passed: false } }
+
+          let(:mutation_a) do
+            Mutant::Mutation::Noop.new(subject_a, s(:true))
+          end
 
           it_reports(<<-REPORT)
-            subject_id
-            - test_id
-            mutation_id-a
+            subject-a
+            - test-a
+            noop:subject-a:d5318
             ---- Noop failure -----
             No code was inserted. And the test did NOT PASS.
             This is typically a problem of your specs not passing unmutated.
-            Test Reports: 1
-            - test_id / runtime: 1.0
+            Test Result:
+            - 1 @ runtime: 1.0
+              - test-a
             Test Output:
-            test-output
+            mutation a test result output
+            -----------------------
+            noop:subject-a:d5318
+            ---- Noop failure -----
+            No code was inserted. And the test did NOT PASS.
+            This is typically a problem of your specs not passing unmutated.
+            Test Result:
+            - 1 @ runtime: 1.0
+              - test-a
+            Test Output:
+            mutation b test result output
             -----------------------
             Mutant configuration:
             Matcher:            #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
@@ -531,44 +440,17 @@ RSpec.describe Mutant::Reporter::CLI do
             Requires:           []
             Available Subjects: 1
             Subjects:           1
-            Mutations:          1
+            Mutations:          2
             Kills:              0
-            Alive:              1
-            Runtime:            1.10s
-            Killtime:           0.50s
-            Overhead:           120.00%
+            Alive:              2
+            Runtime:            4.00s
+            Killtime:           2.00s
+            Overhead:           100.00%
             Coverage:           0.00%
             Expected:           100.00%
           REPORT
         end
       end
-
-      context 'without subjects' do
-        let(:subjects)        { [] }
-        let(:subject_results) { [] }
-
-        let(:config) { Mutant::Config::DEFAULT.update(jobs: 1, includes: %w[include-dir], requires: %w[require-name]) }
-
-        it_reports(<<-REPORT)
-          Mutant configuration:
-          Matcher:            #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
-          Integration:        null
-          Expect Coverage:    100.00%
-          Jobs:               1
-          Includes:           ["include-dir"]
-          Requires:           ["require-name"]
-          Available Subjects: 0
-          Subjects:           0
-          Mutations:          0
-          Kills:              0
-          Alive:              0
-          Runtime:            1.10s
-          Killtime:           0.00s
-          Overhead:           Inf%
-          Coverage:           0.00%
-          Expected:           100.00%
-        REPORT
-      end
     end
   end
 end