crono 1.1.1 → 2.0.1

data/spec/job_spec.rb

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+class TestJob
+  def perform(*args)
+    puts 'Test!'
+  end
+end
+
+class TestFailingJob
+  def perform(*args)
+    raise 'Some error'
+  end
+end
+
+class TestNoArgsJob
+  def perform
+    puts 'Test!'
+  end
+end
+
+describe Crono::Job do
+  let(:period) { Crono::Period.new(2.day, at: '15:00') }
+  let(:job_args) {[{some: 'data'}]}
+  let(:job) { Crono::Job.new(TestJob, period, []) }
+  let(:job_with_args) { Crono::Job.new(TestJob, period, job_args) }
+  let(:failing_job) { Crono::Job.new(TestFailingJob, period, []) }
+  let(:not_args_job) { Crono::Job.new(TestJob, period) }
+
+  it 'should contain performer and period' do
+    expect(job.performer).to be TestJob
+    expect(job.period).to be period
+  end
+
+  it 'should contain data as JSON String' do
+    expect(job_with_args.job_args).to eq '[{"some":"data"}]'
+  end
+
+  describe '#next' do
+    it 'should return next performing time according to period' do
+      expect(job.next).to be_eql period.next
+    end
+  end
+
+  describe '#perform' do
+    after { job.send(:model).destroy }
+
+    it 'should run performer in separate thread' do
+      expect(job).to receive(:save)
+      thread = job.perform.join
+      expect(thread).to be_stop
+    end
+
+    it 'should save performin errors to log' do
+      thread = failing_job.perform.join
+      expect(thread).to be_stop
+      saved_log = Crono::CronoJob.find_by(job_id: failing_job.job_id).log
+      expect(saved_log).to include 'Some error'
+    end
+
+    it 'should set Job#healthy to false if perform with error' do
+      failing_job.perform.join
+      expect(failing_job.healthy).to be false
+    end
+
+    it 'should execute one' do
+      job.execution_interval = 5.minutes
+
+      expect(job).to receive(:perform_job).once
+      job.perform.join
+      thread = job.perform.join
+      expect(thread).to be_stop
+    end
+
+    it 'should execute twice' do
+      job.execution_interval = 0.minutes
+
+      test_preform_job_twice
+    end
+
+    it 'should execute twice without args' do
+      test_preform_job_twice not_args_job
+    end
+
+    it 'should execute twice without initialize execution_interval' do
+      test_preform_job_twice
+    end
+
+    it 'should call perform of performer' do
+      expect(TestJob).to receive(:new).with(no_args)
+      thread = job.perform.join
+      expect(thread).to be_stop
+    end
+
+    it 'should call perform of performer with data' do
+      test_job = double()
+      expect(TestJob).to receive(:new).and_return(test_job)
+      expect(test_job).to receive(:perform).with([{ 'some' => 'data' }])
+      thread = job_with_args.perform.join
+      expect(thread).to be_stop
+    end
+
+    def test_preform_job_twice(jon_instance = job)
+      expect(jon_instance).to receive(:perform_job).twice
+      jon_instance.perform.join
+      thread = jon_instance.perform.join
+      expect(thread).to be_stop
+    end
+  end
+
+  describe '#description' do
+    it 'should return job identificator' do
+      expect(job.description).to be_eql('Perform TestJob every 2 days at 15:00')
+    end
+  end
+
+  describe '#save' do
+    it 'should save new job to DB' do
+      expect(Crono::CronoJob.where(job_id: job.job_id)).to_not exist
+      job.save
+      expect(Crono::CronoJob.where(job_id: job.job_id)).to exist
+    end
+
+    it 'should update saved job' do
+      job.last_performed_at = Time.zone.now
+      job.healthy = true
+      job.job_args = JSON.generate([{some: 'data'}])
+      job.save
+      @crono_job = Crono::CronoJob.find_by(job_id: job.job_id)
+      expect(@crono_job.last_performed_at.utc.to_s).to be_eql job.last_performed_at.utc.to_s
+      expect(@crono_job.healthy).to be true
+    end
+
+    it 'should save log' do
+      message = 'test message'
+      job.send(:log, message)
+      job.save
+      expect(job.send(:model).reload.log).to include message
+      expect(job.job_log.string).to be_empty
+    end
+
+    it 'should not truncate log if not specified' do
+      log = (1..100).map {|n| "line #{n}" }.join("\n")
+      job = Crono::Job.new(TestJob, period, [])
+      job.send(:log, log)
+      job.save
+      expect(job.send(:model).reload.log.lines.size).to be >= log.lines.size
+    end
+
+    it 'should truncate log if specified' do
+      log = (1..100).map {|n| "line #{n}" }.join("\n")
+      job = Crono::Job.new(TestJob, period, [], truncate_log: 50)
+      job.send(:log, log)
+      job.save
+      expect(job.send(:model).reload.log.lines.size).to be 50
+    end
+  end
+
+  describe '#load' do
+    before do
+      @saved_last_performed_at = job.last_performed_at = Time.zone.now
+      job.save
+    end
+
+    it 'should load last_performed_at from DB' do
+      @job = Crono::Job.new(TestJob, period, job_args)
+      @job.load
+      expect(@job.last_performed_at.utc.to_s).to be_eql @saved_last_performed_at.utc.to_s
+    end
+  end
+
+  describe '#log' do
+    it 'should write log messages to both common and job log' do
+      message = 'Test message'
+      job.logfile = "/dev/null"
+      expect(job.logger).to receive(:log).with(Logger::INFO, message)
+      expect(job.job_logger).to receive(:log).with(Logger::INFO, message)
+      job.send(:log, message)
+    end
+
+    it 'should write job log to Job#job_log' do
+      message = 'Test message'
+      job.send(:log, message)
+      expect(job.job_log.string).to include(message)
+    end
+  end
+
+  describe '#log_error' do
+    it 'should call log with ERROR severity' do
+      message = 'Test message'
+      expect(job).to receive(:log).with(message, Logger::ERROR)
+      job.send(:log_error, message)
+    end
+  end
+end

data/spec/models/crono/crono_job_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'rack/test'
+
+module Crono
+  RSpec.describe Crono::CronoJob, type: :model do
+    let(:valid_attrs) do
+      {
+        job_id: 'Perform TestJob every 3 days'
+      }
+    end
+
+    it 'should validate presence of job_id' do
+      @crono_job = Crono::CronoJob.new
+      expect(@crono_job).not_to be_valid
+      expect(@crono_job.errors.added?(:job_id, :blank)).to be true
+    end
+
+    it 'should validate uniqueness of job_id' do
+      Crono::CronoJob.create!(job_id: 'TestJob every 2 days')
+      @crono_job = Crono::CronoJob.create(job_id: 'TestJob every 2 days')
+      expect(@crono_job).not_to be_valid
+      expect(@crono_job.errors.size).to be 1
+    end
+
+    it 'should save job_id to DB' do
+      Crono::CronoJob.create!(valid_attrs)
+      @crono_job = Crono::CronoJob.find_by(job_id: valid_attrs[:job_id])
+      expect(@crono_job).to be_present
+    end
+  end
+end

data/spec/performer_proxy_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+class TestJob
+  def perform
+    puts 'Test!'
+  end
+end
+
+describe Crono::PerformerProxy do
+  it 'should add job to schedule' do
+    expect(Crono.scheduler).to receive(:add_job).with(kind_of(Crono::Job))
+    Crono.perform(TestJob).every(2.days, at: '15:30')
+  end
+
+  it 'should set execution interval' do
+    allow(Crono).to receive(:scheduler).and_return(Crono::Scheduler.new)
+    expect_any_instance_of(Crono::Job).to receive(:execution_interval=).with(0.minutes).once
+    expect_any_instance_of(Crono::Job).to receive(:execution_interval=).with(10.minutes).once
+    Crono.perform(TestJob).every(2.days, at: '15:30').once_per 10.minutes
+  end
+
+  it 'do nothing when job not initalized' do
+    expect_any_instance_of(Crono::Job).not_to receive(:execution_interval=)
+    expect_any_instance_of(described_class).to receive(:once_per)
+    Crono.perform(TestJob).once_per 10.minutes
+  end
+
+  it 'should add job with args to schedule' do
+    expect(Crono::Job).to receive(:new).with(TestJob, kind_of(Crono::Period), :some, { some: 'data' })
+    allow(Crono.scheduler).to receive(:add_job)
+    Crono.perform(TestJob, :some, { some: 'data' }).every(2.days, at: '15:30')
+  end
+
+  it 'should add job without args to schedule' do
+    expect(Crono::Job).to receive(:new).with(TestJob, kind_of(Crono::Period), nil, nil)
+    allow(Crono.scheduler).to receive(:add_job)
+    Crono.perform(TestJob).every(2.days, at: '15:30')
+  end
+
+  it 'should add job with options to schedule' do
+    expect(Crono::Job).to receive(:new).with(TestJob, kind_of(Crono::Period), nil, { some_option: true })
+    allow(Crono.scheduler).to receive(:add_job)
+    Crono.perform(TestJob).with_options(some_option: true).every(2.days, at: '15:30')
+  end
+end

data/spec/period_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe Crono::Period do
+  describe '#description' do
+    it 'should return period description' do
+      @period = Crono::Period.new(1.week, on: :monday, at: '15:20')
+      expected_description = if ActiveSupport::VERSION::MAJOR >= 5
+          'every 1 week at 15:20 on Monday'
+        else
+          'every 7 days at 15:20 on Monday'
+        end
+      expect(@period.description).to be_eql(expected_description)
+    end
+  end
+
+  describe '#next' do
+    context 'in weakly basis' do
+      it "should raise error if 'on' is wrong" do
+        expect { @period = Crono::Period.new(7.days, on: :bad_day) }
+          .to raise_error("Wrong 'on' day")
+      end
+
+      it 'should raise error when period is less than 1 week' do
+        expect { @period = Crono::Period.new(6.days, on: :monday) }
+          .to raise_error("period should be at least 1 week to use 'on'")
+      end
+
+      it "should return a 'on' day" do
+        @period = Crono::Period.new(1.week, on: :thursday, at: '15:30')
+        current_week = Time.zone.now.beginning_of_week
+        last_run_time = current_week.advance(days: 1) # last run on the tuesday
+        next_run_at = Time.zone.now.next_week.advance(days: 3)
+                      .change(hour: 15, min: 30)
+        expect(@period.next(since: last_run_time)).to be_eql(next_run_at)
+      end
+
+      it "should return a next week day 'on'" do
+        @period = Crono::Period.new(1.week, on: :thursday)
+        Timecop.freeze(Time.zone.now.beginning_of_week.advance(days: 4)) do
+          expect(@period.next).to be_eql(Time.zone.now.next_week.advance(days: 3))
+        end
+      end
+
+      it 'should return a current week day on the first run if not too late' do
+        @period = Crono::Period.new(7.days, on: :tuesday)
+        beginning_of_the_week = Time.zone.now.beginning_of_week
+        tuesday = beginning_of_the_week.advance(days: 1)
+        Timecop.freeze(beginning_of_the_week) do
+          expect(@period.next).to be_eql(tuesday)
+        end
+      end
+
+      it 'should return today on the first run if not too late' do
+        @period = Crono::Period.new(1.week, on: :sunday, at: '22:00')
+        Timecop.freeze(Time.zone.now.beginning_of_week.advance(days: 6)
+                           .change(hour: 21, min: 0)) do
+          expect(@period.next).to be_eql(
+            Time.zone.now.beginning_of_week.advance(days: 6).change(hour: 22, min: 0)
+          )
+        end
+      end
+    end
+
+    context 'in daily basis' do
+      it "should return Time.zone.now if the next time in past" do
+        @period = Crono::Period.new(1.day, at: '06:00')
+        expect(@period.next(since: 2.days.ago).to_s).to be_eql(Time.zone.now.to_s)
+      end
+
+      it 'should return time 2 days from now' do
+        @period = Crono::Period.new(2.day)
+        expect(@period.next.to_s).to be_eql(2.days.from_now.to_s)
+      end
+
+      it "should set time to 'at' time as a string" do
+        time = 10.minutes.ago
+        at = [time.hour, time.min].join(':')
+        @period = Crono::Period.new(2.days, at: at)
+        expect(@period.next.to_s).to be_eql(2.days.from_now.change(hour: time.hour, min: time.min).to_s)
+      end
+
+      it "should set time to 'at' time as a hash" do
+        time = 10.minutes.ago
+        at = { hour: time.hour, min: time.min }
+        @period = Crono::Period.new(2.days, at: at)
+        expect(@period.next.to_s).to be_eql(2.days.from_now.change(at).to_s)
+      end
+
+      it "should raise error when 'at' is wrong" do
+        expect {
+          Crono::Period.new(2.days, at: 1)
+        }.to raise_error("Unknown 'at' format")
+      end
+
+      it 'should raise error when period is less than 1 day' do
+        expect {
+          Crono::Period.new(5.hours, at: '15:30')
+        }.to raise_error("period should be at least 1 day to use 'at' with specified hour")
+      end
+
+      it 'should return time in relation to last time' do
+        @period = Crono::Period.new(2.days)
+        expect(@period.next(since: 1.day.ago).to_s).to be_eql(1.day.from_now.to_s)
+      end
+
+      it 'should return today time if it is first run and not too late' do
+        time = 10.minutes.from_now
+        at = { hour: time.hour, min: time.min }
+        @period = Crono::Period.new(2.days, at: at)
+        expect(@period.next.utc.to_s).to be_eql(Time.zone.now.change(at).utc.to_s)
+      end
+    end
+
+    context 'in hourly basis' do
+      it 'should return next hour minutes if current hour minutes passed' do
+        Timecop.freeze(Time.zone.now.beginning_of_hour.advance(minutes: 20)) do
+          @period = Crono::Period.new(1.hour, at: { min: 15 })
+          expect(@period.next.utc.to_s).to be_eql 1.hour.from_now.beginning_of_hour.advance(minutes: 15).utc.to_s
+        end
+      end
+
+      it 'should return current hour minutes if current hour minutes not passed yet' do
+        Timecop.freeze(Time.zone.now.beginning_of_hour.advance(minutes: 10)) do
+          @period = Crono::Period.new(1.hour, at: { min: 15 })
+          expect(@period.next.utc.to_s).to be_eql Time.zone.now.beginning_of_hour.advance(minutes: 15).utc.to_s
+        end
+      end
+
+      it 'should return next hour minutes within the given interval' do
+        Timecop.freeze(Time.zone.now.change(hour: 16, min: 10)) do
+          @period = Crono::Period.new(1.hour, at: { min: 15 }, within: '08:00-16:00')
+          expect(@period.next.utc.to_s).to be_eql Time.zone.now.tomorrow.change(hour: 8, min: 15).utc.to_s
+        end
+        Timecop.freeze(Time.zone.now.change(hour: 16, min: 10)) do
+          @period = Crono::Period.new(1.hour, at: { min: 15 }, within: '23:00-07:00')
+          expect(@period.next.utc.to_s).to be_eql Time.zone.now.change(hour: 23, min: 15).utc.to_s
+        end
+      end
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,89 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+require 'spec_helper'
+ENV['RAILS_ENV'] ||= 'test'
+require File.expand_path('../spec/internal/config/environment.rb', __dir__)
+# Prevent database truncation if the environment is production
+abort('The Rails environment is running in production mode!') if Rails.env.production?
+require 'rspec/rails'
+# Add additional requires below this line. Rails is not loaded until this point!
+require 'bundler/setup'
+Bundler.setup
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __dir__)
+
+require 'timecop'
+require 'byebug'
+require 'crono'
+
+# setting default time zone
+# In Rails project, Time.zone_default equals "UTC"
+Time.zone_default = Time.find_zone('UTC')
+
+ActiveRecord::Base.logger = Logger.new($stdout)
+
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3',
+  database: ':memory'
+)
+ActiveRecord::Schema.define do
+  require_relative '../lib/generators/crono/install/templates/migrations/create_crono_jobs.rb'
+  @migration_version = '[6.1]'
+end
+CreateCronoJobs.up
+
+
+# Requires supporting ruby files with custom matchers and macros, etc, in
+# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
+# run as spec files by default. This means that files in spec/support that end
+# in _spec.rb will both be required and run as specs, causing the specs to be
+# run twice. It is recommended that you do not name files matching this glob to
+# end with _spec.rb. You can configure this pattern with the --pattern
+# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
+#
+# The following line is provided for convenience purposes. It has the downside
+# of increasing the boot-up time by auto-requiring all files in the support
+# directory. Alternatively, in the individual `*_spec.rb` files, manually
+# require only the support files necessary.
+#
+# Dir[Rails.root.join('spec', 'support', '**', '*.rb')].sort.each { |f| require f }
+
+# Checks for pending migrations and applies them before tests are run.
+# If you are not using ActiveRecord, you can remove these lines.
+begin
+  ActiveRecord::Migration.maintain_test_schema!
+rescue ActiveRecord::PendingMigrationError => e
+  puts e.to_s.strip
+  exit 1
+end
+RSpec.configure do |config|
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  # config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  # config.use_transactional_fixtures = true
+
+  # You can uncomment this line to turn off ActiveRecord support entirely.
+  # config.use_active_record = false
+
+  # RSpec Rails can automatically mix in different behaviours to your tests
+  # based on their file location, for example enabling you to call `get` and
+  # `post` in specs under `spec/controllers`.
+  #
+  # You can disable this behaviour by removing the line below, and instead
+  # explicitly tag your specs with their type, e.g.:
+  #
+  #     RSpec.describe UsersController, type: :controller do
+  #       # ...
+  #     end
+  #
+  # The different available types are documented in the features, such as in
+  # https://relishapp.com/rspec/rspec-rails/docs
+  config.infer_spec_type_from_file_location!
+
+  # Filter lines from Rails gems in backtraces.
+  config.filter_rails_from_backtrace!
+  # arbitrary gems may also be filtered via:
+  # config.filter_gems_from_backtrace("gem name")
+end

data/spec/scheduler_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+class TestJob
+  def perform
+    puts 'Test!'
+  end
+end
+
+describe Crono::Scheduler do
+  let(:scheduler) { Crono::Scheduler.new }
+
+  describe '#add_job' do
+    it 'should call Job#load on Job' do
+      @job = Crono::Job.new(TestJob, Crono::Period.new(10.day, at: '04:05'), [])
+      expect(@job).to receive(:load)
+      scheduler.add_job(@job)
+    end
+  end
+
+  describe '#next_jobs' do
+    it 'should return next job in schedule' do
+      scheduler.jobs = jobs = [
+        Crono::Period.new(3.days, at: 10.minutes.from_now.strftime('%H:%M')),
+        Crono::Period.new(1.day, at: 20.minutes.from_now.strftime('%H:%M')),
+        Crono::Period.new(7.days, at: 40.minutes.from_now.strftime('%H:%M'))
+      ].map { |period| Crono::Job.new(TestJob, period, []) }
+
+      time, jobs = scheduler.next_jobs
+      expect(jobs).to be_eql [jobs[0]]
+    end
+
+    it 'should return an array of jobs scheduled at same time with `at`' do
+      time = 5.minutes.from_now
+      scheduler.jobs = jobs = [
+        Crono::Period.new(1.day, at: time.strftime('%H:%M')),
+        Crono::Period.new(1.day, at: time.strftime('%H:%M')),
+        Crono::Period.new(1.day, at: 10.minutes.from_now.strftime('%H:%M'))
+      ].map { |period| Crono::Job.new(TestJob, period, []) }
+
+      time, jobs = scheduler.next_jobs
+      expect(jobs).to be_eql [jobs[0], jobs[1]]
+    end
+
+    it 'should handle a few jobs scheduled at same time without `at`' do
+      scheduler.jobs = jobs = [
+        Crono::Period.new(10.seconds),
+        Crono::Period.new(10.seconds),
+        Crono::Period.new(1.day, at: 10.minutes.from_now.strftime('%H:%M'))
+      ].map { |period| Crono::Job.new(TestJob, period, []) }
+
+      _, next_jobs = scheduler.next_jobs
+      expect(next_jobs).to be_eql [jobs[0]]
+
+      Timecop.travel(4.seconds.from_now)
+      expect(Thread).to receive(:new)
+      jobs[0].perform
+
+      _, next_jobs = scheduler.next_jobs
+      expect(next_jobs).to be_eql [jobs[1]]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'bundler'
+
+Bundler.require :default, :development
+
+# If you're using all parts of Rails:
+Combustion.initialize! :all
+# Or, load just what you need:
+# Combustion.initialize! :active_record, :action_controller
+
+require 'rspec/rails'
+# If you're using Capybara:
+# require 'capybara/rails'
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+  config.mock_with :rspec do |mocks|
+    mocks.allow_message_expectations_on_nil = true
+  end
+end

data/spec/tasks/crono_tasks_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'rake'
+
+load 'tasks/crono_tasks.rake'
+Rake::Task.define_task(:environment)
+
+describe 'rake' do
+  describe 'crono:clean' do
+    it 'should clean unused tasks from DB' do
+      Crono::CronoJob.create!(job_id: 'used_job')
+      ENV['CRONOTAB'] = File.expand_path('../../assets/good_cronotab.rb', __FILE__)
+      Rake::Task['crono:clean'].invoke
+      expect(Crono::CronoJob.where(job_id: 'used_job')).not_to exist
+    end
+  end
+
+  describe 'crono:check' do
+    it 'should check cronotab syntax' do
+      ENV['CRONOTAB'] = File.expand_path('../../assets/bad_cronotab.rb', __FILE__)
+      expect { Rake::Task['crono:check'].invoke }.to raise_error
+    end
+  end
+end

data/spec/web_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'rack/test'
+include Rack::Test::Methods
+
+describe Crono::Engine do
+  let(:app) { Crono::Engine }
+
+  before do
+    Crono::CronoJob.destroy_all
+    @test_job_id = 'Perform TestJob every 5 seconds'
+    @test_job_log = 'All runs ok'
+    @test_job = Crono::CronoJob.create!(
+      job_id: @test_job_id,
+      log: @test_job_log
+    )
+  end
+
+  after { @test_job.destroy }
+
+  describe '/' do
+    it 'should show all jobs' do
+      get '/'
+      expect(last_response).to be_ok
+      expect(last_response.body).to include @test_job_id
+    end
+
+    it 'should show a error mark when a job is unhealthy' do
+      @test_job.update(healthy: false, last_performed_at: 10.minutes.ago)
+      get '/'
+      expect(last_response.body).to include 'Error'
+    end
+
+    it 'should show a success mark when a job is healthy' do
+      @test_job.update(healthy: true, last_performed_at: 10.minutes.ago)
+      get '/'
+      expect(last_response.body).to include 'Success'
+    end
+
+    it 'should show a pending mark when a job is pending' do
+      @test_job.update(healthy: nil)
+      get '/'
+      expect(last_response.body).to include 'Pending'
+    end
+  end
+
+  describe '/job/:id' do
+    it 'should show job log' do
+      get "/jobs/#{@test_job.id}"
+      expect(last_response).to be_ok
+      expect(last_response.body).to include @test_job_id
+      expect(last_response.body).to include @test_job_log
+    end
+
+    it 'should show a message about the unhealthy job' do
+      message = 'An error occurs during the last execution of this job'
+      @test_job.update(healthy: false)
+      get "/jobs/#{@test_job.id}"
+      expect(last_response.body).to include message
+    end
+  end
+end