sidekiq-cron 0.1.0

data/lib/sidekiq/cron/locales/en.yml

@@ -0,0 +1,7 @@
+en:
+  Job: Job
+  Cron: Cron
+  CronJobs: Cron Jobs
+  EnqueueNow: Enqueue Now
+  AreYouSureDeleteCronJob: Are you sure you want to delete the %{job} cron job?
+  NoCronJobsFound: "No cron jobs found"

data/lib/sidekiq/cron/poller.rb

@@ -0,0 +1,65 @@
+require 'sidekiq'
+require 'sidekiq/util'
+require 'sidekiq/actor'
+require 'sidekiq/cron'
+
+module Sidekiq
+  module Cron
+
+    POLL_INTERVAL = 10
+
+    ##
+    # The Poller checks Redis every N seconds for sheduled cron jobs
+    class Poller
+      include Util
+      include Actor
+
+      def poll(first_time=false)
+        watchdog('scheduling cron poller thread died!') do
+          add_jitter if first_time
+
+          begin
+            time_now = Time.now
+
+            #go through all jobs
+            Sidekiq::Cron::Job.all.each do |job|
+              #test if job should be enequed
+              # if yes add job to queue
+              begin
+                job.test_and_enque_for_time! time_now if job && job.valid?
+              rescue => ex
+                #problem somewhere in one job
+                logger.error "CRON JOB: #{ex.message}"
+                logger.error "CRON JOB: #{ex.backtrace.first}"
+              end
+            end
+
+          rescue => ex
+            # Most likely a problem with redis networking.
+            # Punt and try again at the next interval
+            logger.error ex.message
+            logger.error ex.backtrace.first
+          end
+
+          after(poll_interval) { poll }
+        end
+      end
+
+      private
+
+      def poll_interval
+        Sidekiq.options[:poll_interval] || POLL_INTERVAL
+      end
+
+      def add_jitter
+        begin
+          sleep(poll_interval * rand)
+        rescue Celluloid::Task::TerminatedError
+          # Hit Ctrl-C when Sidekiq is finished booting and we have a chance
+          # to get here.
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+header.row
+  .span5
+    h3 = t('CronJobs')
+- if @cron_jobs.size > 0
+
+  table class="table table-hover table-bordered table-striped"
+    thead
+      th = t('Status')
+      th = t('Name')
+      th = t('Cron')
+      th = t('Last enque')
+      th = t('Arguments')
+      th width="253px" 
+        = t('Actions')
+
+
+    - @cron_jobs.sort{|a,b| a.sort_name <=> b.sort_name }.each_with_index do |job, index|
+      - style = "#{job.status == 'disabled' ? "background: #ecc": ""}"
+      tr
+        td[style="#{style}"]= job.status
+        td[style="#{style}"]= job.name
+        td[style="#{style}"]
+          b == job.cron.gsub(" ", "&nbsp;")
+        td[style="#{style}"]== relative_time(job.last_run_time)
+        td[style="#{style}"]
+          - if job.message and job.message.to_s.size > 100
+            button data-toggle="collapse" data-target=".worker_#{index}" class="btn btn-mini" = t('ShowAll')
+            .toggle[class="worker_#{index}" style="display: inline;"]= job.message[0..100] + "... "
+            .toggle[class="worker_#{index}" style="display: none;"]= job.message
+          - else
+            = job.message
+        td[style="#{style}"]
+          -if job.status == 'enabled'
+            form action="#{root_path}cron/#{job.name}/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"
+              input.btn.btn-small.pull-left type="submit" name="disable" value="#{t('Disable')}"
+          -else 
+            form action="#{root_path}cron/#{job.name}/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"
+              input.btn.btn-small.pull-left type="submit" name="enable" value="#{t('Enable')}"
+            form action="#{root_path}cron/#{job.name}/delete" method="post"
+              input.btn.btn-danger.btn-small type="submit" name="delete" value="#{t('Delete')}" data-confirm="#{t('AreYouSureDeleteCronJob', :job => job.name)}"
+
+- else
+  .alert.alert-success = t('NoCronJobsFound')

data/lib/sidekiq/cron/web_extension.rb

@@ -0,0 +1,75 @@
+module Sidekiq
+  module Cron
+    module WebExtension
+
+      def self.registered(app)
+
+        #very bad way of loading locales for cron jobs
+        #should be rewritten
+        app.helpers do
+
+          alias_method :old_strings, :strings
+
+          def strings
+            #only on first load! 
+            unless @strings
+              #load all locales from Sidekiq
+              old_strings
+
+              Dir["#{File.join(File.expand_path("..", __FILE__), "locales")}/*.yml"].each do |file|
+                YAML.load(File.open(file)).each do |locale, translations|
+                  translations.each do |key, value|
+                    @strings[locale][key] = value
+                  end
+                end
+              end
+            end
+            @strings
+          end
+        end
+
+        #index page of cron jobs
+        app.get '/cron' do 
+          view_path    = File.join(File.expand_path("..", __FILE__), "views")
+
+          @cron_jobs = Sidekiq::Cron::Job.all
+
+          render(:slim, File.read(File.join(view_path, "cron.slim")))
+        end
+
+        #enque cron job
+        app.post '/cron/:name/enque' do |name|
+          if job = Sidekiq::Cron::Job.find(name)
+            job.enque!
+          end
+          redirect "#{root_path}cron"
+        end
+
+        #delete schedule
+        app.post '/cron/:name/delete' do |name|
+          if job = Sidekiq::Cron::Job.find(name)
+            job.destroy
+          end
+          redirect "#{root_path}cron"
+        end
+
+        #enable job
+        app.post '/cron/:name/enable' do |name|
+          if job = Sidekiq::Cron::Job.find(name)
+            job.enable!
+          end
+          redirect "#{root_path}cron"
+        end
+
+        #disable job
+        app.post '/cron/:name/disable' do |name|
+          if job = Sidekiq::Cron::Job.find(name)
+            job.disable!
+          end
+          redirect "#{root_path}cron"
+        end
+        
+      end
+    end
+  end
+end

data/lib/sidekiq/launcher.rb

@@ -0,0 +1,46 @@
+require 'sidekiq/cron/poller'
+
+
+# For Cron we need to add some methods to Launcher
+# so look at the code bellow.
+#
+# we are creating new cron poller instance and
+# adding start and stop commands to launcher
+module Sidekiq
+  class Launcher
+
+    #Add cron poller to launcher
+    attr_reader :cron_poller
+
+
+    #remember old initialize
+    alias_method :old_initialize, :initialize
+
+    #add cron poller and execute normal initialize of Sidekiq launcher
+    def initialize(options)
+      @cron_poller  = Sidekiq::Cron::Poller.new
+      old_initialize options
+    end
+
+
+    #remember old run
+    alias_method :old_run, :run
+
+    #execute normal run of launcher and run cron poller
+    def run
+      old_run
+      cron_poller.async.poll(true)
+    end
+
+
+    #remember old stop
+    alias_method :old_stop, :stop
+
+    #execute normal stop of launcher and stop cron poller
+    def stop
+      cron_poller.async.terminate if poller.alive?
+      old_stop
+    end
+
+  end
+end

data/sidekiq-cron.gemspec

@@ -0,0 +1,104 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "sidekiq-cron"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ondrej Bartas"]
+  s.date = "2013-08-25"
+  s.description = "Enables to set jobs to be run in specified time (using CRON notation)"
+  s.email = "ondrej@bartas.cz"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".travis.yml",
+    "Changes.md",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "config.ru",
+    "examples/web-cron-ui.png",
+    "lib/sidekiq-cron.rb",
+    "lib/sidekiq/cron.rb",
+    "lib/sidekiq/cron/job.rb",
+    "lib/sidekiq/cron/locales/en.yml",
+    "lib/sidekiq/cron/poller.rb",
+    "lib/sidekiq/cron/views/cron.slim",
+    "lib/sidekiq/cron/web_extension.rb",
+    "lib/sidekiq/launcher.rb",
+    "sidekiq-cron.gemspec",
+    "test/test_helper.rb",
+    "test/unit/job_test.rb",
+    "test/unit/poller_test.rb",
+    "test/unit/web_extesion_test.rb"
+  ]
+  s.homepage = "http://github.com/ondrejbartas/sidekiq-cron"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.25"
+  s.summary = "Sidekiq Cron helps to add repeated scheduled jobs"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<sidekiq>, [">= 2.13.1"])
+      s.add_runtime_dependency(%q<parse-cron>, [">= 0.1.2"])
+      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<sdoc>, [">= 0"])
+      s.add_development_dependency(%q<slim>, [">= 0"])
+      s.add_development_dependency(%q<sinatra>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<coveralls>, [">= 0"])
+      s.add_development_dependency(%q<shotgun>, [">= 0"])
+    else
+      s.add_dependency(%q<sidekiq>, [">= 2.13.1"])
+      s.add_dependency(%q<parse-cron>, [">= 0.1.2"])
+      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<sdoc>, [">= 0"])
+      s.add_dependency(%q<slim>, [">= 0"])
+      s.add_dependency(%q<sinatra>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<coveralls>, [">= 0"])
+      s.add_dependency(%q<shotgun>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<sidekiq>, [">= 2.13.1"])
+    s.add_dependency(%q<parse-cron>, [">= 0.1.2"])
+    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<sdoc>, [">= 0"])
+    s.add_dependency(%q<slim>, [">= 0"])
+    s.add_dependency(%q<sinatra>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<coveralls>, [">= 0"])
+    s.add_dependency(%q<shotgun>, [">= 0"])
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,67 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'simplecov'
+SimpleCov.start do 
+  add_filter "/test/"
+
+  add_group 'SidekiqCron', 'lib/'
+end
+require 'coveralls'
+Coveralls.wear!
+
+require "minitest/autorun"
+require 'shoulda-context'
+require 'turn'
+require "rack/test"
+require "mocha/setup"
+
+#SIDEKIQ Require - need to have sidekiq running!
+require 'celluloid/autostart'
+require 'sidekiq'
+require 'sidekiq/util'
+require 'sidekiq/web'
+
+Sidekiq.logger.level = Logger::ERROR
+
+require 'sidekiq/redis_connection'
+redis_url = ENV['REDIS_URL'] || 'redis://localhost/15'
+REDIS = Sidekiq::RedisConnection.create(:url => redis_url, :namespace => 'testy')
+
+Sidekiq.configure_client do |config|
+  config.redis = { :url => redis_url, :namespace => 'testy' }
+end
+
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'sidekiq-cron'
+
+class Test::Unit::TestCase
+end
+
+
+class CronTestClass
+  include Sidekiq::Worker
+
+  def perform args = {}
+    puts "super croned job #{args}"
+  end
+end
+
+class CronTestClassWithQueue
+  include Sidekiq::Worker
+  sidekiq_options :queue => :super, :retry => false, :backtrace => true
+
+  def perform args = {}
+    puts "super croned job #{args}"
+  end
+end
+

data/test/unit/job_test.rb

@@ -0,0 +1,529 @@
+# -*- encoding : utf-8 -*-
+require './test/test_helper'
+
+class CronJobTest < Test::Unit::TestCase
+  context "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
+      end
+
+      #clear all queues
+      Sidekiq::Queue.all.each do |queue|
+        queue.clear
+      end
+    end
+
+    should "be initialized" do
+      job = Sidekiq::Cron::Job.new()
+      assert job.is_a?(Sidekiq::Cron::Job)
+    end
+
+    context "class methods" do
+      should "have create method" do
+        assert Sidekiq::Cron::Job.respond_to?(:create)
+      end
+
+      should "have destroy method" do
+        assert Sidekiq::Cron::Job.respond_to?(:destroy)
+      end
+
+      should "have count" do
+        assert Sidekiq::Cron::Job.respond_to?(:count)
+      end
+
+      should "have all" do
+        assert Sidekiq::Cron::Job.respond_to?(:all)
+      end
+
+      should "have find" do
+        assert Sidekiq::Cron::Job.respond_to?(:find)
+      end
+    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
+
+      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
+    end
+
+    context "invalid job" do
+      
+      setup do
+        @job = Sidekiq::Cron::Job.new()
+      end
+
+      should "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
+
+      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
+
+      should "return false on save" do
+        refute @job.save
+      end
+    end
+
+    context "new" do
+      setup do 
+        @args = {
+          name: "Test",
+          cron: "* * * * *"
+        }
+        @job = Sidekiq::Cron::Job.new(@args)
+      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
+
+      should "have to_hash method" do
+        [:name,:klass,:cron,:args,:message,:status, :last_run_time].each do |key|
+          assert @job.to_hash.has_key?(key), "to_hash must have key: #{key}" 
+        end
+      end
+    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
+      end
+
+      should "be initialized by 'klass' and string Class" do
+        assert_nothing_raised do
+          Sidekiq::Cron::Job.new('klass' => 'CronTestClass')
+        end
+      end
+
+      should "be initialized by 'class' and string Class" do
+        assert_nothing_raised do
+          Sidekiq::Cron::Job.new('class' => 'CronTestClass')
+        end
+      end
+
+      should "be initialized by 'class' and Class" do
+        assert_nothing_raised do
+          Sidekiq::Cron::Job.new('class' => CronTestClass)
+        end
+      end
+    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
+
+      should "be initialized with default attributes" do
+        assert_nothing_raised do
+          job = Sidekiq::Cron::Job.new('klass' => 'CronTestClass')
+
+          assert_equal job.message, {"retry"=>true, "queue"=>"default", "class"=>"CronTestClass", "args"=>[]}
+        end
+      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
+
+      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')
+
+          assert_equal job.message, {"retry"=>false,
+                                     "queue"=>'my_testing_queue',
+                                     "backtrace"=>true,
+                                     "class"=>"CronTestClassWithQueue",
+                                     "args"=>[]}
+        end
+      end
+    end
+ 
+    context "cron test" do
+      setup do
+        @job = Sidekiq::Cron::Job.new()
+      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
+
+      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
+
+      should "return previous day" do
+        @job.cron = "1 2 * * *"
+        time = Time.now
+        assert_equal @job.last_time(time).strftime("%Y-%m-%d-%H-%M-%S"), time.strftime("%Y-%m-%d-02-01-00")
+      end
+
+    end
+
+    context "save" do 
+      setup do 
+        @args = {
+          name: "Test",
+          cron: "* * * * *",
+          klass: "CronTestClass"
+        }
+        @job = Sidekiq::Cron::Job.new(@args)
+      end
+
+      should "be saved" do
+        assert @job.save
+      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)
+      end
+    end
+
+    context "nonexisting job" do
+      should "not be found" do
+        assert Sidekiq::Cron::Job.find("nonexisting").nil?, "should return nil"
+      end
+    end
+
+    context "disabled/enabled" do
+      setup do 
+        @args = {
+          name: "Test",
+          cron: "* * * * *",
+          klass: "CronTestClass"
+        }
+      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"
+
+        job.enable!
+        assert_equal job.status, "enabled"
+
+        job.disable!
+        assert_equal job.status, "disabled"
+      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
+
+      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
+
+      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
+    end
+
+    context "create & find methods" do
+      setup do 
+        @args = {
+          name: "Test",
+          cron: "* * * * *",
+          klass: "CronTestClass"
+        }
+      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
+
+      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
+
+      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
+
+      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"))
+
+        Sidekiq.redis do |conn|
+          conn.sadd Sidekiq::Cron::Job.jobs_key, "some_other_key"
+        end  
+
+        assert_equal Sidekiq::Cron::Job.all.size, 3, "All have to return only valid 3 jobs"
+      end
+
+      should "be found by string name" do
+        Sidekiq::Cron::Job.create(@args)
+        assert Sidekiq::Cron::Job.find("Test")
+      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"
+
+        Sidekiq::Cron::Job.create(@args)
+        assert Sidekiq::Cron::Job.find('name' => "Test"), "String keys"
+      end
+
+    end
+
+    context "destroy" do 
+      setup do 
+        @args = {
+          name: "Test",
+          cron: "* * * * *",
+          klass: "CronTestClass"
+        }
+      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"
+
+        assert Sidekiq::Cron::Job.destroy(@args)
+        assert_equal Sidekiq::Cron::Job.all.size, 0, "Should have 0 job after destroy"
+      end
+
+      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
+
+      should "return destroy by string name" do
+        Sidekiq::Cron::Job.create(@args)
+        assert Sidekiq::Cron::Job.destroy("Test")
+      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"
+
+        Sidekiq::Cron::Job.create(@args)
+        assert Sidekiq::Cron::Job.destroy('name' => "Test"), "String keys"
+      end
+
+    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
+
+      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
+
+      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
+
+      should "remove old enque times + should be enqeued" do
+        assert Sidekiq::Cron::Job.new(@args).test_and_enque_for_time!(@time), "should enqueue"
+        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"
+
+        # 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 * * * *'
+            }
+          }
+        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
+
+        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 out.size, 1, "should have 1 error"
+          assert_equal out, {"name_of_job"=>["'cron' -> bad cron: Bad Vixie-style specification bad"]}
+          assert_equal Sidekiq::Cron::Job.all.size, 1, "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
+
+      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
+
+        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
+      end
+    end
+  end
+end