mutant 0.9.7 → 0.9.12

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

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-describe Mutant::Repository::Diff do
-  describe '#touches?' do
-    def apply
-      subject.touches?(path, line_range)
-    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) { 4..5                             }
-
-    let(:world) do
-      instance_double(
-        Mutant::World,
-        kernel:   kernel,
-        pathname: pathname
-      )
-    end
-
-    let(:allowed_paths) do
-      %w[bar.rb baz.rb].map do |path|
-        [path, Pathname.new(path)]
-      end.to_h
-    end
-
-    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
-
-    before do
-      allow(pathname).to receive(:new, &allowed_paths.method(:fetch))
-    end
-
-    context 'when file is not touched in the diff' do
-      let(:index_stdout) { '' }
-
-      it 'returns false' do
-        verify_events { expect(apply).to be(false) }
-      end
-    end
-
-    context 'when a diff-index line is invalid' do
-      let(:index_stdout) { 'invalid-line' }
-
-      it 'raises error' do
-        expect { verify_events { apply } }
-          .to raise_error(
-            described_class::Error,
-            'Invalid git diff-index line: invalid-line'
-          )
-      end
-    end
-
-    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(: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 'and diff touches the line range' do
-        let(:diff_stdout) do
-          <<~'DIFF'
-            --- bar.rb
-            +++ bar.rb
-            @@ -4 +4 @@ header
-            -a
-            +b
-          DIFF
-        end
-
-        it 'returns true' do
-          verify_events { expect(apply).to be(true) }
-        end
-      end
-
-      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
-
-        it 'returns false' do
-          verify_events { expect(apply).to be(false) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Repository::SubjectFilter do
-  context '#call' do
-    subject { object.call(mutant_subject) }
-
-    let(:object) { described_class.new(diff)                 }
-    let(:diff)   { instance_double(Mutant::Repository::Diff) }
-    let(:value)  { instance_double(Object, 'value')          }
-
-    let(:mutant_subject) do
-      double(
-        'Subject',
-        source_path:  double('source path'),
-        source_lines: double('source lines')
-      )
-    end
-
-    before do
-      expect(diff).to receive(:touches?).with(
-        mutant_subject.source_path,
-        mutant_subject.source_lines
-      ).and_return(value)
-    end
-
-    it 'connects return value to repository diff API' do
-      expect(subject).to be(value)
-    end
-  end
-end

data/spec/unit/mutant/require_highjack_spec.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::RequireHighjack do
-  let(:highjacked_calls) { [] }
-  let(:require_calls)    { [] }
-
-  let(:target_module) do
-    acc = require_calls
-    Module.new do
-      define_method(:require, &acc.method(:<<))
-      define_singleton_method(:require, &acc.method(:<<))
-    end
-  end
-
-  def singleton_require(logical_name)
-    target_module.require(logical_name)
-  end
-
-  def instance_require(logical_name)
-    Object.new.extend(target_module).require(logical_name)
-  end
-
-  describe '.call' do
-    let(:logical_name) { instance_double(String) }
-
-    def apply
-      described_class.call(target_module, highjacked_calls.method(:<<))
-    end
-
-    it 'prevents warnings' do
-      expect(Mutant::WORLD.warnings.call(&method(:apply))).to eql([])
-    end
-
-    it 'returns the original implementation from singleton' do
-      expect { apply.call(logical_name) }
-        .to change { require_calls }
-        .from([])
-        .to([logical_name])
-    end
-
-    context '#require' do
-      it 'does highjack calls' do
-        apply
-        expect { instance_require(logical_name) }
-          .to change { highjacked_calls }
-          .from([])
-          .to([logical_name])
-      end
-
-      it 'does not call original require' do
-        apply
-        expect { instance_require(logical_name) }
-          .not_to change { require_calls }.from([])
-      end
-    end
-
-    context '.require' do
-      it 'does highjack calls' do
-        apply
-        expect { singleton_require(logical_name) }
-          .to change { highjacked_calls }
-          .from([])
-          .to([logical_name])
-      end
-
-      it 'does not call original require' do
-        apply
-        expect { singleton_require(logical_name) }
-          .not_to change { require_calls }.from([])
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-# 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/env_spec.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Result::Env do
-  let(:object) do
-    described_class.new(
-      runtime:         instance_double(Float),
-      env:             env,
-      subject_results: subject_results
-    )
-  end
-
-  let(:subject_results) { [subject_result] }
-
-  let(:env) do
-    instance_double(
-      Mutant::Env,
-      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
-
-  let(:subject_result) do
-    instance_double(
-      Mutant::Result::Subject,
-      amount_mutation_results: results,
-      amount_mutations_killed: killed,
-      success?:                subject_success?
-    )
-  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     }
-  let(:subject_success?) { true }
-
-  describe '#success?' do
-    subject { object.success? }
-
-    context 'when coverage matches expectation' do
-      let(:killed) { 1 }
-
-      it { should be(true) }
-    end
-
-    context 'when coverage does not match expectation' do
-      it { should be(false) }
-    end
-  end
-
-  describe '#failed_subject_results' do
-    subject { object.failed_subject_results }
-
-    it { should eql([]) }
-  end
-
-  describe '#coverage' do
-    subject { object.coverage }
-
-    context 'when there are no results' do
-      let(:results) { 0 }
-
-      it { should eql(Rational(1)) }
-    end
-
-    context 'when there are no kills' do
-      it { should eql(Rational(0)) }
-    end
-
-    context 'when there are kills' do
-      let(:killed)  { 1 }
-      let(:results) { 2 }
-
-      it { should eql(Rational(1, 2)) }
-    end
-  end
-
-  describe '#amount_mutations' do
-    subject { object.amount_mutations }
-
-    it { should eql(1) }
-  end
-
-  describe '#stop?' do
-    subject { object.stop? }
-
-    context 'without fail fast' do
-      context 'on empty subjects' do
-        let(:subject_results) { [] }
-
-        it { should be(false) }
-      end
-
-      context 'on failed subject' do
-        let(:subject_success?) { false }
-
-        it { should be(false) }
-      end
-
-      context 'on successful subject' do
-        it { should be(false) }
-      end
-    end
-
-    context 'with fail fast' do
-      let(:fail_fast) { true }
-
-      context 'on empty subjects' do
-        let(:subject_results) { [] }
-
-        it { should be(false) }
-      end
-
-      context 'on failed subject' do
-        let(:subject_success?) { false }
-
-        it { should be(true) }
-      end
-
-      context 'on successful subject' do
-        it { should be(false) }
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Result::Mutation do
-  let(:object) do
-    described_class.new(
-      isolation_result: isolation_result,
-      mutation:         mutation,
-      runtime:          2.0
-    )
-  end
-
-  let(:mutation) { instance_double(Mutant::Mutation) }
-
-  let(:test_result) do
-    instance_double(
-      Mutant::Result::Test,
-      runtime: 1.0
-    )
-  end
-
-  let(:isolation_result) do
-    Mutant::Isolation::Result::Success.new(test_result)
-  end
-
-  shared_examples_for 'unsuccessful isolation' do
-    let(:isolation_result) do
-      Mutant::Isolation::Result::Exception.new(RuntimeError.new('foo'))
-    end
-  end
-
-  describe '#killtime' do
-    subject { object.killtime }
-
-    context 'if isolation is successful' do
-      it { should eql(1.0) }
-    end
-
-    context 'if isolation is not successful' do
-      include_context 'unsuccessful isolation'
-
-      it { should eql(0.0) }
-    end
-  end
-
-  describe '#runtime' do
-    subject { object.runtime }
-
-    it { should eql(2.0) }
-  end
-
-  describe '#success?' do
-    subject { object.success? }
-
-    context 'if isolation is successful' do
-      before do
-        expect(mutation.class).to receive(:success?)
-          .with(test_result)
-          .and_return(true)
-      end
-
-      it { should be(true) }
-    end
-
-    context 'if isolation is not successful' do
-      include_context 'unsuccessful isolation'
-
-      it { should be(false) }
-    end
-  end
-end