resqued 0.9.0 → 0.11.0

data/spec/resqued/config/fork_event_spec.rb

@@ -1,12 +1,12 @@
-require 'spec_helper'
-require 'resqued/config/after_fork'
-require 'resqued/config/before_fork'
-require 'resqued/runtime_info'
+require "spec_helper"
+require "resqued/config/after_fork"
+require "resqued/config/before_fork"
+require "resqued/runtime_info"
 
 describe do
   before { evaluator.apply(config) }
 
-  context 'after_fork' do
+  context "after_fork" do
     # Run the after_fork block.
     #
     #    after_fork do |resque_worker|
@@ -26,13 +26,13 @@ describe do
       end
     END_CONFIG
 
-    let(:evaluator) { Resqued::Config::AfterFork.new(:worker => worker) }
+    let(:evaluator) { Resqued::Config::AfterFork.new(worker: worker) }
     let(:worker) { FakeResqueWorker.new }
 
     it { expect(worker.token).to eq(:called) }
   end
 
-  context 'before_fork' do
+  context "before_fork" do
     # Run the before_fork block.
     #
     #    before_fork do
@@ -56,7 +56,7 @@ describe do
       end
     END_CONFIG
 
-    let(:evaluator) { $before_fork_called = false ; Resqued::Config::BeforeFork.new(:resqued => resqued) }
+    let(:evaluator) { $before_fork_called = false; Resqued::Config::BeforeFork.new(resqued: resqued) }
     let(:resqued) { Resqued::RuntimeInfo.new }
 
     it { expect($before_fork_called).to eq(true) }

data/spec/resqued/config/worker_spec.rb

@@ -1,5 +1,5 @@
-require 'spec_helper'
-require 'resqued/config/worker'
+require "spec_helper"
+require "resqued/config/worker"
 
 describe Resqued::Config::Worker do
   # Create a bunch of Resqued::Worker objects from
@@ -15,7 +15,7 @@ describe Resqued::Config::Worker do
   #
   # ignore calls to any other top-level method.
 
-  let(:evaluator) { described_class.new(:worker_class => FakeWorker) }
+  let(:evaluator) { described_class.new(worker_class: FakeWorker) }
   let(:result) { evaluator.apply(config) }
   module FakeWorker
     def self.new(options)
@@ -23,7 +23,7 @@ describe Resqued::Config::Worker do
     end
   end
 
-  context 'individual' do
+  context "individual" do
     let(:config) { <<-END_CONFIG }
       before_fork { }
       after_fork { }
@@ -35,25 +35,38 @@ describe Resqued::Config::Worker do
       after_fork { } # So that we don't rely on `workers`'s result falling through.
     END_CONFIG
     it { expect(result.size).to eq(6) }
-    it { expect(result[0]).to eq(:queues => ['a']) }
-    it { expect(result[1]).to eq(:queues => ['a']) }
-    it { expect(result[2]).to eq(:queues => ['b']) }
-    it { expect(result[3]).to eq(:queues => ['c', 'd']) }
-    it { expect(result[4]).to eq(:queues => ['d', 'c'], :interval => 3) }
-    it { expect(result[5]).to eq(:queues => ['*']) }
+    it { expect(result[0]).to eq(queues: ["a"]) }
+    it { expect(result[1]).to eq(queues: ["a"]) }
+    it { expect(result[2]).to eq(queues: ["b"]) }
+    it { expect(result[3]).to eq(queues: ["c", "d"]) }
+    it { expect(result[4]).to eq(queues: ["d", "c"], interval: 3) }
+    it { expect(result[5]).to eq(queues: ["*"]) }
   end
 
-  context 'concise pool' do
+  context "concise pool" do
     let(:config) { <<-END_CONFIG }
       worker_pool 2, 'a', 'b', 'c', :interval => 1
     END_CONFIG
-    it { expect(result).to eq([
-      { :queues => ['a', 'b', 'c'], :interval => 1 },
-      { :queues => ['a', 'b', 'c'], :interval => 1 },
-    ]) }
+    it do
+      expect(result).to eq([
+                             { queues: ["a", "b", "c"], interval: 1 },
+                             { queues: ["a", "b", "c"], interval: 1 },
+                           ])
+    end
   end
 
-  context 'pool (hash for concurrency)' do
+  context "small pool with percent" do
+    let(:config) { <<-END_CONFIG }
+      worker_pool 2
+      queue "a"
+      queue "b", :percent => 45
+    END_CONFIG
+    it { expect(result.size).to eq(2) }
+    it { expect(result[0]).to eq(queues: ["a", "b"]) }
+    it { expect(result[1]).to eq(queues: ["a"]) }
+  end
+
+  context "pool (hash for concurrency)" do
     let(:config) { <<-END_CONFIG }
       before_fork { }
       after_fork { }
@@ -64,15 +77,15 @@ describe Resqued::Config::Worker do
       after_fork { } # So that we don't rely on `worker_pool`'s result falling through.
     END_CONFIG
     it { expect(result.size).to eq(20) }
-    it { expect(result[0]).to eq(:queues => ['a', 'b1', 'b2', 'c'], :interval => 1) }
-    it { expect(result[3]).to eq(:queues => ['a', 'b1', 'b2', 'c'], :interval => 1) }
-    it { expect(result[4]).to eq(:queues => ['b1', 'b2', 'c'], :interval => 1) }
-    it { expect(result[9]).to eq(:queues => ['b1', 'b2', 'c'], :interval => 1) }
-    it { expect(result[10]).to eq(:queues => ['c'], :interval => 1) }
-    it { expect(result[19]).to eq(:queues => ['c'], :interval => 1) }
+    it { expect(result[0]).to eq(queues: ["a", "b1", "b2", "c"], interval: 1) }
+    it { expect(result[3]).to eq(queues: ["a", "b1", "b2", "c"], interval: 1) }
+    it { expect(result[4]).to eq(queues: ["b1", "b2", "c"], interval: 1) }
+    it { expect(result[9]).to eq(queues: ["b1", "b2", "c"], interval: 1) }
+    it { expect(result[10]).to eq(queues: ["c"], interval: 1) }
+    it { expect(result[19]).to eq(queues: ["c"], interval: 1) }
   end
 
-  context 'pool, with implied queue' do
+  context "pool, with implied queue" do
     let(:config) { <<-END_CONFIG }
       before_fork { }
       after_fork { }
@@ -80,11 +93,11 @@ describe Resqued::Config::Worker do
       after_fork { } # So that we don't rely on `worker_pool`'s result falling through.
     END_CONFIG
     it { expect(result.size).to eq(20) }
-    it { expect(result[0]).to eq(:queues => ['*']) }
-    it { expect(result[19]).to eq(:queues => ['*']) }
+    it { expect(result[0]).to eq(queues: ["*"]) }
+    it { expect(result[19]).to eq(queues: ["*"]) }
   end
 
-  context 'pool, with fewer queues than workers' do
+  context "pool, with fewer queues than workers" do
     let(:config) { <<-END_CONFIG }
       before_fork { }
       after_fork { }
@@ -93,13 +106,13 @@ describe Resqued::Config::Worker do
       after_fork { } # So that we don't rely on `worker_pool`'s result falling through.
     END_CONFIG
     it { expect(result.size).to eq(20) }
-    it { expect(result[0]).to eq(:queues => ['a']) }
-    it { expect(result[9]).to eq(:queues => ['a']) }
-    it { expect(result[10]).to eq(:queues => ['*']) }
-    it { expect(result[19]).to eq(:queues => ['*']) }
+    it { expect(result[0]).to eq(queues: ["a"]) }
+    it { expect(result[9]).to eq(queues: ["a"]) }
+    it { expect(result[10]).to eq(queues: ["*"]) }
+    it { expect(result[19]).to eq(queues: ["*"]) }
   end
 
-  context 'pool, with more queues than workers' do
+  context "pool, with more queues than workers" do
     let(:config) { <<-END_CONFIG }
       before_fork { }
       after_fork { }
@@ -110,48 +123,48 @@ describe Resqued::Config::Worker do
     it { expect(result.size).to eq(20) }
   end
 
-  context 'pool, with shuffled queues' do
+  context "pool, with shuffled queues" do
     let(:config) { <<-END_CONFIG }
-      worker_pool 20, :shuffle_queues => true
-      queue 'a', :count => 10
-      queue 'b', :count => 15
+      worker_pool 200, :shuffle_queues => true
+      queue 'a', :count => 100
+      queue 'b', :count => 150
     END_CONFIG
-    it { expect(result.size).to eq(20) }
-    it { (0..9).each { |i| expect(result[i][:queues].sort).to eq(['a', 'b']) } }
-    it { (10..14).each { |i| expect(result[i][:queues]).to eq(['b']) } }
-    it { (15..19).each { |i| expect(result[i][:queues]).to eq(['*']) } }
+    it { expect(result.size).to eq(200) }
+    it { (0..99).each { |i| expect(result[i][:queues].sort).to eq(["a", "b"]) } }
+    it { (100..149).each { |i| expect(result[i][:queues]).to eq(["b"]) } }
+    it { (150..199).each { |i| expect(result[i][:queues]).to eq(["*"]) } }
     it { result.each { |x| expect(x).not_to have_key(:shuffle_queues) } }
     it do
-      shuffled_queues = result.take(10).map { |x| x[:queues] }
-      expect(shuffled_queues.sort.uniq).to eq([ ['a','b'], ['b','a'] ]) # Some of the queues should be shuffled
+      shuffled_queues = result.take(100).map { |x| x[:queues] }
+      expect(shuffled_queues.sort.uniq).to eq([["a", "b"], ["b", "a"]]) # Some of the queues should be shuffled
     end
   end
 
-  context 'multiple worker configs' do
+  context "multiple worker configs" do
     let(:config) { <<-END_CONFIG }
       worker 'one'
       worker 'two'
       worker_pool 2
     END_CONFIG
     it { expect(result.size).to eq(4) }
-    it { expect(result[0]).to eq(:queues => ['one']) }
-    it { expect(result[1]).to eq(:queues => ['two']) }
-    it { expect(result[2]).to eq(:queues => ['*']) }
-    it { expect(result[3]).to eq(:queues => ['*']) }
+    it { expect(result[0]).to eq(queues: ["one"]) }
+    it { expect(result[1]).to eq(queues: ["two"]) }
+    it { expect(result[2]).to eq(queues: ["*"]) }
+    it { expect(result[3]).to eq(queues: ["*"]) }
   end
 
-  context 'worker factory' do
+  context "worker factory" do
     let(:config) { <<-END_CONFIG }
       worker_factory { |queues| queues }
       worker 'a'
     END_CONFIG
 
     it { expect(result.size).to eq(1) }
-    it { expect(result[0].reject { |k, _| k == :worker_factory}).to eq(:queues => ['a']) }
-    it { expect(result[0][:worker_factory].call(result[0][:queues])).to eq(['a']) }
+    it { expect(result[0].reject { |k, _| k == :worker_factory }).to eq(queues: ["a"]) }
+    it { expect(result[0][:worker_factory].call(result[0][:queues])).to eq(["a"]) }
   end
 
-  context 'worker factory with pool' do
+  context "worker factory with pool" do
     let(:config) { <<-END_CONFIG }
       worker_factory { |queues| queues }
       worker_pool 1
@@ -159,15 +172,15 @@ describe Resqued::Config::Worker do
     END_CONFIG
 
     it { expect(result.size).to eq(1) }
-    it { expect(result[0].reject { |k, _| k == :worker_factory}).to eq(:queues => ['a']) }
-    it { expect(result[0][:worker_factory].call(result[0][:queues])).to eq(['a']) }
+    it { expect(result[0].reject { |k, _| k == :worker_factory }).to eq(queues: ["a"]) }
+    it { expect(result[0][:worker_factory].call(result[0][:queues])).to eq(["a"]) }
   end
 
-  context 'with default options' do
-    let(:evaluator) { described_class.new(:worker_class => FakeWorker, :config => 'something') }
+  context "with default options" do
+    let(:evaluator) { described_class.new(worker_class: FakeWorker, config: "something") }
     let(:config) { <<-END_CONFIG }
       worker 'a', :interval => 1
     END_CONFIG
-    it { expect(result[0]).to eq(:queues => ['a'], :interval => 1, :config => 'something') }
+    it { expect(result[0]).to eq(queues: ["a"], interval: 1, config: "something") }
   end
 end

data/spec/resqued/config_spec.rb

@@ -1,9 +1,9 @@
-require 'spec_helper'
+require "spec_helper"
 
-require 'fileutils'
-require 'tmpdir'
+require "fileutils"
+require "tmpdir"
 
-require 'resqued/config'
+require "resqued/config"
 
 describe Resqued::Config do
   context do
@@ -19,8 +19,8 @@ describe Resqued::Config do
     end
     let(:config) { Resqued::Config.new([@config_file]) }
 
-    it("can require_relative") { config.build_workers ; expect($test_val).to eq(:ok) }
-    it("does not override require_relative in required files") { config.build_workers ; expect($other_test_val).to eq(:ok) }
+    it("can require_relative") { config.build_workers; expect($test_val).to eq(:ok) }
+    it("does not override require_relative in required files") { config.build_workers; expect($other_test_val).to eq(:ok) }
 
     def make_file(dir, relative_path, content)
       File.join(dir, relative_path).tap do |path|

data/spec/resqued/sleepy_spec.rb

@@ -1,34 +1,33 @@
-require 'spec_helper'
-require 'resqued/sleepy'
-require 'thread'
+require "spec_helper"
+require "resqued/sleepy"
 
 describe Resqued::Sleepy do
   include Resqued::Sleepy
 
-  it 'sleeps' do
+  it "sleeps" do
     expect { yawn(0.2) }.to run_for(0.2)
   end
 
-  it 'wakes on `awake`' do
-    Thread.new { sleep 0.1 ; awake }
+  it "wakes on `awake`" do
+    Thread.new { sleep 0.1; awake }
     expect { yawn(2.0) }.to run_for(0.1)
   end
 
-  it 'wakes on IO' do
+  it "wakes on IO" do
     rd, wr = IO.pipe
-    Thread.new { sleep 0.1 ; wr.write('.') }
+    Thread.new { sleep 0.1; wr.write(".") }
     expect { yawn(2.0, rd) }.to run_for(0.1)
   end
 
-  it 'does not sleep if duration is 0' do
+  it "does not sleep if duration is 0" do
     expect { yawn(-0.000001) }.to run_for(0.0)
   end
 
-  it 'does not sleep if duration is negative' do
+  it "does not sleep if duration is negative" do
     expect { yawn(0) }.to run_for(0.0)
   end
 
-  it 'sleeps if io is nil' do
+  it "sleeps if io is nil" do
     expect { yawn(0.5, nil) }.to run_for(0.5)
   end
 end

data/spec/resqued/test_case_spec.rb

@@ -1,14 +1,14 @@
-require 'spec_helper'
-require 'resqued/test_case'
+require "spec_helper"
+require "resqued/test_case"
 
 describe Resqued::TestCase do
   let(:test_case) { Object.new.extend(the_module) }
 
-  context 'LoadConfig' do
+  context "LoadConfig" do
     let(:the_module) { described_class::LoadConfig }
-    it { expect { test_case.assert_resqued 'spec/fixtures/test_case_environment.rb', 'spec/fixtures/test_case_clean.rb'              }.not_to raise_error }
-    it { expect { test_case.assert_resqued 'spec/fixtures/test_case_environment.rb', 'spec/fixtures/test_case_before_fork_raises.rb' }.to     raise_error }
-    it { expect { test_case.assert_resqued 'spec/fixtures/test_case_environment.rb', 'spec/fixtures/test_case_after_fork_raises.rb'  }.to     raise_error }
-    it { expect { test_case.assert_resqued 'spec/fixtures/test_case_environment.rb', 'spec/fixtures/test_case_no_workers.rb'         }.not_to raise_error }
+    it { expect { test_case.assert_resqued "spec/fixtures/test_case_environment.rb", "spec/fixtures/test_case_clean.rb"              }.not_to raise_error }
+    it { expect { test_case.assert_resqued "spec/fixtures/test_case_environment.rb", "spec/fixtures/test_case_before_fork_raises.rb" }.to     raise_error(RuntimeError) }
+    it { expect { test_case.assert_resqued "spec/fixtures/test_case_environment.rb", "spec/fixtures/test_case_after_fork_raises.rb"  }.to     raise_error(RuntimeError) }
+    it { expect { test_case.assert_resqued "spec/fixtures/test_case_environment.rb", "spec/fixtures/test_case_no_workers.rb"         }.not_to raise_error }
   end
 end

data/spec/spec_helper.rb

@@ -1 +1,6 @@
-require 'support/custom_matchers'
+require "support/custom_matchers"
+require "support/resqued_path"
+require "support/resqued_integration_helpers"
+
+SPEC_TEMPDIR = File.expand_path("../tmp/spec", File.dirname(__FILE__))
+FileUtils.mkpath(SPEC_TEMPDIR)

data/spec/support/custom_matchers.rb

@@ -8,7 +8,11 @@ module CustomMatchers
   class RunFor
     def initialize(expected_duration)
       @expected_duration = expected_duration
-      @epsilon  = 0.01
+      @epsilon = 0.01
+    end
+
+    def supports_block_expectations?
+      true
     end
 
     def within(epsilon)
@@ -24,9 +28,13 @@ module CustomMatchers
       @epsilon >= diff
     end
 
-    def failure_message_for_should
+    def failure_message
       "Expected block to run for #{@expected_duration} +/-#{@epsilon} seconds, but it ran for #{@actual_duration} seconds."
     end
+
+    def failure_message_when_negated
+      "Expected block not to run for #{@expected_duration} +/-#{@epsilon} seconds, but it ran for #{@actual_duration} seconds."
+    end
   end
 end
 

data/spec/support/extra-child-shim

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+extra_child_pid = fork { sleep(100); exit! }
+File.write(ENV["EXTRA_CHILD_PIDFILE"], extra_child_pid.to_s)
+
+exec(*ARGV)

data/spec/support/resqued_integration_helpers.rb

@@ -0,0 +1,50 @@
+module ResquedIntegrationHelpers
+  include ResquedPath
+
+  def start_resqued(config: "", debug: false)
+    # Don't configure any workers. That way, we don't need to have redis running.
+    config_path = File.join(SPEC_TEMPDIR, "config.rb")
+    File.write(config_path, config)
+
+    @pid =
+      if debug
+        spawn resqued_path, config_path
+      else
+        logfile = File.join(SPEC_TEMPDIR, "resqued.log")
+        File.write(logfile, "") # truncate it
+
+        spawn resqued_path, "--logfile", logfile, config_path
+      end
+    sleep 1.0
+  end
+
+  def restart_resqued
+    Process.kill(:HUP, @pid)
+    sleep 1.0
+  end
+
+  def expect_running(listener:)
+    processes = list_processes
+    expect(processes).to include(is_resqued_master)
+    listeners = processes.select { |p| p[:ppid] == @pid }.map { |p| p[:args] }
+    expect(listeners).to all(match(/#{listener}/)).and(satisfy { |l| l.size == 1 })
+  end
+
+  def expect_not_running
+    processes = list_processes
+    expect(processes).not_to include(is_resqued_master)
+  end
+
+  def stop_resqued
+    Process.kill(:TERM, @pid)
+    sleep 1.0
+  end
+
+  def list_processes
+    `ps axo pid,ppid,args`.lines.map { |line| pid, ppid, args = line.strip.split(/\s+/, 3); { pid: pid.to_i, ppid: ppid.to_i, args: args } }
+  end
+
+  def is_resqued_master
+    satisfy { |p| p[:pid] == @pid && p[:args] =~ /resqued-/ }
+  end
+end