mutant 0.9.9 → 0.9.14

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

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

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Result::Subject do
-  let(:object) do
-    described_class.new(
-      subject:          mutation_subject,
-      mutation_results: mutation_results,
-      tests:            []
-    )
-  end
-
-  let(:mutation_subject) do
-    instance_double(
-      Mutant::Subject,
-      mutations: mutation_results.map { instance_double(Mutant::Mutation) }
-    )
-  end
-
-  shared_context 'full coverage' do
-    let(:mutation_results) do
-      [
-        instance_double(Mutant::Result::Mutation, success?: true)
-      ]
-    end
-  end
-
-  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
-
-  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
-
-  describe '#coverage' do
-    subject { object.coverage }
-
-    {
-      '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
-
-  describe '#amount_mutations' do
-    subject { object.amount_mutations }
-
-    {
-      '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 }
-
-    {
-      '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
-
-  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

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

@@ -1,14 +0,0 @@
-# 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

data/spec/unit/mutant/result_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Result do
-  let(:object) do
-    Class.new do
-      include Mutant::Result, Concord.new(:runtime, :killtime)
-
-      def collection
-        [[1]]
-      end
-
-      sum :length, :collection
-    end.new(3.0, 1.0)
-  end
-
-  describe '.included' do
-    it 'includes mixin to freeze instances' do
-      expect(object.frozen?).to be(true)
-    end
-
-    it 'it makes DSL methods from Mutant::Result available' do
-      expect(object.length).to be(1)
-    end
-  end
-
-  describe '#overhead' do
-    subject { object.overhead }
-
-    it 'returns difference between runtime and killtime' do
-      should eql(2.0)
-    end
-  end
-end

data/spec/unit/mutant/runner/sink_spec.rb

@@ -1,174 +0,0 @@
-# frozen_string_literal: true
-
-describe Mutant::Runner::Sink do
-  setup_shared_context
-
-  shared_context 'one result' do
-    before do
-      object.result(mutation_a_result)
-    end
-  end
-
-  shared_context 'two results' do
-    before do
-      object.result(mutation_a_result)
-      object.result(mutation_b_result)
-    end
-  end
-
-  let(:object) { described_class.new(env) }
-
-  before do
-    allow(Mutant::Timer).to receive_messages(now: Mutant::Timer.now)
-  end
-
-  describe '#result' do
-    subject { object.result(mutation_a_result) }
-
-    it 'aggregates results in #status' do
-      subject
-      object.result(mutation_b_result)
-      expect(object.status).to eql(
-        Mutant::Result::Env.new(
-          env:             env,
-          runtime:         0.0,
-          subject_results: [subject_a_result]
-        )
-      )
-    end
-
-    it_should_behave_like 'a command method'
-  end
-
-  describe '#status' do
-    subject { object.status }
-
-    context 'no results' do
-      let(:expected_status) do
-        Mutant::Result::Env.new(
-          env:             env,
-          runtime:         0.0,
-          subject_results: []
-        )
-      end
-
-      it { should eql(expected_status) }
-    end
-
-    context 'one result' do
-      include_context 'one result'
-
-      with(:subject_a_result) { { mutation_results: [mutation_a_result] } }
-
-      let(:expected_status) do
-        Mutant::Result::Env.new(
-          env:             env,
-          runtime:         0.0,
-          subject_results: [subject_a_result]
-        )
-      end
-
-      it { should eql(expected_status) }
-    end
-
-    context 'two results' do
-      include_context 'two results'
-
-      let(:expected_status) do
-        Mutant::Result::Env.new(
-          env:             env,
-          runtime:         0.0,
-          subject_results: [subject_a_result]
-        )
-      end
-
-      it { should eql(expected_status) }
-    end
-  end
-
-  describe '#stop?' do
-    subject { object.stop? }
-
-    context 'without fail fast' do
-      context 'no results' do
-        it { should be(false) }
-      end
-
-      context 'one result' do
-        include_context 'one result'
-
-        context 'when result is successful' do
-          it { should be(false) }
-        end
-
-        context 'when result failed' do
-          with(:mutation_a_test_result) { { passed: true } }
-
-          it { should be(false) }
-        end
-      end
-
-      context 'two results' do
-        include_context 'two results'
-
-        context 'when results are successful' do
-          it { should be(false) }
-        end
-
-        context 'when first result is unsuccessful' do
-          with(:mutation_a_test_result) { { passed: true } }
-
-          it { should be(false) }
-        end
-
-        context 'when second result is unsuccessful' do
-          with(:mutation_b_test_result) { { passed: true } }
-
-          it { should be(false) }
-        end
-      end
-    end
-
-    context 'with fail fast' do
-      with(:config) { { fail_fast: true } }
-
-      context 'no results' do
-        it { should be(false) }
-      end
-
-      context 'one result' do
-        include_context 'one result'
-
-        context 'when result is successful' do
-          it { should be(false) }
-        end
-
-        context 'when result failed' do
-          with(:mutation_a_test_result) { { passed: true } }
-
-          it { should be(true) }
-        end
-      end
-
-      context 'two results' do
-        include_context 'two results'
-
-        context 'when results are successful' do
-          it { should be(false) }
-        end
-
-        context 'when first result is unsuccessful' do
-          with(:mutation_a_test_result) { { passed: true } }
-
-          it { should be(true) }
-        end
-
-        context 'when second result is unsuccessful' do
-          with(:mutation_b_test_result) { { passed: true } }
-
-          it { should be(true) }
-        end
-      end
-    end
-  end
-end