mutant 0.9.10 → 0.10.0

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

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Isolation::None do
-  describe '.call' do
-    let(:object) { described_class.new }
-
-    context 'without exception' do
-      it 'returns success result' do
-        expect(object.call { :foo })
-          .to eql(Mutant::Isolation::Result::Success.new(:foo))
-      end
-    end
-
-    context 'with exception' do
-      let(:exception) { RuntimeError.new('foo') }
-
-      it 'returns error result' do
-        expect(object.call { fail exception })
-          .to eql(Mutant::Isolation::Result::Exception.new(exception))
-      end
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Isolation::Result do
-  describe '#success?' do
-    let(:value) { double('Object') }
-
-    def apply
-      effective_class.new(value).success?
-    end
-
-    context 'on success instance' do
-      let(:effective_class) { described_class::Success }
-
-      it 'returns true' do
-        expect(apply).to be(true)
-      end
-    end
-
-    context 'on error instance' do
-      let(:effective_class) { described_class::Exception }
-
-      it 'returns false' do
-        expect(apply).to be(false)
-      end
-    end
-  end
-
-  describe '#add_error' do
-    let(:other)  { described_class::Success.new(object) }
-    let(:value)  { double('Object')                     }
-    let(:object) { described_class::Success.new(value)  }
-
-    def apply
-      object.add_error(other)
-    end
-
-    it 'returns chain instance' do
-      expect(apply).to eql(described_class::ErrorChain.new(other, object))
-    end
-  end
-
-  describe '#log' do
-    let(:value) { double('Object') }
-
-    def apply
-      object.log
-    end
-
-    context 'on exception result' do
-      let(:object) { described_class::Exception.new(value) }
-
-      it 'returns the empty string' do
-        expect(apply).to eql('')
-      end
-    end
-
-    context 'on sucess result' do
-      let(:object) { described_class::Success.new(value) }
-
-      it 'returns the empty string' do
-        expect(apply).to eql('')
-      end
-    end
-
-    context 'on argument' do
-      let(:object) { described_class::Success.new(value, 'foo') }
-
-      it 'returns the empty string' do
-        expect(apply).to eql('foo')
-      end
-    end
-  end
-end

data/spec/unit/mutant/license_spec.rb

@@ -1,305 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::License do
-  def apply
-    described_class.apply(world)
-  end
-
-  let(:gem)              { class_double(Gem, loaded_specs: loaded_specs) }
-  let(:gem_method)       { instance_double(Method)                       }
-  let(:gem_path)         { '/path/to/mutant-license'                     }
-  let(:gem_pathname)     { instance_double(Pathname)                     }
-  let(:json)             { class_double(JSON)                            }
-  let(:kernel)           { class_double(Kernel)                          }
-  let(:license_pathname) { instance_double(Pathname)                     }
-  let(:load_json)        { true                                          }
-  let(:loaded_specs)     { { 'mutant-license' => spec }                  }
-  let(:path)             { instance_double(Pathname)                     }
-  let(:pathname)         { class_double(Pathname)                        }
-  let(:stderr)           { instance_double(IO)                           }
-
-  let(:spec) do
-    instance_double(
-      Gem::Specification,
-      full_gem_path: gem_path
-    )
-  end
-
-  let(:world) do
-    instance_double(
-      Mutant::World,
-      gem:        gem,
-      gem_method: gem_method,
-      json:       json,
-      kernel:     kernel,
-      pathname:   pathname,
-      stderr:     stderr
-    )
-  end
-
-  before do
-    allow(gem_method).to receive_messages(call: undefined)
-    allow(gem_pathname).to receive_messages(join: license_pathname)
-    allow(json).to receive_messages(load: license_json)
-    allow(kernel).to receive_messages(sleep: undefined)
-    allow(pathname).to receive_messages(new: gem_pathname)
-    allow(world).to receive(:capture_stdout, &commands.method(:fetch))
-  end
-
-  def self.it_fails(expected)
-    it 'failse with exception' do
-      expect { apply }.to raise_error(expected)
-    end
-  end
-
-  def self.it_is_successful
-    include_examples 'license.json lookup'
-
-    it 'allows usage' do
-      expect(apply).to eql(Mutant::Either::Right.new(true))
-    end
-  end
-
-  # rubocop:disable Metrics/AbcSize
-  # rubocop:disable Metrics/MethodLength
-  def self.it_fails_with_message(expected)
-    before do
-      allow(stderr).to receive(:puts)
-    end
-
-    it 'performs IO in expected sequence' do
-      expect(apply).to eql(Mutant::Either::Right.new(true))
-
-      expect(gem_method)
-        .to have_received(:call)
-        .with('mutant-license', '~> 0.1.0')
-        .ordered
-
-      if load_json
-        expect(json)
-          .to have_received(:load)
-          .with(license_pathname)
-          .ordered
-      end
-
-      expect(stderr)
-        .to have_received(:puts)
-        .with(expected)
-        .ordered
-
-      expect(stderr)
-        .to have_received(:puts)
-        .with('[Mutant-License-Error]: Soft fail, continuing in 40 seconds')
-        .ordered
-
-      expect(stderr)
-        .to have_received(:puts)
-        .with('[Mutant-License-Error]: Next major version will enforce the license')
-        .ordered
-
-      expect(stderr)
-        .to have_received(:puts)
-        .with('[Mutant-License-Error]: See https://github.com/mbj/mutant#licensing')
-        .ordered
-
-      expect(kernel)
-        .to have_received(:sleep)
-        .with(40)
-        .ordered
-    end
-  end
-
-  shared_examples 'license.json lookup' do
-    it 'builds correct license.json path' do
-      apply
-
-      expect(pathname).to have_received(:new).with(gem_path)
-      expect(gem_pathname).to have_received(:join).with('license.json')
-    end
-  end
-
-  describe 'on opensource license' do
-    let(:repository) { 'github.com/mbj/mutant' }
-
-    let(:git_remote) do
-      <<~REMOTE
-        origin\tgit@github.com:mbj/mutant (fetch)
-        origin\tgit@github.com:mbj/mutant (push)
-      REMOTE
-    end
-
-    let(:license_json) do
-      {
-        'type'     => 'oss',
-        'contents' => {
-          'repositories' => [repository]
-        }
-      }
-    end
-
-    let(:git_remote_result) { Mutant::Either::Right.new(git_remote) }
-
-    let(:commands) do
-      {
-        %w[git remote --verbose] => git_remote_result
-      }
-    end
-
-    context 'when repository is whitelisted' do
-      context 'on ssh url without protocol and without suffx' do
-        it_is_successful
-      end
-
-      context 'on ssh url with protocol and without suffx' do
-        let(:git_remote) do
-          <<~REMOTE
-            origin\tssh://git@github.com/mbj/mutant (fetch)
-            origin\tssh://git@github.com/mbj/mutant (push)
-          REMOTE
-        end
-
-        it_is_successful
-      end
-
-      context 'on ssh url with protocol and suffx' do
-        let(:git_remote) do
-          <<~REMOTE
-            origin\tssh://git@github.com/mbj/mutant.git (fetch)
-            origin\tssh://git@github.com/mbj/mutant.git (push)
-          REMOTE
-        end
-
-        it_is_successful
-      end
-
-      context 'on https url without suffix' do
-        let(:git_remote) do
-          <<~REMOTE
-            origin\thttps://github.com/mbj/mutant (fetch)
-            origin\thttps://github.com/mbj/mutant (push)
-          REMOTE
-        end
-
-        it_is_successful
-      end
-
-      context 'on https url with .git suffix' do
-        let(:git_remote) do
-          <<~REMOTE
-            origin\thttps://github.com/mbj/mutant.git (fetch)
-            origin\thttps://github.com/mbj/mutant.git (push)
-          REMOTE
-        end
-
-        it_is_successful
-      end
-    end
-
-    context 'when repository is not whitelisted' do
-      let(:repository) { 'github.com/mbj/unparser' }
-
-      it_fails_with_message(<<~'MESSAGE')
-        Can not validate opensource license.
-        Licensed:
-        github.com/mbj/unparser
-        Present:
-        github.com/mbj/mutant
-      MESSAGE
-    end
-
-    context 'when git remote line cannot be parsed' do
-      let(:git_remote) { "some-bad-remote-line\n" }
-
-      it_fails 'Unmatched remote line: "some-bad-remote-line\n"'
-    end
-
-    context 'when git remote url cannot be parsed' do
-      let(:git_remote) { "some-unknown\thttp://github.com/mbj/mutant (fetch)\n" }
-
-      it_fails 'Unmatched git remote URL: "http://github.com/mbj/mutant"'
-    end
-  end
-
-  describe 'on commercial license' do
-    let(:licensed_authors) do
-      %w[
-        customer-a@example.com
-        customer-b@example.com
-      ]
-    end
-
-    let(:license_json) do
-      {
-        'type'     => 'com',
-        'contents' => {
-          'authors' => licensed_authors
-        }
-      }
-    end
-
-    let(:git_config_author) { "customer-a@example.com\n"                   }
-    let(:git_config_result) { Mutant::Either::Right.new(git_config_author) }
-    let(:git_show_author)   { "customer-b@example.com\n"                   }
-    let(:git_show_result)   { Mutant::Either::Right.new(git_show_author)   }
-
-    let(:commands) do
-      {
-        %w[git config --get user.email]          => git_config_result,
-        %w[git show --quiet --pretty=format:%ae] => git_show_result
-      }
-    end
-
-    context 'when author is whitelisted' do
-      it_is_successful
-    end
-
-    context 'when author is not whitelisted' do
-      let(:licensed_authors) { %w[customer-c@example.com] }
-
-      it_fails_with_message(<<~'MESSAGE')
-        Can not validate commercial license.
-        Licensed:
-        customer-c@example.com
-        Present:
-        customer-a@example.com
-        customer-b@example.com
-      MESSAGE
-    end
-
-    context 'when author cannot be found in commit or config' do
-      let(:git_config_result) { Mutant::Either::Left.new('fatal: error') }
-      let(:git_show_result)   { Mutant::Either::Left.new('fatal: error') }
-
-      it_fails_with_message(<<~'MESSAGE')
-        Can not validate commercial license.
-        Licensed:
-        customer-a@example.com
-        customer-b@example.com
-        Present:
-        [none]
-      MESSAGE
-    end
-
-    context 'when mutant-license gem cannot be loaded' do
-      let(:load_json) { false }
-
-      def self.setup_error(message)
-        before do
-          allow(gem_method).to receive(:call).and_raise(Gem::LoadError, message)
-        end
-      end
-
-      context 'while the mutant license gem from rubygems is present' do
-        setup_error %{can't activate mutant-license (~> 0.1.0), already activated mutant-license-0.0.0.}
-
-        it_fails_with_message '[Mutant-License-Error]: mutant-license gem from rubygems.org is a dummy'
-      end
-
-      context 'with other error message' do
-        setup_error 'test-error'
-
-        it_fails_with_message '[Mutant-License-Error]: test-error'
-      end
-    end
-  end
-end