mutant 0.8.24 → 0.9.0

data/spec/unit/mutant/cli_spec.rb

@@ -1,41 +1,98 @@
 # frozen_string_literal: true
 
 RSpec.describe Mutant::CLI do
-  let(:object) { described_class }
+  let(:default_config) { Mutant::Config::DEFAULT                        }
+  let(:kernel)         { instance_double('kernel', exit: undefined)     }
+  let(:stderr)         { instance_double(IO, 'stderr', puts: undefined) }
+  let(:stdout)         { instance_double(IO, 'stdout', puts: undefined) }
+  let(:target_stream)  { stdout                                         }
+
+  let(:world) do
+    instance_double(
+      Mutant::World,
+      kernel: kernel,
+      stderr: stderr,
+      stdout: stdout
+    )
+  end
+
+  shared_examples 'prints expected message' do
+
+    it 'prints expected message' do
+      apply
 
-  shared_examples_for 'an invalid cli run' do
-    it 'raises error' do
-      expect do
-        subject
-      end.to raise_error(Mutant::CLI::Error, expected_message)
+      expect(target_stream).to have_received(:puts).with(expected_message)
     end
   end
 
-  shared_examples_for 'a cli parser' do
-    it { expect(subject.config.integration).to eql(expected_integration) }
-    it { expect(subject.config.reporter).to eql(expected_reporter)       }
-    it { expect(subject.config.matcher).to eql(expected_matcher_config)  }
+  before do
+    allow(stderr).to receive_messages(puts: undefined)
+    allow(stdout).to receive_messages(puts: undefined)
   end
 
   describe '.run' do
-    subject { object.run(arguments) }
+    def apply
+      described_class.run(world, default_config, arguments)
+    end
 
-    let(:arguments) { instance_double(Array)                                         }
-    let(:report)    { instance_double(Mutant::Result::Env, success?: report_success) }
-    let(:config)    { instance_double(Mutant::Config)                                }
-    let(:env)       { instance_double(Mutant::Env)                                   }
+    let(:arguments)      { instance_double(Array)                         }
+    let(:cli_config)     { instance_double(Mutant::Config, 'cli config')  }
+    let(:cli_result)     { Mutant::Either::Right.new(cli_config)          }
+    let(:env)            { instance_double(Mutant::Env)                   }
+    let(:env_result)     { Mutant::Either::Right.new(env)                 }
+    let(:file_config)    { instance_double(Mutant::Config, 'file config') }
+    let(:file_result)    { Mutant::Either::Right.new(file_config)         }
+    let(:license_result) { Mutant::Either::Right.new(true)                }
+    let(:report_success) { true                                           }
+
+    let(:runner_result) do
+      Mutant::Either::Right.new(
+        instance_double(Mutant::Result::Env, success?: report_success)
+      )
+    end
 
     before do
-      expect(Mutant::CLI).to receive(:call).with(arguments).and_return(config)
-      expect(Mutant::Env::Bootstrap).to receive(:call).with(config).and_return(env)
-      expect(Mutant::Runner).to receive(:call).with(env).and_return(report)
+      allow(Mutant::License).to receive_messages(apply: license_result)
+      allow(Mutant::Config).to receive_messages(load_config_file: file_result)
+      allow(Mutant::CLI).to receive_messages(apply: cli_result)
+      allow(Mutant::Bootstrap).to receive_messages(apply: env_result)
+      allow(Mutant::Runner).to receive_messages(apply: runner_result)
+    end
+
+    it 'performs calls in expected sequence' do
+      apply
+
+      expect(Mutant::License)
+        .to have_received(:apply)
+        .with(world)
+        .ordered
+
+      expect(Mutant::Config)
+        .to have_received(:load_config_file)
+        .with(world, default_config)
+        .ordered
+
+      expect(Mutant::CLI)
+        .to have_received(:apply)
+        .with(world, file_config, arguments)
+        .ordered
+
+      expect(Mutant::Bootstrap)
+        .to have_received(:apply)
+        .with(world, cli_config)
+        .ordered
+
+      expect(Mutant::Runner)
+        .to have_received(:apply)
+        .with(env)
+        .ordered
     end
 
     context 'when report signals success' do
       let(:report_success) { true }
 
       it 'exits failure' do
-        expect(subject).to be(true)
+        expect(apply).to be(true)
       end
     end
 
@@ -43,70 +100,78 @@ RSpec.describe Mutant::CLI do
       let(:report_success) { false }
 
       it 'exits failure' do
-        expect(subject).to be(false)
+        expect(apply).to be(false)
       end
     end
 
-    context 'when execution raises an Mutant::CLI::Error' do
-      let(:exception) { Mutant::CLI::Error.new('test-error') }
-      let(:report_success) { nil }
+    context 'when parts of the chain fail' do
+      let(:cli_result)       { Mutant::Either::Left.new(expected_message) }
+      let(:expected_message) { 'cli-error'                                }
+      let(:target_stream)    { stderr                                     }
 
-      before do
-        expect(report).to receive(:success?).and_raise(exception)
-      end
+      include_examples 'prints expected message'
 
       it 'exits failure' do
-        expect($stderr).to receive(:puts).with('test-error')
-        expect(subject).to be(false)
+        expect(apply).to be(false)
       end
     end
   end
 
-  describe '.new' do
-    let(:object) { described_class }
+  describe '.apply' do
+    def apply
+      described_class.apply(world, default_config, arguments)
+    end
 
-    subject { object.new(arguments) }
+    shared_examples 'invalid arguments' do
+      it 'returns left error' do
+        expect(apply).to eql(Mutant::Either::Left.new(expected_message))
+      end
+    end
 
-    # Defaults
-    let(:expected_integration)    { Mutant::Integration::Null        }
-    let(:expected_reporter)       { Mutant::Config::DEFAULT.reporter }
-    let(:expected_matcher_config) { default_matcher_config           }
+    shared_examples 'explicit exit' do
+      it 'prints explicitly exits' do
+        apply
 
-    let(:default_matcher_config) do
-      Mutant::Matcher::Config::DEFAULT
-        .with(match_expressions: expressions.map(&method(:parse_expression)))
+        expect(kernel).to have_received(:exit)
+      end
     end
 
-    let(:flags)       { []           }
-    let(:expressions) { %w[TestApp*] }
+    shared_examples 'no explicit exit' do
+      it 'does not exit' do
+        expect(kernel).to_not have_received(:exit)
+      end
+    end
 
-    let(:arguments) { flags + expressions }
+    shared_examples_for 'cli parser' do
+      it { expect(apply.from_right.integration).to eql(expected_integration) }
+      it { expect(apply.from_right.matcher).to eql(expected_matcher_config)  }
+    end
 
-    context 'with unknown flag' do
-      let(:flags) { %w[--invalid] }
+    before do
+      allow(kernel).to receive_messages(exit: nil)
+    end
 
-      let(:expected_message) { 'invalid option: --invalid' }
+    let(:arguments)               { (options + expressions).freeze }
+    let(:expected_integration)    { 'null'                         }
+    let(:expected_matcher_config) { default_matcher_config         }
+    let(:expressions)             { %w[TestApp*]                   }
+    let(:options)                 { []                             }
 
-      it_should_behave_like 'an invalid cli run'
+    let(:default_matcher_config) do
+      Mutant::Matcher::Config::DEFAULT
+        .with(match_expressions: expressions.map(&method(:parse_expression)))
     end
 
-    context 'with unknown option' do
-      let(:flags) { %w[--invalid Foo] }
-
+    context 'with --invalid option' do
+      let(:options)          { %w[--invalid]               }
       let(:expected_message) { 'invalid option: --invalid' }
 
-      it_should_behave_like 'an invalid cli run'
+      include_examples 'invalid arguments'
+      include_examples 'no explicit exit'
     end
 
-    context 'with include help flag' do
-      let(:flags) { %w[--help] }
-
-      before do
-        expect($stdout).to receive(:puts).with(expected_message)
-        expect(Kernel).to receive(:exit)
-      end
-
-      it_should_behave_like 'a cli parser'
+    context 'with --help option' do
+      let(:options) { %w[--help] }
 
       let(:expected_message) do
         <<~MESSAGE
@@ -126,123 +191,114 @@ RSpec.describe Mutant::CLI do
               -h, --help                       Show this message
         MESSAGE
       end
+
+      include_examples 'cli parser'
+      include_examples 'explicit exit'
+      include_examples 'prints expected message'
     end
 
-    context 'with include flag' do
-      let(:flags) { %w[--include foo] }
+    context 'with --include option' do
+      let(:options) { %w[--include foo] }
 
-      it_should_behave_like 'a cli parser'
+      include_examples 'cli parser'
+      include_examples 'no explicit exit'
 
       it 'configures includes' do
-        expect(subject.config.includes).to eql(%w[foo])
+        expect(apply.from_right.includes).to eql(%w[foo])
       end
     end
 
-    context 'with use flag' do
+    context 'with --use option' do
       context 'when integration exists' do
-        let(:flags) { %w[--use rspec] }
-
-        before do
-          expect(Kernel).to receive(:require)
-            .with('mutant/integration/rspec')
-            .and_call_original
-        end
+        let(:expected_integration) { 'some'         }
+        let(:options)              { %w[--use some] }
 
-        it_should_behave_like 'a cli parser'
-
-        let(:expected_integration) { Mutant::Integration::Rspec }
-      end
-
-      context 'when integration does NOT exist' do
-        let(:flags) { %w[--use other] }
-
-        it 'raises error' do
-          expect { subject }.to raise_error(
-            Mutant::CLI::Error,
-            'Could not load integration "other" (you may want to try installing the gem mutant-other)'
-          )
-        end
+        include_examples 'cli parser'
+        include_examples 'no explicit exit'
       end
     end
 
-    context 'with version flag' do
-      let(:flags) { %w[--version] }
-
-      before do
-        expect(Kernel).to receive(:exit)
-        expect($stdout).to receive(:puts).with("mutant-#{Mutant::VERSION}")
-      end
+    context 'with --version option' do
+      let(:expected_message) { "mutant-#{Mutant::VERSION}" }
+      let(:options)          { %w[--version]               }
 
-      it_should_behave_like 'a cli parser'
+      include_examples 'cli parser'
+      include_examples 'explicit exit'
+      include_examples 'prints expected message'
     end
 
-    context 'with jobs flag' do
-      let(:flags) { %w[--jobs 0] }
+    context 'with --jobs option' do
+      let(:options) { %w[--jobs 0] }
 
-      it_should_behave_like 'a cli parser'
+      include_examples 'cli parser'
+      include_examples 'no explicit exit'
 
       it 'configures expected coverage' do
-        expect(subject.config.jobs).to eql(0)
+        expect(apply.from_right.jobs).to eql(0)
       end
     end
 
-    context 'with require flags' do
-      let(:flags) { %w[--require foo --require bar] }
+    context 'with --require options' do
+      let(:options) { %w[--require foo --require bar] }
 
-      it_should_behave_like 'a cli parser'
+      include_examples 'cli parser'
+      include_examples 'no explicit exit'
 
       it 'configures requires' do
-        expect(subject.config.requires).to eql(%w[foo bar])
+        expect(apply.from_right.requires).to eql(%w[foo bar])
       end
     end
 
-    context 'with --since flag' do
-      let(:flags) { %w[--since master] }
+    context 'with --since option' do
+      let(:options) { %w[--since master] }
 
       let(:expected_matcher_config) do
         default_matcher_config.with(
           subject_filters: [
             Mutant::Repository::SubjectFilter.new(
               Mutant::Repository::Diff.new(
-                config: Mutant::Config::DEFAULT,
-                from:   'HEAD',
-                to:     'master'
+                to:    'master',
+                world: world
               )
             )
           ]
         )
       end
 
-      it_should_behave_like 'a cli parser'
+      include_examples 'cli parser'
+      include_examples 'no explicit exit'
     end
 
-    context 'with subject-ignore flag' do
-      let(:flags) { %w[--ignore-subject Foo::Bar] }
+    context 'with --subject-ignore option' do
+      let(:options) { %w[--ignore-subject Foo::Bar] }
 
       let(:expected_matcher_config) do
         default_matcher_config.with(ignore_expressions: [parse_expression('Foo::Bar')])
       end
 
-      it_should_behave_like 'a cli parser'
+      include_examples 'cli parser'
+      include_examples 'no explicit exit'
     end
 
-    context 'with fail-fast flag' do
-      let(:flags) { %w[--fail-fast] }
+    context 'with --fail-fast option' do
+      let(:options) { %w[--fail-fast] }
 
-      it_should_behave_like 'a cli parser'
+      include_examples 'cli parser'
+      include_examples 'no explicit exit'
 
       it 'sets the fail fast option' do
-        expect(subject.config.fail_fast).to be(true)
+        expect(apply.from_right.fail_fast).to be(true)
       end
     end
 
-    context 'with zombie flag' do
-      let(:flags) { %w[--zombie] }
+    context 'with --zombie option' do
+      let(:options) { %w[--zombie] }
 
-      it_should_behave_like 'a cli parser'
+      include_examples 'cli parser'
+      include_examples 'no explicit exit'
 
       it 'sets the zombie option' do
-        expect(subject.config.zombie).to be(true)
+        expect(apply.from_right.zombie).to be(true)
       end
     end
   end

data/spec/unit/mutant/config_spec.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Config do
+  describe '.load_config_file' do
+    def apply
+      described_class.load_config_file(world, config)
+    end
+
+    let(:config) { Mutant::Config::DEFAULT                            }
+    let(:world)  { instance_double(Mutant::World, pathname: pathname) }
+
+    let(:pathname) do
+      paths = paths()
+      Class.new do
+        define_singleton_method(:new, &paths.method(:fetch))
+      end
+    end
+
+    let(:config_mutant_yml) do
+      instance_double(Pathname, 'config/mutant.yml', readable?: false)
+    end
+
+    let(:dot_mutant_yml) do
+      instance_double(Pathname, '.mutant.yml', readable?: false)
+    end
+
+    let(:mutant_yml) do
+      instance_double(Pathname, 'mutant.yml', readable?: false)
+    end
+
+    let(:paths) do
+      {
+        '.mutant.yml'       => dot_mutant_yml,
+        'config/mutant.yml' => config_mutant_yml,
+        'mutant.yml'        => mutant_yml
+      }
+    end
+
+    before do
+      allow(Pathname).to receive(:new, &paths.method(:fetch))
+    end
+
+    context 'when no path is readable' do
+      it 'returns original config' do
+        expect(apply).to eql(Mutant::Either::Right.new(config))
+      end
+    end
+
+    context 'when more than one path is readable' do
+      before do
+        [config_mutant_yml, mutant_yml].each do |path|
+          allow(path).to receive_messages(readable?: true)
+        end
+      end
+
+      let(:expected_message) do
+        <<~MESSAGE
+          Found more than one candidate for use as implicit config file: #{config_mutant_yml}, #{mutant_yml}
+        MESSAGE
+      end
+
+      it 'returns expected failure' do
+        expect(apply).to eql(Mutant::Either::Left.new(expected_message))
+      end
+    end
+
+    context 'with one readable path' do
+      let(:path_contents) do
+        <<~'YAML'
+          ---
+          integration: rspec
+        YAML
+      end
+
+      before do
+        allow(mutant_yml).to receive_messages(
+          read:      path_contents,
+          readable?: true,
+          to_s:      'mutant.yml'
+        )
+      end
+
+      context 'when file can be read' do
+        context 'when yaml contents can be transformed' do
+          it 'returns expected config' do
+            expect(apply)
+              .to eql(Mutant::Either::Right.new(config.with(integration: 'rspec')))
+          end
+        end
+
+        context 'when yaml contents cannot be transformed' do
+          let(:path_contents) do
+            <<~'YAML'
+              ---
+              integration: true
+            YAML
+          end
+
+          # rubocop:disable Metrics/LineLength
+          let(:expected_message) do
+            'mutant.yml/Mutant::Transform::Sequence/2/Mutant::Transform::Hash/["integration"]/String: Expected: String but got: TrueClass'
+          end
+          # rubocop:enable Metrics/LineLength
+
+          it 'returns expected error' do
+            expect(apply) .to eql(Mutant::Either::Left.new(expected_message))
+          end
+        end
+      end
+
+      context 'when file cannot be read' do
+        before do
+          allow(mutant_yml).to receive(:read).and_raise(SystemCallError, 'some error')
+        end
+
+        let(:expected_message) do
+          'mutant.yml/Mutant::Transform::Sequence/0/Mutant::Transform::Exception: unknown error - some error'
+        end
+
+        it 'returns expected error' do
+          expect(apply) .to eql(Mutant::Either::Left.new(expected_message))
+        end
+      end
+    end
+  end
+end