mutant 0.5.24 → 0.5.25

data/lib/mutant/runner/subject.rb

@@ -1,85 +0,0 @@
-module Mutant
-  class Runner
-    # Subject specific runner
-    class Subject < self
-      include Equalizer.new(:config, :subject)
-
-      # Return subject
-      #
-      # @return [Subject]
-      #
-      # @api private
-      #
-      attr_reader :subject
-
-      register Mutant::Subject
-
-      # Initialize object
-      #
-      # @param [Config] config
-      # @param [Subject] subject
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def initialize(config, subject)
-        @subject = subject
-        super(config)
-      end
-
-      # Return mutation runners
-      #
-      # @return [Enumerable<Runner::Mutation>]
-      #
-      # @api private
-      #
-      attr_reader :mutations
-
-      # Return failed mutations
-      #
-      # @return [Enumerable<Mutation>]
-      #
-      # @api private
-      #
-      def failed_mutations
-        mutations.reject(&:success?)
-      end
-      memoize :failed_mutations
-
-      # Test if subject was processed successful
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
-      def success?
-        failed_mutations.empty?
-      end
-
-      # Return tests used to kill mutations on this subject
-      #
-      # @return [Enumerable<Test>]
-      #
-      # @api private
-      #
-      def tests
-        config.tests(subject)
-      end
-      memoize :tests
-
-    private
-
-      # Perform operation
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def run
-        @mutations = visit_collection(subject.mutations, tests)
-      end
-
-    end # Subject
-  end # Runner
-end # Mutant

data/lib/mutant/test/report.rb

@@ -1,59 +0,0 @@
-module Mutant
-  class Test
-    # Object to report test status
-    class Report
-      include Adamantium::Flat, Anima::Update, Anima.new(
-        :test,
-        :output,
-        :success
-      )
-
-      # Test if test was successful
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
-      alias_method :success?, :success
-
-      # Test if test failed
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
-      def failed?
-        !success?
-      end
-
-      # Return marshallable data
-      #
-      # NOTE:
-      #
-      #  The test is intentionally NOT part of the mashalled data.
-      #  In rspec the example group cannot deterministically being marshalled, because
-      #  they reference a crazy mix of IO objects, global objects etc.
-      #
-      # @return [Array]
-      #
-      # @api private
-      #
-      def marshal_dump
-        [@output, @success]
-      end
-
-      # Load marshalled data
-      #
-      # @param [Array] arry
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def marshal_load(array)
-        @output, @success = array
-      end
-
-    end # Report
-  end # Test
-end # Mutant

data/spec/unit/mutant/cli_new_spec.rb

@@ -1,147 +0,0 @@
-require 'spec_helper'
-
-shared_examples_for 'an invalid cli run' do
-  it 'should raise error' do
-    expect do
-      subject
-    end.to raise_error(Mutant::CLI::Error, expected_message)
-  end
-end
-
-shared_examples_for 'a cli parser' do
-  subject { cli.config }
-
-  it { expect(subject.integration).to eql(expected_integration) }
-  it { expect(subject.reporter).to eql(expected_reporter) }
-  it { expect(subject.matcher).to eql(expected_matcher)   }
-end
-
-describe Mutant::CLI, '.new' do
-  let(:object) { described_class }
-  let(:time)   { Time.now        }
-
-  before do
-    Time.stub(now: time)
-  end
-
-  # Defaults
-  let(:expected_filter)      { Morpher.evaluator(s(:true))        }
-  let(:expected_integration) { Mutant::Integration::Null.new      }
-  let(:expected_reporter)    { Mutant::Reporter::CLI.new($stdout) }
-
-  let(:ns)    { Mutant::Matcher    }
-  let(:env)   { Fixtures::BOOT_ENV }
-
-  let(:cli) { object.new(arguments) }
-
-  subject { cli }
-
-  context 'with unknown flag' do
-    let(:arguments) { %w[--invalid] }
-
-    let(:expected_message) { 'invalid option: --invalid' }
-
-    it_should_behave_like 'an invalid cli run'
-  end
-
-  context 'with unknown option' do
-    let(:arguments) { %w[--invalid Foo] }
-
-    let(:expected_message) { 'invalid option: --invalid' }
-
-    it_should_behave_like 'an invalid cli run'
-  end
-
-  context 'without arguments' do
-    let(:arguments) { [] }
-
-    let(:expected_message) { 'No patterns given' }
-
-    it_should_behave_like 'an invalid cli run'
-  end
-
-  context 'with code filter and missing argument' do
-    let(:arguments)        { %w[--code]                 }
-    let(:expected_message) { 'missing argument: --code' }
-
-    it_should_behave_like 'an invalid cli run'
-  end
-
-  context 'with explicit method pattern' do
-    let(:arguments)        { %w[TestApp::Literal#float] }
-
-    let(:expected_matcher) do
-      ns::Method::Instance.new(env, TestApp::Literal, TestApp::Literal.instance_method(:float))
-    end
-
-    it_should_behave_like 'a cli parser'
-  end
-
-  context 'with debug flag' do
-    let(:pattern)          { 'TestApp*'           }
-    let(:arguments)        { %W[--debug #{pattern}] }
-    let(:expected_matcher) { ns::Namespace.new(env, Mutant::Expression.parse(pattern)) }
-
-    it_should_behave_like 'a cli parser'
-
-    it 'should set the debug option' do
-      expect(subject.config.debug).to be(true)
-    end
-  end
-
-  context 'with zombie flag' do
-    let(:pattern)          { 'TestApp*'            }
-    let(:arguments)        { %W[--zombie #{pattern}] }
-    let(:expected_matcher) { ns::Namespace.new(env, Mutant::Expression.parse(pattern)) }
-
-    it_should_behave_like 'a cli parser'
-
-    it 'should set the zombie option' do
-      expect(subject.config.zombie).to be(true)
-    end
-  end
-
-  context 'with namespace pattern' do
-    let(:pattern)          { 'TestApp*' }
-    let(:arguments)        { [pattern]    }
-    let(:expected_matcher) { ns::Namespace.new(env, Mutant::Expression.parse(pattern)) }
-
-    it_should_behave_like 'a cli parser'
-  end
-
-  context 'with subject code filter' do
-    let(:pattern)   { 'TestApp::Literal#float' }
-    let(:arguments) { %W[--code faa --code bbb #{pattern}] }
-
-    let(:expected_filter) do
-      Morpher.evaluator(
-        s(:mxor,
-          s(:eql, s(:attribute, :code), s(:value, 'faa')),
-          s(:eql, s(:attribute, :code), s(:value, 'bbb'))
-        )
-      )
-    end
-
-    let(:expected_matcher) do
-      matcher = ns::Method::Instance.new(
-        env,
-        TestApp::Literal, TestApp::Literal.instance_method(:float)
-      )
-      predicate = Morpher.compile(
-        s(:or,
-          s(:eql,
-            s(:attribute, :code),
-            s(:static, 'faa')
-          ),
-          s(:eql,
-            s(:attribute, :code),
-            s(:static, 'bbb')
-          )
-        )
-      )
-      ns::Filter.new(matcher, predicate)
-    end
-
-    it_should_behave_like 'a cli parser'
-  end
-end

data/spec/unit/mutant/cli_run_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::CLI, '.run' do
-  subject { object.run(argv) }
-
-  let(:object)     { described_class                              }
-  let(:argv)       { double('ARGV')                               }
-  let(:attributes) { double('Options')                            }
-  let(:runner)     { double('Runner', success?: success)          }
-  let(:config)     { double('Config')                             }
-  let(:instance)   { double(described_class.name, config: config) }
-
-  before do
-    described_class.stub(new: instance)
-    Mutant::Runner::Config.stub(run: runner)
-  end
-
-  context 'when runner is successful' do
-    let(:success) { true }
-
-    it { should be(0) }
-
-    it 'should run with attributes' do
-      Mutant::Runner::Config
-        .should_receive(:run)
-        .with(config)
-        .and_return(runner)
-      should be(0)
-    end
-  end
-
-  context 'when runner fails' do
-    let(:success) { false }
-
-    it { should be(1) }
-
-    it 'should run with attributes' do
-      Mutant::Runner::Config
-        .should_receive(:run)
-        .with(config)
-        .and_return(runner)
-      should be(1)
-    end
-  end
-
-end

data/spec/unit/mutant/runner/config_spec.rb

@@ -1,157 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Runner::Config do
-  let(:object) { described_class.run(config) }
-
-  let(:config) do
-    Mutant::Config.new(
-      matcher:           [subject_a, subject_b],
-      debug:             false,
-      integration:       integration,
-      reporter:          reporter,
-      fail_fast:         fail_fast,
-      expected_coverage: expected_coverage,
-      zombie:            false
-    )
-  end
-
-  let(:fail_fast)         { false                       }
-  let(:expected_coverage) { 100.0                       }
-  let(:reporter)          { Mutant::Reporter::Trace.new }
-  let(:integration)       { double('Integration')       }
-  let(:subject_a)         { double('Subject A')         }
-  let(:subject_b)         { double('Subject B')         }
-
-  before do
-    integration.stub(:setup)
-    integration.stub(:teardown)
-    Mutant::Runner.stub(:run).with(config, subject_a).and_return(runner_a)
-    Mutant::Runner.stub(:run).with(config, subject_b).and_return(runner_b)
-  end
-
-  describe '#subjects' do
-
-    subject { object.subjects }
-
-    let(:runner_a)  { double('Runner A', stop?: stop_a) }
-    let(:runner_b)  { double('Runner B', stop?: stop_b) }
-
-    context 'without early stop' do
-      let(:stop_a) { false }
-      let(:stop_b) { false }
-
-      it { should eql([runner_a, runner_b]) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-
-    context 'with early stop' do
-      let(:stop_a) { true  }
-      let(:stop_b) { false }
-
-      it { should eql([runner_a]) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-  end
-
-  describe '#coverage' do
-    subject { object.coverage }
-
-    let(:runner_a)  { double('Runner A', stop?: false, :mutations => mutations_a) }
-    let(:runner_b)  { double('Runner B', stop?: false, :mutations => []) }
-
-    let(:mutations_a) do
-      Array.new(amount_mutations) do |number|
-        double('Mutation', success?: number <= amount_kills - 1)
-      end
-    end
-
-    context 'with zero mutations and kills' do
-      let(:amount_mutations) { 0 }
-      let(:amount_kills)     { 0 }
-
-      it { should eql(0.0) }
-    end
-
-    context 'with one mutation' do
-      let(:amount_mutations) { 1 }
-
-      context 'and one kill' do
-        let(:amount_kills) { 1 }
-        it { should eql(100.0) }
-      end
-
-      context 'and no kills' do
-        let(:amount_kills) { 0 }
-        it { should eql(0.0) }
-      end
-    end
-
-    context 'with many mutations' do
-      let(:amount_mutations) { 10 }
-
-      context 'and no kill' do
-        let(:amount_kills) { 0 }
-        it { should eql(0.0) }
-      end
-
-      context 'and some kills' do
-        let(:amount_kills) { 2 }
-        it { should eql(20.0) }
-      end
-
-      context 'and as many kills' do
-        let(:amount_kills) { amount_mutations }
-        it { should eql(100.0) }
-      end
-    end
-  end
-
-  describe '#success?' do
-    subject { object.success? }
-
-    let(:mutation_a) do
-      double('Mutation A', success?: false)
-    end
-
-    let(:mutation_b) do
-      double('Mutation B', success?: true)
-    end
-
-    let(:runner_a) do
-      double('Runner A', stop?: false, success?: false, mutations: [mutation_a])
-    end
-
-    let(:runner_b) do
-      double('Runner B', stop?: false, success?: true, mutations: [mutation_b])
-    end
-
-    let(:runner_a) do
-      double('Runner A', stop?: false, success?: false, mutations: [mutation_a])
-    end
-
-    let(:runner_b) do
-      double('Runner B', stop?: false, success?: true, mutations: [mutation_b])
-    end
-
-    context 'without fail fast' do
-
-      context 'when expected coverage equals actual coverage' do
-        let(:expected_coverage) { 50.0 }
-        it { should be(true) }
-      end
-
-      context 'when expected coverage closely equals actual coverage' do
-        let(:expected_coverage) { 50.01 }
-        it { should be(true) }
-      end
-
-      context 'when expected coverage does not equal actual coverage' do
-        let(:expected_coverage) { 51.00 }
-        it { should be(false) }
-      end
-
-    end
-  end
-end