kiqit 0.0.1 → 1.3.0

data/license

@@ -0,0 +1,20 @@
+Copyright (c) Avi Tzurel
+
+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/spec/lib/kiqit/args_parser_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+class CustomFinder 
+  def self.find(klass, id)
+    klass.find(id)
+  end
+end
+
+describe Kiqit::ArgsParser do
+  subject { Kiqit::ArgsParser }
+  let(:user) { User.create }
+
+  context "Custom finder" do
+    it "should invoke the custom class finder method" do
+      CustomFinder.should_receive(:find).with(User, user.id.to_s)
+      Kiqit::Plugins.add_finder(CustomFinder)
+      
+      subject.args_from_sidekiq(["AR:User:#{user.id}"])
+
+      Kiqit::Plugins.clear_finder!
+    end
+  end
+
+  context "args to sidekiq" do
+
+    it "should convert array of hashes correctly" do
+      arr = [
+        { something: "aaa" },
+        { something: "bbb" },
+        { something: "ccc" },
+        { something: "ddd" },
+        { something: "eee" }
+      ]
+      subject.args_to_sidekiq(arr).class.should == Array
+    end
+
+    it "should translate array of hashes back and forth again" do
+      arr = [
+        { something: "aaa" },
+        { something: "bbb" },
+        { something: "ccc" },
+        { something: "ddd" },
+        { something: "eee" }
+      ]
+      to_sidekiq = subject.args_to_sidekiq(arr).to_json
+      a = JSON.parse(to_sidekiq)
+      from_sidekiq = subject.args_from_sidekiq(a)
+      
+      from_sidekiq.should == arr
+    end
+
+    it "should convert the AR object to the proper string" do
+      user_id = user.id
+
+      subject.args_to_sidekiq(user).should == "AR:User:#{user_id}"
+    end
+
+    it "should convert a hash into YAML string so that Sidekiq will be able to JSON convert it" do
+      hash = { name: "something", other: "something else" }
+      subject.args_to_sidekiq(hash)[0].class.name.should == "String"
+    end
+
+    it "should be able to load a yaml from the string and translate it into the same hash again" do
+      hash = { name: "something", other: "something else" }
+      yaml = subject.args_to_sidekiq(hash)
+
+      loaded_yaml = YAML.load(yaml)
+
+      loaded_yaml[:name].should == "something"
+      loaded_yaml[:other].should == "something else"
+    end
+
+    it "should convert a class to the proper string representation" do
+      klass = User
+      subject.args_to_sidekiq(klass).should == "CLASS:User"
+    end
+  end
+
+  context "args from sidekiq" do
+    it "should give me a hash back when I pass a yaml representation of it" do
+      hash = { name: "something", other: "something else" }
+      yaml = *hash.to_yaml
+
+      args = subject.args_from_sidekiq(yaml)
+      args[0].class.name.should == "Hash"
+      args[0][:name].should == "something"
+      args[0][:other].should == "something else"
+    end
+
+    it "Should give me a user model back when I pass the proper string" do
+      args_input = *"AR:User:#{user.id}"
+      args = subject.args_from_sidekiq(args_input)
+      args[0].should == user
+    end
+  end
+end

data/spec/lib/kiqit/config_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Kiqit::Config do
+  before(:each) { Kiqit.config.enabled = false }
+
+  it "should set the perform later mode" do
+    Kiqit.config.enabled?.should be_false
+    Kiqit.config.enabled = true
+    Kiqit.config.enabled?.should == true
+  end
+end

data/spec/lib/kiqit/job_creator_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Kiqit::JobCreator do
+  
+  let(:job)    {Kiqit::JobCreator.new("some_queue", "WorkerClass", "Klass_name", 2, :the_method)}
+  let(:delay)  {42}
+
+  describe :enqueue do
+    context "with :delay option" do
+      it "should enqueue job in Sidekiq with the given delay" do
+        Sidekiq::Client.should_receive(:push)
+        job.enqueue delay: delay
+      end
+    end
+    context "without :delay option" do
+      it "should create a regular sidekiq job if delay option isn't given" do
+        Sidekiq::Client.should_receive(:push)
+        job.enqueue
+      end
+    end
+  end
+end
+

data/spec/lib/kiqit/payload_helper_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+
+describe Kiqit::PayloadHelper do
+  subject { Kiqit::PayloadHelper }
+
+  describe :get_digest do
+    it "should o something" do
+      user = User.create
+
+      digest = Digest::MD5.hexdigest({ :class => "DummyClass", 
+        :method => :some_method.to_s, 
+        :args => ["AR:User:#{user.id}"]
+        }.to_s)
+      digest = "loner:#{digest}"
+
+      args = Kiqit::ArgsParser.args_to_sidekiq(user)
+      subject.get_digest("DummyClass", :some_method, args).should == digest
+    end
+  end
+end

data/spec/lib/kiqit/plugins_spec.rb

@@ -0,0 +1,33 @@
+require 'kiqit/plugins'
+
+class BadDummyFinder 
+
+end
+
+class GoodDummyFinder 
+  def self.find(runner_class, id)
+    runner_class.find(id)
+  end
+end
+
+describe Kiqit::Plugins do
+  subject { Kiqit::Plugins }
+
+  describe :finder_class do
+    it "should be nil" do
+      subject.finder_class.should == nil
+    end
+  end
+  
+  describe :add_finder do
+    it "should not add the finder since it doens't have the proper method" do
+      subject.add_finder(BadDummyFinder)
+      subject.finder_class.should == nil
+    end
+
+    it "should add the finder since it has the proper method" do
+      subject.add_finder(GoodDummyFinder)
+      subject.finder_class.should == GoodDummyFinder
+    end
+  end    
+end

data/spec/lib/kiqit/workers/active_record/worker_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Kiqit::Workers::ActiveRecord::Worker do
+
+end

data/spec/lib/kiqit/workers/objects/worker_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+class DummyClass 
+  def self.do_somthing_with_array_of_hashes(arr)
+    arr[0][:foo]
+  end
+
+  def self.do_something_without_args
+    true
+  end
+
+  def self.identity_function(data)
+    data
+  end
+
+  def self.join(arg1, arg2)
+    "#{arg1}|#{arg2}"
+  end
+end
+
+describe Kiqit::Workers::Objects::Worker do
+  subject { Kiqit::Workers::Objects::Worker.new }
+
+  it "should pass an array of hashes into the method" do
+    arr = [
+      { foo: "bar" },
+      { bar: "foo" }
+    ]
+    arr = Kiqit::ArgsParser.args_to_sidekiq(arr)
+    subject.perform("DummyClass", :do_somthing_with_array_of_hashes, arr).should == "bar"
+  end
+
+  it "should pass no args to the method" do
+    subject.perform("DummyClass", :do_something_without_args).should == true
+  end
+
+  it "should pass a single argument (user)" do
+    user = User.create
+    args = Kiqit::ArgsParser.args_to_sidekiq(user)
+    subject.perform("DummyClass", :identity_function, args).should == user
+  end
+
+  it "should pass a single argument (user) when translated args are passed in" do
+    user = User.create
+    user_arg = "AR:User:#{user.id}"
+    mock_user = double(:user, first: nil)
+    User.should_receive(:where).with(id: user.id.to_s).and_return { mock_user }
+    
+    subject.perform("DummyClass", :identity_function, user_arg).should == nil
+  end
+
+  it "should pass an array with one entry" do
+    users = [User.create]
+    args = Kiqit::ArgsParser.args_to_sidekiq(users)
+    subject.perform("DummyClass", :identity_function, args).should == users
+  end
+
+  it "should pass multi dimension arrays" do
+    data = [1, 2, User.create, ["a", "b", "c"]]
+    args = Kiqit::ArgsParser.args_to_sidekiq(data)
+    subject.perform("DummyClass", :identity_function, args).should == data
+  end
+
+  it 'should pass AR and hash' do
+    user = User.create
+    arr = {
+        something_a: "aaa",
+        something_b: "bbb"
+      }
+    arg1 = Kiqit::ArgsParser.args_to_sidekiq(user)
+    arg2 = Kiqit::ArgsParser.args_to_sidekiq(arr)
+    subject.perform("DummyClass", :join, arg1, arg2).split("|")[1].should == "{:something_a=>\"aaa\", :something_b=>\"bbb\"}"
+  end
+end

data/spec/lib/object_perform_later_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+class DummyClass 
+  def self.do_something_really_heavy
+        
+  end
+
+  def self.do_something_with_string(value)
+    value
+  end
+
+  def self.do_something_with_user(user)
+    user
+  end
+
+  def self.do_something_with_multiple_args(a, b)
+    "#{a}, #{b}"
+  end
+
+  def self.do_something_with_optional_hash(options = {})
+    options.blank?
+  end
+
+  def self.do_something_with_array(arr)
+    arr
+  end
+end
+
+describe ObjectKiqit do
+  it "should insert a task into sidekiq when the config is enabled" do
+    Sidekiq.redis = $redis
+
+    Kiqit.config.stub(:enabled?).and_return(true)
+    User.kiqit(:generic, :get_metadata)
+
+    Sidekiq::Queue.new(:generic).size.should == 1
+  end
+
+  it "should send the method on the class when the config is disabled" do
+    Kiqit.config.stub(:enabled?).and_return(false)
+    
+    User.should_receive(:get_metadata)
+    User.kiqit(:generic, :get_metadata)
+
+    Sidekiq::Queue.new(:generic).size.should == 0
+  end
+
+  it "should only add the method a single time to the queue" do
+    Kiqit.config.stub(:enabled?).and_return(true)
+    
+    DummyClass.kiqit!(:generic, :do_something_really_heavy)
+    DummyClass.kiqit!(:generic, :do_something_really_heavy)
+    DummyClass.kiqit!(:generic, :do_something_really_heavy)
+    DummyClass.kiqit!(:generic, :do_something_really_heavy)
+
+    Sidekiq::Queue.new(:generic).size.should == 1
+  end
+
+  describe "When Enabled" do
+    let(:user) { User.create }
+
+    it "should pass no values" do
+      Kiqit.config.stub(:enabled?).and_return(true)
+      Sidekiq::Client.should_receive(:push).with("queue" => :generic, "class" => Kiqit::Workers::Objects::Worker, "args" => ["DummyClass", :do_something_with_array])
+      DummyClass.kiqit(:generic, :do_something_with_array)
+    end
+
+    it "should pass the correct value (array)" do
+      Kiqit.config.stub(:enabled?).and_return(true)
+      Sidekiq::Client.should_receive(:push).with("queue" => :generic, "class" => Kiqit::Workers::Objects::Worker, "args" => ["DummyClass", :do_something_with_array, [1,2,3,4,5]])
+      DummyClass.kiqit(:generic, :do_something_with_array, [1,2,3,4,5])
+    end
+
+    it "should pass multiple args" do
+      Kiqit.config.stub(:enabled?).and_return(true)
+      Sidekiq::Client.should_receive(:push).with("queue" => :generic, "class" => Kiqit::Workers::Objects::Worker, "args" => ["DummyClass", :do_something_with_multiple_args, 1, 2])
+      DummyClass.kiqit(:generic, :do_something_with_multiple_args, 1, 2)
+    end
+
+    it "should pass AR and hash" do
+      Kiqit.config.stub(:enabled?).and_return(true)
+      Sidekiq::Client.should_receive(:push).with("queue" => :generic, "class" => Kiqit::Workers::Objects::Worker, "args" => ["DummyClass", :do_something_with_multiple_args, "AR:User:#{user.id}", "---\n:a: 2\n"])
+      DummyClass.kiqit(:generic, :do_something_with_multiple_args, user, {a: 2})
+    end
+  end
+
+  describe :kiqit do
+    before(:each) do
+      Kiqit.config.stub(:enabled?).and_return(false)
+    end
+    
+    it "should pass the correct value (String)" do
+      DummyClass.kiqit(:generic, :do_something_with_string, "Avi Tzurel").should == "Avi Tzurel"
+    end
+
+    it "should pass the correct value (AR object)" do
+      user = User.create
+      DummyClass.kiqit(:generic, :do_something_with_user, user).should == user
+    end
+
+    it "should pass the correct value (optional hash)" do
+      DummyClass.kiqit(:generic, :do_something_with_optional_hash).should == true
+    end
+
+    it "should pass multiple args" do
+      DummyClass.kiqit(:generic, :do_something_with_multiple_args, 1, 2).should == "1, 2"
+    end
+
+    it "should pass AR and hash" do
+      u = User.create
+      DummyClass.kiqit(:generic, :do_something_with_multiple_args, u, {a: 2}).should == "#{u}, {:a=>2}"
+    end
+  end
+
+  describe :kiqit! do
+    before(:each) do
+      Kiqit.config.stub(:enabled?).and_return(false)
+    end
+    it "should pass the correct value (String)" do
+      DummyClass.kiqit!(:generic, :do_something_with_string, "Avi Tzurel").should == "Avi Tzurel"
+    end
+
+    it "should pass the correct value (AR object)" do
+      user = User.create
+      DummyClass.kiqit!(:generic, :do_something_with_user, user).should == user
+    end
+
+    it "should pass the correct value (optional hash)" do
+      DummyClass.kiqit!(:generic, :do_something_with_optional_hash).should == true
+    end
+
+    it "should pass multiple args" do
+      DummyClass.kiqit!(:generic, :do_something_with_multiple_args, 1, 2).should == "1, 2"
+    end
+
+    it "should pass AR and hash" do
+      u = User.create
+      DummyClass.kiqit!(:generic, :do_something_with_multiple_args, u, {a: 2}).should == "#{u}, {:a=>2}"
+    end
+  end
+end

data/spec/lib/perform_later_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Kiqit do
+  
+end

data/spec/lib/sidekiq/plugins/later/method_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Sidekiq::Plugins::Later::Method do
+  before(:each) { Kiqit.config.enabled = true }
+  before(:each) { Sidekiq.redis = $redis }
+  
+  context "enabled" do
+    before(:each) do 
+      Kiqit.config.stub(:enabled?).and_return(true)
+      User.later :long_running_method
+    end
+
+    it "should insert a task into sidekiq when the config is enabled" do
+      user = User.create
+      user.long_running_method
+      Sidekiq::Queue.new(:generic).size.should == 1
+    end
+  end
+
+  context "loner" do
+    before(:each) do 
+      Kiqit.config.stub(:enabled?).and_return(true)
+      User.later :lonely_long_running_method, loner: true
+    end
+
+    it "should only add a single method to the queue, since the config is with a loner" do
+      user = User.create
+      user.lonely_long_running_method
+      user.lonely_long_running_method
+      user.lonely_long_running_method
+      user.lonely_long_running_method
+      user.lonely_long_running_method
+      Sidekiq::Queue.new(:generic).size.should == 1
+    end
+
+    it "should only add a single method to the queue, since the config is with a loner when using kiqit! method" do
+      user = User.create
+      user.kiqit!(:generic, :lonely_long_running_method)
+      user.kiqit!(:generic, :lonely_long_running_method)
+      user.kiqit!(:generic, :lonely_long_running_method)
+      user.kiqit!(:generic, :lonely_long_running_method)
+      user.kiqit!(:generic, :lonely_long_running_method)
+      Sidekiq::Queue.new(:generic).size.should == 1
+    end
+  end
+
+  context "disabled" do
+    it "should send the method on the class when the config is disabled" do
+      user = User.create
+      user.now_long_running_method
+      Sidekiq::Queue.new(:generic).size.should == 0
+    end
+  end
+
+  context 'arguments to Sidekiq' do
+    it 'should send no args to sidekiq' do
+      user = User.create
+      Sidekiq::Client.should_receive(:push).with("queue" => :generic, "class" => Kiqit::Workers::ActiveRecord::Worker, "args" => ['User', user.id, :lonely_long_running_method])
+      user.kiqit(:generic, :lonely_long_running_method)
+    end
+
+    it 'should send 1 arg to sidekiq' do
+      user = User.create
+      Sidekiq::Client.should_receive(:push).with("queue" => :generic, "class" => Kiqit::Workers::ActiveRecord::LoneWorker, "args" => ['User', user.id, :lonely_long_running_method, 1])
+      user.kiqit!(:generic, :lonely_long_running_method, 1)
+    end
+  end
+
+  it "shold define the correct method on the user model" do
+    user = User.create
+    user.should respond_to(:long_running_method)
+    user.should respond_to(:now_long_running_method)
+  end
+
+  describe :kiqit! do
+    it "should send the correct params on the method (with hash)" do
+      Kiqit.config.stub(:enabled?).and_return(false)
+       user = User.create
+       user.should_receive(:method_with_hash_as_option).with({:some_option => "Brown fox"})
+       user.kiqit!(:generic, :method_with_hash_as_option, :some_option => "Brown fox")
+    end
+
+    it "should send the correct params on the method (with integer)" do
+      Kiqit.config.stub(:enabled?).and_return(false)
+       user = User.create
+       user.should_receive(:method_with_integer_option).with(1).and_return(1)
+       user.kiqit!(:generic, :method_with_integer_option, 1)
+    end 
+  end
+
+  context "delay" do
+    
+    let(:enqueue_in) {5}
+    let(:actual_enqueue) {Time.now + enqueue_in}
+
+    before(:each) do
+      Kiqit.config.stub(:enabled?).and_return(true)    
+      User.later :delayed_long_running_method, :delay => enqueue_in
+    end
+
+    describe :delay do
+      it "should delay enqueuing for the duration of time given, if delay time is given" do
+        user = User.create
+        old_count = Sidekiq.redis{|i| i.zcount("schedule", "-inf", "+inf")}
+        user.delayed_long_running_method
+        new_count = Sidekiq.redis{|i| i.zcount("schedule", "-inf", "+inf")}
+        new_count.should == old_count + 1
+      end
+    end
+
+    describe :kiqit_in do
+      it "should delay enqueuing for the duration of delay time given" do
+        user = User.create
+        old_count = Sidekiq.redis{|i| i.zcount("schedule", "-inf", "+inf")}
+        user.kiqit_in(enqueue_in, :generic, :delayed_long_running_method)
+        new_count = Sidekiq.redis{|i| i.zcount("schedule", "-inf", "+inf")}
+        new_count.should == old_count + 1
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+require "net/http"
+require "uri"
+require "kiqit"
+require "rspec"
+require "support/database_connection"
+require "support/database_models"
+require "redis"
+require 'fakeredis/rspec'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+
+  config.before(:all) do
+    dir = File.join(File.dirname(__FILE__), 'support/db')
+    
+    old_db = File.join(dir, 'test.sqlite3')
+    FileUtils.rm(old_db) if File.exists?(old_db)
+    FileUtils.cp(File.join(dir, '.blank.sqlite3'), File.join(dir, 'test.sqlite3'))
+  end
+
+  config.before(:suite) do
+    $redis = {}
+    $real_redis = Redis.new
+    Sidekiq.redis = $redis
+  end
+
+  config.before(:each) do
+    Sidekiq.redis{|i| i.flushdb}
+  end
+
+  config.after(:each) do
+    Kiqit::Plugins.clear_finder!
+    $real_redis.flushdb
+  end
+end

data/spec/support/database_connection.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: File.join(File.dirname(__FILE__), "db/test.sqlite3")

data/spec/support/database_models.rb

@@ -0,0 +1,30 @@
+class User < ActiveRecord::Base
+  def long_running_method
+    # Your code here
+  end
+  later :long_running_method
+
+  def long_running_method_2
+    # Your code here
+  end
+  later :long_running_method_2, queue: :some_queue_name
+
+  def lonely_long_running_method
+    # Your code here
+  end
+  later :lonely_long_running_method, :loner => true, queue: :some_queue_name
+
+  def delayed_long_running_method
+    # Your code here
+  end
+  later :delayed_long_running_method, :delay => 30, queue: :some_queue_name
+
+  def method_with_hash_as_option(options = {})
+    options[:some_option]
+  end
+
+  def method_with_integer_option(integer)
+    integer
+  end
+
+end