robinhood 0.0.1.pre → 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 913bb9ef8276fd39f9c3ba6f1ad43548091601d9
+  data.tar.gz: fbb34da42c7ccc99289a41f5fc38495a9360f373
+SHA512:
+  metadata.gz: e09bdea365ad31009265edf0cf7607a0ca47c4b26464a646f35d94a1f556c196c9e3f2fec91297a41968bf1f9a0379adfdfc57adc6ca84b49efc8550a1525de5
+  data.tar.gz: 0e1aaae54ee25b24b35addf173a1f26c94bdd04cf9314ec5fade00e944e61ca106196dafd57caca42b700b415d5bb4e6af6a93fb35e0f57e174db61aec7d1d0c

data/.ruby-version

@@ -1 +1 @@
-rbx
+2.0.0-p247

data/README.md

@@ -1,30 +1,39 @@
-# Robinhood
+# Robinhood [![Build Status](https://www.travis-ci.org/codegram/robinhood.png?branch=master)](https://www.travis-ci.org/codegram/robinhood)
 
 Robinhood is a DSL for constructing iteration-based synchronous processes
 (aka can't be run as jobs) in a distributed manner.
 
+In other words: Robs responsibilities from richer processes and gives them to
+the poor.
+
 It leverages celluloid actors for each process and uses Redis as a locking
 mechanism to ensure the process is run in a single server.
 
 ## Usage
 
 ```ruby
-Robinhood.setup do
-  process :assigner, timeout: 10.minutes do
+Robinhood.define do
+  redis{ Redis.new(:host => "10.0.1.1", :port => 6380) }
+
+  process :assigner, throttle: 10 do
     UserAssigner.process!
   end
 
-  process :sweeper, throttle: 1.minute do
+  process :sweeper, throttle: false, timeout: 20 do
     Sweeper.sweep!
   end
 end
+
+Robinhood.run
 ```
 
 ## How does it work?
 
 Each time a process finishes its execution, the lock is released so any other
 server (or system process) can execute it again. This ensures it will be
-executed in a synchronous manner (one after the other).
+executed in a synchronous manner (one after the other). It also garantees the
+executions will be distributed across the processes (or servers) so if a server
+goes down, the load will be distributed evenly across the rest of them.
 
 You can also set a timeout (in case a process hangs for some reason) and a
 throttling mechanism (so a process can't be re-scheduled before this time has

data/lib/robinhood/dsl.rb

@@ -0,0 +1,46 @@
+require "celluloid"
+require 'logger'
+
+module Robinhood
+  # The DSL provides syntax suger on top of Robinhood's runtime. It allows us
+  # to define processes in a natural language for the programmer's convenience.
+  #
+  class DSL
+    # Public: Initializes the DSL.
+    #
+    # runtime - A runtime that will be configured using the DSL.
+    def initialize(runtime)
+      @runtime = runtime
+    end
+
+    # Public: Adds a process to the runtime.
+    #
+    # name    - The name of the process to be run. Will be used to identify the
+    #           mutex name across System Processes.
+    # options - A set of options that will be passed to the Process.
+    # block   - A block that will be called each execution of this process.
+    #
+    # Returns nil.
+    def process(name, options = {}, &block)
+      @runtime.add_process(name, options, block)
+      nil
+    end
+
+    # Public: Allows a redis instance to be used to provide the locking.
+    #
+    # Example:
+    #
+    # Robinhood.define do
+    #   redis{ Redis.new(host: 'foo') }
+    # end
+    #
+    # block - A mandatory block whose result will be assigned to the runtime's
+    #         redis client.
+    #
+    # Returns nil.
+    def redis
+      @runtime.redis = yield
+      nil
+    end
+  end
+end

data/lib/robinhood/mutex.rb

@@ -0,0 +1,7 @@
+require 'redis-mutex'
+
+Redis::Classy.db ||= Redis.new
+
+module Robinhood
+  class Mutex < Redis::Mutex; end;
+end

data/lib/robinhood/process.rb

@@ -1,14 +1,36 @@
 require 'celluloid'
-require 'redis-mutex'
 require 'benchmark'
+require 'robinhood/mutex'
 
 module Robinhood
+  # This class wraps a previously defined process. It's responsible to prevent
+  # the same process to be run at the sime time on different System Processes.
+  #
+  # A Process leverages a Celluloid Actor, so it will spawned in a different
+  # thread and communicate with the rest of the system with messages.
   class Process
     attr_reader :name, :options
 
     include Celluloid
     include Celluloid::Logger
 
+    finalizer :unlock
+
+    # Public: Initializes a Process
+    #
+    # name    - A String that will be used as a global identifier. It's
+    #           important that it is unique, since the locking will be
+    #           performed this name as scope.
+    # options - A Hash of options that configure this Process.
+    #           :throttle - An Integer that represents the minimum number of
+    #                       seconds that this process will take. In other
+    #                       words, if its execution takes less than that, we'll
+    #                       wait a little bit until it hits the next execution.
+    #           :timeout  - An Integer representing the period of time after
+    #                       which this process' execution will be considered as
+    #                       'hung' and another execution will take place.
+    # block   - The block that will be evaluated each time this Process gets
+    #           executed.
     def initialize(name, options, block)
       @name = name
       @options = options
@@ -16,17 +38,31 @@ module Robinhood
       async.run
     end
 
-    def run
-      mutex.lock
+    private
 
-      time = Benchmark.realtime{ @block.call }
+    def run
+      return unless lock
 
-      sleep(difference) if difference = throttle - time
+      begin
+        time = Benchmark.realtime{ @block.call }
+        if difference = throttle - time
+          sleep(difference)
+        end
+      ensure
+        unlock
+      end
     ensure
-      mutex.unlock
       async.run
     end
 
+    def lock
+      mutex.lock
+    end
+
+    def unlock
+      mutex.unlock
+    end
+
     def lock_name
       "robinhood:#{name}:lock"
     end
@@ -35,12 +71,16 @@ module Robinhood
       if (throttle = options[:throttle]) != nil
         throttle
       else
-        0.1
+        0.05
       end
     end
 
+    def timeout
+      options[:timeout] || 300
+    end
+
     def mutex
-      @mutex ||= Redis::Mutex.new(lock_name, block: 1, sleep: 0.1, expire: 300)
+      @mutex ||= Mutex.new(lock_name, block: 1, sleep: 0.1, expire: timeout)
     end
   end
 end

data/lib/robinhood/runtime.rb

@@ -0,0 +1,77 @@
+require "celluloid"
+require "robinhood/process"
+require 'robinhood/mutex'
+
+module Robinhood
+  # A Runtime is responsible of kickstarting a Robinhood's execution, spawning
+  # all the processes and configuring the environment.
+  class Runtime
+    attr_accessor :redis
+
+    # Public: Initializes a Runtime.
+    def initialize
+      @processes = []
+    end
+
+    # Public: Schedules a process to be run in this Runtime.
+    #
+    # name    - A String identifying this process.
+    # options - A Hash of options that will be passed to the underlying
+    #           Process.
+    # block   - The block that will be evaluated in this Process.
+    #
+    # Returns nil.
+    def add_process(name, options, block)
+      @processes << [name, options, block]
+      nil
+    end
+
+    # Public: Starts the Runtime.
+    #
+    # options - A hash of options to configure this Runtime's execution.
+    #           (default: {background: false})
+    #           :background - True if it runs on the background (doesn't block
+    #                         the main thread), False otherwise.
+    #
+    # Returns the Runtime.
+    def run(options = {})
+      setup_supervision_group
+      Mutex.db = redis
+
+      Robinhood.log :info, "Starting Robin Hood: Robbing from the rich and giving to the poor.."
+
+      @actor = options[:background] ? supervision_group.run! : supervision_group.run
+      self
+    end
+
+    # Public: Stops this Runtime.
+    #
+    # Returns nil.
+    def stop
+      @actor.finalize if @actor
+      nil
+    end
+
+    private
+
+    def redis
+      @redis ||= Redis.new
+    end
+
+    def supervision_group
+      @supervision_group ||= Class.new(Celluloid::SupervisionGroup)
+    end
+
+    def setup_supervision_group
+      @processes.each do |process|
+        name, options, block = process
+
+        supervision_group.supervise Process,
+          as: "robinhood_#{name}",
+          args: [name, options, block]
+      end
+
+      @processes = []
+    end
+  end
+end

data/lib/robinhood/version.rb

@@ -1,3 +1,3 @@
 module Robinhood
-  VERSION = "0.0.1.pre"
+  VERSION = "0.0.1"
 end

data/lib/robinhood.rb

@@ -1,20 +1,89 @@
 require "robinhood/version"
-require "robinhood/setup"
+require "robinhood/dsl"
+require "robinhood/runtime"
 require "celluloid/autostart"
 
 module Robinhood
-  def self.setup(options = {}, &block)
-    @setup ||= Setup.new(options)
-    @setup.instance_eval(&block)
-    @setup.start
+  # Public: The starting point for Robinhood's DSL.
+  #
+  # Example:
+  #
+  #   Robinhood.define do
+  #     redis{ Redis.new(host: 'foobar') }
+  #
+  #     process :ed, timeout: 100 do
+  #       Balls.process!
+  #     end
+  #
+  #     process :sweeper, throttle: 5 do
+  #       Sweeper.sweep!
+  #     end
+  #   end
+  def self.define(&block)
+    dsl.instance_eval(&block) if block
   end
 
+  # Public: Runs a previously configured Robinhood instance.
+  #
+  # options - A hash of options to configure the execution.
+  #           (default: {background: false})
+  #           :background - True if it has to be run on the background (doesn't
+  #                         block the main thread), False otherwise.
+  #
+  # Returns nil.
+  def self.run(options = {})
+    runtime.run(options)
+    nil
+  end
+
+  # Public: Stops Robinhood's execution, if it was run on the background.
+  #
+  # Returns nil.
   def self.stop
-    @setup.stop if @setup
+    runtime.stop if runtime
+    nil
+  end
+
+  # Public: Assigns a Logger to Robinhood where it will output info, debug and
+  # error messages.
+  #
+  # Returns the Logger.
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  # Private: Logs messages to the logger.
+  #
+  # loglevel - The message's log level: :info, :error or :debug
+  # message  - A String with the message to be logged
+  #
+  # Returns nil.
+  def self.log(loglevel, message)
+    logger.send loglevel, message if logger
+    nil
   end
 
+  # Semi-public: Resets robinhood to a clean state. Mostly used on testing.
+  #
+  # Returns nil.
   def self.reset!
     stop
-    @setup = nil
+    @runtime = nil
+  end
+
+  def self.logger
+    return @logger if defined?(@logger)
+    @logger = Logger.new(STDOUT)
+  end
+  private_class_method :logger
+
+  def self.runtime
+    @runtime ||= Runtime.new
+  end
+  private_class_method :runtime
+
+  def self.dsl
+    @dsl ||= DSL.new(runtime)
   end
+  private_class_method :dsl
 end

data/spec/acceptance/dsl_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+require "robinhood"
+
+describe "Robinhood.define" do
+  it "executes a process iteratively until it ends" do
+    queue = [1, 2]
+
+    Robinhood.define do
+      process :test do
+        queue.pop
+      end
+    end
+
+    Robinhood.run(background: true)
+
+    sleep(0.2)
+    expect(queue).to be_empty
+  end
+
+  it "allows setting an arbitrary throttle" do
+    throttle = 0.01
+
+    calls = []
+
+    method_call = Proc.new do
+      calls << Time.now
+    end
+
+    Robinhood.define do
+      process :test, throttle: throttle do
+        method_call.call
+      end
+    end
+
+    Robinhood.run(background: true)
+
+    sleep(throttle * 5)
+
+    calls.each_with_index do |call, index|
+      if (index + 1) < calls.length
+        expect(calls[index + 1] - call).to be > throttle
+      end
+    end
+  end
+end

data/spec/lib/robinhood/dsl_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+require "robinhood"
+require "robinhood/dsl"
+
+module Robinhood
+  describe DSL do
+    let(:dsl){ DSL.new(runtime) }
+
+    describe "#process" do
+      let(:runtime){ double(:runtime, add_process: true) }
+
+      it "adds a process to the runtime" do
+        block = Proc.new{}
+        dsl.process :test, {foo: :bar}, &block
+
+        expect(runtime).to have_received(:add_process).
+          with(:test, {foo: :bar}, block)
+      end
+    end
+
+    describe "#redis" do
+      let(:runtime){ double(:runtime, :redis= => true) }
+
+      it "allows setting a redis client to the runtime" do
+        redis = double(:redis)
+        dsl.redis{ redis }
+
+        expect(runtime).to have_received(:redis=).with(redis)
+      end
+    end
+  end
+end

data/spec/lib/robinhood/process_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+require "robinhood"
+require "robinhood/process"
+require 'thread'
+
+module Robinhood
+  describe Process do
+    before do
+      Robinhood::Runtime.new.run(background: true)
+    end
+
+    describe "mutual exclusion" do
+      it "doesn't allow two of the same processes to run at once" do
+        output = []
+
+        Process.new(:test, {throttle: 0.01}, Proc.new{
+          output << :ed
+          sleep(0.05)
+          output << :ed
+        })
+
+        Process.new(:test, {throttle: 0.01}, Proc.new{
+          output << :balls
+          sleep(0.05)
+          output << :balls
+        })
+
+        sleep(2)
+
+        (output.length / 2).times.map{|i| i * 2}.each do |index|
+          expect(output[index]).to eq(output[index + 1])
+        end
+      end
+    end
+  end
+end

data/spec/lib/robinhood/runtime_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+require "robinhood"
+require "robinhood/runtime"
+require 'thread'
+
+module Robinhood
+  describe Runtime do
+    let(:runtime){ Robinhood::Runtime.new }
+
+    describe "#add_process" do
+      it "adds a process to be executed on start" do
+        runtime.add_process :edballs, {foo: :bar}, Proc.new{}
+
+        runtime.run(background: true)
+
+        actor = Celluloid::Actor[:robinhood_edballs]
+        expect(actor).to_not be_nil
+        expect(actor.options).to include(foo: :bar)
+      end
+    end
+
+    describe "#run" do
+      it "sets the default redis db for the mutex" do
+        redis = double(:redis)
+        runtime.redis = redis
+        runtime.run(background: true)
+
+        expect(Mutex.db).to eq(redis)
+      end
+    end
+
+    describe "#stop" do
+      it "stops the runtime synchronously" do
+        runtime.add_process :edballs, {foo: :bar}, Proc.new{}
+
+        runtime.run(background: true)
+        runtime.stop
+
+        expect(Celluloid::Actor[:robinhood_edballs]).to eq(nil)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -8,13 +8,13 @@ RSpec.configure do |config|
     config.formatter = :documentation
   end
 
-  config.before(:each) do
+  config.before(:all) do
     Celluloid.logger = nil
-    redis = Redis.new
-    redis.flushdb
+    Robinhood.logger = nil
   end
 
-  config.after(:each) do
+  config.before(:each) do
     Robinhood.reset!
+    Redis.new.flushdb
   end
 end

metadata

@@ -1,128 +1,113 @@
 --- !ruby/object:Gem::Specification
 name: robinhood
 version: !ruby/object:Gem::Version
-  prerelease: 6
-  version: 0.0.1.pre
+  version: 0.0.1
 platform: ruby
 authors:
 - Josep Jaume
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-05 00:00:00.000000000 Z
+date: 2013-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-    none: false
+  name: celluloid
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  name: celluloid
   type: :runtime
   prerelease: false
-- !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
+- !ruby/object:Gem::Dependency
+  name: redis-mutex
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  name: redis-mutex
   type: :runtime
   prerelease: false
-- !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '1.3'
-    none: false
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.3'
-    none: false
-  name: bundler
   type: :development
   prerelease: false
-- !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-    none: false
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  name: rake
   type: :development
   prerelease: false
-- !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
+- !ruby/object:Gem::Dependency
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  name: rspec
   type: :development
   prerelease: false
-- !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
+- !ruby/object:Gem::Dependency
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  name: pry
   type: :development
   prerelease: false
-- !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
+- !ruby/object:Gem::Dependency
+  name: pry-nav
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  name: pry-nav
   type: :development
   prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Robin hood leverages celluloid actors and redis-mutex to distribute long-lived,
   single-instance processes across multiple servers.
 email:
@@ -131,65 +116,53 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- !binary |-
-  LmdpdGlnbm9yZQ==
-- !binary |-
-  LnJ1YnktdmVyc2lvbg==
-- !binary |-
-  LnRyYXZpcy55bWw=
-- !binary |-
-  R2VtZmlsZQ==
-- !binary |-
-  TElDRU5TRS50eHQ=
-- !binary |-
-  UkVBRE1FLm1k
-- !binary |-
-  UmFrZWZpbGU=
-- !binary |-
-  bGliL3JvYmluaG9vZC5yYg==
-- !binary |-
-  bGliL3JvYmluaG9vZC9wcm9jZXNzLnJi
-- !binary |-
-  bGliL3JvYmluaG9vZC9zZXR1cC5yYg==
-- !binary |-
-  bGliL3JvYmluaG9vZC92ZXJzaW9uLnJi
-- !binary |-
-  cm9iaW5ob29kLmdlbXNwZWM=
-- !binary |-
-  c3BlYy9hY2NlcHRhbmNlL3NldHVwX3NwZWMucmI=
-- !binary |-
-  c3BlYy9zcGVjX2hlbHBlci5yYg==
+- .gitignore
+- .ruby-version
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/robinhood.rb
+- lib/robinhood/dsl.rb
+- lib/robinhood/mutex.rb
+- lib/robinhood/process.rb
+- lib/robinhood/runtime.rb
+- lib/robinhood/version.rb
+- robinhood.gemspec
+- spec/acceptance/dsl_spec.rb
+- spec/lib/robinhood/dsl_spec.rb
+- spec/lib/robinhood/process_spec.rb
+- spec/lib/robinhood/runtime_spec.rb
+- spec/spec_helper.rb
 homepage: http://www.codegram.com
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
-      hash: 2002549777813010636
-      segments:
-      - 0
       version: '0'
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
-  none: false
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Robin hood leverages celluloid actors and redis-mutex to distribute long-lived,
   single-instance processes across multiple servers.
 test_files:
-- !binary |-
-  c3BlYy9hY2NlcHRhbmNlL3NldHVwX3NwZWMucmI=
-- !binary |-
-  c3BlYy9zcGVjX2hlbHBlci5yYg==
+- spec/acceptance/dsl_spec.rb
+- spec/lib/robinhood/dsl_spec.rb
+- spec/lib/robinhood/process_spec.rb
+- spec/lib/robinhood/runtime_spec.rb
+- spec/spec_helper.rb

data/lib/robinhood/setup.rb

@@ -1,54 +0,0 @@
-require "robinhood/process"
-require "celluloid"
-
-module Robinhood
-  class Setup
-    attr_reader :options
-
-    def initialize(options = {})
-      @options = options
-      @processes = []
-    end
-
-    def process(name, options = {}, &block)
-      @processes << [name, options, block]
-    end
-
-    def redis
-      @redis = yield
-    end
-
-    def supervision_group
-      @supervision_group ||= Class.new(Celluloid::SupervisionGroup)
-    end
-
-    def start
-      setup_supervision_group
-      Redis::Classy.db = @redis || Redis.new
-
-      @supervision_group_actor = if options[:background]
-                                   supervision_group.run!
-                                 else
-                                   supervision_group.run
-                                 end
-    end
-
-    def stop
-      @supervision_group_actor.finalize if @supervision_group_actor
-    end
-
-    def redis_options
-      options[:redis] || {}
-    end
-
-    def setup_supervision_group
-      @processes.each do |process|
-        name, options, block = process
-
-        supervision_group.supervise Process,
-          as: "robinhood_#{name}",
-          args: [name, options.merge(autostart: true), block]
-      end
-    end
-  end
-end

data/spec/acceptance/setup_spec.rb

@@ -1,46 +0,0 @@
-require "spec_helper"
-require "robinhood"
-
-module Robinhood
-  describe ".setup" do
-    it "creates actors for each process" do
-      Robinhood.setup(background: true) do
-        process(:ed){}
-        process(:balls){}
-      end
-
-      sleep(1)
-
-      expect(Celluloid::Actor[:robinhood_ed]).to_not be_nil
-      expect(Celluloid::Actor[:robinhood_balls]).to_not be_nil
-    end
-
-    it "executes a process iteratively until it ends" do
-      queue = [1, 2]
-
-      Robinhood.setup(background: true) do
-        process :test do
-          queue.pop
-        end
-      end
-
-      sleep(1)
-      expect(queue).to be_empty
-    end
-
-    it "allows setting an arbitrary throttle" do
-      queue = [1, 2]
-
-      Robinhood.setup(background: true) do
-        process :test, throttle: 0.5 do
-          queue.pop
-        end
-      end
-
-      sleep(0.2)
-      expect(queue).not_to be_empty
-      sleep(1)
-      expect(queue).to be_empty
-    end
-  end
-end