mutant 0.8.7 → 0.8.8

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

@@ -1,76 +1,72 @@
-RSpec.describe Mutant::Matcher::Method::Singleton, '#each' do
-  subject { object.each(&yields.method(:<<)) }
-
-  let(:object)       { described_class.new(env, scope, method) }
-  let(:method)       { scope.method(method_name)               }
-  let(:env)          { Fixtures::TEST_ENV                      }
-  let(:yields)       { []                                      }
-  let(:type)         { :defs                                   }
-  let(:method_name)  { :foo                                    }
-  let(:method_arity) { 0                                       }
-  let(:base)         { TestApp::SingletonMethodTests           }
+RSpec.describe Mutant::Matcher::Method::Singleton, '#call' do
+  subject { object.call(env) }
+
+  let(:object)       { described_class.new(scope, method)                }
+  let(:env)          { test_env                                          }
+  let(:method)       { scope.method(method_name)                         }
+  let(:type)         { :defs                                             }
+  let(:method_name)  { :foo                                              }
+  let(:method_arity) { 0                                                 }
+  let(:base)         { TestApp::SingletonMethodTests                     }
+  let(:source_path)  { MutantSpec::ROOT.join('test_app/lib/test_app.rb') }
 
   def name
-    node.children[1]
+    node.children.fetch(1)
   end
 
   def arguments
-    node.children[2]
+    node.children.fetch(2)
   end
 
-  context 'on singleton methods' do
+  context 'when also defined on lvar' do
+    let(:scope)        { base::DefinedOnLvar }
+    let(:method_line)  { 66                  }
+    let(:expected_warnings) do
+      [
+        'Can only match :defs on :self or :const got :lvar unable to match'
+      ]
+    end
 
-    context 'when also defined on lvar' do
-      let(:scope)       { base::AlsoDefinedOnLvar                           }
-      let(:source_path) { MutantSpec::ROOT.join('test_app/lib/test_app.rb') }
-      let(:method_line) { 66                                                }
+    include_examples 'skipped candidate'
+  end
 
-      it_should_behave_like 'a method matcher'
+  context 'when defined on self' do
+    let(:scope)       { base::DefinedOnSelf }
+    let(:method_line) { 61                  }
 
-      it 'warns about definition on non const/self' do
-        subject
-        expect(env.config.reporter.warn_calls).to(
-          include('Can only match :defs on :self or :const got :lvar unable to match')
-        )
-      end
-    end
+    it_should_behave_like 'a method matcher'
+  end
 
-    context 'when defined on self' do
-      let(:scope)       { base::DefinedOnSelf                               }
-      let(:source_path) { MutantSpec::ROOT.join('test_app/lib/test_app.rb') }
-      let(:method_line) { 61                                                }
+  context 'when defined on constant' do
+    context 'inside namespace' do
+      let(:scope)       { base::DefinedOnConstant::InsideNamespace }
+      let(:method_line) { 71                                       }
 
       it_should_behave_like 'a method matcher'
     end
 
-    context 'when defined on constant' do
+    context 'outside namespace' do
+      let(:scope)       { base::DefinedOnConstant::OutsideNamespace }
+      let(:method_line) { 78                                        }
 
-      context 'inside namespace' do
-        let(:scope)       { base::DefinedOnConstant::InsideNamespace          }
-        let(:source_path) { MutantSpec::ROOT.join('test_app/lib/test_app.rb') }
-        let(:method_line) { 71                                                }
-
-        it_should_behave_like 'a method matcher'
-      end
+      it_should_behave_like 'a method matcher'
+    end
+  end
 
-      context 'outside namespace' do
-        let(:scope)       { base::DefinedOnConstant::OutsideNamespace         }
-        let(:source_path) { MutantSpec::ROOT.join('test_app/lib/test_app.rb') }
-        let(:method_line) { 78                                                }
+  context 'when defined multiple times in the same line' do
+    context 'with method on different scope' do
+      let(:scope)        { base::DefinedMultipleTimes::SameLine::DifferentScope }
+      let(:method_line)  { 97                                                   }
+      let(:method_arity) { 1                                                    }
 
-        it_should_behave_like 'a method matcher'
-      end
+      it_should_behave_like 'a method matcher'
     end
 
-    context 'when defined multiple times in the same line' do
-      context 'with method on different scope' do
-        let(:scope)        { base::DefinedMultipleTimes::SameLine::DifferentScope }
-        let(:source_path)  { MutantSpec::ROOT.join('test_app/lib/test_app.rb')    }
-        let(:method_line)  { 97                                                   }
-        let(:method_arity) { 1                                                    }
+    context 'with different name' do
+      let(:scope)        { base::DefinedMultipleTimes::SameLine::DifferentName }
+      let(:method_line)  { 101                                                 }
 
-        it_should_behave_like 'a method matcher'
-      end
+      it_should_behave_like 'a method matcher'
     end
   end
 end

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

@@ -1,10 +1,6 @@
-RSpec.describe Mutant::Matcher::Methods::Instance, '#each' do
-  let(:object) { described_class.new(env, class_under_test) }
-  let(:env)    { Fixtures::TEST_ENV            }
-
-  subject { object.each { |matcher| yields << matcher } }
-
-  let(:yields) { [] }
+RSpec.describe Mutant::Matcher::Methods::Instance, '#call' do
+  let(:object) { described_class.new(class_under_test) }
+  let(:env)    { Fixtures::TEST_ENV                    }
 
   let(:class_under_test) do
     parent = Module.new do
@@ -37,26 +33,27 @@ RSpec.describe Mutant::Matcher::Methods::Instance, '#each' do
     end
   end
 
-  let(:subject_a) { double('Subject A') }
-  let(:subject_b) { double('Subject B') }
-  let(:subject_c) { double('Subject C') }
-
-  let(:subjects) { [subject_a, subject_b, subject_c] }
+  let(:subject_a) { instance_double(Mutant::Subject) }
+  let(:subject_b) { instance_double(Mutant::Subject) }
+  let(:subject_c) { instance_double(Mutant::Subject) }
+  let(:subjects)  { [subject_a, subject_b, subject_c] }
 
   before do
-    matcher = Mutant::Matcher::Method::Instance
-    allow(matcher).to receive(:new)
-      .with(env, class_under_test, class_under_test.instance_method(:method_a)).and_return([subject_a])
-    allow(matcher).to receive(:new)
-      .with(env, class_under_test, class_under_test.instance_method(:method_b)).and_return([subject_b])
-    allow(matcher).to receive(:new)
-      .with(env, class_under_test, class_under_test.instance_method(:method_c)).and_return([subject_c])
+    {
+      method_a: subject_a,
+      method_b: subject_b,
+      method_c: subject_c
+    }.each do |method, subject|
+      matcher = instance_double(Mutant::Matcher)
+      expect(matcher).to receive(:call).with(env).and_return([subject])
+
+      expect(Mutant::Matcher::Method::Instance).to receive(:new)
+        .with(class_under_test, class_under_test.instance_method(method))
+        .and_return(matcher)
+    end
   end
 
-  it 'should yield expected subjects' do
-    subject
-    expect(yields).to eql(subjects)
+  it 'returns expected subjects' do
+    expect(object.call(env)).to eql(subjects)
   end
-
-  it_should_behave_like 'an #each method'
 end

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

@@ -1,10 +1,6 @@
-RSpec.describe Mutant::Matcher::Methods::Singleton, '#each' do
-  let(:object) { described_class.new(env, class_under_test) }
-  let(:env)    { Fixtures::TEST_ENV            }
-
-  subject { object.each { |matcher| yields << matcher } }
-
-  let(:yields) { [] }
+RSpec.describe Mutant::Matcher::Methods::Singleton, '#call' do
+  let(:object) { described_class.new(class_under_test) }
+  let(:env)    { Fixtures::TEST_ENV                    }
 
   let(:class_under_test) do
     parent = Module.new do
@@ -32,26 +28,27 @@ RSpec.describe Mutant::Matcher::Methods::Singleton, '#each' do
     end
   end
 
-  let(:subject_a) { double('Subject A') }
-  let(:subject_b) { double('Subject B') }
-  let(:subject_c) { double('Subject C') }
+  let(:subject_a) { instance_double(Mutant::Subject, 'A') }
+  let(:subject_b) { instance_double(Mutant::Subject, 'B') }
+  let(:subject_c) { instance_double(Mutant::Subject, 'C') }
 
   let(:subjects) { [subject_a, subject_b, subject_c] }
 
   before do
     matcher = Mutant::Matcher::Method::Singleton
-    allow(matcher).to receive(:new)
-      .with(env, class_under_test, class_under_test.method(:method_a)).and_return([subject_a])
-    allow(matcher).to receive(:new)
-      .with(env, class_under_test, class_under_test.method(:method_b)).and_return([subject_b])
-    allow(matcher).to receive(:new)
-      .with(env, class_under_test, class_under_test.method(:method_c)).and_return([subject_c])
-  end
 
-  it 'should yield expected subjects' do
-    subject
-    expect(yields).to eql(subjects)
+    {
+      method_a: subject_a,
+      method_b: subject_b,
+      method_c: subject_c
+    }.each do |method, subject|
+      allow(matcher).to receive(:new)
+        .with(class_under_test, class_under_test.method(method))
+        .and_return(Mutant::Matcher::Static.new([subject]))
+    end
   end
 
-  it_should_behave_like 'an #each method'
+  it 'returns expected subjects' do
+    expect(object.call(env)).to eql(subjects)
+  end
 end

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

@@ -1,44 +1,36 @@
-RSpec.describe Mutant::Matcher::Namespace do
-  let(:object) { described_class.new(env, parse_expression('TestApp*')) }
-  let(:yields) { []                                                     }
-  let(:env)    { double('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: 'TestAppOther')     }
-    let(:subject_a)   { double('SubjectA')                             }
-    let(:subject_b)   { double('SubjectB')                             }
-
-    before do
-      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(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, parse_expression(scope.name))
-        end
-      )
+RSpec.describe Mutant::Matcher::Namespace, '#call' do
+  let(:object) { described_class.new(parse_expression('TestApp*')) }
+  let(:env)    { instance_double(Mutant::Env)                      }
+  let(:raw_scope_a) { double('SingletonA', name: 'TestApp::Literal') }
+
+  let(:raw_scope_b) { double('SingletonB', name: 'TestApp::Foo')     }
+  let(:raw_scope_c) { double('SingletonC', name: 'TestAppOther')     }
+  let(:subject_a)   { double('SubjectA')                             }
+  let(:subject_b)   { double('SubjectB')                             }
+
+  before do
+    [
+      [Mutant::Matcher::Methods::Singleton, raw_scope_b, [subject_b]],
+      [Mutant::Matcher::Methods::Instance,  raw_scope_b, []],
+      [Mutant::Matcher::Methods::Singleton, raw_scope_a, [subject_a]],
+      [Mutant::Matcher::Methods::Instance,  raw_scope_a, []]
+    ].each do |klass, scope, subjects|
+      matcher = instance_double(Mutant::Matcher)
+      expect(matcher).to receive(:call).with(env).and_return(subjects)
+
+      expect(klass).to receive(:new)
+        .with(scope)
+        .and_return(matcher)
     end
 
-    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)
+    allow(env).to receive(:matchable_scopes).and_return(
+      [raw_scope_a, raw_scope_b, raw_scope_c].map do |raw_scope|
+        Mutant::Scope.new(raw_scope, parse_expression(raw_scope.name))
       end
-    end
+    )
+  end
 
-    it 'should yield subjects' do
-      expect { subject }.to change { yields }.from([]).to([subject_a, subject_b])
-    end
+  it 'returns subjects' do
+    expect(object.call(env)).to eql([subject_a, subject_b])
   end
 end

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

@@ -1,24 +1,9 @@
-RSpec.describe Mutant::Matcher::Null do
+RSpec.describe Mutant::Matcher::Null, '#call' do
   let(:object) { described_class.new }
+  let(:env) { instance_double(Mutant::Env) }
+  subject { object.call(env) }
 
-  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
+  it 'returns no subjects' do
+    should eql([])
   end
 end

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

@@ -0,0 +1,33 @@
+RSpec.describe Mutant::Matcher::Scope, '#call' do
+  let(:scope)     { TestApp }
+  let(:object)    { described_class.new(scope)       }
+  let(:env)       { instance_double(Mutant::Env)     }
+  let(:matcher_a) { instance_double(Mutant::Matcher) }
+  let(:matcher_b) { instance_double(Mutant::Matcher) }
+  let(:subject_a) { instance_double(Mutant::Subject) }
+  let(:subject_b) { instance_double(Mutant::Subject) }
+
+  subject { object.call(env) }
+
+  before do
+    expect(Mutant::Matcher::Methods::Singleton).to receive(:new)
+      .with(scope)
+      .and_return(matcher_a)
+
+    expect(Mutant::Matcher::Methods::Instance).to receive(:new)
+      .with(scope)
+      .and_return(matcher_b)
+
+    expect(matcher_a).to receive(:call)
+      .with(env)
+      .and_return([subject_a])
+
+    expect(matcher_b).to receive(:call)
+      .with(env)
+      .and_return([subject_b])
+  end
+
+  it 'concatenates subjects from matched singleton and instance methods' do
+    should eql([subject_a, subject_b])
+  end
+end

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

@@ -0,0 +1,11 @@
+RSpec.describe Mutant::Matcher::Static, '#call' do
+  let(:object)   { described_class.new(subjects) }
+  let(:env)      { instance_double(Mutant::Env)  }
+  let(:subjects) { instance_double(Array)        }
+
+  subject { object.call(env) }
+
+  it 'returns its predefined subjects' do
+    should be(subjects)
+  end
+end

data/spec/unit/mutant/mutation_spec.rb

@@ -1,25 +1,45 @@
 RSpec.describe Mutant::Mutation do
-
   class TestMutation < Mutant::Mutation
     SYMBOL = 'test'.freeze
   end
 
   let(:object)  { TestMutation.new(mutation_subject, Mutant::AST::Nodes::N_NIL) }
-  let(:context) { double('Context')                                             }
+  let(:context) { instance_double(Mutant::Context)                              }
 
   let(:mutation_subject) do
-    double(
-      'Subject',
+    instance_double(
+      Mutant::Subject,
       identification: 'subject',
-      context: context,
-      source: 'original',
-      tests:  tests
+      context:        context,
+      source:         'original'
     )
   end
 
-  let(:test_a) { double('Test A') }
-  let(:test_b) { double('Test B') }
-  let(:tests)  { [test_a, test_b] }
+  let(:test_a) { instance_double(Mutant::Test) }
+  let(:test_b) { instance_double(Mutant::Test) }
+
+  describe '#insert' do
+    subject { object.insert }
+
+    let(:root_node) { s(:foo) }
+
+    before do
+      expect(context).to receive(:root)
+        .with(object.node)
+        .and_return(root_node)
+
+      expect(mutation_subject).to receive(:prepare)
+        .ordered
+        .and_return(mutation_subject)
+
+      expect(Mutant::Loader::Eval).to receive(:call)
+        .ordered
+        .with(root_node, mutation_subject)
+        .and_return(Mutant::Loader::Eval)
+    end
+
+    it_should_behave_like 'a command method'
+  end
 
   describe '#code' do
     subject { object.code }