mutant 0.8.24 → 0.9.0

data/spec/unit/mutant/runner_spec.rb

@@ -2,20 +2,22 @@
 
 RSpec.describe Mutant::Runner do
   describe '.call' do
-    let(:reporter)    { instance_double(Mutant::Reporter, delay: delay) }
-    let(:driver)      { instance_double(Mutant::Parallel::Driver)       }
-    let(:delay)       { instance_double(Float)                          }
-    let(:env_result)  { instance_double(Mutant::Result::Env)            }
-    let(:actor_env)   { instance_double(Mutant::Actor::Env)             }
-    let(:kernel)      { class_double(Kernel)                            }
-    let(:sleep)       { instance_double(Method)                         }
+    let(:condition_variable) { class_double(ConditionVariable)                 }
+    let(:delay)              { instance_double(Float)                          }
+    let(:driver)             { instance_double(Mutant::Parallel::Driver)       }
+    let(:env_result)         { instance_double(Mutant::Result::Env)            }
+    let(:kernel)             { class_double(Kernel)                            }
+    let(:mutex)              { class_double(Mutex)                             }
+    let(:processor)          { instance_double(Method)                         }
+    let(:reporter)           { instance_double(Mutant::Reporter, delay: delay) }
+    let(:thread)             { class_double(Thread)                            }
 
     let(:env) do
       instance_double(
         Mutant::Env,
-        actor_env: actor_env,
         config:    config,
-        mutations: []
+        mutations: [],
+        world:     world
       )
     end
 
@@ -23,52 +25,97 @@ RSpec.describe Mutant::Runner do
       instance_double(
         Mutant::Config,
         jobs:     1,
-        kernel:   kernel,
         reporter: reporter
       )
     end
 
-    before do
-      allow(env).to receive(:method).with(:kill).and_return(parallel_config.processor)
-      allow(kernel).to receive(:method).with(:sleep).and_return(sleep)
+    let(:world) do
+      instance_double(
+        Mutant::World,
+        condition_variable: condition_variable,
+        kernel:             kernel,
+        mutex:              mutex,
+        thread:             thread
+      )
     end
 
-    let(:parallel_config) do
-      Mutant::Parallel::Config.new(
-        env:       actor_env,
-        jobs:      1,
-        processor: ->(_object) { fail },
-        sink:      Mutant::Runner::Sink.new(env),
-        source:    Mutant::Parallel::Source::Array.new(env.mutations)
+    let(:status_a) do
+      instance_double(
+        Mutant::Parallel::Status,
+        done?: false
       )
     end
 
-    before do
-      expect(reporter).to receive(:start).with(env).ordered
-      expect(Mutant::Parallel).to receive(:async).with(parallel_config).and_return(driver).ordered
+    let(:status_b) do
+      instance_double(
+        Mutant::Parallel::Status,
+        done?:   true,
+        payload: env_result
+      )
     end
 
-    subject { described_class.call(env) }
-
-    context 'when report iterations are done' do
-      let(:status_a) { instance_double(Mutant::Parallel::Status, done: false)                     }
-      let(:status_b) { instance_double(Mutant::Parallel::Status, done: true, payload: env_result) }
-
-      before do
-        expect(driver).to receive(:status).and_return(status_a).ordered
-        expect(reporter).to receive(:progress).with(status_a).ordered
-        expect(sleep).to receive(:call).with(reporter.delay).ordered
+    let(:parallel_config) do
+      Mutant::Parallel::Config.new(
+        condition_variable: condition_variable,
+        jobs:               1,
+        mutex:              mutex,
+        processor:          processor,
+        sink:               Mutant::Runner::Sink.new(env),
+        source:             Mutant::Parallel::Source::Array.new(env.mutations),
+        thread:             thread
+      )
+    end
 
-        expect(driver).to receive(:status).and_return(status_b).ordered
-        expect(reporter).to receive(:progress).with(status_b).ordered
-        expect(driver).to receive(:stop).ordered
+    def apply
+      described_class.apply(env)
+    end
 
-        expect(reporter).to receive(:report).with(env_result).ordered
-      end
+    let(:raw_expectations) do
+      [
+        {
+          receiver:  reporter,
+          selector:  :start,
+          arguments: [env]
+        },
+        {
+          receiver:  env,
+          selector:  :method,
+          arguments: [:kill],
+          reaction:  { return: processor }
+        },
+        {
+          receiver:  Mutant::Parallel,
+          selector:  :async,
+          arguments: [parallel_config],
+          reaction:  { return: driver }
+        },
+        {
+          receiver:  driver,
+          selector:  :wait_timeout,
+          arguments: [delay],
+          reaction:  { return: status_a }
+        },
+        {
+          receiver:  reporter,
+          selector:  :progress,
+          arguments: [status_a]
+        },
+        {
+          receiver:  driver,
+          selector:  :wait_timeout,
+          arguments: [delay],
+          reaction:  { return: status_b }
+        },
+        {
+          receiver:  reporter,
+          selector:  :report,
+          arguments: [env_result]
+        }
+      ]
+    end
 
-      it 'returns env result' do
-        should be(env_result)
-      end
+    it 'returns env result' do
+      verify_events { expect(apply).to eql(Mutant::Either::Right.new(env_result)) }
     end
   end
 end

data/spec/unit/mutant/selector/expression_spec.rb

@@ -4,28 +4,29 @@ RSpec.describe Mutant::Selector::Expression do
   describe '#call' do
     let(:object) { described_class.new(integration) }
 
+    let(:mutation_subject) { subject_class.new(context: context, node: node, warnings: warnings)     }
+    let(:context)          { instance_double(Mutant::Context)                                        }
+    let(:node)             { instance_double(Parser::AST::Node)                                      }
+    let(:integration)      { instance_double(Mutant::Integration, all_tests: all_tests)              }
+    let(:test_a)           { instance_double(Mutant::Test, expression: parse_expression('SubjectA')) }
+    let(:test_b)           { instance_double(Mutant::Test, expression: parse_expression('SubjectB')) }
+    let(:test_c)           { instance_double(Mutant::Test, expression: parse_expression('SubjectC')) }
+    let(:warnings)         { instance_double(Mutant::Warnings)                                       }
+
     let(:subject_class) do
       parse = method(:parse_expression)
 
       Class.new(Mutant::Subject) do
         define_method(:expression) do
-          parse.('SubjectA')
+          parse.call('SubjectA')
         end
 
         define_method(:match_expressions) do
-          [expression] << parse.('SubjectB')
+          [expression] << parse.call('SubjectB')
         end
       end
     end
 
-    let(:mutation_subject) { subject_class.new(context, node)                                        }
-    let(:context)          { instance_double(Mutant::Context)                                        }
-    let(:node)             { instance_double(Parser::AST::Node)                                      }
-    let(:integration)      { instance_double(Mutant::Integration, all_tests: all_tests)              }
-    let(:test_a)           { instance_double(Mutant::Test, expression: parse_expression('SubjectA')) }
-    let(:test_b)           { instance_double(Mutant::Test, expression: parse_expression('SubjectB')) }
-    let(:test_c)           { instance_double(Mutant::Test, expression: parse_expression('SubjectC')) }
-
     subject { object.call(mutation_subject) }
 
     context 'without available tests' do

data/spec/unit/mutant/selector/null_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Selector::Null do
+  describe '#call' do
+    subject { described_class.new }
+
+    let(:mutant_subject) { instance_double(Mutant::Subject) }
+
+    def apply
+      subject.call(mutant_subject)
+    end
+
+    it 'returns no tests' do
+      expect(apply).to eql([])
+    end
+  end
+end

data/spec/unit/mutant/subject/method/instance_spec.rb

@@ -1,7 +1,16 @@
 # frozen_string_literal: true
 
 RSpec.describe Mutant::Subject::Method::Instance do
-  let(:object)  { described_class.new(context, node) }
+  let(:object) do
+    described_class.new(
+      context:  context,
+      node:     node,
+      warnings: warnings
+    )
+  end
+
+  let(:call_block?) { true                              }
+  let(:warnings)    { instance_double(Mutant::Warnings) }
 
   let(:context) do
     Mutant::Context.new(
@@ -30,6 +39,12 @@ RSpec.describe Mutant::Subject::Method::Instance do
     end
   end
 
+  before do
+    allow(warnings).to receive(:call) do |&block|
+      block.call if call_block?
+    end
+  end
+
   describe '#expression' do
     subject { object.expression }
 
@@ -47,7 +62,6 @@ RSpec.describe Mutant::Subject::Method::Instance do
   end
 
   describe '#prepare' do
-
     let(:context) do
       Mutant::Context.new(scope, instance_double(Pathname))
     end
@@ -55,7 +69,20 @@ RSpec.describe Mutant::Subject::Method::Instance do
     subject { object.prepare }
 
     it 'undefines method on scope' do
-      expect { subject }.to change { scope.instance_methods.include?(:foo) }.from(true).to(false)
+      expect { subject }
+        .to change { scope.instance_methods.include?(:foo) }
+        .from(true)
+        .to(false)
+    end
+
+    context 'within warning capture' do
+      let(:call_block?) { false }
+
+      it 'undefines method on scope' do
+        expect { subject }
+          .to_not change { scope.instance_methods.include?(:foo) }
+          .from(true)
+      end
     end
 
     it_should_behave_like 'a command method'
@@ -69,13 +96,25 @@ RSpec.describe Mutant::Subject::Method::Instance do
 end
 
 RSpec.describe Mutant::Subject::Method::Instance::Memoized do
-  let(:object)  { described_class.new(context, node) }
-  let(:context) { double('Context')                  }
+  let(:object) do
+    described_class.new(
+      context:  context,
+      node:     node,
+      warnings: warnings
+    )
+  end
+
+  let(:context)  { double('Context')                 }
+  let(:warnings) { instance_double(Mutant::Warnings) }
 
   let(:node) do
     s(:def, :foo, s(:args))
   end
 
+  before do
+    allow(warnings).to receive(:call).and_yield
+  end
+
   describe '#prepare' do
 
     let(:context) do

data/spec/unit/mutant/subject/method/singleton_spec.rb

@@ -1,9 +1,16 @@
 # frozen_string_literal: true
 
 RSpec.describe Mutant::Subject::Method::Singleton do
+  let(:object) do
+    described_class.new(
+      context:  context,
+      node:     node,
+      warnings: warnings
+    )
+  end
 
-  let(:object)  { described_class.new(context, node) }
-  let(:node)    { s(:defs, s(:self), :foo, s(:args)) }
+  let(:node)     { s(:defs, s(:self), :foo, s(:args)) }
+  let(:warnings) { instance_double(Mutant::Warnings)  }
 
   let(:context) do
     Mutant::Context.new(scope, instance_double(Pathname))

data/spec/unit/mutant/subject_spec.rb

@@ -16,7 +16,13 @@ RSpec.describe Mutant::Subject do
     end
   end
 
-  let(:object) { class_under_test.new(context, node) }
+  let(:object) do
+    class_under_test.new(
+      context:  context,
+      node:     node,
+      warnings: warnings
+    )
+  end
 
   let(:node) do
     Unparser.parse(<<-RUBY)
@@ -32,6 +38,8 @@ RSpec.describe Mutant::Subject do
     )
   end
 
+  let(:warnings) { instance_double(Mutant::Warnings) }
+
   describe '#identification' do
     subject { object.identification }
 

data/spec/unit/mutant/transform/array_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Transform::Array do
+  subject { described_class.new(transform) }
+
+  let(:transform) { Mutant::Transform::Boolean.new }
+
+  describe '#apply' do
+    def apply
+      subject.apply(input)
+    end
+
+    context 'on array input' do
+      context 'empty' do
+        let(:input) { [] }
+
+        it 'returns sucess' do
+          expect(apply).to eql(Mutant::Either::Right.new(input))
+        end
+      end
+
+      context 'valid elements' do
+        let(:input) { [true, true] }
+
+        it 'returns sucess' do
+          expect(apply).to eql(Mutant::Either::Right.new(input))
+        end
+      end
+
+      context 'invalid elements' do
+        let(:input) { [true, 1] }
+
+        let(:boolean_error) do
+          Mutant::Transform::Error.new(
+            cause:     nil,
+            input:     1,
+            message:   'Expected: boolean but got: 1',
+            transform: transform
+          )
+        end
+
+        let(:index_error) do
+          Mutant::Transform::Error.new(
+            cause:     boolean_error,
+            input:     1,
+            message:   nil,
+            transform: Mutant::Transform::Index.new(index: 1, transform: transform)
+          )
+        end
+
+        let(:error) do
+          Mutant::Transform::Error.new(
+            cause:     index_error,
+            input:     input,
+            message:   'Failed to coerce array at index: 1',
+            transform: subject
+          )
+        end
+
+        it 'returns failure' do
+          expect(apply).to eql(Mutant::Either::Left.new(error))
+        end
+      end
+
+      context 'transformed elements' do
+        let(:input)     { [{ 'foo' => 'bar' }]                   }
+        let(:transform) { Mutant::Transform::Hash::Symbolize.new }
+
+        it 'returns transformed elements' do
+          expect(apply).to eql(Mutant::Either::Right.new([foo: 'bar']))
+        end
+      end
+    end
+
+    context 'on other input' do
+      let(:input) { false }
+
+      let(:error) do
+        Mutant::Transform::Error.new(
+          cause:     nil,
+          input:     input,
+          message:   'Expected: Array but got: FalseClass',
+          transform: subject
+        )
+      end
+
+      it 'returns failure' do
+        expect(apply).to eql(Mutant::Either::Left.new(error))
+      end
+    end
+  end
+end

data/spec/unit/mutant/transform/bool_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Transform::Boolean do
+  subject { described_class.new }
+
+  let(:primitive) { String }
+
+  describe '#apply' do
+    def apply
+      subject.apply(input)
+    end
+
+    context 'on true' do
+      let(:input) { true }
+
+      it 'returns sucess' do
+        expect(apply).to eql(Mutant::Either::Right.new(input))
+      end
+    end
+
+    context 'on false' do
+      let(:input) { false }
+
+      it 'returns sucess' do
+        expect(apply).to eql(Mutant::Either::Right.new(input))
+      end
+    end
+
+    context 'on nil input' do
+      let(:input) { nil }
+
+      let(:error) do
+        Mutant::Transform::Error.new(
+          cause:     nil,
+          input:     input,
+          message:   'Expected: boolean but got: nil',
+          transform: subject
+        )
+      end
+
+      it 'returns failure' do
+        expect(apply).to eql(Mutant::Either::Left.new(error))
+      end
+    end
+
+    context 'on truthy input' do
+      let(:input) { '' }
+
+      let(:error) do
+        Mutant::Transform::Error.new(
+          cause:     nil,
+          input:     input,
+          message:   'Expected: boolean but got: ""',
+          transform: subject
+        )
+      end
+
+      it 'returns failure' do
+        expect(apply).to eql(Mutant::Either::Left.new(error))
+      end
+    end
+  end
+end