mutant 0.9.9 → 0.9.14

data/spec/unit/mutant/integration_spec.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Integration do
-  subject { class_under_test.new(Mutant::Config::DEFAULT) }
-
-  let(:class_under_test) do
-    Class.new(described_class)
-  end
-
-  describe '#setup' do
-    def apply
-      subject.setup
-    end
-
-    it 'returns self' do
-      expect(apply).to be(subject)
-    end
-  end
-
-  describe '.setup' do
-    def apply
-      described_class.setup(env)
-    end
-
-    let(:kernel)           { class_double(Kernel)                       }
-    let(:integration)      { instance_double(Mutant::Integration::Null) }
-    let(:integration_name) { 'null'                                     }
-
-    let(:config) do
-      instance_double(
-        Mutant::Config,
-        integration: integration_name
-      )
-    end
-
-    let(:env) do
-      instance_double(
-        Mutant::Env,
-        config: config,
-        world:  world
-      )
-    end
-
-    let(:world) do
-      instance_double(
-        Mutant::World,
-        kernel: kernel
-      )
-    end
-
-    before do
-      allow(kernel).to receive_messages(require: undefined)
-      allow(described_class).to receive_messages(const_get: described_class::Null)
-      allow(described_class::Null).to receive_messages(new: integration)
-      allow(integration).to receive_messages(setup: integration)
-    end
-
-    context 'when require fails' do
-      let(:exception) { LoadError.new('some-load-error') }
-
-      before do
-        allow(kernel).to receive(:require).and_raise(exception)
-      end
-
-      it 'returns error' do
-        expect(apply).to eql(Mutant::Either::Left.new(<<~MESSAGE))
-          Unable to load integration mutant-null:
-          #{exception.inspect}
-          You may have to install the gem mutant-null!
-        MESSAGE
-      end
-    end
-
-    context 'when constant lookup fails' do
-      let(:exception) { NameError.new('some-name-error') }
-
-      before do
-        allow(described_class).to receive(:const_get).and_raise(exception)
-      end
-
-      it 'returns error' do
-        expect(apply).to eql(Mutant::Either::Left.new(<<~MESSAGE))
-          Unable to load integration mutant-null:
-          #{exception.inspect}
-          This is a bug in the integration you have to report.
-          The integration is supposed to define Mutant::Integration::Null!
-        MESSAGE
-      end
-    end
-
-    it 'performs actions in expected sequence' do
-      apply
-
-      expect(kernel)
-        .to have_received(:require)
-        .with('mutant/integration/null')
-        .ordered
-
-      expect(described_class)
-        .to have_received(:const_get)
-        .with('Null')
-        .ordered
-
-      expect(described_class::Null)
-        .to have_received(:new)
-        .with(config)
-        .ordered
-
-      expect(integration)
-        .to have_received(:setup)
-        .ordered
-    end
-
-    it 'returns integration instance' do
-      expect(apply).to eql(
-        Mutant::Either::Right.new(integration)
-      )
-    end
-  end
-end
-
-RSpec.describe Mutant::Integration::Null do
-
-  let(:object) { described_class.new(Mutant::Config::DEFAULT) }
-
-  describe '#all_tests' do
-    subject { object.all_tests }
-
-    it { should eql([]) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '#call' do
-    let(:tests) { instance_double(Array) }
-
-    subject { object.call(tests) }
-
-    it 'returns test result' do
-      should eql(
-        Mutant::Result::Test.new(
-          output:  '',
-          passed:  true,
-          runtime: 0.0,
-          tests:   tests
-        )
-      )
-    end
-  end
-end

data/spec/unit/mutant/isolation/fork_spec.rb

@@ -1,309 +0,0 @@
-# frozen_string_literal: true
-
-# The fork isolation is all about managing a series of systemcalls with proper error handling
-#
-# So creating a unit spec for this is challenging. Especially under mutation testing.
-# Hence we even have to implement our own message expectation mechanism, as rspec build in
-# expectations are not able to correctly specify a sequence of expectations where a specific
-# message is send twice.
-#
-# Also our replacement for rspec-expectations used here allows easier deduplication.
-RSpec.describe Mutant::Isolation::Fork do
-  let(:block_return)      { instance_double(Object, :block_return)      }
-  let(:block_return_blob) { instance_double(String, :block_return_blob) }
-  let(:io)                { class_double(IO)                            }
-  let(:isolated_block)    { -> { block_return }                         }
-  let(:log_fragment)      { 'log message'                               }
-  let(:log_reader)        { instance_double(IO, :log_reader)            }
-  let(:log_writer)        { instance_double(IO, :log_writer)            }
-  let(:marshal)           { class_double(Marshal)                       }
-  let(:pid)               { class_double(Integer)                       }
-  let(:process)           { class_double(Process)                       }
-  let(:result_fragment)   { 'result body'                               }
-  let(:result_reader)     { instance_double(IO, :result_reader)         }
-  let(:result_writer)     { instance_double(IO, :result_writer)         }
-  let(:stderr)            { instance_double(IO, :stderr)                }
-  let(:stdout)            { instance_double(IO, :stdout)                }
-
-  let(:status_success) do
-    instance_double(Process::Status, success?: true)
-  end
-
-  let(:world) do
-    instance_double(
-      Mutant::World,
-      io:      io,
-      marshal: marshal,
-      process: process,
-      stderr:  stderr,
-      stdout:  stdout
-    )
-  end
-
-  let(:fork_success) do
-    {
-      receiver: process,
-      selector: :fork,
-      reaction: {
-        yields: [],
-        return: pid
-      }
-    }
-  end
-
-  let(:child_wait) do
-    {
-      receiver:  process,
-      selector:  :wait2,
-      arguments: [pid],
-      reaction:  {
-        return: [pid, status_success]
-      }
-    }
-  end
-
-  def close(descriptor)
-    {
-      receiver: descriptor,
-      selector: :close
-    }
-  end
-
-  let(:load_success) do
-    {
-      receiver:  marshal,
-      selector:  :load,
-      arguments: [result_fragment],
-      reaction:  {
-        return: block_return
-      }
-    }
-  end
-
-  let(:read_fragments) do
-    [
-      {
-        receiver:  io,
-        selector:  :select,
-        arguments: [[log_reader, result_reader]],
-        reaction:  { return: [[log_reader, result_reader], []] }
-      },
-      {
-        receiver: log_reader,
-        selector: :eof?,
-        reaction: { return: false }
-      },
-      {
-        receiver:  log_reader,
-        selector:  :read_nonblock,
-        arguments: [4096],
-        reaction:  { return: log_fragment }
-      },
-      {
-        receiver: result_reader,
-        selector: :eof?,
-        reaction: { return: false }
-      },
-      {
-        receiver:  result_reader,
-        selector:  :read_nonblock,
-        arguments: [4096],
-        reaction:  { return: result_fragment }
-      },
-      {
-        receiver:  io,
-        selector:  :select,
-        arguments: [[log_reader, result_reader]],
-        reaction:  { return: [[log_reader, result_reader], []] }
-      },
-      {
-        receiver: log_reader,
-        selector: :eof?,
-        reaction: { return: true }
-      },
-      {
-        receiver: result_reader,
-        selector: :eof?,
-        reaction: { return: true }
-      }
-    ]
-  end
-
-  let(:killfork) do
-    [
-      # Inside the killfork
-      {
-        receiver: log_reader,
-        selector: :close
-      },
-      {
-        receiver: result_reader,
-        selector: :close
-      },
-      {
-        receiver:  stderr,
-        selector:  :reopen,
-        arguments: [log_writer]
-      },
-      {
-        receiver:  stdout,
-        selector:  :reopen,
-        arguments: [log_writer]
-      },
-      {
-        receiver:  marshal,
-        selector:  :dump,
-        arguments: [block_return],
-        reaction:  {
-          return: block_return_blob
-        }
-      },
-      {
-        receiver:  result_writer,
-        selector:  :syswrite,
-        arguments: [block_return_blob]
-      },
-      close(result_writer),
-      close(log_writer)
-    ]
-  end
-
-  describe '#call' do
-    subject { described_class.new(world) }
-
-    def apply
-      subject.call(&isolated_block)
-    end
-
-    let(:prefork_expectations) do
-      [
-        {
-          receiver:  io,
-          selector:  :pipe,
-          arguments: [binmode: true],
-          reaction:  {
-            yields: [[result_reader, result_writer]]
-          }
-        },
-        {
-          receiver:  io,
-          selector:  :pipe,
-          arguments: [binmode: true],
-          reaction:  {
-            yields: [[log_reader, log_writer]]
-          }
-        }
-      ]
-    end
-
-    context 'when no IO operation fails' do
-      let(:expectations) do
-        [
-          *prefork_expectations,
-          fork_success,
-          *killfork,
-          close(result_writer),
-          *read_fragments,
-          load_success,
-          child_wait
-        ].map(&XSpec::MessageExpectation.method(:parse))
-      end
-
-      specify do
-        XSpec::ExpectationVerifier.verify(self, expectations) do
-          expect(apply).to eql(Mutant::Isolation::Result::Success.new(block_return, log_fragment))
-        end
-      end
-    end
-
-    context 'when expected exception was raised when loading result' do
-      let(:exception) { ArgumentError.new }
-
-      let(:expectations) do
-        [
-          *prefork_expectations,
-          fork_success,
-          *killfork,
-          close(result_writer),
-          *read_fragments,
-          {
-            receiver:  marshal,
-            selector:  :load,
-            arguments: [result_fragment],
-            reaction:  {
-              exception: exception
-            }
-          },
-          child_wait
-        ].map(&XSpec::MessageExpectation.method(:parse))
-      end
-
-      specify do
-        XSpec::ExpectationVerifier.verify(self, expectations) do
-          expect(apply).to eql(Mutant::Isolation::Result::Exception.new(exception))
-        end
-      end
-    end
-
-    context 'when fork fails' do
-      let(:result_class) { described_class::ForkError }
-
-      let(:expectations) do
-        [
-          *prefork_expectations,
-          {
-            receiver: process,
-            selector: :fork,
-            reaction: {
-              return: nil
-            }
-          }
-        ].map(&XSpec::MessageExpectation.method(:parse))
-      end
-
-      specify do
-        XSpec::ExpectationVerifier.verify(self, expectations) do
-          expect(apply).to eql(result_class.new)
-        end
-      end
-    end
-
-    context 'when child exits nonzero' do
-      let(:status_error) do
-        instance_double(Process::Status, success?: false)
-      end
-
-      let(:expected_result) do
-        Mutant::Isolation::Result::ErrorChain.new(
-          described_class::ChildError.new(status_error, log_fragment),
-          Mutant::Isolation::Result::Success.new(block_return, log_fragment)
-        )
-      end
-
-      let(:expectations) do
-        [
-          *prefork_expectations,
-          fork_success,
-          *killfork,
-          close(result_writer),
-          *read_fragments,
-          load_success,
-          {
-            receiver:  process,
-            selector:  :wait2,
-            arguments: [pid],
-            reaction:  {
-              return: [pid, status_error]
-            }
-          }
-        ].map(&XSpec::MessageExpectation.method(:parse))
-      end
-
-      specify do
-        XSpec::ExpectationVerifier.verify(self, expectations) do
-          expect(apply).to eql(expected_result)
-        end
-      end
-    end
-  end
-end