rocketjob 3.4.3 → 3.5.0

data/test/config_test.rb

@@ -1,12 +1,10 @@
 require_relative 'test_helper'
 class ConfigTest < Minitest::Test
   describe RocketJob::Config do
-
     describe '.config' do
       it 'support multiple databases' do
         assert_equal 'rocketjob_test', RocketJob::Job.collection.database.name
       end
     end
-
   end
 end

data/test/dirmon_entry_test.rb

@@ -2,30 +2,47 @@ require_relative 'test_helper'
 
 # Unit Test for RocketJob::Job
 class DirmonEntryTest < Minitest::Test
-
-  class WithFullFileNameJob < RocketJob::Job
+  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
 
-  class SumJob < RocketJob::Job
-    @result = nil
+  describe RocketJob::DirmonEntry do
+    let :archive_directory do
+      '/tmp/archive_directory'
+    end
 
-    # For temp test data
-    def self.result
-      @result
+    let :archive_path do
+      archive_path = Pathname.new(archive_directory)
+      archive_path.mkpath
+      archive_path.realdirpath
     end
 
-    def perform(a, b)
-      @result = a + b
+    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
-  end
 
-  describe RocketJob::DirmonEntry do
     describe '.config' do
       it 'support multiple databases' do
         assert_equal 'rocketjob_test', RocketJob::DirmonEntry.collection.database.name
@@ -83,21 +100,11 @@ class DirmonEntryTest < Minitest::Test
     end
 
     describe '#fail!' do
-      before do
-        @dirmon_entry = RocketJob::DirmonEntry.new(job_class_name: 'DirmonEntryTest::WithFullFileNameJob', pattern: 'test/files/**')
-        @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!('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
+        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
@@ -107,138 +114,100 @@ class DirmonEntryTest < Minitest::Test
         rescue Exception => exc
           exception = exc
         end
-        @dirmon_entry.fail!('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
-        assert @dirmon_entry.exception.message.include?('undefined local variable or method'), @dirmon_entry.attributes.inspect
+        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 'existance' do
-        assert entry = RocketJob::DirmonEntry.new(job_class_name: 'DirmonEntryTest::WithFullFileNameJob')
-        assert_equal false, entry.valid?
-        assert_equal ["can't be blank"], entry.errors[:pattern], entry.errors.messages.ai
+      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
-          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.messages.ai
+          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
-      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:    'RocketJob::Jobs::DirmonJob',
-          properties:        {priority: 23},
-          archive_directory: @archive_directory
-        )
-        @job          = DirmonEntryTest::WithFullFileNameJob.new(
-          @entry.properties
-        )
-        @file         = Tempfile.new('archive')
-        @file_name    = @file.path
-        @pathname     = Pathname.new(@file_name)
-        File.open(@file_name, 'w') { |file| file.write('Hello World') }
-        assert File.exist?(@file_name)
-        @archive_real_name = @archive_path.join("#{@job.id}_#{File.basename(@file_name)}").to_s
-      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
 
-      after do
-        @file.delete if @file
-        RocketJob::Jobs::DirmonJob.delete_all
+        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 '#archive_pathname' do
-        it 'with archive directory' do
-          assert_equal File.dirname(@archive_real_name), @entry.archive_pathname(@pathname).to_s
+      describe 'properties' do
+        it 'are valid' do
+          dirmon_entry.properties = {user_id: 123}
+          assert dirmon_entry.valid?, dirmon_entry.errors.messages.ai
         end
 
-        it 'without archive directory' do
-          @entry.archive_directory = nil
-          assert @entry.archive_pathname(@pathname).to_s.end_with?('_archive')
+        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 '#archive_file' do
-        it 'archive file' do
-          assert_equal @archive_real_name, @entry.send(:archive_file, @job, Pathname.new(@file_name))
-          assert File.exist?(@archive_real_name)
-        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
 
-      describe '#upload_default' do
-        it 'sets upload_file_name property' do
-          @entry = RocketJob::DirmonEntry.new(
-            pattern:           'test/files/**/*',
-            job_class_name:    'DirmonEntryTest::WithFullFileNameJob',
-            archive_directory: @archive_directory
-          )
-          assert @entry.valid?, @entry.errors.messages
-          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.upload_file_name
-        end
+      let :file_name do
+        file.path
       end
 
-      describe '#upload_file' do
-        it 'upload using #upload' do
-          @job.define_singleton_method(:upload) do |file_name|
-            self.description = "FILE:#{file_name}"
-          end
-          @entry.send(:upload_file, @job, @pathname)
-          assert_equal "FILE:#{@file_name}", @job.description
-        end
+      let :pathname do
+        Pathname.new(file_name)
       end
 
-      describe '#later' do
-        it 'enqueues job' do
-          @entry = RocketJob::DirmonEntry.new(
-            pattern:           'test/files/**/*',
-            job_class_name:    'DirmonEntryTest::WithFullFileNameJob',
-            archive_directory: @archive_directory
-          )
-          job    = @entry.later(@pathname)
-          assert_equal Pathname.new(@archive_directory).join("#{job.id}_#{File.basename(@file_name)}").realdirpath.to_s, job.upload_file_name
-          assert job.queued?
-          assert_equal 50, job.priority
-        end
-
-        it 'fails with bad job class name' do
-          @entry.job_class_name = 'Blah'
-          assert_raises ArgumentError do
-            @entry.later(@pathname)
-          end
-        end
+      after do
+        file.delete
+        RocketJob::Jobs::DirmonJob.delete_all
       end
 
       describe '#each' do
         it 'without archive path' do
-          @entry.archive_directory = nil
-          files                    = []
-          @entry.each do |file_name|
+          dirmon_entry.archive_directory = nil
+          files                          = []
+          dirmon_entry.each do |file_name|
             files << file_name
           end
-          assert_nil @entry.archive_directory
+          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 = []
-          @entry.each do |file_name|
+          dirmon_entry.each do |file_name|
             files << file_name
           end
           assert_equal 1, files.count
@@ -246,9 +215,9 @@ class DirmonEntryTest < Minitest::Test
         end
 
         it 'with case-insensitive pattern' do
-          @entry.pattern = 'test/files/**/*.TxT'
-          files          = []
-          @entry.each do |file_name|
+          dirmon_entry.pattern = 'test/files/**/*.TxT'
+          files                = []
+          dirmon_entry.each do |file_name|
             files << file_name
           end
           assert_equal 1, files.count
@@ -256,31 +225,89 @@ class DirmonEntryTest < Minitest::Test
         end
 
         it 'reads paths inside of the whitelist' do
-          @entry.archive_directory = nil
-          files                    = []
-          @entry.stub(:whitelist_paths, [Pathname.new('test/files').realpath.to_s]) do
-            @entry.each do |file_name|
+          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 @entry.archive_directory
+          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
-          @entry.archive_directory = nil
-          files                    = []
-          @entry.stub(:whitelist_paths, [Pathname.new('test/config').realpath.to_s]) do
-            @entry.each do |file_name|
+          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 @entry.archive_directory
+          assert_nil dirmon_entry.archive_directory
           assert_equal 0, files.count
         end
       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

@@ -2,44 +2,51 @@ require_relative 'test_helper'
 
 # Unit Test for RocketJob::Job
 class DirmonJobTest < Minitest::Test
-  class DirmonTestJob < RocketJob::Job
+  class TestJob < RocketJob::Job
     def perform
       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:    'DirmonJobTest::DirmonTestJob',
+    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
+        archive_directory: archive_directory
       )
-      FileUtils.makedirs("#{@directory}/abc")
-      FileUtils.makedirs(@archive_directory)
+    end
+
+    before do
+      RocketJob::Jobs::DirmonJob.delete_all
+      FileUtils.makedirs("#{directory}/abc")
     end
 
     after do
-      @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)
+      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          = Tempfile.new('check_file')
-        file_name     = file.path
-        File.open(file_name, 'w') { |file| file.write('*' * new_size) }
-        assert_equal new_size, File.size(file_name)
-        result = @entry.stub(:later, nil) do
-          @dirmon_job.send(:check_file, @entry, file, previous_size)
+        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
@@ -47,13 +54,10 @@ class DirmonJobTest < Minitest::Test
       it 'check completed file' do
         previous_size = 10
         new_size      = 10
-        file          = Tempfile.new('check_file')
-        file_name     = file.path
-        File.open(file_name, 'w') { |file| file.write('*' * new_size) }
-        assert_equal new_size, File.size(file_name)
-        started = false
-        result  = @entry.stub(:later, -> fn { started = true }) do
-          @dirmon_job.send(:check_file, @entry, file, previous_size)
+        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
@@ -63,7 +67,7 @@ class DirmonJobTest < Minitest::Test
         previous_size = 5
         file_name     = Pathname.new('blah')
         assert_raises Errno::ENOENT do
-          @dirmon_job.send(:check_file, @entry, file_name, previous_size)
+          dirmon_job.send(:check_file, dirmon_entry, file_name, previous_size)
         end
       end
     end
@@ -71,104 +75,94 @@ class DirmonJobTest < Minitest::Test
     describe '#check_directories' do
       before do
         RocketJob::DirmonEntry.destroy_all
-        @entry.enable!
-      end
-
-      after do
-        @entry.destroy if @entry
+        dirmon_entry.enable!
       end
 
       it 'no files' do
-        result = @dirmon_job.send(:check_directories)
+        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)
+        create_file("#{directory}/abc/file1", 5)
+        create_file("#{directory}/abc/file2", 10)
 
-        result = @dirmon_job.send(:check_directories)
-        assert_equal 2, result.count, result
-        assert_equal 5, result.values.first, result
-        assert_equal 10, result.values.second, result
+        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 2, result.count, result
-        assert_equal 10, result.values.first, result
-        assert_equal 15, result.values.second, result
+        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)
+        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
+        assert_equal 2, dirmon_job.previous_file_names.count, files
 
-        # files = @dirmon_job.send(:check_directories)
+        # 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)
+        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
-        @entry.archive_directory = nil
-        @entry.pattern           = "#{@directory}/abc/**/*"
-        file_pathname            = Pathname.new("#{@directory}/abc/file1")
+        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)
-        FileUtils.makedirs(@entry.archive_pathname(file_pathname))
-        create_file("#{@entry.archive_pathname(file_pathname)}/file3", 10)
+        create_file("#{directory}/abc/file2", 10)
 
-        result = @dirmon_job.send(:check_directories)
+        archive_pathname = dirmon_entry.send(:archive_pathname, file_pathname)
+        create_file("#{archive_pathname}/file3", 21)
 
-        assert_equal 2, result.count, result
-        assert_equal 5, result.values.first, result
-        assert_equal 10, result.values.second, result
+        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,
+          "#{directory}/abc/file1" => 5,
+          "#{directory}/abc/file2" => 10
         }
         new_file_names      = {
-          "#{@directory}/abc/file1" => 10,
-          "#{@directory}/abc/file2" => 10,
+          "#{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!(
+        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
+          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
-        assert_equal 0, RocketJob::Jobs::DirmonJob.where(id: @dirmon_job.id).count, -> { RocketJob::Jobs::DirmonJob.all.to_a.ai }
+        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
+        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
@@ -185,7 +179,7 @@ class DirmonJobTest < Minitest::Test
           check_seconds:       30,
           destroy_on_complete: false
         )
-        RocketJob::Jobs::DirmonJob.stub_any_instance(:check_directories, -> { raise RuntimeError.new('Oh no') }) do
+        RocketJob::Jobs::DirmonJob.stub_any_instance(:check_directories, -> { raise 'Oh no' }) do
           assert_raises RuntimeError do
             dirmon_job.perform_now
           end
@@ -208,7 +202,15 @@ class DirmonJobTest < Minitest::Test
     end
 
     def create_file(file_name, size)
-      File.open(file_name, 'w') { |file| file.write('*' * 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