mutant 0.8.10 → 0.8.11

data/spec/support/fake_actor.rb

@@ -16,7 +16,7 @@ module FakeActor
       end
       block.call(other.message) if block
     end
-  end
+  end # Expectation
 
   class MessageSequence
     include Adamantium::Flat, Concord::Public.new(:messages)
@@ -47,7 +47,7 @@ module FakeActor
     def consumed?
       messages.empty?
     end
-  end
+  end # MessageSequence
 
   class Env
     include Concord.new(:messages, :mailbox_names)
@@ -89,7 +89,7 @@ module FakeActor
     def bind(sender)
       Mutant::Actor::Binding.new(self, sender)
     end
-  end
+  end # Mailbox
 
   class Sender
     include Concord.new(:name, :messages)
@@ -105,5 +105,5 @@ module FakeActor
     def call
       messages.receiving(name)
     end
-  end
-end
+  end # Receiver
+end # FakeActor

data/spec/support/file_system.rb

@@ -44,7 +44,7 @@ module MutantSpec
     def state
       file_system.state(pathname.to_s)
     end
-  end # Pathname
+  end # FakePathname
 
   class FileSystem
     include Adamantium, Concord.new(:file_states)

data/spec/support/ice_nine_config.rb

@@ -3,6 +3,6 @@ require 'ice_nine'
 module IceNine
   class Freezer
     class RSpec < NoFreeze
-    end
-  end
-end
+    end # RSpec
+  end # Freezer
+end # IceNine

data/spec/support/ruby_vm.rb

@@ -3,18 +3,19 @@ module MutantSpec
   # require semantics Zombifier relies on in a way we can avoid having to
   # mock around everywhere to test every detail.
   class RubyVM
-    include Concord.new(:expected_events)
+    include Concord::Public.new(:expected_events)
 
     # An event being observed by the VM handlers
     class EventObservation
       include Concord::Public.new(:type, :payload)
-    end
+    end # EventObservation
 
     # An event being expected, can advance the VM
     class EventExpectation
       include AbstractType, Anima.new(
         :expected_payload,
-        :trigger_requires
+        :trigger_requires,
+        :return_value
       )
 
       DEFAULTS = IceNine.deep_freeze(trigger_requires: [])
@@ -29,29 +30,28 @@ module MutantSpec
         end
 
         trigger_requires.each(&vm.method(:require))
+
+        self
       end
 
     private
 
-      abstract_method :advance_vm
-
       def match?(observation)
         observation.type.eql?(self.class) && observation.payload.eql?(expected_payload)
       end
 
       # Expectation and advance on require calls
       class Require < self
-      end
+      end # Require
 
       # Expectation and advance on eval calls
       class Eval < self
-      end
-    end
+      end # Eval
+    end # EventExpectation
 
     # A fake implementation of Kernel#require
     def require(logical_name)
       handle_event(EventObservation.new(EventExpectation::Require, logical_name: logical_name))
-      self
     end
 
     # A fake implementation of Kernel#eval
@@ -64,7 +64,6 @@ module MutantSpec
           source_location: location
         )
       )
-      self
     end
 
     # Test if VM events where fully processed
@@ -77,7 +76,7 @@ module MutantSpec
     def handle_event(observation)
       fail "Unexpected event: #{observation.type} / #{observation.payload}" if expected_events.empty?
 
-      expected_events.slice!(0).handle(self, observation)
+      expected_events.slice!(0).handle(self, observation).return_value
     end
-  end
+  end # RubyVM
 end # MutantSpec

data/spec/support/shared_context.rb

@@ -1,9 +1,18 @@
 # 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)
-    define_method(name) do
-      super().with(instance_eval(&block))
-    end
+    new_definition =
+      Module.new do
+        define_method(name) do
+          super().with(instance_eval(&block))
+        end
+      end
+
+    prepend(new_definition)
   end
 
   def messages(&block)
@@ -52,8 +61,8 @@ module SharedContext
 
     let(:config) do
       Mutant::Config::DEFAULT.with(
-        jobs:      1,
-        reporter:  Mutant::Reporter::Null.new
+        jobs:     1,
+        reporter: Mutant::Reporter::Null.new
       )
     end
 
@@ -94,19 +103,19 @@ module SharedContext
 
     let(:mutation_a_test_result) do
       Mutant::Result::Test.new(
-        tests:    [test_a],
-        passed:   false,
-        runtime:  1.0,
+        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'
+        tests:   [test_a],
+        passed:  false,
+        runtime: 1.0,
+        output:  'mutation b test result output'
       )
     end
 
@@ -126,4 +135,4 @@ module SharedContext
       subject_a_result.with(mutation_results: [mutation_a_result])
     end
   end
-end
+end # SharedContext

data/spec/support/test_app.rb

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

data/spec/support/warning.rb

@@ -0,0 +1,64 @@
+require 'yaml'
+require 'equalizer'
+require 'memoizable'
+require 'ice_nine'
+
+module MutantSpec
+  class Warning
+    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
+
+    class Extractor < DelegateClass(IO)
+      PATTERN = /\A(?:.+):(?:\d+): warning: (?:.+)\n\z/.freeze
+
+      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
+
+    warnings  = Pathname.new(__dir__).join('warnings.yml').freeze
+    whitelist = IceNine.deep_freeze(YAML.load(warnings.read))
+
+    EXTRACTOR = Extractor.new(STDERR, whitelist)
+  end
+end

data/spec/support/warnings.yml

@@ -0,0 +1,4 @@
+---
+- 'lib/parser/lexer.rb:10791: 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'

data/spec/support/xspec.rb

@@ -0,0 +1,177 @@
+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, 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)
+      if event_list[0..-2].map(&:first).any?(&TERMINATE_EVENTS.method(:include?))
+        fail "Reaction not total: #{event_list}"
+      end
+    end
+    private_class_method :assert_total
+  end # MessageReaction
+
+  class MessageExpectation
+    include Anima.new(:receiver, :selector, :arguments, :reaction)
+
+    # rubocop:disable 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}"
+      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