mutant 0.9.11 → 0.10.1

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

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

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-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) { instance_double(Class, name: 'TestApp::Literal')  }
-  let(:raw_scope_b) { instance_double(Class, name: 'TestApp::Foo')      }
-  let(:raw_scope_c) { instance_double(Class, name: 'TestAppOther')      }
-  let(:subject_a)   { instance_double(Mutant::Subject)                  }
-  let(:subject_b)   { instance_double(Mutant::Subject)                  }
-
-  before 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::Metaclass, 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
-
-    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
-
-  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,12 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Matcher::Null, '#call' do
-  let(:object) { described_class.new          }
-  let(:env)    { instance_double(Mutant::Env) }
-
-  subject { object.call(env) }
-
-  it 'returns no subjects' do
-    should eql([])
-  end
-end

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-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(: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) }
-
-  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(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])
-
-    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, subject_c])
-  end
-end

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

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-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/matcher_spec.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Matcher do
-  describe '.from_config' do
-    def apply
-      described_class.from_config(config)
-    end
-
-    let(:anon_matcher)       { instance_double(Mutant::Matcher)    }
-    let(:env)                { instance_double(Mutant::Env)        }
-    let(:ignore_expressions) { []                                  }
-    let(:match_expression_a) { expression('Foo::Bar#a', matcher_a) }
-    let(:match_expression_b) { expression('Foo::Bar#b', matcher_b) }
-    let(:subject_filters)    { []                                  }
-
-    let(:matcher_a) do
-      instance_double(Mutant::Matcher, call: [subject_a])
-    end
-
-    let(:matcher_b) do
-      instance_double(Mutant::Matcher, call: [subject_b])
-    end
-
-    let(:expression_class) do
-      Class.new(Mutant::Expression) do
-        include Concord.new(:child, :matcher)
-
-        %w[syntax prefix?].each do |name|
-          define_method(name) do |*arguments, &block|
-            child.public_send(name, *arguments, &block)
-          end
-        end
-
-        public :matcher
-      end
-    end
-
-    let(:config) do
-      Mutant::Matcher::Config.new(
-        ignore_expressions: ignore_expressions,
-        match_expressions:  [match_expression_a, match_expression_b],
-        subject_filters:    subject_filters
-      )
-    end
-
-    let(:subject_a) do
-      instance_double(Mutant::Subject, 'subject a', expression: expression('Foo::Bar#a'))
-    end
-
-    let(:subject_b) do
-      instance_double(Mutant::Subject, 'subject b', expression: expression('Foo::Bar#b'))
-    end
-
-    def expression(input, matcher = anon_matcher)
-      expression_class.new(parse_expression(input), matcher)
-    end
-
-    context 'empty ignores and empty filter' do
-      it 'returns expected subjects' do
-        expect(apply.call(env)).to eql([subject_a, subject_b])
-      end
-    end
-
-    context 'with ignore matching a subject' do
-      let(:ignore_expressions) { [subject_b.expression] }
-
-      it 'returns expected subjects' do
-        expect(apply.call(env)).to eql([subject_a])
-      end
-    end
-
-    context 'with ignore matching many subjects' do
-      let(:ignore_expressions) { [expression('Foo*')] }
-
-      it 'returns expected subjects' do
-        expect(apply.call(env)).to eql([])
-      end
-    end
-
-    context 'with subject filter' do
-      let(:subject_filters) do
-        [subject_a.method(:eql?)]
-      end
-
-      it 'returns expected subjects' do
-        expect(apply.call(env)).to eql([subject_a])
-      end
-    end
-
-    context 'with subject ignore and filter' do
-      let(:ignore_expressions) { [subject_b.expression] }
-
-      let(:subject_filters) do
-        [subject_b.method(:eql?)]
-      end
-
-      it 'returns expected subjects' do
-        expect(apply.call(env)).to eql([])
-      end
-    end
-  end
-end