mutant 0.9.7 → 0.9.12

data/spec/unit/mutant/selector/expression_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Selector::Expression do
-  describe '#call' do
-    let(:object) { described_class.new(integration) }
-
-    let(:mutation_subject) { subject_class.new(context: context, node: node, warnings: warnings)     }
-    let(:context)          { instance_double(Mutant::Context)                                        }
-    let(:node)             { instance_double(Parser::AST::Node)                                      }
-    let(:integration)      { instance_double(Mutant::Integration, all_tests: all_tests)              }
-    let(:test_a)           { instance_double(Mutant::Test, expression: parse_expression('SubjectA')) }
-    let(:test_b)           { instance_double(Mutant::Test, expression: parse_expression('SubjectB')) }
-    let(:test_c)           { instance_double(Mutant::Test, expression: parse_expression('SubjectC')) }
-    let(:warnings)         { instance_double(Mutant::Warnings)                                       }
-
-    let(:subject_class) do
-      parse = method(:parse_expression)
-
-      Class.new(Mutant::Subject) do
-        define_method(:expression) do
-          parse.call('SubjectA')
-        end
-
-        define_method(:match_expressions) do
-          [expression] << parse.call('SubjectB')
-        end
-      end
-    end
-
-    subject { object.call(mutation_subject) }
-
-    context 'without available tests' do
-      let(:all_tests) { [] }
-
-      it { should eql([]) }
-    end
-
-    context 'without qualifying tests' do
-      let(:all_tests) { [test_c] }
-
-      it { should eql([]) }
-    end
-
-    context 'with qualifying tests for first match expression' do
-      let(:all_tests) { [test_a] }
-
-      it { should eql([test_a]) }
-    end
-
-    context 'with qualifying tests for second match expression' do
-      let(:all_tests) { [test_b] }
-
-      it { should eql([test_b]) }
-    end
-
-    context 'with qualifying tests for the first and second match expression' do
-      let(:all_tests) { [test_a, test_b] }
-
-      it { should eql([test_a]) }
-    end
-  end
-end

data/spec/unit/mutant/selector/null_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Selector::Null do
-  describe '#call' do
-    subject { described_class.new }
-
-    let(:mutant_subject) { instance_double(Mutant::Subject) }
-
-    def apply
-      subject.call(mutant_subject)
-    end
-
-    it 'returns no tests' do
-      expect(apply).to eql([])
-    end
-  end
-end

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

@@ -1,181 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Subject::Method::Instance do
-  let(:object) do
-    described_class.new(
-      context:  context,
-      node:     node,
-      warnings: warnings
-    )
-  end
-
-  let(:call_block?) { true                              }
-  let(:warnings)    { instance_double(Mutant::Warnings) }
-
-  let(:context) do
-    Mutant::Context.new(
-      scope,
-      instance_double(Pathname)
-    )
-  end
-
-  let(:node) do
-    s(:def, :foo, s(:args))
-  end
-
-  let(:scope) do
-    Class.new do
-      attr_reader :bar
-
-      def initialize
-        @bar = :boo
-      end
-
-      def foo; end
-
-      def self.name
-        'Test'
-      end
-    end
-  end
-
-  before do
-    allow(warnings).to receive(:call) do |&block|
-      block.call if call_block?
-    end
-  end
-
-  describe '#expression' do
-    subject { object.expression }
-
-    it { should eql(parse_expression('Test#foo')) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '#match_expression' do
-    subject { object.match_expressions }
-
-    it { should eql(%w[Test#foo Test*].map(&method(:parse_expression))) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '#prepare' do
-    let(:context) do
-      Mutant::Context.new(scope, instance_double(Pathname))
-    end
-
-    subject { object.prepare }
-
-    it 'undefines method on scope' do
-      expect { subject }
-        .to change { scope.instance_methods.include?(:foo) }
-        .from(true)
-        .to(false)
-    end
-
-    context 'within warning capture' do
-      let(:call_block?) { false }
-
-      it 'undefines method on scope' do
-        expect { subject }
-          .to_not change { scope.instance_methods.include?(:foo) }
-          .from(true)
-      end
-    end
-
-    it_should_behave_like 'a command method'
-  end
-
-  describe '#source' do
-    subject { object.source }
-
-    it { should eql("def foo\nend") }
-  end
-end
-
-RSpec.describe Mutant::Subject::Method::Instance::Memoized do
-  let(:object) do
-    described_class.new(
-      context:  context,
-      node:     node,
-      warnings: warnings
-    )
-  end
-
-  let(:context)  { double('Context')                 }
-  let(:warnings) { instance_double(Mutant::Warnings) }
-
-  let(:node) do
-    s(:def, :foo, s(:args))
-  end
-
-  before do
-    allow(warnings).to receive(:call).and_yield
-  end
-
-  describe '#prepare' do
-
-    let(:context) do
-      Mutant::Context.new(scope, double('Source Path'))
-    end
-
-    let(:scope) do
-      Class.new do
-        include Memoizable
-        def foo; end
-        memoize :foo
-      end
-    end
-
-    subject { object.prepare }
-
-    it 'undefines memoizer' do
-      expect { subject }.to change { scope.memoized?(:foo) }.from(true).to(false)
-    end
-
-    it 'undefines method on scope' do
-      expect { subject }.to change { scope.instance_methods.include?(:foo) }.from(true).to(false)
-    end
-
-    it_should_behave_like 'a command method'
-  end
-
-  describe '#mutations', mutant_expression: 'Mutant::Subject#mutations' do
-    subject { object.mutations }
-
-    let(:expected) do
-      [
-        Mutant::Mutation::Neutral.new(
-          object,
-          s(:begin,
-            s(:def, :foo, s(:args)), s(:send, nil, :memoize, s(:args, s(:sym, :foo))))
-        ),
-        Mutant::Mutation::Evil.new(
-          object,
-          s(:begin,
-            s(:def, :foo, s(:args), s(:send, nil, :raise)), s(:send, nil, :memoize, s(:args, s(:sym, :foo))))
-        ),
-        Mutant::Mutation::Evil.new(
-          object,
-          s(:begin,
-            s(:def, :foo, s(:args), s(:zsuper)), s(:send, nil, :memoize, s(:args, s(:sym, :foo))))
-        ),
-        Mutant::Mutation::Evil.new(
-          object,
-          s(:begin,
-            s(:def, :foo, s(:args), nil), s(:send, nil, :memoize, s(:args, s(:sym, :foo))))
-        )
-      ]
-    end
-
-    it { should eql(expected) }
-  end
-
-  describe '#source' do
-    subject { object.source }
-
-    it { should eql("def foo\nend\nmemoize(:foo)") }
-  end
-end

data/spec/unit/mutant/subject/method/singleton_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Subject::Method::Singleton do
-  let(:object) do
-    described_class.new(
-      context:  context,
-      node:     node,
-      warnings: warnings
-    )
-  end
-
-  let(:node)     { s(:defs, s(:self), :foo, s(:args)) }
-  let(:warnings) { instance_double(Mutant::Warnings)  }
-
-  let(:context) do
-    Mutant::Context.new(scope, instance_double(Pathname))
-  end
-
-  let(:scope) do
-    Class.new do
-      def self.foo; end
-
-      def self.name
-        'Test'
-      end
-    end
-  end
-
-  describe '#expression' do
-    subject { object.expression }
-
-    it { should eql(parse_expression('Test.foo')) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '#match_expression' do
-    subject { object.match_expressions }
-
-    it { should eql(%w[Test.foo Test*].map(&method(:parse_expression))) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '#prepare' do
-
-    subject { object.prepare }
-
-    it 'undefines method on scope' do
-      expect { subject }.to change { scope.methods.include?(:foo) }.from(true).to(false)
-    end
-
-    it_should_behave_like 'a command method'
-  end
-
-  describe '#source' do
-    subject { object.source }
-
-    it { should eql("def self.foo\nend") }
-  end
-end

data/spec/unit/mutant/subject_spec.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Subject do
-  let(:class_under_test) do
-    Class.new(described_class) do
-      def expression
-        Mutant::Expression::Namespace::Exact.new(scope_name: 'SubjectA')
-      end
-
-      def match_expressions
-        [
-          expression,
-          Mutant::Expression::Namespace::Exact.new(scope_name: 'SubjectB')
-        ]
-      end
-    end
-  end
-
-  let(:object) do
-    class_under_test.new(
-      context:  context,
-      node:     node,
-      warnings: warnings
-    )
-  end
-
-  let(:node) do
-    Unparser.parse(<<-RUBY)
-      def foo
-      end
-    RUBY
-  end
-
-  let(:context) do
-    double(
-      'Context',
-      source_path: 'source_path'
-    )
-  end
-
-  let(:warnings) { instance_double(Mutant::Warnings) }
-
-  describe '#identification' do
-    subject { object.identification }
-
-    it { should eql('SubjectA:source_path:1') }
-  end
-
-  describe '#source_line' do
-    subject { object.source_line }
-
-    it { should be(1) }
-  end
-
-  describe '#source_lines' do
-    subject { object.source_lines }
-
-    it { should eql(1..2) }
-  end
-
-  describe '#prepare' do
-    subject { object.prepare }
-
-    it_should_behave_like 'a command method'
-  end
-
-  describe '#node' do
-    subject { object.node }
-
-    it { should be(node) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '#mutations' do
-    subject { object.mutations }
-
-    before do
-      expect(Mutant::Mutator).to receive(:mutate).with(node).and_return([mutation_a, mutation_b])
-    end
-
-    let(:mutation_a) { instance_double(Parser::AST::Node, :mutation_a) }
-    let(:mutation_b) { instance_double(Parser::AST::Node, :mutation_b) }
-
-    it 'generates neutral and evil mutations' do
-      should eql([
-        Mutant::Mutation::Neutral.new(object, node),
-        Mutant::Mutation::Evil.new(object, mutation_a),
-        Mutant::Mutation::Evil.new(object, mutation_b)
-      ])
-    end
-  end
-end

data/spec/unit/mutant/transform/array_spec.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Transform::Array do
-  subject { described_class.new(transform) }
-
-  let(:transform) { Mutant::Transform::Boolean.new }
-
-  describe '#apply' do
-    def apply
-      subject.apply(input)
-    end
-
-    context 'on array input' do
-      context 'empty' do
-        let(:input) { [] }
-
-        it 'returns sucess' do
-          expect(apply).to eql(Mutant::Either::Right.new(input))
-        end
-      end
-
-      context 'valid elements' do
-        let(:input) { [true, true] }
-
-        it 'returns sucess' do
-          expect(apply).to eql(Mutant::Either::Right.new(input))
-        end
-      end
-
-      context 'invalid elements' do
-        let(:input) { [true, 1] }
-
-        let(:boolean_error) do
-          Mutant::Transform::Error.new(
-            cause:     nil,
-            input:     1,
-            message:   'Expected: boolean but got: 1',
-            transform: transform
-          )
-        end
-
-        let(:index_error) do
-          Mutant::Transform::Error.new(
-            cause:     boolean_error,
-            input:     1,
-            message:   nil,
-            transform: Mutant::Transform::Index.new(index: 1, transform: transform)
-          )
-        end
-
-        let(:error) do
-          Mutant::Transform::Error.new(
-            cause:     index_error,
-            input:     input,
-            message:   'Failed to coerce array at index: 1',
-            transform: subject
-          )
-        end
-
-        it 'returns failure' do
-          expect(apply).to eql(Mutant::Either::Left.new(error))
-        end
-      end
-
-      context 'transformed elements' do
-        let(:input)     { [{ 'foo' => 'bar' }]                   }
-        let(:transform) { Mutant::Transform::Hash::Symbolize.new }
-
-        it 'returns transformed elements' do
-          expect(apply).to eql(Mutant::Either::Right.new([foo: 'bar']))
-        end
-      end
-    end
-
-    context 'on other input' do
-      let(:input) { false }
-
-      let(:error) do
-        Mutant::Transform::Error.new(
-          cause:     nil,
-          input:     input,
-          message:   'Expected: Array but got: FalseClass',
-          transform: subject
-        )
-      end
-
-      it 'returns failure' do
-        expect(apply).to eql(Mutant::Either::Left.new(error))
-      end
-    end
-  end
-end