resque-serializer 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c585a7208430ad2238d75d959dbb0894ca294263
-  data.tar.gz: 2ea899d81f89c05a9eeb048e718c41062649c3fb
+  metadata.gz: df7981e4e3465956ef681be0515e3b132f467c92
+  data.tar.gz: beb3c0112e30f2a4d87a7e4a00cbf2b3b83a2c48
 SHA512:
-  metadata.gz: b503d44847ec2b7a699d6064ce66714f23ad7d991b5772fbc9da0816de5900a0f8dd52e3824d6fa2ee2adc3fac9913ed8889a37d18bad9539135e4fc1b8ac52a
-  data.tar.gz: 536e86f5487b7d6953e92045960844c9324d4b096809f99b6207abd0d863a377b26863321496faba45e9dd6c6e205395c7e83e98e23572c89f41534d7835b1d9
+  metadata.gz: 9d611f691cfd8fa954a57bdcdb07ba636259fc96e407b5ec4add1baafbfbf50a89ad673d0742d7a95543bc16a0baf583a36e345b97b4484e20771572b9a75f7d
+  data.tar.gz: fe4ca85898ed891dd318101cd6be87635ab141cd48eafb2261cc86702b07f168dce205f998947934905f932bb7e5207000bf9756bb970b14c6c92b6392a8d6f2

data/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,8 @@
+### Description
+A description of the changes included in this PR
+
+### Tasks
+ - [ ] Any tasks that must be completed before or after this PR
+
+### References
+ - Any Github issues or other links related to this PR

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+The noteworthy changes for each Resque::Serializer version are included here.
+For a complete changelog, see the git history for each version via the version
+links.
+
+## [0.1.0] - April 10, 2017
+
+### Initial Release
+- Initial release. Adds support for resque job serialization via four
+  strategies.
+
+[0.1.0]: https://github.com/rringler/resque-serializer/releases/tag/v0.1.0

data/lib/resque-serializer/monkey_patches/resque.rb

@@ -0,0 +1,36 @@
+module ResqueSerializer
+  module MonkeyPatches
+    module Resque
+      # NOTE: `Resque#pop` is called when working queued jobs via the
+      # `resque:work` rake task. Resque's default implementation will
+      # not trigger the `before_dequeue` or `after_dequeue` hooks;
+      # this patch will force it do so.
+      def pop(queue)
+        return unless (job_details = decode(data_store.pop_from_queue(queue)))
+        klass  = job_details['class'].safe_constantize
+        args   = job_details['args']
+
+        # Perform before_dequeue hooks. Don't perform dequeue if any hook
+        # returns false
+        # rubocop:disable Metrics/LineLength
+        before_hooks = ::Resque::Plugin.before_dequeue_hooks(klass).collect do |hook|
+          klass.send(hook, *args)
+        end
+
+        return job_details if before_hooks.any? { |result| result == false }
+
+        ::Resque::Plugin.after_dequeue_hooks(klass).each do |hook|
+          klass.send(hook, *args)
+        end
+
+        job_details
+      end
+    end
+  end
+end
+
+module Resque
+  prepend ResqueSerializer::MonkeyPatches::Resque
+
+  module_function :pop
+end

data/lib/resque-serializer/version.rb

@@ -1,7 +1,7 @@
 module Resque
   module Plugins
     module Serializer
-      VERSION = '0.1.1'
+      VERSION = '0.1.2'
     end
   end
 end

data/lib/resque-serializer.rb

@@ -1,4 +1,5 @@
 require 'resque-serializer/version'
+require 'resque-serializer/monkey_patches/resque'
 require 'resque-serializer/mutex'
 require 'resque-serializer/serializers/both'
 require 'resque-serializer/serializers/combined'

data/resque-serializer.gemspec

@@ -21,10 +21,10 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'resque'
 
   gem.add_development_dependency 'bundler', '~> 1.14'
+  gem.add_development_dependency 'bump', '~> 0.7'
   gem.add_development_dependency 'mock_redis'
   gem.add_development_dependency 'pry-byebug'
   gem.add_development_dependency 'pry-stack_explorer'
   gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'resque_spec'
   gem.add_development_dependency 'rspec', '~> 3.0'
 end

data/spec/lib/resque-serializer/monkey_patches/resque_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+class ResqueDequeueHookJob
+  extend Resque::Plugins::Serializer
+
+  serialize :both
+
+  @queue = :default
+
+  def self.perform(*args); end
+end
+
+RSpec.describe ResqueDequeueHookJob do
+  let(:args)          { %w[arg1 arg2] }
+  let(:queue_name)    { :default }
+  let(:dequeue_hooks) { [] }
+
+  before do
+    allow(Resque::Plugin)
+      .to receive(:before_dequeue_hooks)
+      .and_return(dequeue_hooks)
+    allow(Resque::Plugin)
+      .to receive(:after_dequeue_hooks)
+      .and_return(dequeue_hooks)
+    enqueue_job
+  end
+
+  it 'executes the dequeue hooks' do
+    expect(::Resque::Plugin).to receive(:before_dequeue_hooks).ordered
+    expect(::Resque::Plugin).to receive(:after_dequeue_hooks).ordered
+
+    execute_job
+  end
+end

data/spec/lib/resque-serializer/serializers/both_spec.rb

@@ -21,107 +21,64 @@ class JobSerializedByBoth
 end
 
 RSpec.describe JobSerializedByBoth do
-  let(:args) { %w(arg1 arg2) }
+  let(:args)       { %w[arg1 arg2] }
+  let(:queue_name) { :default }
 
   before do
-    ResqueSpec.reset!
     Resque.redis.redis.flushall
   end
 
-  describe 'before enqueuing the job' do
-    let(:mutex) { described_class.queue_mutex(args) }
-
-    subject(:enqueue_job) { Resque.enqueue(described_class, *args) }
-
-    context 'when a lock for the job exists' do
-      before { mutex.lock! }
-
-      it 'does not enqueue the job' do
-        expect { enqueue_job }.to_not change {
-          ResqueSpec.queue_for(described_class).size
-        }.from(0)
-      end
-
-      it 'does not unlock the mutex' do
-        expect { enqueue_job }.to_not change {
-          mutex.locked?
-        }.from(true)
-      end
+  context 'with no jobs in the queue' do
+    before do
+      expect(queue_size).to eq(0)
     end
 
-    context 'when a lock for the job does not exist' do
-      it 'enqueues the job' do
-        expect { enqueue_job }.to change {
-          ResqueSpec.queue_for(described_class).size
-        }.from(0).to(1)
-      end
-
-      it 'locks the mutex' do
-        expect { enqueue_job }.to change {
-          mutex.locked?
-        }.from(false).to(true)
-      end
+    it 'can enqueue the job' do
+      expect { enqueue_job }.to change {
+        queue_size
+      }.from(0).to(1)
     end
-  end
-
-  describe 'after dequeuing the job' do
-    let(:mutex) { described_class.queue_mutex(args) }
-
-    subject(:dequeue_job) { Resque.dequeue(described_class, *args) }
-
-    before { mutex.lock! }
 
-    it 'unlocks the mutex' do
-      expect { dequeue_job }.to change {
-        mutex.locked?
-      }.from(true).to(false)
+    it 'can not execute any jobs' do
+      expect(execute_job).to be_nil
     end
   end
 
-  describe 'before dequeuing the job' do
-    let(:mutex) { described_class.job_mutex(args) }
+  context 'with one job in the queue' do
+    before do
+      enqueue_job
+      expect(queue_size).to eq(1)
+    end
 
-    subject(:dequeue_job) { Resque.dequeue(described_class, *args) }
+    it 'cannot enqueue the same job' do
+      expect { enqueue_job }.to_not change {
+        queue_size
+      }.from(1)
+    end
 
-    it 'locks the mutex' do
-      expect { dequeue_job }.to change {
-        mutex.locked?
-      }.from(false).to(true)
+    it 'can execute the job' do
+      expect(execute_job).to_not be_nil
     end
   end
 
-  describe 'after performing the job' do
-    let(:mutex) { described_class.job_mutex(args) }
-
+  context 'with one job in the queue and one job being executed' do
     before do
-      Resque.enqueue(described_class, *args)
-      mutex.lock!
+      enqueue_job
+      expect(queue_size).to eq(1)
+      execute_job
+      expect(queue_size).to eq(0)
+      enqueue_job
+      expect(queue_size).to eq(1)
     end
 
-    subject(:perform_job) { ResqueSpec.perform_next(:default) }
-
-    context 'if the job completes successfully' do
-      it 'releases the lock after execution' do
-        expect { perform_job }.to change {
-          mutex.locked?
-        }.from(true).to(false)
-      end
+    it 'cannot enqueue the same job' do
+      expect { enqueue_job }.to_not change {
+        queue_size
+      }.from(1)
     end
 
-    context 'if the job raises an exception' do
-      let(:error) { StandardError }
-
-      before do
-        allow(described_class).to receive(:perform).and_raise(error)
-      end
-
-      it 'still releases the lock after execution' do
-        expect(mutex.locked?).to eq(true)
-
-        expect { perform_job }.to raise_error(error)
-
-        expect(mutex.locked?).to eq(false)
-      end
+    it 'can execute the job' do
+      expect(execute_job).to_not be_nil
     end
   end
 end

data/spec/lib/resque-serializer/serializers/combined_spec.rb

@@ -21,81 +21,58 @@ class JobSerializedByCombined
 end
 
 RSpec.describe JobSerializedByCombined do
-  let(:args) { %w(arg1 arg2) }
+  let(:args)       { %w[arg1 arg2] }
+  let(:queue_name) { :default }
 
   before do
-    ResqueSpec.reset!
     Resque.redis.redis.flushall
   end
 
-  describe 'before enqueuing the job' do
-    let(:mutex) { described_class.mutex(args) }
-
-    subject(:enqueue_job) { Resque.enqueue(described_class, *args) }
-
-    context 'when a lock for the job exists' do
-      before { mutex.lock! }
-
-      it 'does not enqueue the job' do
-        expect { enqueue_job }.to_not change {
-          ResqueSpec.queue_for(described_class).size
-        }.from(0)
-      end
-
-      it 'does not change the mutex' do
-        expect { enqueue_job }.to_not change {
-          mutex.locked?
-        }.from(true)
-      end
+  context 'with no jobs in the queue' do
+    before do
+      expect(queue_size).to eq(0)
     end
 
-    context 'when a lock for the job does not exist' do
-      before { mutex.unlock }
-
-      it 'enqueues the job' do
-        expect { enqueue_job }.to change {
-          ResqueSpec.queue_for(described_class).size
-        }.from(0).to(1)
-      end
-
-      it 'locks the mutex' do
-        expect { enqueue_job }.to change {
-          mutex.locked?
-        }.from(false).to(true)
-      end
+    it 'can enqueue the job' do
+      expect { enqueue_job }.to change {
+        queue_size
+      }.from(0).to(1)
     end
   end
 
-  describe 'after performing the job' do
-    let(:mutex) { described_class.mutex(args) }
-
+  context 'with one job in the queue' do
     before do
-      # Note: this locks the mutex on the :before_enqueue_* hook
-      Resque.enqueue(described_class, *args)
+      enqueue_job
+      expect(queue_size).to eq(1)
     end
 
-    subject(:perform_job) { ResqueSpec.perform_next(:default) }
-
-    context 'when the job completes successfully' do
-      it 'releases the lock after execution' do
-        expect { perform_job }.to change {
-          mutex.locked?
-        }.from(true).to(false)
-      end
+    it 'cannot enqueue the same job' do
+      expect { enqueue_job }.to_not change {
+        queue_size
+      }.from(1)
     end
 
-    context 'when the job raises an exception' do
-      let(:error) { StandardError }
-
-      before { allow(described_class).to receive(:perform).and_raise(error) }
+    it 'can execute the job' do
+      expect(execute_job).to_not be_nil
+    end
+  end
 
-      it 'still releases the lock after execution' do
-        expect(mutex.locked?).to eq(true)
+  context 'with one job in the queue and one job being executed' do
+    let(:execute_job) { worker.reserve.perform }
 
-        expect { perform_job }.to raise_error(error)
+    before do
+      enqueue_job
+      expect(queue_size).to eq(1)
+      execute_job
+      expect(queue_size).to eq(0)
+      enqueue_job
+      expect(queue_size).to eq(1)
+    end
 
-        expect(mutex.locked?).to eq(false)
-      end
+    it 'cannot enqueue the same job' do
+      expect { enqueue_job }.to_not change {
+        queue_size
+      }.from(1)
     end
   end
 end

data/spec/lib/resque-serializer/serializers/job_spec.rb

@@ -21,55 +21,60 @@ class JobSerializedByJob
 end
 
 RSpec.describe JobSerializedByJob do
-  let(:args) { %w(arg1 arg2) }
+  let(:args)       { %w[arg1 arg2] }
+  let(:queue_name) { :default }
 
   before do
-    ResqueSpec.reset!
     Resque.redis.redis.flushall
   end
 
-  describe 'before dequeuing the job' do
-    let(:mutex) { described_class.mutex(args) }
+  context 'with no jobs in the queue' do
+    before do
+      expect(queue_size).to eq(0)
+    end
 
-    subject(:dequeue_job) { Resque.dequeue(described_class, *args) }
+    it 'can enqueue the job' do
+      expect { enqueue_job }.to change {
+        queue_size
+      }.from(0).to(1)
+    end
 
-    it 'locks the mutex' do
-      expect { dequeue_job }.to change {
-        mutex.locked?
-      }.from(false).to(true)
+    it 'can not execute any jobs' do
+      expect(execute_job).to be_nil
     end
   end
 
-  describe 'after performing the job' do
-    let(:mutex) { described_class.mutex(args) }
-
+  context 'with one job in the queue' do
     before do
-      Resque.enqueue(described_class, *args)
-      mutex.lock!
+      enqueue_job
+      expect(queue_size).to eq(1)
     end
 
-    subject(:perform_job) { ResqueSpec.perform_next(:default) }
-
-    context 'when the job completes successfully' do
-      it 'releases the lock after execution' do
-        expect { perform_job }.to change {
-          mutex.locked?
-        }.from(true).to(false)
-      end
+    it 'can enqueue the same job' do
+      expect { enqueue_job }.to change {
+        queue_size
+      }.from(1).to(2)
     end
 
-    context 'when the job raises an exception' do
-      let(:error) { StandardError }
-
-      before { allow(described_class).to receive(:perform).and_raise(error) }
-
-      it 'still releases the lock after execution' do
-        expect(mutex.locked?).to eq(true)
+    it 'can execute the job' do
+      expect(execute_job).to_not be_nil
+    end
+  end
 
-        expect { perform_job }.to raise_error(error)
+  context 'with one job in the queue and one job being executed' do
+    before do
+      enqueue_job
+      expect(queue_size).to eq(1)
+      execute_job
+      expect(queue_size).to eq(0)
+      enqueue_job
+      expect(queue_size).to eq(1)
+    end
 
-        expect(mutex.locked?).to eq(false)
-      end
+    it 'can enqueue the same job' do
+      expect { enqueue_job }.to change {
+        queue_size
+      }.from(1).to(2)
     end
   end
 end

data/spec/lib/resque-serializer/serializers/queue_spec.rb

@@ -21,62 +21,64 @@ class JobSerializedByQueue
 end
 
 RSpec.describe JobSerializedByQueue do
-  let(:args) { %w(arg1 arg2) }
+  let(:args)       { %w[arg1 arg2] }
+  let(:queue_name) { :default }
 
   before do
-    ResqueSpec.reset!
     Resque.redis.redis.flushall
   end
 
-  describe 'before enqueuing the job' do
-    let(:mutex) { described_class.mutex(args) }
-
-    subject(:enqueue_job) { Resque.enqueue(described_class, *args) }
-
-    context 'when a lock for the job exists' do
-      before { mutex.lock! }
+  context 'with no jobs in the queue' do
+    before do
+      expect(queue_size).to eq(0)
+    end
 
-      it 'does not enqueue the job' do
-        expect { enqueue_job }.to_not change {
-          ResqueSpec.queue_for(described_class).size
-        }.from(0)
-      end
+    it 'can enqueue the job' do
+      expect { enqueue_job }.to change {
+        queue_size
+      }.from(0).to(1)
+    end
 
-      it 'does not change the mutex' do
-        expect { enqueue_job }.to_not change {
-          mutex.locked?
-        }.from(true)
-      end
+    it 'can not execute any jobs' do
+      expect(execute_job).to be_nil
     end
+  end
 
-    context 'when a lock for the job does not exist' do
-      before { mutex.unlock }
+  context 'with one job in the queue' do
+    before do
+      enqueue_job
+      expect(queue_size).to eq(1)
+    end
 
-      it 'enqueues the job' do
-        expect { enqueue_job }.to change {
-          ResqueSpec.queue_for(described_class).size
-        }.from(0).to(1)
-      end
+    it 'cannot enqueue the same job' do
+      expect { enqueue_job }.to_not change {
+        queue_size
+      }.from(1)
+    end
 
-      it 'locks the mutex' do
-        expect { enqueue_job }.to change {
-          mutex.locked?
-        }.from(false).to(true)
-      end
+    it 'can execute the job' do
+      expect(execute_job).to_not be_nil
     end
   end
 
-  describe 'after dequeuing the job' do
-    let(:mutex) { described_class.mutex(args) }
-
-    subject(:dequeue_job) { Resque.dequeue(described_class, *args) }
+  context 'with one job in the queue and one job being executed' do
+    before do
+      enqueue_job
+      expect(queue_size).to eq(1)
+      execute_job
+      expect(queue_size).to eq(0)
+      enqueue_job
+      expect(queue_size).to eq(1)
+    end
 
-    before { mutex.lock! }
+    it 'cannot enqueue the same job' do
+      expect { enqueue_job }.to_not change {
+        queue_size
+      }.from(1)
+    end
 
-    it 'unlocks the mutex' do
-      expect { dequeue_job }.to change {
-        mutex.locked?
-      }.from(true).to(false)
+    it 'can execute the job' do
+      expect(execute_job).to_not be_nil
     end
   end
 end

data/spec/resque_test_helper.rb

@@ -0,0 +1,17 @@
+module ResqueTestHelper
+  def enqueue_job
+    Resque.enqueue(described_class, *args)
+  end
+
+  def queue_size
+    Resque.size(queue_name)
+  end
+
+  def worker
+    Resque::Worker.new(queue_name)
+  end
+
+  def execute_job
+    worker.reserve
+  end
+end

data/spec/spec_helper.rb

@@ -3,8 +3,8 @@ require 'resque-serializer'
 require 'bundler/setup'
 require 'mock_redis'
 require 'resque'
-require 'resque_spec'
 require 'pry-byebug'
+require 'resque_test_helper'
 
 RSpec.configure do |config|
   config.expect_with(:rspec) do |c|
@@ -14,4 +14,6 @@ RSpec.configure do |config|
   config.before(:suite) do
     Resque.redis = MockRedis.new
   end
+
+  config.include ResqueTestHelper
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: resque-serializer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Ryan Ringler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-10 00:00:00.000000000 Z
+date: 2018-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -53,21 +53,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.14'
 - !ruby/object:Gem::Dependency
-  name: mock_redis
+  name: bump
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
 - !ruby/object:Gem::Dependency
-  name: pry-byebug
+  name: mock_redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -81,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry-stack_explorer
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -95,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: pry-stack_explorer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -109,7 +109,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: resque_spec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -146,9 +146,11 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/PULL_REQUEST_TEMPLATE.md"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -156,6 +158,7 @@ files:
 - bin/console
 - bin/setup
 - lib/resque-serializer.rb
+- lib/resque-serializer/monkey_patches/resque.rb
 - lib/resque-serializer/mutex.rb
 - lib/resque-serializer/serializers/both.rb
 - lib/resque-serializer/serializers/combined.rb
@@ -163,11 +166,13 @@ files:
 - lib/resque-serializer/serializers/queue.rb
 - lib/resque-serializer/version.rb
 - resque-serializer.gemspec
+- spec/lib/resque-serializer/monkey_patches/resque_spec.rb
 - spec/lib/resque-serializer/mutex_spec.rb
 - spec/lib/resque-serializer/serializers/both_spec.rb
 - spec/lib/resque-serializer/serializers/combined_spec.rb
 - spec/lib/resque-serializer/serializers/job_spec.rb
 - spec/lib/resque-serializer/serializers/queue_spec.rb
+- spec/resque_test_helper.rb
 - spec/spec_helper.rb
 homepage: https://github.com/rringler/resque-serializer
 licenses:
@@ -189,14 +194,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.6.14.1
 signing_key: 
 specification_version: 4
 summary: Serializes Resque jobs
 test_files:
+- spec/lib/resque-serializer/monkey_patches/resque_spec.rb
 - spec/lib/resque-serializer/mutex_spec.rb
 - spec/lib/resque-serializer/serializers/both_spec.rb
 - spec/lib/resque-serializer/serializers/combined_spec.rb
 - spec/lib/resque-serializer/serializers/job_spec.rb
 - spec/lib/resque-serializer/serializers/queue_spec.rb
+- spec/resque_test_helper.rb
 - spec/spec_helper.rb