mutant 0.6.7 → 0.7.1

data/lib/mutant/runner/scheduler.rb

@@ -0,0 +1,141 @@
+module Mutant
+  class Runner
+    # Job scheduler
+    class Scheduler
+      include Concord.new(:env)
+
+      # Initialize object
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(*)
+        super
+        @index           = 0
+        @start           = Time.now
+        @active_jobs     = Set.new
+        @subject_results = Hash.new do |_hash, subject|
+          Result::Subject.new(
+            subject:          subject,
+            mutation_results: []
+          )
+        end
+      end
+
+      # Return runner status
+      #
+      # @return [Status]
+      #
+      # @api private
+      #
+      def status
+        Status.new(
+          env_result:  env_result,
+          done:        done?,
+          active_jobs: @active_jobs.dup
+        )
+      end
+
+      # Return next job
+      #
+      # @return [Job]
+      #   in case there is a next job
+      #
+      # @return [nil]
+      #   otherwise
+      #
+      # @api private
+      def next_job
+        return unless next_mutation?
+
+        Job.new(
+          mutation: mutations.fetch(@index),
+          index:    @index
+        ).tap do |job|
+          @index += 1
+          @active_jobs << job
+        end
+      end
+
+      # Consume job result
+      #
+      # @param [JobResult] job_result
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def job_result(job_result)
+        @active_jobs.delete(job_result.job)
+        mutation_result(job_result.result)
+        self
+      end
+
+    private
+
+      # Test if mutation run is done
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def done?
+        !env_result.continue? || (!next_mutation? && @active_jobs.empty?)
+      end
+
+      # Handle mutation finish
+      #
+      # @param [Result::Mutation] mutation_result
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def mutation_result(mutation_result)
+        mutation = mutation_result.mutation
+
+        original = @subject_results[mutation.subject]
+
+        @subject_results[mutation.subject] = original.update(
+          mutation_results: (original.mutation_results.dup << mutation_result)
+        )
+      end
+
+      # Test if a next mutation exist
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def next_mutation?
+        mutations.length > @index
+      end
+
+      # Return mutations
+      #
+      # @return [Array<Mutation>]
+      #
+      # @api private
+      #
+      def mutations
+        env.mutations
+      end
+
+      # Return current result
+      #
+      # @return [Result::Env]
+      #
+      # @api private
+      #
+      def env_result
+        Result::Env.new(
+          env:             env,
+          runtime:         Time.now - @start,
+          subject_results: @subject_results.values
+        )
+      end
+
+    end # Scheduler
+  end # Runner
+end # Mutant

data/lib/mutant/runner/worker.rb

@@ -0,0 +1,93 @@
+module Mutant
+  class Runner
+    # Mutation killing worker receiving work from parent
+    class Worker
+      include Adamantium::Flat, Anima.new(:config, :id, :parent)
+
+      private_class_method :new
+
+      # Run worker
+      #
+      # @param [Hash<Symbol, Object] attributes
+      #
+      # @return [Actor::Sender]
+      #
+      # @api private
+      #
+      def self.run(attributes)
+        attributes.fetch(:config).actor_env.spawn do |actor|
+          worker = new(attributes)
+          worker.send(:run, actor)
+        end
+      end
+
+    private
+
+      # Worker loop
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      # rubocop:disable Lint/Loop
+      #
+      def run(actor)
+        begin
+          parent.call(Actor::Message.new(:ready, actor.sender))
+        end until handle(actor.receiver.call)
+      end
+
+      # Handle job
+      #
+      # @param [Message] message
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def handle(message)
+        type, payload = message.type, message.payload
+        case message.type
+        when :job
+          handle_job(payload)
+          nil
+        when :stop
+          true
+        else
+          fail Actor::ProtocolError, "Unknown command: #{type.inspect}"
+        end
+      end
+
+      # Handle mutation
+      #
+      # @param [Job] job
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def handle_job(job)
+        parent.call(Actor::Message.new(:result, JobResult.new(job: job, result: run_mutation(job))))
+      end
+
+      # Run mutation
+      #
+      # @param [Mutation] mutation
+      #
+      # @return [Report::Mutation]
+      #
+      # @api private
+      #
+      def run_mutation(job)
+        mutation = job.mutation
+        test_result = mutation.kill(config.isolation, config.integration)
+        Result::Mutation.new(
+          index:       job.index,
+          mutation:    mutation,
+          test_result: test_result
+        )
+      end
+
+    end # Worker
+  end # Runner
+end # Mutant

data/lib/mutant/subject/method/instance.rb

@@ -7,10 +7,6 @@ module Mutant
         NAME_INDEX = 0
         SYMBOL     = '#'.freeze
 
-        # A list of methods that will warn when they are undefined
-        WARN_METHODS_UNDEFINED =
-          RUBY_ENGINE.eql?('ruby') ? [:initialize, :__send__, :object_id].freeze : EMPTY_ARRAY
-
         # Test if method is public
         #
         # @return [Boolean]
@@ -22,8 +18,6 @@ module Mutant
         end
         memoize :public?
 
-        LINE_INCREMENT = defined?(Zombie) ? -11 : 5
-
         # Prepare subject for mutation insertion
         #
         # @return [self]
@@ -31,15 +25,7 @@ module Mutant
         # @api private
         #
         def prepare
-          expected_warnings =
-            if WARN_METHODS_UNDEFINED.include?(name)
-              ["#{__FILE__}:#{__LINE__ + LINE_INCREMENT}: warning: undefining `#{name}' may cause serious problems\n"]
-            else
-              EMPTY_ARRAY
-            end
-          WarningExpectation.new(expected_warnings).execute do
-            scope.send(:undef_method, name)
-          end
+          scope.send(:undef_method, name)
           self
         end
 

data/lib/mutant/test.rb

@@ -1,7 +1,7 @@
 module Mutant
   # Abstract base class for test that might kill a mutation
   class Test
-    include Adamantium::Flat, Concord::Public.new(:integration, :expression)
+    include Adamantium::Flat, Anima.new(:id, :expression)
 
     # Return test identification
     #
@@ -9,20 +9,7 @@ module Mutant
     #
     # @api private
     #
-    def identification
-      "#{integration.name}:#{expression.syntax}"
-    end
-    memoize :identification
-
-    # Run test, return report
-    #
-    # @return [Report]
-    #
-    # @api private
-    #
-    def run
-      integration.run(self)
-    end
+    alias_method :identification, :id
 
   end # Test
 end # Mutant

data/lib/mutant/version.rb

@@ -1,4 +1,4 @@
 module Mutant
   # The current mutant version
-  VERSION = '0.6.7'.freeze
+  VERSION = '0.7.1'.freeze
 end # Mutant

data/meta/send.rb

@@ -5,6 +5,7 @@ Mutant::Meta::Example.add do
 
   singleton_mutations
   mutation 'a == b'
+  mutation 'a >= b'
   mutation 'a.eql?(b)'
   mutation 'a.equal?(b)'
   mutation 'nil > b'
@@ -52,6 +53,7 @@ Mutant::Meta::Example.add do
 
   singleton_mutations
   mutation 'a == b'
+  mutation 'a <= b'
   mutation 'a.eql?(b)'
   mutation 'a.equal?(b)'
   mutation 'nil < b'
@@ -187,12 +189,26 @@ Mutant::Meta::Example.add do
   mutation 'self.gsub(a, b)'
 end
 
+Mutant::Meta::Example.add do
+  source 'foo.__send__(bar)'
+
+  singleton_mutations
+  mutation 'foo.__send__'
+  mutation 'foo.public_send(bar)'
+  mutation 'bar'
+  mutation 'foo'
+  mutation 'self.__send__(bar)'
+  mutation 'foo.__send__(nil)'
+  mutation 'foo.__send__(self)'
+end
+
 Mutant::Meta::Example.add do
   source 'foo.send(bar)'
 
   singleton_mutations
   mutation 'foo.send'
   mutation 'foo.public_send(bar)'
+  mutation 'foo.__send__(bar)'
   mutation 'bar'
   mutation 'foo'
   mutation 'self.send(bar)'

data/mutant-rspec.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |gem|
   gem.extra_rdoc_files = %w[TODO LICENSE]
 
   gem.add_runtime_dependency('mutant', "~> #{gem.version}")
-  gem.add_runtime_dependency('rspec-core', '>= 2.14.1', '< 3.2.0')
+  gem.add_runtime_dependency('rspec-core', '>= 3.0.0', '< 3.2.0')
 
   gem.add_development_dependency('bundler', '~> 1.3', '>= 1.3.5')
 end

data/mutant.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency('procto',        '~> 0.0.2')
   gem.add_runtime_dependency('abstract_type', '~> 0.0.7')
   gem.add_runtime_dependency('unparser',      '~> 0.1.16')
-  gem.add_runtime_dependency('ice_nine',      '~> 0.11.0')
+  gem.add_runtime_dependency('ice_nine',      '~> 0.11.1')
   gem.add_runtime_dependency('adamantium',    '~> 0.2.0')
   gem.add_runtime_dependency('memoizable',    '~> 0.4.2')
   gem.add_runtime_dependency('equalizer',     '~> 0.0.9')

data/spec/integration/mutant/rspec_spec.rb

@@ -38,12 +38,6 @@ RSpec.describe 'rspec integration' do
     end
   end
 
-  context 'RSpec 2' do
-    let(:gemfile) { 'Gemfile.rspec2' }
-
-    it_behaves_like 'rspec integration'
-  end
-
   context 'RSpec 3.0' do
     let(:gemfile) { 'Gemfile.rspec3.0' }
 

data/spec/spec_helper.rb

@@ -12,7 +12,7 @@ if ENV['COVERAGE'] == 'true'
     add_filter 'lib/mutant/zombifier'
     add_filter 'lib/mutant/zombifier/*'
 
-    minimum_coverage 97.64  # TODO: raise this to 100, then mutation test
+    minimum_coverage 100
   end
 end
 
@@ -45,8 +45,16 @@ module ParserHelper
   end
 end
 
+module MessageHelper
+  def message(*arguments)
+    Mutant::Actor::Message.new(*arguments)
+  end
+end
+
 RSpec.configure do |config|
+  config.extend(SharedContext)
   config.include(CompressHelper)
+  config.include(MessageHelper)
   config.include(ParserHelper)
   config.include(Mutant::AST::Sexp)
 end

data/spec/support/fake_actor.rb

@@ -0,0 +1,93 @@
+require 'mutant/actor'
+
+# A fake actor used from specs
+module FakeActor
+  class Expectation
+    include Concord::Public.new(:name, :message)
+  end
+
+  class MessageSequence
+    include Adamantium::Flat, Concord.new(:messages)
+
+    def self.new
+      super([])
+    end
+
+    def add(name, *message_arguments)
+      messages << Expectation.new(name, Mutant::Actor::Message.new(*message_arguments))
+      self
+    end
+
+    def sending(expectation)
+      raise "Unexpected send: #{expectation.inspect}" if messages.empty?
+      expected = messages.shift
+      unless expectation.eql?(expected)
+        raise "Got:\n#{expectation.inspect}\nExpected:\n#{expected.inspect}"
+      end
+      self
+    end
+
+    def receiving(name)
+      raise "No message to read for #{name.inspect}" if messages.empty?
+      expected = messages.shift
+      raise "Unexpected message #{expected.inspect} for #{name.inspect}" unless expected.name.eql?(name)
+      expected.message
+    end
+
+    def consumed?
+      messages.empty?
+    end
+  end
+
+  class Env
+    include Concord.new(:messages, :actor_names)
+
+    def spawn
+      name = @actor_names.shift
+      raise 'Tried to spawn actor when no name available' unless name
+      actor = actor(name)
+      yield actor if block_given?
+      actor.sender
+    end
+
+    def current
+      actor(:current)
+    end
+
+    def actor(name)
+      Actor.new(name, @messages)
+    end
+  end # Env
+
+  class Actor
+    include Concord.new(:name, :messages)
+
+    def receiver
+      Receiver.new(name, messages)
+    end
+
+    def sender
+      Sender.new(name, messages)
+    end
+
+    def bind(sender)
+      Mutant::Actor::Binding.new(self, sender)
+    end
+  end
+
+  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
+end