mutant 0.9.8 → 0.9.13

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,61 +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::Methods::Instance.new(TestApp::Literal)) }
-    end
-
-    context 'with a singleton method' do
-      let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '.' } }
-
-      it { should eql(Mutant::Matcher::Methods::Singleton.new(TestApp::Literal)) }
-    end
-  end
-end

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