mutant 0.5.24 → 0.5.25

data/spec/unit/mutant/expression/namespace/flat_spec.rb

@@ -9,7 +9,7 @@ describe Mutant::Expression::Namespace::Exact do
   describe '#matcher' do
     subject { object.matcher(cache) }
 
-    it { should eql(Mutant::Matcher::Scope.new(cache, TestApp::Literal)) }
+    it { should eql(Mutant::Matcher::Scope.new(cache, TestApp::Literal, object)) }
   end
 
   describe '#match_length' do

data/spec/unit/mutant/expression_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Mutant::Expression do
+  let(:object) { described_class }
+
+  describe '.try_parse' do
+    subject { object.try_parse(input) }
+
+    context 'on nonsense' do
+      let(:input) { 'foo bar' }
+
+      it { should be(nil) }
+    end
+
+    context 'on a valid expression' do
+      let(:input) { 'Foo' }
+
+      it { should eql(Mutant::Expression::Namespace::Exact.new('Foo')) }
+    end
+
+    context 'on ambigious expression' do
+      class ExpressionA < Mutant::Expression
+        register(/\Atest-syntax\z/)
+      end
+
+      class ExpressionB < Mutant::Expression
+        register(/^test-syntax$/)
+      end
+
+      let(:input) { 'test-syntax' }
+
+      it 'raises an exception' do
+        expect { subject }.to raise_error(Mutant::Expression::AmbigousExpressionError, 'Ambigous expression: "test-syntax"')
+      end
+    end
+  end
+
+  describe '.parse' do
+    subject { object.parse(input) }
+
+    context 'on nonsense' do
+      let(:input) { 'foo bar' }
+
+      it 'raises an exception' do
+        expect { subject }.to raise_error(Mutant::Expression::InvalidExpressionError, 'Expression: "foo bar" is not valid')
+      end
+    end
+
+    context 'on a valid expression' do
+      let(:input) { 'Foo' }
+
+      it { should eql(Mutant::Expression::Namespace::Exact.new('Foo')) }
+    end
+  end
+end

data/spec/unit/mutant/integration_spec.rb

@@ -8,11 +8,6 @@ describe Mutant::Integration do
 
   let(:object) { class_under_test.new }
 
-  describe '#teardown' do
-    subject { object.teardown }
-    it_should_behave_like 'a command method'
-  end
-
   describe '#setup' do
     subject { object.setup }
     it_should_behave_like 'a command method'

data/spec/unit/mutant/isolation_spec.rb

@@ -1,18 +1,49 @@
 require 'spec_helper'
 
-describe Mutant::Isolation do
+describe Mutant::Isolation::None do
+  before do
+    @initial = 1
+  end
+
+  describe '.run' do
+    let(:object) { described_class }
+
+    it 'does not isolate side effects' do
+      object.call { @initial = 2 }
+      expect(@initial).to be(2)
+    end
+
+    it 'return block value' do
+      expect(object.call { :foo }).to be(:foo)
+    end
+
+    it 'wraps *all* exceptions' do
+      expect { object.call { fail  } }.to raise_error(Mutant::Isolation::Error)
+    end
+
+  end
+end
+
+describe Mutant::Isolation::Fork do
+  before do
+    @initial = 1
+  end
+
   describe '.run' do
     let(:object) { described_class }
 
-    it 'isolates global effects from process' do
-      expect(defined?(::TestConstant)).to be(nil)
-      object.call { ::TestConstant = 1 }
-      expect(defined?(::TestConstant)).to be(nil)
+    it 'does isolate side effects' do
+      object.call { @initial = 2  }
+      expect(@initial).to be(1)
     end
 
     it 'return block value' do
       expect(object.call { :foo }).to be(:foo)
     end
 
+    it 'wraps Parallel::DeadWorker exceptions' do
+      expect { object.call { fail Parallel::DeadWorker } }.to raise_error(Mutant::Isolation::Error)
+    end
+
   end
 end

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

@@ -5,6 +5,7 @@ describe Mutant::Matcher::Chain do
   let(:object) { described_class.new(matchers) }
 
   describe '#each' do
+    let(:yields) { [] }
     subject { object.each { |entry| yields << entry } }
 
     let(:matchers) { [matcher_a, matcher_b] }
@@ -26,21 +27,8 @@ describe Mutant::Matcher::Chain do
       end
     end
 
-    let(:yields) { [] }
-
     it 'should yield subjects' do
       expect { subject }.to change { yields }.from([]).to([subject_a, subject_b])
     end
   end
-
-  describe '#matchers' do
-    subject { object.matchers }
-
-    let(:matchers) { double('Matchers')            }
-
-    it { should be(matchers) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
 end

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

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Mutant::Matcher::Compiler do
+  let(:object) { described_class }
+
+  let(:env) { Fixtures::TEST_ENV }
+
+  let(:expression_a) { Mutant::Expression.parse('Foo*') }
+  let(:expression_b) { Mutant::Expression.parse('Bar*') }
+
+  let(:matcher_a) { expression_a.matcher(env) }
+  let(:matcher_b) { expression_b.matcher(env) }
+
+  let(:expected_matcher) do
+    Mutant::Matcher::Filter.new(expected_positive_matcher, expected_predicate)
+  end
+
+  let(:expected_predicate) do
+    Morpher.compile(s(:true))
+  end
+
+  describe '.call' do
+    subject { object.call(env, matcher_config.update(attributes)) }
+
+    let(:matcher_config) { Mutant::Matcher::Config::DEFAULT }
+
+    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
+      context 'and no filter' do
+        let(:attributes) do
+          { match_expressions: [expression_a] }
+        end
+
+        let(:expected_positive_matcher) { Mutant::Matcher::Chain.new([matcher_a]) }
+
+        it { should eql(expected_matcher) }
+      end
+
+      context 'and a subject filter' do
+        let(:attributes) do
+          {
+            match_expressions: [expression_a],
+            subject_ignores:   [expression_b]
+          }
+        end
+
+        let(:expected_positive_matcher) { Mutant::Matcher::Chain.new([matcher_a]) }
+
+        let(:expected_predicate) do
+          Morpher::Evaluator::Predicate::Negation.new(
+            Morpher::Evaluator::Predicate::Boolean::Or.new([
+              described_class::SubjectPrefix.new(expression_b)
+            ])
+          )
+        end
+
+        it { should eql(expected_matcher) }
+      end
+
+      context 'and an attribute filter' do
+        let(:attributes) do
+          {
+            match_expressions: [expression_a],
+            subject_selects:   [[:code, 'foo']]
+          }
+        end
+
+        let(:expected_positive_matcher) { Mutant::Matcher::Chain.new([matcher_a]) }
+
+        let(:expected_predicate) do
+          Morpher::Evaluator::Predicate::Boolean::Or.new([
+            Morpher.compile(s(:eql, s(:attribute, :code), s(:static, 'foo')))
+          ])
+        end
+
+        it { should eql(expected_matcher) }
+      end
+    end
+
+    context 'on config with multiple match expressions' do
+      let(:attributes) do
+        { match_expressions: [expression_a, expression_b] }
+      end
+
+      let(:expected_positive_matcher) { Mutant::Matcher::Chain.new([matcher_a, matcher_b]) }
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Mutant::Matcher::Filter do
+  let(:object) { described_class.new(matcher, predicate) }
+
+  describe '#each' do
+    let(:yields) { [] }
+    subject { object.each { |entry| yields << entry } }
+
+    let(:matcher)   { [subject_a, subject_b] }
+    let(:predicate) { ->(subject) { subject.eql?(subject_a) } }
+
+    let(:subject_a) { double('Subject A') }
+    let(:subject_b) { double('Subject B') }
+
+    # it_should_behave_like 'an #each method'
+    context 'with no block' do
+      subject { object.each }
+
+      it { should be_instance_of(to_enum.class) }
+
+      it 'yields the expected values' do
+        expect(subject.to_a).to eql(object.to_a)
+      end
+    end
+
+    it 'should yield subjects' do
+      expect { subject }.to change { yields }.from([]).to([subject_a])
+    end
+  end
+end

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

@@ -3,12 +3,13 @@ require 'spec_helper'
 # rubocop:disable ClassAndModuleChildren
 describe Mutant::Matcher::Method::Instance do
 
-  let(:env) { Fixtures::BOOT_ENV }
+  let(:env)      { Fixtures::TEST_ENV             }
+  let(:reporter) { Fixtures::TEST_CONFIG.reporter }
 
   describe '#each' do
     subject { object.each { |subject| yields << subject } }
 
-    let(:object)       { described_class.new(env, scope, method) }
+    let(:object)       { described_class.build(env, scope, method) }
     let(:method)       { scope.instance_method(method_name)        }
     let(:yields)       { []                                        }
     let(:namespace)    { self.class                                }
@@ -25,6 +26,23 @@ describe Mutant::Matcher::Method::Instance do
       node.children[1]
     end
 
+    context 'when method is defined without source location' do
+      let(:scope) { Module }
+      let(:method) { scope.instance_method(:object_id) }
+
+      it 'does not emit matcher' do
+        subject
+        expect(yields.length).to be(0)
+      end
+
+      it 'does warn' do
+        subject
+        expect(reporter.warn_calls.last).to(
+          eql("#{method.inspect} does not have valid source location unable to emit matcher")
+        )
+      end
+    end
+
     context 'when method is defined once' do
       let(:base) { __LINE__ }
       class self::Foo
@@ -36,6 +54,19 @@ describe Mutant::Matcher::Method::Instance do
       it_should_behave_like 'a method matcher'
     end
 
+    context 'when method is defined once with a memoizer' do
+      let(:base) { __LINE__ }
+      class self::Foo
+        def bar; end
+        include Adamantium
+        memoize :bar
+      end
+
+      let(:method_line) { 2 }
+
+      it_should_behave_like 'a method matcher'
+    end
+
     context 'when method is defined multiple times' do
       context 'on differend lines' do
         let(:base) { __LINE__ }

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

@@ -6,7 +6,7 @@ describe Mutant::Matcher::Method::Singleton, '#each' do
 
   let(:object)       { described_class.new(env, scope, method) }
   let(:method)       { scope.method(method_name)               }
-  let(:env)          { Fixtures::BOOT_ENV                      }
+  let(:env)          { Fixtures::TEST_ENV                      }
   let(:yields)       { []                                      }
   let(:namespace)    { self.class                              }
   let(:scope)        { self.class::Foo                         }

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Mutant::Matcher::Methods::Instance, '#each' do
   let(:object) { described_class.new(env, Foo) }
-  let(:env)    { Fixtures::BOOT_ENV            }
+  let(:env)    { Fixtures::TEST_ENV            }
 
   subject { object.each { |matcher| yields << matcher } }
 

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Mutant::Matcher::Methods::Singleton, '#each' do
   let(:object) { described_class.new(env, Foo) }
-  let(:env)    { Fixtures::BOOT_ENV            }
+  let(:env)    { Fixtures::TEST_ENV            }
 
   subject { object.each { |matcher| yields << matcher } }
 

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Mutant::Matcher::Namespace do
   let(:object) { described_class.new(env, Mutant::Expression.parse('TestApp*')) }
   let(:yields) { []                                                             }
-  let(:env)    { Fixtures::BOOT_ENV                                             }
+  let(:env)    { double('Env')                                                  }
 
   subject { object.each { |item| yields << item } }
 
@@ -16,13 +16,17 @@ describe Mutant::Matcher::Namespace do
     let(:subject_b)   { double('SubjectB')                             }
 
     before do
-      allow(Mutant::Matcher::Methods::Singleton).to receive(:new).with(env, singleton_a).and_return([subject_a])
-      allow(Mutant::Matcher::Methods::Instance).to receive(:new).with(env, singleton_a).and_return([])
-
       allow(Mutant::Matcher::Methods::Singleton).to receive(:new).with(env, singleton_b).and_return([subject_b])
       allow(Mutant::Matcher::Methods::Instance).to receive(:new).with(env, singleton_b).and_return([])
 
-      allow(ObjectSpace).to receive(:each_object).with(Module).and_return([singleton_a, singleton_b, singleton_c])
+      allow(Mutant::Matcher::Methods::Singleton).to receive(:new).with(env, singleton_a).and_return([subject_a])
+      allow(Mutant::Matcher::Methods::Instance).to receive(:new).with(env, singleton_a).and_return([])
+
+      allow(env).to receive(:matchable_scopes).and_return(
+        [singleton_a, singleton_b, singleton_c].map do |scope|
+          Mutant::Matcher::Scope.new(env, scope, Mutant::Expression.parse(scope.name))
+        end
+      )
     end
 
     context 'with no block' do
@@ -36,7 +40,7 @@ describe Mutant::Matcher::Namespace do
     end
 
     it 'should yield subjects' do
-      expect { subject }.to change { yields }.from([]).to([subject_b, subject_a])
+      expect { subject }.to change { yields }.from([]).to([subject_a, subject_b])
     end
   end
 end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Mutant::Matcher::Null do
+  let(:object) { described_class.new }
+
+  describe '#each' do
+    let(:yields) { [] }
+
+    subject { object.each { |entry| yields << entry } }
+
+    # it_should_behave_like 'an #each method'
+    context 'with no block' do
+      subject { object.each }
+
+      it { should be_instance_of(to_enum.class) }
+
+      it 'yields the expected values' do
+        expect(subject.to_a).to eql(object.to_a)
+      end
+    end
+
+    it 'should yield subjects' do
+      expect { subject }.not_to change { yields }.from([])
+    end
+  end
+end