mutest 0.0.1 → 0.0.2

data/spec/support/compress_helper.rb

@@ -0,0 +1,9 @@
+module CompressHelper
+  def strip_indent(string)
+    lines       = string.lines
+    match       = /\A( *)/.match(lines.first)
+    return string unless match
+    whitespaces = match[1].to_s.length
+    lines.map { |line| line[whitespaces..-1] }.join
+  end
+end # CompressHelper

data/spec/support/corpus.rb

@@ -0,0 +1,331 @@
+require 'morpher'
+require 'anima'
+require 'mutest'
+
+# @api private
+module MutestSpec
+  ROOT = Pathname.new(__FILE__).parent.parent.parent
+
+  # Namespace module for corpus testing
+  #
+  # rubocop:disable MethodLength
+  module Corpus
+    TMP                 = ROOT.join('tmp').freeze
+    EXCLUDE_GLOB_FORMAT = '{%s}'.freeze
+    RUBY_GLOB_PATTERN   = '**/*.rb'.freeze
+
+    # Not in the docs. Number from chatting with their support.
+    # 2 processors allocated per container, 4 processes works well.
+    CIRCLE_CI_CONTAINER_PROCESSES = 4
+
+    private_constant(*constants(false))
+
+    # Project under corpus test
+    # rubocop:disable ClassLength
+    class Project
+      MUTEX = Mutex.new
+
+      MUTATION_GENERATION_MESSAGE = 'Total Mutations/Time/Parse-Errors: %s/%0.2fs - %0.2f/s'.freeze
+      START_MESSAGE               = 'Starting - %s'.freeze
+      FINISH_MESSAGE              = 'Mutations - %4i - %s'.freeze
+
+      DEFAULT_MUTATION_COUNT = 0
+
+      include Adamantium, Anima.new(
+        :expected_errors,
+        :mutation_coverage,
+        :mutation_generation,
+        :name,
+        :namespace,
+        :repo_uri,
+        :repo_ref
+      )
+
+      # Verify mutation coverage
+      #
+      # @return [self]
+      #   if successful
+      #
+      # @raise [Exception]
+      def verify_mutation_coverage
+        checkout
+        Dir.chdir(repo_path) do
+          Bundler.with_clean_env do
+            install_mutest
+            system(
+              %W[
+                bundle exec mutest
+                --use rspec
+                --include lib
+                --require #{name}
+                #{namespace}*
+              ]
+            )
+          end
+        end
+      end
+
+      # Verify mutation generation
+      #
+      # @return [self]
+      #   if successful
+      #
+      # @raise [Exception]
+      #   otherwise
+      def verify_mutation_generation
+        checkout
+        start = Time.now
+
+        options = {
+          finish:       method(:finish),
+          start:        method(:start),
+          in_processes: parallel_processes
+        }
+
+        total = Parallel.map(effective_ruby_paths, options, &method(:count_mutations_and_check_errors))
+          .inject(DEFAULT_MUTATION_COUNT, :+)
+
+        took = Time.now - start
+        puts format(MUTATION_GENERATION_MESSAGE, total, took, total / took)
+        self
+      end
+
+      # Checkout repository
+      #
+      # @return [self]
+      def checkout
+        return self if noinstall?
+        TMP.mkdir unless TMP.directory?
+
+        if repo_path.exist?
+          Dir.chdir(repo_path) do
+            system(%w[git fetch origin])
+            system(%w[git reset --hard])
+            system(%w[git clean -f -d -x])
+          end
+        else
+          system(%W[git clone #{repo_uri} #{repo_path}])
+        end
+
+        Dir.chdir(repo_path) do
+          system(%W[git checkout #{repo_ref}])
+          system(%w[git reset --hard])
+          system(%w[git clean -f -d -x])
+        end
+
+        self
+      end
+      memoize :checkout
+
+      private
+
+      # Count mutations and check error results against whitelist
+      #
+      # @param path [Pathname] path responsible for exception
+      #
+      # @return [Fixnum] mutations generated
+      def count_mutations_and_check_errors(path)
+        relative_path = path.relative_path_from(repo_path)
+
+        count = count_mutations(path)
+
+        expected_errors.assert_success(relative_path)
+
+        count
+      rescue Exception => exception # rubocop:disable Lint/RescueException
+        expected_errors.assert_error(relative_path, exception)
+
+        DEFAULT_MUTATION_COUNT
+      end
+
+      # Count mutations generated for provided source file
+      #
+      # @param path [Pathname] path to a source file
+      #
+      # @raise [Exception] any error specified by integrations.yml
+      #
+      # @return [Fixnum] number of mutations generated
+      def count_mutations(path)
+        node = Parser::CurrentRuby.parse(path.read)
+
+        return DEFAULT_MUTATION_COUNT unless node
+
+        Mutest::Mutator.mutate(node).length
+      end
+
+      # Install mutest
+      #
+      # @return [undefined]
+      def install_mutest
+        return if noinstall?
+        relative = ROOT.relative_path_from(repo_path)
+        repo_path.join('Gemfile').open('a') do |file|
+          file << "gem 'mutest', path: '#{relative}'\n"
+          file << "gem 'mutest-rspec', path: '#{relative}'\n"
+          file << "eval_gemfile File.expand_path('#{relative.join('Gemfile.shared')}')\n"
+        end
+        lockfile = repo_path.join('Gemfile.lock')
+        lockfile.delete if lockfile.exist?
+        system(%w[bundle])
+      end
+
+      # The effective ruby file paths
+      #
+      # @return [Array<Pathname>]
+      def effective_ruby_paths
+        Pathname
+          .glob(repo_path.join(RUBY_GLOB_PATTERN))
+          .sort_by(&:size)
+          .reverse
+      end
+
+      # Number of parallel processes to use
+      #
+      # @return [Fixnum]
+      def parallel_processes
+        if ENV.key?('CI')
+          CIRCLE_CI_CONTAINER_PROCESSES
+        else
+          Parallel.processor_count
+        end
+      end
+
+      # Repository path
+      #
+      # @return [Pathname]
+      def repo_path
+        TMP.join(name)
+      end
+
+      # Test if installation should be skipped
+      #
+      # @return [Boolean]
+      def noinstall?
+        ENV.key?('NOINSTALL')
+      end
+
+      # Print start progress
+      #
+      # @param [Pathname] path
+      # @param [Fixnum] _index
+      #
+      # @return [undefined]
+      #
+      def start(path, _index)
+        MUTEX.synchronize do
+          puts START_MESSAGE % path
+        end
+      end
+
+      # Print finish progress
+      #
+      # @param [Pathname] path
+      # @param [Fixnum] _index
+      # @param [Fixnum] count
+      #
+      # @return [undefined]
+      #
+      def finish(path, _index, count)
+        MUTEX.synchronize do
+          puts format(FINISH_MESSAGE, count, path)
+        end
+      end
+
+      # Helper method to execute system commands
+      #
+      # @param [Array<String>] arguments
+      #
+      def system(arguments)
+        return if Kernel.system(*arguments)
+
+        if block_given?
+          yield
+        else
+          fail "System command failed!: #{arguments.join(' ')}"
+        end
+      end
+
+      # Mapping of files which we expect to cause errors during mutation generation
+      class ErrorWhitelist
+        class UnnecessaryExpectation < StandardError
+          MESSAGE = 'Expected to encounter %s while mutating "%s"'.freeze
+
+          def initialize(*error_info)
+            super(MESSAGE % error_info)
+          end
+        end # UnnecessaryExpectation
+
+        include Concord.new(:map), Adamantium
+
+        # Assert that we expect to encounter the provided exception for this path
+        #
+        # @param path [Pathname]
+        # @param exception [Exception]
+        #
+        # @raise provided exception if we are not expecting this error
+        #
+        # This method is reraising exceptions but rubocop can't tell
+        # rubocop:disable Style/SignalException
+        #
+        # @return [undefined]
+        def assert_error(path, exception)
+          original_error = exception.cause || exception
+
+          raise exception unless map.fetch(original_error.inspect, []).include?(path)
+        end
+
+        # Assert that we expect to not encounter an error for the specified path
+        #
+        # @param path [Pathname]
+        #
+        # @raise [UnnecessaryExpectation] if we are expecting an exception for this path
+        #
+        # @return [undefined]
+        def assert_success(path)
+          map.each do |error, paths|
+            fail UnnecessaryExpectation.new(error, path) if paths.include?(path)
+          end
+        end
+
+        # Return representation as hash
+        #
+        # @note this method is necessary for morpher loader to be invertible
+        #
+        # @return [Hash{Pathname => String}]
+        def to_h
+          map
+        end
+      end # ErrorWhitelist
+
+      LOADER =
+        Morpher.build do
+          s(:block,
+            s(:guard, s(:primitive, Array)),
+            s(:map,
+              s(:block,
+                s(:guard, s(:primitive, Hash)),
+                s(:hash_transform,
+                  s(:key_symbolize, :repo_uri,            s(:guard, s(:primitive, String))),
+                  s(:key_symbolize, :repo_ref,            s(:guard, s(:primitive, String))),
+                  s(:key_symbolize, :name,                s(:guard, s(:primitive, String))),
+                  s(:key_symbolize, :namespace,           s(:guard, s(:primitive, String))),
+                  s(:key_symbolize, :mutation_coverage,
+                    s(:guard, s(:or, s(:primitive, TrueClass), s(:primitive, FalseClass)))),
+                  s(:key_symbolize, :mutation_generation,
+                    s(:guard, s(:or, s(:primitive, TrueClass), s(:primitive, FalseClass)))),
+                  s(:key_symbolize, :expected_errors,
+                    s(:block,
+                      s(:guard, s(:primitive, Hash)),
+                      s(:custom,
+                        [
+                          ->(hash) { hash.map { |key, values| [key, values.map(&Pathname.method(:new))] }.to_h },
+                          ->(hash) { hash.map { |key, values| [key, values.map(&:to_s)]                 }.to_h }
+                        ]),
+                      s(:load_attribute_hash, s(:param, ErrorWhitelist))))),
+                s(:anima_load, Project))))
+        end
+
+      ALL = LOADER.call(YAML.load_file(ROOT.join('spec', 'integrations.yml')))
+    end # Project
+  end # Corpus
+end # MutestSpec

data/spec/support/fake_actor.rb

@@ -0,0 +1,107 @@
+require 'mutest/actor'
+
+# A fake actor used from specs
+module FakeActor
+  class Expectation
+    include Concord::Public.new(:name, :message, :block)
+    include Equalizer.new(:name, :message)
+
+    def self.new(_name, _message, _block = nil)
+      super
+    end
+
+    def verify(other)
+      fail "Got:\n#{other.inspect}\nExpected:\n#{inspect}" unless eql?(other)
+      block.call(other.message) if block
+    end
+  end # Expectation
+
+  class MessageSequence
+    include Adamantium::Flat, Concord::Public.new(:messages)
+
+    def self.new
+      super([])
+    end
+
+    def add(name, *message_arguments, &block)
+      messages << Expectation.new(name, Mutest::Actor::Message.new(*message_arguments), block)
+      self
+    end
+
+    def sending(expectation)
+      fail "Unexpected send: #{expectation.inspect}" if messages.empty?
+      expected = messages.shift
+      expected.verify(expectation)
+      self
+    end
+
+    def receiving(name)
+      fail "No message to read for #{name.inspect}" if messages.empty?
+      expected = messages.shift
+      fail "Unexpected message #{expected.inspect} for #{name.inspect}" unless expected.name.eql?(name)
+      expected.message
+    end
+
+    def consumed?
+      messages.empty?
+    end
+  end # MessageSequence
+
+  class Env
+    include Concord.new(:messages, :mailbox_names)
+
+    def spawn
+      mailbox = mailbox(next_name)
+      yield mailbox if block_given?
+      mailbox.sender
+    end
+
+    def mailbox(name)
+      Mailbox.new(name, @messages)
+    end
+
+    def new_mailbox
+      mailbox(:current)
+    end
+
+    private
+
+    def next_name
+      @mailbox_names.shift.tap do |name|
+        name or fail 'Tried to spawn actor when no name available'
+      end
+    end
+  end # Env
+
+  class Mailbox
+    include Concord.new(:name, :messages)
+
+    def receiver
+      Receiver.new(name, messages)
+    end
+
+    def sender
+      Sender.new(name, messages)
+    end
+
+    def bind(sender)
+      Mutest::Actor::Binding.new(self, sender)
+    end
+  end # Mailbox
+
+  class Sender
+    include Concord.new(:name, :messages)
+
+    def call(message)
+      messages.sending(Expectation.new(name, message))
+    end
+  end # Sender
+
+  class Receiver
+    include Concord::Public.new(:name, :messages)
+
+    def call
+      messages.receiving(name)
+    end
+  end # Receiver
+end # FakeActor

data/spec/support/file_system.rb

@@ -0,0 +1,60 @@
+module MutestSpec
+  class FileState
+    DEFAULTS = IceNine.deep_freeze(
+      file:     false,
+      contents: nil,
+      requires: []
+    )
+
+    include Adamantium, Anima.new(*DEFAULTS.keys)
+
+    def self.new(attributes = DEFAULTS)
+      super(DEFAULTS.merge(attributes))
+    end
+
+    DOES_NOT_EXIST = new
+
+    alias_method :file?, :file
+  end # FileState
+
+  class FakePathname
+    include Adamantium, Concord.new(:file_system, :pathname)
+
+    def join(*arguments)
+      self.class.new(
+        file_system,
+        pathname.join(*arguments)
+      )
+    end
+
+    def read
+      state.contents
+    end
+
+    def to_s
+      pathname.to_s
+    end
+
+    def file?
+      state.file?
+    end
+
+    private
+
+    def state
+      file_system.state(pathname.to_s)
+    end
+  end # FakePathname
+
+  class FileSystem
+    include Adamantium, Concord.new(:file_states)
+
+    def state(filename)
+      file_states.fetch(filename, FileState::DOES_NOT_EXIST)
+    end
+
+    def path(filename)
+      FakePathname.new(self, Pathname.new(filename))
+    end
+  end # FileSystem
+end # MutestSpec