disc 0.0.27 → 0.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 176f77e62f7e6d5d3fb12160f104e6f9920829f4
-  data.tar.gz: 3f081fa1f1835c21d92c6b52d20650d09b697e5a
+  metadata.gz: 5afabb650aa27d3b020674c300b2c2f198da7562
+  data.tar.gz: 309002ddceb18dbbae790371d6761330044591ef
 SHA512:
-  metadata.gz: 285379b94730d7a5e1eec6a5d551dfd42403452f91289a1fbce88c49d7f26457b59d9e32be25eb16c8a137888756f6ed851666ff64fc07532e0494e8deee8ef2
-  data.tar.gz: ad8a5da1ea7ce655c093796186abd7eb292fd22b2f68e0e7f13c9473643e93c28345893283966196578058fa121bbce70a8971df7f57d2e20b0cb298eeff41f8
+  metadata.gz: 73c4688d1d3363c68f4927bfc9096efc1ac353371d1a4f0a67bcf22c48e5bd1f7e9d57f2771d2dbb831340f939531757d160797d0915753a41ef1e11ed9ab2cb
+  data.tar.gz: c4fa2f21bb5d56b00c658aa72c3e66f307b5c86a77af9f9e9ef917794fd63faa14a2edb16d60a7bd792a78ecdc8cfc29d450a58dea8040ac9c5debd1aade71be

data/README.md

@@ -23,7 +23,7 @@ Disc fills the gap between your Ruby service objects and [antirez](http://antire
     include Disc::Job
     disc queue: 'urgent'
 
-    def perform(type)
+    def self.perform(type)
       # perform rather lengthy operations here.
     end
   end
@@ -40,7 +40,8 @@ Disc fills the gap between your Ruby service objects and [antirez](http://antire
 
   ```ruby
 # disc_init.rb
-  require 'disc/worker'
+  # Require here anything that your application needs to run,
+  # like ORMs and your models, database configuration, etc.
   Dir['./jobs/**/*.rb'].each { |job| require job }
   ```
 
@@ -79,7 +80,7 @@ Signature documentation follows:
 ## Parameters:
 #
 ## `arguments`  - an optional array of arguments with which to execute
-#                 the job's #perform method.
+#                 the job's `self.perform` method.
 #
 # `at`          - an optional named parameter specifying a moment in the
 #                 future in which to run the job, must respond to
@@ -117,7 +118,7 @@ Signature documentation follows:
 ### CAVEATS
 #
 ## For convenience, any object can be passed as the `arguments` parameter,
-#  `Array.wrap` will be used internally to preserve the array structure.
+#  `Array()` will be used internally to preserve the array structure.
 #
 ## The `arguments` parameter is serialized for storage using `Disc.serialize`
 #  and Disc workers picking it up use `Disc.deserialize` on it, both methods
@@ -127,7 +128,7 @@ Signature documentation follows:
 
 You can see [Disque's ADDJOB documentation](https://github.com/antirez/disque#addjob-queue_name-job-ms-timeout-replicate-count-delay-sec-retry-sec-ttl-sec-maxlen-count-async) for more details
 
-When a Disc worker process is assigned a job, it will create a new intance of the job's class and execute the `#perform` method with whatever arguments were previously passed to `#enqueue`.
+When a Disc worker process is assigned a job, it will create a new intance of the job's class and execute the `self.perform` method with whatever arguments were previously passed to `#enqueue`.
 
 Example:
 
@@ -136,7 +137,7 @@ class ComplexJob
   include Disc::Job
   disc queue: 'urgent'
 
-  def perform(first_parameter, second_parameter)
+  def self.perform(first_parameter, second_parameter)
     # do things...
   end
 end
@@ -145,6 +146,18 @@ end
 ComplexJob.enqueue(['first argument', { second: 'argument' }])
 ```
 
+### Job Serialization
+
+Job information (their arguments, and class) need to be serialized in order to be stored
+in Disque, to this end Disc uses the `Disc.serialize` and `Disc.deserialize` methods.
+
+By default, these methods use by default the Ruby standard library json implementation in order to serialize and deserialize job data, this has a few implications:
+
+1. Arguments passed to a job's `#enqueue` method need to be serializable by `Disc.serialize` and parsed back by `Disc.deserialize`, so by default you can't pass complex Ruby objects like a `user` model, instead, pass `user.id`, and use that from your job code.
+
+2. You can override `Disc.serialize` and `Disc.deserialize` to use a different JSON implementation, or MessagePack, or whatever else you wish.
+
+
 ## Settings
 
 Disc takes its configuration from environment variables.
@@ -173,7 +186,7 @@ end
 Dir["./jobs/**/*.rb"].each { |job| require job }
 ```
 
-## Job Definition
+### Job Definition
 
 The error handler function gets the data of the current job as a Hash, that has the following schema.
 
@@ -182,7 +195,60 @@ The error handler function gets the data of the current job as a Hash, that has
 | `'class'`     | (String) The Job class.                               |
 | `'arguments'` | (Array) The arguments passed to perform.              |
 | `'queue'`     | (String) The queue from which this job was picked up. |
-| `'id'`        | (String) Disque's job ID.                             |
+| `'disque_id'` | (String) Disque's job ID.                             |
+
+
+## Testing modes
+
+Disc includes a testing mode, so you can run your test suite without a need to run a Disque server.
+
+### Enqueue mode
+
+By default, Disc places your jobs in an in-memory hash, with each queue being a key in the hash and values being an array.
+
+```ruby
+require 'disc'
+require 'disc/testing'
+
+require_relative 'examples/returner'
+Disc.enqueue! #=> This is the default mode for disc/testing so you don't need to specify it,
+              #   you can use this method to go back to the enqueue mode if you switch it.
+
+
+Returner.enqueue('test argument')
+
+Disc.queues
+#=> {"default"=>[{:arguments=>["test argument"], :class=>"Returner", :options=>{}}]}
+
+Returner.enqueue('another test')
+#=> => {"default"=>[{:arguments=>["test argument"], :class=>"Returner", :options=>{}}, {:arguments=>["another test"], :class=>"Returner", :options=>{}}]}
+
+
+```
+
+You can still flush the queues just as you would running on regular mode.
+
+```ruby
+Disc.flush
+
+Disc.queues
+#=> {}
+```
+
+### Inline mode
+
+You also have the option for Disc to execute jobs immediately when `#enqueue` is called.
+
+```ruby
+require 'disc'
+require 'disc/testing'
+
+require_relative 'examples/returner'
+Disc.inline!
+
+Returner.enqueue('test argument')
+#=> 'test argument'
+```
 
 ## [Optional] Celluloid integration
 
@@ -220,7 +286,7 @@ end
 class CluJob < ActiveJob::Base
   queue_as :urgent
 
-  def perform(*args)
+  def self.perform(*args)
     # Try to take over The Grid here...
   end
 end
@@ -238,10 +304,6 @@ Disc is run in the exact same way, for this example it'd be:
 $ QUEUES=urgent disc -r ./disc_init.rb
 ```
 
-## A note on stability
-
-The version of Disque at the time of this writing is `0.0.1`. It is a wonderful project, I know of people running it in production and I expect it will only get better and better with time, but please do not expect Disc to be more production ready than Disque is.
-
 ## Similar Projects
 
 If you want to use Disque but Disc isn't cutting it for you then you should take a look at [Havanna](https://github.com/djanowski/havanna), a project by my friend [@djanowski](https://twitter.com/djanowski).

data/bin/disc

@@ -19,6 +19,7 @@ trap(:TERM, &stop)
 
 require 'clap'
 require_relative '../lib/disc'
+require_relative '../lib/disc/worker'
 
 Clap.run ARGV,
   "-r" => lambda { |file| require file }

data/examples/echoer.rb

@@ -4,7 +4,7 @@ class Echoer
   include Disc::Job
   disc queue: 'test'
 
-  def perform(first, second, third)
+  def self.perform(first, second, third)
     puts "First: #{ first }, Second: #{ second }, Third: #{ third }"
   end
 end

data/examples/failer.rb

@@ -10,7 +10,7 @@ class Failer
   include Disc::Job
   disc queue: 'test'
 
-  def perform(string)
+  def self.perform(string)
     raise string
   end
 end

data/examples/greeter.rb

@@ -4,7 +4,7 @@ class Greeter
   include Disc::Job
   disc queue: 'test_medium'
 
-  def perform(string)
+  def self.perform(string)
     $stdout.puts(string)
   end
 end

data/examples/returner.rb

@@ -0,0 +1,7 @@
+class Returner
+  include Disc::Job
+
+  def self.perform(argument)
+    return argument
+  end
+end

data/lib/disc/errors.rb

@@ -0,0 +1,6 @@
+class Disc
+  class Error < StandardError; end
+
+  class UnknownJobClassError < Error; end
+  class NonParsableJobError  < Error; end
+end

data/lib/disc/job.rb

@@ -1,35 +1,10 @@
 module Disc::Job
-  attr_accessor :disque_id,
-                :arguments
 
   def self.included(base)
     base.extend(ClassMethods)
   end
 
-  def info
-    return nil if disque_id.nil?
-
-    Hash[*self.class.disque.call("SHOW", disque_id)]
-  end
-
-  def state
-    info.fetch('state')
-  end
-
   module ClassMethods
-    def [](disque_id)
-      job_data = disque.call("SHOW", disque_id)
-      return nil if job_data.nil?
-
-      job = self.new
-      job_data = Hash[*job_data]
-
-      job.disque_id = disque_id
-      job.arguments = Disc.deserialize(job_data.fetch('body')).fetch('arguments')
-
-      return job
-    end
-
     def disque
       defined?(@disque) ? @disque : Disc.disque
     end
@@ -51,10 +26,6 @@ module Disc::Job
       @queue || Disc.default_queue
     end
 
-    def perform(arguments)
-      self.new.perform(*arguments)
-    end
-
     ## Disc's `#enqueue` is the main user-facing method of a Disc job, it
     #  enqueues a job with a given set of arguments in Disque, so it can be
     #  picked up by a Disc worker process.
@@ -100,7 +71,7 @@ module Disc::Job
     ### CAVEATS
     #
     ## For convenience, any object can be passed as the `arguments` parameter,
-    #  `Array.wrap` will be used internally to preserve the array structure.
+    #  `Array()` will be used internally to preserve the array structure.
     #
     ## The `arguments` parameter is serialized for storage using `Disc.serialize`
     #  and Disc workers picking it up use `Disc.deserialize` on it, both methods
@@ -111,7 +82,7 @@ module Disc::Job
         opt[:delay] = at.to_time.to_i - DateTime.now.to_time.to_i unless at.nil?
       end
 
-      disque_id = disque.push(
+      disque.push(
         queue || self.queue,
         Disc.serialize({
           class: self.name,
@@ -120,8 +91,6 @@ module Disc::Job
         Disc.disque_timeout,
         options
       )
-
-      return self[disque_id]
     end
   end
 end

data/lib/disc/testing.rb

@@ -1,9 +1,56 @@
-module Disc::Job::ClassMethods
-  def mocked_queue
-    @_mocked_queue ||= []
+class Disc
+  def self.queues
+    @queues ||= {}
+  end
+
+  def self.testing_mode
+    @testing_mode ||= 'enqueue'
+  end
+
+  def self.enqueue!
+    @testing_mode = 'enqueue'
+  end
+
+  def self.inline!
+    @testing_mode = 'inline'
+  end
+
+  def self.flush
+    @queues = {}
   end
 
+  def self.qlen(queue)
+    return 0 if Disc.queues[queue].nil?
+
+    Disc.queues[queue].length
+  end
+
+  def self.enqueue(klass,  arguments, at: nil, queue: nil, **options)
+    job_attrs = { arguments: arguments, class: klass, options: options }
+    if queues[queue].nil?
+      queues[queue] = [job_attrs]
+    else
+      queues[queue] << job_attrs
+    end
+
+    job_attrs
+  end
+end
+
+module Disc::Job::ClassMethods
   def enqueue(args = [], at: nil, queue: nil, **options)
-    mocked_queue << { args: args, at: at, options: options }
+    case Disc.testing_mode
+    when 'enqueue'
+      Disc.enqueue(
+        self.name,
+        Array(args),
+        queue: queue || self.queue,
+        at: at,
+        **options)
+    when 'inline'
+      self.perform(*args)
+    else
+      raise "Unknown Disc testing mode, this shouldn't happen"
+    end
   end
 end

data/lib/disc/version.rb

@@ -1,3 +1,3 @@
 class Disc
-  VERSION = "0.0.27"
+  VERSION = "0.0.28"
 end

data/lib/disc/worker.rb

@@ -52,13 +52,17 @@ class Disc::Worker
       jobs = disque.fetch(from: queues, timeout: timeout, count: count)
       Array(jobs).each do |queue, msgid, serialized_job|
         begin
-          job = Disc.deserialize(serialized_job)
-          instance = Object.const_get(job['class']).new
-          instance.perform(*job['arguments'])
+          job_class, arguments = Disc.load_job(serialized_job)
+          job_class.perform(*arguments)
           disque.call('ACKJOB', msgid)
-          $stdout.puts("Completed #{job['class']} id #{msgid}")
+          $stdout.puts("Completed #{ job_class.name } id #{ msgid }")
         rescue => err
-          Disc.on_error(err, job.update('id' => msgid, 'queue' => queue))
+          Disc.on_error(err, {
+            disque_id: msgid,
+            queue: queue,
+            class: defined?(job_class) ? job_class.name : '',
+            arguments: defined?(arguments) ? arguments : []
+          })
         end
       end
 

data/lib/disc.rb

@@ -16,7 +16,7 @@ class Disc
   end
 
   def self.disque_timeout
-    @disque_timeout ||= ENV.fetch('DISQUE_TIMEOUT', 100)
+    @disque_timeout ||= 100
   end
 
   def self.disque_timeout=(timeout)
@@ -50,8 +50,46 @@ class Disc
   def self.deserialize(data)
     JSON.parse(data)
   end
+
+  def self.[](disque_id)
+    job_data = disque.call("SHOW", disque_id)
+    return nil if job_data.nil?
+
+    job_data = Hash[*job_data]
+    job_data['arguments'] = Disc.deserialize(job_data['body'])['arguments']
+    job_data['class'] = Disc.deserialize(job_data['body'])['class']
+
+    job_data
+  end
+
+  ## Receives:
+  #
+  #   A string containing data serialized by `Disc.serialize`
+  #
+  ## Returns:
+  #
+  #   An array containing:
+  #
+  #     * An instance of the given job class
+  #     * An array of arguments to pass to the job's `#perorm` class.
+  #
+  def self.load_job(serialized_job)
+    begin
+      job_data = Disc.deserialize(serialized_job)
+    rescue => err
+      raise Disc::NonParsableJobError.new(err)
+    end
+
+    begin
+      job_class = Object.const_get(job_data['class'])
+    rescue => err
+      raise Disc::UnknownJobClassError.new(err)
+    end
+
+    return [job_class, job_data['arguments']]
+  end
 end
 
+require_relative 'disc/errors'
 require_relative 'disc/job'
 require_relative 'disc/version'
-

data/test/disc_test.rb

@@ -1,33 +1,7 @@
 require 'cutest'
 require 'disc'
-require 'pty'
-require 'timeout'
 
 require_relative '../examples/echoer'
-# class Echoer
-#   include Disc::Job
-#   disc queue: 'test'
-#
-#   def perform(first, second, third)
-#     puts "First: #{ first }, Second: #{ second }, Third: #{ third }"
-#   end
-# end
-
-require_relative '../examples/failer'
-# def Disc.on_error(exception, job)
-#   $stdout.puts('<insert error reporting here>')
-#   $stdout.puts(exception.message)
-#   $stdout.puts(job)
-# end
-#
-# class Failer
-#   include Disc::Job
-#   disc queue: 'test'
-# 
-#   def perform(string)
-#     raise string
-#   end
-# end
 
 prepare do
   Disc.disque_timeout = 1 # 1ms so we don't wait at all.
@@ -35,180 +9,67 @@ prepare do
 end
 
 scope do
-  # Runs a given command, yielding the stdout (as an IO) and the PID (a String).
-  # Makes sure the process finishes after the block runs.
-  def run(command)
-    out, _, pid = PTY.spawn(command)
-    yield out, pid
-  ensure
-    Process.kill("KILL", pid)
-    sleep 0.1 # Make sure we give it time to finish.
-  end
-
-  # Checks whether a process is running.
-  def is_running?(pid)
-    Process.getpgid(pid)
-    true
-  rescue Errno::ESRCH
-    false
-  end
-
-  test 'jobs are enqueued to the correct Disque queue with appropriate parameters and class' do
-    job_instance = Echoer.enqueue(['one argument', { random: 'data' }, 3])
-
-    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
-    assert jobs.any?
-    assert_equal 1, jobs.count
+  test 'Disc should be able to communicate with Disque' do
+    assert !Disc.disque.nil?
 
-    jobs.first.tap do |queue, id, serialized_job|
-      job = Disc.deserialize(serialized_job)
-
-      assert job.has_key?('class')
-      assert job.has_key?('arguments')
-
-      assert_equal 'Echoer', job['class']
-      assert_equal job_instance.disque_id, id
-
-      args = job['arguments']
-      assert_equal 3, args.size
-      assert_equal 'one argument', args[0]
-      assert_equal({ 'random' => 'data' }, args[1])
-      assert_equal(3, args[2])
-    end
+    assert_equal 'PONG', Disc.disque.call('PING')
   end
 
-  test 'we get easy access to the job via the job id' do
-    job_instance = Echoer.enqueue(['one argument', { random: 'data' }, 3])
-
-    assert job_instance.is_a?(Echoer)
-    assert !job_instance.disque_id.nil?
-    assert !job_instance.info.nil?
+  test 'we get easy access to the job via the job id with Disc[job_id]' do
+    job_id = Echoer.enqueue(['one argument', { random: 'data' }, 3])
 
-    job = Echoer[job_instance.disque_id]
+    job_data = Disc[job_id]
 
-    assert job.is_a?(Echoer)
-    assert_equal 'queued', job.state
-    assert_equal 3, job.arguments.count
-    assert_equal 'one argument', job.arguments.first
+    assert_equal 'Echoer', job_data['class']
+    assert_equal 'queued', job_data['state']
+    assert_equal 3, job_data['arguments'].count
+    assert_equal 'one argument', job_data['arguments'].first
   end
 
-  test 'we can query the lenght of a given queue' do
-    job_instance = Echoer.enqueue(['one argument', { random: 'data' }, 3])
+  test 'we can query the length of a given queue with Disc.qlen' do
+    Echoer.enqueue(['one argument', { random: 'data' }, 3])
 
     assert_equal 1, Disc.qlen(Echoer.queue)
   end
 
-  test 'enqueue at timestamp behaves properly' do
-    job_instance = Echoer.enqueue(['one argument', { random: 'data' }, 3], at: Time.now + 1)
-
-    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
-    assert jobs.empty?
-
-    sleep 0.5
-    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
-    assert jobs.empty?
-
-    sleep 0.5
-    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
-    assert jobs.any?
-    assert_equal 1, jobs.size
-
-    jobs.first.tap do |queue, id, serialized_job|
-      assert_equal 'test', queue
-      assert_equal job_instance.disque_id, id
-      job = Disc.deserialize(serialized_job)
-      assert job.has_key?('class')
-      assert job.has_key?('arguments')
-      assert_equal 'Echoer', job['class']
-      assert_equal 3, job['arguments'].size
-    end
-  end
-
-  test 'jobs are executed' do
+  test 'Disc.flush deletes everything in the queue' do
     Echoer.enqueue(['one argument', { random: 'data' }, 3])
+    Disc.flush
 
-    run('QUEUES=test ruby -Ilib bin/disc -r disc/worker -r ./examples/echoer') do |cout, pid|
-      output = Timeout.timeout(1) { cout.take(3) }
-      jobs = Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1)
-      assert jobs.nil?
-      assert output.grep(/First: one argument, Second: {"random"=>"data"}, Third: 3/).any?
-    end
+    assert_equal 0, Disc.qlen(Echoer.queue)
   end
 
-  test 'Disc.on_error will catch unhandled exceptions and keep disc alive' do
-    failer = Failer.enqueue('this can only end positively')
+  test 'Disc.load_job returns a job instance and arguments' do
+    serialized_job = Disc.serialize(
+      { class: 'Echoer', arguments: ['one argument', { random: 'data' }, 3] }
+    )
 
-    run('QUEUES=test ruby -Ilib bin/disc -r disc/worker -r ./examples/failer') do |cout, pid|
-      output = Timeout.timeout(1) { cout.take(5) }
-      jobs = Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1)
-      assert jobs.nil?
+    job_class, arguments = Disc.load_job(serialized_job)
 
-      assert output.grep(/<insert error reporting here>/).any?
-      assert output.grep(/this can only end positively/).any?
-      assert output.grep(/Failer/).any?
-
-      assert is_running?(pid)
-    end
+    assert_equal Echoer, job_class
+    assert arguments.is_a?(Array)
+    assert_equal 3, arguments.count
+    assert_equal 'one argument', arguments.first
   end
 
-  test 'enqueue supports replicate' do
-    error = Echoer.enqueue(['one argument', { random: 'data' }, 3], replicate: 100) rescue $!
-
-    assert_equal RuntimeError, error.class
-    assert_equal "NOREPL Not enough reachable nodes for the requested replication level", error.message
-  end
-
-  test 'enqueue supports delay' do
-    job_instance = Echoer.enqueue(['one argument', { random: 'data' }, 3], delay: 2)
-
-    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
-    assert jobs.empty?
-
-    sleep 1
-    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
-    assert jobs.empty?
-
-    sleep 2
-    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
-    assert jobs.any?
-    assert_equal 1, jobs.size
-  end
-
-  test 'enqueue supports retry' do
-    job_instance = Echoer.enqueue(['one argument', { random: 'data' }, 3], retry: 1)
-
-    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
-    assert jobs.any?
-    assert_equal 1, jobs.size
-
-    sleep 1.5
-    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
-    assert jobs.any?
-    assert_equal 1, jobs.size
-  end
-
-  test 'enqueue supports ttl' do
-    job_instance = Echoer.enqueue(['one argument', { random: 'data' }, 3], ttl: 1)
-
-    sleep 1.5
-    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
-    assert jobs.empty?
-  end
-
-  test 'enqueue supports maxlen' do
-    Echoer.enqueue(['one argument', { random: 'data' }, 3], maxlen: 1)
-    error = Echoer.enqueue(['one argument', { random: 'data' }, 3], maxlen: 1) rescue $!
-
-    assert_equal RuntimeError, error.class
-    assert_equal "MAXLEN Queue is already longer than the specified MAXLEN count", error.message
-  end
-
-  test 'enqueue supports async' do
-    job_instance = Echoer.enqueue(['one argument', { random: 'data' }, 3], async: true)
+  test 'Disc.load_job raises appropriate errors ' do
+    begin
+      job_instance, arguments = Disc.load_job('gibberish')
+      assert_equal 'Should not reach this point', false
+    rescue => err
+      assert err.is_a?(Disc::Error)
+      assert err.is_a?(Disc::NonParsableJobError)
+    end
 
-    sleep 1 # async is too fast to reliably assert an empty queue, let's wait instead
-    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
-    assert jobs.any?
-    assert_equal 1, jobs.size
+    serialized_job = Disc.serialize(
+      { class: 'NonExistantDiscJobClass', arguments: [] }
+    )
+    begin
+      job_instance, arguments = Disc.load_job(serialized_job)
+      assert_equal 'Should not reach this point', false
+    rescue => err
+      assert err.is_a?(Disc::Error)
+      assert err.is_a?(Disc::UnknownJobClassError)
+    end
   end
 end

data/test/job_test.rb

@@ -0,0 +1,122 @@
+require 'cutest'
+require 'disc'
+
+require_relative '../examples/echoer'
+
+prepare do
+  Disc.disque_timeout = 1 # 1ms so we don't wait at all.
+  Disc.flush
+end
+
+scope do
+  test 'jobs are enqueued to the correct Disque queue with appropriate parameters and class' do
+    job_id = Echoer.enqueue(['one argument', { random: 'data' }, 3])
+
+    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
+    assert jobs.any?
+    assert_equal 1, jobs.count
+
+    jobs.first.tap do |queue, id, serialized_job|
+      job = Disc.deserialize(serialized_job)
+
+      assert job.has_key?('class')
+      assert job.has_key?('arguments')
+
+      assert_equal 'Echoer', job['class']
+      assert_equal job_id, id
+
+      args = job['arguments']
+      assert_equal 3, args.size
+      assert_equal 'one argument', args[0]
+      assert_equal({ 'random' => 'data' }, args[1])
+      assert_equal(3, args[2])
+    end
+  end
+
+  test 'enqueue at timestamp behaves properly' do
+    job_id = Echoer.enqueue(['one argument', { random: 'data' }, 3], at: Time.now + 1)
+
+    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
+    assert jobs.empty?
+
+    sleep 0.5
+    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
+    assert jobs.empty?
+
+    sleep 0.5
+    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
+    assert jobs.any?
+    assert_equal 1, jobs.size
+
+    jobs.first.tap do |queue, id, serialized_job|
+      assert_equal 'test', queue
+      assert_equal job_id, id
+      job = Disc.deserialize(serialized_job)
+      assert job.has_key?('class')
+      assert job.has_key?('arguments')
+      assert_equal 'Echoer', job['class']
+      assert_equal 3, job['arguments'].size
+    end
+  end
+
+  test 'enqueue supports replicate' do
+    error = Echoer.enqueue(['one argument', { random: 'data' }, 3], replicate: 100) rescue $!
+
+    assert_equal RuntimeError, error.class
+    assert_equal "NOREPL Not enough reachable nodes for the requested replication level", error.message
+  end
+
+  test 'enqueue supports delay' do
+    job_instance = Echoer.enqueue(['one argument', { random: 'data' }, 3], delay: 2)
+
+    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
+    assert jobs.empty?
+
+    sleep 1
+    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
+    assert jobs.empty?
+
+    sleep 2
+    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
+    assert jobs.any?
+    assert_equal 1, jobs.size
+  end
+
+  test 'enqueue supports retry' do
+    job_instance = Echoer.enqueue(['one argument', { random: 'data' }, 3], retry: 1)
+
+    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
+    assert jobs.any?
+    assert_equal 1, jobs.size
+
+    sleep 1.5
+    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
+    assert jobs.any?
+    assert_equal 1, jobs.size
+  end
+
+  test 'enqueue supports ttl' do
+    job_instance = Echoer.enqueue(['one argument', { random: 'data' }, 3], ttl: 1)
+
+    sleep 1.5
+    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
+    assert jobs.empty?
+  end
+
+  test 'enqueue supports maxlen' do
+    Echoer.enqueue(['one argument', { random: 'data' }, 3], maxlen: 1)
+    error = Echoer.enqueue(['one argument', { random: 'data' }, 3], maxlen: 1) rescue $!
+
+    assert_equal RuntimeError, error.class
+    assert_equal "MAXLEN Queue is already longer than the specified MAXLEN count", error.message
+  end
+
+  test 'enqueue supports async' do
+    job_instance = Echoer.enqueue(['one argument', { random: 'data' }, 3], async: true)
+
+    sleep 1 # async is too fast to reliably assert an empty queue, let's wait instead
+    jobs = Array(Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1))
+    assert jobs.any?
+    assert_equal 1, jobs.size
+  end
+end

data/test/process_test.rb

@@ -0,0 +1,59 @@
+require 'cutest'
+require 'disc'
+require 'pty'
+require 'timeout'
+
+require_relative '../examples/echoer'
+require_relative '../examples/failer'
+
+prepare do
+  Disc.disque_timeout = 1 # 1ms so we don't wait at all.
+  Disc.flush
+end
+
+scope do
+  # Runs a given command, yielding the stdout (as an IO) and the PID (a String).
+  # Makes sure the process finishes after the block runs.
+  def run(command)
+    out, _, pid = PTY.spawn(command)
+    yield out, pid
+  ensure
+    Process.kill("KILL", pid)
+    sleep 0.1 # Make sure we give it time to finish.
+  end
+
+  # Checks whether a process is running.
+  def is_running?(pid)
+    Process.getpgid(pid)
+    true
+  rescue Errno::ESRCH
+    false
+  end
+
+  test 'Disc.on_error will catch unhandled exceptions and keep disc alive' do
+    failer = Failer.enqueue('this can only end positively')
+
+    run('QUEUES=test ruby -Ilib bin/disc -r ./examples/failer') do |cout, pid|
+      output = Timeout.timeout(1) { cout.take(5) }
+      jobs = Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1)
+      assert jobs.nil?
+
+      assert output.grep(/<insert error reporting here>/).any?
+      assert output.grep(/this can only end positively/).any?
+      assert output.grep(/Failer/).any?
+
+      assert is_running?(pid)
+    end
+  end
+
+  test 'jobs are executed' do
+    Echoer.enqueue(['one argument', { random: 'data' }, 3])
+
+    run('QUEUES=test ruby -Ilib bin/disc -r ./examples/echoer') do |cout, pid|
+      output = Timeout.timeout(1) { cout.take(3) }
+      jobs = Disc.disque.fetch(from: ['test'], timeout: Disc.disque_timeout, count: 1)
+      assert jobs.nil?
+      assert output.grep(/First: one argument, Second: {"random"=>"data"}, Third: 3/).any?
+    end
+  end
+end

data/test/testing_test.rb

@@ -0,0 +1,45 @@
+# Yo dawg I put some testing in your testing so you can test while you test.
+
+require 'disc'
+require 'disc/testing'
+
+require_relative '../examples/echoer'
+require_relative '../examples/returner'
+
+prepare do
+  Disc.disque_timeout = 1 # 1ms so we don't wait at all.
+  Disc.enqueue!
+  Disc.flush
+end
+
+scope do
+  test "testing mode should not enqueue jobs into Disque" do
+    Echoer.enqueue(['one argument', { random: 'data' }, 3])
+    assert_equal 0, Disc.disque.call('QLEN', 'test')
+    assert_equal 1, Disc.qlen('test')
+
+    # Flush should still work though
+    Disc.flush
+    assert_equal 0, Disc.qlen('test')
+  end
+
+  test "testing mode enqueue jobs into an in-memory list by default" do
+    Echoer.enqueue(['one argument', { random: 'data' }, 3])
+
+    assert_equal 1, Disc.queues['test'].count
+    assert Disc.queues['test'].first.has_key?(:arguments)
+    assert_equal 3, Disc.queues['test'].first[:arguments].count
+    assert_equal 'one argument', Disc.queues['test'].first[:arguments].first
+    assert_equal 'Echoer', Disc.queues['test'].first[:class]
+  end
+
+  test "testing mode enqueue jobs into an in-memory list by default" do
+    Echoer.enqueue(['one argument', { random: 'data' }, 3])
+    assert_equal 'one argument', Disc.queues['test'].first[:arguments].first
+  end
+
+  test "ability to run jobs inline" do
+    Disc.inline!
+    assert_equal 'this is an argument',  Returner.enqueue('this is an argument')
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: disc
 version: !ruby/object:Gem::Version
-  version: 0.0.27
+  version: 0.0.28
 platform: ruby
 authors:
 - pote
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-01 00:00:00.000000000 Z
+date: 2016-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: disque
@@ -61,13 +61,18 @@ files:
 - examples/echoer.rb
 - examples/failer.rb
 - examples/greeter.rb
+- examples/returner.rb
 - lib/active_job/queue_adapters/disc_adapter.rb
 - lib/disc.rb
+- lib/disc/errors.rb
 - lib/disc/job.rb
 - lib/disc/testing.rb
 - lib/disc/version.rb
 - lib/disc/worker.rb
 - test/disc_test.rb
+- test/job_test.rb
+- test/process_test.rb
+- test/testing_test.rb
 homepage: https://github.com/pote/disc
 licenses:
 - MIT