mutant 0.8.9 → 0.8.10

data/spec/unit/mutant/diff_spec.rb

@@ -34,6 +34,15 @@ RSpec.describe Mutant::Diff do
 
       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
 
   describe '#diff' do

data/spec/unit/mutant/mutation_spec.rb

@@ -1,10 +1,16 @@
 RSpec.describe Mutant::Mutation do
-  class TestMutation < Mutant::Mutation
-    SYMBOL = 'test'.freeze
+  let(:mutation_class) do
+    Class.new(Mutant::Mutation) do
+      const_set(:SYMBOL, 'test'.freeze)
+      const_set(:TEST_PASS_SUCCESS, true)
+    end
   end
 
-  let(:object)  { TestMutation.new(mutation_subject, Mutant::AST::Nodes::N_NIL) }
-  let(:context) { instance_double(Mutant::Context)                              }
+  let(:context) { instance_double(Mutant::Context) }
+
+  let(:object) do
+    mutation_class.new(mutation_subject, Mutant::AST::Nodes::N_NIL)
+  end
 
   let(:mutation_subject) do
     instance_double(
@@ -71,6 +77,51 @@ RSpec.describe Mutant::Mutation do
     it_should_behave_like 'an idempotent method'
   end
 
+  describe '.success?' do
+    subject { mutation_class.success?(test_result) }
+
+    let(:test_result) do
+      instance_double(
+        Mutant::Result::Test,
+        passed: passed
+      )
+    end
+
+    context 'on mutation with positive pass expectation' do
+      context 'when Result::Test#passed equals expectation' do
+        let(:passed) { true }
+
+        it { should be(true) }
+      end
+
+      context 'when Result::Test#passed NOT equals expectation' do
+        let(:passed) { false }
+
+        it { should be(false) }
+      end
+    end
+
+    context 'on mutation with negative pass expectation' do
+      let(:mutation_class) do
+        Class.new(super()) do
+          const_set(:TEST_PASS_SUCCESS, false)
+        end
+      end
+
+      context 'when Result::Test#passed equals expectation' do
+        let(:passed) { true }
+
+        it { should be(false) }
+      end
+
+      context 'when Result::Test#passed NOT equals expectation' do
+        let(:passed) { false }
+
+        it { should be(true) }
+      end
+    end
+  end
+
   describe '#identification' do
 
     subject { object.identification }

data/spec/unit/mutant/reporter/cli/printer/mutation_result_spec.rb

@@ -50,11 +50,11 @@ RSpec.describe Mutant::Reporter::CLI::Printer::MutationResult do
             Original unparsed source:
             super
             Original AST:
-            (lvar :super)
+            s(:lvar, :super)
             Mutated unparsed source:
             super
             Mutated AST:
-            (zsuper)
+            s(:zsuper)
             -----------------------
           REPORT
         end
@@ -73,7 +73,7 @@ RSpec.describe Mutant::Reporter::CLI::Printer::MutationResult do
           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)
+          s(:true)
           Unparsed Source:
           true
           Test Result:

data/spec/unit/mutant/reporter/cli/printer_spec.rb

@@ -16,7 +16,7 @@ RSpec.describe Mutant::Reporter::CLI::Printer do
   let(:tty?)       { true                                                     }
   let(:success?)   { true                                                     }
 
-  context '.call' do
+  describe '.call' do
     let(:class_under_test) do
       Class.new(described_class) do
         def run
@@ -30,7 +30,28 @@ RSpec.describe Mutant::Reporter::CLI::Printer do
     it_reports "foo\n"
   end
 
-  context '#status' do
+  describe '.delegate' do
+    let(:reportable) { double(foo: :bar, baz: :boz) }
+
+    let(:class_under_test) do
+      Class.new(described_class) do
+        delegate :foo, :baz
+
+        def run
+          puts(foo)
+          puts(baz)
+        end
+      end
+    end
+
+    it_reports "bar\nboz\n"
+
+    it 'sets delegation methods to private visibility' do
+      expect(class_under_test.private_instance_methods).to include(:foo, :baz)
+    end
+  end
+
+  describe '#status' do
     let(:class_under_test) do
       Class.new(described_class) do
         def run
@@ -65,7 +86,7 @@ RSpec.describe Mutant::Reporter::CLI::Printer do
     end
   end
 
-  context '#visit_collection' do
+  describe '#visit_collection' do
     let(:class_under_test) do
       reporter = nested_reporter
       Class.new(described_class) do
@@ -86,7 +107,7 @@ RSpec.describe Mutant::Reporter::CLI::Printer do
     it_reports "foo\nbar\n"
   end
 
-  context '#visit' do
+  describe '#visit' do
     let(:class_under_test) do
       reporter = nested_reporter
       Class.new(described_class) do
@@ -107,7 +128,7 @@ RSpec.describe Mutant::Reporter::CLI::Printer do
     it_reports "foo\n"
   end
 
-  context '#info' do
+  describe '#info' do
     let(:class_under_test) do
       Class.new(described_class) do
         def run
@@ -119,7 +140,7 @@ RSpec.describe Mutant::Reporter::CLI::Printer do
     it_reports "foo - bar\n"
   end
 
-  context '#colorize' do
+  describe '#colorize' do
     let(:class_under_test) do
       Class.new(described_class) do
         def run

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

@@ -2,21 +2,11 @@ RSpec.describe Mutant::Reporter::Null do
   let(:object) { described_class.new     }
   let(:value)  { instance_double(Object) }
 
-  describe '#report' do
-    subject { object.report(value) }
+  %i[progress report start warn].each do |name|
+    describe "##{name}" do
+      subject { object.public_send(name, value) }
 
-    it_should_behave_like 'a command method'
-  end
-
-  describe '#warn' do
-    subject { object.warn(value) }
-
-    it_should_behave_like 'a command method'
-  end
-
-  describe '#progress' do
-    subject { object.progress(value) }
-
-    it_should_behave_like 'a command method'
+      it_should_behave_like 'a command method'
+    end
   end
 end

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

@@ -0,0 +1,29 @@
+RSpec.describe Mutant::Reporter::Sequence do
+  let(:object)     { described_class.new([reporter_a, reporter_b]) }
+  let(:value)      { instance_double(Object)                       }
+  let(:reporter_a) { instance_double(Mutant::Reporter, delay: 1.0) }
+  let(:reporter_b) { instance_double(Mutant::Reporter, delay: 2.0) }
+
+  %i[report progress warn start].each do |name|
+    describe "##{name}" do
+      subject { object.public_send(name, value) }
+
+      before do
+        [reporter_a, reporter_b].each do |receiver|
+          expect(receiver).to receive(name)
+            .ordered
+            .with(value)
+            .and_return(receiver)
+        end
+      end
+
+      it_should_behave_like 'a command method'
+    end
+  end
+
+  describe '#delay' do
+    it 'returns the lowest value' do
+      expect(object.delay).to eql(1.0)
+    end
+  end
+end

data/spec/unit/mutant/result/class_methods_spec.rb

@@ -0,0 +1,49 @@
+# The effect of this private module is done at boot time.
+# Hence there is no way to kill the mutations at runtime
+# so we have to directly hook into the private moduel via
+# reflection to redo a runtime observable interaction with
+# it.
+#
+# Until mutant gets boot time mutation support there is no
+# way to to avoid this.
+RSpec.describe 'Mutant::Result::ClassMethods' do
+  let(:infected_class) do
+    Class.new do
+      include Adamantium::Flat, Concord::Public.new(:collection)
+      extend Mutant::Result.const_get(:ClassMethods)
+
+      sum :length, :collection
+    end
+  end
+
+  describe '#sum' do
+    let(:object) { infected_class.new(collection) }
+
+    def apply
+      object.length
+    end
+
+    subject { apply }
+
+    before do
+      # memoization behavior
+      expect(collection).to receive(:map)
+        .once
+        .and_call_original
+
+      apply
+    end
+
+    context 'empty collection' do
+      let(:collection) { [] }
+
+      it { should be(0) }
+    end
+
+    context 'non-emtpy collection' do
+      let(:collection) { [[1], [2, 3]] }
+
+      it { should be(3) }
+    end
+  end
+end

data/spec/unit/mutant/result/mutation_spec.rb

@@ -0,0 +1,49 @@
+RSpec.describe Mutant::Result::Mutation do
+  let(:object) do
+    described_class.new(
+      mutation:    mutation,
+      test_result: test_result
+    )
+  end
+
+  let(:mutation) do
+    instance_double(
+      Mutant::Mutation,
+      frozen?: true,
+      class:   class_double(Mutant::Mutation)
+    )
+  end
+
+  let(:test_result) do
+    instance_double(
+      Mutant::Result::Test,
+      runtime: 1.0
+    )
+  end
+
+  let(:mutation_subject) do
+    instance_double(
+      Mutant::Subject
+    )
+  end
+
+  describe '#runtime' do
+    subject { object.runtime }
+
+    it { should eql(1.0) }
+  end
+
+  describe '#success?' do
+    subject { object.success? }
+
+    let(:result) { double('result boolean') }
+
+    before do
+      expect(mutation.class).to receive(:success?)
+        .with(test_result)
+        .and_return(result)
+    end
+
+    it { should be(result) }
+  end
+end

data/spec/unit/mutant/result/subject_spec.rb

@@ -7,38 +7,103 @@ RSpec.describe Mutant::Result::Subject do
     )
   end
 
-  let(:mutation_subject) { instance_double(Mutant::Subject) }
+  let(:mutation_subject) do
+    instance_double(
+      Mutant::Subject,
+      mutations: mutation_results.map { instance_double(Mutant::Mutation) }
+    )
+  end
 
-  describe '#continue?' do
-    subject { object.continue? }
+  shared_context 'full coverage' do
+    let(:mutation_results) do
+      [
+        instance_double(Mutant::Result::Mutation, success?: true)
+      ]
+    end
+  end
 
-    context 'when mutation results are empty' do
-      let(:mutation_results) { [] }
+  shared_context 'partial coverage' do
+    let(:mutation_results) do
+      [
+        instance_double(Mutant::Result::Mutation, success?: false),
+        instance_double(Mutant::Result::Mutation, success?: true)
+      ]
+    end
+  end
 
-      it { should be(true) }
+  shared_context 'no coverage' do
+    let(:mutation_results) do
+      [
+        instance_double(Mutant::Result::Mutation, success?: false)
+      ]
     end
+  end
+
+  shared_context 'no results' do
+    let(:mutation_results) { [] }
+  end
 
-    context 'with failing mutation result' do
-      let(:mutation_results) { [instance_double(Mutant::Result::Mutation, success?: false)] }
+  describe '#coverage' do
+    subject { object.coverage }
 
-      it { should be(false) }
+    {
+      'full coverage'    => 1r,
+      'partial coverage' => 0.5r,
+      'no coverage'      => 0r,
+      'no results'       => 1r
+    }.each do |name, expected|
+      context(name) do
+        include_context(name)
+        it { should eql(expected) }
+      end
     end
+  end
 
-    context 'with successful mutation result' do
-      let(:mutation_results) { [instance_double(Mutant::Result::Mutation, success?: true)] }
+  describe '#amount_mutations' do
+    subject { object.amount_mutations }
 
-      it { should be(true) }
+    {
+      'full coverage'    => 1,
+      'partial coverage' => 2,
+      'no coverage'      => 1,
+      'no results'       => 0
+    }.each do |name, expected|
+      context(name) do
+        include_context(name)
+        it { should be(expected) }
+      end
     end
+  end
+
+  describe '#amount_mutations_alive' do
+    subject { object.amount_mutations_alive }
 
-    context 'with failed and successful mutation result' do
-      let(:mutation_results) do
-        [
-          instance_double(Mutant::Result::Mutation, success?: true),
-          instance_double(Mutant::Result::Mutation, success?: false)
-        ]
+    {
+      'full coverage'    => 0,
+      'partial coverage' => 1,
+      'no coverage'      => 1,
+      'no results'       => 0
+    }.each do |name, expected|
+      context(name) do
+        include_context(name)
+        it { should be(expected) }
       end
+    end
+  end
 
-      it { should be(false) }
+  describe '#success?' do
+    subject { object.success? }
+
+    {
+      'full coverage'    => true,
+      'partial coverage' => false,
+      'no coverage'      => false,
+      'no results'       => true
+    }.each do |name, expected|
+      context(name) do
+        include_context(name)
+        it { should be(expected) }
+      end
     end
   end
 end