mutant 0.8.24 → 0.9.0

data/spec/unit/mutant/either_spec.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Either do
+  describe '.wrap_error' do
+    def apply
+      described_class.wrap_error(error, &block)
+    end
+
+    let(:error) { TestError }
+
+    class TestError < RuntimeError; end
+
+    context 'when block returns' do
+      let(:value) { instance_double(Object, 'value') }
+      let(:block) { -> { value }                     }
+
+      it 'returns right wrapping block value' do
+        expect(apply).to eql(described_class::Right.new(value))
+      end
+    end
+
+    context 'when block raises' do
+      let(:exception) { error.new             }
+      let(:block)     { -> { fail exception } }
+
+      context 'with covered exception' do
+        it 'returns left wrapping exception' do
+          expect(apply).to eql(described_class::Left.new(exception))
+        end
+      end
+
+      context 'with uncovered exception' do
+        let(:exception) { StandardError.new }
+
+        it 'returns raises error' do
+          expect { apply }.to raise_error(StandardError)
+        end
+      end
+    end
+  end
+end
+
+RSpec.describe Mutant::Either::Left do
+  subject { described_class.new(value) }
+
+  let(:block_result) { instance_double(Object, 'block result') }
+  let(:value)        { instance_double(Object, 'value')        }
+  let(:yields)       { []                                      }
+
+  let(:block) do
+    lambda do |value|
+      yields << value
+      block_result
+    end
+  end
+
+  class TestError < RuntimeError; end
+
+  describe '#fmap' do
+    def apply
+      subject.fmap(&block)
+    end
+
+    include_examples 'no block evaluation'
+    include_examples 'requires block'
+    include_examples 'returns self'
+  end
+
+  describe '#apply' do
+    def apply
+      subject.apply(&block)
+    end
+
+    include_examples 'no block evaluation'
+    include_examples 'requires block'
+    include_examples 'returns self'
+  end
+
+  describe '#from_left' do
+    def apply
+      subject.from_left(&block)
+    end
+
+    it 'returns left value' do
+      expect(apply).to be(value)
+    end
+
+    include_examples 'no block evaluation'
+  end
+
+  describe '#from_right' do
+    def apply
+      subject.from_right(&block)
+    end
+
+    context 'without block' do
+      let(:block) { nil }
+
+      it 'raises RuntimeError error' do
+        expect { apply }.to raise_error(
+          RuntimeError,
+          "Expected right value, got #{subject.inspect}"
+        )
+      end
+    end
+
+    context 'with block' do
+      let(:yields)       { []                                      }
+      let(:block_return) { instance_double(Object, 'block-return') }
+
+      let(:block) do
+        lambda do |value|
+          yields << value
+          block_return
+        end
+      end
+
+      it 'calls block with left value' do
+        expect { apply }.to change(yields, :to_a).from([]).to([value])
+      end
+
+      it 'returns block value' do
+        expect(apply).to be(block_return)
+      end
+    end
+  end
+
+  describe '#lmap' do
+    def apply
+      subject.lmap(&block)
+    end
+
+    include_examples 'requires block'
+    include_examples 'Functor#fmap block evaluation'
+  end
+
+  describe '#either' do
+    def apply
+      subject.either(block, -> { fail })
+    end
+
+    include_examples '#apply block evaluation'
+  end
+end
+
+RSpec.describe Mutant::Either::Right do
+  subject { described_class.new(value) }
+
+  let(:block_result) { instance_double(Object, 'block result') }
+  let(:value)        { instance_double(Object, 'value')        }
+  let(:yields)       { []                                      }
+
+  let(:block) do
+    lambda do |value|
+      yields << value
+      block_result
+    end
+  end
+
+  describe '#fmap' do
+    def apply
+      subject.fmap(&block)
+    end
+
+    include_examples 'requires block'
+    include_examples 'Functor#fmap block evaluation'
+  end
+
+  describe '#apply' do
+    def apply
+      subject.apply(&block)
+    end
+
+    include_examples 'requires block'
+    include_examples '#apply block evaluation'
+  end
+
+  describe '#from_left' do
+    def apply
+      subject.from_left(&block)
+    end
+
+    context 'without block' do
+      let(:block) { nil }
+
+      it 'raises RuntimeError error' do
+        expect { apply }.to raise_error(
+          RuntimeError,
+          "Expected left value, got #{subject.inspect}"
+        )
+      end
+    end
+
+    context 'with block' do
+      let(:yields)       { []                                      }
+      let(:block_return) { instance_double(Object, 'block-return') }
+
+      let(:block) do
+        lambda do |value|
+          yields << value
+          block_return
+        end
+      end
+
+      it 'calls block with right value' do
+        expect { apply }.to change(yields, :to_a).from([]).to([value])
+      end
+
+      it 'returns block value' do
+        expect(apply).to be(block_return)
+      end
+    end
+  end
+
+  describe '#from_right' do
+    def apply
+      subject.from_right(&block)
+    end
+
+    it 'returns right value' do
+      expect(apply).to be(value)
+    end
+
+    include_examples 'no block evaluation'
+  end
+
+  describe '#lmap' do
+    def apply
+      subject.lmap(&block)
+    end
+
+    include_examples 'requires block'
+    include_examples 'no block evaluation'
+
+    it 'returns self' do
+      expect(apply).to be(subject)
+    end
+  end
+
+  describe '#either' do
+    def apply
+      subject.either(-> { fail }, block)
+    end
+
+    include_examples '#apply block evaluation'
+  end
+end

data/spec/unit/mutant/env_spec.rb

@@ -1,57 +1,86 @@
 # frozen_string_literal: true
 
 RSpec.describe Mutant::Env do
-  let(:object) do
+  subject do
     described_class.new(
-      actor_env:        Mutant::Actor::Env.new(Thread),
       config:           config,
       integration:      integration,
       matchable_scopes: [],
       mutations:        [],
       selector:         selector,
-      subjects:         [mutation_subject],
-      parser:           Mutant::Parser.new
+      subjects:         subjects,
+      parser:           Mutant::Parser.new,
+      world:            world
     )
   end
 
-  let(:integration)       { instance_double(Mutant::Integration) }
-  let(:test_a)            { instance_double(Mutant::Test)        }
-  let(:test_b)            { instance_double(Mutant::Test)        }
-  let(:tests)             { [test_a, test_b]                     }
-  let(:selector)          { instance_double(Mutant::Selector)    }
   let(:integration_class) { Mutant::Integration::Null            }
   let(:isolation)         { Mutant::Isolation::None.new          }
-  let(:mutation_subject)  { instance_double(Mutant::Subject)     }
+  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: mutation_subject
+      subject: subject_a
     )
   end
 
   let(:config) do
-    Mutant::Config::DEFAULT.with(
-      isolation:   isolation,
+    instance_double(
+      Mutant::Config,
       integration: integration_class,
-      kernel:      class_double(Kernel)
+      isolation:   isolation,
+      reporter:    reporter
+    )
+  end
+
+  let(:world) do
+    instance_double(
+      Mutant::World,
+      kernel: kernel
     )
   end
 
   before do
     allow(selector).to receive(:call)
-      .with(mutation_subject)
-      .and_return(tests)
+      .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
-    subject { object.kill(mutation) }
+    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_for 'mutation kill' do
-      specify do
-        should eql(
+    shared_examples 'mutation kill' do
+      it 'returns expected result' do
+        expect(apply).to eql(
           Mutant::Result::Mutation.new(
             isolation_result: isolation_result,
             mutation:         mutation,
@@ -61,36 +90,41 @@ RSpec.describe Mutant::Env do
       end
     end
 
-    context 'when isolation does not raise error' do
-      let(:test_result) { instance_double(Mutant::Result::Test) }
+    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
-        expect(mutation).to receive(:insert)
-          .ordered
-          .with(config.kernel)
-
-        expect(integration).to receive(:call)
-          .ordered
-          .with(tests)
-          .and_return(test_result)
+        allow(integration).to receive_messages(call: test_result)
       end
 
-      let(:isolation_result) do
-        Mutant::Isolation::Result::Success.new(test_result)
+      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 code does raise error' do
-      let(:exception) { RuntimeError.new('foo') }
+    context 'when loader reports void value' do
+      let(:loader_result) { Mutant::Loader::Result::VoidValue.instance }
 
-      before do
-        expect(mutation).to receive(:insert).and_raise(exception)
+      let(:isolation_result) do
+        Mutant::Isolation::Result::Success.new(Mutant::Result::Test::VoidValue.instance)
       end
 
-      let(:isolation_result) do
-        Mutant::Isolation::Result::Exception.new(exception)
+      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'
@@ -98,10 +132,98 @@ RSpec.describe Mutant::Env do
   end
 
   describe '#selections' do
-    subject { object.selections }
+    def apply
+      subject.selections
+    end
 
     it 'returns expected selections' do
-      expect(subject).to eql(mutation_subject => tests)
+      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