mutest 0.0.1 → 0.0.2

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

@@ -0,0 +1,44 @@
+RSpec.describe Mutest::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
+    subject { object.match_length(other) }
+
+    let(:input) { instance_method }
+
+    context 'when other is an equivalent expression' do
+      let(:other) { parse_expression(object.syntax) }
+
+      it { is_expected.to be(object.syntax.length) }
+    end
+
+    context 'when other is an unequivalent expression' do
+      let(:other) { parse_expression('Foo*') }
+
+      it { is_expected.to 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
+end

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

@@ -0,0 +1,59 @@
+RSpec.describe Mutest::Expression::Methods do
+  let(:object) { described_class.new(attributes) }
+
+  describe '#match_length' do
+    subject { object.match_length(other) }
+
+    let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '#' } }
+
+    context 'when other is an equivalent expression' do
+      let(:other) { parse_expression(object.syntax) }
+
+      it { is_expected.to be(object.syntax.length) }
+    end
+
+    context 'when other is matched' do
+      let(:other) { parse_expression('TestApp::Literal#foo') }
+
+      it { is_expected.to be(object.syntax.length) }
+    end
+
+    context 'when other is an not matched expression' do
+      let(:other) { parse_expression('Foo*') }
+
+      it { is_expected.to 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 { is_expected.to eql('TestApp::Literal#') }
+    end
+
+    context 'with a singleton method' do
+      let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '.' } }
+
+      it { is_expected.to 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 { is_expected.to eql(Mutest::Matcher::Methods::Instance.new(TestApp::Literal)) }
+    end
+
+    context 'with a singleton method' do
+      let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '.' } }
+
+      it { is_expected.to eql(Mutest::Matcher::Methods::Singleton.new(TestApp::Literal)) }
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+RSpec.describe Mutest::Expression::Namespace::Exact do
+  let(:object) { parse_expression(input) }
+  let(:input)  { 'TestApp::Literal'      }
+
+  describe '#matcher' do
+    subject { object.matcher }
+
+    it { is_expected.to eql(Mutest::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 { is_expected.to be(object.syntax.length) }
+    end
+
+    context 'when other is an unequivalent expression' do
+      let(:other) { parse_expression('Foo*') }
+
+      it { is_expected.to be(0) }
+    end
+  end
+end

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

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

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

@@ -0,0 +1,67 @@
+RSpec.describe Mutest::Expression::Parser do
+  let(:object) { Mutest::Config::DEFAULT.expression_parser }
+
+  describe '#call' do
+    subject { object.call(input) }
+
+    context 'on nonsense' do
+      let(:input) { 'foo bar' }
+
+      it 'raises an exception' do
+        expect { subject }.to raise_error(
+          Mutest::Expression::Parser::InvalidExpressionError,
+          'Expression: "foo bar" is not valid'
+        )
+      end
+    end
+
+    context 'on a valid expression' do
+      let(:input) { 'Foo' }
+
+      it { is_expected.to eql(Mutest::Expression::Namespace::Exact.new(scope_name: 'Foo')) }
+    end
+  end
+
+  describe '.try_parse' do
+    subject { object.try_parse(input) }
+
+    context 'on nonsense' do
+      let(:input) { 'foo bar' }
+
+      it { is_expected.to be(nil) }
+    end
+
+    context 'on a valid expression' do
+      let(:input) { 'Foo' }
+
+      it { is_expected.to eql(Mutest::Expression::Namespace::Exact.new(scope_name: 'Foo')) }
+    end
+
+    context 'on ambiguous expression' do
+      let(:object) { described_class.new([test_a, test_b]) }
+
+      let(:test_a) do
+        Class.new(Mutest::Expression) do
+          include Anima.new
+          const_set(:REGEXP, /\Atest-syntax\z/)
+        end
+      end
+
+      let(:test_b) do
+        Class.new(Mutest::Expression) do
+          include Anima.new
+          const_set(:REGEXP, /^test-syntax$/)
+        end
+      end
+
+      let(:input) { 'test-syntax' }
+
+      it 'raises expected exception' do
+        expect { subject }.to raise_error(
+          Mutest::Expression::Parser::AmbiguousExpressionError,
+          'Ambiguous expression: "test-syntax"'
+        )
+      end
+    end
+  end
+end

data/spec/unit/mutest/expression_spec.rb

@@ -0,0 +1,45 @@
+RSpec.describe Mutest::Expression do
+  let(:parser) { Mutest::Config::DEFAULT.expression_parser }
+
+  describe '#prefix?' do
+    subject { object.prefix?(other) }
+
+    let(:object) { parser.call('Foo*') }
+
+    context 'when object is a prefix of other' do
+      let(:other) { parser.call('Foo::Bar') }
+
+      it { is_expected.to be(true) }
+    end
+
+    context 'when other is not a prefix of other' do
+      let(:other) { parser.call('Bar') }
+
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe '.try_parse' do
+    subject { object.try_parse(input) }
+
+    let(:object) do
+      Class.new(described_class) do
+        include Anima.new(:foo)
+
+        const_set(:REGEXP, /(?<foo>foo)/)
+      end
+    end
+
+    context 'on successful parse' do
+      let(:input) { 'foo' }
+
+      it { is_expected.to eql(object.new(foo: 'foo')) }
+    end
+
+    context 'on unsuccessful parse' do
+      let(:input) { 'bar' }
+
+      it { is_expected.to be(nil) }
+    end
+  end
+end

data/spec/unit/mutest/integration/null_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe Mutest::Integration::Null do
+  let(:object) { described_class.new(Mutest::Config::DEFAULT) }
+
+  describe '#all_tests' do
+    subject { object.all_tests }
+
+    it { is_expected.to eql([]) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  describe '#call' do
+    subject { object.call(tests) }
+
+    let(:tests) { instance_double(Array) }
+
+    it 'returns test result' do
+      is_expected.to eql(
+        Mutest::Result::Test.new(
+          output:  '',
+          passed:  true,
+          runtime: 0.0,
+          tests:   tests
+        )
+      )
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+require 'mutest/integration/rspec'
+
+RSpec.describe Mutest::Integration::Rspec do
+  let(:object) { described_class.new(Mutest::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',
+        mutest:           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',
+        mutest_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
+    [
+      Mutest::Test.new(
+        id:         'rspec:0:example-a-location/example-a-full-description',
+        expression: parse_expression('*')
+      ),
+      Mutest::Test.new(
+        id:         'rspec:1:example-c-location/Example::C blah',
+        expression: parse_expression('Example::C')
+      ),
+      Mutest::Test.new(
+        id:         "rspec:2:example-d-location/Example::D\nblah",
+        expression: parse_expression('*')
+      ),
+      Mutest::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(Time).to receive_messages(now: Time.now)
+  end
+
+  describe '#all_tests' do
+    subject { object.all_tests }
+
+    it { is_expected.to 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 { is_expected.to 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
+
+      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
+
+    let(:tests) { [all_tests.fetch(0)] }
+
+    context 'on unsuccessful exit' do
+      let(:exit_status) { 1 }
+
+      it 'returns failed result' do
+        expect(subject).to eql(
+          Mutest::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 'returns passed result' do
+        expect(subject).to eql(
+          Mutest::Result::Test.new(
+            output:  'the-test-output',
+            passed:  true,
+            runtime: 0.0,
+            tests:   tests
+          )
+        )
+      end
+    end
+  end
+end