sidekiq-activerecord 0.0.2 → 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f4546acc561ce4ce6579666b4b05a66006ec39d9
+  data.tar.gz: 73e5e411912bca36600f5bf091fb010767119f00
+SHA512:
+  metadata.gz: 716f41cd85a9809af9965675eca4220b7d35f5607cb42abfea2fe5c1251fb7d2a8f466219db43bcaefb19e9ab77b604a0926a11482039bb0f89a4333c4fc19af
+  data.tar.gz: b5ec0c789fa00a57ee2464f72a88c40b930dd1683c858d914d8a1330059bf13338abd002d15537ea8419c089e37b76e719495ef34aaa4b1c6490e7b77a8fe018

data/.gitignore

@@ -1,2 +1,5 @@
-*.idea
+*.gem
+pkg
+.idea
+*.log
 *.lock

data/.rspec

@@ -1,3 +1,3 @@
--c
--f d
--r spec_helper
+--color
+--format documentation
+--require spec_helper

data/.travis.yml

@@ -1,12 +1,12 @@
 language: ruby
-services:
-  - redis-server
+before_install: gem install bundler
+script: bundle exec rake
 rvm:
   - 1.9.3
   - jruby-19mode
-  - rbx
+  - rbx-2
   - 2.0.0
-  - 2.1
+  - 2.1.2
 matrix:
   allow_failures:
-    - rvm: rbx
+    - rvm: rbx-2

data/Gemfile

@@ -1,2 +1,16 @@
 source 'https://rubygems.org'
 gemspec
+
+
+
+platforms :ruby do
+  gem 'sqlite3'
+end
+
+platform :mri_20, :mri_21 do
+  gem 'byebug'
+end
+
+platforms :jruby do
+  gem 'activerecord-jdbcsqlite3-adapter'
+end

data/README.md

@@ -1,116 +1,76 @@
-# Sidekiq::Activerecord
+[Sidekiq::Activerecord](https://github.com/sidekiq-orm/sidekiq-activerecord) encapsulates common patterns and various interactions between [Sidekiq](https://github.com/mperham/sidekiq) and [ActiveRecord](http://guides.rubyonrails.org/active_record_basics.html).
 
-Encapsulates various interactions between Sidekiq and ActiveRecord.
+[![Build Status](https://travis-ci.org/sidekiq-orm/sidekiq-activerecord.svg?branch=master)](https://travis-ci.org/sidekiq-orm/sidekiq-activerecord)
 
-## Installation
+***
 
-Add this line to your application's Gemfile:
-
-    gem 'sidekiq-activerecord'
-
-And then execute:
+## Common Patterns
+If you've been using Sidekiq for a while, you've probably noticed a recurring pattern in your workers:
 
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install sidekiq-activerecord
 
-# Usage
+## [Sidekiq::ActiveRecord::TaskWorker](https://github.com/sidekiq-orm/sidekiq-activerecord/wiki/Task-Worker)
+A very conventional pattern, is to have a worker that gets a model identifier, loads it and runs some custom logic on the model. 
 
-If you've been using Sidekiq for a while, you've probably noticed a recurring pattern in your workers;
+[```TaskWorker```]https://github.com/sidekiq-orm/sidekiq-activerecord/wiki/Task-Worker) provides a simple and clean interface, which reduces the boilerplate and exposes only the custom logic.   
 
-## Child-Parent Workers
-A parent worker which goes over some model collection and enqueues a child worker for each model in the collection.
+Here's a simple example:
 
 ```ruby
-class ParentWorker
-  include Sidekiq::Worker
+class UserTaskWorker < Sidekiq::ActiveRecord::TaskWorker
 
-  def perform
-    User.active.each do |user|
-      ChildWorker.perform_async(user.id)
-    end
-  end
+  sidekiq_task_model :user # or User
 
+  def perform_on_user
+    UserService.run(user)
+  end
+  
 end
 ```
+For a more see the [TaskWorker documention](https://github.com/sidekiq-orm/sidekiq-activerecord/wiki/Task-Worker).
 
-## Sidekiq::ManagerWorker - Example
 
-```ruby
-class UserTaskWorker
-  include Sidekiq::TaskWorker
-end
+***
 
-class UserSyncer
-  include Sidekiq::ActiveRecord::ManagerWorker
 
+## [Sidekiq::ActiveRecord::ManagerWorker](https://github.com/sidekiq-orm/sidekiq-activerecord/wiki/Manager-Worker)
+Another farily common ```Sidekiq::Worker``` pattern, is a parent worker which goes over a model collection and enqueues a child worker for each model in the collection.
+
+Here's a simple example:
+```ruby
+# Parent Worker
+class UserSyncer < Sidekiq::ActiveRecord::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.
-
+Then, just call the worker with the model collection:
 ```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
+UserSyncer.perform_query_async(User.active)
 ```
 
-## Sidekiq::TaskWorker - Example
-
-```ruby
-class UserMailerTaskWorker
-  include Sidekiq::ActiveRecord::TaskWorker
+For a more see the [ManagerWorker documention](https://github.com/sidekiq-orm/sidekiq-activerecord/wiki/Manager-Worker).
 
-  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
+# Documention
+Checkout the project's [Wiki Page](https://github.com/sidekiq-orm/sidekiq-activerecord/wiki)
 
-  # optional
-  def not_found_model(token)
-    Log.error "User not found for token:#{token}"
-  end
+***
 
-  # optional
-  def model_valid?(user)
-    user.active?
-  end
+# Installation
 
-  # optional
-  def invalid_model(user)
-    Log.error "User #{user.token} is invalid"
-  end
+Add this line to your application's Gemfile:
 
-end
+    gem 'sidekiq-activerecord'
 
+And then execute:
 
-UserMailerTaskWorker.perform(user.id, :new_email)
-```
+    $ bundle
+    
+***
 
 ## Contributing
 
-1. Fork it ( http://github.com/yelled3/sidekiq-activerecord/fork )
+1. Fork it ( http://github.com/sidekiq-orm/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`)

data/lib/sidekiq/active_record/manager_worker.rb

@@ -1,17 +1,19 @@
 module Sidekiq
   module ActiveRecord
-    module ManagerWorker
-      extend Sidekiq::Worker
+    class ManagerWorker
+      include Sidekiq::Worker
 
       DEFAULT_IDENTIFIER_KEY = :id
       DEFAULT_BATCH_SIZE = 1000
 
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.class_attribute :sidekiq_manager_options_hash
+      def perform(options = {})
+        default_query = self.class.get_default_models_query
+        self.class.perform_query_async(default_query, options)
       end
 
-      module ClassMethods
+
+      class << self
+
         # For a given model collection, it delegates each model to a sub-worker (e.g TaskWorker)
         # Specify the TaskWorker with the `sidekiq_delegate_task_to` method.
         #
@@ -24,7 +26,9 @@ module Sidekiq
         #
         # @example:
         #   class UserTaskWorker
-        #     include Sidekiq::ActiveRecord::TaskWorker
+        #     def perform(user_id)
+        #       # user task logic
+        #     end
         #   end
         #
         #   class UserSyncer
@@ -44,7 +48,7 @@ module Sidekiq
         #
         def perform_query_async(models_query, options = {})
           set_runtime_options(options)
-          models = models_query.select(selected_attributes)
+          models = prepare_models_query(models_query)
           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)
@@ -72,10 +76,24 @@ module Sidekiq
         #   :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 || {}))
+          @sidekiq_manager_options_hash = get_sidekiq_manager_options.merge((opts || {}))
         end
 
-        # private
+        # The default of query to run, when the workers runs perform
+        # example
+        #   class UserManagerWorker < Sidekiq::ActiveRecord::ManagerWorker
+        #     sidekiq_delegate_task_to UserTaskWorker
+        #     default_models_query -> { User.active }
+        #   end
+        #
+        #   UserManagerWorker.perform_async(:batch_size => 300)
+        def default_models_query(query)
+          @query = query
+        end
+
+        def get_default_models_query
+          @query.call() if @query.present?
+        end
 
         def default_worker_manager_options
           {
@@ -93,10 +111,9 @@ module Sidekiq
           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
+        def prepare_models_query(models_query)
+          selected_attributes = [models_query.primary_key.to_sym, identifier_key, additional_keys].uniq
+          models_query.select(selected_attributes)
         end
 
         def worker_class
@@ -104,10 +121,6 @@ module Sidekiq
           manager_options[:worker_class]
         end
 
-        def default_identifier?
-          identifier_key == DEFAULT_IDENTIFIER_KEY
-        end
-
         def identifier_key
           manager_options[:identifier_key]
         end
@@ -125,7 +138,7 @@ module Sidekiq
         end
 
         def get_sidekiq_manager_options
-          self.sidekiq_manager_options_hash ||= default_worker_manager_options
+          @sidekiq_manager_options_hash ||= default_worker_manager_options
         end
 
         def runtime_options
@@ -135,7 +148,9 @@ module Sidekiq
         def set_runtime_options(options={})
           @sidekiq_manager_runtime_options = options.delete_if { |_, v| v.to_s.strip == '' }
         end
+
       end
+
     end
   end
 end

data/lib/sidekiq/active_record/task_worker.rb

@@ -1,88 +1,86 @@
 module Sidekiq
   module ActiveRecord
-    module TaskWorker
-      extend Sidekiq::Worker
+    class TaskWorker
+      include Sidekiq::Worker
 
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.class_attribute :sidekiq_task_options_hash
-      end
+      attr_reader :task_model
 
-      module ClassMethods
-        # @example:
-        #   class UserMailerTaskWorker
-        #     include Sidekiq::ActiveRecord::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
+      # @example:
+      #   class UserMailerTaskWorker < Sidekiq::ActiveRecord::TaskWorker
+      #
+      #     sidekiq_task_model :user_model # or UserModel
+      #     sidekiq_task_options :identifier_key => :token
+      #
+      #     def perform_on_model
+      #       UserMailer.deliver_registration_confirmation(user, email_type)
+      #     end
+      #
+      #     def not_found_model(token)
+      #       Log.error "User not found for token:#{token}"
+      #     end
+      #
+      #     def should_perform_on_model?
+      #       user.active?
+      #     end
+      #
+      #     def did_not_perform_on_model
+      #       Log.error "User #{user.token} is inactive"
+      #     end
+      #
+      #   end
+      #
+      #
+      #   UserMailerTaskWorker.perform(user.id, :new_email)
+      #
+      def perform(identifier, *args)
+        @task_model = fetch_model(identifier, *args)
+        return not_found_model(identifier, *args) unless @task_model.present?
 
-        def sidekiq_task_model(model_klass)
-          if model_klass.is_a?(String) || model_klass.is_a?(Symbol)
-            model_klass = model_klass.to_s.split('_').map(&:capitalize).join.constantize
-          else
-            model_klass
-          end
-          get_sidekiq_task_options[:model_class] = model_klass
+        if should_perform_on_model?
+          perform_on_model(*args)
+        else
+          did_not_perform_on_model
         end
+      end
 
-        def perform_on_model(model)
-          model
-        end
+      def perform_on_model(*args)
+        task_model
+      end
 
-        # recheck the if one of the items is still valid
-        def model_valid?(_model)
-          true
-        end
+      # Hook that can block perform_on_model from being triggered,
+      # e.g in cases when the model is no longer valid
+      def should_perform_on_model?
+        true
+      end
 
-        # Hook to handel an invalid model
-        def invalid_model(_model)
-        end
+      # Hook to handel a model that was not performed
+      def did_not_perform_on_model
+        task_model
+      end
 
-        # Hook to handel not found model
-        def not_found_model(_identifier)
-        end
+      # Hook to handel not found model
+      def not_found_model(identifier, *args)
+        identifier
+      end
 
-        # private
+      def fetch_model(identifier, *args)
+        self.class.model_class.find_by(self.class.identifier_key => identifier)
+      end
 
-        def fetch_model(identifier)
-          model_class.find_by(identifier_key => identifier)
+
+      class << self
+
+        def sidekiq_task_model(model_klass)
+          return if model_klass.blank?
+
+          setup_task_model_alias(model_klass)
+
+          get_sidekiq_task_options[:model_class] = active_record_class(model_klass)
         end
 
         def model_class
           klass = get_sidekiq_task_options[:model_class]
-          fail NotImplementedError.new('`model_class` was not specified') unless klass.present?
+          fail NotImplementedError.new('`sidekiq_task_model` was not specified') unless klass.present?
           klass
         end
 
@@ -96,11 +94,49 @@ module Sidekiq
         #
         #   :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!)
+          @sidekiq_task_options_hash = get_sidekiq_task_options.merge((opts).symbolize_keys!)
+        end
+
+
+        private
+
+        # aliases task_model with the name of the model
+        #
+        # example:
+        #   sidekiq_task_model: AdminUser # or :admin_user
+        #
+        # then the worker will have access to `admin_user`, which is an alias to `task_model`
+        #
+        #   def perform_on_admin_user
+        #     admin_user == task_model
+        #   end
+        #
+        # it will add the following method aliases to the hooks:
+        #
+        #   def not_found_admin_user; end
+        #   def should_perform_on_admin_user?; end
+        #   def did_not_perform_on_admin_user; end
+        #
+        def setup_task_model_alias(model_klass_name)
+          if model_klass_name.is_a?(Class)
+            model_klass_name = model_klass_name.name.underscore
+          end
+          {
+              :task_model => model_klass_name,
+              :fetch_model => "fetch_#{model_klass_name}",
+              :not_found_model => "not_found_#{model_klass_name}",
+              :should_perform_on_model? => "should_perform_on_#{model_klass_name}?",
+              :did_not_perform_on_model => "did_not_perform_on_#{model_klass_name}",
+              :perform_on_model => "perform_on_#{model_klass_name}"
+          }.each do |old_name, new_name|
+            self.class_exec do
+              alias_method new_name.to_sym, old_name
+            end
+          end
         end
 
         def get_sidekiq_task_options
-          self.sidekiq_task_options_hash ||= default_worker_task_options
+          @sidekiq_task_options_hash ||= default_worker_task_options
         end
 
         def default_worker_task_options
@@ -108,7 +144,19 @@ module Sidekiq
               identifier_key: :id
           }
         end
+
+        def active_record_class(model_klass)
+          begin
+            model_klass = model_klass.to_s.classify.constantize
+            raise unless model_klass <= ::ActiveRecord::Base
+          rescue
+            fail ArgumentError.new '`sidekiq_task_model` must be an ActiveRecord model'
+          end
+          model_klass
+        end
+
       end
+
     end
   end
 end

data/lib/sidekiq/active_record/version.rb

@@ -1,5 +1,5 @@
 module Sidekiq
   module ActiveRecord
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

data/sidekiq-activerecord.gemspec

@@ -21,8 +21,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'sidekiq',   '>= 2.16'
   spec.add_dependency 'activerecord', '>= 4.0'
 
+  spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec', '3.0.0.rc1'
   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/sidekiq/active_record/manager_worker_spec.rb

@@ -9,8 +9,7 @@ describe Sidekiq::ActiveRecord::ManagerWorker do
   let(:worker_class) { MockUserWorker }
   let(:sidekiq_client) { Sidekiq::Client }
 
-  class UserManagerWorker
-    include Sidekiq::ActiveRecord::ManagerWorker
+  class UserManagerWorker < Sidekiq::ActiveRecord::ManagerWorker
     sidekiq_delegate_task_to MockUserWorker
   end
 
@@ -21,6 +20,24 @@ describe Sidekiq::ActiveRecord::ManagerWorker do
 
   let(:models_query) { User.active }
 
+  describe 'perform with default models query' do
+
+    before do
+      class UserManagerWorker < Sidekiq::ActiveRecord::ManagerWorker
+        sidekiq_delegate_task_to MockUserWorker
+        default_models_query -> { User.active }
+      end
+    end
+
+    let(:default_models_query) { User.active }
+    let(:worker_options) { {:batch_size => 300} }
+
+    it 'runs `perform_query_async` with the default models query and the specified options' do
+      expect(UserManagerWorker).to receive(:perform_query_async).with(default_models_query, worker_options)
+      UserManagerWorker.new.perform(worker_options)
+    end
+  end
+
   describe 'perform_query_async' do
 
     def run_worker(options = {})
@@ -37,6 +54,20 @@ describe Sidekiq::ActiveRecord::ManagerWorker do
 
     let(:model_ids) { [[user_1.id], [user_2.id], [user_3.id]] }
 
+    context 'when a sidekiq_options is specified' do
+
+      before do
+        class UserManagerWorker
+          sidekiq_options :queue => :user_manager_queue
+        end
+      end
+
+      it 'sets the queue' do
+        sidekiq_options = UserManagerWorker.send(:get_sidekiq_options)
+        expect(sidekiq_options['queue']).to eq :user_manager_queue
+      end
+    end
+
     context 'when the worker_class is specified' do
 
       class MockCustomWorker; end

data/spec/sidekiq/active_record/task_worker_spec.rb

@@ -1,12 +1,12 @@
 describe Sidekiq::ActiveRecord::TaskWorker do
 
-  class UserTaskWorker
-    include Sidekiq::ActiveRecord::TaskWorker
+  class UserTaskWorker < Sidekiq::ActiveRecord::TaskWorker
   end
 
   let!(:user) { create(:user, :active) }
 
-  subject(:task_worker)  {UserTaskWorker }
+  subject(:task_worker_class)  { UserTaskWorker }
+  subject(:task_worker)  { UserTaskWorker.new }
 
   def run_worker
     task_worker.perform(user.id)
@@ -30,17 +30,51 @@ describe Sidekiq::ActiveRecord::TaskWorker do
       end
 
       it 'sets the identifier_key' do
-        identifier = task_worker.send(:identifier_key)
+        identifier = task_worker_class.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)
+        expect(task_worker).to receive(:perform_on_model)
         task_worker.perform(user.email)
       end
     end
 
-    context 'when a Class is specified' do
+    context 'when a sidekiq_options is specified' do
+
+      before do
+        class UserTaskWorker
+          sidekiq_options :queue => :user_queue
+        end
+      end
+
+      it 'sets the queue' do
+        sidekiq_options = task_worker_class.send(:get_sidekiq_options)
+        expect(sidekiq_options['queue']).to eq :user_queue
+      end
+    end
+
+    context 'when the specified task model is not a class' do
+
+      it 'raises an ArgumentError' do
+        expect {
+          task_worker_class.send(:sidekiq_task_model, :something_unrelated)
+        }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when the specified task model is not an ActiveRecord class' do
+
+      class NotActiveRecord; end
+
+      it 'raises an ArgumentError' do
+        expect {
+          task_worker_class.send(:sidekiq_task_model, NotActiveRecord)
+        }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when a ActiveRecord class is specified' do
 
       before do
         class UserTaskWorker
@@ -49,13 +83,25 @@ describe Sidekiq::ActiveRecord::TaskWorker do
       end
 
       it 'sets the model' do
-        klass = task_worker.send(:model_class)
+        klass = task_worker_class.send(:model_class)
         expect(klass).to eq User
       end
 
+      describe 'task_model' do
+        it 'sets the model' do
+          run_worker
+          expect(task_worker.task_model).to eq user
+        end
+
+        it 'has an alias of `task_model` withe for the specified model name' do
+          run_worker
+          expect(task_worker.user).to eq user
+        end
+      end
+
     end
 
-    context 'when a class name is specified' do
+    context 'when an ActiveRecord class name is specified' do
       before do
         class UserTaskWorker
           sidekiq_task_model :user
@@ -63,20 +109,45 @@ describe Sidekiq::ActiveRecord::TaskWorker do
       end
 
       it 'sets the model' do
-        klass = task_worker.send(:model_class)
+        klass = task_worker_class.send(:model_class)
         expect(klass).to eq User
       end
 
+      describe 'task_model' do
+        it 'sets the model' do
+          run_worker
+          expect(task_worker.task_model).to eq user
+        end
+
+        it 'has an alias of `task_model` withe for the specified model name' do
+          run_worker
+          expect(task_worker.user).to eq user
+        end
+      end
+
+      describe 'when fetching the model' do
+
+        def run_worker
+          task_worker.perform(user.id, user.email)
+        end
+
+        it 'calls the fetch_model hook' do
+          expect(task_worker).to receive(:fetch_model).with(user.id, user.email)
+          run_worker
+        end
+
+      end
+
       context 'when the model is not found' do
 
         let(:trash_id) { user.id + 10 }
 
         def run_worker
-          task_worker.perform(trash_id)
+          task_worker.perform(trash_id, user.email)
         end
 
         it 'calls the not_found_model hook' do
-          expect(task_worker).to receive(:not_found_model).with(trash_id)
+          expect(task_worker).to receive(:not_found_model).with(trash_id, user.email)
           run_worker
         end
 
@@ -84,54 +155,86 @@ describe Sidekiq::ActiveRecord::TaskWorker do
           expect(task_worker).to_not receive(:perform_on_model)
           run_worker
         end
+
+        describe 'method alias' do
+          it 'has an alias of not_found_model hook with for the specified task model name' do
+            expect(task_worker.not_found_user(trash_id)).to eq trash_id
+          end
+        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)
+        context 'when the should_perform_on_model? hook is specified' do
+          it 'calls the should_perform_on_model? hook' do
+            expect(task_worker).to receive(:should_perform_on_model?)
             run_worker
           end
+
+          describe 'method alias' do
+
+            let(:mock_result) { 1234 }
+
+            before do
+              class UserTaskWorker
+                def should_perform_on_user?
+                  1234
+                end
+              end
+            end
+
+            it 'has an alias of should_perform_on_model? hook with for the specified task model name' do
+              run_worker
+              expect(task_worker.should_perform_on_user?).to eq mock_result
+            end
+          end
         end
 
-        context 'when the model is valid' do
+        context 'when the model should be performed' do
 
           before do
-            allow(task_worker).to receive(:model_valid?).and_return(true)
+            allow(task_worker).to receive(:should_perform_on_model?).and_return(true)
           end
 
           it 'calls the perform_on_model with the model' do
-            expect(task_worker).to receive(:perform_on_model).with(user)
+            expect(task_worker).to receive(:perform_on_model)
             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)
+                expect(task_worker).to receive(:perform_on_model)
                 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)
+                expect(task_worker).to receive(:perform_on_model).with(user.email)
                 task_worker.perform(user.id, user.email)
               end
             end
 
+            describe 'method alias' do
+              it 'has an alias of perform_on_model hook with for the specified task model name' do
+                task_worker.perform(user.id)
+                expect(task_worker.perform_on_user).to eq user
+              end
+            end
+
           end
         end
 
-        context 'when the model is invalid' do
+        context 'when the model should not be performed' do
 
           before do
-            allow(task_worker).to receive(:model_valid?).and_return(false)
+            allow(task_worker).to receive(:should_perform_on_model?).and_return(false)
           end
 
-          it 'calls the invalid_model hook' do
-            expect(task_worker).to receive(:invalid_model).with(user)
+          it 'calls the did_not_perform_on_model hook' do
+            expect(task_worker).to receive(:did_not_perform_on_model)
             run_worker
           end
 
@@ -140,6 +243,13 @@ describe Sidekiq::ActiveRecord::TaskWorker do
             run_worker
           end
 
+          describe 'method alias' do
+            it 'has an alias of did_not_perform_on_model hook with for the specified task model name' do
+              run_worker
+              expect(task_worker.did_not_perform_on_user).to eq user
+            end
+          end
+
         end
 
       end

data/spec/spec_helper.rb

@@ -1,4 +1,8 @@
+if RUBY_ENGINE == 'ruby' and RUBY_VERSION != '1.9.3'
+  require 'byebug'
+end
 require 'sidekiq'
+require 'sidekiq/testing/inline'
 require 'sidekiq/activerecord'
 require 'factory_girl'
 require 'database_cleaner'

metadata

@@ -1,100 +1,88 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-activerecord
 version: !ruby/object:Gem::Version
-  version: 0.0.2
-  prerelease: 
+  version: 0.0.3
 platform: ruby
 authors:
 - Adam Farhi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-27 00:00:00.000000000 Z
+date: 2014-06-05 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'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '2.16'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '4.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - '='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 3.0.0.rc1
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - '='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 3.0.0.rc1
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: database_cleaner
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 3.0.0.rc1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 3.0.0.rc1
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: database_cleaner
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 1.3.9
+        version: 1.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 1.3.9
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: factory_girl
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -102,7 +90,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -118,7 +105,6 @@ files:
 - .rspec
 - .travis.yml
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -126,8 +112,6 @@ files:
 - lib/sidekiq/active_record/task_worker.rb
 - lib/sidekiq/active_record/version.rb
 - lib/sidekiq/activerecord.rb
-- pkg/sidekiq-activerecord-0.0.1.gem
-- pkg/sidekiq-activerecord-0.0.2.gem
 - sidekiq-activerecord.gemspec
 - spec/sidekiq/active_record/manager_worker_spec.rb
 - spec/sidekiq/active_record/task_worker_spec.rb
@@ -139,27 +123,26 @@ files:
 homepage: https://github.com/yelled3/sidekiq-activerecord
 licenses:
 - MIT
+metadata: {}
 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
+rubygems_version: 2.0.6
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Encapsulates various interactions between Sidekiq and ActiveRecord
 test_files:
 - spec/sidekiq/active_record/manager_worker_spec.rb
@@ -169,4 +152,3 @@ test_files:
 - spec/support/database_cleaner.rb
 - spec/support/factory_girl.rb
 - spec/support/models.rb
-has_rdoc: 

data/Gemfile.lock

@@ -1,71 +0,0 @@
-PATH
-  remote: .
-  specs:
-    sidekiq-activerecord (0.0.2)
-      activerecord (>= 4.0)
-      sidekiq (>= 2.16)
-
-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.4.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 (3.0.0.rc1)
-      rspec-core (= 3.0.0.rc1)
-      rspec-expectations (= 3.0.0.rc1)
-      rspec-mocks (= 3.0.0.rc1)
-    rspec-core (3.0.0.rc1)
-      rspec-support (= 3.0.0.rc1)
-    rspec-expectations (3.0.0.rc1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (= 3.0.0.rc1)
-    rspec-mocks (3.0.0.rc1)
-      rspec-support (= 3.0.0.rc1)
-    rspec-support (3.0.0.rc1)
-    sidekiq (3.1.0)
-      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 (= 3.0.0.rc1)
-  sidekiq-activerecord!
-  sqlite3 (>= 1.3.9)