mutant 0.9.9 → 0.9.14

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

data/spec/unit/mutant/loader_spec.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Loader, '.call' do
-  def apply
-    described_class.call(
-      binding: binding,
-      kernel:  kernel,
-      source:  source,
-      subject: mutation_subject
-    )
-  end
-
-  let(:path)     { instance_double(Pathname, to_s: path_str) }
-  let(:path_str) { instance_double(String)                   }
-  let(:line)     { instance_double(Integer)                  }
-  let(:kernel)   { class_double(Kernel)                      }
-  let(:binding)  { instance_double(Binding)                  }
-  let(:source)   { instance_double(String)                   }
-  let(:node)     { instance_double(Parser::AST::Node)        }
-
-  let(:mutation_subject) do
-    instance_double(
-      Mutant::Subject,
-      source_path: path,
-      source_line: line
-    )
-  end
-
-  before do
-    allow(kernel).to receive_messages(eval: nil)
-  end
-
-  shared_examples 'kernel eval' do
-    it 'performs eval' do
-      apply
-
-      expect(kernel).to have_received(:eval)
-        .with(
-          "# frozen_string_literal: true\n#[InstanceDouble(String) (anonymous)]",
-          binding,
-          path_str,
-          line
-        )
-    end
-  end
-
-  context 'without exception being raised' do
-    it 'returns success result' do
-      expect(apply).to be(described_class::Result::Success.instance)
-    end
-
-    include_examples 'kernel eval'
-  end
-
-  context 'with void value syntax error' do
-    before do
-      allow(kernel).to receive(:eval)
-        .and_raise(SyntaxError, '/some/path.rb:1: void value expression')
-    end
-
-    it 'returns void value result' do
-      expect(apply).to be(described_class::Result::VoidValue.instance)
-    end
-
-    include_examples 'kernel eval'
-  end
-
-  context 'with other syntax error' do
-    let(:message) { '(eval):1: some other error' }
-
-    before do
-      allow(kernel).to receive(:eval).and_raise(SyntaxError, message)
-    end
-
-    it 'raises exception' do
-      expect { apply }.to raise_error(SyntaxError, message)
-    end
-  end
-end