mutant 0.8.24 → 0.9.0

data/spec/unit/mutant/expression/method_spec.rb

@@ -43,4 +43,20 @@ RSpec.describe Mutant::Expression::Method do
       end
     end
   end
+
+  describe '#syntax' do
+    subject { object.syntax }
+
+    context 'on instance method' do
+      let(:input) { instance_method }
+
+      it { should eql(instance_method) }
+    end
+
+    context 'on singleton method' do
+      let(:input) { singleton_method }
+
+      it { should eql(singleton_method) }
+    end
+  end
 end

data/spec/unit/mutant/expression/parser_spec.rb

@@ -1,46 +1,41 @@
 # frozen_string_literal: true
 
 RSpec.describe Mutant::Expression::Parser do
-  let(:object) { Mutant::Config::DEFAULT.expression_parser }
-
-  describe '#call' do
-    subject { object.call(input) }
-
-    context 'on nonsense' do
-      let(:input) { 'foo bar' }
+  subject do
+    Mutant::Config::DEFAULT.expression_parser
+  end
 
-      it 'raises an exception' do
-        expect { subject }.to raise_error(
-          Mutant::Expression::Parser::InvalidExpressionError,
-          'Expression: "foo bar" is not valid'
-        )
-      end
-    end
+  def apply
+    subject.apply(input)
+  end
 
+  describe '#apply' do
     context 'on a valid expression' do
       let(:input) { 'Foo' }
 
-      it { should eql(Mutant::Expression::Namespace::Exact.new(scope_name: 'Foo')) }
+      it 'returns sucess' do
+        expect(apply).to eql(
+          Mutant::Either::Right.new(
+            Mutant::Expression::Namespace::Exact.new(scope_name: 'Foo')
+          )
+        )
+      end
     end
-  end
-
-  describe '.try_parse' do
-    subject { object.try_parse(input) }
 
-    context 'on nonsense' do
+    context 'on invalid input' do
       let(:input) { 'foo bar' }
 
-      it { should be(nil) }
-    end
-
-    context 'on a valid expression' do
-      let(:input) { 'Foo' }
-
-      it { should eql(Mutant::Expression::Namespace::Exact.new(scope_name: 'Foo')) }
+      it 'returns returns error' do
+        expect(apply).to eql(
+          Mutant::Either::Left.new('Expression: "foo bar" is invalid')
+        )
+      end
     end
 
-    context 'on ambiguous expression' do
-      let(:object) { described_class.new([test_a, test_b]) }
+    context 'on ambiguous input' do
+      subject do
+        described_class.new([test_a, test_b])
+      end
 
       let(:test_a) do
         Class.new(Mutant::Expression) do
@@ -58,10 +53,11 @@ RSpec.describe Mutant::Expression::Parser do
 
       let(:input) { 'test-syntax' }
 
-      it 'raises expected exception' do
-        expect { subject }.to raise_error(
-          Mutant::Expression::Parser::AmbiguousExpressionError,
-          'Ambiguous expression: "test-syntax"'
+      it 'returns error' do
+        expect(apply).to eql(
+          Mutant::Either::Left.new(
+            'Expression: "test-syntax" is ambiguous'
+          )
         )
       end
     end

data/spec/unit/mutant/expression_spec.rb

@@ -1,21 +1,19 @@
 # frozen_string_literal: true
 
 RSpec.describe Mutant::Expression do
-  let(:parser) { Mutant::Config::DEFAULT.expression_parser }
-
   describe '#prefix?' do
-    let(:object) { parser.call('Foo*') }
+    let(:object) { parse_expression('Foo*') }
 
     subject { object.prefix?(other) }
 
     context 'when object is a prefix of other' do
-      let(:other) { parser.call('Foo::Bar') }
+      let(:other) { parse_expression('Foo::Bar') }
 
       it { should be(true) }
     end
 
     context 'when other is not a prefix of other' do
-      let(:other) { parser.call('Bar') }
+      let(:other) { parse_expression('Bar') }
 
       it { should be(false) }
     end
@@ -32,13 +30,13 @@ RSpec.describe Mutant::Expression do
 
     subject { object.try_parse(input) }
 
-    context 'on successful parse' do
+    context 'good input' do
       let(:input) { 'foo' }
 
       it { should eql(object.new(foo: 'foo')) }
     end
 
-    context 'on unsuccessful parse' do
+    context 'bad input' do
       let(:input) { 'bar' }
 
       it { should be(nil) }

data/spec/unit/mutant/integration_spec.rb

@@ -1,30 +1,121 @@
 # 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
 
-  let(:object) { class_under_test.new(Mutant::Config::DEFAULT) }
-
   describe '#setup' do
-    subject { object.setup }
-    it_should_behave_like 'a command method'
+    def apply
+      subject.setup
+    end
+
+    it 'returns self' do
+      expect(apply).to be(subject)
+    end
   end
 
   describe '.setup' do
-    subject { described_class.setup(kernel, name) }
+    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(:name)   { 'null'               }
-    let(:kernel) { class_double(Kernel) }
+    let(:env) do
+      instance_double(
+        Mutant::Env,
+        config: config,
+        world:  world
+      )
+    end
+
+    let(:world) do
+      instance_double(
+        Mutant::World,
+        kernel: kernel
+      )
+    end
 
     before do
-      expect(kernel).to receive(:require)
+      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 { should be(Mutant::Integration::Null) }
+    it 'returns integration instance' do
+      expect(apply).to eql(
+        Mutant::Either::Right.new(integration)
+      )
+    end
   end
 end
 

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

@@ -11,22 +11,35 @@
 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(:devnull)           { instance_double(Proc, :devnull)             }
   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(:pid)               { class_double(0.class)                       }
-  let(:reader)            { instance_double(IO, :reader)                }
+  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(:writer)            { instance_double(IO, :writer)                }
-  let(:nullio)            { instance_double(IO, :nullio)                }
 
   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,
@@ -49,9 +62,9 @@ RSpec.describe Mutant::Isolation::Fork do
     }
   end
 
-  let(:writer_close) do
+  def close(descriptor)
     {
-      receiver: writer,
+      receiver: descriptor,
       selector: :close
     }
   end
@@ -60,40 +73,82 @@ RSpec.describe Mutant::Isolation::Fork do
     {
       receiver:  marshal,
       selector:  :load,
-      arguments: [reader],
+      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: reader,
+        receiver: log_reader,
         selector: :close
       },
       {
-        receiver: writer,
-        selector: :binmode
-      },
-      {
-        receiver: devnull,
-        selector: :call,
-        reaction: {
-          yields: [nullio]
-        }
+        receiver: result_reader,
+        selector: :close
       },
       {
         receiver:  stderr,
         selector:  :reopen,
-        arguments: [nullio]
+        arguments: [log_writer]
       },
       {
         receiver:  stdout,
         selector:  :reopen,
-        arguments: [nullio]
+        arguments: [log_writer]
       },
       {
         receiver:  marshal,
@@ -104,27 +159,21 @@ RSpec.describe Mutant::Isolation::Fork do
         }
       },
       {
-        receiver:  writer,
+        receiver:  result_writer,
         selector:  :syswrite,
         arguments: [block_return_blob]
       },
-      writer_close
+      close(result_writer),
+      close(log_writer)
     ]
   end
 
   describe '#call' do
-    let(:object) do
-      described_class.new(
-        devnull: devnull,
-        io:      io,
-        marshal: marshal,
-        process: process,
-        stderr:  stderr,
-        stdout:  stdout
-      )
-    end
+    subject { described_class.new(world) }
 
-    subject { object.call(&isolated_block) }
+    def apply
+      subject.call(&isolated_block)
+    end
 
     let(:prefork_expectations) do
       [
@@ -133,7 +182,15 @@ RSpec.describe Mutant::Isolation::Fork do
           selector:  :pipe,
           arguments: [binmode: true],
           reaction:  {
-            yields: [[reader, writer]]
+            yields: [[result_reader, result_writer]]
+          }
+        },
+        {
+          receiver:  io,
+          selector:  :pipe,
+          arguments: [binmode: true],
+          reaction:  {
+            yields: [[log_reader, log_writer]]
           }
         }
       ]
@@ -145,7 +202,8 @@ RSpec.describe Mutant::Isolation::Fork do
           *prefork_expectations,
           fork_success,
           *killfork,
-          writer_close,
+          close(result_writer),
+          *read_fragments,
           load_success,
           child_wait
         ].map(&XSpec::MessageExpectation.method(:parse))
@@ -153,37 +211,36 @@ RSpec.describe Mutant::Isolation::Fork do
 
       specify do
         XSpec::ExpectationVerifier.verify(self, expectations) do
-          expect(subject).to eql(Mutant::Isolation::Result::Success.new(block_return))
+          expect(apply).to eql(Mutant::Isolation::Result::Success.new(block_return, log_fragment))
         end
       end
     end
 
-    context 'when expected exception was raised when reading from child' do
-      [ArgumentError, EOFError].each do |exception_class|
-        context "on #{exception_class}" do
-          let(:exception) { exception_class.new }
-
-          let(:expectations) do
-            [
-              *prefork_expectations,
-              fork_success,
-              *killfork,
-              {
-                receiver: writer,
-                selector: :close,
-                reaction: {
-                  exception: exception
-                }
-              },
-              child_wait
-            ].map(&XSpec::MessageExpectation.method(:parse))
-          end
-
-          specify do
-            XSpec::ExpectationVerifier.verify(self, expectations) do
-              expect(subject).to eql(Mutant::Isolation::Result::Exception.new(exception))
-            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
@@ -206,7 +263,7 @@ RSpec.describe Mutant::Isolation::Fork do
 
       specify do
         XSpec::ExpectationVerifier.verify(self, expectations) do
-          expect(subject).to eql(result_class.new)
+          expect(apply).to eql(result_class.new)
         end
       end
     end
@@ -218,8 +275,8 @@ RSpec.describe Mutant::Isolation::Fork do
 
       let(:expected_result) do
         Mutant::Isolation::Result::ErrorChain.new(
-          described_class::ChildError.new(status_error),
-          Mutant::Isolation::Result::Success.new(block_return)
+          described_class::ChildError.new(status_error, log_fragment),
+          Mutant::Isolation::Result::Success.new(block_return, log_fragment)
         )
       end
 
@@ -228,7 +285,8 @@ RSpec.describe Mutant::Isolation::Fork do
           *prefork_expectations,
           fork_success,
           *killfork,
-          writer_close,
+          close(result_writer),
+          *read_fragments,
           load_success,
           {
             receiver:  process,
@@ -243,7 +301,7 @@ RSpec.describe Mutant::Isolation::Fork do
 
       specify do
         XSpec::ExpectationVerifier.verify(self, expectations) do
-          expect(subject).to eql(expected_result)
+          expect(apply).to eql(expected_result)
         end
       end
     end