mutant 0.9.9 → 0.9.14

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

data/spec/unit/mutant/meta/example/dsl_spec.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Meta::Example::DSL do
-  describe '.call' do
-    subject { described_class.call(file, types, block) }
-
-    let(:file)     { 'foo.rb'             }
-    let(:node)     { s(:false)            }
-    let(:types)    { Set.new([node.type]) }
-    let(:expected) { []                   }
-
-    let(:expected_example) do
-      Mutant::Meta::Example.new(
-        file:     file,
-        node:     node,
-        types:    types,
-        expected: expected
-      )
-    end
-
-    def self.expect_example(&block)
-      let(:block) { block }
-
-      specify do
-        # Kill mutations to warnings
-        warnings = Mutant::WORLD.warnings.call do
-          should eql(expected_example)
-        end
-        expect(warnings).to eql([])
-      end
-    end
-
-    def self.expect_error(message, &block)
-      let(:block) { block }
-
-      specify do
-        expect { subject }.to raise_error(RuntimeError, message)
-      end
-    end
-
-    context 'source as node' do
-      expect_example do
-        source s(:false)
-      end
-    end
-
-    context 'source as string' do
-      expect_example do
-        source 'false'
-      end
-    end
-
-    context 'on node that needs unparser preprocessing to be normalized' do
-      let(:node) { s(:send, s(:float, -1.0), :/, s(:float, 0.0)) }
-
-      expect_example do
-        source '(-1.0) / 0.0'
-      end
-    end
-
-    context 'using #mutation' do
-      let(:expected) { [s(:nil)] }
-
-      expect_example do
-        source 'false'
-
-        mutation 'nil'
-      end
-    end
-
-    context 'using #singleton_mutations' do
-      let(:expected) { [s(:nil), s(:self)] }
-
-      expect_example do
-        source 'false'
-
-        singleton_mutations
-      end
-    end
-
-    context 'no definition of source' do
-      expect_error('source not defined') do
-      end
-    end
-
-    context 'duplicate definition of source' do
-      expect_error('source already defined') do
-        source 'true'
-        source 'false'
-      end
-    end
-
-    context 'uncoercable source' do
-      expect_error('Cannot coerce to node: nil') do
-        source nil
-      end
-    end
-
-    context 'duplicate mutation expectation' do
-      expect_error('Mutation for input: "true" is already expected') do
-        source 'false'
-
-        mutation 'true'
-        mutation 'true'
-      end
-    end
-  end
-end