mutant 0.9.9 → 0.9.14

data/spec/unit/mutant/context_spec.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Context do
-  describe '.wrap' do
-    subject { described_class.wrap(scope, node) }
-
-    let(:node) { s(:str, 'test') }
-
-    context 'with Module as scope' do
-      let(:scope) { Mutant }
-
-      let(:expected) do
-        s(:module,
-          s(:const, nil, :Mutant),
-          s(:str, 'test'))
-      end
-
-      it { should eql(expected) }
-    end
-
-    context 'with Class as scope' do
-      let(:scope) { Mutant::Context }
-
-      let(:expected) do
-        s(:class,
-          s(:const, nil, :Context),
-          nil,
-          s(:str, 'test'))
-      end
-
-      it { should eql(expected) }
-    end
-  end
-
-  let(:object)      { described_class.new(scope, source_path) }
-  let(:source_path) { instance_double(Pathname)               }
-  let(:scope)       { TestApp::Literal                        }
-
-  describe '#identification' do
-    subject { object.identification }
-
-    it { should eql(scope.name) }
-  end
-
-  describe '#root' do
-    subject { object.root(node) }
-
-    let(:node) { s(:sym, :node) }
-
-    let(:expected_source) do
-      generate(parse(<<-RUBY))
-        module TestApp
-          class Literal
-            :node
-          end
-        end
-      RUBY
-    end
-
-    let(:generated_source) do
-      Unparser.unparse(subject)
-    end
-
-    it 'should create correct source' do
-      expect(generated_source).to eql(expected_source)
-    end
-  end
-
-  describe '#unqualified_name' do
-    subject { object.unqualified_name }
-
-    context 'with top level constant name' do
-      let(:scope) { TestApp }
-
-      it 'should return the unqualified name' do
-        should eql('TestApp')
-      end
-
-      it_should_behave_like 'an idempotent method'
-    end
-
-    context 'with scoped constant name' do
-      it 'should return the unqualified name' do
-        should eql('Literal')
-      end
-
-      it_should_behave_like 'an idempotent method'
-    end
-  end
-
-  describe '#match_expressions' do
-    subject { object.match_expressions }
-
-    context 'on toplevel scope' do
-      let(:scope) { TestApp }
-
-      it { should eql([parse_expression('TestApp*')]) }
-    end
-
-    context 'on nested scope' do
-      specify do
-        should eql(
-          [
-            parse_expression('TestApp::Literal*'),
-            parse_expression('TestApp*')
-          ]
-        )
-      end
-    end
-  end
-end

data/spec/unit/mutant/diff_spec.rb

@@ -1,189 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Diff do
-  let(:object) { described_class }
-
-  describe '.build' do
-
-    subject { object.build(old_string, new_string) }
-
-    let(:old_string) { "foo\nbar" }
-    let(:new_string) { "bar\nbaz" }
-
-    it { should eql(Mutant::Diff.new(%w[foo bar], %w[bar baz])) }
-
-  end
-
-  describe '#colorized_diff' do
-    let(:object) { described_class.new(old, new) }
-
-    subject { object.colorized_diff }
-
-    context 'when there is a diff at begin of hunk' do
-      let(:old) { %w[foo bar] }
-      let(:new) { %w[baz bar] }
-
-      let(:expectation) do
-        [
-          "@@ -1,3 +1,3 @@\n",
-          Mutant::Color::RED.format("-foo\n"),
-          Mutant::Color::GREEN.format("+baz\n"),
-          " bar\n"
-        ].join
-      end
-
-      it { should eql(expectation) }
-
-      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
-    let(:object) { described_class.new(old, new) }
-
-    subject { object.diff }
-
-    context 'when there is a diff at begin and end' do
-      let(:old) { %w[foo bar foo] }
-      let(:new) { %w[baz bar baz] }
-
-      let(:expectation) do
-        <<~STR
-          @@ -1,4 +1,4 @@
-          -foo
-          +baz
-           bar
-          -foo
-          +baz
-        STR
-      end
-
-      it { should eql(expectation) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-
-    context 'when there is a diff at begin of hunk' do
-      let(:old) { %w[foo bar] }
-      let(:new) { %w[baz bar] }
-
-      let(:expectation) do
-        <<~STR
-          @@ -1,3 +1,3 @@
-          -foo
-          +baz
-           bar
-        STR
-      end
-
-      it { should eql(expectation) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-
-    context 'when there is a diff NOT at begin of hunk' do
-      let(:old) { %w[foo bar]     }
-      let(:new) { %w[foo baz bar] }
-
-      let(:expectation) do
-        <<~STR
-          @@ -1,3 +1,4 @@
-           foo
-          +baz
-           bar
-        STR
-      end
-
-      it { should eql(expectation) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-
-    context 'when the diff has a long context at begin' do
-      let(:old) { %w[foo bar baz boz a b c]       }
-      let(:new) { %w[foo bar baz boz a b c other] }
-
-      let(:expectation) do
-        <<~STR
-          @@ -1,8 +1,9 @@
-           foo
-           bar
-           baz
-           boz
-           a
-           b
-           c
-          +other
-        STR
-      end
-
-      it { should eql(expectation) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-
-    context 'when the diff has a long context at end, deleting' do
-      let(:old) { %w[other foo bar baz boz a b c] }
-      let(:new) { %w[foo bar baz boz a b c]       }
-
-      let(:expectation) do
-        <<~STR
-          @@ -1,9 +1,8 @@
-          -other
-           foo
-           bar
-           baz
-           boz
-           a
-           b
-           c
-        STR
-      end
-
-      it { should eql(expectation) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-
-    context 'when the diff has a long context at end, inserting' do
-      let(:old) { %w[foo bar baz boz a b c]       }
-      let(:new) { %w[other foo bar baz boz a b c] }
-
-      let(:expectation) do
-        <<~STR
-          @@ -1,8 +1,9 @@
-          +other
-           foo
-           bar
-           baz
-           boz
-           a
-           b
-           c
-        STR
-      end
-
-      it { should eql(expectation) }
-
-      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
-end

data/spec/unit/mutant/env_spec.rb

@@ -1,229 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Env do
-  subject do
-    described_class.new(
-      config:           config,
-      integration:      integration,
-      matchable_scopes: [],
-      mutations:        [],
-      selector:         selector,
-      subjects:         subjects,
-      parser:           Mutant::Parser.new,
-      world:            world
-    )
-  end
-
-  let(:integration_class) { Mutant::Integration::Null            }
-  let(:isolation)         { Mutant::Isolation::None.new          }
-  let(:kernel)            { instance_double(Object, 'kernel')    }
-  let(:reporter)          { instance_double(Mutant::Reporter)    }
-  let(:selector)          { instance_double(Mutant::Selector)    }
-  let(:subject_a)         { instance_double(Mutant::Subject, :a) }
-  let(:subject_b)         { instance_double(Mutant::Subject, :b) }
-  let(:subjects)          { [subject_a, subject_b]               }
-  let(:test_a)            { instance_double(Mutant::Test, :a)    }
-  let(:test_b)            { instance_double(Mutant::Test, :b)    }
-  let(:test_c)            { instance_double(Mutant::Test, :c)    }
-
-  let(:integration) do
-    instance_double(Mutant::Integration, all_tests: [test_a, test_b, test_c])
-  end
-
-  let(:mutation) do
-    instance_double(
-      Mutant::Mutation,
-      subject: subject_a
-    )
-  end
-
-  let(:config) do
-    instance_double(
-      Mutant::Config,
-      integration: integration_class,
-      isolation:   isolation,
-      reporter:    reporter
-    )
-  end
-
-  let(:world) do
-    instance_double(
-      Mutant::World,
-      kernel: kernel
-    )
-  end
-
-  before do
-    allow(selector).to receive(:call)
-      .with(subject_a)
-      .and_return([test_a, test_b])
-
-    allow(selector).to receive(:call)
-      .with(subject_b)
-      .and_return([test_b, test_c])
-
-    allow(Mutant::Timer).to receive(:now).and_return(2.0, 3.0)
-  end
-
-  describe '#kill' do
-    def apply
-      subject.kill(mutation)
-    end
-
-    before do
-      allow(isolation).to receive(:call) do |&block|
-        Mutant::Isolation::Result::Success.new(block.call)
-      end
-
-      allow(mutation).to receive_messages(insert: loader_result)
-    end
-
-    shared_examples 'mutation kill' do
-      it 'returns expected result' do
-        expect(apply).to eql(
-          Mutant::Result::Mutation.new(
-            isolation_result: isolation_result,
-            mutation:         mutation,
-            runtime:          1.0
-          )
-        )
-      end
-    end
-
-    context 'when loader is successful' do
-      let(:loader_result) { Mutant::Loader::Result::Success.instance }
-      let(:test_result)   { instance_double(Mutant::Result::Test)    }
-
-      let(:isolation_result) do
-        Mutant::Isolation::Result::Success.new(test_result)
-      end
-
-      before do
-        allow(integration).to receive_messages(call: test_result)
-      end
-
-      it 'performs IO in expected sequence' do
-        apply
-
-        expect(isolation).to have_received(:call).ordered
-        expect(mutation).to have_received(:insert).ordered.with(kernel)
-        expect(integration).to have_received(:call).ordered.with([test_a, test_b])
-      end
-
-      include_examples 'mutation kill'
-    end
-
-    context 'when loader reports void value' do
-      let(:loader_result) { Mutant::Loader::Result::VoidValue.instance }
-
-      let(:isolation_result) do
-        Mutant::Isolation::Result::Success.new(Mutant::Result::Test::VoidValue.instance)
-      end
-
-      it 'performs IO in expected sequence' do
-        apply
-
-        expect(isolation).to have_received(:call).ordered
-        expect(mutation).to have_received(:insert).ordered.with(kernel)
-      end
-
-      include_examples 'mutation kill'
-    end
-  end
-
-  describe '#selections' do
-    def apply
-      subject.selections
-    end
-
-    it 'returns expected selections' do
-      expect(apply).to eql(
-        subject_a => [test_a, test_b],
-        subject_b => [test_b, test_c]
-      )
-    end
-  end
-
-  describe '#warn' do
-    def apply
-      subject.warn(message)
-    end
-
-    before do
-      allow(reporter).to receive_messages(warn: reporter)
-    end
-
-    let(:message) { 'test-warning' }
-
-    it 'warns via the reporter' do
-      apply
-
-      expect(reporter).to have_received(:warn).with(message)
-    end
-
-    it 'returns self' do
-      expect(apply).to be(subject)
-    end
-  end
-
-  describe '#amount_mutations' do
-    def apply
-      subject.amount_mutations
-    end
-
-    it 'returns expected value' do
-      expect(apply).to be(0)
-    end
-  end
-
-  describe '#amount_total_tests' do
-    def apply
-      subject.amount_total_tests
-    end
-
-    it 'returns expected value' do
-      expect(apply).to be(3)
-    end
-  end
-
-  describe '#test_subject_ratio' do
-    def apply
-      subject.test_subject_ratio
-    end
-
-    context 'on empty subjects' do
-      let(:subjects) { [] }
-
-      it 'returns expected value' do
-        expect(apply).to eql(Rational(0))
-      end
-    end
-
-    context 'on non empty subjects' do
-      it 'returns expected value' do
-        expect(apply).to eql(Rational(3, 2))
-      end
-    end
-  end
-
-  describe '.empty' do
-    def apply
-      described_class.empty(world, config)
-    end
-
-    it 'returns empty env' do
-      expect(apply).to eql(
-        described_class.new(
-          config:           config,
-          integration:      Mutant::Integration::Null.new(config),
-          matchable_scopes: Mutant::EMPTY_ARRAY,
-          mutations:        Mutant::EMPTY_ARRAY,
-          parser:           Mutant::Parser.new,
-          selector:         Mutant::Selector::Null.new,
-          subjects:         Mutant::EMPTY_ARRAY,
-          world:            world
-        )
-      )
-    end
-  end
-end