mutant 0.9.8 → 0.9.9

data/meta/true.rb

@@ -3,6 +3,5 @@
 Mutant::Meta::Example.add :true do
   source 'true'
 
-  mutation 'nil'
   mutation 'false'
 end

data/meta/until.rb

@@ -8,7 +8,6 @@ Mutant::Meta::Example.add :until do
   mutation 'until true; foo; end'
   mutation 'until true; end'
   mutation 'until false; foo; bar; end'
-  mutation 'until nil; foo; bar; end'
   mutation 'until true; foo; nil; end'
   mutation 'until true; foo; self; end'
   mutation 'until true; nil; bar; end'

data/meta/while.rb

@@ -10,7 +10,6 @@ Mutant::Meta::Example.add :while do
   mutation 'while true; foo; end'
   mutation 'while true; end'
   mutation 'while false; foo; bar; end'
-  mutation 'while nil;   foo; bar; end'
   mutation 'while true;  foo; nil; end'
   mutation 'while true;  nil; bar; end'
   mutation 'while true;  raise; end'
@@ -22,5 +21,4 @@ Mutant::Meta::Example.add :while do
   singleton_mutations
   mutation 'while true; raise; end'
   mutation 'while false; end'
-  mutation 'while nil; end'
 end

data/meta/yield.rb

@@ -5,6 +5,5 @@ Mutant::Meta::Example.add :yield do
 
   singleton_mutations
   mutation 'yield false'
-  mutation 'yield nil'
   mutation 'yield'
 end

data/mutant.sh

@@ -0,0 +1,12 @@
+#/usr/bin/bash -ex
+
+bundle exec mutant                                               \
+  --since HEAD~1                                                 \
+  --zombie                                                       \
+  --ignore-subject Mutant::CLI#add_debug_options                 \
+  --ignore-subject Mutant::Mutator::Node::Argument#skip?         \
+  --ignore-subject Mutant::Mutator::Node::ProcargZero#dispatch   \
+  --ignore-subject Mutant::Mutator::Node::When#mutate_conditions \
+  --ignore-subject Mutant::Zombifier#call                        \
+  --                                                             \
+  'Mutant*'

data/spec/unit/mutant/ast/find_metaclass_containing_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::AST::FindMetaclassContaining do
+  describe '#call' do
+    subject { described_class.call(ast, node) }
+
+    let(:metaclass_node) { s(:sclass, s(:self), method_node) }
+    let(:method_node) { s(:def, 'test', s(:nil)) }
+
+    let(:ast) { metaclass_node }
+    let(:node) { method_node }
+
+    context 'when called without ast' do
+      let(:ast) { nil }
+
+      it { expect { subject }.to raise_error }
+    end
+
+    context 'when called without node' do
+      let(:node) { nil }
+
+      it { is_expected.to be nil }
+    end
+
+    context 'when called with ast which contains a duplicate of the node' do
+      let(:node) { s(:def, 'test', s(:nil)) }
+
+      shared_examples_for 'unfooled by the duplicate node' do
+        it { is_expected.to be nil }
+
+        # if we changed method_node or node without altering the other to match,
+        # the above example would provide a false positive. by ensuring node and
+        # method_node are eq but not equal, we ensure the usefulness of the
+        # above example.
+        it { expect(node).to eq(method_node) }
+        it { expect(node).not_to be method_node }
+      end
+
+      it_behaves_like 'unfooled by the duplicate node'
+
+      context 'when the node is in a begin block' do
+        let(:metaclass_node) { s(:sclass, s(:self), s(:begin, method_node)) }
+
+        it_behaves_like 'unfooled by the duplicate node'
+      end
+    end
+
+    context 'when called with ast containing the node' do
+      it { is_expected.to be metaclass_node }
+
+      context 'inside a begin block' do
+        let(:metaclass_node) { s(:sclass, s(:self), s(:begin, method_node)) }
+
+        it { is_expected.to be metaclass_node }
+      end
+
+      context 'inside a different class' do
+        let(:metaclass_node) { s(:sclass, s(:self), s(:class, :MyClass, nil, method_node)) }
+
+        it { is_expected.to be nil }
+      end
+    end
+  end
+end

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

@@ -49,13 +49,18 @@ RSpec.describe Mutant::Expression::Methods do
     context 'with an instance method' do
       let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '#' } }
 
-      it { should eql(Mutant::Matcher::Methods::Instance.new(TestApp::Literal)) }
+      it { should eql(Mutant::Matcher::Chain.new([Mutant::Matcher::Methods::Instance.new(TestApp::Literal)])) }
     end
 
     context 'with a singleton method' do
       let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '.' } }
 
-      it { should eql(Mutant::Matcher::Methods::Singleton.new(TestApp::Literal)) }
+      it do
+        should eql(Mutant::Matcher::Chain.new([
+          Mutant::Matcher::Methods::Singleton.new(TestApp::Literal),
+          Mutant::Matcher::Methods::Metaclass.new(TestApp::Literal)
+        ]))
+      end
     end
   end
 end

data/spec/unit/mutant/license_spec.rb

@@ -283,11 +283,23 @@ RSpec.describe Mutant::License do
     context 'when mutant-license gem cannot be loaded' do
       let(:load_json) { false }
 
-      before do
-        allow(gem_method).to receive(:call).and_raise(Gem::LoadError, 'test-error')
+      def self.setup_error(message)
+        before do
+          allow(gem_method).to receive(:call).and_raise(Gem::LoadError, message)
+        end
+      end
+
+      context 'while the mutant license gem from rubygems is present' do
+        setup_error %{can't activate mutant-license (~> 0.1.0), already activated mutant-license-0.0.0.}
+
+        it_fails_with_message '[Mutant-License-Error]: mutant-license gem from rubygems.org is a dummy'
       end
 
-      it_fails_with_message '[Mutant-License-Error]: test-error'
+      context 'with other error message' do
+        setup_error 'test-error'
+
+        it_fails_with_message '[Mutant-License-Error]: test-error'
+      end
     end
   end
 end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Matcher::Method::Metaclass, '#call' do
+  SOURCE_PATH = 'test_app/lib/test_app/metaclasses.rb'
+  subject { object.call(env) }
+
+  let(:object)       { described_class.new(scope, method) }
+  let(:method)       { scope.method(method_name)          }
+  let(:type)         { :def                               }
+  let(:method_name)  { :foo                               }
+  let(:method_arity) { 0                                  }
+  let(:base)         { TestApp::MetaclassMethodTests      }
+  let(:source_path)  { MutantSpec::ROOT.join(SOURCE_PATH) }
+  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,
+      config: Mutant::Config::DEFAULT,
+      parser: Fixtures::TEST_ENV.parser,
+      world:  world
+    )
+  end
+
+  def name
+    node.children.fetch(0)
+  end
+
+  def arguments
+    node.children.fetch(1)
+  end
+
+  context 'when also defined on lvar' do
+    let(:scope) { base::DefinedOnLvar }
+    let(:expected_warnings) do
+      [
+        'Can only match :def inside :sclass on :self or :const, got :sclass on :lvar unable to match'
+      ]
+    end
+
+    include_examples 'skipped candidate'
+  end
+
+  context 'when defined on self' do
+    let(:scope)       { base::DefinedOnSelf }
+    let(:method_line) { 7                   }
+
+    it_should_behave_like 'a method matcher'
+
+    context 'when scope is a metaclass' do
+      let(:scope) { base::DefinedOnSelf::InsideMetaclass.metaclass }
+      let(:method_line) { 28 }
+
+      it_should_behave_like 'a method matcher'
+    end
+  end
+
+  context 'when defined on constant' do
+    context 'inside namespace' do
+      let(:scope)       { base::DefinedOnConstant::InsideNamespace }
+      let(:method_line) { 44                                       }
+
+      it_should_behave_like 'a method matcher'
+    end
+
+    context 'outside namespace' do
+      let(:scope)       { base::DefinedOnConstant::OutsideNamespace }
+      let(:method_line) { 52                                        }
+
+      it_should_behave_like 'a method matcher'
+    end
+  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(:method_line)  { 76                                                   }
+      let(:method_arity) { 1                                                    }
+
+      it_should_behave_like 'a method matcher'
+    end
+
+    context 'with different name' do
+      let(:scope)        { base::DefinedMultipleTimes::SameLine::DifferentName }
+      let(:method_line)  { 80                                                  }
+
+      it_should_behave_like 'a method matcher'
+    end
+  end
+
+  # tests that the evaluator correctly returns nil when the metaclass doesn't
+  # directly contain the method
+  context 'when defined inside a class in a metaclass' do
+    let(:scope)       { base::NotActuallyInAMetaclass               }
+    let(:method)      { scope.metaclass::SomeClass.new.method(:foo) }
+    let(:method_line) { 93                                          }
+
+    it { is_expected.to be_empty }
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Matcher::Methods::Metaclass, '#call' do
+  let(:object) { described_class.new(class_under_test) }
+  let(:env)    { Fixtures::TEST_ENV                    }
+
+  let(:class_under_test) do
+    parent = Module.new do
+      class << self
+        def method_d; end
+
+        protected
+
+        def method_e; end
+
+        private
+
+        def method_f; end
+      end
+    end
+
+    Class.new do
+      extend parent
+
+      class << self
+        def method_a; end
+
+        protected
+
+        def method_b; end
+
+        private
+
+        def method_c; end
+      end
+    end
+  end
+
+  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::Metaclass
+
+    {
+      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 'returns expected subjects' do
+    expect(object.call(env)).to eql(subjects)
+  end
+end

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

@@ -13,8 +13,10 @@ RSpec.describe Mutant::Matcher::Namespace, '#call' do
     [
       [Mutant::Matcher::Methods::Singleton, raw_scope_b, [subject_b]],
       [Mutant::Matcher::Methods::Instance,  raw_scope_b, []],
+      [Mutant::Matcher::Methods::Metaclass, raw_scope_b, []],
       [Mutant::Matcher::Methods::Singleton, raw_scope_a, [subject_a]],
-      [Mutant::Matcher::Methods::Instance,  raw_scope_a, []]
+      [Mutant::Matcher::Methods::Instance,  raw_scope_a, []],
+      [Mutant::Matcher::Methods::Metaclass, raw_scope_a, []]
     ].each do |klass, scope, subjects|
       matcher = instance_double(Mutant::Matcher)
       expect(matcher).to receive(:call).with(env).and_return(subjects)

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

@@ -6,8 +6,10 @@ RSpec.describe Mutant::Matcher::Scope, '#call' do
   let(:env)       { instance_double(Mutant::Env)     }
   let(:matcher_a) { instance_double(Mutant::Matcher) }
   let(:matcher_b) { instance_double(Mutant::Matcher) }
+  let(:matcher_c) { instance_double(Mutant::Matcher) }
   let(:subject_a) { instance_double(Mutant::Subject) }
   let(:subject_b) { instance_double(Mutant::Subject) }
+  let(:subject_c) { instance_double(Mutant::Subject) }
 
   subject { object.call(env) }
 
@@ -20,6 +22,10 @@ RSpec.describe Mutant::Matcher::Scope, '#call' do
       .with(scope)
       .and_return(matcher_b)
 
+    expect(Mutant::Matcher::Methods::Metaclass).to receive(:new)
+      .with(scope)
+      .and_return(matcher_c)
+
     expect(matcher_a).to receive(:call)
       .with(env)
       .and_return([subject_a])
@@ -27,9 +33,13 @@ RSpec.describe Mutant::Matcher::Scope, '#call' do
     expect(matcher_b).to receive(:call)
       .with(env)
       .and_return([subject_b])
+
+    expect(matcher_c).to receive(:call)
+      .with(env)
+      .and_return([subject_c])
   end
 
   it 'concatenates subjects from matched singleton and instance methods' do
-    should eql([subject_a, subject_b])
+    should eql([subject_a, subject_b, subject_c])
   end
 end

data/spec/unit/mutant/meta/example_spec.rb

@@ -10,9 +10,9 @@ RSpec.describe Mutant::Meta::Example do
     )
   end
 
-  let(:file)           { 'foo/bar.rb'         }
-  let(:node)           { s(:true)             }
-  let(:mutation_nodes) { [s(:nil), s(:false)] }
+  let(:file)           { 'foo/bar.rb' }
+  let(:node)           { s(:true)     }
+  let(:mutation_nodes) { [s(:false)]  }
 
   let(:mutations) do
     mutation_nodes.map do |node|

data/spec/unit/mutant/mutator/node_spec.rb

@@ -41,12 +41,7 @@ RSpec.describe Mutant::Mutator::Node do
     end
 
     specify do
-      expect(apply).to eql(
-        [
-          s(:and, s(:nil), s(:true)),
-          s(:and, s(:true), s(:nil))
-        ].to_set
-      )
+      expect(apply).to eql([s(:and, s(:nil), s(:true))].to_set)
     end
   end
 end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Subject::Method::Metaclass do
+  let(:object) do
+    described_class.new(
+      context:  context,
+      node:     node,
+      warnings: warnings
+    )
+  end
+
+  let(:node)     { s(:def, :foo, s(:args)) }
+  let(:warnings) { instance_double(Mutant::Warnings) }
+
+  let(:context) do
+    Mutant::Context.new(scope, instance_double(Pathname))
+  end
+
+  let(:scope) do
+    Class.new do
+      class << self
+        def foo; end
+
+        def name
+          'Test'
+        end
+      end
+    end
+  end
+
+  describe '#expression' do
+    subject { object.expression }
+
+    it { should eql(parse_expression('Test.foo')) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  describe '#match_expression' do
+    subject { object.match_expressions }
+
+    it { should eql(%w[Test.foo Test*].map(&method(:parse_expression))) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  describe '#prepare' do
+
+    subject { object.prepare }
+
+    it 'undefines method on scope' do
+      expect { subject }.to change { scope.methods.include?(:foo) }.from(true).to(false)
+    end
+
+    it_should_behave_like 'a command method'
+  end
+
+  describe '#source' do
+    subject { object.source }
+
+    it { should eql("class << self\n  def foo\n  end\nend") }
+  end
+end