resque-workers-lock 1.5 → 1.6

data/Rakefile

@@ -1,30 +1,11 @@
-require 'resque/tasks'
-
-task "resque:setup" do
-  require_relative 'test/lock_worker'
-end
-
 require 'rake/testtask'
 require 'rdoc/task'
-
-def command?(command)
-  system("type #{command} > /dev/null")
-end
-
-# Tests
+require 'resque/tasks'
 
 task :default => :test
 
-if command? :turn
-  desc "Run tests"
-  task :test do
-    suffix = "-n #{ENV['TEST']}" if ENV['TEST']
-    sh "turn test/*.rb #{suffix}"
-  end
-else
-  Rake::TestTask.new do |t|
-    t.libs << 'lib'
-    t.pattern = 'test/**/*_test.rb'
-    t.verbose = false
-  end
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
 end

data/test/lock_test.rb

@@ -1,38 +1,24 @@
 require 'test/unit'
 require 'resque/plugins/workers/lock'
-require_relative 'lock_worker'
+require 'tempfile'
 
 class LockTest < Test::Unit::TestCase
-  class SimilarJob
-    extend Resque::Plugins::Workers::Lock
-    @queue = :lock_test
-
-    def self.perform
-      raise "Woah woah! How did this happen?"
-    end
-  end
-
   class UniqueJob
     extend Resque::Plugins::Workers::Lock
     @queue = :lock_test
 
-    def self.lock_enqueue(id)
-      return id.to_s+"e"
+    def self.lock_workers(*)
+      self.name
     end
 
-    def self.lock_workers(id)
-      return id.to_s+"w"
+    def self.perform params
+      File.open(params['output_file'], 'a') do |output_file|
+        output_file.puts params['job']
+        output_file.flush
+        sleep 1
+        output_file.puts params['job']
+      end
     end
-
-    def self.perform(id)
-      raise "Woah woah! How did this happen?"
-    end
-  end
-
-  def setup
-    Resque.redis.del('queue:lock_test')
-    Resque.redis.del(SimilarJob.lock_workers)
-    Resque.redis.del(SimilarJob.lock_enqueue)
   end
 
   def test_lint
@@ -41,53 +27,78 @@ class LockTest < Test::Unit::TestCase
     end
   end
 
-  def test_enqueue
-    3.times { Resque.enqueue(SimilarJob) }
+  def test_workers_dont_work_simultaneously
+    assert_locking_works_with jobs: 2, workers: 2
+  end
+
+  private
 
-    assert_equal "LockTest::SimilarJob-[]", SimilarJob.lock_workers
-    assert_equal "LockTest::SimilarJob-[]", SimilarJob.lock_enqueue
-    assert_equal 1, Resque.redis.llen('queue:lock_test')
+  def assert_locking_works_with options
+    jobs = (1..options[:jobs]).map{|job| "Job #{job}" }
+    output_file = Tempfile.new 'output_file'
 
-    3.times do |i|
-      Resque.enqueue(UniqueJob, i+100)
-      assert_equal i.to_s+"e", UniqueJob.lock_enqueue(i)
-      assert_equal i.to_s+"w", UniqueJob.lock_workers(i)
+    jobs.each do |job|
+      Resque.enqueue UniqueJob, job: job, output_file: output_file.path
     end
 
-    assert_equal 4, Resque.redis.llen('queue:lock_test')
+    process_jobs workers: options[:workers], timeout: 10
 
-    # Test for complete queue wipe
-    Resque.remove_queue(:lock_test)
+    lines = File.readlines(output_file).map(&:chomp)
+    lines.each_slice(2) do |a,b|
+      assert_equal a,b, "#{a} was interrupted by #{b}"
+    end
+  ensure
+    output_file.close
+  end
 
-    Resque.enqueue(SimilarJob)
-    assert_equal 1, Resque.redis.llen('queue:lock_test')
+  def process_jobs options
+    with_workers options[:workers] do
+      wait_until(options[:timeout]) do
+         no_busy_workers && no_queued_jobs
+      end
+    end
   end
 
-  def test_zcleanup
-    Resque.remove_queue(:lock_test)
+  def with_workers n
+    pids = []
+    n.times do
+      if pid = fork
+        pids << pid
+      else
+        pids = [] # Don't kill from child's ensure
+        worker = Resque::Worker.new('*')
+        worker.reconnect
+        worker.work(0.5)
+        exit!
+      end
+    end
+
+    yield
+
+  ensure
+    pids.each do |pid|
+      Process.kill("QUIT", pid)
+    end
+
+    pids.each do |pid|
+      Process.waitpid(pid)
+    end
+  end
 
-    Resque.redis.keys('enqueuelock:*').collect { |x| Resque.redis.del(x) }
-    Resque.redis.keys('workerslock:*').collect { |x| Resque.redis.del(x) }
+  def no_busy_workers
+    Resque::Worker.working.size == 0
+  end
 
-    assert_equal 0, Resque.redis.llen('queue:lock_test')
+  def no_queued_jobs
+    Resque.redis.llen("queue:lock_test") == 0
   end
 
-  # To test this, make sure to run `TERM_CHILD=1 COUNT=2 VVERBOSE=1 QUEUES=* rake resque:work`
-  def test_lock
-    2.times { Resque.enqueue(SimilarSleepJob, 'writing_and_sleeping') }
-    
-    # After 3 seconds only 1 job had the change of running
-    sleep(3)
-    file = File.open('test/test.txt', 'rb')
-    contents = file.read
-    file.close
-    assert_equal '1', contents
-    
-    # After 12 seconds the 2 jobs should have been processed (not at the same time because of the lock)
-    sleep(12)
-    file = File.open('test/test.txt', 'rb')
-    contents = file.read
-    file.close
-    assert_equal '11', contents
+  def wait_until(timeout)
+    timeout.times do
+      return if yield
+      sleep 1
+    end
+
+    raise "Timout occured"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-workers-lock
 version: !ruby/object:Gem::Version
-  version: '1.5'
+  version: '1.6'
   prerelease: 
 platform: ruby
 authors:
@@ -27,22 +27,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: turn
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -59,9 +43,12 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: ! "A Resque plugin. Two or more jobs with the same lock cannot be processed
-  simultaneously by multiple workers. \nWhen this situation occurs the second job
-  gets pushed back to the queue.\n"
+description: ! 'A Resque plugin. Two or more jobs with the same lock cannot be processed
+  simultaneously by multiple workers.
+
+  When this situation occurs the second job gets pushed back to the queue.
+
+'
 email: bartolsthoorn@gmail.com
 executables: []
 extensions: []
@@ -72,7 +59,6 @@ files:
 - LICENSE
 - lib/resque/plugins/workers/lock.rb
 - test/lock_test.rb
-- test/lock_worker.rb
 homepage: http://github.com/bartolsthoorn/resque-workers-lock
 licenses: []
 post_install_message: 

data/test/lock_worker.rb

@@ -1,22 +0,0 @@
-require 'resque'
-require 'resque/plugins/workers/lock'
-
-# Sleep job, for testing that two workers are not processing two jobs with
-# the same lock.
-class SimilarSleepJob
-  extend Resque::Plugins::Workers::Lock
-  @queue = :lock_test_workers
-
-  def self.lock_enqueue(id)
-    false
-  end
-
-  def self.lock_workers(id)
-    return id.to_s
-  end
-
-  def self.perform(id)
-    File.open('test/test.txt', 'a') {|f| f.write('1') }
-    sleep(5)
-  end
-end