resque-approval 1.0.1 → 1.2.0

data/lib/resque-approval.rb

@@ -6,14 +6,14 @@ module Resque
     module Approval
       def self.pending_job_keys
         keys = Resque.redis.hkeys('pending_jobs')
-        keys.map! { |key| JSON.parse(key) }
+        keys.map! { |key| Resque.decode(key) }
         keys.sort! { |a, b| a['id'] <=> b['id'] }
       end
 
       def before_enqueue_approval(*args)
         args = args[0] || {}
 
-        requires_approval = args.delete(:requires_approval) || args.delete('requires_approval')
+        requires_approval = extract_value(args, :requires_approval)
         if requires_approval
           enqueue_for_approval(args)
           allow_enqueue = false
@@ -24,52 +24,93 @@ module Resque
         allow_enqueue
       end
 
+      def before_delayed_enqueue(args)
+        key = extract_value(args, :approval_key)
+        Resque.redis.hdel('pending_jobs', key)
+      end
+
       def enqueue_for_approval(*args)
         args = args[0] || {}
 
-        message = args.delete(:approval_message) || args.delete('approval_message')
+        message = extract_value(args, :approval_message)
+        timeout = extract_value(args, :approval_timeout)
 
-        Resque.enqueue_to(:approval_required, self, args)
+        id = Resque.redis.hlen('pending_jobs')
+        key = build_key(id, message, timeout)
 
-        id = Resque.size(:approval_required) - 1
+        if timeout && Resque.respond_to?(:enqueue_in)
+          approval_args = args.merge(:approval_key => key)
+          Resque.enqueue_in(timeout, self, approval_args)
 
-        if message
-          key = {:id => id, :approval_message => message}.to_json
+          queue = Resque.queue_from_class(self)
+          value = build_value(queue, approval_args)
         else
-          key = { :id => id }.to_json
-        end
+          Resque.enqueue_to(:approval_required, self, args)
 
-        job = Resque.peek(:approval_required, id)
-        value = job.to_json
+          value = build_value(nil, args)
+        end
 
         Resque.redis.hset('pending_jobs', key, value)
       end
 
       def approve(key)
-        value = Resque.redis.hget('pending_jobs', key)
-
-        return false if value.nil?
+        job = remove_from_pending(key)
 
-        job = JSON.parse(value)
+        return false if job.nil?
 
-        Resque.redis.hdel('pending_jobs', key)
-        Resque.redis.lrem('queue:approval_required', 1, job.to_json)
         Resque.push(Resque.queue_from_class(self), job)
 
         true
       end
 
       def reject(key)
+        !!remove_from_pending(key)
+      end
+
+      def remove_from_pending(key)
         value = Resque.redis.hget('pending_jobs', key)
 
-        return false if value.nil?
+        return if value.nil?
 
-        job = JSON.parse(value)
+        encoded_job = value
+        job = Resque.decode(value)
 
         Resque.redis.hdel('pending_jobs', key)
-        Resque.redis.lrem('queue:approval_required', 1, job.to_json)
 
-        true
+        decoded_key = Resque.decode(key)
+        if decoded_key.has_key? 'approval_timeout'
+          Array(Resque.redis.keys("delayed:*")).each do |key|
+            destroyed = Resque.redis.lrem(key, 1, encoded_job)
+            break if destroyed > 0
+          end
+        else
+          Resque.redis.lrem('queue:approval_required', 1, encoded_job)
+        end
+
+        job
+      end
+
+      private
+
+      def extract_value(args, key)
+        args.delete(key.to_sym) || args.delete(key.to_s)
+      end
+
+      def build_key(id, message, timeout = nil)
+        key = { :id => id }
+
+        key.merge!(:approval_message => message) if message
+        key.merge!(:approval_timeout => timeout) if timeout
+
+        Resque.encode(key)
+      end
+
+      def build_value(queue = nil, *args)
+        value = { :class => self.to_s, :args => args }
+
+        value.merge!(:queue => queue) if queue
+
+        Resque.encode(value)
       end
     end
   end

data/lib/resque-approval/version.rb

@@ -1,7 +1,7 @@
 module Resque
   module Plugins
     module Approval
-      VERSION = '1.0.1'
+      VERSION = '1.2.0'
     end
   end
 end

data/resque-approval.gemspec

@@ -25,4 +25,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'guard'
   gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'resque-scheduler'
 end

data/spec/lib/resque-approval_spec.rb

@@ -14,6 +14,7 @@ describe "Resque::Plugins::Approval" do
     Resque.remove_queue(:dummy)
     Resque.remove_queue(:approval_required)
     Resque.redis.del('pending_jobs')
+    Resque.reset_delayed_queue
   end
 
   it "is a valid Resque plugin" do
@@ -22,23 +23,22 @@ describe "Resque::Plugins::Approval" do
 
   describe "#pending_job_keys" do
     it "lists keys (ordered by id) for all jobs that are waiting for approval" do
-      Job.enqueue_for_approval(:approval_message => 'test message 1')
       Job.enqueue_for_approval
-      Job.enqueue_for_approval(:approval_message => 'test message 2')
+      Job.enqueue_for_approval(:approval_timeout => 10)
+      Job.enqueue_for_approval(:approval_message => 'test message')
 
-      keys = [{'id' => 0, 'approval_message' => 'test message 1'},
-              {'id' => 1},
-              {'id' => 2, 'approval_message' => 'test message 2'}]
+      keys = [{ 'id' => 0 },
+              { 'id' => 1, 'approval_timeout' => 10 },
+              { 'id' => 2, 'approval_message' => 'test message' }]
       Resque::Plugins::Approval.pending_job_keys.should == keys
     end
   end
 
   describe ".before_enqueue_approval" do
-    context "when a job requires approval (via symbol or string)" do
+    context "when a job requires approval" do
       it "calls enqueue_for_approval" do
-        Job.should_receive(:enqueue_for_approval).twice.with({})
+        Job.should_receive(:enqueue_for_approval).with({})
         Resque.enqueue(Job, :requires_approval => true)
-        Resque.enqueue(Job, 'requires_approval' => true)
       end
     end
 
@@ -62,7 +62,7 @@ describe "Resque::Plugins::Approval" do
     end
 
     it "adds an entry to the 'pending_jobs' hash" do
-      Job.enqueue_for_approval()
+      Job.enqueue_for_approval
 
       key = '{"id":0}'
       value = '{"class":"Job","args":[{}]}'
@@ -70,47 +70,72 @@ describe "Resque::Plugins::Approval" do
       Resque.redis.hget('pending_jobs', key).should == value
     end
 
-    context "with an approval message (via symbol)" do
+    context "with an approval message" do
       it "includes the message in the 'pending_jobs' hash entry" do
-        Job.enqueue_for_approval(:approval_message => 'symbol test message')
+        Job.enqueue_for_approval(:approval_message => 'test message')
 
-        key = '{"id":0,"approval_message":"symbol test message"}'
+        key = '{"id":0,"approval_message":"test message"}'
         value = '{"class":"Job","args":[{}]}'
 
         Resque.redis.hget('pending_jobs', key).should == value
       end
     end
 
-    context "with an approval message (via string)" do
-      it "includes the message in the 'pending_jobs' hash entry" do
-        Job.enqueue_for_approval('approval_message' => 'string test message')
+    context "with a timeout" do
+      it "includes the timeout in the 'pending_jobs' hash entry" do
+        Job.enqueue_for_approval(:approval_timeout => 10)
 
-        key = '{"id":0,"approval_message":"string test message"}'
-        value = '{"class":"Job","args":[{}]}'
+        key = '{"id":0,"approval_timeout":10}'
+        args = { :approval_key => key }
+        value = { :class => Job, :args => [args], :queue => :dummy }
+        value = Resque.encode(value)
 
         Resque.redis.hget('pending_jobs', key).should == value
       end
+
+      it "schedules the job" do
+        Resque.count_all_scheduled_jobs.should == 0
+
+        Job.enqueue_for_approval(:approval_timeout => 10)
+
+        Resque.count_all_scheduled_jobs.should == 1
+      end
+
+      it "does not add the job to the appoval queue" do
+        Job.enqueue_for_approval(:approval_timeout => 10)
+        Resque.size(:approval_required).should == 0
+      end
     end
   end
 
   describe ".approve" do
-    it "moves the job from the approval queue to its normal queue" do
+    it "calls .remove_from_pending" do
       key = '{"id":0}'
 
-      Resque.enqueue(Job, :requires_approval => true)
+      Job.should_receive(:remove_from_pending).with(key)
       Job.approve(key)
+    end
+
+    context "without a timeout" do
+      it "adds  the job to its normal queue" do
+        key = '{"id":0}'
+
+        Job.enqueue_for_approval
+        Job.approve(key)
 
-      Resque.size(:approval_required).should == 0
-      Resque.size(:dummy).should == 1
+        Resque.size(:dummy).should == 1
+      end
     end
 
-    it "deletes the entry in the 'pending_jobs' hash" do
-      key = '{"id":0}'
+    context "with a timeout" do
+      it "adds  the job to its normal queue" do
+        key = '{"id":0,"approval_timeout":10}'
 
-      Resque.enqueue(Job, :requires_approval => true)
-      Job.approve(key)
+        Job.enqueue_for_approval(:approval_timeout => 10)
+        Job.approve(key)
 
-      Resque.redis.hget('pending_jobs', key).should be_nil
+        Resque.size(:dummy).should == 1
+      end
     end
 
     it "returns false when key can not be found" do
@@ -119,35 +144,106 @@ describe "Resque::Plugins::Approval" do
   end
 
   describe ".reject" do
-    it "deletes the job from the approval queue" do
+    it "calls .remove_from_pending" do
       key = '{"id":0}'
 
-      Resque.enqueue(Job, :requires_approval => true)
+      Job.should_receive(:remove_from_pending).with(key)
       Job.reject(key)
-
-      Resque.size(:approval_required).should == 0
     end
 
     it "does not add  the job to its normal queue" do
       key = '{"id":0}'
 
-      Resque.enqueue(Job, :requires_approval => true)
+      Job.enqueue_for_approval
       Job.reject(key)
 
       Resque.size(:dummy).should == 0
     end
 
+    it "returns false when key can not be found" do
+      Job.reject('bad key').should == false
+    end
+  end
+
+  describe ".remove_from_pending" do
+    context "without a timeout" do
+      it "deletes the job from the approval queue" do
+        key = '{"id":0}'
+
+        Job.enqueue_for_approval
+        Job.remove_from_pending(key)
+
+        Resque.size(:approval_required).should == 0
+      end
+    end
+
+    context "with a timeout" do
+      it "unschedules the job" do
+        key = '{"id":0,"approval_timeout":10}'
+
+        Job.enqueue_for_approval(:approval_timeout => 10)
+
+        Resque.count_all_scheduled_jobs.should == 1
+
+        Job.remove_from_pending(key)
+
+        Resque.count_all_scheduled_jobs.should == 0
+      end
+    end
+
     it "deletes the entry in the 'pending_jobs' hash" do
       key = '{"id":0}'
 
-      Resque.enqueue(Job, :requires_approval => true)
-      Job.reject(key)
+      Job.enqueue_for_approval
+      Job.remove_from_pending(key)
 
       Resque.redis.hget('pending_jobs', key).should be_nil
     end
 
-    it "returns false when key can not be found" do
-      Job.reject('bad key').should == false
+    it "returns job when key can be found" do
+      key = '{"id":0}'
+      job = { 'class' => 'Job', 'args' => [{}] }
+
+      Job.enqueue_for_approval
+      job = Job.remove_from_pending(key).should == job
+    end
+
+    it "returns nil when key can not be found" do
+      Job.remove_from_pending('bad key').should == nil
+    end
+  end
+
+  describe ".extract_value" do
+    context "when key is a symbol" do
+      it "deletes and returns value by symbol-referenced key" do
+        hash = { :key => 1 }
+
+        Job.send(:extract_value, hash, :key).should == 1
+        hash.should == {}
+      end
+
+      it "deletes and returns value by string-referenced key" do
+        hash = { :key => 1 }
+
+        Job.send(:extract_value, hash, 'key').should == 1
+        hash.should == {}
+      end
+    end
+
+    context "when key is a string" do
+      it "deletes and returns value by symbol-referenced key" do
+        hash = { 'key' => 1 }
+
+        Job.send(:extract_value, hash, :key).should == 1
+        hash.should == {}
+      end
+
+      it "deletes and returns value by string-referenced key" do
+        hash = { 'key' => 1 }
+
+        Job.send(:extract_value, hash, 'key').should == 1
+        hash.should == {}
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,4 +1,6 @@
+require 'rspec'
 require 'resque-approval'
+require 'resque_scheduler'
 
 def start_redis
   redis_config = <<END

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-approval
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-06 00:00:00.000000000 Z
+date: 2012-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque
-  requirement: &12083540 !ruby/object:Gem::Requirement
+  requirement: &11915740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *12083540
+  version_requirements: *11915740
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &12082920 !ruby/object:Gem::Requirement
+  requirement: &11910380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *12082920
+  version_requirements: *11910380
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &12082180 !ruby/object:Gem::Requirement
+  requirement: &11908520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *12082180
+  version_requirements: *11908520
 - !ruby/object:Gem::Dependency
   name: guard
-  requirement: &12080700 !ruby/object:Gem::Requirement
+  requirement: &11907760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *12080700
+  version_requirements: *11907760
 - !ruby/object:Gem::Dependency
   name: guard-rspec
-  requirement: &12078080 !ruby/object:Gem::Requirement
+  requirement: &11907160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *12078080
+  version_requirements: *11907160
+- !ruby/object:Gem::Dependency
+  name: resque-scheduler
+  requirement: &11906580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *11906580
 description: ! "A Resque plugin allowing jobs to be sent to a temporary\n                         queue
   to await approval.  Once the job is approved, it\n                         is placed
   on its normal queue."