mutant 0.9.11 → 0.9.12

data/spec/unit/mutant/context_spec.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Context do
-  describe '.wrap' do
-    subject { described_class.wrap(scope, node) }
-
-    let(:node) { s(:str, 'test') }
-
-    context 'with Module as scope' do
-      let(:scope) { Mutant }
-
-      let(:expected) do
-        s(:module,
-          s(:const, nil, :Mutant),
-          s(:str, 'test'))
-      end
-
-      it { should eql(expected) }
-    end
-
-    context 'with Class as scope' do
-      let(:scope) { Mutant::Context }
-
-      let(:expected) do
-        s(:class,
-          s(:const, nil, :Context),
-          nil,
-          s(:str, 'test'))
-      end
-
-      it { should eql(expected) }
-    end
-  end
-
-  let(:object)      { described_class.new(scope, source_path) }
-  let(:source_path) { instance_double(Pathname)               }
-  let(:scope)       { TestApp::Literal                        }
-
-  describe '#identification' do
-    subject { object.identification }
-
-    it { should eql(scope.name) }
-  end
-
-  describe '#root' do
-    subject { object.root(node) }
-
-    let(:node) { s(:sym, :node) }
-
-    let(:expected_source) do
-      generate(parse(<<-RUBY))
-        module TestApp
-          class Literal
-            :node
-          end
-        end
-      RUBY
-    end
-
-    let(:generated_source) do
-      Unparser.unparse(subject)
-    end
-
-    it 'should create correct source' do
-      expect(generated_source).to eql(expected_source)
-    end
-  end
-
-  describe '#unqualified_name' do
-    subject { object.unqualified_name }
-
-    context 'with top level constant name' do
-      let(:scope) { TestApp }
-
-      it 'should return the unqualified name' do
-        should eql('TestApp')
-      end
-
-      it_should_behave_like 'an idempotent method'
-    end
-
-    context 'with scoped constant name' do
-      it 'should return the unqualified name' do
-        should eql('Literal')
-      end
-
-      it_should_behave_like 'an idempotent method'
-    end
-  end
-
-  describe '#match_expressions' do
-    subject { object.match_expressions }
-
-    context 'on toplevel scope' do
-      let(:scope) { TestApp }
-
-      it { should eql([parse_expression('TestApp*')]) }
-    end
-
-    context 'on nested scope' do
-      specify do
-        should eql(
-          [
-            parse_expression('TestApp::Literal*'),
-            parse_expression('TestApp*')
-          ]
-        )
-      end
-    end
-  end
-end

data/spec/unit/mutant/env_spec.rb

@@ -1,229 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Env do
-  subject do
-    described_class.new(
-      config:           config,
-      integration:      integration,
-      matchable_scopes: [],
-      mutations:        [],
-      selector:         selector,
-      subjects:         subjects,
-      parser:           Mutant::Parser.new,
-      world:            world
-    )
-  end
-
-  let(:integration_class) { Mutant::Integration::Null            }
-  let(:isolation)         { Mutant::Isolation::None.new          }
-  let(:kernel)            { instance_double(Object, 'kernel')    }
-  let(:reporter)          { instance_double(Mutant::Reporter)    }
-  let(:selector)          { instance_double(Mutant::Selector)    }
-  let(:subject_a)         { instance_double(Mutant::Subject, :a) }
-  let(:subject_b)         { instance_double(Mutant::Subject, :b) }
-  let(:subjects)          { [subject_a, subject_b]               }
-  let(:test_a)            { instance_double(Mutant::Test, :a)    }
-  let(:test_b)            { instance_double(Mutant::Test, :b)    }
-  let(:test_c)            { instance_double(Mutant::Test, :c)    }
-
-  let(:integration) do
-    instance_double(Mutant::Integration, all_tests: [test_a, test_b, test_c])
-  end
-
-  let(:mutation) do
-    instance_double(
-      Mutant::Mutation,
-      subject: subject_a
-    )
-  end
-
-  let(:config) do
-    instance_double(
-      Mutant::Config,
-      integration: integration_class,
-      isolation:   isolation,
-      reporter:    reporter
-    )
-  end
-
-  let(:world) do
-    instance_double(
-      Mutant::World,
-      kernel: kernel
-    )
-  end
-
-  before do
-    allow(selector).to receive(:call)
-      .with(subject_a)
-      .and_return([test_a, test_b])
-
-    allow(selector).to receive(:call)
-      .with(subject_b)
-      .and_return([test_b, test_c])
-
-    allow(Mutant::Timer).to receive(:now).and_return(2.0, 3.0)
-  end
-
-  describe '#kill' do
-    def apply
-      subject.kill(mutation)
-    end
-
-    before do
-      allow(isolation).to receive(:call) do |&block|
-        Mutant::Isolation::Result::Success.new(block.call)
-      end
-
-      allow(mutation).to receive_messages(insert: loader_result)
-    end
-
-    shared_examples 'mutation kill' do
-      it 'returns expected result' do
-        expect(apply).to eql(
-          Mutant::Result::Mutation.new(
-            isolation_result: isolation_result,
-            mutation:         mutation,
-            runtime:          1.0
-          )
-        )
-      end
-    end
-
-    context 'when loader is successful' do
-      let(:loader_result) { Mutant::Loader::Result::Success.instance }
-      let(:test_result)   { instance_double(Mutant::Result::Test)    }
-
-      let(:isolation_result) do
-        Mutant::Isolation::Result::Success.new(test_result)
-      end
-
-      before do
-        allow(integration).to receive_messages(call: test_result)
-      end
-
-      it 'performs IO in expected sequence' do
-        apply
-
-        expect(isolation).to have_received(:call).ordered
-        expect(mutation).to have_received(:insert).ordered.with(kernel)
-        expect(integration).to have_received(:call).ordered.with([test_a, test_b])
-      end
-
-      include_examples 'mutation kill'
-    end
-
-    context 'when loader reports void value' do
-      let(:loader_result) { Mutant::Loader::Result::VoidValue.instance }
-
-      let(:isolation_result) do
-        Mutant::Isolation::Result::Success.new(Mutant::Result::Test::VoidValue.instance)
-      end
-
-      it 'performs IO in expected sequence' do
-        apply
-
-        expect(isolation).to have_received(:call).ordered
-        expect(mutation).to have_received(:insert).ordered.with(kernel)
-      end
-
-      include_examples 'mutation kill'
-    end
-  end
-
-  describe '#selections' do
-    def apply
-      subject.selections
-    end
-
-    it 'returns expected selections' do
-      expect(apply).to eql(
-        subject_a => [test_a, test_b],
-        subject_b => [test_b, test_c]
-      )
-    end
-  end
-
-  describe '#warn' do
-    def apply
-      subject.warn(message)
-    end
-
-    before do
-      allow(reporter).to receive_messages(warn: reporter)
-    end
-
-    let(:message) { 'test-warning' }
-
-    it 'warns via the reporter' do
-      apply
-
-      expect(reporter).to have_received(:warn).with(message)
-    end
-
-    it 'returns self' do
-      expect(apply).to be(subject)
-    end
-  end
-
-  describe '#amount_mutations' do
-    def apply
-      subject.amount_mutations
-    end
-
-    it 'returns expected value' do
-      expect(apply).to be(0)
-    end
-  end
-
-  describe '#amount_total_tests' do
-    def apply
-      subject.amount_total_tests
-    end
-
-    it 'returns expected value' do
-      expect(apply).to be(3)
-    end
-  end
-
-  describe '#test_subject_ratio' do
-    def apply
-      subject.test_subject_ratio
-    end
-
-    context 'on empty subjects' do
-      let(:subjects) { [] }
-
-      it 'returns expected value' do
-        expect(apply).to eql(Rational(0))
-      end
-    end
-
-    context 'on non empty subjects' do
-      it 'returns expected value' do
-        expect(apply).to eql(Rational(3, 2))
-      end
-    end
-  end
-
-  describe '.empty' do
-    def apply
-      described_class.empty(world, config)
-    end
-
-    it 'returns empty env' do
-      expect(apply).to eql(
-        described_class.new(
-          config:           config,
-          integration:      Mutant::Integration::Null.new(config),
-          matchable_scopes: Mutant::EMPTY_ARRAY,
-          mutations:        Mutant::EMPTY_ARRAY,
-          parser:           Mutant::Parser.new,
-          selector:         Mutant::Selector::Null.new,
-          subjects:         Mutant::EMPTY_ARRAY,
-          world:            world
-        )
-      )
-    end
-  end
-end

data/spec/unit/mutant/expression/method_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Expression::Method do
-  let(:object)           { parse_expression(input)   }
-  let(:env)              { Fixtures::TEST_ENV        }
-  let(:instance_method)  { 'TestApp::Literal#string' }
-  let(:singleton_method) { 'TestApp::Literal.string' }
-
-  describe '#match_length' do
-    let(:input) { instance_method }
-
-    subject { object.match_length(other) }
-
-    context 'when other is an equivalent expression' do
-      let(:other) { parse_expression(object.syntax) }
-
-      it { should be(object.syntax.length) }
-    end
-
-    context 'when other is an unequivalent expression' do
-      let(:other) { parse_expression('Foo*') }
-
-      it { should be(0) }
-    end
-  end
-
-  describe '#matcher' do
-    subject { object.matcher }
-
-    context 'with an instance method' do
-      let(:input) { instance_method }
-
-      it 'returns correct matcher' do
-        expect(subject.call(env).map(&:expression)).to eql([object])
-      end
-    end
-
-    context 'with a singleton method' do
-      let(:input) { singleton_method }
-
-      it 'returns correct matcher' do
-        expect(subject.call(env).map(&:expression)).to eql([object])
-      end
-    end
-  end
-
-  describe '#syntax' do
-    subject { object.syntax }
-
-    context 'on instance method' do
-      let(:input) { instance_method }
-
-      it { should eql(instance_method) }
-    end
-
-    context 'on singleton method' do
-      let(:input) { singleton_method }
-
-      it { should eql(singleton_method) }
-    end
-  end
-end

data/spec/unit/mutant/expression/methods_spec.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Expression::Methods do
-  let(:object) { described_class.new(attributes) }
-
-  describe '#match_length' do
-    let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '#' } }
-
-    subject { object.match_length(other) }
-
-    context 'when other is an equivalent expression' do
-      let(:other) { parse_expression(object.syntax) }
-
-      it { should be(object.syntax.length) }
-    end
-
-    context 'when other is matched' do
-      let(:other) { parse_expression('TestApp::Literal#foo') }
-
-      it { should be(object.syntax.length) }
-    end
-
-    context 'when other is an not matched expression' do
-      let(:other) { parse_expression('Foo*') }
-
-      it { should be(0) }
-    end
-  end
-
-  describe '#syntax' do
-    subject { object.syntax }
-
-    context 'with an instance method' do
-      let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '#' } }
-
-      it { should eql('TestApp::Literal#') }
-    end
-
-    context 'with a singleton method' do
-      let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '.' } }
-
-      it { should eql('TestApp::Literal.') }
-    end
-  end
-
-  describe '#matcher' do
-    subject { object.matcher }
-
-    context 'with an instance method' do
-      let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '#' } }
-
-      it { should eql(Mutant::Matcher::Chain.new([Mutant::Matcher::Methods::Instance.new(TestApp::Literal)])) }
-    end
-
-    context 'with a singleton method' do
-      let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '.' } }
-
-      it do
-        should eql(Mutant::Matcher::Chain.new([
-          Mutant::Matcher::Methods::Singleton.new(TestApp::Literal),
-          Mutant::Matcher::Methods::Metaclass.new(TestApp::Literal)
-        ]))
-      end
-    end
-  end
-end