assembly-image 1.7.7 → 1.7.8

data/spec/image_spec.rb

@@ -2,274 +2,278 @@
 
 require 'spec_helper'
 
-# rubocop:disable Metrics/BlockLength
-describe Assembly::Image do
-  it 'does not run if no input file is passed in' do
-    @ai = Assembly::Image.new('')
-    expect{ @ai.create_jp2 }.to raise_error
-  end
+RSpec.describe Assembly::Image do
+  let(:ai) { described_class.new(input_path) }
+  let(:input_path) { TEST_TIF_INPUT_FILE }
 
-  it 'indicates the default jp2 filename' do
-    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-    expect(@ai.jp2_filename).to eq TEST_TIF_INPUT_FILE.gsub('.tif', '.jp2')
+  after do
+    # after each test, empty out the input and output test directories
+    remove_files(TEST_INPUT_DIR)
+    remove_files(TEST_OUTPUT_DIR)
   end
 
-  it 'indicates the default jp2 filename' do
-    @ai = Assembly::Image.new('/path/to/a/file_with_no_extension')
-    expect(@ai.jp2_filename).to eq '/path/to/a/file_with_no_extension.jp2'
-  end
+  describe '#jp2_filename' do
+    it 'indicates the default jp2 filename' do
+      expect(ai.jp2_filename).to eq TEST_TIF_INPUT_FILE.gsub('.tif', '.jp2')
+    end
 
-  it 'indicates the default DPG jp2 filename' do
-    @ai = Assembly::Image.new(TEST_DPG_TIF_INPUT_FILE)
-    expect(@ai.dpg_jp2_filename).to eq TEST_DPG_TIF_INPUT_FILE.gsub('.tif', '.jp2').gsub('_00_', '_05_')
-  end
+    context 'with a file with no extension' do
+      let(:input_path) { '/path/to/a/file_with_no_extension' }
 
-  it 'indicates the default jp2 filename' do
-    @ai = Assembly::Image.new('/path/to/a/file_with_no_00_extension')
-    expect(@ai.dpg_jp2_filename).to eq '/path/to/a/file_with_no_05_extension.jp2'
+      it 'indicates the default jp2 filename' do
+        expect(ai.jp2_filename).to eq '/path/to/a/file_with_no_extension.jp2'
+      end
+    end
   end
 
-  # it 'creates the jp2 without a temp file when given an uncompressed RGB tif' do
-  #   generate_test_image(TEST_TIF_INPUT_FILE)
-  #   expect(File).to exist TEST_TIF_INPUT_FILE
-  #   expect(File).to_not exist TEST_JP2_OUTPUT_FILE
-  #   @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-  #   result = @ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
-  #   # Indicates a temp tiff was not created.
-  #   expect(@ai.tmp_path).to be_nil
-  #   expect(result).to be_a_kind_of Assembly::Image
-  #   expect(result.path).to eq TEST_JP2_OUTPUT_FILE
-  #   expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
-  #   expect(result.exif.colorspace).to eq 'sRGB'
-  #   @jp2 = Assembly::Image.new(TEST_JP2_OUTPUT_FILE)
-  #   expect(@jp2.height).to eq 100
-  #   expect(@jp2.width).to eq 100
-  # end
-
-  it 'creates the jp2 with a temp file when given an LZW compressed RGB tif' do
-    generate_test_image(TEST_TIF_INPUT_FILE, compress: 'lzw')
-    expect(File).to exist TEST_TIF_INPUT_FILE
-    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
-    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-    result = @ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
-    # Indicates a temp tiff was not created.
-    expect(@ai.tmp_path).to_not be_nil
-    expect(result).to be_a_kind_of Assembly::Image
-    expect(result.path).to eq TEST_JP2_OUTPUT_FILE
-    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
-    expect(result.exif.colorspace).to eq 'sRGB'
-    @jp2 = Assembly::Image.new(TEST_JP2_OUTPUT_FILE)
-    expect(@jp2.height).to eq 100
-    expect(@jp2.width).to eq 100
-  end
+  describe '#dpg_jp2_filename' do
+    context 'with a dpg tiff file' do
+      let(:input_path) { TEST_DPG_TIF_INPUT_FILE }
 
-  it 'creates the jp2 with a temp file when given an uncompressed compressed RGB tif with more than 4GB of image data' do
-    skip 'This test will create a 4GB test image and a 4GB temporary image, so skipping by default.'
-    generate_test_image(TEST_TIF_INPUT_FILE, compress: 'none', width: '37838', height: '37838')
-    expect(File).to exist TEST_TIF_INPUT_FILE
-    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
-    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-    result = @ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
-    expect(@ai.tmp_path).to_not be_nil
-    expect(result).to be_a_kind_of Assembly::Image
-    expect(result.path).to eq TEST_JP2_OUTPUT_FILE
-    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
-    expect(result.exif.colorspace).to eq 'sRGB'
-    @jp2 = Assembly::Image.new(TEST_JP2_OUTPUT_FILE)
-    expect(@jp2.height).to eq 37_838
-    expect(@jp2.width).to eq 37_838
-  end
+      it 'indicates the default DPG jp2 filename' do
+        expect(ai.dpg_jp2_filename).to eq TEST_DPG_TIF_INPUT_FILE.gsub('.tif', '.jp2').gsub('_00_', '_05_')
+      end
+    end
 
-  it 'creates the jp2 with a temp file when given an LZW compressed RGB tif with more than 4GB of image data' do
-    skip 'This test will create a 4GB temporary image, so skipping by default.'
-    generate_test_image(TEST_TIF_INPUT_FILE, compress: 'lzw', width: '37838', height: '37838')
-    expect(File).to exist TEST_TIF_INPUT_FILE
-    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
-    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-    result = @ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
-    expect(@ai.tmp_path).to_not be_nil
-    expect(result).to be_a_kind_of Assembly::Image
-    expect(result.path).to eq TEST_JP2_OUTPUT_FILE
-    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
-    expect(result.exif.colorspace).to eq 'sRGB'
-    @jp2 = Assembly::Image.new(TEST_JP2_OUTPUT_FILE)
-    expect(@jp2.height).to eq 37_838
-    expect(@jp2.width).to eq 37_838
-  end
+    context 'with a file with no extension' do
+      let(:input_path) { '/path/to/a/file_with_no_00_extension' }
 
-  it 'creates grayscale jp2 when given a bitonal tif' do
-    # Need to force group4 compression to get ImageMagick to create bitonal tiff
-    generate_test_image(TEST_TIF_INPUT_FILE, image_type: 'Bilevel', compress: 'group4')
-    expect(File).to exist TEST_TIF_INPUT_FILE
-    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
-    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-    result = @ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
-    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
-    expect(result.exif.colorspace).to eq 'Grayscale'
+      it 'indicates the default jp2 filename' do
+        expect(ai.dpg_jp2_filename).to eq '/path/to/a/file_with_no_05_extension.jp2'
+      end
+    end
   end
 
-  it 'creates color jp2 when given a color tif but bitonal image data (1 channels and 1 bits per pixel)' do
-    generate_test_image(TEST_TIF_INPUT_FILE, color: 'Bilevel', image_type: 'TrueColor', profile: '')
-    expect(File).to exist TEST_TIF_INPUT_FILE
-    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
-    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-    expect(@ai).to_not have_color_profile
-    result = @ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
-    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
-    expect(result.exif.colorspace).to eq 'sRGB'
-  end
+  describe '#create_jp2' do
+    context 'when input path is blank' do
+      let(:input_path) { '' }
 
-  it 'creates grayscale jp2 when given a graycale tif but with bitonal image data (1 channel and 1 bits per pixel)' do
-    generate_test_image(TEST_TIF_INPUT_FILE, color: 'Bilevel', image_type: 'Grayscale', profile: '')
-    expect(File).to exist TEST_TIF_INPUT_FILE
-    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
-    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-    # Indicates a temp tiff was not created.
-    expect(@ai.tmp_path).to be_nil
-    expect(@ai).to_not have_color_profile
-    result = @ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
-    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
-    expect(result.exif.colorspace).to eq 'Grayscale'
-  end
+      it 'does not run if no input file is passed in' do
+        expect { ai.create_jp2 }.to raise_error
+      end
+    end
 
-  it 'creates color jp2 when given a color tif but with greyscale image data (1 channel and 8 bits per pixel)' do
-    generate_test_image(TEST_TIF_INPUT_FILE, color: 'Grayscale', image_type: 'TrueColor', profile: '')
-    expect(File).to exist TEST_TIF_INPUT_FILE
-    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
-    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-    # Indicates a temp tiff was not created.
-    expect(@ai.tmp_path).to be_nil
-    expect(@ai).to_not have_color_profile
-    result = @ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
-    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
-    expect(result.exif.colorspace).to eq 'sRGB'
-  end
+    context 'when given an uncompressed compressed RGB tif with more than 4GB of image data', skip: 'This test will create a 4GB test image and a 4GB temporary image, so skipping by default.' do
+      before do
+        generate_test_image(TEST_TIF_INPUT_FILE, compress: 'none', width: '37838', height: '37838')
+      end
 
-  it 'creates a jp2 when the source image has no profile' do
-    generate_test_image(TEST_TIF_INPUT_FILE, profile: '') # generate a test input with no profile
-    expect(File).to exist TEST_TIF_INPUT_FILE
-    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
-    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-    # Indicates a temp tiff was not created.
-    expect(@ai.tmp_path).to be_nil
-    expect(@ai).to_not have_color_profile
-    expect(@ai).to be_a_valid_image
-    expect(@ai).to be_jp2able
-    @ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
-    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
-  end
+      it 'creates the jp2 with a temp file' do
+        expect(File).to exist TEST_TIF_INPUT_FILE
+        expect(File).not_to exist TEST_JP2_OUTPUT_FILE
+        result = ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
+        expect(ai.tmp_path).not_to be_nil
+        expect(result).to be_a_kind_of described_class
+        expect(result.path).to eq TEST_JP2_OUTPUT_FILE
+        expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+        expect(result.exif.colorspace).to eq 'sRGB'
+        jp2 = described_class.new(TEST_JP2_OUTPUT_FILE)
+        expect(jp2.height).to eq 37_838
+        expect(jp2.width).to eq 37_838
+      end
+    end
 
-  it "does not run if the output file exists and you don't allow overwriting" do
-    generate_test_image(TEST_TIF_INPUT_FILE)
-    generate_test_image(TEST_JP2_OUTPUT_FILE)
-    expect(File).to exist TEST_TIF_INPUT_FILE
-    expect(File).to exist TEST_JP2_OUTPUT_FILE
-    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-    expect{ @ai.create_jp2(output: TEST_JP2_OUTPUT_FILE) }.to raise_error(SecurityError)
-  end
+    context 'when given an LZW compressed RGB tif with more than 4GB of image data', skip: 'This test will create a 4GB temporary image, so skipping by default.' do
+      before do
+        generate_test_image(TEST_TIF_INPUT_FILE, compress: 'lzw', width: '37838', height: '37838')
+      end
 
-  it 'gets the correct image height and width' do
-    generate_test_image(TEST_TIF_INPUT_FILE)
-    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-    expect(@ai.height).to eq 100
-    expect(@ai.width).to eq 100
-  end
+      it 'creates the jp2 with a temp file' do
+        expect(File).to exist TEST_TIF_INPUT_FILE
+        expect(File).not_to exist TEST_JP2_OUTPUT_FILE
+        result = ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
+        expect(ai.tmp_path).not_to be_nil
+        expect(result).to be_a_kind_of described_class
+        expect(result.path).to eq TEST_JP2_OUTPUT_FILE
+        expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+        expect(result.exif.colorspace).to eq 'sRGB'
+        jp2 = described_class.new(TEST_JP2_OUTPUT_FILE)
+        expect(jp2.height).to eq 37_838
+        expect(jp2.width).to eq 37_838
+      end
+    end
 
-  it 'does not run if the input file is a jp2' do
-    generate_test_image(TEST_TIF_INPUT_FILE, profile: '') # generate a test input with no profile
-    expect(File).to exist TEST_TIF_INPUT_FILE
-    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
-    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-    # Indicates a temp tiff was not created.
-    expect(@ai.tmp_path).to be_nil
-    expect(@ai).to_not have_color_profile
-    expect(@ai).to be_a_valid_image
-    expect(@ai).to be_jp2able
-    @ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
-    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
-    @ai = Assembly::Image.new(TEST_JP2_OUTPUT_FILE)
-    expect(@ai).to be_valid_image
-    expect(@ai).to_not be_jp2able
-    expect { @ai.create_jp2 }.to raise_error
-  end
+    context 'when given a bitonal tif' do
+      before do
+        # Need to force group4 compression to get ImageMagick to create bitonal tiff
+        generate_test_image(TEST_TIF_INPUT_FILE, image_type: 'Bilevel', compress: 'group4')
+      end
 
-  it 'runs if you specify a bogus output profile, because this is not currently an option' do
-    generate_test_image(TEST_TIF_INPUT_FILE)
-    expect(File).to exist TEST_TIF_INPUT_FILE
-    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-    result = @ai.create_jp2(output_profile: 'bogusness')
-    expect(result).to be_a_kind_of Assembly::Image
-    expect(result.path).to eq TEST_JP2_INPUT_FILE
-    expect(TEST_JP2_INPUT_FILE).to be_a_jp2
-    expect(result.exif.colorspace).to eq 'sRGB'
-  end
+      it 'creates grayscale jp2' do
+        expect(File).to exist TEST_TIF_INPUT_FILE
+        expect(File).not_to exist TEST_JP2_OUTPUT_FILE
+        result = ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
+        expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+        expect(result.exif.colorspace).to eq 'Grayscale'
+      end
+    end
 
-  it 'creates jp2 when given a JPEG' do
-    generate_test_image(TEST_JPEG_INPUT_FILE)
-    expect(File).to exist TEST_JPEG_INPUT_FILE
-    expect(File).to_not exist TEST_JP2_OUTPUT_FILE
-    @ai = Assembly::Image.new(TEST_JPEG_INPUT_FILE)
-    result = @ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
-    # Indicates a temp tiff was created.
-    expect(@ai.tmp_path).not_to be_nil
-    expect(File).not_to exist @ai.tmp_path
-    expect(result).to be_a_kind_of Assembly::Image
-    expect(result.path).to eq TEST_JP2_OUTPUT_FILE
-    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
-  end
+    context 'when given a color tif but bitonal image data (1 channels and 1 bits per pixel)' do
+      before do
+        generate_test_image(TEST_TIF_INPUT_FILE, color: 'Bilevel', image_type: 'TrueColor', profile: '')
+      end
 
-  it 'does not run if you specify a bogus tmp folder' do
-    generate_test_image(TEST_JPEG_INPUT_FILE)
-    bogus_folder = '/crapsticks'
-    expect(File).to exist TEST_JPEG_INPUT_FILE
-    expect(File).to_not exist bogus_folder
-    @ai = Assembly::Image.new(TEST_JPEG_INPUT_FILE)
-    expect { @ai.create_jp2(tmp_folder: bogus_folder) }.to raise_error
-  end
+      it 'creates color jp2' do
+        expect(File).to exist TEST_TIF_INPUT_FILE
+        expect(File).not_to exist TEST_JP2_OUTPUT_FILE
+        expect(ai).not_to have_color_profile
+        result = ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
+        expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+        expect(result.exif.colorspace).to eq 'sRGB'
+      end
+    end
 
-  it 'creates a jp2 and preserve the temporary file if specified' do
-    generate_test_image(TEST_JPEG_INPUT_FILE)
-    expect(File).to exist TEST_JPEG_INPUT_FILE
-    @ai = Assembly::Image.new(TEST_JPEG_INPUT_FILE)
-    result = @ai.create_jp2(output: TEST_JP2_OUTPUT_FILE, preserve_tmp_source: true)
-    # Indicates a temp tiff was created.
-    expect(@ai.tmp_path).not_to be_nil
-    expect(File).to exist @ai.tmp_path
-    expect(result).to be_a_kind_of Assembly::Image
-    expect(result.path).to eq TEST_JP2_OUTPUT_FILE
-    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
-    expect(File.exist?(@ai.tmp_path)).to be true
-  end
+    context 'when given a graycale tif but with bitonal image data (1 channel and 1 bits per pixel)' do
+      before do
+        generate_test_image(TEST_TIF_INPUT_FILE, color: 'Bilevel', image_type: 'Grayscale', profile: '')
+      end
 
-  it 'creates a jp2 of the same filename and in the same location as the input if no output file is specified, and should cleanup tmp file' do
-    generate_test_image(TEST_TIF_INPUT_FILE)
-    expect(File).to exist TEST_TIF_INPUT_FILE
-    expect(File.exist?(TEST_JP2_INPUT_FILE)).to be false
-    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-    result = @ai.create_jp2
-    expect(result).to be_a_kind_of Assembly::Image
-    expect(result.path).to eq TEST_JP2_INPUT_FILE
-    expect(TEST_JP2_INPUT_FILE).to be_a_jp2
-    expect(result.exif.colorspace).to eq 'sRGB'
-  end
+      it 'creates grayscale jp2' do
+        expect(File).to exist TEST_TIF_INPUT_FILE
+        expect(File).not_to exist TEST_JP2_OUTPUT_FILE
+        expect(ai).not_to have_color_profile
+        result = ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
+        expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+        expect(result.exif.colorspace).to eq 'Grayscale'
+      end
+    end
 
-  it 'recreates jp2 if the output file exists and if you allow overwriting' do
-    generate_test_image(TEST_TIF_INPUT_FILE)
-    generate_test_image(TEST_JP2_OUTPUT_FILE)
-    expect(File).to exist TEST_TIF_INPUT_FILE
-    expect(File).to exist TEST_JP2_OUTPUT_FILE
-    @ai = Assembly::Image.new(TEST_TIF_INPUT_FILE)
-    result = @ai.create_jp2(output: TEST_JP2_OUTPUT_FILE, overwrite: true)
-    expect(result).to be_a_kind_of Assembly::Image
-    expect(result.path).to eq TEST_JP2_OUTPUT_FILE
-    expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
-    expect(result.exif.colorspace).to eq 'sRGB'
-  end
+    context 'when given a color tif but with greyscale image data (1 channel and 8 bits per pixel)' do
+      before do
+        generate_test_image(TEST_TIF_INPUT_FILE, color: 'Grayscale', image_type: 'TrueColor', profile: '')
+      end
 
-  after(:each) do
-    # after each test, empty out the input and output test directories
-    remove_files(TEST_INPUT_DIR)
-    remove_files(TEST_OUTPUT_DIR)
+      it 'creates color jp2' do
+        expect(File).to exist TEST_TIF_INPUT_FILE
+        expect(File).not_to exist TEST_JP2_OUTPUT_FILE
+        expect(ai).not_to have_color_profile
+        result = ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
+        expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+        expect(result.exif.colorspace).to eq 'sRGB'
+      end
+    end
+
+    context 'when the source image has no profile' do
+      before do
+        generate_test_image(TEST_TIF_INPUT_FILE, profile: '') # generate a test input with no profile
+      end
+
+      it 'creates a jp2' do
+        expect(File).to exist TEST_TIF_INPUT_FILE
+        expect(File).not_to exist TEST_JP2_OUTPUT_FILE
+        expect(ai).not_to have_color_profile
+        expect(ai).to be_a_valid_image
+        expect(ai).to be_jp2able
+        ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
+        expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+      end
+    end
+
+    context "when the output file exists and you don't allow overwriting" do
+      before do
+        generate_test_image(TEST_TIF_INPUT_FILE)
+        generate_test_image(TEST_JP2_OUTPUT_FILE)
+      end
+
+      it 'does not run' do
+        expect(File).to exist TEST_TIF_INPUT_FILE
+        expect(File).to exist TEST_JP2_OUTPUT_FILE
+        expect { ai.create_jp2(output: TEST_JP2_OUTPUT_FILE) }.to raise_error(SecurityError)
+      end
+    end
+
+    context 'when given a test tiff' do
+      before do
+        generate_test_image(TEST_TIF_INPUT_FILE)
+      end
+
+      it 'gets the correct image height and width' do
+        expect(ai.height).to eq 100
+        expect(ai.width).to eq 100
+      end
+    end
+
+    context 'when the input file is a jp2' do
+      before do
+        generate_test_image(TEST_TIF_INPUT_FILE, profile: '') # generate a test input with no profile
+      end
+
+      it 'does not run' do
+        expect(File).to exist TEST_TIF_INPUT_FILE
+        expect(File).not_to exist TEST_JP2_OUTPUT_FILE
+        expect(ai).not_to have_color_profile
+        expect(ai).to be_a_valid_image
+        expect(ai).to be_jp2able
+        ai.create_jp2(output: TEST_JP2_OUTPUT_FILE)
+        expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+        jp2_file = described_class.new(TEST_JP2_OUTPUT_FILE)
+        expect(jp2_file).to be_valid_image
+        expect(jp2_file).not_to be_jp2able
+        expect { jp2_file.create_jp2 }.to raise_error
+      end
+    end
+
+    context 'when you specify a bogus output profile' do
+      before do
+        generate_test_image(TEST_TIF_INPUT_FILE)
+      end
+
+      it 'runs, because this is not currently an option' do
+        expect(File).to exist TEST_TIF_INPUT_FILE
+        result = ai.create_jp2(output_profile: 'bogusness')
+        expect(result).to be_a_kind_of described_class
+        expect(result.path).to eq TEST_JP2_INPUT_FILE
+        expect(TEST_JP2_INPUT_FILE).to be_a_jp2
+        expect(result.exif.colorspace).to eq 'sRGB'
+      end
+    end
+
+    context 'when an invalid tmp folder' do
+      before do
+        generate_test_image(TEST_JPEG_INPUT_FILE)
+      end
+
+      let(:input_path) { TEST_JPEG_INPUT_FILE }
+
+      it 'does not run' do
+        bogus_folder = '/crapsticks'
+        expect(File).to exist TEST_JPEG_INPUT_FILE
+        expect(File).not_to exist bogus_folder
+        expect { ai.create_jp2(tmp_folder: bogus_folder) }.to raise_error
+      end
+    end
+
+    context 'when no output file is specified' do
+      before do
+        generate_test_image(TEST_TIF_INPUT_FILE)
+      end
+
+      it 'creates a jp2 of the same filename and in the same location as the input and cleans up the tmp file' do
+        expect(File).to exist TEST_TIF_INPUT_FILE
+        expect(File.exist?(TEST_JP2_INPUT_FILE)).to be false
+        result = ai.create_jp2
+        expect(result).to be_a_kind_of described_class
+        expect(result.path).to eq TEST_JP2_INPUT_FILE
+        expect(TEST_JP2_INPUT_FILE).to be_a_jp2
+        expect(result.exif.colorspace).to eq 'sRGB'
+      end
+    end
+
+    context 'when the output file exists and you allow overwriting' do
+      before do
+        generate_test_image(TEST_TIF_INPUT_FILE)
+        generate_test_image(TEST_JP2_OUTPUT_FILE)
+      end
+
+      it 'recreates jp2' do
+        expect(File).to exist TEST_TIF_INPUT_FILE
+        expect(File).to exist TEST_JP2_OUTPUT_FILE
+        result = ai.create_jp2(output: TEST_JP2_OUTPUT_FILE, overwrite: true)
+        expect(result).to be_a_kind_of described_class
+        expect(result.path).to eq TEST_JP2_OUTPUT_FILE
+        expect(TEST_JP2_OUTPUT_FILE).to be_a_jp2
+        expect(result.exif.colorspace).to eq 'sRGB'
+      end
+    end
   end
 end
-# rubocop:enable Metrics/BlockLength

data/spec/images_spec.rb

@@ -2,48 +2,46 @@
 
 require 'spec_helper'
 
-# rubocop:disable Metrics/BlockLength
-describe Assembly::Images do
-  it 'should not run if no input folder is passed in' do
-    expect{ Assembly::Images.batch_generate_jp2('') }.to raise_error
+RSpec.describe Assembly::Images do
+  after do
+    # after each test, empty out the input and output test directories
+    remove_files(TEST_INPUT_DIR)
+    remove_files(TEST_OUTPUT_DIR)
+  end
+
+  it 'does not run if no input folder is passed in' do
+    expect{ described_class.batch_generate_jp2('') }.to raise_error
   end
 
-  it 'should not run if a non-existent input folder is passed in' do
-    expect{ Assembly::Images.batch_generate_jp2('/junk/path') }.to raise_error
+  it 'does not run if a non-existent input folder is passed in' do
+    expect{ described_class.batch_generate_jp2('/junk/path') }.to raise_error
   end
 
-  it 'should run and batch produe jp2s from input tiffs' do
+  it 'runs and batch produces jp2s from input tiffs' do
     ['test1', 'test2', 'test3'].each { |image| generate_test_image(File.join(TEST_INPUT_DIR, "#{image}.tif")) }
-    Assembly::Images.batch_generate_jp2(TEST_INPUT_DIR, output: TEST_OUTPUT_DIR)
+    described_class.batch_generate_jp2(TEST_INPUT_DIR, output: TEST_OUTPUT_DIR)
     expect(File.directory?(TEST_OUTPUT_DIR)).to be true
     ['test1', 'test2', 'test3'].each { |image| expect(File.join(TEST_OUTPUT_DIR, "#{image}.jp2")).to be_a_jp2 }
   end
 
-  it 'should run and batch add color profile descriptions input tiffs with no color profile descriptions' do
+  it 'runs and batch add color profile descriptions input tiffs with no color profile descriptions' do
     ['test1', 'test2', 'test3'].each { |image| generate_test_image(File.join(TEST_INPUT_DIR, "#{image}.tif"), profile: '') }
-    ['test1', 'test2', 'test3'].each { |image| expect(Assembly::Image.new(File.join(TEST_INPUT_DIR, "#{image}.tif")).exif.profiledescription).to be nil }
-    Assembly::Images.batch_add_exif_profile_descr(TEST_INPUT_DIR, 'Adobe RGB 1998')
+    ['test1', 'test2', 'test3'].each { |image| expect(Assembly::Image.new(File.join(TEST_INPUT_DIR, "#{image}.tif")).exif.profiledescription).to be_nil }
+    described_class.batch_add_exif_profile_descr(TEST_INPUT_DIR, 'Adobe RGB 1998')
     ['test1', 'test2', 'test3'].each { |image| expect(Assembly::Image.new(File.join(TEST_INPUT_DIR, "#{image}.tif")).exif.profiledescription).to eq 'Adobe RGB (1998)' }
   end
 
-  it 'should run and batch add color profile descriptions input tiffs, forcing over existing color profile descriptions' do
+  it 'runs and batch add color profile descriptions input tiffs, forcing over existing color profile descriptions' do
     ['test1', 'test2', 'test3'].each { |image| generate_test_image(File.join(TEST_INPUT_DIR, "#{image}.tif")) }
     ['test1', 'test2', 'test3'].each { |image| expect(Assembly::Image.new(File.join(TEST_INPUT_DIR, "#{image}.tif")).exif.profiledescription).to eq 'sRGB IEC61966-2.1' }
-    Assembly::Images.batch_add_exif_profile_descr(TEST_INPUT_DIR, 'Adobe RGB 1998', force: true) # force overwrite
+    described_class.batch_add_exif_profile_descr(TEST_INPUT_DIR, 'Adobe RGB 1998', force: true) # force overwrite
     ['test1', 'test2', 'test3'].each { |image| expect(Assembly::Image.new(File.join(TEST_INPUT_DIR, "#{image}.tif")).exif.profiledescription).to eq 'Adobe RGB (1998)' }
   end
 
-  it 'should run and batch add color profile descriptions input tiffs, not overwriting existing color profile descriptions' do
+  it 'runs and batch add color profile descriptions input tiffs, not overwriting existing color profile descriptions' do
     ['test1', 'test2', 'test3'].each { |image| generate_test_image(File.join(TEST_INPUT_DIR, "#{image}.tif")) }
     ['test1', 'test2', 'test3'].each { |image| expect(Assembly::Image.new(File.join(TEST_INPUT_DIR, "#{image}.tif")).exif.profiledescription).to eq 'sRGB IEC61966-2.1' }
-    Assembly::Images.batch_add_exif_profile_descr(TEST_INPUT_DIR, 'Adobe RGB 1998') # do not force overwrite
+    described_class.batch_add_exif_profile_descr(TEST_INPUT_DIR, 'Adobe RGB 1998') # do not force overwrite
     ['test1', 'test2', 'test3'].each { |image| expect(Assembly::Image.new(File.join(TEST_INPUT_DIR, "#{image}.tif")).exif.profiledescription).to eq 'sRGB IEC61966-2.1' }
   end
-
-  after(:each) do
-    # after each test, empty out the input and output test directories
-    remove_files(TEST_INPUT_DIR)
-    remove_files(TEST_OUTPUT_DIR)
-  end
 end
-# rubocop:enable Metrics/BlockLength