mutant 0.8.24 → 0.9.0

data/spec/unit/mutant/repository/diff/ranges_spec.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+describe Mutant::Repository::Diff::Ranges do
+  describe '.parse' do
+    def apply
+      described_class.parse(diff)
+    end
+
+    let(:diff) do
+      Tempfile.open('old') do |old_file|
+        old_file.write(old)
+        old_file.flush
+        Tempfile.open('new') do |new_file|
+          new_file.write(new)
+          new_file.flush
+          # rubocop:disable Lint/UnneededSplatExpansion
+          stdout, status = Open3.capture2(
+            *%W[
+              git
+              diff
+              --no-index
+              --unified=0
+              --
+              #{old_file.path}
+              #{new_file.path}
+            ]
+          )
+          # rubocop:enable Lint/UnneededSplatExpansion
+
+          fail unless [0, 256].include?(status.to_i)
+
+          stdout
+        end
+      end
+    end
+
+    context 'on empty diff' do
+      let(:old) { '' }
+      let(:new) { '' }
+
+      it 'returns emtpy set' do
+        expect(apply).to eql(Set.new)
+      end
+    end
+
+    context 'on empty old' do
+      let(:old) { '' }
+
+      context 'adding a single line' do
+        let(:new) do
+          <<~'STR'
+            a
+          STR
+        end
+
+        it 'returns expected set' do
+          expect(apply).to eql([1..1].to_set)
+        end
+      end
+
+      context 'adding a multiple lines' do
+        let(:old) { '' }
+
+        let(:new) do
+          <<~'STR'
+            a
+            b
+          STR
+        end
+
+        it 'returns expected set' do
+          expect(apply).to eql([1..2].to_set)
+        end
+      end
+    end
+
+    context 'on empty new' do
+      let(:new) { '' }
+
+      context 'removing a single line' do
+        let(:old) do
+          <<~'STR'
+            a
+          STR
+        end
+
+        it 'returns expected set' do
+          expect(apply).to eql([1..1].to_set)
+        end
+      end
+
+      context 'removing a multiple lines' do
+        let(:old) do
+          <<~'STR'
+            a
+            b
+          STR
+        end
+
+        it 'returns expected set' do
+          expect(apply).to eql([1..2].to_set)
+        end
+      end
+    end
+
+    context 'single line modification' do
+      let(:old) do
+        <<~'STR'
+          a
+          b
+          c
+          a
+        STR
+      end
+
+      let(:new) do
+        <<~'STR'
+          a
+          b
+          b
+          a
+        STR
+      end
+
+      it 'returns expected set' do
+        expect(apply).to eql([3..3].to_set)
+      end
+    end
+
+    context 'nonempty old and new' do
+      context 'single line addition' do
+        let(:old) do
+          <<~'STR'
+            a
+            b
+            a
+          STR
+        end
+
+        let(:new) do
+          <<~'STR'
+            a
+            b
+            b
+            a
+          STR
+        end
+
+        it 'returns expected set' do
+          expect(apply).to eql([3..3].to_set)
+        end
+      end
+      context 'multi line modification' do
+        let(:old) do
+          <<~'STR'
+            a
+            b
+            c
+            d
+            a
+          STR
+        end
+
+        let(:new) do
+          <<~'STR'
+            a
+            b
+            b
+            b
+            a
+          STR
+        end
+
+        it 'returns expected set' do
+          expect(apply).to eql([3..4].to_set)
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutant/repository/diff_spec.rb

@@ -2,106 +2,119 @@
 
 describe Mutant::Repository::Diff do
   describe '#touches?' do
-    let(:object) do
-      described_class.new(
-        config: config,
-        from:   'from_rev',
-        to:     'to_rev'
-      )
+    def apply
+      subject.touches?(path, line_range)
     end
 
-    let(:config) do
-      instance_double(
-        Mutant::Config,
-        kernel:   kernel,
-        open3:    open3,
-        pathname: pathname
-      )
-    end
+    subject { described_class.new(world: world, to: 'to_rev') }
 
     let(:pathname)   { class_double(Pathname, pwd: pwd) }
     let(:open3)      { class_double(Open3)              }
     let(:kernel)     { class_double(Kernel)             }
     let(:pwd)        { Pathname.new('/foo')             }
     let(:path)       { Pathname.new('/foo/bar.rb')      }
-    let(:line_range) { 1..2                             }
-
-    subject { object.touches?(path, line_range) }
-
-    shared_context 'test if git tracks the file' do
-      before do
-        # rubocop:disable Lint/UnneededSplatExpansion
-        expect(config.kernel).to receive(:system)
-          .ordered
-          .with(
-            *%W[git ls-files --error-unmatch -- #{path}],
-            out: File::NULL,
-            err: File::NULL
-          ).and_return(git_ls_success?)
-      end
-    end
+    let(:line_range) { 4..5                             }
 
-    context 'when file is in a different subdirectory' do
-      let(:path) { Pathname.new('/baz/bar.rb') }
+    let(:world) do
+      instance_double(
+        Mutant::World,
+        kernel:   kernel,
+        pathname: pathname
+      )
+    end
 
-      before do
-        expect(config.kernel).to_not receive(:system)
-      end
+    let(:allowed_paths) do
+      %w[bar.rb baz.rb].map do |path|
+        [path, Pathname.new(path)]
+      end.to_h
+    end
 
-      it { should be(false) }
+    let(:file_diff_expectations) { [] }
+
+    let(:raw_expectations) do
+      [
+        {
+          receiver:  world,
+          selector:  :capture_stdout,
+          arguments: [%w[git diff-index to_rev]],
+          reaction:  { return: Mutant::Either::Right.new(index_stdout) }
+        },
+        *file_diff_expectations
+      ]
     end
 
-    context 'when file is NOT tracked in repository' do
-      let(:git_ls_success?) { false }
+    before do
+      allow(pathname).to receive(:new, &allowed_paths.method(:fetch))
+    end
 
-      include_context 'test if git tracks the file'
+    context 'when file is not touched in the diff' do
+      let(:index_stdout) { '' }
 
-      it { should be(false) }
+      it 'returns false' do
+        verify_events { expect(apply).to be(false) }
+      end
     end
 
-    context 'when file is tracked in repository' do
-      let(:git_ls_success?) { true                                                 }
-      let(:status)          { instance_double(Process::Status, success?: success?) }
-      let(:stdout)          { instance_double(String, empty?: stdout_empty?)       }
-      let(:stdout_empty?)   { false                                                }
+    context 'when a diff-index line is invalid' do
+      let(:index_stdout) { 'invalid-line' }
 
-      include_context 'test if git tracks the file'
+      it 'raises error' do
+        expect { verify_events { apply } }
+          .to raise_error(
+            described_class::Error,
+            'Invalid git diff-index line: invalid-line'
+          )
+      end
+    end
 
-      before do
-        expect(config.open3).to receive(:capture2)
-          .ordered
-          .with(*expected_git_log_command, binmode: true)
-          .and_return([stdout, status])
+    context 'when file is touched in the diff' do
+      let(:index_stdout) do
+        <<~STR
+          :000000 000000 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 M\tbar.rb
+          :000000 000000 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 M\tbaz.rb
+        STR
       end
 
-      let(:expected_git_log_command) do
-        %W[git log from_rev...to_rev --ignore-all-space -L 1,2:#{path}]
+      let(:file_diff_expectations) do
+        [
+          {
+            receiver:  world,
+            selector:  :capture_stdout,
+            arguments: [%w[git diff --unified=0 to_rev -- /foo/bar.rb]],
+            reaction:  { return: Mutant::Either::Right.new(diff_stdout) }
+          }
+        ]
       end
 
-      context 'on failure of git log command' do
-        let(:success?) { false }
+      context 'and diff touches the line range' do
+        let(:diff_stdout) do
+          <<~'DIFF'
+            --- bar.rb
+            +++ bar.rb
+            @@ -4 +4 @@ header
+            -a
+            +b
+          DIFF
+        end
 
-        it 'raises error' do
-          expect { subject }.to raise_error(
-            Mutant::Repository::RepositoryError,
-            "Command #{expected_git_log_command} failed!"
-          )
+        it 'returns true' do
+          verify_events { expect(apply).to be(true) }
         end
       end
 
-      context 'on suuccess of git command' do
-        let(:success?) { true }
-
-        context 'on empty stdout' do
-          let(:stdout_empty?) { true }
-
-          it { should be(false) }
+      context 'and diff does not touch the line range' do
+        let(:diff_stdout) do
+          <<~'DIFF'
+            --- bar.rb
+            +++ bar.rb
+            @@ -3 +3 @@ header
+            -a
+            +b
+          DIFF
         end
 
-        context 'on non empty stdout' do
-          let(:stdout_empty?) { false }
-
-          it { should be(true) }
+        it 'returns false' do
+          verify_events { expect(apply).to be(false) }
         end
       end
     end

data/spec/unit/mutant/require_highjack_spec.rb

@@ -28,7 +28,7 @@ RSpec.describe Mutant::RequireHighjack do
     end
 
     it 'prevents warnings' do
-      expect(Mutant::WarningFilter.use(&method(:apply))).to eql([])
+      expect(Mutant::WORLD.warnings.call(&method(:apply))).to eql([])
     end
 
     it 'returns the original implementation from singleton' do

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

@@ -14,9 +14,18 @@ RSpec.describe Mutant::Result::Env do
   let(:env) do
     instance_double(
       Mutant::Env,
-      config:    instance_double(Mutant::Config, fail_fast: fail_fast),
-      subjects:  [instance_double(Mutant::Subject)],
-      mutations: [instance_double(Mutant::Mutation)]
+      config:      instance_double(Mutant::Config, fail_fast: fail_fast),
+      integration: integration,
+      mutations:   [instance_double(Mutant::Mutation)],
+      selections:  selections,
+      subjects:    [subject_a, subject_b]
+    )
+  end
+
+  let(:integration) do
+    instance_double(
+      Mutant::Integration,
+      all_tests: [test_a, test_b]
     )
   end
 
@@ -29,6 +38,33 @@ RSpec.describe Mutant::Result::Env do
     )
   end
 
+  let(:selections) do
+    {
+      subject_a: [test_a],
+      subject_b: [test_a, test_b, test_c]
+    }
+  end
+
+  let(:subject_a) do
+    instance_double(Mutant::Subject, :a)
+  end
+
+  let(:subject_b) do
+    instance_double(Mutant::Subject, :b)
+  end
+
+  let(:test_a) do
+    instance_double(Mutant::Test, :a)
+  end
+
+  let(:test_b) do
+    instance_double(Mutant::Test, :b)
+  end
+
+  let(:test_c) do
+    instance_double(Mutant::Test, :c)
+  end
+
   let(:fail_fast)        { false }
   let(:killed)           { 0     }
   let(:results)          { 1     }
@@ -81,12 +117,6 @@ RSpec.describe Mutant::Result::Env do
     it { should eql(1) }
   end
 
-  describe '#amount_subjects' do
-    subject { object.amount_subjects }
-
-    it { should eql(1) }
-  end
-
   describe '#stop?' do
     subject { object.stop? }
 

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Result::Test::VoidValue do
+  describe '.new' do
+    it 'returns expected attributes' do
+      expect(described_class.instance.to_h).to eql(
+        output:  '',
+        passed:  false,
+        runtime: 0.0,
+        tests:   []
+      )
+    end
+  end
+end