rocketjob 3.5.2 → 4.0.0

data/test/files/text.txt

@@ -1,3 +0,0 @@
-Hello World
-Line2
-Line3

data/test/job_test.rb

@@ -1,71 +0,0 @@
-require_relative 'test_helper'
-
-# Unit Test for RocketJob::Job
-class JobTest < Minitest::Test
-  class SimpleJob < RocketJob::Job
-    def perform
-    end
-  end
-
-  describe RocketJob::Job do
-    before do
-      @description = 'Hello World'
-      @job         = SimpleJob.new(description: @description)
-      @job2        = SimpleJob.new(description: @description, priority: 52)
-    end
-
-    after do
-      @job.destroy if @job && !@job.new_record?
-      @job2.destroy if @job2 && !@job2.new_record?
-    end
-
-    describe '#status' do
-      it 'return status for a queued job' do
-        assert_equal true, @job.queued?
-        h = @job.status
-        assert_equal :queued, h['state']
-        assert_equal @description, h['description']
-      end
-
-      it 'return status for a failed job' do
-        @job.start!
-        @job.fail!('worker:1234', 'oh no')
-        assert_equal true, @job.failed?
-        h = @job.status
-        assert_equal :failed, h['state']
-        assert_equal @description, h['description']
-        assert_equal 'RocketJob::JobException', h['exception']['class_name'], h
-        assert_equal 'oh no', h['exception']['message'], h
-      end
-    end
-
-    describe '.requeue_dead_server' do
-      it 'requeue jobs from dead workers' do
-        assert_equal 52, @job2.priority
-        worker_name      = 'server:12345'
-        @job.worker_name = worker_name
-        @job.start!
-        assert @job.running?, @job.state
-
-        worker_name2      = 'server:76467'
-        @job2.worker_name = worker_name2
-        @job2.start!
-        assert_equal true, @job2.valid?
-        assert @job2.running?, @job2.state
-        @job2.save!
-
-        RocketJob::Job.requeue_dead_server(worker_name)
-        @job.reload
-
-        assert @job.queued?
-        assert_nil @job.worker_name
-
-        assert_equal worker_name2, @job2.worker_name
-        @job2.reload
-        assert_equal worker_name2, @job2.worker_name
-        assert @job2.running?, @job2.state
-        assert_equal worker_name2, @job2.worker_name
-      end
-    end
-  end
-end

data/test/jobs/housekeeping_job_test.rb

@@ -1,102 +0,0 @@
-require_relative '../test_helper'
-
-# Unit Test for RocketJob::Job
-class HousekeepingJobTest < Minitest::Test
-  class TestJob < RocketJob::Job
-    def perform
-    end
-  end
-
-  describe RocketJob::Jobs::HousekeepingJob do
-    before do
-      HousekeepingJobTest::TestJob.delete_all
-      RocketJob::Jobs::HousekeepingJob.delete_all
-      RocketJob::Server.delete_all
-    end
-
-    describe 'job retention' do
-      before do
-        job = HousekeepingJobTest::TestJob.new
-        Time.stub(:now, 2.days.ago) do
-          job.abort!
-        end
-        job = HousekeepingJobTest::TestJob.new
-        Time.stub(:now, 8.days.ago) do
-          job.abort!
-        end
-
-        job = HousekeepingJobTest::TestJob.new
-        Time.stub(:now, 2.days.ago) do
-          job.perform_now
-          job.save!
-        end
-        job = HousekeepingJobTest::TestJob.new
-        Time.stub(:now, 8.days.ago) do
-          job.perform_now
-          job.save!
-        end
-
-        job = HousekeepingJobTest::TestJob.new
-        Time.stub(:now, 2.days.ago) do
-          job.fail!
-        end
-        job = HousekeepingJobTest::TestJob.new
-        Time.stub(:now, 15.days.ago) do
-          job.fail!
-        end
-
-        job = HousekeepingJobTest::TestJob.new
-        Time.stub(:now, 400.days.ago) do
-          job.pause!
-        end
-        job = HousekeepingJobTest::TestJob.new
-        job.pause!
-
-        HousekeepingJobTest::TestJob.create!(created_at: 15.days.ago)
-        HousekeepingJobTest::TestJob.create!
-
-        assert_equal 10, HousekeepingJobTest::TestJob.count, -> { HousekeepingJobTest::TestJob.all.to_a.ai }
-      end
-
-      after do
-        @job.destroy if @job && !@job.new_record?
-      end
-
-      describe 'perform' do
-        it 'destroys jobs' do
-          @job = RocketJob::Jobs::HousekeepingJob.new
-          @job.perform_now
-          assert_equal 1, HousekeepingJobTest::TestJob.aborted.count, -> { HousekeepingJobTest::TestJob.aborted.to_a.ai }
-          assert_equal 1, HousekeepingJobTest::TestJob.completed.count, -> { HousekeepingJobTest::TestJob.completed.to_a.ai }
-          assert_equal 1, HousekeepingJobTest::TestJob.failed.count, -> { HousekeepingJobTest::TestJob.failed.to_a.ai }
-          assert_equal 2, HousekeepingJobTest::TestJob.paused.count, -> { HousekeepingJobTest::TestJob.paused.to_a.ai }
-          assert_equal 2, HousekeepingJobTest::TestJob.queued.count, -> { HousekeepingJobTest::TestJob.queued.to_a.ai }
-        end
-      end
-    end
-
-    describe 'zombie cleanup' do
-      before do
-        @server = RocketJob::Server.new
-        @server.started!
-        assert @server.reload.zombie?
-        assert_equal 1, RocketJob::Server.count, -> { RocketJob::Server.all.to_a.ai }
-      end
-
-      it 'removes zombies' do
-        @job = RocketJob::Jobs::HousekeepingJob.new
-        assert @job.destroy_zombies
-        @job.perform_now
-        assert_equal 0, RocketJob::Server.count, -> { RocketJob::Server.all.to_a.ai }
-      end
-
-      it 'leaves zombies' do
-        @job = RocketJob::Jobs::HousekeepingJob.new(destroy_zombies: false)
-        refute @job.destroy_zombies
-        assert_equal 1, RocketJob::Server.count, -> { RocketJob::Server.all.to_a.ai }
-        @job.perform_now
-        assert_equal 1, RocketJob::Server.count, -> { RocketJob::Server.all.to_a.ai }
-      end
-    end
-  end
-end

data/test/jobs/on_demand_job_test.rb

@@ -1,59 +0,0 @@
-require_relative '../test_helper'
-
-class OnDemandJobTest < Minitest::Test
-  describe RocketJob::Jobs::OnDemandJob do
-    before do
-      RocketJob::Jobs::OnDemandJob.delete_all
-    end
-
-    describe '#perform' do
-      it 'hello world' do
-        code = <<~CODE
-          logger.info 'Hello World'
-        CODE
-
-        job = RocketJob::Jobs::OnDemandJob.new(code: code)
-        job.perform_now
-      end
-
-      it 'retain output' do
-        code = <<~CODE
-          {'value' => 'h' * 24}
-        CODE
-
-        job = RocketJob::Jobs::OnDemandJob.new(
-          code:           code,
-          collect_output: true
-        )
-        job.perform_now
-        assert_equal 'h' * 24, job.result['value']
-      end
-
-      it 'accepts input data' do
-        code = <<~CODE
-          {'value' => data['a'] * data['b']}
-        CODE
-
-        job = RocketJob::Jobs::OnDemandJob.new(
-          code:           code,
-          collect_output: true,
-          data:           {'a' => 10, 'b' => 2}
-        )
-        job.perform_now
-        assert_equal 20, job.result['value']
-      end
-
-      it 'validates code' do
-        code = <<~CODE
-          def bad code
-        CODE
-
-        job = RocketJob::Jobs::OnDemandJob.new(code: code)
-        refute job.valid?
-        assert_raises Mongoid::Errors::Validations do
-          job.perform_now
-        end
-      end
-    end
-  end
-end

data/test/jobs/upload_file_job_test.rb

@@ -1,107 +0,0 @@
-require_relative '../test_helper'
-
-class UploadFileJobTest < Minitest::Test
-  class TestJob < RocketJob::Job
-    field :upload_file_name, type: String
-
-    def upload(file_name)
-      self.upload_file_name = file_name
-    end
-
-    def perform
-    end
-  end
-
-  class BatchTestJob < RocketJob::Job
-    field :upload_file_name, type: String
-    field :saved_streams, type: Array
-
-    def upload(file_name, streams: nil)
-      self.upload_file_name = file_name
-      self.saved_streams    = streams
-    end
-
-    def perform
-    end
-  end
-
-  class BadJob < RocketJob::Job
-    def perform
-    end
-  end
-
-  describe RocketJob::Jobs::UploadFileJob do
-    before do
-      RocketJob::Job.delete_all
-    end
-
-    describe '#valid?' do
-      it 'validates upload_file_name' do
-        job = RocketJob::Jobs::UploadFileJob.new(job_class_name: UploadFileJobTest::TestJob.to_s)
-        refute job.valid?
-        assert_equal ["can't be blank"], job.errors.messages[:upload_file_name]
-      end
-
-      it 'validates file does not exist' do
-        job = RocketJob::Jobs::UploadFileJob.new(
-          job_class_name:   UploadFileJobTest::TestJob.to_s,
-          upload_file_name: '/tmp/blah'
-        )
-        refute job.valid?
-        assert_equal ['Upload file: /tmp/blah does not exist.'], job.errors.messages[:upload_file_name]
-      end
-
-      it 'validates job_class_name' do
-        job = RocketJob::Jobs::UploadFileJob.new(job_class_name: UploadFileJobTest::BadJob.to_s)
-        refute job.valid?
-        assert_equal ['UploadFileJobTest::BadJob must implement any one of: :upload :upload_file_name= :full_file_name= instance methods'], job.errors.messages[:job_class_name]
-      end
-
-      it 'with valid job and upload_file_name' do
-        job = RocketJob::Jobs::UploadFileJob.new(
-          job_class_name:   UploadFileJobTest::TestJob.to_s,
-          upload_file_name: __FILE__
-        )
-        assert job.valid?
-      end
-    end
-
-    describe '#perform' do
-      let :job do
-        RocketJob::Jobs::UploadFileJob.new(
-          job_class_name:   UploadFileJobTest::TestJob.name,
-          upload_file_name: __FILE__
-        )
-      end
-
-      it 'creates the job' do
-        job.perform_now
-        assert_equal 1, UploadFileJobTest::TestJob.count
-        assert job = UploadFileJobTest::TestJob.first
-      end
-
-      it 'calls upload' do
-        job.perform_now
-        assert job = UploadFileJobTest::TestJob.first
-        assert_equal __FILE__, job.upload_file_name
-      end
-
-      it 'calls upload with original_file_name' do
-        job.job_class_name     = BatchTestJob.name
-        job.perform_now
-        assert created_job = UploadFileJobTest::BatchTestJob.first
-        assert_equal __FILE__, created_job.upload_file_name
-        assert_nil created_job.saved_streams
-      end
-
-      it 'job retains the original_file_name when present' do
-        job.job_class_name     = BatchTestJob.name
-        job.original_file_name = 'file.zip'
-        job.perform_now
-        assert created_job = UploadFileJobTest::BatchTestJob.first
-        assert_equal 'file.zip', created_job.upload_file_name
-        assert_equal %i[file zip], created_job.saved_streams
-      end
-    end
-  end
-end

data/test/plugins/cron_test.rb

@@ -1,166 +0,0 @@
-require_relative '../test_helper'
-
-# Unit Test for RocketJob::Job
-module Plugins
-  class CronTest < Minitest::Test
-    class CronJob < RocketJob::Job
-      include RocketJob::Plugins::Cron
-
-      def perform
-        'DONE'
-      end
-    end
-
-    class FailOnceCronJob < RocketJob::Job
-      include RocketJob::Plugins::Cron
-
-      def perform
-        raise 'oh no' if failure_count.zero?
-      end
-    end
-
-    describe RocketJob::Plugins::Cron do
-      before do
-        # destroy_all could create new instances
-        CronJob.delete_all
-        FailOnceCronJob.delete_all
-        assert_equal 0, CronJob.count
-      end
-
-      after do
-        @job.destroy if @job && !@job.new_record?
-        CronJob.delete_all
-      end
-
-      describe '#create!' do
-        it 'queues a new job' do
-          @job = CronJob.create!(cron_schedule: '* 1 * * *')
-          assert @job.valid?
-          refute @job.new_record?
-        end
-
-        describe 'timezones are supported' do
-          it 'handles UTC' do
-            time = Time.parse('2015-12-09 17:50:05 UTC')
-            Time.stub(:now, time) do
-              @job = CronJob.create!(cron_schedule: '* 1 * * * UTC')
-            end
-            assert @job.valid?
-            refute @job.new_record?
-            assert_equal Time.parse('2015-12-10 01:00:00 UTC'), @job.run_at
-          end
-
-          it 'handles Eastern' do
-            time = Time.parse('2015-12-09 17:50:05 UTC')
-            Time.stub(:now, time) do
-              @job = CronJob.create!(cron_schedule: '* 1 * * * America/New_York')
-            end
-            assert @job.valid?
-            refute @job.new_record?
-            assert_equal Time.parse('2015-12-10 06:00:00 UTC'), @job.run_at
-          end
-        end
-      end
-
-      describe '#save' do
-        it 'updates run_at for a new record' do
-          @job = CronJob.create!(cron_schedule: '* 1 * * *')
-          assert @job.run_at
-        end
-
-        it 'updates run_at for a modified record' do
-          @job = CronJob.create!(cron_schedule: '* 1 * * * UTC')
-          assert run_at = @job.run_at
-          @job.cron_schedule = '* 2 * * * UTC'
-          assert_equal run_at, @job.run_at
-          @job.save!
-          assert run_at < @job.run_at
-        end
-      end
-
-      describe '#valid?' do
-        it 'allows missing cron schedule' do
-          @job = CronJob.new
-          assert @job.valid?
-        end
-
-        it 'fails on bad cron schedule' do
-          @job = CronJob.new(cron_schedule: 'blah')
-          refute @job.valid?
-          assert_equal "not a valid cronline : 'blah'", @job.errors.messages[:cron_schedule].first
-        end
-
-        it 'passes on valid cron schedule' do
-          @job = CronJob.new(cron_schedule: '* 1 * * *')
-          assert @job.valid?
-        end
-      end
-
-      describe '#fail' do
-        describe 'with cron_schedule' do
-          let :job do
-            job = FailOnceCronJob.create!(cron_schedule: '* 1 * * *')
-            job.start
-            assert_raises RuntimeError do
-              job.perform_now
-            end
-            job.reload
-            job
-          end
-
-          it 'allows current cron job instance to fail' do
-            assert job.failed?
-          end
-
-          it 'clears out cron_schedule' do
-            refute job.cron_schedule
-          end
-
-          it 'retains run_at' do
-            assert job.run_at
-          end
-
-          it 'schedules a new instance' do
-            assert_equal 0, FailOnceCronJob.count
-            job
-            assert_equal 2, FailOnceCronJob.count
-            assert scheduled_job = FailOnceCronJob.last
-            assert scheduled_job.queued?
-            assert_equal '* 1 * * *', scheduled_job.cron_schedule
-          end
-
-          it 'restarts on retry' do
-            job.retry!
-            job.perform_now
-            assert job.completed?
-            assert_equal 1, FailOnceCronJob.count, -> { FailOnceCronJob.all.to_a.collect(&:state).to_s }
-            assert_equal 1, FailOnceCronJob.queued.count
-          end
-        end
-
-        describe 'without cron_schedule' do
-          let :job do
-            job = CronJob.create!
-            job.start
-            job.fail
-            job
-          end
-
-          it 'allows current cron job instance to fail' do
-            assert job.failed?
-          end
-
-          it 'has no cron_schedule' do
-            refute job.cron_schedule
-          end
-
-          it 'does not schedule a new instance' do
-            assert_equal 0, CronJob.count
-            job
-            assert_equal 1, CronJob.count
-          end
-        end
-      end
-    end
-  end
-end