mutant 0.8.24 → 0.9.0

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

@@ -25,7 +25,7 @@ RSpec.describe Mutant::Isolation::Result do
     end
   end
 
-  describe 'add_error' do
+  describe '#add_error' do
     let(:other)  { described_class::Success.new(object) }
     let(:value)  { double('Object')                     }
     let(:object) { described_class::Success.new(value)  }
@@ -38,4 +38,36 @@ RSpec.describe Mutant::Isolation::Result 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

@@ -0,0 +1,257 @@
+# 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_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(: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,
+      json:     json,
+      kernel:   kernel,
+      pathname: pathname,
+      stderr:   stderr
+    )
+  end
+
+  before do
+    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(stderr)
+        .to have_received(:puts)
+        .with(expected)
+        .ordered
+
+      expect(stderr)
+        .to have_received(:puts)
+        .with('Soft fail, continuing in 10 seconds')
+        .ordered
+
+      expect(kernel)
+        .to have_received(:sleep)
+        .with(10)
+        .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
+  end
+end

data/spec/unit/mutant/loader_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 RSpec.describe Mutant::Loader, '.call' do
-  subject do
+  def apply
     described_class.call(
       binding: binding,
       kernel:  kernel,
@@ -12,7 +12,7 @@ RSpec.describe Mutant::Loader, '.call' do
 
   let(:path)     { instance_double(Pathname, to_s: path_str) }
   let(:path_str) { instance_double(String)                   }
-  let(:line)     { instance_double(0.class)                  }
+  let(:line)     { instance_double(Integer)                  }
   let(:kernel)   { class_double(Kernel)                      }
   let(:binding)  { instance_double(Binding)                  }
   let(:source)   { instance_double(String)                   }
@@ -26,15 +26,54 @@ RSpec.describe Mutant::Loader, '.call' do
     )
   end
 
-  it 'performs expected kernel interaction' do
-    expect(kernel).to receive(:eval)
-      .with(
-        "# frozen_string_literal: true\n#[InstanceDouble(String) (anonymous)]",
-        binding,
-        path_str,
-        line
-      )
+  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
 
-    subject
+    it 'raises exception' do
+      expect { apply }.to raise_error(SyntaxError, message)
+    end
   end
 end

data/spec/unit/mutant/matcher/compiler_spec.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Matcher::Compiler, '#call' do
-  let(:object)         { described_class                  }
-  let(:matcher_config) { Mutant::Matcher::Config::DEFAULT }
-  let(:expression_a)   { parse_expression('Foo*')         }
-  let(:expression_b)   { parse_expression('Bar*')         }
-  let(:matcher_a)      { expression_a.matcher             }
-
-  let(:expected_matcher) do
-    Mutant::Matcher::Filter.new(
-      expected_positive_matcher,
-      expected_predicate
-    )
-  end
-
-  let(:expected_predicate) do
-    Morpher.compile(s(:and, s(:negate, s(:or)), s(:and)))
-  end
-
-  subject { object.call(matcher_config.with(attributes)) }
-
-  context 'on empty config' do
-    let(:attributes) { {} }
-
-    let(:expected_positive_matcher) { Mutant::Matcher::Chain.new([]) }
-
-    it { should eql(expected_matcher) }
-  end
-
-  context 'on config with match expression' do
-    let(:expected_predicate) do
-      Morpher::Evaluator::Predicate::Boolean::And.new(
-        [
-          Morpher::Evaluator::Predicate::Negation.new(
-            Morpher::Evaluator::Predicate::Boolean::Or.new(ignore_expression_predicates)
-          ),
-          Morpher::Evaluator::Predicate::Boolean::And.new(subject_filter_predicates)
-        ]
-      )
-    end
-
-    let(:expected_positive_matcher)    { Mutant::Matcher::Chain.new([matcher_a]) }
-    let(:attributes)                   { { match_expressions: [expression_a] }   }
-    let(:ignore_expression_predicates) { []                                      }
-    let(:subject_filter_predicates)    { []                                      }
-
-    context 'and no other constraints' do
-      it { should eql(expected_matcher) }
-    end
-
-    context 'and ignore expressions' do
-      let(:attributes) do
-        super().merge(ignore_expressions: [expression_b])
-      end
-
-      let(:ignore_expression_predicates) do
-        [Mutant::Matcher::Compiler::SubjectPrefix.new(expression_b)]
-      end
-
-      it { should eql(expected_matcher) }
-    end
-
-    context 'and subject filters' do
-      let(:subject_filter) { instance_double(Mutant::Matcher) }
-
-      let(:attributes) do
-        super().merge(subject_filters: [subject_filter])
-      end
-
-      let(:subject_filter_predicates) do
-        [subject_filter]
-      end
-
-      it { should eql(expected_matcher) }
-    end
-  end
-end