mutant 0.9.10 → 0.10.0

data/spec/unit/mutant/expression/namespace/exact_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Expression::Namespace::Exact do
-  let(:object) { parse_expression(input) }
-  let(:input)  { 'TestApp::Literal'      }
-
-  describe '#matcher' do
-    subject { object.matcher }
-
-    it { should eql(Mutant::Matcher::Scope.new(TestApp::Literal)) }
-  end
-
-  describe '#match_length' do
-    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
-end

data/spec/unit/mutant/expression/namespace/recursive_spec.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Expression::Namespace::Recursive do
-  let(:object) { parse_expression(input) }
-  let(:input)  { 'TestApp::Literal*'     }
-
-  describe '#matcher' do
-    subject { object.matcher }
-
-    it { should eql(Mutant::Matcher::Namespace.new(object)) }
-  end
-
-  describe '#syntax' do
-    subject { object.syntax }
-
-    it { should eql(input) }
-  end
-
-  describe '#match_length' do
-    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 expression describes a shorter prefix' do
-      let(:other) { parse_expression('TestApp') }
-
-      it { should be(0) }
-    end
-
-    context 'when other expression describes adjacent namespace' do
-      let(:other) { parse_expression('TestApp::LiteralFoo') }
-
-      it { should be(0) }
-    end
-
-    context 'when other expression describes root namespace' do
-      let(:other) { parse_expression('TestApp::Literal') }
-
-      it { should be(16) }
-    end
-
-    context 'when other expression describes a longer prefix' do
-      context 'on constants' do
-        let(:other) { parse_expression('TestApp::Literal::Deep') }
-
-        it { should be(input[0..-2].length) }
-      end
-
-      context 'on singleton method' do
-        let(:other) { parse_expression('TestApp::Literal.foo') }
-
-        it { should be(input[0..-2].length) }
-      end
-
-      context 'on instance method' do
-        let(:other) { parse_expression('TestApp::Literal#foo') }
-
-        it { should be(input[0..-2].length) }
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Expression::Parser do
-  subject do
-    Mutant::Config::DEFAULT.expression_parser
-  end
-
-  def apply
-    subject.apply(input)
-  end
-
-  describe '#apply' do
-    context 'on a valid expression' do
-      let(:input) { 'Foo' }
-
-      it 'returns sucess' do
-        expect(apply).to eql(
-          Mutant::Either::Right.new(
-            Mutant::Expression::Namespace::Exact.new(scope_name: 'Foo')
-          )
-        )
-      end
-    end
-
-    context 'on invalid input' do
-      let(:input) { 'foo bar' }
-
-      it 'returns returns error' do
-        expect(apply).to eql(
-          Mutant::Either::Left.new('Expression: "foo bar" is invalid')
-        )
-      end
-    end
-
-    context 'on ambiguous input' do
-      subject do
-        described_class.new([test_a, test_b])
-      end
-
-      let(:test_a) do
-        Class.new(Mutant::Expression) do
-          include Anima.new
-          const_set(:REGEXP, /\Atest-syntax\z/.freeze)
-        end
-      end
-
-      let(:test_b) do
-        Class.new(Mutant::Expression) do
-          include Anima.new
-          const_set(:REGEXP, /^test-syntax$/.freeze)
-        end
-      end
-
-      let(:input) { 'test-syntax' }
-
-      it 'returns error' do
-        expect(apply).to eql(
-          Mutant::Either::Left.new(
-            'Expression: "test-syntax" is ambiguous'
-          )
-        )
-      end
-    end
-  end
-end

data/spec/unit/mutant/expression_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Expression do
-  describe '#prefix?' do
-    let(:object) { parse_expression('Foo*') }
-
-    subject { object.prefix?(other) }
-
-    context 'when object is a prefix of other' do
-      let(:other) { parse_expression('Foo::Bar') }
-
-      it { should be(true) }
-    end
-
-    context 'when other is not a prefix of other' do
-      let(:other) { parse_expression('Bar') }
-
-      it { should be(false) }
-    end
-  end
-
-  describe '.try_parse' do
-    let(:object) do
-      Class.new(described_class) do
-        include Anima.new(:foo)
-
-        const_set(:REGEXP, /(?<foo>foo)/)
-      end
-    end
-
-    subject { object.try_parse(input) }
-
-    context 'good input' do
-      let(:input) { 'foo' }
-
-      it { should eql(object.new(foo: 'foo')) }
-    end
-
-    context 'bad input' do
-      let(:input) { 'bar' }
-
-      it { should be(nil) }
-    end
-  end
-end

data/spec/unit/mutant/integration/rspec_spec.rb

@@ -1,201 +0,0 @@
-# frozen_string_literal: true
-
-require 'mutant/integration/rspec'
-
-RSpec.describe Mutant::Integration::Rspec do
-  let(:object) { described_class.new(Mutant::Config::DEFAULT) }
-
-  let(:rspec_options) { instance_double(RSpec::Core::ConfigurationOptions) }
-  let(:rspec_runner)  { instance_double(RSpec::Core::Runner)               }
-
-  let(:example_a) do
-    double(
-      'Example A',
-      metadata: {
-        location:         'example-a-location',
-        full_description: 'example-a-full-description'
-      }
-    )
-  end
-
-  let(:example_b) do
-    double(
-      'Example B',
-      metadata: {
-        location:         'example-b-location',
-        full_description: 'example-b-full-description',
-        mutant:           false
-      }
-    )
-  end
-
-  let(:example_c) do
-    double(
-      'Example C',
-      metadata: {
-        location:         'example-c-location',
-        full_description: 'Example::C blah'
-      }
-    )
-  end
-
-  let(:example_d) do
-    double(
-      'Example D',
-      metadata: {
-        location:         'example-d-location',
-        full_description: "Example::D\nblah"
-      }
-    )
-  end
-
-  let(:example_e) do
-    double(
-      'Example E',
-      metadata: {
-        location:          'example-e-location',
-        full_description:  'Example::E',
-        mutant_expression: 'Foo'
-      }
-    )
-  end
-
-  let(:examples) do
-    [
-      example_a,
-      example_b,
-      example_c,
-      example_d,
-      example_e
-    ]
-  end
-
-  let(:example_groups) do
-    [
-      double(
-        'root example group',
-        descendants: [
-          double('example group', examples: examples)
-        ]
-      )
-    ]
-  end
-
-  let(:filtered_examples) do
-    {
-      double('Key') => examples.dup
-    }
-  end
-
-  let(:world) do
-    double(
-      'world',
-      example_groups:    example_groups,
-      filtered_examples: filtered_examples
-    )
-  end
-
-  let(:all_tests) do
-    [
-      Mutant::Test.new(
-        id:         'rspec:0:example-a-location/example-a-full-description',
-        expression: parse_expression('*')
-      ),
-      Mutant::Test.new(
-        id:         'rspec:1:example-c-location/Example::C blah',
-        expression: parse_expression('Example::C')
-      ),
-      Mutant::Test.new(
-        id:         "rspec:2:example-d-location/Example::D\nblah",
-        expression: parse_expression('*')
-      ),
-      Mutant::Test.new(
-        id:         'rspec:3:example-e-location/Example::E',
-        expression: parse_expression('Foo')
-      )
-    ]
-  end
-
-  before do
-    expect(RSpec::Core::ConfigurationOptions).to receive(:new)
-      .with(%w[spec --fail-fast])
-      .and_return(rspec_options)
-
-    expect(RSpec::Core::Runner).to receive(:new)
-      .with(rspec_options)
-      .and_return(rspec_runner)
-
-    expect(RSpec).to receive_messages(world: world)
-    allow(Mutant::Timer).to receive_messages(now: Mutant::Timer.now)
-  end
-
-  describe '#all_tests' do
-    subject { object.all_tests }
-
-    it { should eql(all_tests) }
-  end
-
-  describe '#setup' do
-    subject { object.setup }
-
-    before do
-      expect(rspec_runner).to receive(:setup) do |error, output|
-        expect(error).to be($stderr)
-        output.write('foo')
-      end
-    end
-
-    it { should be(object) }
-  end
-
-  describe '#call' do
-    subject { object.call(tests) }
-
-    before do
-      expect(rspec_runner).to receive(:setup) do |_errors, output|
-        output.write('the-test-output')
-      end
-
-      object.setup
-    end
-
-    let(:tests) { [all_tests.fetch(0)] }
-
-    before do
-      expect(world).to receive(:ordered_example_groups) do
-        filtered_examples.values.flatten
-      end
-      expect(rspec_runner).to receive(:run_specs).with([example_a]).and_return(exit_status)
-    end
-
-    context 'on unsuccessful exit' do
-      let(:exit_status) { 1 }
-
-      it 'should return failed result' do
-        expect(subject).to eql(
-          Mutant::Result::Test.new(
-            output:  'the-test-output',
-            passed:  false,
-            runtime: 0.0,
-            tests:   tests
-          )
-        )
-      end
-    end
-
-    context 'on successful exit' do
-      let(:exit_status) { 0 }
-
-      it 'should return passed result' do
-        expect(subject).to eql(
-          Mutant::Result::Test.new(
-            output:  'the-test-output',
-            passed:  true,
-            runtime: 0.0,
-            tests:   tests
-          )
-        )
-      end
-    end
-  end
-end

data/spec/unit/mutant/integration_spec.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Integration do
-  subject { class_under_test.new(Mutant::Config::DEFAULT) }
-
-  let(:class_under_test) do
-    Class.new(described_class)
-  end
-
-  describe '#setup' do
-    def apply
-      subject.setup
-    end
-
-    it 'returns self' do
-      expect(apply).to be(subject)
-    end
-  end
-
-  describe '.setup' do
-    def apply
-      described_class.setup(env)
-    end
-
-    let(:kernel)           { class_double(Kernel)                       }
-    let(:integration)      { instance_double(Mutant::Integration::Null) }
-    let(:integration_name) { 'null'                                     }
-
-    let(:config) do
-      instance_double(
-        Mutant::Config,
-        integration: integration_name
-      )
-    end
-
-    let(:env) do
-      instance_double(
-        Mutant::Env,
-        config: config,
-        world:  world
-      )
-    end
-
-    let(:world) do
-      instance_double(
-        Mutant::World,
-        kernel: kernel
-      )
-    end
-
-    before do
-      allow(kernel).to receive_messages(require: undefined)
-      allow(described_class).to receive_messages(const_get: described_class::Null)
-      allow(described_class::Null).to receive_messages(new: integration)
-      allow(integration).to receive_messages(setup: integration)
-    end
-
-    context 'when require fails' do
-      let(:exception) { LoadError.new('some-load-error') }
-
-      before do
-        allow(kernel).to receive(:require).and_raise(exception)
-      end
-
-      it 'returns error' do
-        expect(apply).to eql(Mutant::Either::Left.new(<<~MESSAGE))
-          Unable to load integration mutant-null:
-          #{exception.inspect}
-          You may have to install the gem mutant-null!
-        MESSAGE
-      end
-    end
-
-    context 'when constant lookup fails' do
-      let(:exception) { NameError.new('some-name-error') }
-
-      before do
-        allow(described_class).to receive(:const_get).and_raise(exception)
-      end
-
-      it 'returns error' do
-        expect(apply).to eql(Mutant::Either::Left.new(<<~MESSAGE))
-          Unable to load integration mutant-null:
-          #{exception.inspect}
-          This is a bug in the integration you have to report.
-          The integration is supposed to define Mutant::Integration::Null!
-        MESSAGE
-      end
-    end
-
-    it 'performs actions in expected sequence' do
-      apply
-
-      expect(kernel)
-        .to have_received(:require)
-        .with('mutant/integration/null')
-        .ordered
-
-      expect(described_class)
-        .to have_received(:const_get)
-        .with('Null')
-        .ordered
-
-      expect(described_class::Null)
-        .to have_received(:new)
-        .with(config)
-        .ordered
-
-      expect(integration)
-        .to have_received(:setup)
-        .ordered
-    end
-
-    it 'returns integration instance' do
-      expect(apply).to eql(
-        Mutant::Either::Right.new(integration)
-      )
-    end
-  end
-end
-
-RSpec.describe Mutant::Integration::Null do
-
-  let(:object) { described_class.new(Mutant::Config::DEFAULT) }
-
-  describe '#all_tests' do
-    subject { object.all_tests }
-
-    it { should eql([]) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '#call' do
-    let(:tests) { instance_double(Array) }
-
-    subject { object.call(tests) }
-
-    it 'returns test result' do
-      should eql(
-        Mutant::Result::Test.new(
-          output:  '',
-          passed:  true,
-          runtime: 0.0,
-          tests:   tests
-        )
-      )
-    end
-  end
-end