mutant 0.5.24 → 0.5.25

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

@@ -0,0 +1,337 @@
+require 'spec_helper'
+
+describe Mutant::Reporter::CLI do
+  let(:object) { described_class.new(output) }
+  let(:output) { StringIO.new }
+
+  def contents
+    output.rewind
+    output.read
+  end
+
+  describe '#warn' do
+    subject { object.warn(message) }
+
+    let(:message) { 'message' }
+
+    it 'writes message to output' do
+      expect { subject }.to change { contents }.from('').to("message\n")
+    end
+  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
+    )
+  end
+
+  let(:config)           { Mutant::Config::DEFAULT                }
+  let(:mutation_class)   { Mutant::Mutation::Evil                 }
+  let(:matchable_scopes) { double('Matchable Scopes', length: 10) }
+
+  before do
+    allow(mutation).to receive(:subject).and_return(_subject)
+  end
+
+  let(:mutation) do
+    double(
+      'Mutation',
+      identification:  'mutation_id',
+      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:      [mutation],
+      tests: [
+        double('Test', identification: 'test_id')
+      ]
+    )
+  end
+
+  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(:subject_results) do
+    [
+      Mutant::Result::Subject.new(
+        subject: _subject,
+        runtime: 1.0,
+        mutation_results: [
+          double(
+            'Mutation Result',
+            class: Mutant::Result::Mutation,
+            mutation: mutation,
+            killtime: 0.5,
+            success?: mutation_result_success,
+            test_results: test_results,
+            failed_test_results: mutation_result_success ? [] : test_results
+          )
+        ]
+      )
+    ]
+  end
+
+  let(:subjects) { [_subject] }
+
+  describe '#progress' do
+    subject { object.progress(reportable) }
+
+    context 'with env' do
+      let(:reportable) { env }
+
+      it 'writes report to output' do
+        subject
+        expect(contents).to eql(strip_indent(<<-REPORT))
+          Mutant configuration:
+          Matcher:            #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
+          Integration:        null
+          Expect Coverage:    100.00%
+          Available Subjects: 10
+          Subjects:           1
+        REPORT
+      end
+    end
+
+    context 'with subject' do
+      let(:reportable) { _subject }
+
+      it 'writes report to output' do
+        subject
+        expect(contents).to eql(strip_indent(<<-REPORT))
+          subject_id mutations: 1
+          - test_id
+        REPORT
+      end
+    end
+
+    context 'with subject report' do
+      let(:reportable) { subject_results.first }
+      let(:mutation_result_success) { true }
+
+      it 'writes report to output' do
+        subject
+        expect(contents).to eql("\n(01/01) 100% - killtime: 0.50s runtime: 1.00s overhead: 0.50s\n")
+      end
+    end
+
+    context 'with mutation result' do
+      let(:reportable) { subject_results.first.mutation_results.first }
+
+      context 'when mutation results in success' do
+        let(:mutation_result_success) { true }
+
+        it 'writes report to output' do
+          subject
+          expect(contents).to eql('.')
+        end
+      end
+
+      context 'when mutation results in failure' do
+        let(:mutation_result_success) { false }
+
+        it 'writes report to output' do
+          subject
+          expect(contents).to eql('F')
+        end
+      end
+    end
+  end
+
+  describe '#report' do
+    subject { object.report(result) }
+
+    context 'with subjects' do
+
+      context 'and full covergage' do
+        let(:mutation_result_success) { true }
+
+        it 'writes report to output' do
+          subject
+          expect(contents).to eql(strip_indent(<<-REPORT))
+            Subjects:  1
+            Mutations: 1
+            Kills:     1
+            Alive:     0
+            Runtime:   1.10s
+            Killtime:  0.50s
+            Overhead:  120.00%
+            Coverage:  100.00%
+            Expected:  100.00%
+          REPORT
+        end
+      end
+
+      context 'and partial covergage' do
+        let(:mutation_result_success) { false }
+
+        context 'on evil mutation' do
+          context 'with a diff' do
+            it 'writes report to output' do
+              subject
+              expect(contents).to eql(strip_indent(<<-REPORT))
+                subject_id
+                - test_id
+                mutation_id
+                @@ -1,2 +1,2 @@
+                -true
+                +false
+                -----------------------
+                Subjects:  1
+                Mutations: 1
+                Kills:     0
+                Alive:     1
+                Runtime:   1.10s
+                Killtime:  0.50s
+                Overhead:  120.00%
+                Coverage:  0.00%
+                Expected:  100.00%
+              REPORT
+            end
+          end
+
+          context 'without a diff' do
+            let(:mutation_source) { 'true' }
+
+            it 'writes report to output' do
+              subject
+              expect(contents).to eql(strip_indent(<<-REPORT))
+                subject_id
+                - test_id
+                mutation_id
+                BUG: Mutation NOT resulted in exactly one diff. Please report a reproduction!
+                -----------------------
+                Subjects:  1
+                Mutations: 1
+                Kills:     0
+                Alive:     1
+                Runtime:   1.10s
+                Killtime:  0.50s
+                Overhead:  120.00%
+                Coverage:  0.00%
+                Expected:  100.00%
+              REPORT
+            end
+          end
+        end
+
+        context 'on neutral mutation' do
+          let(:mutation_class)  { Mutant::Mutation::Neutral }
+          let(:mutation_source) { 'true' }
+
+          it 'writes report to output' do
+            subject
+            expect(contents).to eql(strip_indent(<<-REPORT))
+              subject_id
+              - test_id
+              mutation_id
+              --- 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 Reports: 1
+              - test_id / runtime: 1.0
+              Test Output:
+              test-output
+              -----------------------
+              Subjects:  1
+              Mutations: 1
+              Kills:     0
+              Alive:     1
+              Runtime:   1.10s
+              Killtime:  0.50s
+              Overhead:  120.00%
+              Coverage:  0.00%
+              Expected:  100.00%
+            REPORT
+          end
+        end
+
+        context 'on neutral mutation' do
+          let(:mutation_class) { Mutant::Mutation::Noop }
+
+          it 'writes report to output' do
+            subject
+            expect(contents).to eql(strip_indent(<<-REPORT))
+              subject_id
+              - test_id
+              mutation_id
+              ---- 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 Output:
+              test-output
+              -----------------------
+              Subjects:  1
+              Mutations: 1
+              Kills:     0
+              Alive:     1
+              Runtime:   1.10s
+              Killtime:  0.50s
+              Overhead:  120.00%
+              Coverage:  0.00%
+              Expected:  100.00%
+            REPORT
+          end
+        end
+      end
+    end
+
+    context 'without subjects' do
+
+      let(:subjects)        { [] }
+      let(:subject_results) { [] }
+
+      it 'writes report to output' do
+        subject
+        expect(contents).to eql(strip_indent(<<-REPORT))
+          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

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

@@ -8,4 +8,16 @@ describe Mutant::Reporter::Null do
 
     it_should_behave_like 'a command method'
   end
+
+  describe '#warn' do
+    subject { object.warn(double('some input')) }
+
+    it_should_behave_like 'a command method'
+  end
+
+  describe '#progress' do
+    subject { object.progress(double('some input')) }
+
+    it_should_behave_like 'a command method'
+  end
 end

data/spec/unit/mutant/runner_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+# FIXME: This is not even close to a mutation covering spec.
+describe Mutant::Runner do
+  let(:object) { described_class.new(env) }
+
+  let(:reporter) { Mutant::Reporter::Trace.new                        }
+  let(:config)   { Mutant::Config::DEFAULT.update(reporter: reporter, isolation: Mutant::Isolation::None) }
+  let(:subjects) { [subject_a, subject_b]                             }
+
+  class Double
+    include Concord.new(:name, :attributes)
+
+    def self.new(name, attributes = {})
+      super
+    end
+
+    def update(_attributes)
+      self
+    end
+
+    def method_missing(name, *arguments)
+      super unless attributes.key?(name)
+      fail "Arguments provided for #{name}" if arguments.any?
+      attributes.fetch(name)
+    end
+  end
+
+  let(:subject_a) { Double.new('Subject A', mutations: mutations_a, tests: subject_a_tests) }
+  let(:subject_b) { Double.new('Subject B', mutations: mutations_b) }
+
+  let(:subject_a_tests) { [test_a1, test_a2] }
+
+  let(:env) do
+    subjects = self.subjects
+    Class.new(Mutant::Env) do
+      define_method(:subjects) { subjects }
+    end.new(config)
+  end
+
+  let(:mutations_a) { [mutation_a1, mutation_a2] }
+  let(:mutations_b) { [] }
+
+  let(:mutation_a1) { Double.new('Mutation A1') }
+  let(:mutation_a2) { Double.new('Mutation A2') }
+
+  let(:test_a1) { Double.new('Test A1') }
+  let(:test_a2) { Double.new('Test A2') }
+
+  let(:test_report_a1) { Double.new('Test Report A1') }
+
+  before do
+    allow(mutation_a1).to receive(:subject).and_return(subject_a)
+    allow(mutation_a1).to receive(:insert)
+    allow(mutation_a2).to receive(:subject).and_return(subject_a)
+    allow(mutation_a2).to receive(:insert)
+    allow(test_a1).to receive(:run).and_return(test_report_a1)
+    allow(mutation_a1).to receive(:killed_by?).with(test_report_a1).and_return(true)
+    allow(mutation_a2).to receive(:killed_by?).with(test_report_a1).and_return(true)
+  end
+
+  before do
+    time = Time.at(0)
+    allow(Time).to receive(:now).and_return(time)
+  end
+
+  let(:expected_subject_results) do
+    [
+      Mutant::Result::Subject.new(
+        subject:          subject_a,
+        mutation_results: [
+          Mutant::Result::Mutation.new(
+            mutation: mutation_a1,
+            runtime: 0.0,
+            test_results: [test_report_a1]
+          ),
+          Mutant::Result::Mutation.new(
+            mutation: mutation_a2,
+            runtime: 0.0,
+            test_results: [test_report_a1]
+          )
+        ],
+        runtime:          0.0
+      ),
+      Mutant::Result::Subject.new(
+        subject:          subject_b,
+        mutation_results: [],
+        runtime:          0.0
+      )
+    ]
+  end
+
+  describe '#result' do
+    context 'on normal execution' do
+      subject { object.result }
+
+      its(:env)             { should be(env)                       }
+      its(:subject_results) { should eql(expected_subject_results) }
+    end
+
+    context 'when isolation raises error' do
+      subject { object.result }
+
+      its(:env)             { should be(env)                       }
+      its(:subject_results) { should eql(expected_subject_results) }
+
+      before do
+        expect(Mutant::Isolation::None).to receive(:call)
+          .twice
+          .and_raise(Mutant::Isolation::Error.new('test-exception-message'))
+
+        expect(Mutant::Result::Test).to receive(:new).with(
+          test:     test_a1,
+          mutation: mutation_a1,
+          runtime:  0.0,
+          output:   'test-exception-message',
+          passed:   false
+        ).and_return(test_report_a1)
+        expect(Mutant::Result::Test).to receive(:new).with(
+          test:     test_a1,
+          mutation: mutation_a2,
+          runtime:  0.0,
+          output:   'test-exception-message',
+          passed:   false
+        ).and_return(test_report_a1)
+      end
+
+    end
+  end
+end