mutant 0.9.8 → 0.9.13

data/spec/support/ice_nine_config.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require 'ice_nine'
-
-module IceNine
-  class Freezer
-    class RSpec < NoFreeze
-    end # RSpec
-  end # Freezer
-end # IceNine

data/spec/support/ruby_vm.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module MutantSpec
-  # Not a real VM, just kidding. It connects the require / eval triggers
-  # require semantics Zombifier relies on in a way we can avoid having to
-  # mock around everywhere to test every detail.
-  class RubyVM
-    include Concord::Public.new(:expected_events)
-
-    # An event being observed by the VM handlers
-    class EventObservation
-      include Concord::Public.new(:type, :payload)
-    end # EventObservation
-
-    # An event being expected, can advance the VM
-    class EventExpectation
-      include AbstractType, Anima.new(
-        :expected_payload,
-        :trigger_requires,
-        :return_value
-      )
-
-      DEFAULTS = IceNine.deep_freeze(trigger_requires: [])
-
-      def initialize(attributes)
-        super(DEFAULTS.merge(attributes))
-      end
-
-      def handle(vm, observation) # rubocop:disable Naming/MethodParameterName
-        unless match?(observation)
-          fail "Unexpected event observation: #{observation.inspect}, expected #{inspect}"
-        end
-
-        trigger_requires.each(&vm.method(:require))
-
-        self
-      end
-
-    private
-
-      def match?(observation)
-        observation.type.eql?(self.class) && observation.payload.eql?(expected_payload)
-      end
-
-      # Expectation and advance on require calls
-      class Require < self
-      end # Require
-
-      # Expectation and advance on eval calls
-      class Eval < self
-      end # Eval
-    end # EventExpectation
-
-    # A fake implementation of Kernel#require
-    def require(logical_name)
-      handle_event(EventObservation.new(EventExpectation::Require, logical_name: logical_name))
-    end
-
-    # A fake implementation of Kernel#eval
-    def eval(source, binding, location)
-      handle_event(
-        EventObservation.new(
-          EventExpectation::Eval,
-          binding:         binding,
-          source:          source,
-          source_location: location
-        )
-      )
-    end
-
-    # Test if VM events where fully processed
-    def done?
-      expected_events.empty?
-    end
-
-  private
-
-    def handle_event(observation)
-      fail "Unexpected event: #{observation.type} / #{observation.payload}" if expected_events.empty?
-
-      expected_events.slice!(0).handle(self, observation).return_value
-    end
-  end # RubyVM
-end # MutantSpec

data/spec/support/shared_context.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Metrics/ModuleLength
-module SharedContext
-  # Prepend an anonymous module with the new `with` method
-  #
-  # Using an anonymous module eliminates warnings where `setup_shared_context`
-  # is used and one of the shared methods is immediately redefined.
-  def with(name, &block)
-    new_definition =
-      Module.new do
-        define_method(name) do
-          super().with(instance_eval(&block))
-        end
-      end
-
-    prepend(new_definition)
-  end
-
-  def it_reports(expected_content)
-    it 'writes expected report to output' do
-      described_class.call(output, reportable)
-      output.rewind
-      expect(output.read).to eql(expected_content)
-    end
-  end
-
-  # rubocop:disable Metrics/MethodLength
-  # rubocop:disable Metrics/AbcSize
-  def setup_shared_context
-    let(:mutation_a)      { Mutant::Mutation::Evil.new(subject_a, mutation_a_node)   }
-    let(:mutation_a_node) { s(:false)                                                }
-    let(:mutation_b)      { Mutant::Mutation::Evil.new(subject_a, mutation_b_node)   }
-    let(:mutation_b_node) { s(:nil)                                                  }
-    let(:mutations)       { [mutation_a, mutation_b]                                 }
-    let(:output)          { StringIO.new                                             }
-    let(:subject_a_node)  { s(:true)                                                 }
-    let(:test_a)          { instance_double(Mutant::Test, identification: 'test-a')  }
-    let(:subjects)        { [subject_a]                                              }
-
-    let(:job_a) do
-      Mutant::Parallel::Source::Job.new(
-        index:   0,
-        payload: mutation_a
-      )
-    end
-
-    let(:job_b) do
-      Mutant::Parallel::Source::Job.new(
-        index:   1,
-        payload: mutation_b
-      )
-    end
-
-    let(:env) do
-      instance_double(
-        Mutant::Env,
-        amount_mutations:      mutations.length,
-        amount_selected_tests: selections.values.flatten.to_set.length,
-        amount_subjects:       subjects.length,
-        amount_total_tests:    integration.all_tests.length,
-        config:                config,
-        integration:           integration,
-        mutations:             mutations,
-        selected_tests:        [test_a].to_set,
-        selections:            selections,
-        subjects:              subjects,
-        test_subject_ratio:    Rational(1)
-      )
-    end
-
-    let(:selections) do
-      { subject_a => [test_a] }
-    end
-
-    let(:integration) do
-      instance_double(
-        Mutant::Integration,
-        all_tests: [test_a]
-      )
-    end
-
-    let(:status) do
-      Mutant::Parallel::Status.new(
-        active_jobs: [].to_set,
-        payload:     env_result,
-        done:        true
-      )
-    end
-
-    let(:config) do
-      Mutant::Config::DEFAULT.with(
-        jobs:     1,
-        reporter: Mutant::Reporter::Null.new
-      )
-    end
-
-    let(:subject_a) do
-      instance_double(
-        Mutant::Subject,
-        node:           subject_a_node,
-        source:         Unparser.unparse(subject_a_node),
-        identification: 'subject-a'
-      )
-    end
-
-    before do
-      allow(subject_a).to receive(:mutations).and_return([mutation_a, mutation_b])
-    end
-
-    let(:env_result) do
-      Mutant::Result::Env.new(
-        env:             env,
-        runtime:         4.0,
-        subject_results: [subject_a_result]
-      )
-    end
-
-    let(:mutation_a_result) do
-      Mutant::Result::Mutation.new(
-        mutation:         mutation_a,
-        isolation_result: mutation_a_isolation_result,
-        runtime:          1.0
-      )
-    end
-
-    let(:mutation_b_result) do
-      Mutant::Result::Mutation.new(
-        isolation_result: mutation_b_isolation_result,
-        mutation:         mutation_b,
-        runtime:          1.0
-      )
-    end
-
-    let(:mutation_a_isolation_result) do
-      Mutant::Isolation::Result::Success.new(mutation_a_test_result)
-    end
-
-    let(:mutation_a_test_result) do
-      Mutant::Result::Test.new(
-        tests:   [test_a],
-        passed:  false,
-        runtime: 1.0,
-        output:  'mutation a test result output'
-      )
-    end
-
-    let(:mutation_b_test_result) do
-      Mutant::Result::Test.new(
-        tests:   [test_a],
-        passed:  false,
-        runtime: 1.0,
-        output:  'mutation b test result output'
-      )
-    end
-
-    let(:mutation_b_isolation_result) do
-      Mutant::Isolation::Result::Success.new(mutation_b_test_result)
-    end
-
-    let(:subject_a_result) do
-      Mutant::Result::Subject.new(
-        subject:          subject_a,
-        tests:            [test_a],
-        mutation_results: [mutation_a_result, mutation_b_result]
-      )
-    end
-  end
-end # SharedContext

data/spec/support/test_app.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module TestApp
-  def self.root
-    File.expand_path('../../test_app', __dir__)
-  end
-end # TestApp

data/spec/support/warnings.yml

@@ -1,6 +0,0 @@
----
-- "lib/mutant/subject/method/instance.rb:9: warning: undefining `initialize' may cause serious problems"
-- 'lib/parallel.rb:222: warning: shadowing outer local variable - args'
-- 'lib/parallel.rb:227: warning: shadowing outer local variable - args'
-- 'lib/parser/lexer.rb:10836: warning: assigned but unused variable - testEof'
-- 'lib/regexp_parser/scanner.rb:1146: warning: assigned but unused variable - testEof'

data/spec/support/xspec.rb

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-
-module XSpec
-  class MessageReaction
-    include Concord.new(:event_list)
-
-    TERMINATE_EVENTS = IceNine.deep_freeze(%i[return exception].to_set)
-    VALID_EVENTS     = IceNine.deep_freeze(%i[return execute exception yields].to_set)
-
-    private_constant(*constants(false))
-
-    def call(observation)
-      event_list.map do |event, object|
-        __send__(event, observation, object)
-      end.last
-    end
-
-    # Parse events into reaction
-    #
-    # @param [Array{Symbol,Object}, Hash{Symbol,Object}]
-    #
-    # @return [MessageReaction]
-    def self.parse(events)
-      event_list = events.to_a
-      assert_valid(event_list)
-      new(event_list)
-    end
-
-  private
-
-    def return(_event, value)
-      value
-    end
-
-    def execute(_event, block)
-      block.call
-    end
-
-    def exception(_event, exception)
-      fail exception
-    end
-
-    def yields(observation, yields)
-      block = observation.block or fail 'No block passed where expected'
-
-      validate_block_arity(observation, yields)
-
-      block.call(*yields)
-    end
-
-    def validate_block_arity(observation, yields)
-      expected, observed = yields.length, observation.block.arity
-
-      # block allows anything we can skip the check
-      return if observed.equal?(-1)
-      fail 'Optargs currently not supported' if observed < -1
-      block_arity_mismatch(observation, expected, observed) unless expected.equal?(observed)
-    end
-
-    def block_arity_mismatch(observation, expected, observed)
-      fail "block arity mismatch, expected #{expected} observed #{observed}\nobservation:\n#{observation.inspect}"
-    end
-
-    alias_method :yields_return, :yields
-
-    def self.assert_valid(event_list)
-      assert_not_empty(event_list)
-      assert_valid_events(event_list)
-      assert_total(event_list)
-    end
-    private_class_method :assert_valid
-
-    def self.assert_valid_events(event_list)
-      event_list.map(&:first).each do |event|
-        fail "Invalid event: #{event}" unless VALID_EVENTS.include?(event)
-      end
-    end
-    private_class_method :assert_valid_events
-
-    def self.assert_not_empty(event_list)
-      fail 'no events' if event_list.empty?
-    end
-    private_class_method :assert_not_empty
-
-    def self.assert_total(event_list)
-      return unless event_list[0..-2].map(&:first).any?(&TERMINATE_EVENTS.method(:include?))
-
-      fail "Reaction not total: #{event_list}"
-    end
-    private_class_method :assert_total
-  end # MessageReaction
-
-  class MessageExpectation
-    include Anima.new(:receiver, :selector, :arguments, :reaction)
-
-    # rubocop:disable Metrics/ParameterLists
-    def self.parse(receiver:, selector:, arguments: [], reaction: nil)
-      new(
-        receiver:  receiver,
-        selector:  selector,
-        arguments: arguments,
-        reaction:  MessageReaction.parse(reaction || { return: nil })
-      )
-    end
-
-    def call(observation)
-      Verifier.new(self, observation).call
-    end
-
-    class Verifier
-      include Concord.new(:expectation, :observation)
-
-      VERIFIED_ATTRIBUTES = IceNine.deep_freeze(%i[receiver selector arguments])
-
-      def call
-        VERIFIED_ATTRIBUTES.each(&method(:assert_expected_attribute))
-
-        expectation.reaction.call(observation)
-      end
-
-    private
-
-      def assert_expected_attribute(name)
-        error("#{name} mismatch") unless observation.public_send(name).eql?(expectation.public_send(name))
-      end
-
-      def error(message)
-        fail "#{message},\n observation:\n #{observation.inspect}\n expectation:\n #{expectation.inspect}"
-      end
-
-      def trigger_exception
-        exception = expectation.exception
-        fail exception if exception
-      end
-
-    end # Verifier
-  end # MessageExpectation
-
-  class MessageObservation
-    include Anima.new(:receiver, :selector, :arguments, :block)
-  end # MessageObservation
-
-  class ExpectationVerifier
-    include Concord.new(:expectations)
-
-    def call(observation)
-      expectation = expectations.shift or fail "No expected message but observed #{observation.inspect}"
-      expectation.call(observation)
-    end
-
-    def assert_done
-      expectations.empty? or fail "unconsumed expectations:\n#{expectations.map(&:inspect).join("\n")}"
-    end
-
-    # rubocop:disable Metrics/MethodLength
-    def self.verify(rspec_context, expectations)
-      verifier = new(expectations)
-
-      hooks = expectations
-        .map { |expectation| [expectation.receiver, expectation.selector] }
-        .to_set
-
-      hooks.each do |receiver, selector|
-        rspec_context.instance_eval do
-          allow(receiver).to receive(selector) do |*arguments, &block|
-            verifier.call(
-              MessageObservation.new(
-                receiver:  receiver,
-                selector:  selector,
-                arguments: arguments,
-                block:     block
-              )
-            )
-          end
-        end
-      end
-
-      yield
-
-      verifier.assert_done
-    end
-  end # ExpectationVerifier
-end # XSpec