mutest 0.0.1 → 0.0.2

data/spec/unit/mutest/ast/sexp_spec.rb

@@ -0,0 +1,36 @@
+RSpec.describe Mutest::AST::Sexp do
+  let(:object) do
+    Class.new do
+      include Mutest::AST::Sexp
+
+      public :n_not
+      public :s
+    end.new
+  end
+
+  describe '#n_not' do
+    subject { object.n_not(node) }
+
+    let(:node) { s(:true) }
+
+    it 'returns negated ast' do
+      expect(subject).to eql(s(:send, s(:true), :!))
+    end
+  end
+
+  describe '#s' do
+    subject { object.s(*arguments) }
+
+    context 'with single argument' do
+      let(:arguments) { %i[foo] }
+
+      it { is_expected.to eql(Parser::AST::Node.new(:foo)) }
+    end
+
+    context 'with single multiple arguments' do
+      let(:arguments) { %i[foo bar baz] }
+
+      it { is_expected.to eql(Parser::AST::Node.new(:foo, %i[bar baz])) }
+    end
+  end
+end

data/spec/unit/mutest/ast_spec.rb

@@ -0,0 +1,55 @@
+RSpec.describe Mutest::AST do
+  let(:object) { described_class }
+
+  describe '.find_last_path' do
+    subject { object.find_last_path(root, &block) }
+
+    let(:root)    { s(:root, parent)             }
+    let(:child_a) { s(:child_a)                  }
+    let(:child_b) { s(:child_b)                  }
+    let(:parent)  { s(:parent, child_a, child_b) }
+
+    def path
+      subject.map(&:type)
+    end
+
+    context 'when no node matches' do
+      let(:block) { ->(_) { false } }
+
+      it { is_expected.to eql([]) }
+    end
+
+    context 'when called without block' do
+      let(:block) { nil }
+
+      it 'raises error' do
+        expect { subject }.to raise_error(ArgumentError, 'block expected')
+      end
+    end
+
+    context 'on non Parser::AST::Node child' do
+      let(:block)   { ->(node) { fail if node.equal?(child_a) } }
+      let(:child_a) { AST::Node.new(:foo) }
+
+      it 'does not yield that node' do
+        expect(path).to eql([])
+      end
+    end
+
+    context 'when one node matches' do
+      let(:block) { ->(node) { node.equal?(child_a) } }
+
+      it 'returns the full path' do
+        expect(path).to eql(%i[root parent child_a])
+      end
+    end
+
+    context 'when two nodes match' do
+      let(:block) { ->(node) { node.equal?(child_a) || node.equal?(child_b) } }
+
+      it 'returns the last full path' do
+        expect(path).to eql(%i[root parent child_b])
+      end
+    end
+  end
+end

data/spec/unit/mutest/cli_spec.rb

@@ -0,0 +1,247 @@
+RSpec.describe Mutest::CLI do
+  let(:object) { described_class }
+
+  shared_examples_for 'an invalid cli run' do
+    it 'raises error' do
+      expect do
+        subject
+      end.to raise_error(Mutest::CLI::Error, expected_message)
+    end
+  end
+
+  shared_examples_for 'a cli parser' do
+    it { expect(subject.config.integration).to eql(expected_integration) }
+    it { expect(subject.config.reporter).to eql(expected_reporter)       }
+    it { expect(subject.config.matcher).to eql(expected_matcher_config)  }
+  end
+
+  describe '.run' do
+    subject { object.run(arguments) }
+
+    let(:arguments) { instance_double(Array)                                         }
+    let(:report)    { instance_double(Mutest::Result::Env, success?: report_success) }
+    let(:config)    { instance_double(Mutest::Config)                                }
+    let(:env)       { instance_double(Mutest::Env)                                   }
+
+    before do
+      expect(described_class).to receive(:call).with(arguments).and_return(config)
+      expect(Mutest::Env::Bootstrap).to receive(:call).with(config).and_return(env)
+      expect(Mutest::Runner).to receive(:call).with(env).and_return(report)
+    end
+
+    context 'when report signals success' do
+      let(:report_success) { true }
+
+      it 'exits failure' do
+        expect(subject).to be(true)
+      end
+    end
+
+    context 'when report signals error' do
+      let(:report_success) { false }
+
+      it 'exits failure' do
+        expect(subject).to be(false)
+      end
+    end
+
+    context 'when execution raises an Mutest::CLI::Error' do
+      let(:exception) { Mutest::CLI::Error.new('test-error') }
+      let(:report_success) { nil }
+
+      before do
+        expect(report).to receive(:success?).and_raise(exception)
+      end
+
+      it 'exits failure' do
+        expect($stderr).to receive(:puts).with('test-error')
+        expect(subject).to be(false)
+      end
+    end
+  end
+
+  describe '.new' do
+    subject { object.new(arguments) }
+
+    let(:object) { described_class }
+
+    # Defaults
+    let(:expected_integration)    { Mutest::Integration::Null        }
+    let(:expected_reporter)       { Mutest::Config::DEFAULT.reporter }
+    let(:expected_matcher_config) { default_matcher_config           }
+
+    let(:default_matcher_config) do
+      Mutest::Matcher::Config::DEFAULT
+        .with(match_expressions: expressions.map(&method(:parse_expression)))
+    end
+
+    let(:flags)       { []           }
+    let(:expressions) { %w[TestApp*] }
+
+    let(:arguments) { flags + expressions }
+
+    context 'with unknown flag' do
+      let(:flags) { %w[--invalid] }
+
+      let(:expected_message) { 'invalid option: --invalid' }
+
+      it_should_behave_like 'an invalid cli run'
+    end
+
+    context 'with unknown option' do
+      let(:flags) { %w[--invalid Foo] }
+
+      let(:expected_message) { 'invalid option: --invalid' }
+
+      it_should_behave_like 'an invalid cli run'
+    end
+
+    context 'with include help flag' do
+      let(:flags) { %w[--help] }
+
+      before do
+        expect($stdout).to receive(:puts).with(expected_message)
+        expect(Kernel).to receive(:exit)
+      end
+
+      it_should_behave_like 'a cli parser'
+
+      let(:expected_message) do
+        strip_indent(<<-MESSAGE)
+usage: mutest [options] MATCH_EXPRESSION ...
+Environment:
+        --zombie                     Run mutest zombified
+    -I, --include DIRECTORY          Add DIRECTORY to $LOAD_PATH
+    -r, --require NAME               Require file with NAME
+    -j, --jobs NUMBER                Number of kill jobs. Defaults to number of processors.
+
+Options:
+        --use INTEGRATION            Use INTEGRATION to kill mutations
+        --ignore-subject EXPRESSION  Ignore subjects that match EXPRESSION as prefix
+        --since REVISION             Only select subjects touched since REVISION
+        --fail-fast                  Fail fast
+        --version                    Print mutests version
+    -h, --help                       Show this message
+        MESSAGE
+      end
+    end
+
+    context 'with include flag' do
+      let(:flags) { %w[--include foo] }
+
+      it_should_behave_like 'a cli parser'
+
+      it 'configures includes' do
+        expect(subject.config.includes).to eql(%w[foo])
+      end
+    end
+
+    context 'with use flag' do
+      context 'when integration exists' do
+        let(:flags) { %w[--use rspec] }
+
+        before do
+          expect(Kernel).to receive(:require)
+            .with('mutest/integration/rspec')
+            .and_call_original
+        end
+
+        it_should_behave_like 'a cli parser'
+
+        let(:expected_integration) { Mutest::Integration::Rspec }
+      end
+
+      context 'when integration does NOT exist' do
+        let(:flags) { %w[--use other] }
+
+        it 'raises error' do
+          expect { subject }.to raise_error(
+            Mutest::CLI::Error,
+            'Could not load integration "other" (you may want to try installing the gem mutest-other)'
+          )
+        end
+      end
+    end
+
+    context 'with version flag' do
+      let(:flags) { %w[--version] }
+
+      before do
+        expect(Kernel).to receive(:exit)
+        expect($stdout).to receive(:puts).with("mutest-#{Mutest::VERSION}")
+      end
+
+      it_should_behave_like 'a cli parser'
+    end
+
+    context 'with jobs flag' do
+      let(:flags) { %w[--jobs 0] }
+
+      it_should_behave_like 'a cli parser'
+
+      it 'configures expected coverage' do
+        expect(subject.config.jobs).to be(0)
+      end
+    end
+
+    context 'with require flags' do
+      let(:flags) { %w[--require foo --require bar] }
+
+      it_should_behave_like 'a cli parser'
+
+      it 'configures requires' do
+        expect(subject.config.requires).to eql(%w[foo bar])
+      end
+    end
+
+    context 'with --since flag' do
+      let(:flags) { %w[--since master] }
+
+      let(:expected_matcher_config) do
+        default_matcher_config.with(
+          subject_filters: [
+            Mutest::Repository::SubjectFilter.new(
+              Mutest::Repository::Diff.new(
+                config: Mutest::Config::DEFAULT,
+                from:   'HEAD',
+                to:     'master'
+              )
+            )
+          ]
+        )
+      end
+
+      it_should_behave_like 'a cli parser'
+    end
+
+    context 'with subject-ignore flag' do
+      let(:flags) { %w[--ignore-subject Foo::Bar] }
+
+      let(:expected_matcher_config) do
+        default_matcher_config.with(ignore_expressions: [parse_expression('Foo::Bar')])
+      end
+
+      it_should_behave_like 'a cli parser'
+    end
+
+    context 'with fail-fast flag' do
+      let(:flags) { %w[--fail-fast] }
+
+      it_should_behave_like 'a cli parser'
+
+      it 'sets the fail fast option' do
+        expect(subject.config.fail_fast).to be(true)
+      end
+    end
+
+    context 'with zombie flag' do
+      let(:flags) { %w[--zombie] }
+
+      it_should_behave_like 'a cli parser'
+
+      it 'sets the zombie option' do
+        expect(subject.config.zombie).to be(true)
+      end
+    end
+  end
+end

data/spec/unit/mutest/context_spec.rb

@@ -0,0 +1,141 @@
+RSpec.describe Mutest::Context do
+  describe '.wrap' do
+    subject { described_class.wrap(scope, node) }
+
+    let(:node) { s(:str, 'test') }
+
+    context 'with Module as scope' do
+      let(:scope) { Mutest }
+
+      let(:expected) do
+        s(:module,
+          s(:const, nil, :Mutest),
+          s(:str, 'test'))
+      end
+
+      it { is_expected.to eql(expected) }
+    end
+
+    context 'with Class as scope' do
+      let(:scope) { described_class }
+
+      let(:expected) do
+        s(:class,
+          s(:const, nil, :Context),
+          nil,
+          s(:str, 'test'))
+      end
+
+      it { is_expected.to eql(expected) }
+    end
+  end
+
+  let(:source_path) { instance_double(Pathname) }
+  let(:scope)       { TestApp::Literal          }
+
+  let(:object) do
+    described_class.new(scope, instance_double(Mutest::SourceFile))
+  end
+
+  describe '#identification' do
+    subject { object.identification }
+
+    it { is_expected.to eql(scope.name) }
+  end
+
+  describe '#root' do
+    subject { object.root(node) }
+
+    let(:node) { s(:sym, :node) }
+
+    let(:expected_source) do
+      generate(parse(<<-RUBY))
+        module TestApp
+          class Literal
+            :node
+          end
+        end
+      RUBY
+    end
+
+    let(:generated_source) do
+      Unparser.unparse(subject)
+    end
+
+    it 'creates correct source' do
+      expect(generated_source).to eql(expected_source)
+    end
+  end
+
+  describe '#unqualified_name' do
+    subject { object.unqualified_name }
+
+    context 'with top level constant name' do
+      let(:scope) { TestApp }
+
+      it 'returns the unqualified name' do
+        is_expected.to eql('TestApp')
+      end
+
+      it_should_behave_like 'an idempotent method'
+    end
+
+    context 'with scoped constant name' do
+      it 'returns the unqualified name' do
+        is_expected.to eql('Literal')
+      end
+
+      it_should_behave_like 'an idempotent method'
+    end
+  end
+
+  describe '#match_expressions' do
+    subject { object.match_expressions }
+
+    context 'on toplevel scope' do
+      let(:scope) { TestApp }
+
+      it { is_expected.to eql([parse_expression('TestApp*')]) }
+    end
+
+    context 'on nested scope' do
+      specify do
+        is_expected.to eql(
+          [
+            parse_expression('TestApp::Literal*'),
+            parse_expression('TestApp*')
+          ]
+        )
+      end
+    end
+  end
+
+  describe '#ignore?' do
+    let(:object) do
+      described_class.new(scope, source_file)
+    end
+
+    let(:source_file) { instance_double(Mutest::SourceFile) }
+    let(:node) { s(:node) }
+
+    before do
+      allow(source_file).to receive(:ignore?).with(node).and_return(ignore)
+    end
+
+    context 'when comment disables the node' do
+      let(:ignore) { true }
+
+      it 'ignores the node' do
+        expect(object.ignore?(node)).to be(true)
+      end
+    end
+
+    context 'when comment does not disable the node' do
+      let(:ignore) { false }
+
+      it 'ignores the node' do
+        expect(object.ignore?(node)).to be(false)
+      end
+    end
+  end
+end