resque-serializer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea193acc18e7717c6a3f990c82ef5d31d9682219
+  data.tar.gz: 40d82f79180b84382efdddf99a7f4fa998127487
+SHA512:
+  metadata.gz: 21271809497bc8c8ece3344fc7f9e351b9b9ea18653f2565e0518cee8ee349df96d9dd69fb728c34f3dc3be682da9527bb0685b1d56f493477884cac3f1516bc
+  data.tar.gz: cd46348ba7b8481816cae2fabd904c8fe06925fc8ccbf2462650aedf49e9819841d6244960e3c8d2433f4c246bff14e42dc67e10995ceb851b760176e07a8b8c

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+# Misc
+.DS_Store

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.3
+before_install: gem install bundler -v 1.14.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in resque-serializer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Ryan Ringler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,140 @@
+# Resque::Serializer
+
+A Resque plugin which ensures for a given queue, that only one worker is executing a job at any given time.
+
+It is slightly more flexible than [Resque::LonelyJob](https://github.com/wallace/resque-lonely_job).
+
+This gem may be helpful to avoid database lock contention.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'resque-serializer'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install resque-serializer
+
+
+## Usage
+
+### TLDR
+```
+|  Lock Lifetime | :queue | :job  | :both  | :combined |
+| -------------: | :----: | :---: | :----: | :-------: |
+| before_enqueue |    ✓   |       |  ✓     |     ✓     |
+|        enqueue |    |   |       |  |     |     |     |
+|  after_enqueue |    |   |       |  |     |     |     |
+| before_dequeue |    |   |   ✓   |  |  ✓  |     |     |
+|        dequeue |    |   |   |   |  |  |  |     |     |
+|  after_dequeue |    ✗   |   |   |  ✗  |  |     |     |
+| before_perform |        |   |   |     |  |     |     |
+|        perform |        |   |   |     |  |     |     |
+|  after_perform |        |   ✗   |     ✗  |     ✗     |
+```
+
+### Example #1 -- Serializing the queue
+
+```ruby
+require 'resque-serializer'
+
+class SerializedJob
+  extend Resque::Plugins::Serializer
+
+  @queue = :default
+
+  serialize :queue
+
+  def self.perform
+    # work
+  end
+end
+```
+
+Only one of job with identical arguments will be allowed to be queued at a time. As soon as the job is dequeued to begin executing, an identical job may be queued (and may begin executing.)
+
+
+### Example #2 -- Serializing the job
+
+```ruby
+require 'resque-serializer'
+
+class SerializedJob
+  extend Resque::Plugins::Serializer
+
+  @queue = :default
+
+  serialize :job
+
+  def self.perform
+    # work
+  end
+end
+```
+
+Any number of these jobs may be queued, but only one job with identical arguments will be executed at a time. As soon as the executing job is completed, another queued job may be dequeued to execute.
+
+
+### Example #3 -- Serializing both the queue & job (independently)
+
+```ruby
+require 'resque-serializer'
+
+class SerializedJob
+  extend Resque::Plugins::Serializer
+
+  @queue = :default
+
+  serialize :both
+
+  def self.perform
+    # work
+  end
+end
+```
+
+A combination of the first two examples; both the queue and the execution of identical jobs is serialized (independently.) An additional job may be queued if no identical job exists in the queue. Similarly, an additional job may begin executing if no identical job is currently executing.
+
+
+### Example #4 -- Serializing both the queue & job (combined)
+
+```ruby
+require 'resque-serializer'
+
+class SerializedJob
+  extend Resque::Plugins::Serializer
+
+  @queue = :default
+
+  serialize :combined
+
+  def self.perform
+    # work
+  end
+end
+```
+
+Also a combination of the first two examples; both the queue and execution of identical jobs is serialized (together.) An additional job may not be queued if an identical job exists in the queue or execution.
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'resque/serializer'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/resque-serializer/mutex.rb

@@ -0,0 +1,46 @@
+require 'active_support/core_ext/numeric/time'
+
+module Resque
+  module Plugins
+    module Serializer
+      class Mutex
+        class LockFailed < StandardError; end
+
+        attr_reader :key, :ttl
+
+        delegate :redis,
+          to: Resque
+
+        def initialize(key, ttl: 5.minutes)
+          @key = key
+          @ttl = ttl.to_i
+        end
+
+        def lock
+          !!redis.set(key, true, set_options)
+        end
+
+        def lock!
+          !!redis.set(key, true, set_options) || fail(LockFailed)
+        end
+
+        def locked?
+          !!redis.get(key)
+        end
+
+        def unlock
+          !!redis.del(key)
+        end
+
+        private
+
+        def set_options
+          {
+            nx: true,
+            px: ttl * 1000 # msecs
+          }
+        end
+      end
+    end
+  end
+end

data/lib/resque-serializer/serializers/both.rb

@@ -0,0 +1,62 @@
+module Resque
+  module Plugins
+    module Serializer
+      module Serializers
+        module Both
+
+          # before_enqueue: ✓
+          #        enqueue: |
+          #  after_enqueue: |
+          # before_dequeue: | ✓
+          #        dequeue: | |
+          #  after_dequeue: ✗ |
+          # before_perform:   |
+          #        perform:   |
+          #  after_perform:   ✗
+
+          def before_enqueue_set_queue_lock(*args)
+            queue_mutex(args).lock
+          end
+
+          def before_dequeue_set_job_lock(*args)
+            job_mutex(args).lock
+          end
+
+          def after_dequeue_clear_queue_lock(*args)
+            queue_mutex(args).unlock
+          end
+
+          def around_perform_clear_job_lock(*args)
+            yield
+          ensure
+            job_mutex(args).unlock
+          end
+
+          def queue_mutex(args)
+            Serializer::Mutex.new(queue_key(args))
+          end
+
+          def job_mutex(args)
+            Serializer::Mutex.new(job_key(args))
+          end
+
+          private
+
+          def queue_key(args)
+            klass = self.name.tableize.singularize
+            args  = args.map(&:to_s).join(',')
+
+            "resque-serializer:queue:#{klass}:#{args}"
+          end
+
+          def job_key(args)
+            klass = self.name.tableize.singularize
+            args  = args.map(&:to_s).join(',')
+
+            "resque-serializer:job:#{klass}:#{args}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resque-serializer/serializers/combined.rb

@@ -0,0 +1,43 @@
+module Resque
+  module Plugins
+    module Serializer
+      module Serializers
+        module Combined
+
+          # before_enqueue: ✓
+          #        enqueue: |
+          #  after_enqueue: |
+          # before_dequeue: |
+          #        dequeue: |
+          #  after_dequeue: |
+          # before_perform: |
+          #        perform: |
+          #  after_perform: ✗
+
+          def before_enqueue_set_lock(*args)
+            mutex(args).lock
+          end
+
+          def around_perform_clear_lock(*args)
+            yield
+          ensure
+            mutex(args).unlock
+          end
+
+          def mutex(args)
+            Serializer::Mutex.new(key(args))
+          end
+
+          private
+
+          def key(args)
+            klass = self.name.tableize.singularize
+            args  = args.map(&:to_s).join(',')
+
+            "resque-serializer:#{klass}:#{args}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resque-serializer/serializers/job.rb

@@ -0,0 +1,43 @@
+module Resque
+  module Plugins
+    module Serializer
+      module Serializers
+        module Job
+
+          # before_enqueue:
+          #        enqueue:
+          #  after_enqueue:
+          # before_dequeue: ✓
+          #        dequeue: |
+          #  after_dequeue: |
+          # before_perform: |
+          #        perform: |
+          #  after_perform: ✗
+
+          def before_dequeue_set_lock(*args)
+            mutex(args).lock
+          end
+
+          def around_perform_clear_lock(*args)
+            yield
+          ensure
+            mutex(args).unlock
+          end
+
+          def mutex(args)
+            Serializer::Mutex.new(key(args))
+          end
+
+          private
+
+          def key(args)
+            klass = self.name.tableize.singularize
+            args  = args.map(&:to_s).join(',')
+
+            "resque-serializer:#{klass}:#{args}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resque-serializer/serializers/queue.rb

@@ -0,0 +1,41 @@
+module Resque
+  module Plugins
+    module Serializer
+      module Serializers
+        module Queue
+
+          # before_enqueue: ✓
+          #        enqueue: |
+          #  after_enqueue: |
+          # before_dequeue: |
+          #        dequeue: |
+          #  after_dequeue: ✗
+          # before_perform:
+          #        perform:
+          #  after_perform:
+
+          def before_enqueue_set_lock(*args)
+            mutex(args).lock
+          end
+
+          def after_dequeue_clear_lock(*args)
+            mutex(args).unlock
+          end
+
+          def mutex(args)
+            Serializer::Mutex.new(key(args))
+          end
+
+          private
+
+          def key(args)
+            klass = self.name.tableize.singularize
+            args  = args.map(&:to_s).join(',')
+
+            "resque-serializer:#{klass}:#{args}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resque-serializer/version.rb

@@ -0,0 +1,7 @@
+module Resque
+  module Plugins
+    module Serializer
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/resque-serializer.rb

@@ -0,0 +1,32 @@
+require 'resque-serializer/version'
+require 'resque-serializer/mutex'
+require 'resque-serializer/serializers/both'
+require 'resque-serializer/serializers/combined'
+require 'resque-serializer/serializers/job'
+require 'resque-serializer/serializers/queue'
+
+module Resque
+  module Plugins
+    module Serializer
+      def serialize(resource)
+        case resource
+        when :job      then extend(Serializers::Job)
+        when :queue    then extend(Serializers::Queue)
+        when :both     then extend(Serializers::Both)
+        when :combined then extend(Serializers::Combined)
+        else                raise_invalid_resource
+        end
+      end
+
+      private
+
+      def raise_invalid_resource
+        error_msg = begin
+          'The passed argument must be one of: [:job, :queue, :both, :combined]'
+        end
+
+        raise ArgumentError, error_msg
+      end
+    end
+  end
+end

data/resque-serializer.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+require File.expand_path('../lib/resque-serializer/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'resque-serializer'
+  gem.version       = Resque::Plugins::Serializer::VERSION
+  gem.authors       = ['Ryan Ringler']
+  gem.email         = ['rringler@gmail.com']
+
+  gem.summary       = 'Serializes Resque jobs'
+  gem.description   = 'Ensures that only one Resque job with unique arguments is running at a time.'
+  gem.homepage      = 'https://github.com/rringler/resque-serializer'
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'activesupport'
+  gem.add_dependency 'resque'
+
+  gem.add_development_dependency 'bundler', '~> 1.14'
+  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/mutex_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Resque::Plugins::Serializer::Mutex do
+  let(:redis) { Resque.redis }
+
+  describe 'instance methods' do
+    describe '#lock' do
+      let(:key)     { 'key' }
+      let(:options) { {} }
+      let(:mutex)   { described_class.new(key, options) }
+
+      subject(:lock) { mutex.lock }
+
+      it 'calls redis#set with the correct arguments' do
+        default_ttl = 5.minutes
+
+        expect(redis).to receive(:set).with(
+          key,
+          true,
+          nx: true,
+          px: default_ttl.to_i * 1000
+        ).and_return(true)
+
+        lock
+      end
+
+      context 'when the lock gets set' do
+        before { allow(redis).to receive(:set).and_return(true) }
+
+        it 'returns true' do
+          expect(lock).to eq(true)
+        end
+      end
+
+      context 'when the lock does not get set' do
+        before { allow(redis).to receive(:set).and_return(false) }
+
+        it 'returns false' do
+          expect(lock).to eq(false)
+        end
+      end
+    end
+
+    describe '#lock!' do
+      let(:key)     { 'key' }
+      let(:options) { {} }
+      let(:mutex)   { described_class.new(key, options) }
+
+      subject(:lock!) { mutex.lock! }
+
+      it 'calls redis#set with the correct arguments' do
+        default_ttl = 5.minutes
+
+        expect(redis).to receive(:set).with(
+          key,
+          true,
+          nx: true,
+          px: default_ttl.to_i * 1000
+        ).and_return(true)
+
+        lock!
+      end
+
+      context 'when the lock gets set' do
+        before { allow(redis).to receive(:set).and_return(true) }
+
+        it 'returns true' do
+          expect(lock!).to eq(true)
+        end
+      end
+
+      context 'when the lock does not get set' do
+        let(:error) { described_class::LockFailed }
+
+        before { allow(redis).to receive(:set).and_raise(error) }
+
+        it 'raises a Mutex::LockFailed error' do
+          expect { lock! }.to raise_error(error)
+        end
+      end
+    end
+
+    describe '#unlock' do
+      let(:key)   { 'key' }
+      let(:mutex) { described_class.new(key) }
+
+      subject(:unlock) { mutex.unlock }
+
+      it 'calls redis#del with its key' do
+        expect(redis).to receive(:del).with(key)
+        unlock
+      end
+
+      it 'returns true' do
+        expect(unlock).to eq(true)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+class JobSerializedByBoth
+  extend Resque::Plugins::Serializer
+
+  @queue = :default
+
+  serialize :both
+
+  # before_enqueue: ✓
+  #        enqueue: |
+  #  after_enqueue: |
+  # before_dequeue: | ✓
+  #        dequeue: | |
+  #  after_dequeue: ✗ |
+  # before_perform:   |
+  #        perform:   |
+  #  after_perform:   ✗
+
+  def self.perform(*args); end
+end
+
+RSpec.describe JobSerializedByBoth do
+  let(:args) { %w(arg1 arg2) }
+
+  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
+    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
+    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)
+    end
+  end
+
+  describe 'before dequeuing the job' do
+    let(:mutex) { described_class.job_mutex(args) }
+
+    subject(:dequeue_job) { Resque.dequeue(described_class, *args) }
+
+    it 'locks the mutex' do
+      expect { dequeue_job }.to change {
+        mutex.locked?
+      }.from(false).to(true)
+    end
+  end
+
+  describe 'after performing the job' do
+    let(:mutex) { described_class.job_mutex(args) }
+
+    before do
+      Resque.enqueue(described_class, *args)
+      mutex.lock!
+    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
+    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
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+class JobSerializedByCombined
+  extend Resque::Plugins::Serializer
+
+  @queue = :default
+
+  serialize :combined
+
+  # before_enqueue: ✓
+  #        enqueue: |
+  #  after_enqueue: |
+  # before_dequeue: |
+  #        dequeue: |
+  #  after_dequeue: |
+  # before_perform: |
+  #        perform: |
+  #  after_perform: ✗
+
+  def self.perform(*args); end
+end
+
+RSpec.describe JobSerializedByCombined do
+  let(:args) { %w(arg1 arg2) }
+
+  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
+    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
+    end
+  end
+
+  describe 'after performing the job' do
+    let(:mutex) { described_class.mutex(args) }
+
+    before do
+      # Note: this locks the mutex on the :before_enqueue_* hook
+      Resque.enqueue(described_class, *args)
+    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
+    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)
+
+        expect { perform_job }.to raise_error(error)
+
+        expect(mutex.locked?).to eq(false)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+class JobSerializedByJob
+  extend Resque::Plugins::Serializer
+
+  @queue = :default
+
+  serialize :job
+
+  # before_enqueue:
+  #        enqueue:
+  #  after_enqueue:
+  # before_dequeue: ✓
+  #        dequeue: |
+  #  after_dequeue: |
+  # before_perform: |
+  #        perform: |
+  #  after_perform: ✗
+
+  def self.perform(*args); end
+end
+
+RSpec.describe JobSerializedByJob do
+  let(:args) { %w(arg1 arg2) }
+
+  before do
+    ResqueSpec.reset!
+    Resque.redis.redis.flushall
+  end
+
+  describe 'before dequeuing the job' do
+    let(:mutex) { described_class.mutex(args) }
+
+    subject(:dequeue_job) { Resque.dequeue(described_class, *args) }
+
+    it 'locks the mutex' do
+      expect { dequeue_job }.to change {
+        mutex.locked?
+      }.from(false).to(true)
+    end
+  end
+
+  describe 'after performing the job' do
+    let(:mutex) { described_class.mutex(args) }
+
+    before do
+      Resque.enqueue(described_class, *args)
+      mutex.lock!
+    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
+    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)
+
+        expect { perform_job }.to raise_error(error)
+
+        expect(mutex.locked?).to eq(false)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+class JobSerializedByQueue
+  extend Resque::Plugins::Serializer
+
+  @queue = :default
+
+  serialize :queue
+
+  # before_enqueue: ✓
+  #        enqueue: |
+  #  after_enqueue: |
+  # before_dequeue: |
+  #        dequeue: |
+  #  after_dequeue: ✗
+  # before_perform:
+  #        perform:
+  #  after_perform:
+
+  def self.perform(*args); end
+end
+
+RSpec.describe JobSerializedByQueue do
+  let(:args) { %w(arg1 arg2) }
+
+  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
+    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
+    end
+  end
+
+  describe 'after dequeuing the job' do
+    let(:mutex) { described_class.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)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'resque-serializer'
+
+require 'bundler/setup'
+require 'mock_redis'
+require 'resque'
+require 'resque_spec'
+require 'pry-byebug'
+
+RSpec.configure do |config|
+  config.expect_with(:rspec) do |c|
+    c.syntax = :expect
+  end
+
+  config.before(:suite) do
+    Resque.redis = MockRedis.new
+  end
+end

metadata

@@ -0,0 +1,202 @@
+--- !ruby/object:Gem::Specification
+name: resque-serializer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ryan Ringler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: mock_redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-stack_explorer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: resque_spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Ensures that only one Resque job with unique arguments is running at
+  a time.
+email:
+- rringler@gmail.com
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/resque-serializer.rb
+- lib/resque-serializer/mutex.rb
+- lib/resque-serializer/serializers/both.rb
+- lib/resque-serializer/serializers/combined.rb
+- lib/resque-serializer/serializers/job.rb
+- lib/resque-serializer/serializers/queue.rb
+- lib/resque-serializer/version.rb
+- resque-serializer.gemspec
+- 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/spec_helper.rb
+homepage: https://github.com/rringler/resque-serializer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Serializes Resque jobs
+test_files:
+- 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/spec_helper.rb