crono 1.1.2 → 2.0.0

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