sidekiq-activerecord 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+*.idea

data/.rspec

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

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,67 @@
+PATH
+  remote: .
+  specs:
+    sidekiq-activerecord (0.0.1)
+      activerecord (~> 4.1.1)
+      sidekiq (>= 2.16.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.1.1)
+      activesupport (= 4.1.1)
+      builder (~> 3.1)
+    activerecord (4.1.1)
+      activemodel (= 4.1.1)
+      activesupport (= 4.1.1)
+      arel (~> 5.0.0)
+    activesupport (4.1.1)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    arel (5.0.1.20140414130214)
+    builder (3.2.2)
+    celluloid (0.15.2)
+      timers (~> 1.1.0)
+    connection_pool (2.0.0)
+    database_cleaner (1.2.0)
+    diff-lcs (1.2.5)
+    factory_girl (4.2.0)
+      activesupport (>= 3.0.0)
+    i18n (0.6.9)
+    json (1.8.1)
+    minitest (5.3.4)
+    redis (3.0.7)
+    redis-namespace (1.4.1)
+      redis (~> 3.0.4)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.8)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.6)
+    sidekiq (3.0.2)
+      celluloid (>= 0.15.2)
+      connection_pool (>= 2.0.0)
+      json
+      redis (>= 3.0.6)
+      redis-namespace (>= 1.3.1)
+    sqlite3 (1.3.9)
+    thread_safe (0.3.3)
+    timers (1.1.0)
+    tzinfo (1.1.0)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  database_cleaner (~> 1.2.0)
+  factory_girl (~> 4.0)
+  rspec (>= 2.14)
+  sidekiq-activerecord!
+  sqlite3 (~> 1.3.9)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Adam Farhi
+
+MIT License
+
+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,117 @@
+# Sidekiq::Activerecord
+
+Encapsulates various interactions between Sidekiq and ActiveRecord.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sidekiq-activerecord'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sidekiq-activerecord
+
+# Usage
+
+If you've been using Sidekiq for a while, you've probably noticed a recurring pattern in your workers;
+
+## Child-Parent Workers
+A parent worker which goes over some model collection and enqueues a child worker for each model in the collection.
+
+```ruby
+class ParentWorker
+  include Sidekiq::Worker
+
+  def perform
+    User.active.each do |user|
+      ChildWorker.perform_async(user.id)
+    end
+  end
+
+end
+```
+
+## Sidekiq::ManagerWorker - Example
+
+```ruby
+class UserTaskWorker
+  include Sidekiq::TaskWorker
+end
+
+class UserSyncer
+  include Sidekiq::ManagerWorker
+
+  sidekiq_delegate_task_to :user_task_worker # or UserTaskWorker
+  sidekiq_manager_options :batch_size => 500,
+                          :identifier_key => :user_token,
+                          :additional_keys => [:status]
+end
+
+UserSyncer.perform_query_async(User.active, :batch_size => 300)
+```
+
+## Model Task Workers
+
+A worker which gets a model.id (like ChildWorker above) loads it, validates it and runs some logic on the model.
+
+```ruby
+class ModelTaskWorker
+  include Sidekiq::Worker
+
+  def perform(user_id)
+    user = User.find(user_id)
+    return unless user.present?
+    return unless user.active?
+
+    UserService.run(user)
+  end
+
+end
+```
+
+## Sidekiq::TaskWorker - Example
+
+```ruby
+class UserMailerTaskWorker
+  include Sidekiq::TaskWorker
+
+  sidekiq_task_model :user_model # or UserModel
+  sidekiq_task_options :identifier_key => :token
+
+  def perform_on_model(user, email_type)
+    UserMailer.deliver_registration_confirmation(user, email_type)
+  end
+
+  # optional
+  def not_found_model(token)
+    Log.error "User not found for token:#{token}"
+  end
+
+  # optional
+  def model_valid?(user)
+    user.active?
+  end
+
+  # optional
+  def invalid_model(user)
+    Log.error "User #{user.token} is invalid"
+  end
+
+end
+
+
+UserMailerTaskWorker.perform(user.id, :new_email)
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/sidekiq-activerecord/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/sidekiq/activerecord/version.rb

@@ -0,0 +1,5 @@
+module Sidekiq
+  module Activerecord
+    VERSION = "0.0.1"
+  end
+end

data/lib/sidekiq/activerecord.rb

@@ -0,0 +1,10 @@
+
+# gems
+require 'sidekiq'
+require 'active_record'
+
+require "sidekiq/activerecord/version"
+
+# internal
+require 'sidekiq/task_worker'
+require 'sidekiq/manager_worker'

data/lib/sidekiq/manager_worker.rb

@@ -0,0 +1,144 @@
+module Sidekiq
+  module ManagerWorker
+    extend Sidekiq::Worker
+
+    DEFAULT_IDENTIFIER_KEY = :id
+    DEFAULT_BATCH_SIZE = 1000
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.class_attribute :sidekiq_manager_options_hash
+    end
+
+    module ClassMethods
+
+      # For a given model collection, it delegates each model to a sub-worker (e.g TaskWorker)
+      # Specify the TaskWoker with the `sidekiq_delegate_task_to` method.
+      #
+      # @param models_query ActiveRecord::Relation
+      # @param options Hash
+      #   :worker_class - the worker class to delegate the task to. Alternative to the default `sidekiq_delegate_task_to`
+      #   :identifier_key - the model identifier column. Default 'id'
+      #   :additional_keys - additional model keys
+      #   :batch_size - Specifies the size of the batch. Default to 1000.
+      #
+      # @example:
+      #   class UserTaskWorker
+      #     include Sidekiq::TaskWorker
+      #   end
+      #
+      #   class UserSyncer
+      #     include Sidekiq::ManagerWorker
+      #
+      #     sidekiq_delegate_task_to :user_task_worker # or UserTaskWorker
+      #     sidekiq_manager_options :batch_size => 500,
+      #                             :identifier_key => :user_token,
+      #                             :additional_keys => [:status]
+      #   end
+      #
+      #   UserSyncer.perform_query_async(User.active, :batch_size => 300)
+      #
+      #
+      # is equivalent to doing:
+      #   User.active.each {|user| UserTaskWorker.peform(user.id) }
+      #
+      def perform_query_async(models_query, options={})
+        set_runtime_options(options)
+        models = models_query.select(selected_attributes)
+        models.find_in_batches(batch_size: batch_size) do |models_batch|
+          model_attributes = models_batch.map { |model| model_attributes(model) }
+          Sidekiq::Client.push_bulk('class' => worker_class, 'args' => model_attributes)
+        end
+        # set_runtime_options(nil)
+      end
+
+      # @required
+      # The task worker to delegate to.
+      # @param worker_klass (Sidekiq::Worker, Symbol) - UserTaskWorker or :user_task_worker
+      def sidekiq_delegate_task_to(worker_klass)
+        if worker_klass.is_a?(String) or is_a?(Symbol)
+          worker_klass.to_s.split('_').collect(&:capitalize).join.constantize
+        else
+          worker_klass
+        end
+        self.get_sidekiq_manager_options[:worker_class] = worker_klass
+      end
+
+      # Allows customization for this type of ManagerWorker.
+      # Legal options:
+      #
+      #   :worker_class - the worker class to delegate the task to. Alternative to `sidekiq_delegate_task_to`
+      #   :identifier_key - the model identifier column. Default 'id'
+      #   :additional_keys - additional model keys
+      #   :batch_size - Specifies the size of the batch. Default to 1000.
+      def sidekiq_manager_options(opts={})
+        self.sidekiq_manager_options_hash = get_sidekiq_manager_options.merge((opts || {}).symbolize_keys!)
+      end
+
+
+      # private
+
+      def default_worker_manager_options
+        {
+            :identifier_key => DEFAULT_IDENTIFIER_KEY,
+            :additional_keys => [],
+            :worker_class => nil,
+            :batch_size => DEFAULT_BATCH_SIZE,
+        }
+      end
+
+      # returns the model attributes array:
+      # [model_id, attr1, attr2, ...]
+      def model_attributes(model)
+        additional_attributes = additional_keys.map { |key| model.send(key) }
+        id_attribute = model.send(identifier_key)
+        additional_attributes.unshift(id_attribute)
+      end
+
+      def selected_attributes
+        attrs = [identifier_key, additional_keys]
+        attrs << DEFAULT_IDENTIFIER_KEY unless default_identifier? # :id must be included
+        attrs
+      end
+
+      def worker_class
+        raise NotImplementedError.new('`worker_class` was not specified') unless manager_options[:worker_class].present?
+        manager_options[:worker_class]
+      end
+
+      def default_identifier?
+        identifier_key == DEFAULT_IDENTIFIER_KEY
+      end
+
+      def identifier_key
+        manager_options[:identifier_key]
+      end
+
+      def additional_keys
+        manager_options[:additional_keys]
+      end
+
+      def batch_size
+        manager_options[:batch_size]
+      end
+
+      def manager_options
+        self.get_sidekiq_manager_options.merge(runtime_options)
+      end
+
+      def get_sidekiq_manager_options
+        self.sidekiq_manager_options_hash ||= default_worker_manager_options
+      end
+
+      def runtime_options
+        @sidekiq_manager_runtime_options || {}
+      end
+
+      def set_runtime_options(options)
+        options = options.delete_if { |k, v| v.nil? } if options.present?
+        @sidekiq_manager_runtime_options = options
+      end
+
+    end
+  end
+end

data/lib/sidekiq/task_worker.rb

@@ -0,0 +1,117 @@
+module Sidekiq
+  module TaskWorker
+    extend Sidekiq::Worker
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.class_attribute :sidekiq_task_options_hash
+    end
+
+    module ClassMethods
+
+      # @example:
+      #   class UserMailerTaskWorker
+      #     include Sidekiq::TaskWorker
+      #
+      #     sidekiq_task_model :user_model # or UserModel
+      #     sidekiq_task_options :identifier_key => :token
+      #
+      #     def perform_on_model(user, email_type)
+      #       UserMailer.deliver_registration_confirmation(user, email_type)
+      #     end
+      #
+      #     def not_found_model(token)
+      #       Log.error "User not found for token:#{token}"
+      #     end
+      #
+      #     def model_valid?(user)
+      #       user.active?
+      #     end
+      #
+      #     def invalid_model(user)
+      #       Log.error "User #{user.token} is invalid"
+      #     end
+      #
+      #   end
+      #
+      #
+      #   UserMailerTaskWorker.perform(user.id, :new_email)
+      #
+      def perform(identifier, *args)
+        model = fetch_model(identifier)
+        return not_found_model(identifier) unless model.present?
+
+        if model_valid?(model)
+          perform_on_model(model, *args)
+        else
+          invalid_model(model)
+        end
+      end
+
+      def sidekiq_task_model(model_klass)
+        if model_klass.is_a?(String) or model_klass.is_a?(Symbol)
+          model_klass = model_klass.to_s.split('_').collect(&:capitalize).join.constantize
+        else
+          model_klass
+        end
+        self.get_sidekiq_task_options[:model_class] = model_klass
+      end
+
+      def perform_on_model(model)
+        model
+      end
+
+      # recheck the if one of the items is still valid
+      def model_valid?(model)
+        true
+      end
+
+      # Hook to handel an invalid model
+      def invalid_model(model)
+      end
+
+      # Hook to handel not found model
+      def not_found_model(identifier)
+      end
+
+      
+      # private
+
+      def fetch_model(identifier)
+        model_class.find_by(identifier_key => identifier)
+      end
+
+      def model_class
+        klass = self.get_sidekiq_task_options[:model_class]
+        raise NotImplementedError.new('`model_class` was not specified') unless klass.present?
+        klass
+      end
+
+      def identifier_key
+        self.get_sidekiq_task_options[:identifier_key]
+      end
+
+      #
+      # Allows customization for this type of TaskWorker.
+      # Legal options:
+      #
+      #   :identifier_key - the model identifier column. Default 'id'
+      def sidekiq_task_options(opts={})
+        self.sidekiq_task_options_hash = get_sidekiq_task_options.merge((opts || {}).symbolize_keys!)
+      end
+
+      def get_sidekiq_task_options
+        self.sidekiq_task_options_hash ||= default_worker_task_options
+      end
+
+      def default_worker_task_options
+        {
+            :identifier_key => :id,
+            :model_class => nil
+        }
+      end
+
+    end
+
+  end
+end

data/sidekiq-activerecord.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sidekiq/activerecord/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sidekiq-activerecord"
+  spec.version       = Sidekiq::Activerecord::VERSION
+  spec.authors       = ["Adam Farhi"]
+  spec.email         = ["yelled3@gmail.com"]
+  spec.summary       = 'Encapsulates various interactions between Sidekiq and ActiveRecord'
+  spec.description   = 'Encapsulates various interactions between Sidekiq and ActiveRecord'
+  spec.homepage      = "https://github.com/yelled3/sidekiq-activerecord"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'sidekiq',   '>= 2.16.0'
+  spec.add_dependency 'activerecord', '~> 4.1.1'
+
+  spec.add_development_dependency "rspec", ">= 2.14"
+  spec.add_development_dependency "database_cleaner", '~> 1.2.0'
+  spec.add_development_dependency 'sqlite3', '~> 1.3.9'
+  spec.add_development_dependency 'factory_girl', "~> 4.0"
+end

data/spec/lib/sidekiq/manager_worker.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe Sidekiq::ManagerWorker do
+
+  before do
+    allow(Sidekiq::Client).to receive(:push_bulk)
+  end
+
+  class MockUserWorker; end
+
+  let(:worker_class) { MockUserWorker }
+  let(:sidekiq_client) { Sidekiq::Client }
+
+  class UserManagerWorker
+    include Sidekiq::ManagerWorker
+    sidekiq_delegate_task_to MockUserWorker
+  end
+
+  let!(:user_1) { create(:user, :active) }
+  let!(:user_2) { create(:user, :active) }
+  let!(:user_3) { create(:user, :active) }
+  let!(:user_4) { create(:user, :banned) }
+
+  let(:models_query) { User.active }
+
+  describe 'perform_query_async' do
+
+    def run_worker(options = {})
+      UserManagerWorker.perform_query_async(models_query, options)
+    end
+
+    def mock_options(options)
+      UserManagerWorker.send(:sidekiq_manager_options, options)
+    end
+
+    def batch_args(*ids)
+      {'class' => worker_class, 'args' => ids.map{ |id| [id] }}
+    end
+
+    let(:model_ids) { [[user_1.id], [user_2.id], [user_3.id]] }
+
+    context 'when the worker_class is specified' do
+
+      class MockCustomWorker; end
+
+      let(:custom_worker_class) { MockCustomWorker }
+
+      def batch_args(*ids)
+        {'class' => custom_worker_class, 'args' => ids.map{ |id| [id] }}
+      end
+
+      context 'as method arguments' do
+
+        it 'pushes a bulk of all user ids for the specified worker_class' do
+          expect(sidekiq_client).to receive(:push_bulk).with( batch_args(user_1.id, user_2.id, user_3.id) )
+          run_worker({:worker_class => custom_worker_class})
+        end
+      end
+
+      context 'as sidekiq_delegate_task_to' do
+
+        around do |example|
+          UserManagerWorker.send(:sidekiq_delegate_task_to, custom_worker_class)
+          example.run
+          UserManagerWorker.send(:sidekiq_delegate_task_to, worker_class)
+        end
+
+        it 'pushes a bulk of all user ids for the specified worker_class' do
+          expect(sidekiq_client).to receive(:push_bulk).with( batch_args(user_1.id, user_2.id, user_3.id) )
+          run_worker
+        end
+      end
+
+    end
+
+    context 'when the batch size is specified' do
+
+      let(:batch_size) { 2 }
+
+      context 'as method arguments' do
+        it 'pushes a bulk of user ids batches' do
+          expect(sidekiq_client).to receive(:push_bulk).with( batch_args(user_1.id, user_2.id) )
+          expect(sidekiq_client).to receive(:push_bulk).with( batch_args(user_3.id) )
+          run_worker({batch_size: batch_size})
+        end
+      end
+
+      context 'as sidekiq_manager_options' do
+
+        around do |example|
+          mock_options(:batch_size => batch_size)
+          example.run
+          mock_options(:batch_size => Sidekiq::ManagerWorker::DEFAULT_BATCH_SIZE)
+        end
+
+        it 'pushes a bulk of user ids batches' do
+          expect(sidekiq_client).to receive(:push_bulk).with( batch_args(user_1.id, user_2.id) )
+          expect(sidekiq_client).to receive(:push_bulk).with( batch_args(user_3.id) )
+          run_worker
+        end
+      end
+    end
+
+    context 'when the additional_keys are specified' do
+
+      let(:additional_keys) { [:email, :status] }
+
+      def batch_args(*users)
+        {'class' => worker_class, 'args' => users.map{ |user| [user.id, user.email, user.status] }}
+      end
+
+      context 'as method arguments' do
+        it 'pushes a bulk of all user ids and additional_keys' do
+          expect(sidekiq_client).to receive(:push_bulk).with( batch_args(user_1, user_2, user_3) )
+          run_worker({additional_keys: additional_keys})
+        end
+      end
+
+      context 'as sidekiq_manager_options' do
+        around do |example|
+          mock_options(:additional_keys => additional_keys)
+          example.run
+          mock_options(:additional_keys => [])
+        end
+
+        it 'pushes a bulk of all user ids and additional_keys' do
+          expect(sidekiq_client).to receive(:push_bulk).with( batch_args(user_1, user_2, user_3) )
+          run_worker
+        end
+      end
+
+    end
+
+    context 'when the identifier_key is specified' do
+
+      def batch_args(*users)
+        {'class' => worker_class, 'args' => users.map{ |user| [user.email] }}
+      end
+
+      let(:identifier_key) { :email }
+
+      context 'as method arguments' do
+        it 'pushes a bulk of all user emails as the identifier_key' do
+          expect(sidekiq_client).to receive(:push_bulk).with( batch_args(user_1, user_2, user_3) )
+          run_worker({identifier_key: identifier_key})
+        end
+      end
+
+      context 'as sidekiq_manager_options' do
+
+        around do |example|
+          mock_options(:identifier_key => identifier_key)
+          example.run
+          mock_options(:identifier_key => Sidekiq::ManagerWorker::DEFAULT_IDENTIFIER_KEY)
+        end
+
+        it 'pushes a bulk of all user emails as the identifier_key' do
+          expect(sidekiq_client).to receive(:push_bulk).with( batch_args(user_1, user_2, user_3) )
+          run_worker
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/sidekiq/task_worker.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe Sidekiq::TaskWorker do
+
+  class UserTaskWorker
+    include Sidekiq::TaskWorker
+  end
+
+  let!(:user) { create(:user, :active) }
+
+  subject(:task_worker)  {UserTaskWorker }
+
+  def run_worker
+    task_worker.perform(user.id)
+  end
+
+  describe 'sidekiq_task_model' do
+
+    context 'when the identifier_key is specified' do
+      before do
+        class UserTaskWorker
+          sidekiq_task_model User
+          sidekiq_task_options :identifier_key => :email
+        end
+      end
+
+      after do
+        class UserTaskWorker
+          sidekiq_task_model nil
+          sidekiq_task_options :identifier_key => :id
+        end
+      end
+
+      it 'sets the identifier_key' do
+        identifier = task_worker.send(:identifier_key)
+        expect(identifier).to eq :email
+      end
+
+      it 'calls the perform_on_model with the model' do
+        expect(task_worker).to receive(:perform_on_model).with(user)
+        task_worker.perform(user.email)
+      end
+    end
+
+    context 'when a Class is specified' do
+
+      before do
+        class UserTaskWorker
+          sidekiq_task_model User
+        end
+      end
+
+      it 'sets the model' do
+        klass = task_worker.send(:model_class)
+        expect(klass).to eq User
+      end
+
+    end
+
+    context 'when a class name is specified' do
+      before do
+        class UserTaskWorker
+          sidekiq_task_model :user
+        end
+      end
+
+      it 'sets the model' do
+        klass = task_worker.send(:model_class)
+        expect(klass).to eq User
+      end
+
+      context 'when the model is not found' do
+
+        let(:trash_id) { user.id + 10 }
+
+        def run_worker
+          task_worker.perform(trash_id)
+        end
+
+        it 'calls the not_found_model hook' do
+          expect(task_worker).to receive(:not_found_model).with(trash_id)
+          run_worker
+        end
+
+        it 'skips the perform_on_model' do
+          expect(task_worker).to_not receive(:perform_on_model)
+          run_worker
+        end
+      end
+
+      context 'when the mode is found' do
+
+        context 'when the model validation is specified' do
+          it 'calls the model_valid? hook' do
+            expect(task_worker).to receive(:model_valid?).with(user)
+            run_worker
+          end
+        end
+
+        context 'when the model is valid' do
+
+          before do
+            allow(task_worker).to receive(:model_valid?).and_return(true)
+          end
+
+          it 'calls the perform_on_model with the model' do
+            expect(task_worker).to receive(:perform_on_model).with(user)
+            run_worker
+          end
+
+          describe 'perform_on_model' do
+            context 'when passing only the model identifier' do
+              it 'calls the perform_on_model with the model' do
+                expect(task_worker).to receive(:perform_on_model).with(user)
+                run_worker
+              end
+            end
+
+            context 'when passing additional arguments' do
+              it 'calls the perform_on_model with the model' do
+                expect(task_worker).to receive(:perform_on_model).with(user, user.email)
+                task_worker.perform(user.id, user.email)
+              end
+            end
+
+          end
+        end
+
+        context 'when the model is invalid' do
+
+          before do
+            allow(task_worker).to receive(:model_valid?).and_return(false)
+          end
+
+          it 'calls the invalid_model hook' do
+            expect(task_worker).to receive(:invalid_model).with(user)
+            run_worker
+          end
+
+          it 'skips the perform_on_model' do
+            expect(task_worker).to_not receive(:perform_on_model)
+            run_worker
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+require "sidekiq"
+require "sidekiq/activerecord"
+require 'factory_girl'
+require 'database_cleaner'
+require 'support'
+
+RSpec.configure do |config|
+  config.alias_example_to :expect_it
+
+  # config.full_backtrace = true
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  # config.use_transactional_fixtures = true
+
+  config.expect_with :rspec do |config|
+    config.syntax = :expect
+  end
+
+  config.include FactoryGirl::Syntax::Methods # Don't need to write FactoryGirl.create => create
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end
+

data/spec/support.rb

@@ -0,0 +1,39 @@
+require "active_record"
+
+def set_database
+  db_config = {:adapter => "sqlite3", :database => ":memory:"}
+  ActiveRecord::Base.establish_connection(db_config)
+  connection = ActiveRecord::Base.connection
+
+  connection.create_table :users, force: true do |t|
+    t.string :name
+    t.string :email
+    t.string :status
+    t.timestamps
+  end
+end
+
+set_database
+
+class User < ActiveRecord::Base
+  scope :active, -> { where(:status => :active) }
+  scope :banned, -> { where(:status => :banned) }
+end
+
+
+FactoryGirl.define do
+  factory :user do
+
+    sequence(:name) { |n| "name-#{n}" }
+    sequence(:email) { |n| "email-#{n}" }
+
+    trait :active do
+      status 'active'
+    end
+
+    trait :banned do
+      status 'banned'
+    end
+
+  end
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq-activerecord
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Adam Farhi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.16.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.16.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Encapsulates various interactions between Sidekiq and ActiveRecord
+email:
+- yelled3@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sidekiq/activerecord.rb
+- lib/sidekiq/activerecord/version.rb
+- lib/sidekiq/manager_worker.rb
+- lib/sidekiq/task_worker.rb
+- sidekiq-activerecord.gemspec
+- spec/lib/sidekiq/manager_worker.rb
+- spec/lib/sidekiq/task_worker.rb
+- spec/spec_helper.rb
+- spec/support.rb
+homepage: https://github.com/yelled3/sidekiq-activerecord
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Encapsulates various interactions between Sidekiq and ActiveRecord
+test_files:
+- spec/lib/sidekiq/manager_worker.rb
+- spec/lib/sidekiq/task_worker.rb
+- spec/spec_helper.rb
+- spec/support.rb
+has_rdoc: