mutant 0.8.24 → 0.9.0

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

@@ -3,19 +3,29 @@
 RSpec.describe Mutant::Matcher::Method::Instance, '#call' do
   subject { object.call(env) }
 
-  let(:object)       { described_class.new(scope, method)                }
-  let(:method_name)  { :foo                                              }
-  let(:source_path)  { MutantSpec::ROOT.join('test_app/lib/test_app.rb') }
-  let(:method)       { scope.instance_method(method_name)                }
-  let(:type)         { :def                                              }
-  let(:method_arity) { 0                                                 }
-  let(:base)         { TestApp::InstanceMethodTests                      }
+  let(:base)          { TestApp::InstanceMethodTests                      }
+  let(:method)        { scope.instance_method(method_name)                }
+  let(:method_arity)  { 0                                                 }
+  let(:method_name)   { :foo                                              }
+  let(:object)        { described_class.new(scope, method)                }
+  let(:source_path)   { MutantSpec::ROOT.join('test_app/lib/test_app.rb') }
+  let(:type)          { :def                                              }
+  let(:warnings)      { instance_double(Mutant::Warnings)                 }
+
+  let(:world) do
+    instance_double(
+      Mutant::World,
+      pathname: Pathname,
+      warnings: warnings
+    )
+  end
 
   let(:env) do
     instance_double(
-      Mutant::Env::Bootstrap,
+      Mutant::Env,
       config: Mutant::Config::DEFAULT,
-      parser: Fixtures::TEST_ENV.parser
+      parser: Fixtures::TEST_ENV.parser,
+      world:  world
     )
   end
 
@@ -28,8 +38,9 @@ RSpec.describe Mutant::Matcher::Method::Instance, '#call' do
   end
 
   context 'when method is defined inside eval' do
-    let(:scope)  { base::WithMemoizer          }
-    let(:method) { scope.instance_method(:boz) }
+    let(:subject_class) { Mutant::Subject::Method::Instance::Memoized }
+    let(:scope)  { base::WithMemoizer                                 }
+    let(:method) { scope.instance_method(:boz)                        }
 
     let(:expected_warnings) do
       [
@@ -38,6 +49,10 @@ RSpec.describe Mutant::Matcher::Method::Instance, '#call' do
     end
 
     include_examples 'skipped candidate'
+
+    it 'returns expected subjects' do
+      expect(subject).to eql([])
+    end
   end
 
   context 'when method is defined without source location' do
@@ -51,6 +66,10 @@ RSpec.describe Mutant::Matcher::Method::Instance, '#call' do
     end
 
     include_examples 'skipped candidate'
+
+    it 'returns expected subjects' do
+      expect(subject).to eql([])
+    end
   end
 
   context 'in module eval' do
@@ -63,6 +82,10 @@ RSpec.describe Mutant::Matcher::Method::Instance, '#call' do
     end
 
     include_examples 'skipped candidate'
+
+    it 'returns expected subjects' do
+      expect(subject).to eql([])
+    end
   end
 
   context 'in class eval' do
@@ -75,6 +98,10 @@ RSpec.describe Mutant::Matcher::Method::Instance, '#call' do
     end
 
     include_examples 'skipped candidate'
+
+    it 'returns expected subjects' do
+      expect(subject).to eql([])
+    end
   end
 
   context 'when method is defined once' do
@@ -83,6 +110,23 @@ RSpec.describe Mutant::Matcher::Method::Instance, '#call' do
     let(:method_line) { 13                 }
 
     it_should_behave_like 'a method matcher'
+
+    it 'returns expected subjects' do
+      context = Mutant::Context.new(
+        TestApp::InstanceMethodTests::WithMemoizer,
+        MutantSpec::ROOT.join('test_app', 'lib', 'test_app.rb')
+      )
+
+      expect(subject).to eql(
+        [
+          Mutant::Subject::Method::Instance.new(
+            context:  context,
+            node:     s(:def, :bar, s(:args), nil),
+            warnings: warnings
+          )
+        ]
+      )
+    end
   end
 
   context 'when method is defined once with a memoizer' do

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

@@ -10,12 +10,22 @@ RSpec.describe Mutant::Matcher::Method::Singleton, '#call' do
   let(:method_arity) { 0                                                 }
   let(:base)         { TestApp::SingletonMethodTests                     }
   let(:source_path)  { MutantSpec::ROOT.join('test_app/lib/test_app.rb') }
+  let(:warnings)     { instance_double(Mutant::Warnings)                 }
+
+  let(:world) do
+    instance_double(
+      Mutant::World,
+      pathname: Pathname,
+      warnings: warnings
+    )
+  end
 
   let(:env) do
     instance_double(
-      Mutant::Env::Bootstrap,
+      Mutant::Env,
       config: Mutant::Config::DEFAULT,
-      parser: Fixtures::TEST_ENV.parser
+      parser: Fixtures::TEST_ENV.parser,
+      world:  world
     )
   end
 

data/spec/unit/mutant/matcher_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Matcher do
+  describe '.from_config' do
+    def apply
+      described_class.from_config(config)
+    end
+
+    let(:anon_matcher)       { instance_double(Mutant::Matcher)    }
+    let(:env)                { instance_double(Mutant::Env)        }
+    let(:ignore_expressions) { []                                  }
+    let(:match_expression_a) { expression('Foo::Bar#a', matcher_a) }
+    let(:match_expression_b) { expression('Foo::Bar#b', matcher_b) }
+    let(:subject_filters)    { []                                  }
+
+    let(:matcher_a) do
+      instance_double(Mutant::Matcher, call: [subject_a])
+    end
+
+    let(:matcher_b) do
+      instance_double(Mutant::Matcher, call: [subject_b])
+    end
+
+    let(:expression_class) do
+      Class.new(Mutant::Expression) do
+        include Concord.new(:child, :matcher)
+
+        %w[syntax prefix?].each do |name|
+          define_method(name) do |*arguments, &block|
+            child.public_send(name, *arguments, &block)
+          end
+        end
+
+        public :matcher
+      end
+    end
+
+    let(:config) do
+      Mutant::Matcher::Config.new(
+        ignore_expressions: ignore_expressions,
+        match_expressions:  [match_expression_a, match_expression_b],
+        subject_filters:    subject_filters
+      )
+    end
+
+    let(:subject_a) do
+      instance_double(Mutant::Subject, 'subject a', expression: expression('Foo::Bar#a'))
+    end
+
+    let(:subject_b) do
+      instance_double(Mutant::Subject, 'subject b', expression: expression('Foo::Bar#b'))
+    end
+
+    def expression(input, matcher = anon_matcher)
+      expression_class.new(parse_expression(input), matcher)
+    end
+
+    context 'empty ignores and empty filter' do
+      it 'returns expected subjects' do
+        expect(apply.call(env)).to eql([subject_a, subject_b])
+      end
+    end
+
+    context 'with ignore matching a subject' do
+      let(:ignore_expressions) { [subject_b.expression] }
+
+      it 'returns expected subjects' do
+        expect(apply.call(env)).to eql([subject_a])
+      end
+    end
+
+    context 'with ignore matching many subjects' do
+      let(:ignore_expressions) { [expression('Foo*')] }
+
+      it 'returns expected subjects' do
+        expect(apply.call(env)).to eql([])
+      end
+    end
+
+    context 'with subject filter' do
+      let(:subject_filters) do
+        [subject_a.method(:eql?)]
+      end
+
+      it 'returns expected subjects' do
+        expect(apply.call(env)).to eql([subject_a])
+      end
+    end
+
+    context 'with subject ignore and filter' do
+      let(:ignore_expressions) { [subject_b.expression] }
+
+      let(:subject_filters) do
+        [subject_b.method(:eql?)]
+      end
+
+      it 'returns expected subjects' do
+        expect(apply.call(env)).to eql([])
+      end
+    end
+  end
+end

data/spec/unit/mutant/maybe_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Maybe::Nothing do
+  subject { described_class.new }
+
+  let(:block) { -> {} }
+
+  describe '#fmap' do
+    def apply
+      subject.fmap(&block)
+    end
+
+    include_examples 'no block evaluation'
+    include_examples 'requires block'
+    include_examples 'returns self'
+  end
+
+  describe '#apply' do
+    def apply
+      subject.apply(&block)
+    end
+
+    include_examples 'no block evaluation'
+    include_examples 'requires block'
+    include_examples 'returns self'
+  end
+end
+
+RSpec.describe Mutant::Maybe::Just do
+  subject { described_class.new(value) }
+
+  let(:block_result) { instance_double(Object, 'block result') }
+  let(:value)        { instance_double(Object, 'value')        }
+  let(:yields)       { []                                      }
+
+  let(:block) do
+    lambda do |value|
+      yields << value
+      block_result
+    end
+  end
+
+  describe '#fmap' do
+    def apply
+      subject.fmap(&block)
+    end
+
+    include_examples 'requires block'
+    include_examples 'Functor#fmap block evaluation'
+  end
+
+  describe '#apply' do
+    def apply
+      subject.apply(&block)
+    end
+
+    include_examples 'requires block'
+    include_examples '#apply block evaluation'
+  end
+end

data/spec/unit/mutant/meta/example/dsl_spec.rb

@@ -23,7 +23,7 @@ RSpec.describe Mutant::Meta::Example::DSL do
 
       specify do
         # Kill mutations to warnings
-        warnings = Mutant::WarningFilter.use do
+        warnings = Mutant::WORLD.warnings.call do
           should eql(expected_example)
         end
         expect(warnings).to eql([])
@@ -78,22 +78,6 @@ RSpec.describe Mutant::Meta::Example::DSL do
       end
     end
 
-    context 'using #regexp_mutations' do
-      let(:expected) do
-        [s(:regexp, s(:regopt)), s(:regexp, s(:str, 'nomatch\\A'), s(:regopt))]
-      end
-
-      let(:node) do
-        s(:regexp, s(:str, 'foo'), s(:regopt))
-      end
-
-      expect_example do
-        source '/foo/'
-
-        regexp_mutations
-      end
-    end
-
     context 'no definition of source' do
       expect_error('source not defined') do
       end

data/spec/unit/mutant/mutation_spec.rb

@@ -24,11 +24,16 @@ RSpec.describe Mutant::Mutation do
   end
 
   describe '#insert' do
-    subject { object.insert(kernel) }
+    subject { object }
 
-    let(:expected_source) { '1'                     }
-    let(:kernel)          { instance_double(Kernel) }
-    let(:root_node)       { s(:int, 1)              }
+    def apply
+      subject.insert(kernel)
+    end
+
+    let(:expected_source) { '1'                                     }
+    let(:kernel)          { instance_double(Kernel)                 }
+    let(:loader_result)   { instance_double(Mutant::Loader::Result) }
+    let(:root_node)       { s(:int, 1)                              }
 
     before do
       expect(context).to receive(:root)
@@ -47,10 +52,12 @@ RSpec.describe Mutant::Mutation do
           source:  expected_source,
           subject: mutation_subject
         )
-        .and_return(Mutant::Loader)
+        .and_return(loader_result)
     end
 
-    it_should_behave_like 'a command method'
+    it 'returns loader result' do
+      expect(apply).to be(loader_result)
+    end
   end
 
   describe '#code' do

data/spec/unit/mutant/parallel/driver_spec.rb

@@ -1,28 +1,126 @@
 # frozen_string_literal: true
 
 RSpec.describe Mutant::Parallel::Driver do
-  let(:object) { described_class.new(binding) }
+  let(:active_jobs) { []                                    }
+  let(:thread_a)    { instance_double(Thread, alive?: true) }
+  let(:thread_b)    { instance_double(Thread, alive?: true) }
+  let(:threads)     { [thread_a, thread_b]                  }
+  let(:timeout)     { instance_double(Float)                }
+  let(:sink_status) { instance_double(Object)               }
 
-  let(:binding) { instance_double(Mutant::Actor::Binding) }
-  let(:value)   { instance_double(Object, 'value')        }
+  let(:sink) do
+    instance_double(
+      Mutant::Parallel::Sink,
+      status: sink_status
+    )
+  end
 
-  describe '#stop' do
-    subject { object.stop }
+  let(:var_active_jobs) do
+    instance_double(Mutant::Variable::IVar, 'active jobs')
+  end
 
-    before do
-      expect(binding).to receive(:call).with(:stop)
-    end
+  let(:var_final) do
+    instance_double(Mutant::Variable::IVar, 'final')
+  end
+
+  let(:var_sink) do
+    instance_double(Mutant::Variable::IVar, 'sink')
+  end
 
-    it_should_behave_like 'a command method'
+  subject do
+    described_class.new(
+      threads:         threads,
+      var_active_jobs: var_active_jobs,
+      var_final:       var_final,
+      var_sink:        var_sink
+    )
   end
 
-  describe '#status' do
-    subject { object.status }
+  describe '#wait_timeout' do
+    def apply
+      subject.wait_timeout(timeout)
+    end
+
+    shared_examples 'returns expected status' do
+      it 'returns expected status' do
+        verify_events do
+          expect(apply).to eql(expected_status)
+        end
+      end
 
-    before do
-      expect(binding).to receive(:call).with(:status).and_return(value)
+      it 'returns frozen copy of active jobs' do
+        verify_events do
+          returned_active_jobs = apply.active_jobs
+
+          expect(returned_active_jobs).to_not be(active_jobs)
+          expect(returned_active_jobs.frozen?).to be(true)
+        end
+      end
     end
 
-    it { should be(value) }
+    let(:raw_expectations) do
+      [
+        {
+          receiver:  var_final,
+          selector:  :take_timeout,
+          arguments: [timeout],
+          reaction:  { return: Mutant::Variable.const_get(:Result)::Timeout.new }
+        },
+        {
+          receiver: var_active_jobs,
+          selector: :with,
+          reaction: { yields: [active_jobs] }
+        },
+        {
+          receiver: var_sink,
+          selector: :with,
+          reaction: { yields: [sink] }
+        }
+      ]
+    end
+
+    context 'when not done' do
+      let(:expected_status) do
+        Mutant::Parallel::Status.new(
+          active_jobs: active_jobs,
+          done:        false,
+          payload:     sink_status
+        )
+      end
+
+      include_examples 'returns expected status'
+    end
+
+    context 'when done' do
+      before do
+        allow(thread_a).to receive_messages(alive?: false)
+        allow(thread_b).to receive_messages(alive?: false)
+      end
+
+      let(:raw_expectations) do
+        [
+          *super(),
+          {
+            receiver: thread_a,
+            selector: :join
+          },
+          {
+            receiver: thread_b,
+            selector: :join
+          }
+        ]
+
+      end
+
+      let(:expected_status) do
+        Mutant::Parallel::Status.new(
+          active_jobs: active_jobs,
+          done:        true,
+          payload:     sink_status
+        )
+      end
+
+      include_examples 'returns expected status'
+    end
   end
 end