mutant 0.6.7 → 0.7.1

data/lib/mutant/runner/collector.rb

@@ -1,133 +0,0 @@
-module Mutant
-  class Runner
-    # Parallel process collector
-    class Collector
-      include Concord::Public.new(:env)
-
-      # Initialize object
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def initialize(*)
-        super
-        @start                = Time.now
-        @aggregate            = Hash.new { |hash, key| hash[key] = [] }
-        @active               = Set.new
-        @last_mutation_result = nil
-      end
-
-      # Return last mutation result
-      #
-      # @return [Result::Mutation]
-      #   if there is a last mutation result
-      #
-      # @return [nil]
-      #   otherwise
-      #
-      # @api private
-      #
-      attr_reader :last_mutation_result
-
-      # Return active subject results
-      #
-      # @return [Array<Result::Subject>]
-      #
-      # @api private
-      #
-      def active_subject_results
-        active_subjects.map(&method(:subject_result))
-      end
-
-      # Return current result
-      #
-      # @return [Result::Env]
-      #
-      # @api private
-      #
-      def result
-        Result::Env.new(
-          env:             env,
-          runtime:         Time.now - @start,
-          subject_results: subject_results
-        )
-      end
-
-      # Register mutation start
-      #
-      # @param [Mutation] mutation
-      #
-      # @return [self]
-      #
-      # @api private
-      #
-      def start(mutation)
-        @active << mutation
-        self
-      end
-
-      # Handle mutation finish
-      #
-      # @param [Result::Mutation] mutation_result
-      #
-      # @return [self]
-      #
-      # @api private
-      #
-      def finish(mutation_result)
-        @last_mutation_result = mutation_result
-
-        mutation = mutation_result.mutation
-        @active.delete(mutation)
-
-        @aggregate[mutation.subject] << mutation_result
-
-        self
-      end
-
-    private
-
-      # Return current subject results
-      #
-      # @return [Array<Result::Subject>]
-      #
-      # @api private
-      #
-      def subject_results
-        env.subjects.map(&method(:subject_result))
-      end
-
-      # Return active subjects
-      #
-      # @return [Array<Subject>]
-      #
-      # @api private
-      #
-      def active_subjects
-        @active.each_with_object(Set.new) do |mutation, subjects|
-          subjects << mutation.subject
-        end.sort_by(&:identification)
-      end
-
-      # Return current subject result
-      #
-      # @param [Subject] subject
-      #
-      # @return [Array<Subject::Result>]
-      #
-      # @api private
-      #
-      def subject_result(subject)
-        mutation_results = @aggregate[subject].sort_by(&:index)
-
-        Result::Subject.new(
-          subject:          subject,
-          runtime:          mutation_results.map(&:runtime).inject(0.0, :+),
-          mutation_results: mutation_results
-        )
-      end
-
-    end # Collector
-  end # Runner
-end # Mutant

data/lib/mutant/warning_expectation.rb

@@ -1,47 +0,0 @@
-module Mutant
-  # A class to expect some warning message raising on absence of unexpected warnings
-  class WarningExpectation
-    include Adamantium::Flat, Concord.new(:expected)
-
-    # Error raised on expectation miss
-    class ExpectationError < RuntimeError
-      include Concord.new(:unexpected, :expected)
-
-      # Return exception message
-      #
-      # @return [String]
-      #
-      # @api private
-      #
-      def message
-        "Unexpected warnings: #{unexpected.inspect}, expected: #{expected.inspect}"
-      end
-    end
-
-    # Execute blocks with warning expectations
-    #
-    # @return [self]
-    #
-    # @api private
-    #
-    def execute(&block)
-      warnings = WarningFilter.use do
-        block.call
-      end
-
-      missing    = expected - warnings
-      unexpected = warnings - expected
-
-      if unexpected.any?
-        fail ExpectationError.new(unexpected, expected)
-      end
-
-      if missing.any?
-        $stderr.puts("Expected but missing warnings: #{missing}")
-      end
-
-      self
-    end
-
-  end # WarningExpectation
-end # Mutant

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

@@ -1,198 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Runner::Collector do
-  let(:object) { described_class.new(env) }
-
-  before do
-    allow(Time).to receive(:now).and_return(Time.now)
-  end
-
-  let(:env) do
-    double(
-      'env',
-      subjects: [mutation_a.subject]
-    )
-  end
-
-  let(:mutation_a) do
-    double(
-      'mutation a',
-      subject: double('subject', identification: 'A')
-    )
-  end
-
-  let(:mutation_a_result) do
-    double(
-      'mutation a result',
-      index:    0,
-      runtime:  0.0,
-      mutation: mutation_a
-    )
-  end
-
-  let(:subject_a_result) do
-    Mutant::Result::Subject.new(
-      subject: mutation_a.subject,
-      runtime: 0.0,
-      mutation_results: [mutation_a_result]
-    )
-  end
-
-  let(:active_subject_result) do
-    subject_a_result.update(mutation_results: [])
-  end
-
-  let(:active_subject_results) do
-    [active_subject_result]
-  end
-
-  describe '.new' do
-    it 'initializes instance variables' do
-      expect(object.instance_variables).to include(:@last_mutation_result)
-    end
-  end
-
-  describe '#start' do
-    subject { object.start(mutation_a) }
-
-    it 'tracs the mutation as active' do
-      expect { subject }.to change { object.active_subject_results }.from([]).to(active_subject_results)
-    end
-
-    it_should_behave_like 'a command method'
-  end
-
-  describe '#finish' do
-    subject { object.finish(mutation_a_result) }
-
-    before do
-      object.start(mutation_a)
-    end
-
-    it 'removes the tracking of mutation as active' do
-      expect { subject }.to change { object.active_subject_results }.from(active_subject_results).to([])
-    end
-
-    it 'sets last mutation result' do
-      expect { subject }.to change { object.last_mutation_result }.from(nil).to(mutation_a_result)
-    end
-
-    it 'aggregates results in #result' do
-      subject
-      expect(object.result).to eql(
-        Mutant::Result::Env.new(
-          env: object.env,
-          runtime: 0.0,
-          subject_results: [subject_a_result]
-        )
-      )
-    end
-
-    it_should_behave_like 'a command method'
-  end
-
-  describe '#last_mutation_result' do
-    subject { object.last_mutation_result }
-
-    context 'when empty' do
-      it { should be(nil) }
-    end
-
-    context 'with partial state' do
-      before do
-        object.start(mutation_a)
-      end
-
-      it { should be(nil) }
-    end
-
-    context 'with full state' do
-      before do
-        object.start(mutation_a)
-        object.finish(mutation_a_result)
-      end
-
-      it { should be(mutation_a_result) }
-    end
-  end
-
-  describe '#active_subject_results' do
-    subject { object.active_subject_results }
-
-    context 'when empty' do
-      it { should eql([]) }
-    end
-
-    context 'on partial state' do
-      let(:mutation_b) do
-        double(
-          'mutation b',
-          subject: double(
-            'subject',
-            identification: 'B'
-          )
-        )
-      end
-
-      let(:mutation_b_result) do
-        double(
-          'mutation b result',
-          index:    0,
-          runtime:  0.0,
-          mutation: mutation_b
-        )
-      end
-
-      let(:subject_b_result) do
-        Mutant::Result::Subject.new(
-          subject: mutation_b.subject,
-          runtime: 0.0,
-          mutation_results: [mutation_b_result]
-        )
-      end
-
-      let(:active_subject_results) { [subject_a_result, subject_b_result] }
-
-      before do
-        object.start(mutation_b)
-        object.start(mutation_a)
-      end
-
-      it { should eql(active_subject_results.map { |result| result.update(mutation_results: []) }) }
-    end
-
-    context 'on full state' do
-      before do
-        object.start(mutation_a)
-        object.finish(mutation_a_result)
-      end
-
-      it { should eql([]) }
-    end
-  end
-
-  describe '#result' do
-    subject { object.result }
-
-    context 'when empty' do
-      it { should eql(Mutant::Result::Env.new(env: object.env, runtime: 0.0, subject_results: [active_subject_result])) }
-    end
-
-    context 'on partial state' do
-      before do
-        object.start(mutation_a)
-      end
-
-      it { should eql(Mutant::Result::Env.new(env: object.env, runtime: 0.0, subject_results: [active_subject_result])) }
-    end
-
-    context 'on full state' do
-      before do
-        object.start(mutation_a)
-        object.finish(mutation_a_result)
-      end
-
-      it { should eql(Mutant::Result::Env.new(env: object.env, runtime: 0.0, subject_results: [subject_a_result])) }
-    end
-  end
-end

data/spec/unit/mutant/test_spec.rb

@@ -1,23 +0,0 @@
-RSpec.describe Mutant::Test do
-  let(:object) { described_class.new(integration, expression) }
-
-  let(:integration) { double('Integration', name: 'test-integration') }
-  let(:expression)  { double('Expression', syntax: 'test-syntax') }
-
-  describe '#identification' do
-    subject { object.identification }
-
-    it { should eql('test-integration:test-syntax') }
-  end
-
-  describe '#run' do
-    subject { object.run }
-
-    let(:report) { double('Report') }
-
-    it 'runs test via integration' do
-      expect(integration).to receive(:run).with(object).and_return(report)
-      expect(subject).to be(report)
-    end
-  end
-end

data/spec/unit/mutant/warning_expectation_spec.rb

@@ -1,80 +0,0 @@
-RSpec.describe Mutant::WarningExpectation do
-  let(:object) { described_class.new(expected_warnings) }
-
-  let(:expected_warnings) { [] }
-  let(:actual_warnings)   { [] }
-
-  let(:warning_a) { "foo.rb:10: warning: We have a problem!\n" }
-  let(:warning_b) { "bar.rb:10: warning: We have an other problem!\n" }
-
-  describe '#execute' do
-    subject { object.execute(&block) }
-
-    before do
-      @called = false
-    end
-
-    let(:block) do
-      lambda do
-        @called = true
-        actual_warnings.each(&Kernel.method(:warn))
-      end
-    end
-
-    it 'executes block' do
-      expect { subject }.to change { @called }.from(false).to(true)
-    end
-
-    context 'when no warnings occur during block execution' do
-
-      context 'and no warnings are expected' do
-        it_should_behave_like 'a command method'
-      end
-
-      context 'and warnings are expected' do
-        let(:expected_warnings) { [warning_a] }
-
-        before do
-          expect($stderr).to receive(:puts).with("Expected but missing warnings: #{expected_warnings}")
-        end
-
-        it_should_behave_like 'a command method'
-      end
-    end
-
-    context 'when warnings occur during block execution' do
-      let(:actual_warnings) { [warning_a, warning_b] }
-
-      context 'and only some no warnings are expected' do
-        let(:expected_warnings) { [warning_a] }
-
-        it 'raises an expectation error' do
-          expect { subject }.to raise_error(Mutant::WarningExpectation::ExpectationError.new([warning_b], expected_warnings))
-        end
-      end
-
-      context 'and all warnings are expected' do
-        let(:expected_warnings) { [warning_a, warning_b] }
-
-        it_should_behave_like 'a command method'
-      end
-
-      context 'and there is an expected warning missing' do
-        let(:expected_warnings) { [warning_a] }
-        let(:actual_warnings)   { [warning_b] }
-
-        it 'raises an expectation error' do
-          expect { subject }.to raise_error(Mutant::WarningExpectation::ExpectationError.new([warning_b], expected_warnings))
-        end
-      end
-    end
-  end
-end
-
-RSpec.describe Mutant::WarningExpectation::ExpectationError do
-  describe '#message' do
-    subject { described_class.new(['unexpected-a'], ['expected-b']).message }
-
-    it { should eql('Unexpected warnings: ["unexpected-a"], expected: ["expected-b"]') }
-  end
-end