mutant 0.9.10 → 0.10.0

data/spec/unit/mutant/loader_spec.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Loader, '.call' do
-  def apply
-    described_class.call(
-      binding: binding,
-      kernel:  kernel,
-      source:  source,
-      subject: mutation_subject
-    )
-  end
-
-  let(:path)     { instance_double(Pathname, to_s: path_str) }
-  let(:path_str) { instance_double(String)                   }
-  let(:line)     { instance_double(Integer)                  }
-  let(:kernel)   { class_double(Kernel)                      }
-  let(:binding)  { instance_double(Binding)                  }
-  let(:source)   { instance_double(String)                   }
-  let(:node)     { instance_double(Parser::AST::Node)        }
-
-  let(:mutation_subject) do
-    instance_double(
-      Mutant::Subject,
-      source_path: path,
-      source_line: line
-    )
-  end
-
-  before do
-    allow(kernel).to receive_messages(eval: nil)
-  end
-
-  shared_examples 'kernel eval' do
-    it 'performs eval' do
-      apply
-
-      expect(kernel).to have_received(:eval)
-        .with(
-          "# frozen_string_literal: true\n#[InstanceDouble(String) (anonymous)]",
-          binding,
-          path_str,
-          line
-        )
-    end
-  end
-
-  context 'without exception being raised' do
-    it 'returns success result' do
-      expect(apply).to be(described_class::Result::Success.instance)
-    end
-
-    include_examples 'kernel eval'
-  end
-
-  context 'with void value syntax error' do
-    before do
-      allow(kernel).to receive(:eval)
-        .and_raise(SyntaxError, '/some/path.rb:1: void value expression')
-    end
-
-    it 'returns void value result' do
-      expect(apply).to be(described_class::Result::VoidValue.instance)
-    end
-
-    include_examples 'kernel eval'
-  end
-
-  context 'with other syntax error' do
-    let(:message) { '(eval):1: some other error' }
-
-    before do
-      allow(kernel).to receive(:eval).and_raise(SyntaxError, message)
-    end
-
-    it 'raises exception' do
-      expect { apply }.to raise_error(SyntaxError, message)
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Matcher::Chain, '#call' do
-  subject { object.call(env) }
-
-  let(:object)    { described_class.new([matcher_a, matcher_b]) }
-  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)            }
-
-  before do
-    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 'returns concatenated matches' do
-    should eql([subject_a, subject_b])
-  end
-end

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Matcher::Config do
-  describe '#inspect' do
-    subject { object.inspect }
-
-    context 'on default config' do
-      let(:object) { described_class::DEFAULT }
-
-      it { should eql('#<Mutant::Matcher::Config empty>') }
-    end
-
-    context 'with one expression' do
-      let(:object) { described_class::DEFAULT.add(:match_expressions, parse_expression('Foo')) }
-      it { should eql('#<Mutant::Matcher::Config match_expressions: [Foo]>') }
-    end
-
-    context 'with many expressions' do
-      let(:object) do
-        described_class::DEFAULT
-          .add(:match_expressions, parse_expression('Foo'))
-          .add(:match_expressions, parse_expression('Bar'))
-      end
-
-      it { should eql('#<Mutant::Matcher::Config match_expressions: [Foo,Bar]>') }
-    end
-
-    context 'with match and ignore expression' do
-      let(:object) do
-        described_class::DEFAULT
-          .add(:match_expressions,  parse_expression('Foo'))
-          .add(:ignore_expressions, parse_expression('Bar'))
-      end
-
-      it { should eql('#<Mutant::Matcher::Config ignore_expressions: [Bar] match_expressions: [Foo]>') }
-    end
-
-    context 'with subject filter' do
-      let(:object) do
-        described_class::DEFAULT
-          .add(:subject_filters, 'foo')
-      end
-
-      it { should eql('#<Mutant::Matcher::Config subject_filters: ["foo"]>') }
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Matcher::Filter, '#call' do
-  subject { object.call(env) }
-
-  let(:object)    { described_class.new(matcher, predicate) }
-  let(:matcher)   { instance_double(Mutant::Matcher)        }
-  let(:subject_a) { instance_double(Mutant::Subject)        }
-  let(:subject_b) { instance_double(Mutant::Subject)        }
-  let(:env)       { instance_double(Mutant::Env)            }
-  let(:predicate) { ->(node) { node.eql?(subject_a) }       }
-
-  before do
-    expect(matcher).to receive(:call)
-      .with(env)
-      .and_return([subject_a, subject_b])
-  end
-
-  it 'returns subjects after filtering' do
-    should eql([subject_a])
-  end
-end

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

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Matcher::Method::Instance, '#call' do
-  subject { object.call(env) }
-
-  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,
-      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 method is defined inside eval' do
-    let(:subject_class) { Mutant::Subject::Method::Instance::Memoized }
-    let(:scope)  { base::WithMemoizer                                 }
-    let(:method) { scope.instance_method(:boz)                        }
-
-    let(:expected_warnings) do
-      [
-        "#{method} does not have a valid source location, unable to emit subject"
-      ]
-    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
-    let(:scope)  { Module                            }
-    let(:method) { scope.instance_method(:object_id) }
-
-    let(:expected_warnings) do
-      [
-        "#{method} does not have a valid source location, unable to emit subject"
-      ]
-    end
-
-    include_examples 'skipped candidate'
-
-    it 'returns expected subjects' do
-      expect(subject).to eql([])
-    end
-  end
-
-  context 'in module eval' do
-    let(:scope) { base::InModuleEval }
-
-    let(:expected_warnings) do
-      [
-        "#{method} is dynamically defined in a closure, unable to emit subject"
-      ]
-    end
-
-    include_examples 'skipped candidate'
-
-    it 'returns expected subjects' do
-      expect(subject).to eql([])
-    end
-  end
-
-  context 'in class eval' do
-    let(:scope) { base::InClassEval }
-
-    let(:expected_warnings) do
-      [
-        "#{method} is dynamically defined in a closure, unable to emit subject"
-      ]
-    end
-
-    include_examples 'skipped candidate'
-
-    it 'returns expected subjects' do
-      expect(subject).to eql([])
-    end
-  end
-
-  context 'when method is defined once' do
-    let(:method_name) { :bar               }
-    let(:scope)       { base::WithMemoizer }
-    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
-    let(:scope)       { base::WithMemoizer }
-    let(:method_line) { 15                 }
-
-    it_should_behave_like 'a method matcher'
-  end
-
-  context 'when method is defined multiple times' do
-    context 'on different lines' do
-      let(:scope)        { base::DefinedMultipleTimes::DifferentLines }
-      let(:method_line)  { 24                                         }
-      let(:method_arity) { 1                                          }
-
-      it_should_behave_like 'a method matcher'
-    end
-
-    context 'on the same line' do
-      let(:scope)        { base::DefinedMultipleTimes::SameLineSameScope }
-      let(:method_line)  { 29                                            }
-      let(:method_arity) { 1                                             }
-
-      it_should_behave_like 'a method matcher'
-    end
-
-    context 'on the same line with different scope' do
-      let(:scope)        { base::DefinedMultipleTimes::SameLineDifferentScope }
-      let(:method_line)  { 33                                                 }
-      let(:method_arity) { 1                                                  }
-
-      it_should_behave_like 'a method matcher'
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-# 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