rocketjob 1.3.0 → 2.0.0.rc1

data/test/dirmon_entry_test.rb

@@ -1,17 +1,34 @@
 require_relative 'test_helper'
-require_relative 'jobs/test_job'
 
 # Unit Test for RocketJob::Job
 class DirmonEntryTest < Minitest::Test
+
+  class OneArgumentJob < RocketJob::Job
+    def perform(arg)
+    end
+  end
+
   class WithFullFileNameJob < RocketJob::Job
     # Dirmon will store the filename in this property when starting the job
-    key :full_file_name, String
+    key :upload_file_name, String
 
     def perform
-      # Do something with the file name stored in :full_file_name
+      # Do something with the file name stored in :upload_file_name
     end
   end
 
+  class SumJob < RocketJob::Job
+    @@result = nil
+
+    # For temp test data
+    def self.result
+      @@result
+    end
+
+    def perform(a, b)
+      @@result = a + b
+    end
+  end
 
   describe RocketJob::DirmonEntry do
     describe '.config' do
@@ -57,31 +74,33 @@ class DirmonEntryTest < Minitest::Test
       end
 
       it 'convert relative path to an absolute one' do
-        path = Pathname('test/jobs').realpath.to_s
-        assert_equal path, RocketJob::DirmonEntry.add_whitelist_path('test/jobs')
+        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/jobs').realpath.to_s
-        assert_equal path, RocketJob::DirmonEntry.add_whitelist_path('test/jobs')
-        assert_equal path, RocketJob::DirmonEntry.add_whitelist_path('test/jobs')
+        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_with_exception!' do
+    describe '#fail!' do
       before do
-        @dirmon_entry = RocketJob::DirmonEntry.new(job_class_name: 'Jobs::TestJob', pattern: 'test/files/**', arguments: [1])
+        @dirmon_entry = RocketJob::DirmonEntry.new(job_class_name: 'DirmonEntryTest::OneArgumentJob', pattern: 'test/files/**', arguments: [1])
         @dirmon_entry.enable!
+        assert @dirmon_entry.valid?, @dirmon_entry.errors.messages.ai
       end
+
       after do
         @dirmon_entry.destroy if @dirmon_entry && @dirmon_entry.new_record?
       end
 
       it 'fail with message' do
-        @dirmon_entry.fail_with_exception!('myworker:2323', 'oh no')
+        @dirmon_entry.fail!('myworker:2323', 'oh no')
         assert_equal true, @dirmon_entry.failed?
         assert_equal 'RocketJob::DirmonEntryException', @dirmon_entry.exception.class_name
         assert_equal 'oh no', @dirmon_entry.exception.message
@@ -94,7 +113,7 @@ class DirmonEntryTest < Minitest::Test
         rescue Exception => exc
           exception = exc
         end
-        @dirmon_entry.fail_with_exception!('myworker:2323', exception)
+        @dirmon_entry.fail!('myworker:2323', exception)
 
         assert_equal true, @dirmon_entry.failed?
         assert_equal exception.class.name.to_s, @dirmon_entry.exception.class_name
@@ -104,107 +123,84 @@ class DirmonEntryTest < Minitest::Test
 
     describe '#validate' do
       it 'existance' do
-        assert entry = RocketJob::DirmonEntry.new(job_class_name: 'Jobs::TestJob')
+        assert entry = RocketJob::DirmonEntry.new(job_class_name: 'DirmonEntryTest::OneArgumentJob')
         assert_equal false, entry.valid?
-        assert_equal ["can't be blank"], entry.errors[:pattern], entry.errors.inspect
-      end
-
-      describe 'perform_method' do
-        describe 'with an invalid method' do
-          it 'add errors to the entry' do
-            entry = RocketJob::DirmonEntry.new(job_class_name: 'Jobs::TestJob', perform_method: :missing_perform_method)
-            assert_equal false, entry.valid?
-            assert_equal ['Method not implemented by Jobs::TestJob'], entry.errors[:perform_method], entry.errors.inspect
-          end
-        end
+        assert_equal ["can't be blank"], entry.errors[:pattern], entry.errors.messages.ai
       end
 
       describe 'job_class_name' do
         it 'ensure presence' do
           assert entry = RocketJob::DirmonEntry.new(pattern: 'test/files/**')
           assert_equal false, entry.valid?
-          assert_equal ["can't be blank", 'job_class_name must be defined and must be derived from RocketJob::Job'], entry.errors[:job_class_name], entry.errors.inspect
+          assert_equal ["can't be blank", 'job_class_name must be defined and must be derived from RocketJob::Job'], entry.errors[:job_class_name], entry.errors.messages.ai
         end
       end
 
       describe 'arguments' do
         it 'allow no arguments' do
           assert entry = RocketJob::DirmonEntry.new(
-              job_class_name: 'Jobs::TestJob',
-              pattern:        'test/files/**',
-              perform_method: :result
-            )
-          assert_equal true, entry.valid?, entry.errors.inspect
-          assert_equal [], entry.errors[:arguments], entry.errors.inspect
+            job_class_name: 'DirmonEntryTest::WithFullFileNameJob',
+            pattern:        'test/files/**'
+          )
+          assert entry.valid?, entry.errors.messages.ai
         end
 
         it 'ensure correct number of arguments' do
           assert entry = RocketJob::DirmonEntry.new(
-              job_class_name: 'Jobs::TestJob',
-              pattern:        'test/files/**'
-            )
-          assert_equal false, entry.valid?
-          assert_equal ['There must be 1 argument(s)'], entry.errors[:arguments], entry.errors.inspect
+            job_class_name: 'DirmonEntryTest::OneArgumentJob',
+            pattern:        'test/files/**'
+          )
+          refute entry.valid?
+          assert_equal ['There must be 1 argument(s)'], entry.errors[:arguments], entry.errors.messages.ai
         end
 
-        it 'return false if the job name is bad' do
+        it 'fail if the job name is bad' do
           assert entry = RocketJob::DirmonEntry.new(
-              job_class_name: 'Jobs::Tests::Names::Things',
-              pattern:        'test/files/**'
-            )
-          assert_equal false, entry.valid?
-          assert_equal [], entry.errors[:arguments], entry.errors.inspect
-        end
-      end
-
-      it 'arguments with perform_method' do
-        assert entry = RocketJob::DirmonEntry.new(
-            job_class_name: 'Jobs::TestJob',
-            pattern:        'test/files/**',
-            perform_method: :sum
+            job_class_name: 'Jobs::Tests::Names::Things',
+            pattern:        'test/files/**'
           )
-        assert_equal false, entry.valid?
-        assert_equal ['There must be 2 argument(s)'], entry.errors[:arguments], entry.errors.inspect
+          refute entry.valid?
+          assert_equal [], entry.errors[:arguments], entry.errors.messages.ai
+        end
       end
 
-      it 'valid' do
+      it 'invalid without 2 arguments' do
         assert entry = RocketJob::DirmonEntry.new(
-            job_class_name: 'Jobs::TestJob',
-            pattern:        'test/files/**',
-            arguments:      [1]
-          )
-        assert entry.valid?, entry.errors.inspect
+          job_class_name: 'DirmonEntryTest::SumJob',
+          pattern:        'test/files/**'
+        )
+        refute entry.valid?
+        assert_equal ['There must be 2 argument(s)'], entry.errors[:arguments], entry.errors.messages.ai
       end
 
-      it 'valid with perform_method' do
+      it 'valid with 2 arguments' do
         assert entry = RocketJob::DirmonEntry.new(
-            job_class_name: 'Jobs::TestJob',
-            pattern:        'test/files/**',
-            perform_method: :sum,
-            arguments:      [1, 2]
-          )
-        assert entry.valid?, entry.errors.inspect
+          job_class_name: 'DirmonEntryTest::SumJob',
+          pattern:        'test/files/**',
+          arguments:      [1, 2]
+        )
+        assert entry.valid?, entry.errors.messages.ai
       end
     end
 
     describe 'with valid entry' do
       before do
+        RocketJob::Jobs::DirmonJob.delete_all
         @archive_directory = '/tmp/archive_directory'
         @archive_path      = Pathname.new(@archive_directory)
         @archive_path.mkpath
         @archive_path = @archive_path.realdirpath
         @entry        = RocketJob::DirmonEntry.new(
           pattern:           'test/files/**/*',
-          job_class_name:    'Jobs::TestJob',
+          job_class_name:    'RocketJob::Jobs::DirmonJob',
           arguments:         [{}],
-          properties:        {priority: 23, perform_method: :event},
+          properties:        {priority: 23},
           archive_directory: @archive_directory
         )
-        @job          = Jobs::TestJob.new(
+        @job          = DirmonEntryTest::OneArgumentJob.new(
           @entry.properties.merge(
-            arguments:      @entry.arguments,
-            properties:     @entry.properties,
-            perform_method: @entry.perform_method
+            arguments:  @entry.arguments,
+            properties: @entry.properties
           )
         )
         @file         = Tempfile.new('archive')
@@ -217,6 +213,7 @@ class DirmonEntryTest < Minitest::Test
 
       after do
         @file.delete if @file
+        RocketJob::Jobs::DirmonJob.delete_all
       end
 
       describe '#archive_pathname' do
@@ -243,7 +240,7 @@ class DirmonEntryTest < Minitest::Test
           assert_equal @archive_real_name, @job.arguments.first[:full_file_name], @job.arguments
         end
 
-        it 'sets full_file_name property' do
+        it 'sets upload_file_name property' do
           @entry = RocketJob::DirmonEntry.new(
             pattern:           'test/files/**/*',
             job_class_name:    'DirmonEntryTest::WithFullFileNameJob',
@@ -253,7 +250,7 @@ class DirmonEntryTest < Minitest::Test
           job = @entry.job_class.new
           @entry.send(:upload_default, job, @pathname)
           archive_real_name = @archive_path.join("#{job.id}_#{File.basename(@file_name)}").to_s
-          assert_equal archive_real_name, job.full_file_name, job.arguments
+          assert_equal archive_real_name, job.upload_file_name, job.arguments
         end
 
         it 'handles non hash argument and missing property' do
@@ -265,14 +262,6 @@ class DirmonEntryTest < Minitest::Test
       end
 
       describe '#upload_file' do
-        it 'upload using #file_store_upload' do
-          @job.define_singleton_method(:file_store_upload) do |file_name|
-            self.description = "FILE:#{file_name}"
-          end
-          @entry.send(:upload_file, @job, @pathname)
-          assert_equal "FILE:#{@file_name}", @job.description
-        end
-
         it 'upload using #upload' do
           @job.define_singleton_method(:upload) do |file_name|
             self.description = "FILE:#{file_name}"
@@ -283,13 +272,20 @@ class DirmonEntryTest < Minitest::Test
       end
 
       describe '#later' do
-        it 'enqueue job' do
-          @entry.arguments      = [{}]
-          @entry.perform_method = :event
-          job                   = @entry.later(@pathname)
+        it 'enqueues job' do
+          @entry.arguments = [{}]
+          job              = @entry.later(@pathname)
           assert_equal Pathname.new(@archive_directory).join("#{job.id}_#{File.basename(@file_name)}").realdirpath.to_s, job.arguments.first[:full_file_name]
           assert job.queued?
         end
+
+        it 'fails with bad job class name' do
+          @entry.arguments      = [{}]
+          @entry.job_class_name = 'Blah'
+          assert_raises ArgumentError do
+            @entry.later(@pathname)
+          end
+        end
       end
 
       describe '#each' do

data/test/dirmon_job_test.rb

@@ -1,18 +1,24 @@
 require_relative 'test_helper'
-require_relative 'jobs/test_job'
 
 # Unit Test for RocketJob::Job
 class DirmonJobTest < Minitest::Test
+  class DirmonTestJob < RocketJob::Job
+    def perform(hash)
+      3645
+    end
+  end
+
   describe RocketJob::Jobs::DirmonJob do
     before do
+      RocketJob::Jobs::DirmonJob.delete_all
       @dirmon_job        = RocketJob::Jobs::DirmonJob.new
       @directory         = '/tmp/directory'
       @archive_directory = '/tmp/archive_directory'
       @entry             = RocketJob::DirmonEntry.new(
         pattern:           "#{@directory}/abc/*",
-        job_class_name:    'Jobs::TestJob',
+        job_class_name:    'DirmonJobTest::DirmonTestJob',
         arguments:         [{input: 'yes'}],
-        properties:        {priority: 23, perform_method: :event},
+        properties:        {priority: 23},
         archive_directory: @archive_directory
       )
       FileUtils.makedirs("#{@directory}/abc")
@@ -20,7 +26,7 @@ class DirmonJobTest < Minitest::Test
     end
 
     after do
-      @dirmon_job.destroy if @dirmon_job && !@dirmon_job.new_record?
+      @dirmon_job.delete if @dirmon_job && !@dirmon_job.new_record?
       FileUtils.remove_dir(@archive_directory, true) if Dir.exist?(@archive_directory)
       FileUtils.remove_dir(@directory, true) if Dir.exist?(@directory)
     end
@@ -57,8 +63,9 @@ class DirmonJobTest < Minitest::Test
       it 'check deleted file' do
         previous_size = 5
         file_name     = Pathname.new('blah')
-        result        = @dirmon_job.send(:check_file, @entry, file_name, previous_size)
-        assert_equal nil, result
+        assert_raises Errno::ENOENT do
+          @dirmon_job.send(:check_file, @entry, file_name, previous_size)
+        end
       end
     end
 
@@ -137,7 +144,6 @@ class DirmonJobTest < Minitest::Test
 
     describe '#perform' do
       it 'check directories and reschedule' do
-        dirmon_job          = nil
         previous_file_names = {
           "#{@directory}/abc/file1" => 5,
           "#{@directory}/abc/file2" => 10,
@@ -146,22 +152,24 @@ class DirmonJobTest < Minitest::Test
           "#{@directory}/abc/file1" => 10,
           "#{@directory}/abc/file2" => 10,
         }
-        RocketJob::Jobs::DirmonJob.destroy_all
+        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
-          # perform_now does not save the job, just runs it
-          dirmon_job = RocketJob::Jobs::DirmonJob.new(
-            previous_file_names: previous_file_names,
-            priority:            11,
-            check_seconds:       30
-          )
-          dirmon_job.work_now
+          @dirmon_job.perform_now
         end
-        assert dirmon_job.completed?, dirmon_job.status.inspect
+        assert @dirmon_job.completed?, @dirmon_job.status.inspect
+        # Job must destroy on complete
+        refute RocketJob::Jobs::DirmonJob.find(@dirmon_job.id)
 
-        # It it have enqueued another instance to run in the future
+        # 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
-        assert_equal false, dirmon_job.id == new_dirmon_job.id
+        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
@@ -171,20 +179,24 @@ class DirmonJobTest < Minitest::Test
       end
 
       it 'check directories and reschedule even on exception' do
-        dirmon_job = nil
         RocketJob::Jobs::DirmonJob.destroy_all
-        RocketJob::Jobs::DirmonJob.stub_any_instance(:check_directories, -> previous { raise RuntimeError.new("Oh no") }) do
-          # perform_now does not save the job, just runs it
-          dirmon_job = RocketJob::Jobs::DirmonJob.create!(
-            priority:      11,
-            check_seconds: 30
-          )
-          dirmon_job.work_now
+        # 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 RuntimeError.new('Oh no') }) do
+          assert_raises RuntimeError do
+            dirmon_job.perform_now
+          end
         end
-        assert dirmon_job.failed?, dirmon_job.status.inspect
+        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
+        assert_equal 2, RocketJob::Jobs::DirmonJob.count, RocketJob::Jobs::DirmonJob.to_a
         assert new_dirmon_job = RocketJob::Jobs::DirmonJob.last
         assert new_dirmon_job.run_at
         assert_equal 11, new_dirmon_job.priority