sidekiq-cron 0.2.0 → 0.3.0

data/lib/sidekiq/cron/views/cron.erb

@@ -34,20 +34,20 @@
           </td>
           <td style="<%= style %>">
             <% if job.status == 'enabled' %>
-              <form action="<%= root_path %>cron/<%= job.name %>/enque" method="post">
+              <form action="<%= root_path %>cron/<%= CGI.escape(job.name).gsub('+', '%20') %>/enque" method="post">
                 <input class='btn btn-xs pull-left' type="submit" name="enque" value="<%= t('EnqueueNow') %>"/>
               </form>
-              <form action="<%= root_path %>cron/<%= job.name %>/disable" method="post">
+              <form action="<%= root_path %>cron/<%= CGI.escape(job.name).gsub('+', '%20') %>/disable" method="post">
                 <input class='btn btn-xs pull-left' type="submit" name="disable" value="<%= t('Disable') %>"/>
               </form>
             <% else %>
-              <form action="<%= root_path %>cron/<%= job.name %>/enque" method="post">
+              <form action="<%= root_path %>cron/<%= CGI.escape(job.name).gsub('+', '%20') %>/enque" method="post">
                 <input class='btn btn-xs pull-left' type="submit" name="enque" value="<%= t('EnqueueNow') %>"/>
               </form>
-              <form action="<%= root_path %>cron/<%= job.name %>/enable" method="post">
+              <form action="<%= root_path %>cron/<%= CGI.escape(job.name).gsub('+', '%20') %>/enable" method="post">
                 <input class='btn btn-xs pull-left' type="submit" name="enable" value="<%= t('Enable') %>"/>
               </form>
-              <form action="<%= root_path %>cron/<%= job.name %>/delete" method="post">
+              <form action="<%= root_path %>cron/<%= CGI.escape(job.name).gsub('+', '%20') %>/delete" method="post">
                 <input class='btn btn-xs btn-danger pull-left' type="submit" name="delete" value="<%= t('Delete') %>" data-confirm="<%= t('AreYouSureDeleteCronJob', :job => job.name) %>"/>
               </form>
             <% end %>

data/lib/sidekiq/cron/views/cron.slim

@@ -10,7 +10,7 @@ header.row
       th = t('Cron')
       th = t('Last enque')
       th = t('Arguments')
-      th width="253px" 
+      th width="253px"
         = t('Actions')
 
 
@@ -31,16 +31,16 @@ header.row
             = job.message
         td[style="#{style}"]
           -if job.status == 'enabled'
-            form action="#{root_path}cron/#{job.name}/enque" method="post"
+            form action="#{root_path}cron/#{CGI.escape(job.name).gsub('+', '%20')}/enque" method="post"
               input.btn.btn-small.pull-left type="submit" name="enque" value="#{t('EnqueueNow')}"
-            form action="#{root_path}cron/#{job.name}/disable" method="post"
+            form action="#{root_path}cron/#{CGI.escape(job.name).gsub('+', '%20')}/disable" method="post"
               input.btn.btn-small.pull-left type="submit" name="disable" value="#{t('Disable')}"
-          -else 
-            form action="#{root_path}cron/#{job.name}/enque" method="post"
+          -else
+            form action="#{root_path}cron/#{CGI.escape(job.name).gsub('+', '%20')}/enque" method="post"
               input.btn.btn-small.pull-left type="submit" name="enque" value="#{t('EnqueueNow')}"
-            form action="#{root_path}cron/#{job.name}/enable" method="post"
+            form action="#{root_path}cron/#{CGI.escape(job.name).gsub('+', '%20')}/enable" method="post"
               input.btn.btn-small.pull-left type="submit" name="enable" value="#{t('Enable')}"
-            form action="#{root_path}cron/#{job.name}/delete" method="post"
+            form action="#{root_path}cron/#{CGI.escape(job.name).gsub('+', '%20')}/delete" method="post"
               input.btn.btn-danger.btn-small type="submit" name="delete" value="#{t('Delete')}" data-confirm="#{t('AreYouSureDeleteCronJob', :job => job.name)}"
 
 - else

data/lib/sidekiq/cron/web.rb

@@ -0,0 +1,12 @@
+require "sidekiq/cron/web_extension"
+
+if defined?(Sidekiq::Web)
+  Sidekiq::Web.register Sidekiq::Cron::WebExtension
+
+  if Sidekiq::Web.tabs.is_a?(Array)
+    # For sidekiq < 2.5
+    Sidekiq::Web.tabs << "cron"
+  else
+    Sidekiq::Web.tabs["Cron"] = "cron"
+  end
+end

data/sidekiq-cron.gemspec

@@ -2,14 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+# stub: sidekiq-cron 0.3.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "sidekiq-cron"
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
   s.authors = ["Ondrej Bartas"]
-  s.date = "2014-01-31"
+  s.date = "2015-06-26"
   s.description = "Enables to set jobs to be run in specified time (using CRON notation)"
   s.email = "ondrej@bartas.cz"
   s.extra_rdoc_files = [
@@ -36,6 +38,7 @@ Gem::Specification.new do |s|
     "lib/sidekiq/cron/poller.rb",
     "lib/sidekiq/cron/views/cron.erb",
     "lib/sidekiq/cron/views/cron.slim",
+    "lib/sidekiq/cron/web.rb",
     "lib/sidekiq/cron/web_extension.rb",
     "sidekiq-cron.gemspec",
     "test/test_helper.rb",
@@ -45,12 +48,11 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/ondrejbartas/sidekiq-cron"
   s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.23"
+  s.rubygems_version = "2.4.5"
   s.summary = "Sidekiq Cron helps to add repeated scheduled jobs"
 
   if s.respond_to? :specification_version then
-    s.specification_version = 3
+    s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<tilt>, ["< 2.0.0"])
@@ -59,10 +61,11 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<bundler>, [">= 0"])
       s.add_development_dependency(%q<simplecov>, [">= 0"])
       s.add_development_dependency(%q<shoulda-context>, [">= 0"])
-      s.add_development_dependency(%q<turn>, [">= 0"])
       s.add_development_dependency(%q<rack>, [">= 0"])
       s.add_development_dependency(%q<rack-test>, [">= 0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_development_dependency(%q<minitest>, [">= 0"])
+      s.add_development_dependency(%q<test-unit>, [">= 0"])
       s.add_development_dependency(%q<sdoc>, [">= 0"])
       s.add_development_dependency(%q<slim>, [">= 0"])
       s.add_development_dependency(%q<sinatra>, [">= 0"])
@@ -76,10 +79,11 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<bundler>, [">= 0"])
       s.add_dependency(%q<simplecov>, [">= 0"])
       s.add_dependency(%q<shoulda-context>, [">= 0"])
-      s.add_dependency(%q<turn>, [">= 0"])
       s.add_dependency(%q<rack>, [">= 0"])
       s.add_dependency(%q<rack-test>, [">= 0"])
       s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_dependency(%q<minitest>, [">= 0"])
+      s.add_dependency(%q<test-unit>, [">= 0"])
       s.add_dependency(%q<sdoc>, [">= 0"])
       s.add_dependency(%q<slim>, [">= 0"])
       s.add_dependency(%q<sinatra>, [">= 0"])
@@ -94,10 +98,11 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<bundler>, [">= 0"])
     s.add_dependency(%q<simplecov>, [">= 0"])
     s.add_dependency(%q<shoulda-context>, [">= 0"])
-    s.add_dependency(%q<turn>, [">= 0"])
     s.add_dependency(%q<rack>, [">= 0"])
     s.add_dependency(%q<rack-test>, [">= 0"])
     s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    s.add_dependency(%q<minitest>, [">= 0"])
+    s.add_dependency(%q<test-unit>, [">= 0"])
     s.add_dependency(%q<sdoc>, [">= 0"])
     s.add_dependency(%q<slim>, [">= 0"])
     s.add_dependency(%q<sinatra>, [">= 0"])

data/test/test_helper.rb

@@ -9,7 +9,7 @@ rescue Bundler::BundlerError => e
 end
 
 require 'simplecov'
-SimpleCov.start do 
+SimpleCov.start do
   add_filter "/test/"
 
   add_group 'SidekiqCron', 'lib/'
@@ -19,7 +19,6 @@ Coveralls.wear!
 
 require "minitest/autorun"
 require 'shoulda-context'
-require 'turn'
 require "rack/test"
 require "mocha/setup"
 
@@ -44,10 +43,7 @@ end
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'sidekiq-cron'
-
-class Test::Unit::TestCase
-end
-
+require 'sidekiq/cron/web'
 
 class CronTestClass
   include Sidekiq::Worker
@@ -65,4 +61,3 @@ class CronTestClassWithQueue
     puts "super croned job #{args}"
   end
 end
-

data/test/unit/job_test.rb

@@ -1,584 +1,709 @@
 # -*- encoding : utf-8 -*-
 require './test/test_helper'
 
-class CronJobTest < Test::Unit::TestCase
-  context "Cron Job" do
+describe "Cron Job" do
 
-    setup do 
-      #clear all previous saved data from redis
-      Sidekiq.redis do |conn|
-        conn.keys("cron_job*").each do |key|
-          conn.del(key)
-        end
+  before do
+    #clear all previous saved data from redis
+    Sidekiq.redis do |conn|
+      conn.keys("cron_job*").each do |key|
+        conn.del(key)
       end
+    end
 
-      #clear all queues
-      Sidekiq::Queue.all.each do |queue|
-        queue.clear
-      end
+    #clear all queues
+    Sidekiq::Queue.all.each do |queue|
+      queue.clear
     end
+  end
 
-    should "be initialized" do
-      job = Sidekiq::Cron::Job.new()
-      assert_nil job.last_enqueue_time
-      assert job.is_a?(Sidekiq::Cron::Job)
+  it "be initialized" do
+    job = Sidekiq::Cron::Job.new()
+    assert_nil job.last_enqueue_time
+    assert job.is_a?(Sidekiq::Cron::Job)
+  end
+
+  describe "class methods" do
+    it "have create method" do
+      assert Sidekiq::Cron::Job.respond_to?(:create)
     end
 
-    context "class methods" do
-      should "have create method" do
-        assert Sidekiq::Cron::Job.respond_to?(:create)
-      end
+    it "have destroy method" do
+      assert Sidekiq::Cron::Job.respond_to?(:destroy)
+    end
 
-      should "have destroy method" do
-        assert Sidekiq::Cron::Job.respond_to?(:destroy)
-      end
+    it "have count" do
+      assert Sidekiq::Cron::Job.respond_to?(:count)
+    end
 
-      should "have count" do
-        assert Sidekiq::Cron::Job.respond_to?(:count)
-      end
+    it "have all" do
+      assert Sidekiq::Cron::Job.respond_to?(:all)
+    end
 
-      should "have all" do
-        assert Sidekiq::Cron::Job.respond_to?(:all)
-      end
+    it "have find" do
+      assert Sidekiq::Cron::Job.respond_to?(:find)
+    end
+  end
 
-      should "have find" do
-        assert Sidekiq::Cron::Job.respond_to?(:find)
-      end
+  describe "instance methods" do
+    before do
+      @job = Sidekiq::Cron::Job.new()
     end
 
-    context "instance methods" do
-      setup do 
-        @job = Sidekiq::Cron::Job.new()
-      end 
-      
-      should "have save method" do
-        assert @job.respond_to?(:save)
-      end
-      should "have valid? method" do
-        assert @job.respond_to?("valid?".to_sym)
-      end
-      should "have destroy method" do
-        assert @job.respond_to?(:destroy)
-      end
+    it "have save method" do
+      assert @job.respond_to?(:save)
+    end
+    it "have valid? method" do
+      assert @job.respond_to?("valid?".to_sym)
+    end
+    it "have destroy method" do
+      assert @job.respond_to?(:destroy)
+    end
 
-      should 'have sort_name - used for sorting enabled disbaled jobs on frontend' do
-        job = Sidekiq::Cron::Job.new(name: "TestName")
-        assert_equal job.sort_name, "0_testname"
-      end
+    it 'have sort_name - used for sorting enabled disbaled jobs on frontend' do
+      job = Sidekiq::Cron::Job.new(name: "TestName")
+      assert_equal job.sort_name, "0_testname"
     end
+  end
 
-    context "invalid job" do
-      
-      setup do
-        @job = Sidekiq::Cron::Job.new()
-      end
+  describe "invalid job" do
 
-      should "return false on valid? and errors" do
-        refute @job.valid?
-        assert @job.errors.is_a?(Array)
+    before do
+      @job = Sidekiq::Cron::Job.new()
+    end
 
-        assert @job.errors.any?{|e| e.include?("name")}, "Should have error for name"
-        assert @job.errors.any?{|e| e.include?("cron")}, "Should have error for cron"
-        assert @job.errors.any?{|e| e.include?("klass")}, "Should have error for klass"
-      end
+    it "allow a class instance for the klass" do
+      @job.klass = CronTestClass
 
-      should "return false on valid? with invalid cron" do
-        @job.cron = "* s *"
-        refute @job.valid?
-        assert @job.errors.is_a?(Array)
-        assert @job.errors.any?{|e| e.include?("cron")}, "Should have error for cron"
-      end
+      refute @job.valid?
+      refute @job.errors.any?{|e| e.include?("klass")}, "Should not have error for klass"
+    end
 
-      should "return false on save" do
-        refute @job.save
-      end
+    it "return false on valid? and errors" do
+      refute @job.valid?
+      assert @job.errors.is_a?(Array)
+
+      assert @job.errors.any?{|e| e.include?("name")}, "Should have error for name"
+      assert @job.errors.any?{|e| e.include?("cron")}, "Should have error for cron"
+      assert @job.errors.any?{|e| e.include?("klass")}, "Should have error for klass"
     end
 
-    context "new" do
-      setup do 
-        @args = {
-          name: "Test",
-          cron: "* * * * *"
-        }
-        @job = Sidekiq::Cron::Job.new(@args)
-      end
+    it "return false on valid? with invalid cron" do
+      @job.cron = "* s *"
+      refute @job.valid?
+      assert @job.errors.is_a?(Array)
+      assert @job.errors.any?{|e| e.include?("cron")}, "Should have error for cron"
+    end
 
-      should "have all setted attributes" do
-        @args.each do |key, value|
-          assert_equal @job.send(key), value, "New job should have #{key} with value #{value} but it has: #{@job.send(key)}"
-        end
-      end
+    it "return false on save" do
+      refute @job.save
+    end
+  end
 
-      should "have to_hash method" do
-        [:name,:klass,:cron,:args,:message,:status].each do |key|
-          assert @job.to_hash.has_key?(key), "to_hash must have key: #{key}"
-        end
-      end
+  describe "new" do
+    before do
+      @args = {
+        name: "Test",
+        cron: "* * * * *"
+      }
+      @job = Sidekiq::Cron::Job.new(@args)
     end
 
-    context "new with different class inputs" do
-      should "be initialized by 'klass' and Class" do
-        assert_nothing_raised do
-          Sidekiq::Cron::Job.new('klass' => CronTestClass)
-        end
+    it "have all setted attributes" do
+      @args.each do |key, value|
+        assert_equal @job.send(key), value, "New job should have #{key} with value #{value} but it has: #{@job.send(key)}"
       end
+    end
 
-      should "be initialized by 'klass' and string Class" do
-        assert_nothing_raised do
-          Sidekiq::Cron::Job.new('klass' => 'CronTestClass')
-        end
+    it "have to_hash method" do
+      [:name,:klass,:cron,:args,:message,:status].each do |key|
+        assert @job.to_hash.has_key?(key), "to_hash must have key: #{key}"
       end
+    end
+  end
 
-      should "be initialized by 'class' and string Class" do
-        assert_nothing_raised do
-          Sidekiq::Cron::Job.new('class' => 'CronTestClass')
-        end
-      end
+  describe "new with different class inputs" do
+    it "be initialized by 'klass' and Class" do
+      job = Sidekiq::Cron::Job.new('klass' => CronTestClass)
+      assert_equal job.message['class'], 'CronTestClass'
+    end
 
-      should "be initialized by 'class' and Class" do
-        assert_nothing_raised do
-          Sidekiq::Cron::Job.new('class' => CronTestClass)
-        end
-      end
+    it "be initialized by 'klass' and string Class" do
+      job = Sidekiq::Cron::Job.new('klass' => 'CronTestClass')
+      assert_equal job.message['class'], 'CronTestClass'
     end
 
-    context "new should find klass specific settings (queue, retry ...)" do
-      should "nothing raise on unknown klass" do
-        assert_nothing_raised do
-          job = Sidekiq::Cron::Job.new('klass' => 'UnknownCronClass')
-          assert_equal job.message, {"class"=>"UnknownCronClass", "args"=>[], "queue"=>"default"}
-        end
-      end
+    it "be initialized by 'class' and string Class" do
+      job = Sidekiq::Cron::Job.new('class' => 'CronTestClass')
+      assert_equal job.message['class'], 'CronTestClass'
+    end
 
-      should "be initialized with default attributes" do
-        assert_nothing_raised do
-          job = Sidekiq::Cron::Job.new('klass' => 'CronTestClass')
+    it "be initialized by 'class' and Class" do
+      job = Sidekiq::Cron::Job.new('class' => CronTestClass)
+      assert_equal job.message['class'], 'CronTestClass'
+    end
+  end
 
-          assert_equal job.message, {"retry"=>true, "queue"=>"default", "class"=>"CronTestClass", "args"=>[]}
-        end
-      end
+  describe "new should find klass specific settings (queue, retry ...)" do
+    it "nothing raise on unknown klass" do
+      job = Sidekiq::Cron::Job.new('klass' => 'UnknownCronClass')
+      assert_equal job.message, {"class"=>"UnknownCronClass", "args"=>[], "queue"=>"default"}
+    end
 
-      should "be initialized with class specified attributes" do
-        assert_nothing_raised do
-          job = Sidekiq::Cron::Job.new('class' => 'CronTestClassWithQueue')
-          assert_equal job.message, {"retry"=>false,
-                                     "queue"=>:super,
-                                     "backtrace"=>true,
-                                     "class"=>"CronTestClassWithQueue",
-                                     "args"=>[]}
-        end
-      end
+    it "be initialized with default attributes" do
+      job = Sidekiq::Cron::Job.new('klass' => 'CronTestClass')
+      assert_equal job.message, {"retry"=>true, "queue"=>"default", "class"=>"CronTestClass", "args"=>[]}
+    end
 
-      should "be initialized with 'class' and overwrite queue by settings" do
-        assert_nothing_raised do
-          job = Sidekiq::Cron::Job.new('class' => CronTestClassWithQueue, queue: 'my_testing_queue')
+    it "be initialized with class specified attributes" do
+      job = Sidekiq::Cron::Job.new('class' => 'CronTestClassWithQueue')
+      assert_equal job.message, {"retry"=>false,
+                                 "queue"=>:super,
+                                 "backtrace"=>true,
+                                 "class"=>"CronTestClassWithQueue",
+                                 "args"=>[]}
+    end
 
-          assert_equal job.message, {"retry"=>false,
-                                     "queue"=>'my_testing_queue',
-                                     "backtrace"=>true,
-                                     "class"=>"CronTestClassWithQueue",
-                                     "args"=>[]}
-        end
-      end
+    it "be initialized with 'class' and overwrite queue by settings" do
+      job = Sidekiq::Cron::Job.new('class' => CronTestClassWithQueue, queue: 'my_testing_queue')
+
+      assert_equal job.message, {"retry"=>false,
+                                 "queue"=>'my_testing_queue',
+                                 "backtrace"=>true,
+                                 "class"=>"CronTestClassWithQueue",
+                                 "args"=>[]}
     end
- 
-    context "cron test" do
-      setup do
-        @job = Sidekiq::Cron::Job.new()
-      end
+  end
 
-      should "return previous minute" do
-        @job.cron = "* * * * *"
-        time = Time.now
-        assert_equal @job.last_time(time).strftime("%Y-%m-%d-%H-%M-%S"), time.strftime("%Y-%m-%d-%H-%M-00")
-      end
+  describe "cron test" do
+    before do
+      @job = Sidekiq::Cron::Job.new()
+    end
 
-      should "return previous hour" do
-        @job.cron = "1 * * * *"
-        time = Time.now
-        assert_equal @job.last_time(time).strftime("%Y-%m-%d-%H-%M-%S"), time.strftime("%Y-%m-%d-%H-01-00")
-      end
+    it "return previous minute" do
+      @job.cron = "* * * * *"
+      time = Time.now
+      assert_equal @job.last_time(time).strftime("%Y-%m-%d-%H-%M-%S"), time.strftime("%Y-%m-%d-%H-%M-00")
+    end
+
+    it "return previous hour" do
+      @job.cron = "1 * * * *"
+      time = Time.now
+      assert_equal @job.last_time(time).strftime("%Y-%m-%d-%H-%M-%S"), time.strftime("%Y-%m-%d-%H-01-00")
+    end
+
+    it "return previous day" do
+      @job.cron = "1 2 * * *"
+      time = Time.now
 
-      should "return previous day" do
-        @job.cron = "1 2 * * *"
-        time = Time.now
+      if time.hour >= 2
         assert_equal @job.last_time(time).strftime("%Y-%m-%d-%H-%M-%S"), time.strftime("%Y-%m-%d-02-01-00")
+      else
+        yesterday = Date.today - 1
+        assert_equal @job.last_time(time).strftime("%Y-%m-%d-%H-%M-%S"), yesterday.strftime("%Y-%m-%d-02-01-00")
       end
+    end
+  end
 
+  describe '#sidekiq_worker_message' do
+    before do
+      @args = {
+        name:  'Test',
+        cron:  '* * * * *',
+        queue: 'super_queue',
+        klass: 'CronTestClass',
+        args:  { foo: 'bar' }
+      }
+      @job = Sidekiq::Cron::Job.new(@args)
     end
 
-    context "save" do 
-      setup do 
+    it 'should return valid payload for Sidekiq::Client' do
+      payload = {
+        "retry" => true,
+        "queue" => "super_queue",
+        "class" => "CronTestClass",
+        "args"  => [{:foo=>"bar"}]
+      }
+      assert_equal @job.sidekiq_worker_message, payload
+    end
+  end
+
+  describe '#active_job_message' do
+    before do
+      SecureRandom.stubs(:uuid).returns('XYZ')
+
+      @args = {
+        name:  'Test',
+        cron:  '* * * * *',
+        klass: 'CronTestClass',
+        queue: 'super_queue',
+        args:  { foo: 'bar' }
+      }
+      @job = Sidekiq::Cron::Job.new(@args)
+    end
+
+    it 'should return valid payload for Sidekiq::Client' do
+      payload = {
+        'class' => 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper',
+        'queue' => 'super_queue',
+        'args'  =>[{
+          'job_class'  => 'CronTestClass',
+          'job_id'     => 'XYZ',
+          'queue_name' => 'super_queue',
+          'arguments'  => [{foo: 'bar'}]
+        }]
+      }
+      assert_equal @job.active_job_message, payload
+    end
+  end
+
+  describe '#enque!' do
+    describe 'active job' do
+      before do
+        module ActiveJob
+          class Base; end
+        end
+        class ActiveJobTest < ActiveJob::Base; end
+
         @args = {
-          name: "Test",
-          cron: "* * * * *",
-          klass: "CronTestClass"
+          name:  'Test',
+          cron:  '* * * * *',
+          klass: 'ActiveJobTest'
         }
         @job = Sidekiq::Cron::Job.new(@args)
       end
 
-      should "be saved" do
-        assert @job.save
+      it 'pushes to queue active jobs message' do
+        @job.expects(:active_job_message)
+          .returns('class' => 'Test', 'args' => [])
+        @job.enque!
       end
+    end
 
+    describe 'sidekiq worker' do
+      before do
+        @args = {
+          name:  'Test',
+          cron:  '* * * * *',
+          klass: 'CronTestClass'
+        }
+        @job = Sidekiq::Cron::Job.new(@args)
+      end
 
-      should "be saved and found by name" do
-        assert @job.save, "not saved"
-        assert Sidekiq::Cron::Job.find("Test").is_a?(Sidekiq::Cron::Job)
+      it 'pushes to queue active jobs message' do
+        @job.expects(:sidekiq_worker_message)
+          .returns('class' => 'Test', 'args' => [])
+        @job.enque!
       end
     end
+  end
 
-    context "nonexisting job" do
-      should "not be found" do
-        assert Sidekiq::Cron::Job.find("nonexisting").nil?, "should return nil"
-      end
+  describe "save" do
+    before do
+      @args = {
+        name: "Test",
+        cron: "* * * * *",
+        klass: "CronTestClass"
+      }
+      @job = Sidekiq::Cron::Job.new(@args)
     end
 
-    context "disabled/enabled" do
-      setup do 
-        @args = {
-          name: "Test",
-          cron: "* * * * *",
-          klass: "CronTestClass"
-        }
-      end
+    it "be saved" do
+      assert @job.save
+    end
 
-      should "be created and enabled" do
-        Sidekiq::Cron::Job.create(@args)
-        job = Sidekiq::Cron::Job.find(@args)
-        assert_equal job.status, "enabled"
-      end
 
-      should "be created and then enabled and disabled" do
-        Sidekiq::Cron::Job.create(@args)
-        job = Sidekiq::Cron::Job.find(@args)
-        assert_equal job.status, "enabled"
+    it "be saved and found by name" do
+      assert @job.save, "not saved"
+      assert Sidekiq::Cron::Job.find("Test").is_a?(Sidekiq::Cron::Job)
+    end
+  end
 
-        job.enable!
-        assert_equal job.status, "enabled"
+  describe "nonexisting job" do
+    it "not be found" do
+      assert Sidekiq::Cron::Job.find("nonexisting").nil?, "should return nil"
+    end
+  end
 
-        job.disable!
-        assert_equal job.status, "disabled"
-      end
+  describe "disabled/enabled" do
+    before do
+      @args = {
+        name: "Test",
+        cron: "* * * * *",
+        klass: "CronTestClass"
+      }
+    end
 
-      should "be created with status disabled" do
-        Sidekiq::Cron::Job.create(@args.merge(status: "disabled"))
-        job = Sidekiq::Cron::Job.find(@args)
-        assert_equal job.status, "disabled"
-      end
+    it "be created and enabled" do
+      Sidekiq::Cron::Job.create(@args)
+      job = Sidekiq::Cron::Job.find(@args)
+      assert_equal job.status, "enabled"
+    end
 
-      should "be created with status enabled and disable it afterwards" do
-        Sidekiq::Cron::Job.create(@args)
-        job = Sidekiq::Cron::Job.find(@args)
-        assert_equal job.status, "enabled"
-        job.disable!
-        assert_equal job.status, "disabled", "directly after call"
-        job = Sidekiq::Cron::Job.find(@args)
-        assert_equal job.status, "disabled", "after find"
-      end
+    it "be created and then enabled and disabled" do
+      Sidekiq::Cron::Job.create(@args)
+      job = Sidekiq::Cron::Job.find(@args)
+      assert_equal job.status, "enabled"
 
-      should "status shouldn't be rewritten after save without status" do
-        Sidekiq::Cron::Job.create(@args)
-        job = Sidekiq::Cron::Job.find(@args)
-        assert_equal job.status, "enabled"
-        job.disable!
-        assert_equal job.status, "disabled", "directly after call"
-        job = Sidekiq::Cron::Job.find(@args)
-        assert_equal job.status, "disabled", "after find"
-
-        Sidekiq::Cron::Job.create(@args)
-        assert_equal job.status, "disabled", "after second create"
-        job = Sidekiq::Cron::Job.find(@args)
-        assert_equal job.status, "disabled", "after second find"
-      end
+      job.enable!
+      assert_equal job.status, "enabled"
 
-      should "last_enqueue_time shouldn't be rewritten after save" do
-        #adding last_enqueue_time to initialize is only for test purpose
-        last_enqueue_time = '2013-01-01 23:59:59'
-        Sidekiq::Cron::Job.create(@args.merge('last_enqueue_time' => last_enqueue_time))
-        job = Sidekiq::Cron::Job.find(@args)
-        assert_equal job.last_enqueue_time, Time.parse(last_enqueue_time)
+      job.disable!
+      assert_equal job.status, "disabled"
+    end
 
-        Sidekiq::Cron::Job.create(@args)
-        job = Sidekiq::Cron::Job.find(@args)
-        assert_equal job.last_enqueue_time, Time.parse(last_enqueue_time), "after second create should have same time"
-      end
+    it "be created with status disabled" do
+      Sidekiq::Cron::Job.create(@args.merge(status: "disabled"))
+      job = Sidekiq::Cron::Job.find(@args)
+      assert_equal job.status, "disabled"
     end
 
-    context "initialize args" do
-      should "from JSON" do
-        args = {
-          name: "Test",
-          cron: "* * * * *",
-          klass: "CronTestClass",
-          args: JSON.dump(["123"])
-        }
-        Sidekiq::Cron::Job.new(args).tap do |job|
-          assert_equal job.args, ["123"]
-          assert_equal job.name, "Test"
-        end
-      end
-      should "from String" do
-        args = {
-          name: "Test",
-          cron: "* * * * *",
-          klass: "CronTestClass",
-          args: "(my funny string)"
-        }
-        Sidekiq::Cron::Job.new(args).tap do |job|
-          assert_equal job.args, ["(my funny string)"]
-          assert_equal job.name, "Test"
-        end
+    it "be created with status enabled and disable it afterwards" do
+      Sidekiq::Cron::Job.create(@args)
+      job = Sidekiq::Cron::Job.find(@args)
+      assert_equal job.status, "enabled"
+      job.disable!
+      assert_equal job.status, "disabled", "directly after call"
+      job = Sidekiq::Cron::Job.find(@args)
+      assert_equal job.status, "disabled", "after find"
+    end
+
+    it "status shouldn't be rewritten after save without status" do
+      Sidekiq::Cron::Job.create(@args)
+      job = Sidekiq::Cron::Job.find(@args)
+      assert_equal job.status, "enabled"
+      job.disable!
+      assert_equal job.status, "disabled", "directly after call"
+      job = Sidekiq::Cron::Job.find(@args)
+      assert_equal job.status, "disabled", "after find"
+
+      Sidekiq::Cron::Job.create(@args)
+      assert_equal job.status, "disabled", "after second create"
+      job = Sidekiq::Cron::Job.find(@args)
+      assert_equal job.status, "disabled", "after second find"
+    end
+
+    it "last_enqueue_time shouldn't be rewritten after save" do
+      #adding last_enqueue_time to initialize is only for test purpose
+      last_enqueue_time = '2013-01-01 23:59:59'
+      Sidekiq::Cron::Job.create(@args.merge('last_enqueue_time' => last_enqueue_time))
+      job = Sidekiq::Cron::Job.find(@args)
+      assert_equal job.last_enqueue_time, Time.parse(last_enqueue_time)
+
+      Sidekiq::Cron::Job.create(@args)
+      job = Sidekiq::Cron::Job.find(@args)
+      assert_equal job.last_enqueue_time, Time.parse(last_enqueue_time), "after second create should have same time"
+    end
+  end
+
+  describe "initialize args" do
+    it "from JSON" do
+      args = {
+        name: "Test",
+        cron: "* * * * *",
+        klass: "CronTestClass",
+        args: JSON.dump(["123"])
+      }
+      Sidekiq::Cron::Job.new(args).tap do |job|
+        assert_equal job.args, ["123"]
+        assert_equal job.name, "Test"
       end
-      should "from Array" do
-        args = {
-          name: "Test",
-          cron: "* * * * *",
-          klass: "CronTestClass",
-          args: ["This is array"]
-        }
-        Sidekiq::Cron::Job.new(args).tap do |job|
-          assert_equal job.args, ["This is array"]
-          assert_equal job.name, "Test"
-        end
+    end
+    it "from String" do
+      args = {
+        name: "Test",
+        cron: "* * * * *",
+        klass: "CronTestClass",
+        args: "(my funny string)"
+      }
+      Sidekiq::Cron::Job.new(args).tap do |job|
+        assert_equal job.args, ["(my funny string)"]
+        assert_equal job.name, "Test"
       end
     end
-
-    context "create & find methods" do
-      setup do 
-        @args = {
-          name: "Test",
-          cron: "* * * * *",
-          klass: "CronTestClass"
-        }
+    it "from Array" do
+      args = {
+        name: "Test",
+        cron: "* * * * *",
+        klass: "CronTestClass",
+        args: ["This is array"]
+      }
+      Sidekiq::Cron::Job.new(args).tap do |job|
+        assert_equal job.args, ["This is array"]
+        assert_equal job.name, "Test"
       end
+    end
+  end
 
-      should "create first three jobs" do
-        assert_equal Sidekiq::Cron::Job.count, 0, "Should have 0 jobs"
-        Sidekiq::Cron::Job.create(@args)
-        Sidekiq::Cron::Job.create(@args.merge(name: "Test2"))
-        Sidekiq::Cron::Job.create(@args.merge(name: "Test3"))
-        assert_equal Sidekiq::Cron::Job.count, 3, "Should have 3 jobs"
-      end
+  describe "create & find methods" do
+    before do
+      @args = {
+        name: "Test",
+        cron: "* * * * *",
+        klass: "CronTestClass"
+      }
+    end
 
-      should "create first three jobs - 1 has same name" do
-        assert_equal Sidekiq::Cron::Job.count, 0, "Should have 0 jobs"
-        Sidekiq::Cron::Job.create(@args)
-        Sidekiq::Cron::Job.create(@args.merge(name: "Test2"))
-        Sidekiq::Cron::Job.create(@args.merge(cron: "1 * * * *"))
-        assert_equal Sidekiq::Cron::Job.count, 2, "Should have 2 jobs"
-      end
+    it "create first three jobs" do
+      assert_equal Sidekiq::Cron::Job.count, 0, "Should have 0 jobs"
+      Sidekiq::Cron::Job.create(@args)
+      Sidekiq::Cron::Job.create(@args.merge(name: "Test2"))
+      Sidekiq::Cron::Job.create(@args.merge(name: "Test3"))
+      assert_equal Sidekiq::Cron::Job.count, 3, "Should have 3 jobs"
+    end
 
-      should "be found by method all" do
-        Sidekiq::Cron::Job.create(@args)
-        Sidekiq::Cron::Job.create(@args.merge(name: "Test2"))
-        Sidekiq::Cron::Job.create(@args.merge(name: "Test3"))
-        assert_equal Sidekiq::Cron::Job.all.size, 3, "Should have 3 jobs"
-        assert Sidekiq::Cron::Job.all.all?{|j| j.is_a?(Sidekiq::Cron::Job)}, "All returned jobs should be Job class"
-      end
+    it "create first three jobs - 1 has same name" do
+      assert_equal Sidekiq::Cron::Job.count, 0, "Should have 0 jobs"
+      Sidekiq::Cron::Job.create(@args)
+      Sidekiq::Cron::Job.create(@args.merge(name: "Test2"))
+      Sidekiq::Cron::Job.create(@args.merge(cron: "1 * * * *"))
+      assert_equal Sidekiq::Cron::Job.count, 2, "Should have 2 jobs"
+    end
 
-      should "be found by method all - defect in set" do
-        Sidekiq::Cron::Job.create(@args)
-        Sidekiq::Cron::Job.create(@args.merge(name: "Test2"))
-        Sidekiq::Cron::Job.create(@args.merge(name: "Test3"))
+    it "be found by method all" do
+      Sidekiq::Cron::Job.create(@args)
+      Sidekiq::Cron::Job.create(@args.merge(name: "Test2"))
+      Sidekiq::Cron::Job.create(@args.merge(name: "Test3"))
+      assert_equal Sidekiq::Cron::Job.all.size, 3, "Should have 3 jobs"
+      assert Sidekiq::Cron::Job.all.all?{|j| j.is_a?(Sidekiq::Cron::Job)}, "All returned jobs should be Job class"
+    end
 
-        Sidekiq.redis do |conn|
-          conn.sadd Sidekiq::Cron::Job.jobs_key, "some_other_key"
-        end  
+    it "be found by method all - defect in set" do
+      Sidekiq::Cron::Job.create(@args)
+      Sidekiq::Cron::Job.create(@args.merge(name: "Test2"))
+      Sidekiq::Cron::Job.create(@args.merge(name: "Test3"))
 
-        assert_equal Sidekiq::Cron::Job.all.size, 3, "All have to return only valid 3 jobs"
+      Sidekiq.redis do |conn|
+        conn.sadd Sidekiq::Cron::Job.jobs_key, "some_other_key"
       end
 
-      should "be found by string name" do
-        Sidekiq::Cron::Job.create(@args)
-        assert Sidekiq::Cron::Job.find("Test")
-      end
+      assert_equal Sidekiq::Cron::Job.all.size, 3, "All have to return only valid 3 jobs"
+    end
 
-      should "be found by hash with key name" do
-        Sidekiq::Cron::Job.create(@args)
-        assert Sidekiq::Cron::Job.find(name: "Test"), "symbol keys keys"
+    it "be found by string name" do
+      Sidekiq::Cron::Job.create(@args)
+      assert Sidekiq::Cron::Job.find("Test")
+    end
 
-        Sidekiq::Cron::Job.create(@args)
-        assert Sidekiq::Cron::Job.find('name' => "Test"), "String keys"
-      end
+    it "be found by hash with key name" do
+      Sidekiq::Cron::Job.create(@args)
+      assert Sidekiq::Cron::Job.find(name: "Test"), "symbol keys keys"
 
+      Sidekiq::Cron::Job.create(@args)
+      assert Sidekiq::Cron::Job.find('name' => "Test"), "String keys"
     end
 
-    context "destroy" do 
-      setup do 
-        @args = {
-          name: "Test",
-          cron: "* * * * *",
-          klass: "CronTestClass"
-        }
-      end
+  end
 
-      should "create and then destroy by hash" do
-        Sidekiq::Cron::Job.create(@args)
-        assert_equal Sidekiq::Cron::Job.all.size, 1, "Should have 1 job"
+  describe "destroy" do
+    before do
+      @args = {
+        name: "Test",
+        cron: "* * * * *",
+        klass: "CronTestClass"
+      }
+    end
 
-        assert Sidekiq::Cron::Job.destroy(@args)
-        assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 job after destroy"
-      end
+    it "create and then destroy by hash" do
+      Sidekiq::Cron::Job.create(@args)
+      assert_equal Sidekiq::Cron::Job.all.size, 1, "Should have 1 job"
 
-      should "return false on destroying nonexisting" do
-        assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 jobs"
-        refute Sidekiq::Cron::Job.destroy("nonexisting")
-      end
+      assert Sidekiq::Cron::Job.destroy(@args)
+      assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 job after destroy"
+    end
 
-      should "return destroy by string name" do
-        Sidekiq::Cron::Job.create(@args)
-        assert Sidekiq::Cron::Job.destroy("Test")
-      end
+    it "return false on destroying nonexisting" do
+      assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 jobs"
+      refute Sidekiq::Cron::Job.destroy("nonexisting")
+    end
 
-      should "return destroy by hash with key name" do
-        Sidekiq::Cron::Job.create(@args)
-        assert Sidekiq::Cron::Job.destroy(name: "Test"), "symbol keys keys"
+    it "return destroy by string name" do
+      Sidekiq::Cron::Job.create(@args)
+      assert Sidekiq::Cron::Job.destroy("Test")
+    end
 
-        Sidekiq::Cron::Job.create(@args)
-        assert Sidekiq::Cron::Job.destroy('name' => "Test"), "String keys"
-      end
+    it "return destroy by hash with key name" do
+      Sidekiq::Cron::Job.create(@args)
+      assert Sidekiq::Cron::Job.destroy(name: "Test"), "symbol keys keys"
 
+      Sidekiq::Cron::Job.create(@args)
+      assert Sidekiq::Cron::Job.destroy('name' => "Test"), "String keys"
     end
 
-    context "test of enque" do
-      setup do 
-        @args = {
-          name: "Test",
-          cron: "* * * * *",
-          klass: "CronTestClass"
-        }
-        #first time is allways 
-        #after next cron time!
-        @time = Time.now + 120
-      end
-      should "be allways false when status is disabled" do
-        refute Sidekiq::Cron::Job.new(@args.merge(status: 'disabled')).should_enque? @time
-        refute Sidekiq::Cron::Job.new(@args.merge(status: 'disabled')).should_enque? @time - 60
-        refute Sidekiq::Cron::Job.new(@args.merge(status: 'disabled')).should_enque? @time - 120
-        assert_equal Sidekiq::Queue.all.size, 0, "Sidekiq 0 queues"
-      end
+  end
 
-      should "be false for same times" do
-        assert Sidekiq::Cron::Job.new(@args).should_enque?(@time), "First time - true"
-        refute Sidekiq::Cron::Job.new(@args).should_enque? @time
-        refute Sidekiq::Cron::Job.new(@args).should_enque? @time
-      end
+  describe "destroy_removed_jobs" do
+    before do
+      args1 = {
+        name: "WillBeErasedJob",
+        cron: "* * * * *",
+        klass: "CronTestClass"
+      }
+      Sidekiq::Cron::Job.create(args1)
+
+      args2 = {
+        name: "ContinueRemainingJob",
+        cron: "* * * * *",
+        klass: "CronTestClass"
+      }
+      Sidekiq::Cron::Job.create(args2)
+    end
 
-      should "be false for same times but true for next time" do
-        assert Sidekiq::Cron::Job.new(@args).should_enque?(@time), "First time - true"
-        refute Sidekiq::Cron::Job.new(@args).should_enque? @time
-        assert Sidekiq::Cron::Job.new(@args).should_enque? @time + 135
-        refute Sidekiq::Cron::Job.new(@args).should_enque? @time + 135
-        assert Sidekiq::Cron::Job.new(@args).should_enque? @time + 235
-        refute Sidekiq::Cron::Job.new(@args).should_enque? @time + 235
-
-        #just for check
-        refute Sidekiq::Cron::Job.new(@args).should_enque? @time
-        refute Sidekiq::Cron::Job.new(@args).should_enque? @time + 135
-        refute Sidekiq::Cron::Job.new(@args).should_enque? @time + 235
-      end
+    it "be destroied removed job that not exists in args" do
+      assert_equal Sidekiq::Cron::Job.destroy_removed_jobs(["ContinueRemainingJob"]), ["WillBeErasedJob"], "Should be destroyed WillBeErasedJob"
+    end
+  end
 
-      should "remove old enque times + should be enqeued" do
-        job = Sidekiq::Cron::Job.new(@args)
-        assert_nil job.last_enqueue_time
-        assert job.test_and_enque_for_time!(@time), "should enqueue"
-        assert job.last_enqueue_time
+  describe "test of enque" do
+    before do
+      @args = {
+        name: "Test",
+        cron: "* * * * *",
+        klass: "CronTestClass"
+      }
+      #first time is allways
+      #after next cron time!
+      @time = Time.now + 120
+    end
+    it "be allways false when status is disabled" do
+      refute Sidekiq::Cron::Job.new(@args.merge(status: 'disabled')).should_enque? @time
+      refute Sidekiq::Cron::Job.new(@args.merge(status: 'disabled')).should_enque? @time - 60
+      refute Sidekiq::Cron::Job.new(@args.merge(status: 'disabled')).should_enque? @time - 120
+      assert_equal Sidekiq::Queue.all.size, 0, "Sidekiq 0 queues"
+    end
 
-        refute Sidekiq::Cron::Job.new(@args).test_and_enque_for_time!(@time), "should not enqueue"
-        Sidekiq.redis do |conn|
-          assert_equal conn.zcard(Sidekiq::Cron::Job.new(@args).send(:job_enqueued_key)), 2, "Should have two enqueued job (first was in save, second in enque)"
-        end
-        assert_equal Sidekiq::Queue.all.first.size, 1, "Sidekiq queue 1 job in queue"
+    it "be false for same times" do
+      assert Sidekiq::Cron::Job.new(@args).should_enque?(@time), "First time - true"
+      refute Sidekiq::Cron::Job.new(@args).should_enque? @time
+      refute Sidekiq::Cron::Job.new(@args).should_enque? @time
+    end
 
-        # 20 hours after
-        assert Sidekiq::Cron::Job.new(@args).test_and_enque_for_time! @time + 1 * 60 * 60
-        refute Sidekiq::Cron::Job.new(@args).test_and_enque_for_time! @time + 1 * 60 * 60
+    it "be false for same times but true for next time" do
+      assert Sidekiq::Cron::Job.new(@args).should_enque?(@time), "First time - true"
+      refute Sidekiq::Cron::Job.new(@args).should_enque? @time
+      assert Sidekiq::Cron::Job.new(@args).should_enque? @time + 135
+      refute Sidekiq::Cron::Job.new(@args).should_enque? @time + 135
+      assert Sidekiq::Cron::Job.new(@args).should_enque? @time + 235
+      refute Sidekiq::Cron::Job.new(@args).should_enque? @time + 235
+
+      #just for check
+      refute Sidekiq::Cron::Job.new(@args).should_enque? @time
+      refute Sidekiq::Cron::Job.new(@args).should_enque? @time + 135
+      refute Sidekiq::Cron::Job.new(@args).should_enque? @time + 235
+    end
 
-        Sidekiq.redis do |conn|
-          assert_equal conn.zcard(Sidekiq::Cron::Job.new(@args).send(:job_enqueued_key)), 3, "Should have two enqueued job + one from start"
-        end
-        assert_equal Sidekiq::Queue.all.first.size, 2, "Sidekiq queue 2 jobs in queue"
+    it "remove old enque times + should be enqeued" do
+      job = Sidekiq::Cron::Job.new(@args)
+      assert_nil job.last_enqueue_time
+      assert job.test_and_enque_for_time!(@time), "should enqueue"
+      assert job.last_enqueue_time
 
-        # 26 hour after
-        assert Sidekiq::Cron::Job.new(@args).test_and_enque_for_time! @time + 26 * 60 * 60
-        refute Sidekiq::Cron::Job.new(@args).test_and_enque_for_time! @time + 26 * 60 * 60
+      refute Sidekiq::Cron::Job.new(@args).test_and_enque_for_time!(@time), "should not enqueue"
+      Sidekiq.redis do |conn|
+        assert_equal conn.zcard(Sidekiq::Cron::Job.new(@args).send(:job_enqueued_key)), 2, "Should have two enqueued job (first was in save, second in enque)"
+      end
+      assert_equal Sidekiq::Queue.all.first.size, 1, "Sidekiq queue 1 job in queue"
 
-        Sidekiq.redis do |conn|
-          assert_equal conn.zcard(Sidekiq::Cron::Job.new(@args).send(:job_enqueued_key)), 1, "Should have one enqueued job - old jobs should be deleted"
-        end   
-        assert_equal Sidekiq::Queue.all.first.size, 3, "Sidekiq queue 3 jobs in queue"
+      # 20 hours after
+      assert Sidekiq::Cron::Job.new(@args).test_and_enque_for_time! @time + 1 * 60 * 60
+      refute Sidekiq::Cron::Job.new(@args).test_and_enque_for_time! @time + 1 * 60 * 60
+
+      Sidekiq.redis do |conn|
+        assert_equal conn.zcard(Sidekiq::Cron::Job.new(@args).send(:job_enqueued_key)), 3, "Should have two enqueued job + one from start"
       end
+      assert_equal Sidekiq::Queue.all.first.size, 2, "Sidekiq queue 2 jobs in queue"
+
+      # 26 hour after
+      assert Sidekiq::Cron::Job.new(@args).test_and_enque_for_time! @time + 26 * 60 * 60
+      refute Sidekiq::Cron::Job.new(@args).test_and_enque_for_time! @time + 26 * 60 * 60
+
+      Sidekiq.redis do |conn|
+        assert_equal conn.zcard(Sidekiq::Cron::Job.new(@args).send(:job_enqueued_key)), 1, "Should have one enqueued job - old jobs should be deleted"
+      end
+      assert_equal Sidekiq::Queue.all.first.size, 3, "Sidekiq queue 3 jobs in queue"
     end
+  end
 
-    context "load" do
-
-      context "from hash" do
-        setup do 
-          @jobs_hash = {
-            'name_of_job' => {
-              'class' => 'MyClass',
-              'cron'  => '1 * * * *',
-              'args'  => '(OPTIONAL) [Array or Hash]'
-            },
-            'My super iber cool job' => {
-              'class' => 'SecondClass',
-              'cron'  => '*/5 * * * *'
-            }
+  describe "load" do
+
+    describe "from hash" do
+      before do
+        @jobs_hash = {
+          'name_of_job' => {
+            'class' => 'MyClass',
+            'cron'  => '1 * * * *',
+            'args'  => '(OPTIONAL) [Array or Hash]'
+          },
+          'My super iber cool job' => {
+            'class' => 'SecondClass',
+            'cron'  => '*/5 * * * *'
           }
-        end
+        }
+      end
 
-        should "create new jobs and update old one with same settings" do
-          assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 jobs before load"
-          out = Sidekiq::Cron::Job.load_from_hash @jobs_hash
-          assert_equal out.size, 0, "should have no errors"
-          assert_equal Sidekiq::Cron::Job.all.size, 2, "Should have 2 jobs after load"          
-        end
+      it "create new jobs and update old one with same settings" do
+        assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 jobs before load"
+        out = Sidekiq::Cron::Job.load_from_hash @jobs_hash
+        assert_equal out.size, 0, "should have no errors"
+        assert_equal Sidekiq::Cron::Job.all.size, 2, "Should have 2 jobs after load"
+      end
 
-        should "return errors on loaded jobs" do
-          assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 jobs before load"
-          #set something bag to hash
-          @jobs_hash['name_of_job']['cron'] = "bad cron"
-          out = Sidekiq::Cron::Job.load_from_hash @jobs_hash
-          assert_equal 1, out.size, "should have 1 error"
-          assert_equal ({"name_of_job"=>["'cron' -> bad cron: not a valid cronline : 'bad cron'"]}), out
-          assert_equal 1, Sidekiq::Cron::Job.all.size, "Should have only 1 job after load"          
-        end
+      it "return errors on loaded jobs" do
+        assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 jobs before load"
+        #set something bag to hash
+        @jobs_hash['name_of_job']['cron'] = "bad cron"
+        out = Sidekiq::Cron::Job.load_from_hash @jobs_hash
+        assert_equal 1, out.size, "should have 1 error"
+        assert_equal ({"name_of_job"=>["'cron' -> bad cron: not a valid cronline : 'bad cron'"]}), out
+        assert_equal 1, Sidekiq::Cron::Job.all.size, "Should have only 1 job after load"
+      end
 
-        should "create new jobs and then destroy them all" do
-          assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 jobs before load"
-          out = Sidekiq::Cron::Job.load_from_hash @jobs_hash
-          assert_equal out.size, 0, "should have no errors"
-          assert_equal Sidekiq::Cron::Job.all.size, 2, "Should have 2 jobs after load"          
-          Sidekiq::Cron::Job.destroy_all!
-          assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 jobs after destroy all"
-        end
+      it "create new jobs and then destroy them all" do
+        assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 jobs before load"
+        out = Sidekiq::Cron::Job.load_from_hash @jobs_hash
+        assert_equal out.size, 0, "should have no errors"
+        assert_equal Sidekiq::Cron::Job.all.size, 2, "Should have 2 jobs after load"
+        Sidekiq::Cron::Job.destroy_all!
+        assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 jobs after destroy all"
+      end
+
+      it "create new jobs and update old one with same settings with load_from_hash!" do
+        assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 jobs before load"
+        out = Sidekiq::Cron::Job.load_from_hash! @jobs_hash
+        assert_equal out.size, 0, "should have no errors"
+        assert_equal Sidekiq::Cron::Job.all.size, 2, "Should have 2 jobs after load"
+      end
+    end
 
+    describe "from array" do
+      before do
+        @jobs_array = [
+          {
+            'name'  => 'name_of_job',
+            'class' => 'MyClass',
+            'cron'  => '1 * * * *',
+            'args'  => '(OPTIONAL) [Array or Hash]'
+          },
+          {
+            'name'  => 'Cool Job for Second Class',
+            'class' => 'SecondClass',
+            'cron'  => '*/5 * * * *'
+          }
+        ]
       end
 
-      context "from array" do
-        setup do 
-          @jobs_array = [
-            {
-              'name'  => 'name_of_job',
-              'class' => 'MyClass',
-              'cron'  => '1 * * * *',
-              'args'  => '(OPTIONAL) [Array or Hash]'
-            },
-            {
-              'name'  => 'Cool Job for Second Class',
-              'class' => 'SecondClass',
-              'cron'  => '*/5 * * * *'
-            }
-          ]
-        end
+      it "create new jobs and update old one with same settings" do
+        assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 jobs before load"
+        out = Sidekiq::Cron::Job.load_from_array @jobs_array
+        assert_equal out.size, 0, "should have 0 error"
+        assert_equal Sidekiq::Cron::Job.all.size, 2, "Should have 2 jobs after load"
+      end
 
-        should "create new jobs and update old one with same settings" do
-          assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 jobs before load"
-          out = Sidekiq::Cron::Job.load_from_array @jobs_array
-          assert_equal out.size, 0, "should have 0 error"
-          assert_equal Sidekiq::Cron::Job.all.size, 2, "Should have 2 jobs after load"          
-        end
+      it "create new jobs and update old one with same settings with load_from_array" do
+        assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 jobs before load"
+        out = Sidekiq::Cron::Job.load_from_array! @jobs_array
+        assert_equal out.size, 0, "should have 0 error"
+        assert_equal Sidekiq::Cron::Job.all.size, 2, "Should have 2 jobs after load"
       end
     end
   end