mutant 0.5.23 → 0.5.24

data/spec/unit/mutant/expression/methods_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Mutant::Expression::Methods do
+
+  let(:object)            { described_class.parse(input) }
+  let(:cache)             { Mutant::Cache.new            }
+  let(:instance_methods)  { 'TestApp::Literal#'          }
+  let(:singleton_methods) { 'TestApp::Literal.'          }
+
+  describe '#match_length' do
+    let(:input) { instance_methods }
+
+    subject { object.match_length(other) }
+
+    context 'when other is an equivalent expression' do
+      let(:other) { described_class.parse(object.syntax) }
+
+      it { should be(object.syntax.length) }
+    end
+
+    context 'when other is an unequivalent expression' do
+      let(:other) { described_class.parse('Foo*') }
+
+      it { should be(0) }
+    end
+  end
+
+  describe '#matcher' do
+    subject { object.matcher(cache) }
+
+    context 'with an instance method' do
+      let(:input) { instance_methods }
+
+      it { should eql(Mutant::Matcher::Methods::Instance.new(cache, TestApp::Literal)) }
+    end
+
+    context 'with a singleton method' do
+      let(:input) { singleton_methods }
+
+      it { should eql(Mutant::Matcher::Methods::Singleton.new(cache, TestApp::Literal)) }
+    end
+  end
+end

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::Namespace::Scope.new(cache, TestApp::Literal)) }
+    it { should eql(Mutant::Matcher::Scope.new(cache, TestApp::Literal)) }
   end
 
   describe '#match_length' do

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

@@ -3,12 +3,12 @@ require 'spec_helper'
 describe Mutant::Expression::Namespace::Recursive do
 
   let(:object) { described_class.parse(input) }
-  let(:cache)  { Mutant::Cache.new            }
-  let(:input)  { 'TestApp::Literal*'          }
+  let(:cache)  { Mutant::Cache.new                   }
+  let(:input)  { 'TestApp::Literal*'                 }
 
   describe '#matcher' do
     subject { object.matcher(cache) }
-    it { should eql(Mutant::Matcher::Namespace.new(cache, 'TestApp::Literal')) }
+    it { should eql(Mutant::Matcher::Namespace.new(cache, object)) }
   end
 
   describe '#match_length' do
@@ -33,9 +33,23 @@ describe Mutant::Expression::Namespace::Recursive do
     end
 
     context 'when other expression describes a longer prefix' do
-      let(:other) { described_class.parse('TestApp::Literal::Deep') }
+      context 'on constants' do
+        let(:other) { described_class.parse('TestApp::Literal::Deep') }
 
-      it { should be(input[0..-2].length) }
+        it { should be(input[0..-2].length) }
+      end
+
+      context 'on singleton method' do
+        let(:other) { described_class.parse('TestApp::Literal.foo') }
+
+        it { should be(input[0..-2].length) }
+      end
+
+      context 'on instance method' do
+        let(:other) { described_class.parse('TestApp::Literal#foo') }
+
+        it { should be(input[0..-2].length) }
+      end
     end
   end
 end

data/spec/unit/mutant/{strategy_spec.rb → integration_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Mutant::Strategy do
+describe Mutant::Integration do
 
   let(:class_under_test) do
     Class.new(described_class)

data/spec/unit/mutant/isolation_spec.rb

@@ -5,7 +5,9 @@ describe Mutant::Isolation do
     let(:object) { described_class }
 
     it 'isolates global effects from process' do
-      expect { object.call { ::Foo = 1 } }.not_to change { defined?(Foo) }.from(nil)
+      expect(defined?(::TestConstant)).to be(nil)
+      object.call { ::TestConstant = 1 }
+      expect(defined?(::TestConstant)).to be(nil)
     end
 
     it 'return block value' do

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

@@ -3,12 +3,12 @@ require 'spec_helper'
 # rubocop:disable ClassAndModuleChildren
 describe Mutant::Matcher::Method::Instance do
 
-  let(:cache) { Fixtures::AST_CACHE }
+  let(:env) { Fixtures::BOOT_ENV }
 
   describe '#each' do
     subject { object.each { |subject| yields << subject } }
 
-    let(:object)       { described_class.new(cache, scope, method) }
+    let(:object)       { described_class.new(env, scope, method) }
     let(:method)       { scope.instance_method(method_name)        }
     let(:yields)       { []                                        }
     let(:namespace)    { self.class                                }
@@ -118,7 +118,7 @@ describe Mutant::Matcher::Method::Instance do
   describe '.build' do
     let(:object) { described_class }
 
-    subject { object.build(cache, scope, method) }
+    subject { object.build(env, scope, method) }
 
     let(:scope) do
       Class.new do
@@ -141,13 +141,13 @@ describe Mutant::Matcher::Method::Instance do
       context 'with unmemoized method' do
         let(:method_name) { :bar }
 
-        it { should eql(described_class.new(cache, scope, method)) }
+        it { should eql(described_class.new(env, scope, method)) }
       end
 
       context 'with memoized method' do
         let(:method_name) { :foo }
 
-        it { should eql(described_class::Memoized.new(cache, scope, method)) }
+        it { should eql(described_class::Memoized.new(env, scope, method)) }
       end
     end
   end

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

@@ -4,14 +4,14 @@ require 'spec_helper'
 describe Mutant::Matcher::Method::Singleton, '#each' do
   subject { object.each { |subject| yields << subject } }
 
-  let(:object)       { described_class.new(cache, scope, method) }
-  let(:method)       { scope.method(method_name)                 }
-  let(:cache)        { Fixtures::AST_CACHE                       }
-  let(:yields)       { []                                        }
-  let(:namespace)    { self.class                                }
-  let(:scope)        { self.class::Foo                           }
-  let(:type)         { :defs                                     }
-  let(:method_arity) { 0                                         }
+  let(:object)       { described_class.new(env, scope, method) }
+  let(:method)       { scope.method(method_name)               }
+  let(:env)          { Fixtures::BOOT_ENV                      }
+  let(:yields)       { []                                      }
+  let(:namespace)    { self.class                              }
+  let(:scope)        { self.class::Foo                         }
+  let(:type)         { :defs                                   }
+  let(:method_arity) { 0                                       }
 
   def name
     node.children[1]

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

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe Mutant::Matcher::Methods::Instance, '#each' do
-  let(:object) { described_class.new(cache, Foo) }
-  let(:cache)  { Mutant::Cache.new               }
+  let(:object) { described_class.new(env, Foo) }
+  let(:env)    { Fixtures::BOOT_ENV            }
 
   subject { object.each { |matcher| yields << matcher } }
 
@@ -46,12 +46,9 @@ describe Mutant::Matcher::Methods::Instance, '#each' do
 
   before do
     matcher = Mutant::Matcher::Method::Instance
-    matcher.stub(:new)
-      .with(cache, Foo, Foo.instance_method(:method_a)).and_return([subject_a])
-    matcher.stub(:new)
-      .with(cache, Foo, Foo.instance_method(:method_b)).and_return([subject_b])
-    matcher.stub(:new)
-      .with(cache, Foo, Foo.instance_method(:method_c)).and_return([subject_c])
+    allow(matcher).to receive(:new).with(env, Foo, Foo.instance_method(:method_a)).and_return([subject_a])
+    allow(matcher).to receive(:new).with(env, Foo, Foo.instance_method(:method_b)).and_return([subject_b])
+    allow(matcher).to receive(:new).with(env, Foo, Foo.instance_method(:method_c)).and_return([subject_c])
   end
 
   it 'should yield expected subjects' do

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

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe Mutant::Matcher::Methods::Singleton, '#each' do
-  let(:object) { described_class.new(cache, Foo) }
-  let(:cache)  { Mutant::Cache.new               }
+  let(:object) { described_class.new(env, Foo) }
+  let(:env)    { Fixtures::BOOT_ENV            }
 
   subject { object.each { |matcher| yields << matcher } }
 
@@ -41,11 +41,11 @@ describe Mutant::Matcher::Methods::Singleton, '#each' do
   before do
     matcher = Mutant::Matcher::Method::Singleton
     matcher.stub(:new)
-      .with(cache, Foo, Foo.method(:method_a)).and_return([subject_a])
+      .with(env, Foo, Foo.method(:method_a)).and_return([subject_a])
     matcher.stub(:new)
-      .with(cache, Foo, Foo.method(:method_b)).and_return([subject_b])
+      .with(env, Foo, Foo.method(:method_b)).and_return([subject_b])
     matcher.stub(:new)
-      .with(cache, Foo, Foo.method(:method_c)).and_return([subject_c])
+      .with(env, Foo, Foo.method(:method_c)).and_return([subject_c])
   end
 
   it 'should yield expected subjects' do

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

@@ -1,29 +1,28 @@
 require 'spec_helper'
 
 describe Mutant::Matcher::Namespace do
-  let(:object) { described_class.new(cache, 'TestApp::Literal') }
-  let(:yields) { []                                             }
-
-  let(:cache) { Mutant::Cache.new }
+  let(:object) { described_class.new(env, Mutant::Expression.parse('TestApp*')) }
+  let(:yields) { []                                                             }
+  let(:env)    { Fixtures::BOOT_ENV                                             }
 
   subject { object.each { |item| yields << item } }
 
   describe '#each' do
 
-    let(:singleton_a) { double('SingletonA', name: 'TestApp::Literal')      }
-    let(:singleton_b) { double('SingletonB', name: 'TestApp::Foo')          }
-    let(:singleton_c) { double('SingletonC', name: 'TestApp::LiteralOther') }
-    let(:subject_a)   { double('SubjectA')                                  }
-    let(:subject_b)   { double('SubjectB')                                  }
+    let(:singleton_a) { double('SingletonA', name: 'TestApp::Literal') }
+    let(:singleton_b) { double('SingletonB', name: 'TestApp::Foo')     }
+    let(:singleton_c) { double('SingletonC', name: 'TestAppOther')     }
+    let(:subject_a)   { double('SubjectA')                             }
+    let(:subject_b)   { double('SubjectB')                             }
 
     before do
-      Mutant::Matcher::Methods::Singleton.stub(:each)
-        .with(cache, singleton_a)
-        .and_yield(subject_a)
-      Mutant::Matcher::Methods::Instance.stub(:each)
-        .with(cache, singleton_a)
-        .and_yield(subject_b)
-      ObjectSpace.stub(each_object: [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(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])
     end
 
     context 'with no block' do
@@ -31,17 +30,13 @@ describe Mutant::Matcher::Namespace do
 
       it { should be_instance_of(to_enum.class) }
 
-      if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
-        skip 'FIX RBX rspec? BUG HERE'
-      else
-        it 'yields the expected values' do
-          expect(subject.to_a).to eql(object.to_a)
-        end
+      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, subject_b])
+      expect { subject }.to change { yields }.from([]).to([subject_b, subject_a])
     end
   end
 end

data/spec/unit/mutant/mutation_spec.rb

@@ -6,7 +6,7 @@ describe Mutant::Mutation do
     SYMBOL = 'test'.freeze
   end
 
-  let(:object)           { TestMutation.new(mutation_subject, Mutant::NodeHelpers::N_NIL)   }
+  let(:object)           { TestMutation.new(mutation_subject, Mutant::AST::Nodes::N_NIL)    }
   let(:mutation_subject) { double('Subject', identification: 'subject', source: 'original') }
   let(:node)             { double('Node')                                                   }
 

data/spec/unit/mutant/runner/config_spec.rb

@@ -6,9 +6,8 @@ describe Mutant::Runner::Config do
   let(:config) do
     Mutant::Config.new(
       matcher:           [subject_a, subject_b],
-      cache:             Mutant::Cache.new,
       debug:             false,
-      strategy:          strategy,
+      integration:       integration,
       reporter:          reporter,
       fail_fast:         fail_fast,
       expected_coverage: expected_coverage,
@@ -19,13 +18,13 @@ describe Mutant::Runner::Config do
   let(:fail_fast)         { false                       }
   let(:expected_coverage) { 100.0                       }
   let(:reporter)          { Mutant::Reporter::Trace.new }
-  let(:strategy)          { double('Strategy')          }
+  let(:integration)       { double('Integration')       }
   let(:subject_a)         { double('Subject A')         }
   let(:subject_b)         { double('Subject B')         }
 
   before do
-    strategy.stub(:setup)
-    strategy.stub(:teardown)
+    integration.stub(:setup)
+    integration.stub(:teardown)
     Mutant::Runner.stub(:run).with(config, subject_a).and_return(runner_a)
     Mutant::Runner.stub(:run).with(config, subject_b).and_return(runner_b)
   end

data/spec/unit/mutant/runner/mutation_spec.rb

@@ -3,25 +3,25 @@ require 'spec_helper'
 describe Mutant::Runner::Mutation do
   let(:object) { described_class.new(config, mutation, tests) }
 
-  let(:reporter)  { double('Reporter')                                                             }
-  let(:mutation)  { double('Mutation', class: Mutant::Mutation)                                    }
-  let(:strategy)  { double('Strategy')                                                             }
-  let(:killer_a)  { Mutant::Killer.new(test: test_a, mutation: mutation)                           }
-  let(:killer_b)  { Mutant::Killer.new(test: test_b, mutation: mutation)                           }
-  let(:runner_a)  { double('Runner A', success?: success_a, stop?: stop_a, mutation_dead?: dead_a) }
-  let(:runner_b)  { double('Runner B', success?: success_b, stop?: stop_b, mutation_dead?: dead_b) }
-  let(:runners)   { [runner_a, runner_b]                                                           }
-  let(:killers)   { [killer_a, killer_b]                                                           }
-  let(:fail_fast) { false                                                                          }
-  let(:success_a) { true                                                                           }
-  let(:success_b) { true                                                                           }
-  let(:stop_a)    { false                                                                          }
-  let(:stop_b)    { false                                                                          }
-  let(:dead_a)    { false                                                                          }
-  let(:dead_b)    { false                                                                          }
-  let(:test_a)    { double('test a')                                                               }
-  let(:test_b)    { double('test b')                                                               }
-  let(:tests)     { [test_a, test_b]                                                               }
+  let(:reporter)    { double('Reporter')                                                             }
+  let(:mutation)    { double('Mutation', class: Mutant::Mutation)                                    }
+  let(:integration) { double('Integration')                                                          }
+  let(:killer_a)    { Mutant::Killer.new(test: test_a, mutation: mutation)                           }
+  let(:killer_b)    { Mutant::Killer.new(test: test_b, mutation: mutation)                           }
+  let(:runner_a)    { double('Runner A', success?: success_a, stop?: stop_a, mutation_dead?: dead_a) }
+  let(:runner_b)    { double('Runner B', success?: success_b, stop?: stop_b, mutation_dead?: dead_b) }
+  let(:runners)     { [runner_a, runner_b]                                                           }
+  let(:killers)     { [killer_a, killer_b]                                                           }
+  let(:fail_fast)   { false                                                                          }
+  let(:success_a)   { true                                                                           }
+  let(:success_b)   { true                                                                           }
+  let(:stop_a)      { false                                                                          }
+  let(:stop_b)      { false                                                                          }
+  let(:dead_a)      { false                                                                          }
+  let(:dead_b)      { false                                                                          }
+  let(:test_a)      { double('test a')                                                               }
+  let(:test_b)      { double('test b')                                                               }
+  let(:tests)       { [test_a, test_b]                                                               }
 
   before do
     expect(Mutant::Runner).to receive(:run).with(config, killer_a).and_return(runner_a)
@@ -33,13 +33,13 @@ describe Mutant::Runner::Mutation do
       'Config',
       fail_fast: fail_fast,
       reporter:  reporter,
-      strategy:  strategy
+      integration:  integration
     )
   end
 
   before do
     reporter.stub(progress: reporter)
-    strategy.stub(killers: killers)
+    integration.stub(killers: killers)
   end
 
   describe '#stop?' do

data/spec/unit/mutant/runner/subject_spec.rb

@@ -13,11 +13,11 @@ describe Mutant::Runner::Subject, '#success?' do
     )
   end
 
-  let(:reporter)   { Mutant::Reporter::Trace.new                              }
-  let(:config)     { double('Config', reporter: reporter, strategy: strategy) }
-  let(:mutation_a) { double('Mutation A')                                     }
-  let(:mutation_b) { double('Mutation B')                                     }
-  let(:strategy)   { double('Strategy')                                       }
+  let(:reporter)    { Mutant::Reporter::Trace.new                                    }
+  let(:config)      { double('Config', reporter: reporter, integration: integration) }
+  let(:mutation_a)  { double('Mutation A')                                           }
+  let(:mutation_b)  { double('Mutation B')                                           }
+  let(:integration) { double('Integration')                                          }
 
   let(:runner_a) do
     double('Runner A', success?: success_a, stop?: stop_a)
@@ -30,7 +30,7 @@ describe Mutant::Runner::Subject, '#success?' do
   let(:tests) { [double('test a'), double('test b')] }
 
   before do
-    expect(strategy).to receive(:tests).with(mutation_subject).and_return(tests)
+    expect(config).to receive(:tests).with(mutation_subject).and_return(tests)
     expect(Mutant::Runner).to receive(:run).with(config, mutation_a, tests).and_return(runner_a)
     expect(Mutant::Runner).to receive(:run).with(config, mutation_b, tests).and_return(runner_b)
   end

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

@@ -3,8 +3,6 @@
 require 'spec_helper'
 
 describe Mutant::Subject::Method::Instance do
-  include Mutant::NodeHelpers
-
   let(:object)  { described_class.new(context, node) }
   let(:context) { double }
 
@@ -73,8 +71,6 @@ describe Mutant::Subject::Method::Instance do
 end
 
 describe Mutant::Subject::Method::Instance::Memoized do
-  include Mutant::NodeHelpers
-
   let(:object)  { described_class.new(context, node) }
   let(:context) { double }
 

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

@@ -3,7 +3,6 @@
 require 'spec_helper'
 
 describe Mutant::Subject::Method::Singleton do
-  include Mutant::NodeHelpers
 
   let(:object)  { described_class.new(context, node) }
   let(:context) { double }