mutant 0.9.9 → 0.9.14

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

@@ -1,64 +0,0 @@
-# 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/ast/meta/optarg_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::AST::Meta::Optarg do
-  subject(:object) { described_class.new(node) }
-
-  let(:node)  { s(:optarg, name, value) }
-  let(:name)  { :foo                    }
-  let(:value) { s(:sym, :bar)           }
-
-  its(:name) { should be(:foo) }
-  its(:default_value) { should eql(s(:sym, :bar)) }
-
-  describe '#used?' do
-    subject { object.used? }
-
-    it { should be true }
-
-    context 'when name is prefixed with an underscore' do
-      let(:name) { :_foo }
-      it { should be false }
-    end
-  end
-
-end

data/spec/unit/mutant/ast/meta/send/proc_predicate_spec.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::AST::Meta::Send, '#proc?' do
-  subject { described_class.new(node).proc? }
-
-  shared_context 'proc send' do |source|
-    let(:node) { Unparser.parse(source).children.first }
-  end
-
-  shared_examples 'proc definition' do |*args|
-    include_context 'proc send', *args
-
-    it { should be(true) }
-  end
-
-  shared_examples 'not a proc definition' do |*args|
-    include_context 'proc send', *args
-
-    it { should be_falsey }
-  end
-
-  it_behaves_like 'proc definition', 'proc { }'
-  it_behaves_like 'proc definition', 'Proc.new { }'
-  it_behaves_like 'not a proc definition', 'new { }'
-  it_behaves_like 'not a proc definition', 'foo.proc { }'
-  it_behaves_like 'not a proc definition', 'Proc.blah { }'
-  it_behaves_like 'not a proc definition', 'Proc().new { }'
-  it_behaves_like 'not a proc definition', 'Foo.new { }'
-  it_behaves_like 'not a proc definition', 'blah { }'
-end

data/spec/unit/mutant/ast/meta/send/receiver_possible_top_level_const_predicate_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::AST::Meta::Send, '#receiver_possible_top_level_const?' do
-  subject { described_class.new(node).receiver_possible_top_level_const? }
-
-  def parse(source)
-    Unparser.parse(source)
-  end
-
-  context 'when implicit top level const' do
-    let(:node) { parse('Foo.bar') }
-
-    it { should be true }
-  end
-
-  context 'when cbase' do
-    let(:node) { parse('::Foo.bar') }
-
-    it { should be true }
-  end
-
-  context 'when nested const' do
-    let(:node) { parse('Baz::Foo.bar') }
-
-    it { should be false }
-  end
-
-  context 'when no receiver' do
-    let(:node) { parse('bar') }
-
-    it { should be false }
-  end
-
-  context 'when send receiver' do
-    let(:node) { parse('foo.bar') }
-
-    it { should be false }
-  end
-end

data/spec/unit/mutant/ast/meta/send_spec.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::AST::Meta::Send do
-  let(:object) { described_class.new(node) }
-
-  def parse(source)
-    Unparser.parse(source)
-  end
-
-  let(:method_call)            { parse('foo.bar(baz)')  }
-  let(:attribute_read)         { parse('foo.bar')       }
-  let(:attribute_assignment)   { parse('foo.bar = baz') }
-  let(:binary_method_operator) { parse('foo == bar')    }
-
-  class Expectation
-    include Adamantium, Anima.new(:name, :attribute_assignment, :binary_method_operator)
-
-    ALL = [
-      [:method_call,            false, false],
-      [:attribute_read,         false, false],
-      [:attribute_assignment,   true,  false],
-      [:binary_method_operator, false, true]
-    ].map do |values|
-      new(Hash[anima.attribute_names.zip(values)])
-    end.freeze
-  end # Expectation
-
-  # Rspec should have a build in for this kind of "n-dimensional assertion with context"
-  (Expectation.anima.attribute_names - %i[name]).each do |name|
-    describe "##{name}?" do
-      subject { object.public_send(:"#{name}?") }
-
-      Expectation::ALL.each do |expectation|
-        context "on #{expectation.name}" do
-          let(:node) { public_send(expectation.name) }
-
-          it { should be(expectation.public_send(name)) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::AST::NamedChildren do
-  describe '.included' do
-    let(:klass) do
-      Class.new do
-        include Mutant::AST::NamedChildren, Concord.new(:node)
-
-        children :foo, :bar
-      end
-    end
-
-    def publish
-      klass.class_eval do
-        public :foo, :bar
-
-        public :remaining_children, :remaining_children_indices, :remaining_children_with_index
-      end
-    end
-
-    let(:instance) { klass.new(node) }
-
-    let(:node_foo) { s(:foo) }
-    let(:node_bar) { s(:bar) }
-    let(:node_baz) { s(:baz) }
-
-    let(:node) { s(:node, node_foo, node_bar, node_baz) }
-
-    describe 'generated methods' do
-      specify 'are private by default' do
-        %i[
-          foo
-          bar
-          remaining_children
-          remaining_children_indices
-          remaining_children_with_index
-        ].each do |name|
-          expect(klass.private_instance_methods.include?(name)).to be(true)
-        end
-      end
-
-      describe '#remaining_children' do
-        it 'returns remaining unnamed children' do
-          publish
-          expect(instance.remaining_children).to eql([node_baz])
-        end
-      end
-
-      describe '#remaining_children_indices' do
-        it 'returns remaining unnamed children indices' do
-          publish
-          expect(instance.remaining_children_indices).to eql([2])
-        end
-      end
-
-      describe '#remaining_children_with_index' do
-        it 'returns remaining unnamed children indices' do
-          publish
-          expect(instance.remaining_children_with_index).to eql([[node_baz, 2]])
-        end
-      end
-
-      describe '#foo' do
-        it 'returns named child foo' do
-          publish
-          expect(instance.foo).to be(node_foo)
-        end
-      end
-
-      describe '#bar' do
-        context 'when node is present' do
-          it 'returns named child bar' do
-            publish
-            expect(instance.bar).to be(node_bar)
-          end
-        end
-
-        context 'when node is NOT present' do
-          let(:node) { s(:node, node_foo) }
-
-          it 'returns nil' do
-            publish
-            expect(instance.bar).to be(nil)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::AST::Sexp do
-  let(:object) do
-    Class.new do
-      include Mutant::AST::Sexp
-
-      public :n_not
-      public :s
-    end.new
-  end
-
-  describe '#n_not' do
-    subject { object.n_not(node) }
-
-    let(:node) { s(:true) }
-
-    it 'returns negated ast' do
-      expect(subject).to eql(s(:send, s(:true), :!))
-    end
-  end
-
-  describe '#s' do
-    subject { object.s(*arguments) }
-
-    context 'with single argument' do
-      let(:arguments) { %i[foo] }
-
-      it { should eql(Parser::AST::Node.new(:foo)) }
-    end
-
-    context 'with single multiple arguments' do
-      let(:arguments) { %i[foo bar baz] }
-
-      it { should eql(Parser::AST::Node.new(:foo, %i[bar baz])) }
-    end
-  end
-end

data/spec/unit/mutant/ast_spec.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::AST do
-  let(:object) { described_class }
-
-  describe '.find_last_path' do
-    subject { object.find_last_path(root, &block) }
-
-    let(:root)    { s(:root, parent)             }
-    let(:child_a) { s(:child_a)                  }
-    let(:child_b) { s(:child_b)                  }
-    let(:parent)  { s(:parent, child_a, child_b) }
-
-    def path
-      subject.map(&:type)
-    end
-
-    context 'when no node matches' do
-      let(:block) { ->(_) { false } }
-
-      it { should eql([]) }
-    end
-
-    context 'when called without block' do
-      let(:block) { nil }
-
-      it 'raises error' do
-        expect { subject }.to raise_error(ArgumentError, 'block expected')
-      end
-    end
-
-    context 'on non Parser::AST::Node child' do
-      let(:block)   { ->(node) { fail if node.equal?(child_a) } }
-      let(:child_a) { AST::Node.new(:foo) }
-
-      it 'does not yield that node' do
-        expect(path).to eql([])
-      end
-    end
-
-    context 'when one node matches' do
-      let(:block) { ->(node) { node.equal?(child_a) } }
-
-      it 'returns the full path' do
-        expect(path).to eql(%i[root parent child_a])
-      end
-    end
-
-    context 'when two nodes match' do
-      let(:block) { ->(node) { node.equal?(child_a) || node.equal?(child_b) } }
-
-      it 'returns the last full path' do
-        expect(path).to eql(%i[root parent child_b])
-      end
-    end
-  end
-end

data/spec/unit/mutant/bootstrap_spec.rb

@@ -1,216 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Bootstrap do
-  let(:integration)          { instance_double(Mutant::Integration)   }
-  let(:integration_name)     { instance_double(String)                }
-  let(:integration_result)   { Mutant::Either::Right.new(integration) }
-  let(:kernel)               { instance_double(Object, 'kernel')      }
-  let(:load_path)            { %w[original]                           }
-  let(:matcher_config)       { Mutant::Matcher::Config::DEFAULT       }
-  let(:object_space)         { class_double(ObjectSpace)              }
-  let(:object_space_modules) { []                                     }
-  let(:warnings)             { instance_double(Mutant::Warnings)      }
-
-  let(:world) do
-    instance_double(
-      Mutant::World,
-      kernel:       kernel,
-      load_path:    load_path,
-      object_space: object_space,
-      pathname:     Pathname,
-      warnings:     warnings
-    )
-  end
-
-  let(:config) do
-    Mutant::Config::DEFAULT.with(
-      includes:    [],
-      integration: integration,
-      jobs:        1,
-      matcher:     matcher_config,
-      reporter:    instance_double(Mutant::Reporter),
-      requires:    []
-    )
-  end
-
-  let(:expected_env) do
-    env_with_scopes.with(
-      integration: integration,
-      selector:    Mutant::Selector::Expression.new(integration)
-    )
-  end
-
-  let(:env_empty) do
-    Mutant::Env.empty(world, config)
-  end
-
-  let(:env_with_scopes) { env_empty }
-
-  shared_examples 'expected warning' do
-    let(:warns) { [] }
-
-    before do
-      allow(config.reporter).to receive(:warn, &warns.method(:<<))
-    end
-
-    it 'warns with expected warning' do
-      expect { apply }.to change(warns, :to_a).from([]).to([expected_warning])
-    end
-  end
-
-  shared_examples_for 'bootstrap call' do
-    it 'returns expected env' do
-      expect(apply).to eql(Mutant::Either::Right.new(expected_env))
-    end
-
-    it 'performs IO in expected sequence' do
-      apply
-
-      expect(object_space)
-        .to have_received(:each_object)
-        .ordered
-
-      expect(Mutant::Integration)
-        .to have_received(:setup)
-        .with(env_with_scopes)
-        .ordered
-    end
-  end
-
-  before do
-    allow(Mutant::Integration).to receive_messages(setup: integration_result)
-
-    allow(object_space).to receive(:each_object) do |argument|
-      expect(argument).to be(Module)
-      object_space_modules.each
-    end
-  end
-
-  describe '.apply' do
-    def apply
-      described_class.apply(world, config)
-    end
-
-    context 'when Module#name calls result in exceptions' do
-      let(:object_space_modules) { [invalid_class] }
-
-      let(:expected_warning) do
-        "Object#name from: #{invalid_class} raised an error: " \
-        "RuntimeError. #{Mutant::Env::SEMANTICS_MESSAGE}"
-      end
-
-      # Not really a class, but does not leak a "wrong" class
-      # into later specs.
-      let(:invalid_class) do
-        Object.new.tap do |object|
-          def object.name
-            fail
-          end
-        end
-      end
-
-      include_examples 'expected warning'
-      include_examples 'bootstrap call'
-    end
-
-    context 'when Module#name calls return nil' do
-      let(:anonymous_class)      { Class.new         }
-      let(:object_space_modules) { [anonymous_class] }
-
-      include_examples 'bootstrap call'
-    end
-
-    context 'when requires are configured' do
-      let(:config)   { super().with(requires: %w[foo bar]) }
-      let(:requires) { []                                  }
-
-      before do
-        allow(kernel).to receive(:require, &requires.method(:<<))
-      end
-
-      it 'executes requires' do
-        expect { apply }.to change(requires, :to_a).from([]).to(%w[foo bar])
-      end
-
-      include_examples 'bootstrap call'
-    end
-
-    context 'when includes are configured' do
-      let(:config) { super().with(includes: %w[foo bar]) }
-
-      it 'appends to load path' do
-        expect { apply }
-          .to change(load_path, :to_a)
-          .from(load_path.dup)
-          .to(%w[original foo bar])
-      end
-
-      include_examples 'bootstrap call'
-    end
-
-    context 'when Module#name does not return a String or nil' do
-      let(:object_space_modules) { [invalid_class] }
-
-      let(:invalid_class) do
-        # intentionally an object to not actually pollute object space
-        Object.new.tap do |object|
-          def object.name
-            Object
-          end
-        end
-      end
-
-      let(:expected_warning) do
-        "Object#name from: #{invalid_class} " \
-        "returned Object. #{Mutant::Env::SEMANTICS_MESSAGE}"
-      end
-
-      include_examples 'expected warning'
-      include_examples 'bootstrap call'
-    end
-
-    context 'when object name cannot be parsed as expression' do
-      let(:object_space_modules) { [invalid_class] }
-
-      let(:invalid_class) do
-        # intentionally an object to not actually pollute object space
-        Object.new.tap do |object|
-          def object.name
-            'invalid expression'
-          end
-        end
-      end
-
-      include_examples 'bootstrap call'
-    end
-
-    context 'when scope matches expression' do
-      let(:object_space_modules) { [TestApp::Literal, TestApp::Empty]                               }
-      let(:match_expressions)    { object_space_modules.map(&:name).map(&method(:parse_expression)) }
-
-      let(:matcher_config) do
-        super().with(match_expressions: match_expressions)
-      end
-
-      let(:env_with_scopes) do
-        env_empty.with(
-          matchable_scopes: [
-            Mutant::Scope.new(TestApp::Empty,   match_expressions.last),
-            Mutant::Scope.new(TestApp::Literal, match_expressions.first)
-          ]
-        )
-      end
-
-      let(:expected_env) do
-        subjects = Mutant::Matcher::Scope.new(TestApp::Literal).call(env_empty)
-
-        super().with(
-          mutations: subjects.flat_map(&:mutations),
-          subjects:  subjects
-        )
-      end
-
-      include_examples 'bootstrap call'
-    end
-  end
-end