mutest 0.0.1 → 0.0.2

data/spec/unit/mutest/runner_spec.rb

@@ -0,0 +1,69 @@
+RSpec.describe Mutest::Runner do
+  describe '.call' do
+    subject { described_class.call(env) }
+
+    let(:reporter)    { instance_double(Mutest::Reporter, delay: delay) }
+    let(:driver)      { instance_double(Mutest::Parallel::Driver)       }
+    let(:delay)       { instance_double(Float)                          }
+    let(:env_result)  { instance_double(Mutest::Result::Env)            }
+    let(:actor_env)   { instance_double(Mutest::Actor::Env)             }
+    let(:kernel)      { class_double(Kernel)                            }
+    let(:sleep)       { instance_double(Method)                         }
+
+    let(:env) do
+      instance_double(
+        Mutest::Env,
+        actor_env: actor_env,
+        config:    config,
+        mutations: []
+      )
+    end
+
+    let(:config) do
+      instance_double(
+        Mutest::Config,
+        jobs:     1,
+        kernel:   kernel,
+        reporter: reporter
+      )
+    end
+
+    before do
+      allow(env).to receive(:method).with(:kill).and_return(parallel_config.processor)
+      allow(kernel).to receive(:method).with(:sleep).and_return(sleep)
+      expect(reporter).to receive(:start).with(env).ordered
+      expect(Mutest::Parallel).to receive(:async).with(parallel_config).and_return(driver).ordered
+    end
+
+    let(:parallel_config) do
+      Mutest::Parallel::Config.new(
+        env:       actor_env,
+        jobs:      1,
+        processor: ->(_object) { fail },
+        sink:      Mutest::Runner::Sink.new(env),
+        source:    Mutest::Parallel::Source::Array.new(env.mutations)
+      )
+    end
+
+    context 'when report iterations are done' do
+      let(:status_a) { instance_double(Mutest::Parallel::Status, done: false)                     }
+      let(:status_b) { instance_double(Mutest::Parallel::Status, done: true, payload: env_result) }
+
+      before do
+        expect(driver).to receive(:status).and_return(status_a).ordered
+        expect(reporter).to receive(:progress).with(status_a).ordered
+        expect(sleep).to receive(:call).with(reporter.delay).ordered
+
+        expect(driver).to receive(:status).and_return(status_b).ordered
+        expect(reporter).to receive(:progress).with(status_b).ordered
+        expect(driver).to receive(:stop).ordered
+
+        expect(reporter).to receive(:report).with(env_result).ordered
+      end
+
+      it 'returns env result' do
+        is_expected.to be(env_result)
+      end
+    end
+  end
+end

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

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

data/spec/unit/mutest/source_file_spec.rb

@@ -0,0 +1,42 @@
+RSpec.describe Mutest::SourceFile do
+  subject(:source_file) { described_class.read(path) }
+
+  let(:ast)  { Parser::CurrentRuby.parse(source)       }
+  let(:path) { instance_double(Pathname, read: source) }
+
+  let(:source) do
+    <<-RUBY
+    # rubocop:disable
+    def foo(bar)
+    end
+
+    # mutest:disable
+    def bar
+    end
+    RUBY
+  end
+
+  it 'exposes the AST' do
+    expect(source_file.ast).to eql(ast)
+  end
+
+  it 'exposes the path' do
+    expect(source_file.path).to be(path)
+  end
+
+  it 'ignores the line after the the comment' do
+    foo_method, bar_method = *ast
+
+    aggregate_failures do
+      expect(source_file.ignore?(foo_method)).to be(false)
+      expect(source_file.ignore?(bar_method)).to be(true)
+    end
+  end
+
+  it 'ignores nodes that do not have a location' do
+    _, bar_method = *ast
+    _, bar_method_args, = *bar_method
+
+    expect(source_file.ignore?(bar_method_args)).to be(false)
+  end
+end

data/spec/unit/mutest/subject/method/instance/memoized_spec.rb

@@ -0,0 +1,78 @@
+RSpec.describe Mutest::Subject::Method::Instance::Memoized do
+  let(:object) { described_class.new(context, node) }
+
+  let(:context) do
+    double('Context', source_path: 'source_path', method: ->(_) {})
+  end
+
+  let(:node) do
+    s(:def, :foo, s(:args))
+  end
+
+  describe '#prepare' do
+    subject { object.prepare }
+
+    let(:context) do
+      Mutest::Context.new(
+        scope,
+        instance_double(Mutest::SourceFile)
+      )
+    end
+
+    let(:scope) do
+      Class.new do
+        include Memoizable
+        def foo
+        end
+        memoize :foo
+      end
+    end
+
+    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', mutest_expression: 'Mutest::Subject#mutations' do
+    subject { object.mutations }
+
+    let(:expected) do
+      [
+        Mutest::Mutation::Neutral.new(
+          object,
+          s(:begin,
+            s(:def, :foo, s(:args)), s(:send, nil, :memoize, s(:args, s(:sym, :foo))))
+        ),
+        Mutest::Mutation::Evil.new(
+          object,
+          s(:begin,
+            s(:def, :foo, s(:args), s(:send, nil, :raise)), s(:send, nil, :memoize, s(:args, s(:sym, :foo))))
+        ),
+        Mutest::Mutation::Evil.new(
+          object,
+          s(:begin,
+            s(:def, :foo, s(:args), s(:zsuper)), s(:send, nil, :memoize, s(:args, s(:sym, :foo))))
+        ),
+        Mutest::Mutation::Evil.new(
+          object,
+          s(:begin,
+            s(:def, :foo, s(:args), nil), s(:send, nil, :memoize, s(:args, s(:sym, :foo))))
+        )
+      ]
+    end
+
+    it { is_expected.to eql(expected) }
+  end
+
+  describe '#source' do
+    subject { object.source }
+
+    it { is_expected.to eql("def foo\nend\nmemoize(:foo)") }
+  end
+end

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

@@ -0,0 +1,64 @@
+RSpec.describe Mutest::Subject::Method::Instance do
+  let(:object)  { described_class.new(context, node) }
+
+  let(:context) do
+    Mutest::Context.new(scope, instance_double(Mutest::SourceFile))
+  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
+
+  describe '#expression' do
+    subject { object.expression }
+
+    it { is_expected.to eql(parse_expression('Test#foo')) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  describe '#match_expression' do
+    subject { object.match_expressions }
+
+    it { is_expected.to eql(%w[Test#foo Test*].map(&method(:parse_expression))) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  describe '#prepare' do
+    subject { object.prepare }
+
+    let(:context) do
+      Mutest::Context.new(scope, instance_double(Mutest::SourceFile))
+    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 '#source' do
+    subject { object.source }
+
+    it { is_expected.to eql("def foo\nend") }
+  end
+end

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

@@ -0,0 +1,51 @@
+RSpec.describe Mutest::Subject::Method::Singleton do
+  let(:object)  { described_class.new(context, node) }
+  let(:node)    { s(:defs, s(:self), :foo, s(:args)) }
+
+  let(:context) do
+    Mutest::Context.new(scope, instance_double(Mutest::SourceFile))
+  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 { is_expected.to eql(parse_expression('Test.foo')) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  describe '#match_expression' do
+    subject { object.match_expressions }
+
+    it { is_expected.to 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 { is_expected.to eql("def self.foo\nend") }
+  end
+end

data/spec/unit/mutest/subject_spec.rb

@@ -0,0 +1,87 @@
+RSpec.describe Mutest::Subject do
+  let(:class_under_test) do
+    Class.new(described_class) do
+      def expression
+        Mutest::Expression::Namespace::Exact.new(scope_name: 'SubjectA')
+      end
+
+      def match_expressions
+        [
+          expression,
+          Mutest::Expression::Namespace::Exact.new(scope_name: 'SubjectB')
+        ]
+      end
+    end
+  end
+
+  let(:object) { class_under_test.new(context, node) }
+
+  let(:node) do
+    Parser::CurrentRuby.parse(<<-RUBY)
+      def foo
+      end
+    RUBY
+  end
+
+  let(:context) do
+    double('Context', source_path: 'source_path').tap do |context|
+      allow(context).to receive(:method).with(:ignore?).and_return(ignore_predicate)
+    end
+  end
+
+  let(:ignore_predicate) { ->(_) {} }
+
+  describe '#identification' do
+    subject { object.identification }
+
+    it { is_expected.to eql('SubjectA:source_path:1') }
+  end
+
+  describe '#source_line' do
+    subject { object.source_line }
+
+    it { is_expected.to be(1) }
+  end
+
+  describe '#source_lines' do
+    subject { object.source_lines }
+
+    it { is_expected.to 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 { is_expected.to be(node) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  describe '#mutations' do
+    subject { object.mutations }
+
+    before do
+      expect(Mutest::Mutator)
+        .to receive(:mutate)
+        .with(node, ignore_predicate)
+        .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
+      is_expected.to eql([
+        Mutest::Mutation::Neutral.new(object, node),
+        Mutest::Mutation::Evil.new(object, mutation_a),
+        Mutest::Mutation::Evil.new(object, mutation_b)
+      ])
+    end
+  end
+end