mutest 0.0.1 → 0.0.2

data/spec/support/ice_nine_config.rb

@@ -0,0 +1,8 @@
+require 'ice_nine'
+
+module IceNine
+  class Freezer
+    class RSpec < NoFreeze
+    end # RSpec
+  end # Freezer
+end # IceNine

data/spec/support/rb_bug.rb

@@ -0,0 +1,15 @@
+require 'ffi'
+
+# @api private
+module RbBug
+  extend FFI::Library
+  ffi_lib 'ruby'
+  attach_function :rb_bug, %i[string varargs], :void
+
+  # Call the test bug
+  #
+  # @return [undefined]
+  def self.call
+    rb_bug('%s', :string, 'test bug')
+  end
+end # RbBug

data/spec/support/ruby_vm.rb

@@ -0,0 +1,82 @@
+module MutestSpec
+  # 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)
+        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 # MutestSpec

data/spec/support/shared_context.rb

@@ -0,0 +1,125 @@
+# rubocop:disable 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 messages(&block)
+    let(:message_sequence) do
+      FakeActor::MessageSequence.new.tap do |sequence|
+        sequence.instance_eval(&block)
+      end
+    end
+  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(strip_indent(expected_content))
+    end
+  end
+
+  # rubocop:disable MethodLength
+  # rubocop:disable AbcSize
+  def setup_shared_context
+    let(:env)              { instance_double(Mutest::Env, config: config, subjects: [subject_a], mutations: mutations) }
+    let(:job_a)            { Mutest::Parallel::Job.new(index: 0, payload: mutation_a)                                  }
+    let(:job_b)            { Mutest::Parallel::Job.new(index: 1, payload: mutation_b)                                  }
+    let(:test_a)           { instance_double(Mutest::Test, identification: 'test-a')                                   }
+    let(:output)           { StringIO.new                                                                              }
+    let(:mutations)        { [mutation_a, mutation_b]                                                                  }
+    let(:mutation_a_node)  { s(:false)                                                                                 }
+    let(:mutation_b_node)  { s(:nil)                                                                                   }
+    let(:mutation_b)       { Mutest::Mutation::Evil.new(subject_a, mutation_b_node)                                    }
+    let(:mutation_a)       { Mutest::Mutation::Evil.new(subject_a, mutation_a_node)                                    }
+    let(:subject_a_node)   { s(:true)                                                                                  }
+
+    let(:status) do
+      Mutest::Parallel::Status.new(
+        active_jobs: [].to_set,
+        payload:     env_result,
+        done:        true
+      )
+    end
+
+    let(:config) do
+      Mutest::Config::DEFAULT.with(
+        jobs:     1,
+        reporter: Mutest::Reporter::Null.new
+      )
+    end
+
+    let(:subject_a) do
+      instance_double(
+        Mutest::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
+      Mutest::Result::Env.new(
+        env:             env,
+        runtime:         4.0,
+        subject_results: [subject_a_result]
+      )
+    end
+
+    let(:mutation_a_result) do
+      Mutest::Result::Mutation.new(
+        mutation:    mutation_a,
+        test_result: mutation_a_test_result
+      )
+    end
+
+    let(:mutation_b_result) do
+      Mutest::Result::Mutation.new(
+        mutation:    mutation_a,
+        test_result: mutation_b_test_result
+      )
+    end
+
+    let(:mutation_a_test_result) do
+      Mutest::Result::Test.new(
+        tests:   [test_a],
+        passed:  false,
+        runtime: 1.0,
+        output:  'mutation a test result output'
+      )
+    end
+
+    let(:mutation_b_test_result) do
+      Mutest::Result::Test.new(
+        tests:   [test_a],
+        passed:  false,
+        runtime: 1.0,
+        output:  'mutation b test result output'
+      )
+    end
+
+    let(:subject_a_result) do
+      Mutest::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

@@ -0,0 +1,5 @@
+module TestApp
+  def self.root
+    File.expand_path('../../../test_app', __FILE__)
+  end
+end # TestApp

data/spec/support/warning.rb

@@ -0,0 +1,73 @@
+require 'yaml'
+require 'equalizer'
+require 'memoizable'
+require 'ice_nine'
+
+module MutestSpec
+  class Warning
+    # Install our $stderr warning proxy only if the top level program is RSpec
+    #
+    # Mutest performs certain mutations which emit warnings that will obviously
+    # not be on our whitelist. We don't need to have enforce our warning assertions
+    # then anyways
+    def self.hook_under_rspec
+      $stderr = EXTRACTOR if $PROGRAM_NAME.end_with?('/rspec')
+    end
+
+    def self.assert_no_warnings
+      return if EXTRACTOR.warnings.empty?
+
+      fail UnexpectedWarnings, EXTRACTOR.warnings.to_a
+    end
+
+    class UnexpectedWarnings < StandardError
+      MSG = 'Unexpected warnings: %s'.freeze
+
+      def initialize(warnings)
+        super(MSG % warnings.join("\n"))
+      end
+    end # UnexpectedWarnings
+
+    class Extractor < DelegateClass(IO)
+      PATTERN = /\A(?:.+):(?:\d+): warning: (?:.+)\n\z/
+
+      include Equalizer.new(:whitelist, :seen, :io), Memoizable
+
+      def initialize(io, whitelist)
+        @whitelist = whitelist
+        @seen      = Set.new
+        @io        = io
+
+        super(io)
+      end
+
+      def write(message)
+        return super if PATTERN !~ message
+
+        add(message.chomp)
+
+        self
+      end
+
+      def warnings
+        seen.dup
+      end
+      memoize :warnings
+
+      private
+
+      def add(warning)
+        return if whitelist.any?(&warning.public_method(:end_with?))
+
+        seen << warning
+      end
+
+      attr_reader :whitelist, :seen, :io
+    end # Extractor
+
+    warnings  = Pathname.new(__dir__).join('warnings.yml').freeze
+    whitelist = IceNine.deep_freeze(YAML.safe_load(warnings.read))
+
+    EXTRACTOR = Extractor.new(STDERR, whitelist)
+  end # Warning
+end # MutestSpec

data/spec/support/warnings.yml

@@ -0,0 +1,5 @@
+---
+- 'lib/parser/lexer.rb:10922: warning: assigned but unused variable - testEof'
+- 'lib/parser/source/rewriter.rb:392: warning: assigned but unused variable - begin_pos'
+- 'lib/regexp_parser/scanner.rb:1646: warning: assigned but unused variable - testEof'
+- 'lib/regexp_parser/scanner.rb:1674: warning: assigned but unused variable - testEof'

data/spec/support/xspec.rb

@@ -0,0 +1,175 @@
+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 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(_, value)
+      value
+    end
+
+    def exception(_, 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 = yields.length
+      observed = 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)
+    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}"
+      expectation.call(observation)
+    end
+
+    def assert_done
+      expectations.empty? or fail "unconsumed expectations:\n#{expectations.map(&:inspect).join}"
+    end
+
+    # rubocop:disable 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