delayed_cron_job 0.6.0 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 52ec65c4ec0ca66d57f30457b6bf0327f43ee479
-  data.tar.gz: c311cfb9241e8145f324386833366b764cc73c1a
+SHA256:
+  metadata.gz: 853453d17f852e33afef72373ceec5a6fe462679272e5aa8a2cee37bccf26f3b
+  data.tar.gz: e88869f8b206ad9acd3214eb63ee4366e61c8113fc29084e8d8edaf1fd85db22
 SHA512:
-  metadata.gz: 2d9b317975e2914d4ba8f3a6fd12981fccd9341d8432bd9508d6cdadf322f786fb0bb9cda5dd5015c9b053300ab3f1f5dc00ae88b568de9f22296dc416e1542a
-  data.tar.gz: 670ec7558441a32ede722f66c1821ee524498ee595fc9c03f230f1b313b9bdd3dabb58a7f8d883726a735b9007c4783635fdcad222b7234d8c6799e32b30a794
+  metadata.gz: b7bdef74835bd41fe795bc61889361bea65521b7c1771c6e2c29ef693fe15afeeafe74fecb0152a2be7aa40483578866ceec03711e24b71eafa7c66e454c05ad
+  data.tar.gz: 991d3d78e52d7932e96d99dacb0bd869bf5ac314fb0a2e89fa5b9d2c0063a63f595b22fad950bf72397003d3621bfabbe79e4e2863b41fee9bac410cb1043286

data/.gitignore

@@ -20,4 +20,5 @@ tmp
 *.o
 *.a
 mkmf.log
-.project
+.project
+file::memory:*

data/.rspec

@@ -1,3 +1,2 @@
 --color
---warnings
 --require spec_helper

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+
+rvm:
+ - "2.5.8"
+
+sudo: false
+
+cache: bundler
+
+script: bundle exec rake

data/{LICENSE.txt → LICENSE}

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Pascal Zumkehr
+Copyright (c) 2014-2017 Pascal Zumkehr
 
 MIT License
 

data/README.md

@@ -1,11 +1,13 @@
 # Delayed::Cron::Job
 
+[![Build Status](https://travis-ci.org/codez/delayed_cron_job.svg)](https://travis-ci.org/codez/delayed_cron_job)
+
 Delayed::Cron::Job is an extension to Delayed::Job that allows you to set
 cron expressions for your jobs to run repeatedly.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add the following line to your application's Gemfile. Add it after the lines for all other `delayed_job*` gems so the gem can properly integrate with the Delayed::Job code.
 
     gem 'delayed_cron_job'
 
@@ -26,13 +28,124 @@ There are no additional steps for `delayed_job_mongoid`.
 
 When enqueuing a job, simply pass the `cron` option, e.g.:
 
-    Delayed::Job.enqueue(MyRepeatedJob.new, cron: '15 */6 * * 1-5')
+```ruby
+Delayed::Job.enqueue(MyRepeatedJob.new, cron: '15 */6 * * 1-5')
+```
+
+Or, when using ActiveJob:
+
+```ruby
+MyJob.set(cron: '*/5 * * * *').perform_later
+```
 
 Any crontab compatible cron expressions are supported (see `man 5 crontab`).
 The credits for the `Cronline` class used go to
 [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler).
 
-## Details
+## Scheduling
+
+Usually, you want to schedule all existing cron jobs when deploying the
+application. Using a common super class makes this simple.
+
+### Custom CronJob superclass
+
+`app/jobs/cron_job.rb`:
+
+```ruby
+# Default configuration in `app/jobs/application_job.rb`, or subclass
+# ActiveJob::Base .
+class CronJob < ApplicationJob
+
+  class_attribute :cron_expression
+
+  class << self
+
+    def schedule
+      set(cron: cron_expression).perform_later unless scheduled?
+    end
+
+    def remove
+      delayed_job.destroy if scheduled?
+    end
+
+    def scheduled?
+      delayed_job.present?
+    end
+
+    def delayed_job
+      Delayed::Job
+        .where('handler LIKE ?', "%job_class: #{name}%")
+        .first
+    end
+
+  end
+end
+```
+
+### Example Job inheriting from CronJob
+
+Then, an example job that triggers E-Mail-sending with default cron time at
+noon every day:
+
+`app/jobs/noon_job.rb`:
+
+```ruby
+
+# Note that it inherits from `CronJob`
+class NoonJob < CronJob
+  # set the (default) cron expression
+  self.cron_expression = '0 12 * * *'
+
+  # will enqueue the mailing delivery job
+  def perform
+    UserMailer.daily_notice(User.first).deliver_later
+  end
+end
+```
+
+### Scheduling "trigger"
+
+Jobs with a `cron` definition are rescheduled automatically only when a job
+instance finished its work. So there needs to be an initial scheduling of all
+cron jobs. If you do not want to do this manually (e.g. using `rails console`)
+or with your application logic, you can e.g. hook into the `rails db:*` rake
+tasks:
+
+`lib/tasks/jobs.rake`:
+
+```ruby
+namespace :db do
+  desc 'Schedule all cron jobs'
+  task :schedule_jobs => :environment do
+    # Need to load all jobs definitions in order to find subclasses
+    glob = Rails.root.join('app', 'jobs', '**', '*_job.rb')
+    Dir.glob(glob).each { |file| require file }
+    CronJob.subclasses.each { |job| job.schedule }
+  end
+end
+
+# invoke schedule_jobs automatically after every migration and schema load.
+%w(db:migrate db:schema:load).each do |task|
+  Rake::Task[task].enhance do
+    Rake::Task['db:schedule_jobs'].invoke
+  end
+end
+```
+
+Now, if you run `rails db:migrate`, `rails db:schema:load` or `rails
+db:schedule_jobs` all jobs inheriting from `CronJob` are scheduled.
+
+*If you are not using ActiveJob, the same approach may be used with minor
+adjustments.*
+
+### Changing the schedule
+
+Note that if you have a CronJob scheduled and change its `cron_expression` in
+its source file, you will have to remove any scheduled instances of the Job and
+reschedule it (e.g. with the snippet above: `rails db:migrate`). This is because
+the `cron_expression` is already persisted in the database (as `cron`).
+
+## Details
 
 The initial `run_at` value is computed during the `#enqueue` method call.
 If you create `Delayed::Job` database entries directly, make sure to set
@@ -61,3 +174,9 @@ jobs.
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
+
+## License
+
+Delayed::Cron::Job is released under the terms of the MIT License.
+Copyright 2014-2020 Pascal Zumkehr. See [LICENSE](LICENSE) for further
+information.

data/delayed_cron_job.gemspec

@@ -28,4 +28,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "delayed_job_active_record"
+  spec.add_development_dependency "activejob"
+
 end

data/lib/delayed_cron_job.rb

@@ -3,6 +3,15 @@ require 'English'
 require 'delayed_cron_job/cronline'
 require 'delayed_cron_job/plugin'
 require 'delayed_cron_job/version'
+require 'delayed_cron_job/backend/updatable_cron'
+
+begin
+  require 'delayed_job_active_record'
+rescue LoadError; end
+
+begin
+  require 'delayed_job_mongoid'
+rescue LoadError; end
 
 module DelayedCronJob
 
@@ -11,10 +20,33 @@ end
 if defined?(Delayed::Backend::Mongoid)
   Delayed::Backend::Mongoid::Job.field :cron, :type => String
   Delayed::Backend::Mongoid::Job.attr_accessible(:cron) if Delayed::Backend::Mongoid::Job.respond_to?(:attr_accessible)
+  Delayed::Backend::Mongoid::Job.send(:include, DelayedCronJob::Backend::UpdatableCron)
 end
 
-if defined?(Delayed::Backend::ActiveRecord) && Delayed::Backend::ActiveRecord::Job.respond_to?(:attr_accessible)
-  Delayed::Backend::ActiveRecord::Job.attr_accessible(:cron)
+if defined?(Delayed::Backend::ActiveRecord)
+  if defined?(Rails::Railtie)
+    # Postpone initialization to railtie for correct order
+    require 'delayed_cron_job/backend/active_record/railtie'
+  else
+    # Do the same as in the railtie
+    Delayed::Backend::ActiveRecord::Job.send(:include, DelayedCronJob::Backend::UpdatableCron)
+    if Delayed::Backend::ActiveRecord::Job.respond_to?(:attr_accessible)
+      Delayed::Backend::ActiveRecord::Job.attr_accessible(:cron)
+    end
+  end
 end
 
 Delayed::Worker.plugins << DelayedCronJob::Plugin
+
+if defined?(::ActiveJob)
+  require 'delayed_cron_job/active_job/enqueuing'
+  require 'delayed_cron_job/active_job/queue_adapter'
+
+  ActiveJob::Base.send(:include, DelayedCronJob::ActiveJob::Enqueuing)
+  if ActiveJob::QueueAdapters::DelayedJobAdapter.respond_to?(:enqueue)
+    ActiveJob::QueueAdapters::DelayedJobAdapter.extend(DelayedCronJob::ActiveJob::QueueAdapter)
+  else
+    ActiveJob::QueueAdapters::DelayedJobAdapter.send(:include, DelayedCronJob::ActiveJob::QueueAdapter)
+  end
+
+end

data/lib/delayed_cron_job/active_job/enqueuing.rb

@@ -0,0 +1,16 @@
+module DelayedCronJob
+  module ActiveJob
+    module Enqueuing
+
+      def self.included(klass)
+        klass.send(:attr_accessor, :cron)
+      end
+
+      def enqueue(options = {})
+        self.cron = options[:cron] if options[:cron]
+        super
+      end
+
+    end
+  end
+end

data/lib/delayed_cron_job/active_job/queue_adapter.rb

@@ -0,0 +1,33 @@
+module DelayedCronJob
+  module ActiveJob
+    module QueueAdapter
+
+      def self.included(klass)
+        klass.send(:alias_method, :enqueue, :enqueue_with_cron)
+        klass.send(:alias_method, :enqueue_at, :enqueue_at_with_cron)
+      end
+
+      def self.extended(klass)
+        meta = class << klass; self; end
+        meta.send(:alias_method, :enqueue, :enqueue_with_cron)
+        meta.send(:alias_method, :enqueue_at, :enqueue_at_with_cron)
+      end
+
+      def enqueue_with_cron(job)
+        enqueue_at(job, nil)
+      end
+
+      def enqueue_at_with_cron(job, timestamp)
+        options = { queue: job.queue_name,
+                    cron: job.cron  }
+        options[:run_at] = Time.at(timestamp) if timestamp
+        options[:priority] = job.priority if job.respond_to?(:priority)
+        wrapper = ::ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(job.serialize)
+        delayed_job = Delayed::Job.enqueue(wrapper, options)
+        job.provider_job_id = delayed_job.id if job.respond_to?(:provider_job_id=)
+        delayed_job
+      end
+
+    end
+  end
+end

data/lib/delayed_cron_job/backend/active_record/railtie.rb

@@ -0,0 +1,14 @@
+module DelayedCronJob
+  module Backend
+    module ActiveRecord
+      class Railtie < ::Rails::Railtie
+        config.after_initialize do
+          Delayed::Backend::ActiveRecord::Job.send(:include, DelayedCronJob::Backend::UpdatableCron)
+          if Delayed::Backend::ActiveRecord::Job.respond_to?(:attr_accessible)
+            Delayed::Backend::ActiveRecord::Job.attr_accessible(:cron)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delayed_cron_job/backend/updatable_cron.rb

@@ -0,0 +1,29 @@
+module DelayedCronJob
+  module Backend
+    module UpdatableCron
+
+      def self.included(klass)
+        klass.send(:before_save, :set_next_run_at, :if => :cron_changed?)
+        klass.attr_accessor :schedule_instead_of_destroy
+      end
+
+      def set_next_run_at
+        if cron.present?
+          self.run_at = Cronline.new(cron).next_time(Delayed::Job.db_time_now)
+        end
+      end
+
+      def destroy
+        super unless schedule_instead_of_destroy
+      end
+
+      def schedule_next_run
+        self.attempts += 1
+        unlock
+        set_next_run_at
+        save!
+      end
+
+    end
+  end
+end

data/lib/delayed_cron_job/cronline.rb

@@ -74,7 +74,7 @@ module DelayedCronJob
 
         raise ArgumentError.new(
           "invalid cronline: '#{line}'"
-        ) if es && es.find { |e| ! e.is_a?(Fixnum) }
+        ) if es && es.find { |e| ! e.is_a?(Integer) }
       end
     end
 

data/lib/delayed_cron_job/plugin.rb

@@ -2,20 +2,12 @@ module DelayedCronJob
   class Plugin < Delayed::Plugin
 
     class << self
-      def next_run_at(job)
-        job.run_at = Cronline.new(job.cron).next_time(Delayed::Job.db_time_now)
-      end
-
       def cron?(job)
         job.cron.present?
       end
     end
 
     callbacks do |lifecycle|
-      # Calculate the next run_at based on the cron attribute before enqueue.
-      lifecycle.before(:enqueue) do |job|
-        next_run_at(job) if cron?(job)
-      end
 
       # Prevent rescheduling of failed jobs as this is already done
       # after perform.
@@ -25,7 +17,6 @@ module DelayedCronJob
           worker.job_say(job,
                          "FAILED with #{$ERROR_INFO.class.name}: #{$ERROR_INFO.message}",
                          Logger::ERROR)
-          job.destroy
         else
           # No cron job - proceed as normal
           block.call(worker, job)
@@ -34,25 +25,26 @@ module DelayedCronJob
 
       # Reset the last_error to have the correct status of the last run.
       lifecycle.before(:perform) do |worker, job|
-        if cron?(job)
-          job.last_error = nil
-        end
+        job.last_error = nil if cron?(job)
+      end
+
+      # Prevent destruction of cron jobs
+      lifecycle.after(:invoke_job) do |job|
+        job.schedule_instead_of_destroy = true if cron?(job)
       end
 
       # Schedule the next run based on the cron attribute.
       lifecycle.after(:perform) do |worker, job|
-        if cron?(job)
-          next_job = job.dup
-          next_job.id = job.id
-          next_job.created_at = job.created_at
-          next_job.locked_at = nil
-          next_job.locked_by = nil
-          next_job.attempts += 1
-          next_run_at(next_job)
-          next_job.save!
+        if cron?(job) && !job.destroyed?
+          job.cron = job.class.where(:id => job.id).pluck(:cron).first
+          if job.cron.present?
+            job.schedule_next_run
+          else
+            job.schedule_instead_of_destroy = false
+            job.destroy
+          end
         end
       end
     end
-
   end
 end

data/lib/delayed_cron_job/version.rb

@@ -1,3 +1,3 @@
 module DelayedCronJob
-  VERSION = '0.6.0'
+  VERSION = '0.7.4'
 end

data/lib/generators/delayed_job/cron_generator.rb

@@ -12,11 +12,22 @@ module DelayedJob
     self.source_paths << File.join(File.dirname(__FILE__), 'templates')
 
     def create_migration_file
-      migration_template('cron_migration.rb', 'db/migrate/add_cron_to_delayed_jobs.rb')
+      migration_template('cron_migration.rb',
+                         'db/migrate/add_cron_to_delayed_jobs.rb',
+                         migration_version: migration_version)
     end
 
     def self.next_migration_number(dirname)
       ActiveRecord::Generators::Base.next_migration_number(dirname)
     end
+
+    private
+
+    def migration_version
+      if ActiveRecord::VERSION::MAJOR >= 5
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+
   end
-end
+end

data/lib/generators/delayed_job/templates/cron_migration.rb

@@ -1,4 +1,4 @@
-class AddCronToDelayedJobs < ActiveRecord::Migration
+class AddCronToDelayedJobs < ActiveRecord::Migration<%= migration_version %>
   def self.up
     add_column :delayed_jobs, :cron, :string
   end
@@ -6,4 +6,4 @@ class AddCronToDelayedJobs < ActiveRecord::Migration
   def self.down
     remove_column :delayed_jobs, :cron
   end
-end
+end

data/spec/active_job_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe ActiveJob do
+
+  class CronJob < ActiveJob::Base
+    class_attribute :cron
+
+    def perform; end
+
+    def cron
+      @cron ||= self.class.cron
+    end
+  end
+
+  before { Delayed::Job.delete_all }
+
+  let(:cron)    { '5 1 * * *' }
+  let(:job)     { CronJob.set(cron: cron).perform_later }
+  let(:delayed_job) { Delayed::Job.first }
+  let(:worker)  { Delayed::Worker.new }
+  let(:now)     { Delayed::Job.db_time_now }
+  let(:next_run) do
+    run = now.hour * 60 + now.min >= 65 ? now + 1.day : now
+    Time.utc(run.year, run.month, run.day, 1, 5)
+  end
+
+  context 'with cron' do
+    it 'sets run_at on enqueue' do
+      expect { job }.to change { Delayed::Job.count }.by(1)
+      expect(delayed_job.run_at).to eq(next_run)
+      expect(delayed_job.cron).to eq(cron)
+    end
+
+    it 'schedules a new job after success' do
+      job
+      delayed_job.update_column(:run_at, now)
+      delayed_job.reload
+
+      worker.work_off
+
+      expect(Delayed::Job.count).to eq(1)
+      j = Delayed::Job.first
+      expect(j.id).to eq(delayed_job.id)
+      expect(j.cron).to eq(delayed_job.cron)
+      expect(j.run_at).to eq(next_run)
+      expect(j.attempts).to eq(1)
+      expect(j.last_error).to eq(nil)
+      expect(j.created_at).to eq(delayed_job.created_at)
+    end
+  end
+
+  context 'without cron' do
+    let(:job) { CronJob.perform_later }
+
+    it 'sets run_at but not cron on enqueue' do
+      CronJob.cron = nil
+      expect { job }.to change { Delayed::Job.count }.by(1)
+      expect(delayed_job.run_at).to be <= now
+      expect(delayed_job.cron).to be_nil
+    end
+
+    it 'uses default cron on enqueue' do
+      CronJob.cron = cron
+      expect { job }.to change { Delayed::Job.count }.by(1)
+      expect(delayed_job.run_at).to eq(next_run)
+      expect(delayed_job.cron).to eq(cron)
+    end
+  end
+end

data/spec/delayed_cron_job_spec.rb

@@ -1,4 +1,4 @@
-
+require 'spec_helper'
 
 describe DelayedCronJob do
 
@@ -6,6 +6,16 @@ describe DelayedCronJob do
     def perform; end
   end
 
+  class DatabaseDisconnectPlugin < Delayed::Plugin
+
+    callbacks do |lifecycle|
+      lifecycle.after(:perform) do
+        ActiveRecord::Base.connection.disconnect!
+      end
+    end
+
+  end
+
   before { Delayed::Job.delete_all }
 
   let(:cron)    { '5 1 * * *' }
@@ -25,13 +35,13 @@ describe DelayedCronJob do
     end
 
     it 'enqueue fails with invalid cron' do
-      expect { Delayed::Job.enqueue(handler, cron: 'no valid cron') }.
-        to raise_error(ArgumentError)
+      expect { Delayed::Job.enqueue(handler, cron: 'no valid cron') }
+        .to raise_error(ArgumentError)
     end
 
     it 'schedules a new job after success' do
       job.update_column(:run_at, now)
-      job.reload
+      job.reload # adjusts granularity of run_at datetime
 
       worker.work_off
 
@@ -48,7 +58,7 @@ describe DelayedCronJob do
     it 'schedules a new job after failure' do
       allow_any_instance_of(TestJob).to receive(:perform).and_raise('Fail!')
       job.update(run_at: now)
-      job.reload
+      job.reload # adjusts granularity of run_at datetime
 
       worker.work_off
 
@@ -74,19 +84,16 @@ describe DelayedCronJob do
       expect(j.cron).to eq(job.cron)
       expect(j.run_at).to eq(next_run)
       expect(j.attempts).to eq(1)
-      expect(j.last_error).to match("execution expired")
+      expect(j.last_error).to match('execution expired')
     end
 
-    it 'schedules new job after deserialization error' do
-      Delayed::Worker.max_run_time = 1.second
+    it 'does not schedule new job after deserialization error' do
       job.update_column(:run_at, now)
       allow_any_instance_of(TestJob).to receive(:perform).and_raise(Delayed::DeserializationError)
 
       worker.work_off
 
-      expect(Delayed::Job.count).to eq(1)
-      j = Delayed::Job.first
-      expect(j.last_error).to match("Delayed::DeserializationError")
+      expect(Delayed::Job.count).to eq(0)
     end
 
     it 'has empty last_error after success' do
@@ -98,7 +105,7 @@ describe DelayedCronJob do
       expect(j.last_error).to eq(nil)
     end
 
-    it 'has correct last_error after success' do
+    it 'has updated last_error after failure' do
       allow_any_instance_of(TestJob).to receive(:perform).and_raise('Fail!')
       job.update(run_at: now, last_error: 'Last error')
 
@@ -116,7 +123,7 @@ describe DelayedCronJob do
         run_at = Time.utc(run.year, run.month, run.day, hour, (now.min + 1) % 60)
         expect(job.run_at).to eq(run_at)
       else
-        pending "This test only makes sense in non-UTC time zone"
+        pending 'This test only makes sense in non-UTC time zone'
       end
     end
 
@@ -138,6 +145,65 @@ describe DelayedCronJob do
       j = Delayed::Job.first
       expect(j.attempts).to eq(job.attempts + 1)
     end
+
+    it 'updates run_at if cron is changed' do
+      job.update!(cron: '1 10 * * *')
+      expect(job.run_at.min).to eq(1)
+    end
+
+    it 'uses new cron when this is updated while job is running' do
+      job.update_column(:run_at, now)
+      allow_any_instance_of(TestJob).to receive(:perform) { job.update!(cron: '1 10 * * *') }
+
+      worker.work_off
+
+      j = Delayed::Job.first
+      expect(j.run_at.min).to eq(1)
+    end
+
+    it 'does not reschedule job if cron is cleared while job is running' do
+      job.update_column(:run_at, now)
+      allow_any_instance_of(TestJob).to receive(:perform) { job.update!(cron: '') }
+
+      expect { worker.work_off }.to change { Delayed::Job.count }.by(-1)
+    end
+
+    it 'does not reschedule job if model is deleted while job is running' do
+      job.update_column(:run_at, now)
+      allow_any_instance_of(TestJob).to receive(:perform) { job.destroy! }
+
+      expect { worker.work_off }.to change { Delayed::Job.count }.by(-1)
+    end
+
+    context 'when database connection is lost' do
+      around(:each) do |example|
+        Delayed::Worker.plugins.unshift DatabaseDisconnectPlugin
+        # hold onto a connection so the in-memory database isn't lost when disconnected
+        temp_connection = ActiveRecord::Base.connection_pool.checkout
+        example.run
+        ActiveRecord::Base.connection_pool.checkin temp_connection
+        Delayed::Worker.plugins.delete DatabaseDisconnectPlugin
+      end
+
+      it 'does not lose the job if database connection is lost' do
+        job.update_column(:run_at, now)
+        job.reload # adjusts granularity of run_at datetime
+
+        begin
+          worker.work_off
+        rescue StandardError
+          # Attempting to save the clone delayed_job will raise an exception due to the database connection being closed
+        end
+
+        ActiveRecord::Base.connection.reconnect!
+
+        expect(Delayed::Job.count).to eq(1)
+        j = Delayed::Job.first
+        expect(j.id).to eq(job.id)
+        expect(j.cron).to eq(job.cron)
+        expect(j.attempts).to eq(0)
+      end
+    end
   end
 
   context 'without cron' do

data/spec/spec_helper.rb

@@ -15,12 +15,15 @@
 #
 
 require 'delayed_job_active_record'
+require 'active_job'
 require 'delayed_cron_job'
 
 Delayed::Worker.logger = Logger.new('/tmp/dj.log')
 ENV['RAILS_ENV'] = 'test'
 
-ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
+ActiveJob::Base.queue_adapter = :delayed_job
+
+ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => 'file::memory:?cache=shared'
 ActiveRecord::Base.logger = Delayed::Worker.logger
 ActiveRecord::Migration.verbose = false
 
@@ -45,5 +48,5 @@ end
 
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delayed_cron_job
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.4
 platform: ruby
 authors:
 - Pascal Zumkehr
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-01-11 00:00:00.000000000 Z
+date: 2020-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: delayed_job
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |-
   Delayed Cron Job is an extension to Delayed::Job
                             that allows you to set cron expressions for your
@@ -106,24 +120,30 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
 - Gemfile
-- LICENSE.txt
+- LICENSE
 - README.md
 - Rakefile
 - delayed_cron_job.gemspec
 - lib/delayed_cron_job.rb
+- lib/delayed_cron_job/active_job/enqueuing.rb
+- lib/delayed_cron_job/active_job/queue_adapter.rb
+- lib/delayed_cron_job/backend/active_record/railtie.rb
+- lib/delayed_cron_job/backend/updatable_cron.rb
 - lib/delayed_cron_job/cronline.rb
 - lib/delayed_cron_job/plugin.rb
 - lib/delayed_cron_job/version.rb
 - lib/generators/delayed_job/cron_generator.rb
 - lib/generators/delayed_job/templates/cron_migration.rb
+- spec/active_job_spec.rb
 - spec/delayed_cron_job_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/codez/delayed_cron_job
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -138,12 +158,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
-signing_key: 
+rubygems_version: 3.0.6
+signing_key:
 specification_version: 4
 summary: An extension to Delayed::Job that allows you to set cron expressions for
   your jobs to run regularly.
 test_files:
+- spec/active_job_spec.rb
 - spec/delayed_cron_job_spec.rb
 - spec/spec_helper.rb