mutant 0.9.7 → 0.9.12

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/singleton_spec.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Matcher::Method::Singleton, '#call' do
-  subject { object.call(env) }
-
-  let(:object)       { described_class.new(scope, method)                }
-  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') }
-  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(1)
-  end
-
-  def arguments
-    node.children.fetch(2)
-  end
-
-  context 'when also defined on lvar' do
-    let(:scope) { base::DefinedOnLvar }
-    let(:expected_warnings) do
-      [
-        'Can only match :defs on :self or :const got :lvar unable to match'
-      ]
-    end
-
-    include_examples 'skipped candidate'
-  end
-
-  context 'when defined on self' do
-    let(:scope)       { base::DefinedOnSelf }
-    let(:method_line) { 61                  }
-
-    it_should_behave_like 'a method matcher'
-  end
-
-  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 'outside namespace' do
-      let(:scope)       { base::DefinedOnConstant::OutsideNamespace }
-      let(:method_line) { 78                                        }
-
-      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)  { 97                                                   }
-      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)  { 101                                                 }
-
-      it_should_behave_like 'a method matcher'
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-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
-      def method_d; end
-
-      def method_e; end
-    end
-
-    Class.new do
-      include parent
-
-      private :method_d
-
-      def method_a; end
-
-    protected
-
-      def method_b; end
-
-    private
-
-      def method_c; end
-    end
-  end
-
-  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
-    {
-      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 'returns expected subjects' do
-    expect(object.call(env)).to eql(subjects)
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-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
-      def method_d; end
-
-      def method_e; end
-    end
-
-    Class.new do
-      extend parent
-
-      def self.method_a; end
-
-      def self.method_b; end
-      class << self; protected :method_b; end
-
-      def self.method_c; end
-      private_class_method :method_c
-
-    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::Singleton
-
-    {
-      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