delayed-method 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45f6aeda084fa4a56d760f90effd7d0ff880ff4f
-  data.tar.gz: 404061f1cac27b9492f36baca111acdfe103d5dc
+  metadata.gz: 6e36ff8184489e5c0415e3ee4ce57985c10470fe
+  data.tar.gz: e210411cac14668a7aa3e5bd3ccd30f7d358da5b
 SHA512:
-  metadata.gz: 49cce6cf789b42f0de0bc9dc7a52ec1c8106f1ad79e85ee67ca950b39f2d6008d0267084cc2fad967dab093cee630dea53581071c2b8d8977541112ae7947d38
-  data.tar.gz: 3587b1c651742af294a2a840d40487bcb6abf2d5adedec69cc056ba4091831885f6e32fe5939dbdc96ee76a3b5285f8d69bde85a006f5e4fa9b89a4e14ab2866
+  metadata.gz: da3ce8966c10d57988f8fddf82851ca665885375d3dd7b96ed45252f46a93b9e5e7fc3ae91498f020bfa2cd68a3fe8687acb2674d461e088b07c591fd77258f2
+  data.tar.gz: 7d7fea6d7148b4f586aa58908391d14a71d9edff03bdf912322a7d0db6f0b0d99c77c423dfc869d23ea2322685e431b792971b30498d64400dd3b90771627c31

data/README.md

@@ -3,13 +3,13 @@ delayed-method
 
 Requires the resque gem.
 
-Allows you to move a long run method to background to be processed later by resque
+Allows you to move a long running method to background to be processed later by resque
 
-I have to come up with this because all other resque based delayed execution gem out there that I have tried is complex, buggy and doesn't work.
+I have to come up with this because all other resque based delayed execution gems out there that I have tried are complex, buggy and don't work.
 
-This delayed-method is designed to be deadly simple, doesn't hack deep into resque itself (so it is more likely to continue to work, even with further internal change of resque)
+delayed-method is designed to be dead simple, and doesn't hack deep into resque itself (so it is more likely to continue to work, even with further internal change of resque)
 
-Infact, it just rely on Resque.enqueue at the deepest level. It doesn't deal with serialization, so it won't have any problem with serialization
+In fact, it just relies on Resque.enqueue at the deepest level. It doesn't deal with serialization, so it won't have any problem with serialization
 
 Installation
 ============
@@ -22,37 +22,58 @@ Usage
 
   Given you have this long call inside your web request:
 
-Executor.long_call(arg1, arg2)
+    Executor.long_call(arg1, arg2)
 
   then you can easily move it to the delayed queue in background with this:
 
-DelayedMethod.enqueue(Executor, :long_call, arg1, arg2)
+    DelayedMethod.enqueue(Executor, :long_call, arg1, arg2)
 
   Or if you use active record model:
 
-model.long_call(arg1, arg2)
+    model.long_call(arg1, arg2)
 
   then you can easily move it to the delayed queue in background with this:
 
-DelayedMethod.enqueue(model, :long_call, arg1, arg2)
+    DelayedMethod.enqueue(model, :long_call, arg1, arg2)
 
-That's it. This is the only 2 cases that DelayedMethod will work: Caller
-need to be either a class or a persisted ActiveRecord model
+That's it. This is the only two cases where DelayedMethod will work: Caller
+needs to be either a class or a persisted ActiveRecord model
 
 If you use resque-scheduler, you can also do this:
 
-  DelayedMethod.enqueue_at(1.day.from_now, Executor, :long_call, arg1, arg2)
+    DelayedMethod.enqueue_at(1.day.from_now, Executor, :long_call, arg1, arg2)
 
 or
 
-  DelayedMethod.enqueue_at(1.day.from_now, model, :long_call, arg1, arg2)
+    DelayedMethod.enqueue_at(1.day.from_now, model, :long_call, arg1, arg2)
+
+Customize your worker
+=====================
+
+If you want to customize DelayedMethod to enforce things like having
+ActiveRecord reading from master instead of slave, you can do this:
+
+```
+   class MyCustomDelayedMethod < DelayedMethod
+     @queue = :delayed
+
+     def perform(klass_name, instance_id, method, *args)
+       wrap_method do
+         super
+       end
+     end
+   end
+
+   MyCustomDelayedMethod.enqueue(object, :method)
+```
+
 
 Warning
 ===========
 
-Please notice that Class method call and ActiveRecord instance call are the only 2 cases supported.
-Even in that case, only simple arguments (string, number) are supported.
-Using object, structure, or symbol as argument will yield unexpected result. (Symbol will be converted to String).
+Please notice that Class method call and ActiveRecord instance call are the only two cases supported.
+Even in those cases, only simple arguments (string, number) are supported.
+Using object, structure, or symbol as argument will yield unexpected results. (Symbol will be converted to String).
 
 Author
 =====

data/lib/delayed-method.rb

@@ -16,13 +16,13 @@ class DelayedMethod
 
     def enqueue(object, method, *args)
       ensure_proper_call(object, method) do |klass, id|
-        Resque.enqueue(DelayedMethod, klass, id, method, *args)
+        Resque.enqueue(self, klass, id, method, *args)
       end
     end
 
     def enqueue_to(queue, object, method, *args)
       ensure_proper_call(object, method) do |klass, id|
-        Resque.enqueue_to(queue, DelayedMethod, klass, id, method, *args)
+        Resque.enqueue_to(queue, self, klass, id, method, *args)
       end
     end
 
@@ -30,7 +30,7 @@ class DelayedMethod
     def enqueue_at(time, object, method, *args)
       ensure_proper_call(object, method) do |klass, id|
         if Resque.respond_to?(:enqueue_at)
-          Resque.enqueue_at(time, DelayedMethod, klass, id, method, *args)
+          Resque.enqueue_at(time, self, klass, id, method, *args)
         else
           raise "resque-scheduler need to be included for this to work"
         end

data/spec/delayed_method_inheritance_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'active_record'
+
+describe "DelayedMethod inheritance" do
+  describe "enqueue and perform" do
+    class CustomDelayedMethod < DelayedMethod
+      @queue = :delayed
+
+      def self.perform(*args)
+        before_hook
+        super
+        after_hook
+      end
+
+      def self.before_hook
+      end
+
+      def self.after_hook
+      end
+    end
+
+    class TestClass2
+      def self.execute(name, value)
+
+      end
+    end
+
+    context "for class object" do
+      it "queues a job to cause execution to happen" do
+        TestClass2.should_receive(:execute).with("sample", "another_sample")
+        CustomDelayedMethod.enqueue(TestClass2, :execute, "sample", "another_sample")
+        klass, args = Resque.reserve(:delayed)
+        klass.perform(*args)
+      end
+
+      it "queues CustomDelayedMethod as worker" do
+        CustomDelayedMethod.enqueue(TestClass2, :execute, "sample", "another_sample")
+        klass, args = Resque.reserve(:delayed)
+        klass.payload_class.should eq(CustomDelayedMethod)
+      end
+
+      it "executes correctly with extra hooks" do
+        CustomDelayedMethod.should_receive(:before_hook)
+        CustomDelayedMethod.should_receive(:after_hook)
+        CustomDelayedMethod.enqueue(TestClass2, :execute, "sample", "another_sample")
+        klass, args = Resque.reserve(:delayed)
+        klass.perform(*args)
+      end
+    end
+
+    context "for active record instance" do
+      it "queues a job to cause execution to happen" do
+        armodel = mock_armodel
+        armodel.should_receive(:execute).with("sample", "another_sample")
+        CustomDelayedMethod.enqueue(armodel, :execute, "sample", "another_sample")
+        klass, args = Resque.reserve(:delayed)
+        klass.perform(*args)
+      end
+
+      it "queues CustomDelayedMethod as worker" do
+        armodel = mock_armodel
+        CustomDelayedMethod.enqueue(armodel, :execute, "sample", "another_sample")
+        klass, args = Resque.reserve(:delayed)
+        klass.payload_class.should eq(CustomDelayedMethod)
+      end
+    end
+  end
+end
+
+def mock_armodel
+  mock(ActiveRecord::Base, { :id => 1, :execute => true }).tap do |armodel|
+    armodel.should_receive(:is_a?).with(Class).and_return(false)
+    armodel.should_receive(:is_a?).with(ActiveRecord::Base).and_return(true)
+    armodel.should_receive(:class).and_return ActiveRecord::Base
+    armodel.stub(:persisted?).and_return true
+    ActiveRecord::Base.stub(:find).with(1).and_return armodel
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delayed-method
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Phuong Nguyen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-11 00:00:00.000000000 Z
+date: 2019-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque
@@ -91,6 +91,7 @@ files:
 - README.md
 - Rakefile
 - lib/delayed-method.rb
+- spec/delayed_method_inheritance_spec.rb
 - spec/delayed_method_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/phuongnd08/delayed-method
@@ -112,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.6.14.3
 signing_key: 
 specification_version: 4
 summary: Allow you to quickly move a long call to background which then executed by