rocketjob 3.5.2 → 4.0.0

data/test/dirmon_entry_test.rb

@@ -1,313 +0,0 @@
-require_relative 'test_helper'
-
-# Unit Test for RocketJob::Job
-class DirmonEntryTest < Minitest::Test
-  class TestJob < RocketJob::Job
-    # Dirmon will store the filename in this property when starting the job
-    field :upload_file_name, type: String
-
-    field :user_id, type: Integer
-
-    def perform
-      # Do something with the file name stored in :upload_file_name
-    end
-  end
-
-  describe RocketJob::DirmonEntry do
-    let :archive_directory do
-      '/tmp/archive_directory'
-    end
-
-    let :archive_path do
-      archive_path = Pathname.new(archive_directory)
-      archive_path.mkpath
-      archive_path.realdirpath
-    end
-
-    let :dirmon_entry do
-      dirmon_entry = RocketJob::DirmonEntry.new(
-        name:              'Test',
-        job_class_name:    'DirmonEntryTest::TestJob',
-        pattern:           'test/files/**',
-        properties:        {user_id: 341},
-        archive_directory: archive_directory
-      )
-      dirmon_entry.enable!
-      assert dirmon_entry.valid?, dirmon_entry.errors.messages.ai
-      dirmon_entry
-    end
-
-    before do
-      RocketJob::Jobs::DirmonJob.delete_all
-      RocketJob::Jobs::UploadFileJob.delete_all
-      RocketJob::DirmonEntry.delete_all
-    end
-
-    describe '.config' do
-      it 'support multiple databases' do
-        assert_equal 'rocketjob_test', RocketJob::DirmonEntry.collection.database.name
-      end
-    end
-
-    describe '#job_class' do
-      describe 'with a nil job_class_name' do
-        it 'return nil' do
-          entry = RocketJob::DirmonEntry.new
-          assert_nil entry.job_class
-        end
-      end
-
-      describe 'with an unknown job_class_name' do
-        it 'return nil' do
-          entry = RocketJob::DirmonEntry.new(job_class_name: 'FakeJobThatDoesNotExistAnyWhereIPromise')
-          assert_nil entry.job_class
-        end
-      end
-
-      describe 'with a valid job_class_name' do
-        it 'return job class' do
-          entry = RocketJob::DirmonEntry.new(job_class_name: 'RocketJob::Job')
-          assert_equal RocketJob::Job, entry.job_class
-          assert_equal 0, entry.properties.size
-        end
-      end
-    end
-
-    describe '.whitelist_paths' do
-      it 'default to []' do
-        assert_equal [], RocketJob::DirmonEntry.whitelist_paths
-      end
-    end
-
-    describe '.add_whitelist_path' do
-      after do
-        RocketJob::DirmonEntry.whitelist_paths.each { |path| RocketJob::DirmonEntry.delete_whitelist_path(path) }
-      end
-
-      it 'convert relative path to an absolute one' do
-        path = Pathname('test/files').realpath.to_s
-        assert_equal path, RocketJob::DirmonEntry.add_whitelist_path('test/files')
-        assert_equal [path], RocketJob::DirmonEntry.whitelist_paths
-      end
-
-      it 'prevent duplicates' do
-        path = Pathname('test/files').realpath.to_s
-        assert_equal path, RocketJob::DirmonEntry.add_whitelist_path('test/files')
-        assert_equal path, RocketJob::DirmonEntry.add_whitelist_path('test/files')
-        assert_equal path, RocketJob::DirmonEntry.add_whitelist_path(path)
-        assert_equal [path], RocketJob::DirmonEntry.whitelist_paths
-      end
-    end
-
-    describe '#fail!' do
-      it 'fail with message' do
-        dirmon_entry.fail!('myworker:2323', 'oh no')
-        assert dirmon_entry.failed?
-        assert_equal 'RocketJob::DirmonEntryException', dirmon_entry.exception.class_name
-        assert_equal 'oh no', dirmon_entry.exception.message
-      end
-
-      it 'fail with exception' do
-        exception = nil
-        begin
-          blah
-        rescue Exception => exc
-          exception = exc
-        end
-        dirmon_entry.fail!('myworker:2323', exception)
-
-        assert_equal true, dirmon_entry.failed?
-        assert_equal exception.class.name.to_s, dirmon_entry.exception.class_name
-        assert dirmon_entry.exception.message.include?('undefined local variable or method'), dirmon_entry.attributes.inspect
-      end
-    end
-
-    describe '#validate' do
-      it 'strip_whitespace' do
-        dirmon_entry.pattern           = ' test/files/*'
-        dirmon_entry.archive_directory = ' test/archive/ '
-        assert dirmon_entry.valid?
-        assert_equal 'test/files/*', dirmon_entry.pattern
-        assert_equal 'test/archive/', dirmon_entry.archive_directory
-      end
-
-      describe 'pattern' do
-        it 'present' do
-          dirmon_entry.pattern = nil
-          refute dirmon_entry.valid?
-          assert_equal ["can't be blank"], dirmon_entry.errors[:pattern], dirmon_entry.errors.messages.ai
-        end
-      end
-
-      describe 'job_class_name' do
-        it 'ensure presence' do
-          dirmon_entry.job_class_name = nil
-          refute dirmon_entry.valid?
-          assert_equal ["can't be blank"], dirmon_entry.errors[:job_class_name], dirmon_entry.errors.messages.ai
-        end
-
-        it 'is a RocketJob::Job' do
-          dirmon_entry.job_class_name = 'String'
-          refute dirmon_entry.valid?
-          assert_equal ['Job String must be defined and inherit from RocketJob::Job'], dirmon_entry.errors[:job_class_name], dirmon_entry.errors.messages.ai
-        end
-
-        it 'is invalid' do
-          dirmon_entry.job_class_name = 'Blah'
-          refute dirmon_entry.valid?
-          assert_equal ['Job Blah must be defined and inherit from RocketJob::Job'], dirmon_entry.errors[:job_class_name], dirmon_entry.errors.messages.ai
-        end
-      end
-
-      describe 'properties' do
-        it 'are valid' do
-          dirmon_entry.properties = {user_id: 123}
-          assert dirmon_entry.valid?, dirmon_entry.errors.messages.ai
-        end
-
-        it 'not valid' do
-          dirmon_entry.properties = {blah: 123}
-          refute dirmon_entry.valid?
-          assert_equal ['Unknown Property: Attempted to set a value for :blah which is not allowed on the job DirmonEntryTest::TestJob'], dirmon_entry.errors[:properties], dirmon_entry.errors.messages.ai
-        end
-      end
-    end
-
-    describe 'with valid entry' do
-      let :file do
-        file = Tempfile.new('archive')
-        File.open(file.path, 'w') { |file| file.write('Hello World') }
-        file
-      end
-
-      let :file_name do
-        file.path
-      end
-
-      let :pathname do
-        Pathname.new(file_name)
-      end
-
-      after do
-        file.delete
-        RocketJob::Jobs::DirmonJob.delete_all
-      end
-
-      describe '#each' do
-        it 'without archive path' do
-          dirmon_entry.archive_directory = nil
-          files                          = []
-          dirmon_entry.each do |file_name|
-            files << file_name
-          end
-          assert_nil dirmon_entry.archive_directory
-          assert_equal 1, files.count
-          assert_equal Pathname.new('test/files/text.txt').realpath, files.first
-        end
-
-        it 'with archive path' do
-          files = []
-          dirmon_entry.each do |file_name|
-            files << file_name
-          end
-          assert_equal 1, files.count
-          assert_equal Pathname.new('test/files/text.txt').realpath, files.first
-        end
-
-        it 'with case-insensitive pattern' do
-          dirmon_entry.pattern = 'test/files/**/*.TxT'
-          files                = []
-          dirmon_entry.each do |file_name|
-            files << file_name
-          end
-          assert_equal 1, files.count
-          assert_equal Pathname.new('test/files/text.txt').realpath, files.first
-        end
-
-        it 'reads paths inside of the whitelist' do
-          dirmon_entry.archive_directory = nil
-          files                          = []
-          dirmon_entry.stub(:whitelist_paths, [Pathname.new('test/files').realpath.to_s]) do
-            dirmon_entry.each do |file_name|
-              files << file_name
-            end
-          end
-          assert_nil dirmon_entry.archive_directory
-          assert_equal 1, files.count
-          assert_equal Pathname.new('test/files/text.txt').realpath, files.first
-        end
-
-        it 'skips paths outside of the whitelist' do
-          dirmon_entry.archive_directory = nil
-          files                          = []
-          dirmon_entry.stub(:whitelist_paths, [Pathname.new('test/config').realpath.to_s]) do
-            dirmon_entry.each do |file_name|
-              files << file_name
-            end
-          end
-          assert_nil dirmon_entry.archive_directory
-          assert_equal 0, files.count
-        end
-      end
-
-      describe '#later' do
-        it 'enqueues job' do
-          job = dirmon_entry.later(pathname)
-          assert created_job = RocketJob::Jobs::UploadFileJob.last
-          assert_equal job.id, created_job.id
-          assert job.queued?
-        end
-
-        it 'sets attributes' do
-          job = dirmon_entry.later(pathname)
-
-          upload_file_name = Pathname.new(archive_directory).join("#{job.job_id}_#{File.basename(file_name)}").realdirpath.to_s
-
-          assert_equal dirmon_entry.job_class_name, job.job_class_name
-          assert_equal dirmon_entry.properties, job.properties
-          assert_equal upload_file_name, job.upload_file_name
-          assert_equal "#{dirmon_entry.name}: #{pathname.basename}", job.description
-          assert_equal pathname.to_s, job.original_file_name
-          assert job.job_id
-        end
-      end
-
-      describe '#archive_file' do
-        it 'moves file to archive dir' do
-          job_id            = BSON::ObjectId.new
-          archive_real_name = archive_path.join("#{job_id}_#{File.basename(file_name)}").to_s
-
-          assert File.exist?(file_name)
-          assert_equal archive_real_name, dirmon_entry.send(:archive_file, job_id, pathname)
-          refute File.exist?(file_name)
-          assert File.exist?(archive_real_name)
-        end
-      end
-
-      describe '#archive_pathname' do
-        it 'with fully qualified archive directory' do
-          assert_equal archive_path.to_s, dirmon_entry.send(:archive_pathname, pathname).to_s
-        end
-
-        describe 'with relative' do
-          let :archive_directory do
-            'my_archive/files'
-          end
-
-          it 'archive directory' do
-            archive_dir = File.join(pathname.realdirpath.dirname, archive_directory)
-            assert_equal archive_dir, dirmon_entry.send(:archive_pathname, pathname).to_s
-          end
-        end
-
-        it 'has a default archive directory' do
-          e = RocketJob::DirmonEntry.new(
-            pattern:        'test/files/**/*',
-            job_class_name: 'RocketJob::Jobs::DirmonJob'
-          )
-          assert_equal 'archive', e.archive_directory
-        end
-      end
-    end
-  end
-end

data/test/dirmon_job_test.rb

@@ -1,216 +0,0 @@
-require_relative 'test_helper'
-
-# Unit Test for RocketJob::Job
-class DirmonJobTest < Minitest::Test
-  class TestJob < RocketJob::Job
-    def perform
-      3645
-    end
-  end
-
-  describe RocketJob::Jobs::DirmonJob do
-    let :dirmon_job do
-      RocketJob::Jobs::DirmonJob.new
-    end
-
-    let :directory do
-      '/tmp/directory'
-    end
-
-    let :archive_directory do
-      '/tmp/archive_directory'
-    end
-
-    let :dirmon_entry do
-      RocketJob::DirmonEntry.new(
-        pattern:           "#{directory}/abc/*",
-        job_class_name:    'DirmonJobTest::TestJob',
-        properties:        {priority: 23},
-        archive_directory: archive_directory
-      )
-    end
-
-    before do
-      RocketJob::Jobs::DirmonJob.delete_all
-      FileUtils.makedirs("#{directory}/abc")
-    end
-
-    after do
-      FileUtils.remove_dir(archive_directory, true) if Dir.exist?(archive_directory)
-      FileUtils.remove_dir(directory, true) if Dir.exist?(directory)
-    end
-
-    describe '#check_file' do
-      it 'check growing file' do
-        previous_size = 5
-        new_size      = 10
-        file          = create_temp_file(new_size)
-        result        = dirmon_entry.stub(:later, nil) do
-          dirmon_job.send(:check_file, dirmon_entry, file, previous_size)
-        end
-        assert_equal new_size, result
-      end
-
-      it 'check completed file' do
-        previous_size = 10
-        new_size      = 10
-        file          = create_temp_file(new_size)
-        started       = false
-        result        = dirmon_entry.stub(:later, ->(_fn) { started = true }) do
-          dirmon_job.send(:check_file, dirmon_entry, file, previous_size)
-        end
-        assert_nil result
-        assert started
-      end
-
-      it 'check deleted file' do
-        previous_size = 5
-        file_name     = Pathname.new('blah')
-        assert_raises Errno::ENOENT do
-          dirmon_job.send(:check_file, dirmon_entry, file_name, previous_size)
-        end
-      end
-    end
-
-    describe '#check_directories' do
-      before do
-        RocketJob::DirmonEntry.destroy_all
-        dirmon_entry.enable!
-      end
-
-      it 'no files' do
-        result = dirmon_job.send(:check_directories)
-        assert_equal 0, result.count
-      end
-
-      it 'collect new files without enqueuing them' do
-        create_file("#{directory}/abc/file1", 5)
-        create_file("#{directory}/abc/file2", 10)
-
-        result = dirmon_job.send(:check_directories)
-        assert_equal [5, 10], result.values.sort
-      end
-
-      it 'allow files to grow' do
-        create_file("#{directory}/abc/file1", 5)
-        create_file("#{directory}/abc/file2", 10)
-        dirmon_job.send(:check_directories)
-        create_file("#{directory}/abc/file1", 10)
-        create_file("#{directory}/abc/file2", 15)
-        result = dirmon_job.send(:check_directories)
-        assert_equal [10, 15], result.values.sort
-      end
-
-      it 'start all files' do
-        create_file("#{directory}/abc/file1", 5)
-        create_file("#{directory}/abc/file2", 10)
-        files = dirmon_job.send(:check_directories)
-        assert_equal 2, files.count, files
-        assert_equal 2, dirmon_job.previous_file_names.count, files
-
-        # files = dirmon_job.send(:check_directories)
-        # assert_equal 0, files.count, files
-
-        count  = 0
-        result = RocketJob::DirmonEntry.stub_any_instance(:later, ->(_path) { count += 1 }) do
-          dirmon_job.send(:check_directories)
-        end
-        assert_equal 0, result.count, result
-        assert 2, count
-      end
-
-      it 'skip files in archive directory' do
-        dirmon_entry.archive_directory = 'archive'
-        dirmon_entry.pattern           = "#{directory}/abc/**/*"
-
-        file_pathname                  = Pathname.new("#{directory}/abc/file1")
-        create_file(file_pathname.to_s, 5)
-        create_file("#{directory}/abc/file2", 10)
-
-        archive_pathname = dirmon_entry.send(:archive_pathname, file_pathname)
-        create_file("#{archive_pathname}/file3", 21)
-
-        result = dirmon_job.send(:check_directories)
-        assert_equal [5, 10], result.values.sort
-      end
-    end
-
-    describe '#perform' do
-      it 'check directories and reschedule' do
-        previous_file_names = {
-          "#{directory}/abc/file1" => 5,
-          "#{directory}/abc/file2" => 10
-        }
-        new_file_names      = {
-          "#{directory}/abc/file1" => 10,
-          "#{directory}/abc/file2" => 10
-        }
-        assert_equal 0, RocketJob::Jobs::DirmonJob.count
-        # perform_now does not save the job, just runs it
-        dirmon_job = RocketJob::Jobs::DirmonJob.create!(
-          previous_file_names: previous_file_names,
-          priority:            11,
-          check_seconds:       30
-        )
-        RocketJob::Jobs::DirmonJob.stub_any_instance(:check_directories, new_file_names) do
-          dirmon_job.perform_now
-        end
-        assert dirmon_job.completed?, dirmon_job.status.inspect
-        # Job must destroy on complete
-        assert_equal 0, RocketJob::Jobs::DirmonJob.where(id: dirmon_job.id).count, -> { RocketJob::Jobs::DirmonJob.all.to_a.ai }
-
-        # Must have enqueued another instance to run in the future
-        assert_equal 1, RocketJob::Jobs::DirmonJob.count
-        assert new_dirmon_job = RocketJob::Jobs::DirmonJob.last
-        refute_equal dirmon_job.id.to_s, new_dirmon_job.id.to_s
-        assert new_dirmon_job.run_at
-        assert_equal 11, new_dirmon_job.priority
-        assert_equal 30, new_dirmon_job.check_seconds
-        assert new_dirmon_job.queued?
-
-        new_dirmon_job.destroy
-      end
-
-      it 'check directories and reschedule even on exception' do
-        RocketJob::Jobs::DirmonJob.destroy_all
-        # perform_now does not save the job, just runs it
-        dirmon_job = RocketJob::Jobs::DirmonJob.create!(
-          priority:            11,
-          check_seconds:       30,
-          destroy_on_complete: false
-        )
-        RocketJob::Jobs::DirmonJob.stub_any_instance(:check_directories, -> { raise 'Oh no' }) do
-          assert_raises RuntimeError do
-            dirmon_job.perform_now
-          end
-        end
-        dirmon_job.save!
-        assert dirmon_job.aborted?, dirmon_job.status.ai
-        assert_equal 'RuntimeError', dirmon_job.exception.class_name, dirmon_job.exception.attributes
-        assert_equal 'Oh no', dirmon_job.exception.message, dirmon_job.exception.attributes
-
-        # Must have enqueued another instance to run in the future
-        assert_equal 2, RocketJob::Jobs::DirmonJob.count, -> { RocketJob::Jobs::DirmonJob.all.ai }
-        assert new_dirmon_job = RocketJob::Jobs::DirmonJob.queued.first
-        assert new_dirmon_job.run_at
-        assert_equal 11, new_dirmon_job.priority, -> { new_dirmon_job.attributes.ai }
-        assert_equal 30, new_dirmon_job.check_seconds
-        assert new_dirmon_job.queued?, new_dirmon_job.state
-
-        new_dirmon_job.destroy
-      end
-    end
-
-    def create_file(file_name, size)
-      File.open(file_name, 'wb') { |file| file.write('*' * size) }
-    end
-
-    def create_temp_file(size)
-      file      = Tempfile.new('check_file')
-      file_name = file.path
-      File.open(file_name, 'wb') { |f| f.write('*' * size) }
-      assert_equal size, File.size(file_name)
-      file
-    end
-  end
-end