mutest 0.0.1 → 0.0.2

data/spec/unit/mutest/integration_spec.rb

@@ -0,0 +1,26 @@
+RSpec.describe Mutest::Integration do
+  let(:class_under_test) do
+    Class.new(described_class)
+  end
+
+  let(:object) { class_under_test.new(Mutest::Config::DEFAULT) }
+
+  describe '#setup' do
+    subject { object.setup }
+    it_should_behave_like 'a command method'
+  end
+
+  describe '.setup' do
+    subject { described_class.setup(kernel, name) }
+
+    let(:name)   { 'null'               }
+    let(:kernel) { class_double(Kernel) }
+
+    before do
+      expect(kernel).to receive(:require)
+        .with('mutest/integration/null')
+    end
+
+    it { is_expected.to be(Mutest::Integration::Null) }
+  end
+end

data/spec/unit/mutest/isolation/fork_spec.rb

@@ -0,0 +1,155 @@
+# The fork isolation is all about managing a series of systemcalls with proper error handling
+#
+# So creating a unit spec for this is challenging. Especially under mutation testing.
+# Hence we even have to implement our own message expectation mechanism, as rspec build in
+# expectations are not able to correctly specify a sequence of expectations where a specific
+# message is send twice.
+#
+# Also our replacement for rspec-expectations used here allows easier deduplication.
+RSpec.describe Mutest::Isolation::Fork do
+  let(:block_return)      { instance_double(Object, :block_return)      }
+  let(:block_return_blob) { instance_double(String, :block_return_blob) }
+  let(:devnull)           { instance_double(Proc, :devnull)             }
+  let(:io)                { class_double(IO)                            }
+  let(:isolated_block)    { -> { block_return }                         }
+  let(:marshal)           { class_double(Marshal)                       }
+  let(:process)           { class_double(Process)                       }
+  let(:pid)               { class_double(Fixnum)                        }
+  let(:reader)            { instance_double(IO, :reader)                }
+  let(:stderr)            { instance_double(IO, :stderr)                }
+  let(:stdout)            { instance_double(IO, :stdout)                }
+  let(:writer)            { instance_double(IO, :writer)                }
+  let(:nullio)            { instance_double(IO, :nullio)                }
+
+  describe '#call' do
+    subject { object.call(&isolated_block) }
+
+    let(:object) do
+      described_class.new(
+        devnull: devnull,
+        io:      io,
+        marshal: marshal,
+        process: process,
+        stderr:  stderr,
+        stdout:  stdout
+      )
+    end
+
+    let(:prefork_expectations) do
+      [
+        {
+          receiver:  io,
+          selector:  :pipe,
+          arguments: [binmode: true],
+          reaction:  {
+            yields: [[reader, writer]]
+          }
+        }
+      ]
+    end
+
+    context 'when no IO operation fails' do
+      let(:expectations) do
+        [
+          *prefork_expectations,
+          {
+            receiver: process,
+            selector: :fork,
+            reaction: {
+              yields: [],
+              return: pid
+            }
+          },
+          # Inside the killfork
+          {
+            receiver: reader,
+            selector: :close
+          },
+          {
+            receiver: writer,
+            selector: :binmode
+          },
+          {
+            receiver: devnull,
+            selector: :call,
+            reaction: {
+              yields: [nullio]
+            }
+          },
+          {
+            receiver:  stderr,
+            selector:  :reopen,
+            arguments: [nullio]
+          },
+          {
+            receiver:  stdout,
+            selector:  :reopen,
+            arguments: [nullio]
+          },
+          {
+            receiver:  marshal,
+            selector:  :dump,
+            arguments: [block_return],
+            reaction:  {
+              return: block_return_blob
+            }
+          },
+          {
+            receiver:  writer,
+            selector:  :syswrite,
+            arguments: [block_return_blob]
+          },
+          {
+            receiver: writer,
+            selector: :close
+          },
+          # Outside the killfork
+          {
+            receiver: writer,
+            selector: :close
+          },
+          {
+            receiver:  marshal,
+            selector:  :load,
+            arguments: [reader],
+            reaction:  {
+              return: block_return
+            }
+          },
+          {
+            receiver:  process,
+            selector:  :waitpid,
+            arguments: [pid]
+          }
+        ].map(&XSpec::MessageExpectation.method(:parse))
+      end
+
+      specify do
+        XSpec::ExpectationVerifier.verify(self, expectations) do
+          expect(subject).to be(block_return)
+        end
+      end
+    end
+
+    context 'when fork fails' do
+      let(:expectations) do
+        [
+          *prefork_expectations,
+          {
+            receiver: process,
+            selector: :fork,
+            reaction: {
+              exception: RuntimeError.new('fork(2)')
+            }
+          }
+        ].map(&XSpec::MessageExpectation.method(:parse))
+      end
+
+      specify do
+        XSpec::ExpectationVerifier.verify(self, expectations) do
+          expect { expect(subject) }.to raise_error(described_class::Error, 'fork(2)')
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutest/isolation/none_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe Mutest::Isolation::None do
+  describe '.call' do
+    let(:object) { described_class.new }
+
+    it 'return block value' do
+      expect(object.call { :foo }).to be(:foo)
+    end
+
+    it 'wraps *all* exceptions' do
+      expect { object.call { fail 'foo' } }.to raise_error(
+        Mutest::Isolation::Error,
+        'foo'
+      )
+    end
+  end
+end

data/spec/unit/mutest/loader_spec.rb

@@ -0,0 +1,42 @@
+RSpec.describe Mutest::Loader, '.call' do
+  subject do
+    described_class.call(
+      binding: binding,
+      kernel:  kernel,
+      node:    node,
+      subject: mutation_subject
+    )
+  end
+
+  let(:path)     { instance_double(Pathname, to_s: path_str) }
+  let(:path_str) { instance_double(String)                   }
+  let(:line)     { instance_double(Fixnum)                   }
+  let(:kernel)   { class_double(Kernel)                      }
+  let(:binding)  { instance_double(Binding)                  }
+  let(:source)   { instance_double(String)                   }
+  let(:node)     { instance_double(Parser::AST::Node)        }
+
+  let(:mutation_subject) do
+    instance_double(
+      Mutest::Subject,
+      source_path: path,
+      source_line: line
+    )
+  end
+
+  it 'performs expected kernel interaction' do
+    expect(Unparser).to receive(:unparse)
+      .with(node)
+      .and_return(source)
+
+    expect(kernel).to receive(:eval)
+      .with(
+        source,
+        binding,
+        path_str,
+        line
+      )
+
+    subject
+  end
+end

data/spec/unit/mutest/matcher/chain_spec.rb

@@ -0,0 +1,24 @@
+RSpec.describe Mutest::Matcher::Chain, '#call' do
+  subject { object.call(env) }
+
+  let(:object)    { described_class.new([matcher_a, matcher_b]) }
+  let(:env)       { instance_double(Mutest::Env)                }
+  let(:matcher_a) { instance_double(Mutest::Matcher)            }
+  let(:matcher_b) { instance_double(Mutest::Matcher)            }
+  let(:subject_a) { instance_double(Mutest::Subject)            }
+  let(:subject_b) { instance_double(Mutest::Subject)            }
+
+  before do
+    expect(matcher_a).to receive(:call)
+      .with(env)
+      .and_return([subject_a])
+
+    expect(matcher_b).to receive(:call)
+      .with(env)
+      .and_return([subject_b])
+  end
+
+  it 'returns concatenated matches' do
+    is_expected.to eql([subject_a, subject_b])
+  end
+end

data/spec/unit/mutest/matcher/compiler/subject_prefix_spec.rb

@@ -0,0 +1,24 @@
+RSpec.describe Mutest::Matcher::Compiler::SubjectPrefix, '#call' do
+  subject { object.call(_subject) }
+
+  let(:object)   { described_class.new(parse_expression('Foo*')) }
+
+  let(:_subject) do
+    instance_double(
+      Mutest::Subject,
+      expression: parse_expression(subject_expression)
+    )
+  end
+
+  context 'when subject expression is prefixed by expression' do
+    let(:subject_expression) { 'Foo::Bar' }
+
+    it { is_expected.to be(true) }
+  end
+
+  context 'when subject expression is NOT prefixed by expression' do
+    let(:subject_expression) { 'Bar' }
+
+    it { is_expected.to be(false) }
+  end
+end

data/spec/unit/mutest/matcher/compiler_spec.rb

@@ -0,0 +1,76 @@
+RSpec.describe Mutest::Matcher::Compiler, '#call' do
+  subject { object.call(matcher_config.with(attributes)) }
+
+  let(:object)         { described_class                  }
+  let(:matcher_config) { Mutest::Matcher::Config::DEFAULT }
+  let(:expression_a)   { parse_expression('Foo*')         }
+  let(:expression_b)   { parse_expression('Bar*')         }
+  let(:matcher_a)      { expression_a.matcher             }
+
+  let(:expected_matcher) do
+    Mutest::Matcher::Filter.new(
+      expected_positive_matcher,
+      expected_predicate
+    )
+  end
+
+  let(:expected_predicate) do
+    Morpher.compile(s(:and, s(:negate, s(:or)), s(:and)))
+  end
+
+  context 'on empty config' do
+    let(:attributes) { {} }
+
+    let(:expected_positive_matcher) { Mutest::Matcher::Chain.new([]) }
+
+    it { is_expected.to eql(expected_matcher) }
+  end
+
+  context 'on config with match expression' do
+    let(:expected_predicate) do
+      Morpher::Evaluator::Predicate::Boolean::And.new(
+        [
+          Morpher::Evaluator::Predicate::Negation.new(
+            Morpher::Evaluator::Predicate::Boolean::Or.new(ignore_expression_predicates)
+          ),
+          Morpher::Evaluator::Predicate::Boolean::And.new(subject_filter_predicates)
+        ]
+      )
+    end
+
+    let(:expected_positive_matcher)    { Mutest::Matcher::Chain.new([matcher_a]) }
+    let(:attributes)                   { { match_expressions: [expression_a] }   }
+    let(:ignore_expression_predicates) { []                                      }
+    let(:subject_filter_predicates)    { []                                      }
+
+    context 'and no other constraints' do
+      it { is_expected.to eql(expected_matcher) }
+    end
+
+    context 'and ignore expressions' do
+      let(:attributes) do
+        super().merge(ignore_expressions: [expression_b])
+      end
+
+      let(:ignore_expression_predicates) do
+        [Mutest::Matcher::Compiler::SubjectPrefix.new(expression_b)]
+      end
+
+      it { is_expected.to eql(expected_matcher) }
+    end
+
+    context 'and subject filters' do
+      let(:subject_filter) { instance_double(Mutest::Matcher) }
+
+      let(:attributes) do
+        super().merge(subject_filters: [subject_filter])
+      end
+
+      let(:subject_filter_predicates) do
+        [subject_filter]
+      end
+
+      it { is_expected.to eql(expected_matcher) }
+    end
+  end
+end

data/spec/unit/mutest/matcher/config_spec.rb

@@ -0,0 +1,45 @@
+RSpec.describe Mutest::Matcher::Config do
+  describe '#inspect' do
+    subject { object.inspect }
+
+    context 'on default config' do
+      let(:object) { described_class::DEFAULT }
+
+      it { is_expected.to eql('#<Mutest::Matcher::Config empty>') }
+    end
+
+    context 'with one expression' do
+      let(:object) { described_class::DEFAULT.add(:match_expressions, parse_expression('Foo')) }
+      it { is_expected.to eql('#<Mutest::Matcher::Config match_expressions: [Foo]>') }
+    end
+
+    context 'with many expressions' do
+      let(:object) do
+        described_class::DEFAULT
+          .add(:match_expressions, parse_expression('Foo'))
+          .add(:match_expressions, parse_expression('Bar'))
+      end
+
+      it { is_expected.to eql('#<Mutest::Matcher::Config match_expressions: [Foo,Bar]>') }
+    end
+
+    context 'with match and ignore expression' do
+      let(:object) do
+        described_class::DEFAULT
+          .add(:match_expressions,  parse_expression('Foo'))
+          .add(:ignore_expressions, parse_expression('Bar'))
+      end
+
+      it { is_expected.to eql('#<Mutest::Matcher::Config ignore_expressions: [Bar] match_expressions: [Foo]>') }
+    end
+
+    context 'with subject filter' do
+      let(:object) do
+        described_class::DEFAULT
+          .add(:subject_filters, 'foo')
+      end
+
+      it { is_expected.to eql('#<Mutest::Matcher::Config subject_filters: ["foo"]>') }
+    end
+  end
+end

data/spec/unit/mutest/matcher/filter_spec.rb

@@ -0,0 +1,20 @@
+RSpec.describe Mutest::Matcher::Filter, '#call' do
+  subject { object.call(env) }
+
+  let(:object)    { described_class.new(matcher, predicate) }
+  let(:matcher)   { instance_double(Mutest::Matcher)        }
+  let(:subject_a) { instance_double(Mutest::Subject)        }
+  let(:subject_b) { instance_double(Mutest::Subject)        }
+  let(:env)       { instance_double(Mutest::Env)            }
+  let(:predicate) { ->(node) { node.eql?(subject_a) }       }
+
+  before do
+    expect(matcher).to receive(:call)
+      .with(env)
+      .and_return([subject_a, subject_b])
+  end
+
+  it 'returns subjects after filtering' do
+    is_expected.to eql([subject_a])
+  end
+end

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

@@ -0,0 +1,125 @@
+RSpec.describe Mutest::Matcher::Method::Instance, '#call' do
+  subject { object.call(env) }
+
+  let(:object)       { described_class.new(scope, method)                }
+  let(:method_name)  { :foo                                              }
+  let(:source_path)  { MutestSpec::ROOT.join('test_app/lib/test_app.rb') }
+  let(:method)       { scope.instance_method(method_name)                }
+  let(:type)         { :def                                              }
+  let(:method_arity) { 0                                                 }
+  let(:base)         { TestApp::InstanceMethodTests                      }
+
+  let(:env) do
+    instance_double(
+      Mutest::Env::Bootstrap,
+      config: Mutest::Config::DEFAULT,
+      parser: Fixtures::TEST_ENV.parser
+    )
+  end
+
+  let(:source_file) do
+    Mutest::SourceFile.new(
+      source_path,
+      *Parser::CurrentRuby.parse_with_comments(source_path.read)
+    )
+  end
+
+  def name
+    node.children.fetch(0)
+  end
+
+  def arguments
+    node.children.fetch(1)
+  end
+
+  context 'when method is defined inside eval' do
+    let(:scope)             { base::WithMemoizer          }
+    let(:method)            { scope.instance_method(:boz) }
+
+    let(:expected_warnings) do
+      [
+        "#{method} does not have a valid source location, unable to emit subject"
+      ]
+    end
+
+    include_examples 'skipped candidate'
+  end
+
+  context 'when method is defined without source location' do
+    let(:scope)             { Module                            }
+    let(:method)            { scope.instance_method(:object_id) }
+
+    let(:expected_warnings) do
+      [
+        "#{method} does not have a valid source location, unable to emit subject"
+      ]
+    end
+
+    include_examples 'skipped candidate'
+  end
+
+  context 'in module eval' do
+    let(:scope) { base::InModuleEval }
+
+    let(:expected_warnings) do
+      [
+        "#{method} is dynamically defined in a closure, unable to emit subject"
+      ]
+    end
+
+    include_examples 'skipped candidate'
+  end
+
+  context 'in class eval' do
+    let(:scope) { base::InClassEval }
+
+    let(:expected_warnings) do
+      [
+        "#{method} is dynamically defined in a closure, unable to emit subject"
+      ]
+    end
+
+    include_examples 'skipped candidate'
+  end
+
+  context 'when method is defined once' do
+    let(:method_name) { :bar               }
+    let(:scope)       { base::WithMemoizer }
+    let(:method_line) { 13                 }
+
+    it_should_behave_like 'a method matcher'
+  end
+
+  context 'when method is defined once with a memoizer' do
+    let(:scope)       { base::WithMemoizer }
+    let(:method_line) { 15                 }
+
+    it_should_behave_like 'a method matcher'
+  end
+
+  context 'when method is defined multiple times' do
+    context 'on different lines' do
+      let(:scope)        { base::DefinedMultipleTimes::DifferentLines }
+      let(:method_line)  { 24                                         }
+      let(:method_arity) { 1                                          }
+
+      it_should_behave_like 'a method matcher'
+    end
+
+    context 'on the same line' do
+      let(:scope)        { base::DefinedMultipleTimes::SameLineSameScope }
+      let(:method_line)  { 29                                            }
+      let(:method_arity) { 1                                             }
+
+      it_should_behave_like 'a method matcher'
+    end
+
+    context 'on the same line with different scope' do
+      let(:scope)        { base::DefinedMultipleTimes::SameLineDifferentScope }
+      let(:method_line)  { 33                                                 }
+      let(:method_arity) { 1                                                  }
+
+      it_should_behave_like 'a method matcher'
+    end
+  end
+end