parallel_minion 1.2.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ec80ef2321aa78ba6f8b6dc7b16452f1ccb15a9b
-  data.tar.gz: f3a394698da183ce6e64c8137ac7cf50cae98943
+SHA256:
+  metadata.gz: 8ee831ee7f2939c246ff997e0abbdeca9f2779a4faa21d68d1cd6d4e27c09b52
+  data.tar.gz: e681733d3cbd2e9da49a0552e070a9fa52be776208d2bbfa02943752fd3b6a53
 SHA512:
-  metadata.gz: 946b4306251796613bf5a44b89d32016aa0a9133048caaaa698206151aeb5e9dc4684e377230d767b2fb8bcc2f952a83c18c140f96bcb7e5c44fdee10f88c16c
-  data.tar.gz: 1f52084ea14e186ff3796f8276fbc879bb99ada6d0b05fead4513b26a4611a471064c2ebbbc0cdb27ced7e1e9a41135674083436b2737108a54b921f640fb1fc
+  metadata.gz: aa0986ec9d4c9c8713f9a19a37ba32739af5c184fd558e1ce9860a2b38de5caf6ccb8aa1a933fb4969f9ca94224a21386fd608551b6d582d0e2418976b9c26c6
+  data.tar.gz: 8d7b3ca45414d9154311fed2fa3d7ab487f201224532e07304c1f8965265d0d8bb96a44da10aa4b82b940869df0c60c3e91e1fbd43390f0595cc91a6aef716e8

data/README.md

@@ -1,7 +1,7 @@
-parallel_minion [![Build Status](https://secure.travis-ci.org/reidmorrison/parallel_minion.png?branch=master)](http://travis-ci.org/reidmorrison/parallel_minion)
-===============
+# Parallel Minion
+[![Gem Version](https://img.shields.io/gem/v/parallel_minion.svg)](https://rubygems.org/gems/parallel_minion) [![Build Status](https://github.com/reidmorrison/parallel_minion/workflows/build/badge.svg)](https://github.com/reidmorrison/parallel_minion/actions?query=workflow%3Abuild) [![Downloads](https://img.shields.io/gem/dt/parallel_minion.svg)](https://rubygems.org/gems/parallel_minion) [![License](https://img.shields.io/badge/license-Apache%202.0-brightgreen.svg)](http://opensource.org/licenses/Apache-2.0) ![](https://img.shields.io/badge/status-Production%20Ready-blue.svg)
 
-Pragmatic approach to parallel processing in Ruby
+Wrap Ruby code with a minion so that it is run on a parallel thread.
 
 ## Description
 
@@ -46,12 +46,20 @@ has been achieved by moving existing blocks of code into Minions.
 
     gem install parallel_minion
 
+## Rails 7.2 compatibility
+
+- **Apps** need **Ruby ≥ 3.1** (Rails 7.2 requirement).
+- **Code:** Thread cleanup uses `ActiveRecord::Base.connection_handler.clear_active_connections!` instead of `ActiveRecord::Base.clear_active_connections!` because Rails 7 deprecates the latter.
+- **Railtie:** Unchanged (`config.parallel_minion` as before).
+- **CI:** `rails_7.2` Appraisal  `gemfiles/rails_7.2.gemfile`, Ruby 3.2. The 7.2 appraisal pins **Minitest ~> 5.0** (tests use `stub`, removed in Minitest 6).
+- **sqlite3 (dev):** The 7.2 appraisal allows `sqlite3 >= 1.4` (including 2.x). Other gemfiles use `sqlite3 >= 1.5, < 2` to skip **1.4.4**, which often fails to compile on modern toolchains (all OSes).
+
 ## Meta
 
 * Code: `git clone git://github.com/reidmorrison/parallel_minion.git`
 * Home: <https://github.com/reidmorrison/parallel_minion>
 * Bugs: <http://github.com/reidmorrison/parallel_minion/issues>
-* Gems: <http://rubygems.org/gems/parallel_minion>
+* Gems: <https://rubygems.org/gems/parallel_minion>
 
 This project uses [Semantic Versioning](http://semver.org/).
 

data/Rakefile

@@ -1,30 +1,30 @@
 # Setup bundler to avoid having to run bundle exec all the time.
-require 'rubygems'
-require 'bundler/setup'
+require "rubygems"
+require "bundler/setup"
 
-require 'rake/testtask'
-require_relative 'lib/parallel_minion/version'
+require "rake/testtask"
+require_relative "lib/parallel_minion/version"
 
 task :gem do
-  system 'gem build parallel_minion.gemspec'
+  system "gem build parallel_minion.gemspec"
 end
 
-task :publish => :gem do
-  system "git tag -a v#{ParallelMinion::VERSION} -m 'Tagging #{ParallelMinion::VERSION}'"
-  system 'git push --tags'
+task publish: :gem do
+  # system "git tag -a v#{ParallelMinion::VERSION} -m 'Tagging #{ParallelMinion::VERSION}'"
+  # system "git push --tags"
   system "gem push parallel_minion-#{ParallelMinion::VERSION}.gem"
   system "rm parallel_minion-#{ParallelMinion::VERSION}.gem"
 end
 
 Rake::TestTask.new(:test) do |t|
-  t.pattern = 'test/**/*_test.rb'
+  t.pattern = "test/**/*_test.rb"
   t.verbose = true
   t.warning = false
 end
 
 # By default run tests against all appraisals
 if !ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"]
-  require 'appraisal'
+  require "appraisal"
   task default: :appraisal
 else
   task default: :test

data/lib/parallel_minion/minion.rb

@@ -22,7 +22,7 @@ module ParallelMinion
     # Metrics [String]
     attr_reader :metric, :wait_metric
 
-    attr_reader :on_timeout, :log_exception, :start_time
+    attr_reader :on_timeout, :log_exception, :start_time, :on_exception_level
 
     # Give an infinite amount of time to wait for a Minion to complete a task
     INFINITE = 0
@@ -40,8 +40,8 @@ module ParallelMinion
     # - Production:
     #     Batch processing in Rocket Job where throughput is more important than latency.
     #       http://rocketjob.io
-    def self.enabled=(enabled)
-      @enabled = enabled
+    class << self
+      attr_writer :enabled
     end
 
     # Returns whether minions are enabled to run in their own threads
@@ -54,8 +54,8 @@ module ParallelMinion
     #
     # Example:
     #   ...
-    def self.scoped_classes
-      @scoped_classes
+    class << self
+      attr_reader :scoped_classes
     end
 
     def self.scoped_classes=(scoped_classes)
@@ -70,11 +70,12 @@ module ParallelMinion
     #   :trace, :debug, :info, :warn, :error, :fatal
     def self.started_log_level=(level)
       raise(ArgumentError, "Invalid log level: #{level}") unless SemanticLogger::LEVELS.include?(level)
+
       @started_log_level = level
     end
 
-    def self.started_log_level
-      @started_log_level
+    class << self
+      attr_reader :started_log_level
     end
 
     # Change the log level for the Completed log message.
@@ -85,18 +86,18 @@ module ParallelMinion
     #   :trace, :debug, :info, :warn, :error, :fatal
     def self.completed_log_level=(level)
       raise(ArgumentError, "Invalid log level: #{level}") unless SemanticLogger::LEVELS.include?(level)
+
       @completed_log_level = level
     end
 
-    def self.completed_log_level
-      @completed_log_level
+    class << self
+      attr_reader :completed_log_level
     end
 
     self.started_log_level   = :info
     self.completed_log_level = :info
     self.enabled             = true
     self.scoped_classes      = []
-    logger.name              = 'Minion'
 
     # Create a new Minion
     #
@@ -177,6 +178,10 @@ module ParallelMinion
     #        Any unhandled exception raised in the block will not be logged
     #      Default: :partial
     #
+    #   :on_exception_level [:trace | :debug | :info | :warn | :error | :fatal]
+    #     Override the log level only when an exception occurs.
+    #     Default: ParallelMinion::Minion.completed_log_level
+    #
     #   :enabled [Boolean]
     #     Override the global setting: `ParallelMinion::Minion.enabled?` for this minion instance.
     #
@@ -193,25 +198,54 @@ module ParallelMinion
     #     thread.pool.enabled=true
     #
     # Example:
-    #   ParallelMinion::Minion.new(10.days.ago, description: 'Doing something else in parallel', timeout: 1000) do |date|
+    #   ParallelMinion::Minion.new(
+    #     10.days.ago,
+    #     description: 'Doing something else in parallel',
+    #     timeout:     1000
+    #   ) do |date|
     #     MyTable.where('created_at <= ?', date).count
     #   end
-    def initialize(*arguments, description: 'Minion', metric: nil, log_exception: nil, enabled: self.class.enabled?, timeout: INFINITE, on_timeout: nil, wait_metric: nil, &block)
-      raise 'Missing mandatory block that Minion must perform' unless block
-      @start_time    = Time.now
-      @exception     = nil
-      @arguments     = arguments
-      @timeout       = timeout.to_f
-      @description   = description.to_s
-      @metric        = metric
-      @log_exception = log_exception
-      @enabled       = enabled
-      @on_timeout    = on_timeout
-
-      @wait_metric   = (wait_metric || "#{metric}/wait") if @metric
-
-      # When minion is disabled it is obvious in the logs since the name will now be 'Inline' instead of 'Minion'
-      self.logger    = SemanticLogger['Inline'] unless @enabled
+    #
+    # Example, when the result is being ignored, log full exception as an error:
+    #   ParallelMinion::Minion.new(
+    #     customer,
+    #     description:        "We don't care about the result",
+    #     log_exception:      :full,
+    #     on_exception_level: :error
+    #   ) do |customer|
+    #     customer.save!
+    #   end
+    def initialize(*arguments,
+                   description: "Minion",
+                   metric: nil,
+                   log_exception: nil,
+                   on_exception_level: self.class.completed_log_level,
+                   enabled: self.class.enabled?,
+                   timeout: INFINITE,
+                   on_timeout: nil,
+                   wait_metric: nil,
+                   &block)
+      raise "Missing mandatory block that Minion must perform" unless block
+
+      @start_time         = Time.now
+      @exception          = nil
+      @arguments          = arguments
+      @timeout            = timeout.to_f
+      @description        = description.to_s
+      @metric             = metric
+      @log_exception      = log_exception
+      @on_exception_level = on_exception_level
+      @enabled            = enabled
+      @on_timeout         = on_timeout
+
+      @wait_metric        = (wait_metric || "#{metric}/wait") if @metric
+
+      # When minion is disabled make it obvious in the logs by setting the name to 'Inline' instead of 'Minion'.
+      unless @enabled
+        l           = self.class.logger.dup
+        l.name      = "Inline"
+        self.logger = l
+      end
 
       @enabled ? run(&block) : run_inline(&block)
     end
@@ -225,7 +259,12 @@ module ParallelMinion
       # Return nil if Minion is still working and has time left to finish
       if working?
         ms = time_left
-        logger.measure(self.class.completed_log_level, "Waited for Minion to complete: #{description}", min_duration: 0.01, metric: wait_metric) do
+        logger.measure(
+          self.class.completed_log_level,
+          "Waited for Minion to complete: #{description}",
+          min_duration: 0.01,
+          metric:       wait_metric
+        ) do
           if @thread.join(ms.nil? ? nil : ms / 1000).nil?
             @thread.raise(@on_timeout.new("Minion: #{description} timed out")) if @on_timeout
             logger.warn("Timed out waiting for: #{description}")
@@ -257,8 +296,9 @@ module ParallelMinion
     # Returns 0 if no time is left
     # Returns nil if their is no time limit. I.e. :timeout was set to Minion::INFINITE (infinite time left)
     def time_left
-      return nil if (timeout == 0) || (timeout == -1)
-      duration = timeout - (Time.now - start_time) * 1000
+      return nil if timeout.zero? || (timeout == -1)
+
+      duration = timeout - ((Time.now - start_time) * 1000)
       duration <= 0 ? 0 : duration
     end
 
@@ -272,32 +312,40 @@ module ParallelMinion
     if defined?(ActiveRecord)
       if ActiveRecord::VERSION::MAJOR >= 4
         def self.current_scopes
-          scoped_classes.collect { |klass| klass.all }
+          scoped_classes.collect(&:all)
         end
       else
         def self.current_scopes
-          scoped_classes.collect { |klass| klass.scoped }
+          scoped_classes.collect(&:scoped)
         end
       end
     end
 
     private
 
+    # rubocop:disable Lint/RescueException
+
     # Run the supplied block of code in the current thread.
     # Useful for debugging, testing, and when running in batch environments.
     def run_inline(&block)
-      begin
-        logger.public_send(self.class.started_log_level, "Started #{@description}")
-        logger.measure(self.class.completed_log_level, "Completed #{@description}", log_exception: @log_exception, metric: metric) do
-          @result = instance_exec(*arguments, &block)
-        end
-      rescue Exception => exc
-        @exception = exc
-      ensure
-        @duration = Time.now - start_time
+      logger.public_send(self.class.started_log_level, "Started #{description}")
+      logger.measure(
+        self.class.completed_log_level,
+        "Completed #{description}",
+        log_exception:      log_exception,
+        on_exception_level: on_exception_level,
+        metric:             metric
+      ) do
+        @result = instance_exec(*arguments, &block)
       end
+    rescue Exception => e
+      @exception = e
+    ensure
+      @duration = Time.now - start_time
     end
 
+    # rubocop:enable Lint/RescueException
+
     def run(&block)
       # Capture tags from current thread
       tags = SemanticLogger.tags
@@ -316,17 +364,26 @@ module ParallelMinion
         SemanticLogger.tagged(*tags) do
           SemanticLogger.named_tagged(named_tags) do
             logger.public_send(self.class.started_log_level, "Started #{description}")
+            # rubocop:disable Lint/RescueException
             begin
-              proc = Proc.new { run_in_scope(scopes, &block) }
-              logger.measure(self.class.completed_log_level, "Completed #{description}", log_exception: log_exception, metric: metric, &proc)
-            rescue Exception => exc
-              @exception = exc
+              proc = proc { run_in_scope(scopes, &block) }
+              logger.measure(
+                self.class.completed_log_level,
+                "Completed #{description}",
+                log_exception:      log_exception,
+                on_exception_level: on_exception_level,
+                metric:             metric,
+                &proc
+              )
+            rescue Exception => e
+              @exception = e
               nil
             ensure
               @duration = Time.now - start_time
               # Return any database connections used by this thread back to the pool
-              ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
+              ActiveRecord::Base.connection_handler.clear_active_connections! if defined?(ActiveRecord::Base)
             end
+            # rubocop:enable Lint/RescueException
           end
         end
       end
@@ -338,12 +395,11 @@ module ParallelMinion
       else
         # Use the captured scope when running the block.
         # Each Class to scope requires passing a block to .scoping.
-        proc  = Proc.new { instance_exec(*@arguments, &block) }
+        proc  = proc { instance_exec(*@arguments, &block) }
         first = scopes.shift
-        scopes.each { |scope| proc = Proc.new { scope.scoping(&proc) } }
+        scopes.each { |scope| proc = proc { scope.scoping(&proc) } }
         @result = first.scoping(&proc)
       end
     end
-
   end
 end

data/lib/parallel_minion/railtie.rb

@@ -1,5 +1,5 @@
-module ParallelMinion #:nodoc:
-  class Railtie < Rails::Railtie #:nodoc:
+module ParallelMinion # :nodoc:
+  class Railtie < Rails::Railtie # :nodoc:
     #
     # Make the ParallelMinion config available in the Rails application config
     #
@@ -26,6 +26,5 @@ module ParallelMinion #:nodoc:
     #     end
     #   end
     config.parallel_minion = ::ParallelMinion::Minion
-
   end
 end

data/lib/parallel_minion/version.rb

@@ -1,3 +1,3 @@
-module ParallelMinion #:nodoc
-  VERSION = '1.2.1'
+module ParallelMinion
+  VERSION = "1.4.0".freeze
 end

data/lib/parallel_minion.rb

@@ -1,8 +1,7 @@
-require 'thread'
-require 'semantic_logger'
+require "semantic_logger"
 
 module ParallelMinion
-  autoload :Minion, 'parallel_minion/minion'
+  autoload :Minion, "parallel_minion/minion"
 end
 
-require 'parallel_minion/railtie' if defined?(Rails)
+require "parallel_minion/railtie" if defined?(Rails)

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: parallel_minion
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Reid Morrison
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-10 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: semantic_logger
@@ -24,10 +23,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
-description: Parallel Minion allows you to take existing blocks of code and wrap them
-  in a minion so that they can run asynchronously in a separate thread
-email:
-- reidmo@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -39,16 +34,11 @@ files:
 - lib/parallel_minion/minion.rb
 - lib/parallel_minion/railtie.rb
 - lib/parallel_minion/version.rb
-- test/config/database.yml
-- test/minion_scope_test.rb
-- test/minion_test.rb
-- test/test_db.sqlite3
-- test/test_helper.rb
 homepage: https://github.com/reidmorrison/parallel_minion
 licenses:
 - Apache License V2.0
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -56,21 +46,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.1'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
-summary: Pragmatic approach to parallel and asynchronous processing in Ruby
-test_files:
-- test/config/database.yml
-- test/minion_scope_test.rb
-- test/minion_test.rb
-- test/test_db.sqlite3
-- test/test_helper.rb
+summary: Wrap Ruby code with a minion so that it is run on a parallel thread
+test_files: []

data/test/config/database.yml

@@ -1,5 +0,0 @@
-test:
-  adapter:  sqlite3
-  database: test/test_db.sqlite3
-  pool:     5
-  timeout:  5000

data/test/minion_scope_test.rb

@@ -1,59 +0,0 @@
-require_relative 'test_helper'
-require 'erb'
-require 'active_record'
-
-ActiveRecord::Base.logger         = SemanticLogger[ActiveRecord]
-ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read('test/config/database.yml')).result)
-ActiveRecord::Base.establish_connection(:test)
-
-ActiveRecord::Schema.define :version => 0 do
-  create_table :people, :force => true do |t|
-    t.string :name
-    t.string :state
-    t.string :zip_code
-  end
-end
-
-class Person < ActiveRecord::Base
-end
-
-class MinionScopeTest < Minitest::Test
-  describe ParallelMinion::Minion do
-    [false, true].each do |enabled|
-      describe ".new with enabled: #{enabled.inspect}" do
-        before do
-          Person.create(name: 'Jack', state: 'FL', zip_code: 38729)
-          Person.create(name: 'John', state: 'FL', zip_code: 35363)
-          Person.create(name: 'Jill', state: 'FL', zip_code: 73534)
-          Person.create(name: 'Joe', state: 'NY', zip_code: 45325)
-          Person.create(name: 'Jane', state: 'NY', zip_code: 45325)
-          Person.create(name: 'James', state: 'CA', zip_code: 123123)
-          # Instruct Minions to adhere to any dynamic scopes for Person model
-          ParallelMinion::Minion.scoped_classes << Person
-          ParallelMinion::Minion.enabled = enabled
-        end
-
-        after do
-          Person.destroy_all
-          ParallelMinion::Minion.scoped_classes.clear
-          SemanticLogger.flush
-        end
-
-        it 'copy across model scope' do
-          assert_equal 6, Person.count
-
-          Person.unscoped.where(state: 'FL').scoping { Person.count }
-
-          Person.unscoped.where(state: 'FL').scoping do
-            assert_equal 3, Person.count
-            minion = ParallelMinion::Minion.new(description: 'Scope Test', log_exception: :full) do
-              Person.count
-            end
-            assert_equal 3, minion.result
-          end
-        end
-
-      end
-    end
-  end
-end

data/test/minion_test.rb

@@ -1,207 +0,0 @@
-require_relative './test_helper'
-
-# Test ParallelMinion standalone without Rails
-# Run this test standalone to verify it has no Rails dependencies
-class MinionTest < Minitest::Test
-  include SemanticLogger::Loggable
-
-  describe ParallelMinion::Minion do
-
-    [false, true].each do |enabled|
-      describe enabled ? 'enabled' : 'disabled' do
-        before do
-          ParallelMinion::Minion.enabled = enabled
-          $log_structs.clear
-        end
-
-        it 'without parameters' do
-          minion = ParallelMinion::Minion.new { 196 }
-          assert_equal 196, minion.result
-        end
-
-        it 'with a description' do
-          minion = ParallelMinion::Minion.new(description: 'Test') { 197 }
-          assert_equal 197, minion.result
-        end
-
-        it 'with an argument' do
-          p1     = {name: 198}
-          minion = ParallelMinion::Minion.new(p1, description: 'Test') do |v|
-            v[:name]
-          end
-          assert_equal 198, minion.result
-        end
-
-        it 'raise exception' do
-          minion = ParallelMinion::Minion.new(description: 'Test') { raise "An exception" }
-          assert_raises RuntimeError do
-            minion.result
-          end
-        end
-
-        it 'has correct logger name' do
-          minion = ParallelMinion::Minion.new { 196 }
-          name   = enabled ? 'Minion' : 'Inline'
-          assert_equal name, minion.logger.name
-        end
-
-        # TODO Blocks still have access to their original scope if variables cannot be
-        #      resolved first by the parameters, then by the values in Minion itself
-        #        it 'not have access to local variables' do
-        #          name = 'Jack'
-        #          minion = ParallelMinion::Minion.new(description: 'Test') { puts name }
-        #          assert_raises NameError do
-        #            minion.result
-        #          end
-        #        end
-
-        it 'run minion' do
-          hash   = {value: 23}
-          value  = 47
-          minion = ParallelMinion::Minion.new(hash, description: 'Test') do |h|
-            value     = 321
-            h[:value] = 123
-            456
-          end
-          assert_equal 456, minion.result
-          assert_equal 123, hash[:value]
-          assert_equal 321, value
-        end
-
-        it 'copy across logging tags' do
-          minion = nil
-          SemanticLogger.tagged('TAG') do
-            assert_equal 'TAG', SemanticLogger.tags.last
-            minion = ParallelMinion::Minion.new(description: 'Tag Test') do
-              logger.info "Tag Test"
-              logger.tags.last
-            end
-          end
-          assert_equal 'TAG', minion.result
-        end
-
-        it 'copy across named tags' do
-          minion = nil
-          SemanticLogger.named_tagged(tag: 'TAG') do
-            assert_equal({tag: 'TAG'}, SemanticLogger.named_tags)
-            minion = ParallelMinion::Minion.new(description: 'Named Tags Test') do
-              logger.info "Named Tags Test"
-              SemanticLogger.named_tags
-            end
-          end
-          assert_equal({tag: 'TAG'}, minion.result)
-        end
-
-        it 'copy across tags and named tags' do
-          minion = nil
-          SemanticLogger.tagged('TAG') do
-            SemanticLogger.named_tagged(tag: 'TAG') do
-              assert_equal({tag: 'TAG'}, SemanticLogger.named_tags)
-              assert_equal 'TAG', SemanticLogger.tags.last
-              minion = ParallelMinion::Minion.new(description: 'Tags Test') do
-                logger.info "Tags Test"
-                [SemanticLogger.named_tags, SemanticLogger.tags.last]
-              end
-
-              assert_equal({tag: 'TAG'}, minion.result.first)
-              assert_equal 'TAG', minion.result.last
-            end
-          end
-
-        end
-
-        it 'include metric' do
-          metric_name = 'model/method'
-          hash        = {value: 23}
-          value       = 47
-          minion      = ParallelMinion::Minion.new(hash, description: 'Test', metric: metric_name) do |h|
-            value     = 321
-            h[:value] = 123
-            sleep 1
-            456
-          end
-          assert_equal 456, minion.result
-          assert_equal 123, hash[:value]
-          assert_equal 321, value
-          SemanticLogger.flush
-          assert log = $log_structs.first, -> { $log_structs.ai }
-          if enabled
-            # Completed log message
-            assert_equal metric_name, log.metric, -> { $log_structs.ai }
-            # Wait log message
-            assert log = $log_structs.last, -> { $log_structs.ai }
-            assert_equal "#{metric_name}/wait", log.metric, -> { $log_structs.ai }
-          else
-            # Timeout and wait has no effect when run inline
-            assert_equal metric_name, log.metric, -> { $log_structs.ai }
-          end
-        end
-
-        it 'handle multiple minions concurrently' do
-          # Start 10 minions
-          minions = 10.times.collect do |i|
-            # Each Minion returns its index in the collection
-            ParallelMinion::Minion.new(i, description: "Minion:#{i}") { |counter| counter }
-          end
-          assert_equal 10, minions.count
-          # Fetch the result from each Minion
-          minions.each_with_index do |minion, index|
-            assert_equal index, minion.result
-          end
-        end
-
-        it 'timeout' do
-          if enabled
-            minion = ParallelMinion::Minion.new(description: 'Test', timeout: 100) { sleep 1 }
-            assert_nil minion.result
-          end
-        end
-
-        it 'timeout and terminate thread with Exception' do
-          if enabled
-            minion = ParallelMinion::Minion.new(description: 'Test', timeout: 100, on_timeout: Timeout::Error) { sleep 1 }
-            assert_nil minion.result
-            # Give time for thread to terminate
-            sleep 0.1
-            assert_equal Timeout::Error, minion.exception.class
-            assert_equal false, minion.working?
-            assert_equal true, minion.completed?
-            assert_equal true, minion.failed?
-            assert_equal 0, minion.time_left
-          end
-        end
-
-        it 'make description instance variable available' do
-          minion = ParallelMinion::Minion.new(description: 'Test') do
-            description
-          end
-          assert_equal 'Test', minion.result
-        end
-
-        it 'make timeout instance variable available' do
-          minion = ParallelMinion::Minion.new(description: 'Test', timeout: 1000) do
-            timeout
-          end
-          assert_equal 1000, minion.result
-        end
-
-        it 'make enabled? method available' do
-          minion = ParallelMinion::Minion.new(description: 'Test') do
-            enabled?
-          end
-          assert_equal enabled, minion.result
-        end
-
-        it 'keep the original arguments' do
-          minion = ParallelMinion::Minion.new(1, 'data', 14.1, description: 'Test') do |num, str, float|
-            num + float
-          end
-          assert_equal 15.1, minion.result
-          assert_equal [1, 'data', 14.1], minion.arguments
-        end
-      end
-
-    end
-
-  end
-end

data/test/test_helper.rb

@@ -1,14 +0,0 @@
-#$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-
-require 'minitest/autorun'
-require 'parallel_minion'
-require 'semantic_logger'
-
-SemanticLogger.default_level = :trace
-SemanticLogger.add_appender(file_name: 'test.log', formatter: :color)
-
-# Setup global callback for metric so that it can be tested below
-$log_structs = []
-SemanticLogger.on_metric do |log_struct|
-  $log_structs << log_struct.dup
-end