hydra-derivatives 3.5.0 → 3.6.0

data/spec/services/remote_source_file_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-class TestObject < ActiveFedora::Base
-  attr_accessor :source_file_name
-end
-
-describe Hydra::Derivatives::RemoteSourceFile do
-  describe '.call' do
-    let(:file_name) { 'my_source_file.mp4' }
-
-    context 'when you pass in a String file name' do
-      let(:input_obj) { file_name }
-      let(:options) { {} }
-
-      it 'yields the file name' do
-        expect do |blk|
-          described_class.call(input_obj, options, &blk)
-        end.to yield_with_args(file_name)
-      end
-    end
-
-    context 'when you pass in an ActiveFedora::Base object ' do
-      let(:input_obj) { TestObject.new(source_file_name: file_name) }
-      let(:options) { { source: :source_file_name } }
-
-      it 'yields the file name' do
-        expect do |blk|
-          described_class.call(input_obj, options, &blk)
-        end.to yield_with_args(file_name)
-      end
-    end
-  end
-end

data/spec/services/retrieve_source_file_service_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Derivatives::RetrieveSourceFileService do
-  before(:all) do
-    # Need a class that:
-    #  1) Allows you to set .uri= (to work with directly_contains)
-    #  2) has a metadata_node (to work with directly_contains_one)
-    class FileWithMetadata < ActiveFedora::File
-      include ActiveFedora::WithMetadata
-    end
-
-    class ObjectWithBasicContainer < ActiveFedora::Base
-      has_subresource "contained_file"
-    end
-
-    class DirectContainerObject < ActiveFedora::Base
-      directly_contains :files, has_member_relation: ::RDF::URI("http://pcdm.org/use#hasFile"),
-                                class_name: "FileWithMetadata"
-      directly_contains_one :directly_contained_file, through: :files, type: ::RDF::URI("http://pcdm.org/use#OriginalFile")
-    end
-  end
-
-  context "when file is in basic container (default assumption)" do # alas, we have to support this as the default because all legacy code (and fedora 3 systems) created indirectly contained files
-    let(:object)            { ObjectWithBasicContainer.new }
-    let(:content)           { "fake file content (basic container)" }
-    let(:source_name)       { 'contained_file' }
-
-    before do
-      allow(object).to receive(:uri).and_return('http://foo/bar')
-      allow(object.contained_file).to receive(:new_record?).and_return(false)
-      allow(object.contained_file).to receive(:has_content?).and_return(true)
-      allow(object.contained_file).to receive(:mime_type).and_return('text/html')
-      # attaches the file as an indirectly contained object
-      object.contained_file.content = content
-    end
-
-    it "persists the file to the specified destination on the given object" do
-      described_class.call(object, source: source_name) do |f|
-        expect(f.read).to eq(object.contained_file.content)
-      end
-    end
-  end
-
-  context "when file is directly contained" do # direct containers are more efficient, but most legacy code will have indirect containers
-    let(:object)            { DirectContainerObject.new }
-    let(:content)           { "fake file content (direct container)" }
-    let(:source_name)       { 'directly_contained_file' }
-
-    before do
-      object.save # can't build directly contained objects without saving the parent first
-      object.build_directly_contained_file
-      object.directly_contained_file.content = content
-    end
-    it "retrieves the file from the specified location on the given object" do
-      described_class.call(object, source: source_name) do |f|
-        expect(f.read).to eq(object.directly_contained_file.content)
-      end
-    end
-  end
-end

data/spec/services/tempfile_service_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Derivatives::TempfileService do
-  subject { described_class.new(file) }
-
-  let(:class_with_metadata_extraction) do
-    Class.new do
-      attr_reader :content, :mime_type, :uri
-
-      def initialize(options = {})
-        @content = options.fetch(:content, '')
-        @mime_uype = options.fetch(:mime_type, nil)
-        @uri = 'http://example.com/pid/123'
-      end
-
-      def has_content?
-        content.present?
-      end
-    end
-  end
-
-  let(:class_with_tempfile) do
-    Class.new do
-      def to_tempfile
-        "stub"
-      end
-    end
-  end
-
-  let(:initialization_options) { { content: 'abc', mime_type: 'text/plain' } }
-
-  let(:file) { class_with_metadata_extraction.new(initialization_options) }
-
-  describe '#tempfile' do
-    it 'has a method called to_tempfile' do
-      expect { |b| subject.tempfile(&b) }.to yield_with_args(Tempfile)
-    end
-    it "will call read on passed content if available" do
-      file_with_readable_content = class_with_metadata_extraction.new(content: StringIO.new("test"), mime_type: 'text/plain')
-
-      service = described_class.new(file_with_readable_content)
-
-      service.tempfile do |t|
-        expect(t.read).to eq "test"
-      end
-    end
-    it "delegates down to `to_tempfile` if available" do
-      tempfile_stub = class_with_tempfile.new
-      service = described_class.new(tempfile_stub)
-
-      expect(service.tempfile).to eq "stub"
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,40 +0,0 @@
-ENV['environment'] ||= 'test'
-ENV['RAILS_ENV'] = 'test'
-
-require 'simplecov'
-require 'coveralls'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
-  [
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-  ]
-)
-SimpleCov.minimum_coverage 100
-SimpleCov.start do
-  add_filter '/spec'
-end
-
-# - RSpec adds ./lib to the $LOAD_PATH
-require 'hydra/derivatives'
-# Resque.inline = Rails.env.test?
-require 'byebug' unless ENV['TRAVIS']
-
-require 'active_fedora/cleaner'
-ActiveFedora::Base.logger = Logger.new(STDOUT)
-RSpec.configure do |config|
-  config.before(:each) do
-    ActiveFedora::Cleaner.clean!
-  end
-end
-
-# Workaround for RAW image support until these are pushed upstream to
-# the MIME Types gem
-require 'mime-types'
-dng_format = MIME::Type.new('image/x-adobe-dng')
-dng_format.extensions = 'dng'
-MIME::Types.add(dng_format)
-
-def fixture_path
-  File.expand_path("../fixtures", __FILE__)
-end

data/spec/units/audio_encoder_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Derivatives::AudioEncoder do
-  before do
-    @audio_encoder = described_class.new
-  end
-
-  describe 'fdk_aac?' do
-    it 'outpus libfdk_aac if your ffmpeg was compiled with the library' do
-      enable_libfdk_flags = '--enable-gpl --enable-version3 --enable-nonfree --enable-hardcoded-tables --enable-avresample --with-fdk-aac'
-      @audio_encoder.instance_variable_set(:@ffmpeg_output, enable_libfdk_flags)
-      audio_encoder = @audio_encoder.audio_encoder
-      expect(audio_encoder).to eq('libfdk_aac')
-    end
-
-    it 'outputs aac if your ffmpeg was compiled with the library' do
-      enable_libfdk_flags = '--enable-gpl --enable-version3 --enable-nonfree --enable-hardcoded-tables --enable-avresample'
-      @audio_encoder.instance_variable_set(:@ffmpeg_output, enable_libfdk_flags)
-      audio_encoder = @audio_encoder.audio_encoder
-      expect(audio_encoder).to eq('aac')
-    end
-  end
-
-  context "when ffmpeg is not installed" do
-    it "logs a warning" do
-      allow(ActiveFedora::Base.logger).to receive(:warn)
-      allow(Open3).to receive(:capture3).with('ffmpeg -codecs').and_raise StandardError
-
-      described_class.new
-
-      expect(ActiveFedora::Base.logger).to have_received(:warn).with('Unable to find ffmpeg')
-    end
-  end
-end

data/spec/units/config_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-describe "the configuration" do
-  subject { Hydra::Derivatives::Config.new }
-
-  before do
-    # It's not always /tmp; it depends on OS and ENV vars
-    allow(Dir).to receive(:tmpdir).and_return('/tmp')
-  end
-
-  it "has some configuration defaults" do
-    expect(subject.ffmpeg_path).to eq('ffmpeg')
-    expect(subject.enable_ffmpeg).to be true
-    expect(subject.libreoffice_path).to eq('soffice')
-    expect(subject.temp_file_base).to eq('/tmp')
-    expect(subject.fits_path).to eq('fits.sh')
-    expect(subject.kdu_compress_path).to eq('kdu_compress')
-    expect(subject.output_file_service).to eq(Hydra::Derivatives::PersistBasicContainedOutputFileService)
-    expect(subject.source_file_service).to eq(Hydra::Derivatives::RetrieveSourceFileService)
-  end
-
-  it "lets you change the configuration" do
-    subject.ffmpeg_path = '/usr/local/ffmpeg-1.0/bin/ffmpeg'
-    expect(subject.ffmpeg_path).to eq('/usr/local/ffmpeg-1.0/bin/ffmpeg')
-
-    subject.kdu_compress_path = '/opt/local/bin/kdu_compress'
-    expect(subject.kdu_compress_path).to eq('/opt/local/bin/kdu_compress')
-
-    subject.enable_ffmpeg = false
-    expect(subject.enable_ffmpeg).to be false
-  end
-
-  it "lets you set a custom output file service" do
-    output_file_service = instance_double("MyOutputFileService")
-    subject.output_file_service = output_file_service
-    expect(subject.output_file_service).to eq(output_file_service)
-  end
-
-  it "lets you set a custom source file service" do
-    source_file_service = instance_double("MyRetriveSourceFileService")
-    subject.source_file_service = source_file_service
-    expect(subject.source_file_service).to eq(source_file_service)
-  end
-
-  it "lets you set the poll time for ActiveEncode jobs" do
-    expect(subject.active_encode_poll_time).to eq 10
-    subject.active_encode_poll_time = 15
-    expect(subject.active_encode_poll_time).to eq 15
-  end
-end

data/spec/units/derivatives_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Derivatives do
-  before(:all) do
-    class CustomFile < ActiveFedora::Base
-      include Hydra::Derivatives
-    end
-  end
-
-  after(:all) { Object.send(:remove_const, :CustomFile) }
-
-  describe "source_file_service" do
-    before  { subject.source_file_service = custom_source_file_service }
-
-    context "with a global configuration setting" do
-      subject { CustomFile }
-
-      let(:custom_source_file_service) { "fake service" }
-
-      it "utilizes the default source file service" do
-        expect(subject.source_file_service).to eq(custom_source_file_service)
-      end
-    end
-
-    context "with an instance level configuration setting" do
-      subject { CustomFile.new }
-
-      let(:custom_source_file_service) { "another fake service" }
-
-      it "accepts a custom source file service as an option" do
-        expect(subject.source_file_service).to eq(custom_source_file_service)
-      end
-    end
-  end
-
-  Hydra::Derivatives::CONFIG_METHODS.each do |method|
-    describe method.to_s do
-      it 'returns the config value' do
-        expect(subject.send(method)).to eq subject.config.send(method)
-      end
-    end
-    describe "#{method}=" do
-      around do |example|
-        value = subject.config.send(method)
-        example.call
-        subject.send("#{method}=", value)
-      end
-
-      it 'stores config changes' do
-        expect { subject.send("#{method}=", "new_value") }.to change { subject.config.send(method) }.from(subject.config.send(method)).to("new_value")
-      end
-    end
-  end
-
-  describe 'reset_config!' do
-    it "resets the configuration" do
-      subject.ffmpeg_path = '/usr/local/ffmpeg-1.0/bin/ffmpeg'
-      subject.reset_config!
-      expect(subject.ffmpeg_path).to eq('ffmpeg')
-
-      subject.kdu_compress_path = '/usr/local/bin/kdu_compress'
-      subject.reset_config!
-      expect(subject.kdu_compress_path).to eq('kdu_compress')
-
-      subject.active_encode_poll_time = 2
-      subject.reset_config!
-      expect(subject.active_encode_poll_time).to eq 10
-    end
-  end
-end

data/spec/units/io_decorator_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-require 'stringio'
-
-describe Hydra::Derivatives::IoDecorator do
-  let(:file) { StringIO.new('hello') }
-
-  context "with one argument" do
-    let(:decorator) { described_class.new(file) }
-
-    describe "#read" do
-      subject { decorator.read }
-
-      it { is_expected.to eq 'hello' }
-    end
-  end
-
-  context "with three arguments" do
-    let(:decorator) { described_class.new(file, 'text/plain', 'help.txt') }
-
-    describe "#read" do
-      subject { decorator.read }
-
-      it { is_expected.to eq 'hello' }
-    end
-
-    describe "mime_type" do
-      subject { decorator.mime_type }
-
-      it { is_expected.to eq 'text/plain' }
-    end
-
-    describe "original_filename" do
-      subject { decorator.original_filename }
-
-      it { is_expected.to eq 'help.txt' }
-    end
-
-    describe "original_name" do
-      subject { decorator.original_name }
-
-      before { allow(Deprecation).to receive(:warn) }
-      it { is_expected.to eq 'help.txt' }
-    end
-  end
-end

data/spec/units/logger_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Derivatives::Logger do
-  context "with log levels" do
-    let(:levels) { %w[unknown fatal error warn info debug] }
-
-    it "responds successfully" do
-      levels.each do |level|
-        expect(described_class.respond_to?(level)).to be_truthy
-      end
-    end
-    it "accepts messages" do
-      expect(described_class.warn("message")).to be_truthy
-    end
-  end
-
-  it "delegates respond_to_missing" do
-    allow(ActiveFedora::Base.logger).to receive(:respond_to_missing?).with(:weird, false).and_return(true)
-    expect(described_class.respond_to_missing?(:weird)).to be_truthy
-  end
-
-  context "with garbage" do
-    it "raises an error" do
-      expect { described_class.garbage }.to raise_error(NoMethodError)
-    end
-  end
-end

data/spec/units/transcoding_spec.rb

@@ -1,354 +0,0 @@
-require 'spec_helper'
-
-describe "Transcoding" do
-  before(:all) do
-    class GenericFile < ActiveFedora::Base
-      include Hydra::Derivatives
-      property :mime_type_from_fits, predicate: ::RDF::URI('http://example.com/mime'), multiple: false
-      has_subresource 'original_file'
-
-      def create_derivatives(_filename)
-        case mime_type_from_fits
-        when 'application/pdf'
-          PdfDerivatives.create(self, source: :original_file,
-                                      outputs: [{ label: :thumb, size: "100x100>", url: "#{uri}/original_file_thumb" }])
-          FullTextExtract.create(self, source: :original_file, outputs: [{ url: "#{uri}/fulltext" }])
-        when 'audio/x-wav'
-          AudioDerivatives.create(self, source: :original_file,
-                                        outputs: [
-                                          { label: :mp3, format: 'mp3', url: "#{uri}/original_file_mp3" },
-                                          { label: :ogg, format: 'ogg', url: "#{uri}/original_file_ogg" }
-                                        ])
-        when 'video/x-msvideo'
-          VideoDerivatives.create(self, source: :original_file,
-                                        outputs: [
-                                          { label: :mp4,       format: 'mp4',  url: "#{uri}/original_file_mp4" },
-                                          { label: :webm,      format: 'webm', url: "#{uri}/original_file_webm" },
-                                          { label: :thumbnail, format: 'jpg',  url: "#{uri}/thumbnail" }
-                                        ])
-        when 'image/png', 'image/jpg'
-          ImageDerivatives.create(self, source: :original_file,
-                                        outputs: [
-                                          { label: :medium, size: "300x300>", url: "#{uri}/original_file_medium" },
-                                          { label: :thumb,  size: "100x100>", url: "#{uri}/original_file_thumb" },
-                                          { label: :access, format: 'jpg',    url: "#{uri}/access" }
-                                        ])
-        when 'application/vnd.ms-powerpoint'
-          DocumentDerivatives.create(self, source: :original_file,
-                                           outputs: [
-                                             { label: :preservation, format: 'pptx', url: "#{uri}/original_file_preservation" },
-                                             { label: :access,       format: 'pdf',  url: "#{uri}/original_file_access" },
-                                             { label: :thumnail,     format: 'jpg',  url: "#{uri}/original_file_thumbnail" }
-                                           ])
-        when 'text/rtf'
-          DocumentDerivatives.create(self, source: :original_file,
-                                           outputs: [
-                                             { label: :preservation, format: 'odt', url: "#{uri}/original_file_preservation" },
-                                             { label: :access,       format: 'pdf', url: "#{uri}/original_file_access" },
-                                             { label: :thumnail,     format: 'jpg', url: "#{uri}/original_file_thumbnail" }
-                                           ])
-        when 'application/msword'
-          DocumentDerivatives.create(self, source: :original_file,
-                                           outputs: [
-                                             { label: :preservation, format: 'docx', url: "#{uri}/original_file_preservation" },
-                                             { label: :access,       format: 'pdf',  url: "#{uri}/original_file_access" },
-                                             { label: :thumnail,     format: 'jpg',  url: "#{uri}/original_file_thumbnail" }
-                                           ])
-        when 'application/vnd.ms-excel'
-          DocumentDerivatives.create(self, source: :original_file,
-                                           outputs: [
-                                             { label: :preservation, format: 'xlsx', url: "#{uri}/original_file_preservation" },
-                                             { label: :access,       format: 'pdf',  url: "#{uri}/original_file_access" },
-                                             { label: :thumnail,     format: 'jpg',  url: "#{uri}/original_file_thumbnail" }
-                                           ])
-        when 'image/tiff'
-          Jpeg2kImageDerivatives.create(self, source: :original_file,
-                                              outputs: [
-                                                { label: :resized,       format: 'jp2', recipe: :default, processor: 'jpeg2k_image', resize: "600x600>", url: "#{uri}/resized" },
-                                                { label: :config_lookup, format: 'jp2', recipe: :default, processor: 'jpeg2k_image', url: "#{uri}/config_lookup" },
-                                                { label: :string_recipe, format: 'jp2', recipe: '-jp2_space sRGB', processor: 'jpeg2k_image', url: "#{uri}/string_recipe" },
-                                                { label: :diy,           format: 'jp2', processor: 'jpeg2k_image', url: "#{uri}/original_file_diy" }
-                                              ])
-        when 'image/x-adobe-dng'
-          ImageDerivatives.create(self, source: :original_file,
-                                        outputs: [
-                                          { label: :access, size: "300x300>", format: 'jpg', processor: :raw_image, url: "#{uri}/original_file_access" },
-                                          { label: :thumb,  size: "100x100>", format: 'jpg', processor: :raw_image, url: "#{uri}/original_file_thumb" }
-                                        ])
-        end
-      end
-    end
-  end
-
-  after(:all) do
-    Object.send(:remove_const, :GenericFile)
-  end
-
-  describe "with an attached image" do
-    let(:filename) { File.expand_path('../../fixtures/world.png', __FILE__) }
-    let(:attachment) { File.open(filename) }
-    let(:file) do
-      GenericFile.new(mime_type_from_fits: 'image/png') do |f|
-        f.original_file.content = attachment
-        f.original_file.mime_type = f.mime_type_from_fits
-        f.save!
-      end
-    end
-
-    it "transcodes" do
-      expect(file.attached_files.key?('original_file_medium')).to be_falsey
-      file.create_derivatives(filename)
-      file.reload
-      expect(file.attached_files['original_file_medium']).to have_content
-      expect(file.attached_files['original_file_medium'].mime_type).to eq('image/png')
-      expect(file.attached_files['original_file_thumb']).to have_content
-      expect(file.attached_files['original_file_thumb'].mime_type).to eq('image/png')
-      expect(file.attached_files['access']).to have_content
-      expect(file.attached_files['access'].mime_type).to eq('image/jpeg')
-      expect(file.attached_files.key?('original_file_text')).to be_falsey
-    end
-  end
-
-  describe "with an attached RAW image", requires_imagemagick: true do
-    let(:filename) { File.expand_path('../../fixtures/test.dng', __FILE__) }
-    let(:attachment) { File.open(filename) }
-    let(:file) do
-      GenericFile.new(mime_type_from_fits: 'image/x-adobe-dng') do |f|
-        f.original_file.content = attachment
-        f.original_file.mime_type = f.mime_type_from_fits
-        f.save!
-      end
-    end
-
-    it "transcodes" do
-      expect(file.attached_files.key?('original_file_access')).to be_falsey
-      expect(file.attached_files.key?('original_file_thumb')).to be_falsey
-
-      file.create_derivatives(filename)
-      file.reload
-      expect(file.attached_files['original_file_access']).to have_content
-      expect(file.attached_files['original_file_access'].mime_type).to eq('image/jpeg')
-      expect(file.attached_files['original_file_thumb']).to have_content
-      expect(file.attached_files['original_file_thumb'].mime_type).to eq('image/jpeg')
-    end
-  end
-
-  describe "with an attached pdf", requires_imagemagick: true do
-    let(:filename) { File.expand_path('../../fixtures/test.pdf', __FILE__) }
-    let(:attachment) { File.open(filename) }
-    let(:file) do
-      GenericFile.new(mime_type_from_fits: 'application/pdf') do |t|
-        t.original_file.content = attachment
-        t.original_file.mime_type = t.mime_type_from_fits
-        t.save
-      end
-    end
-
-    it "transcodes" do
-      expect(file.attached_files.key?('original_file_thumb')).to be_falsey
-      file.create_derivatives(filename)
-      file.reload
-      expect(file.attached_files['original_file_thumb']).to have_content
-      expect(file.attached_files['original_file_thumb'].mime_type).to eq('image/png')
-      expect(file.attached_files['fulltext'].content).to match(/This PDF file was created using CutePDF/)
-      expect(file.attached_files['fulltext'].mime_type).to eq 'text/plain;charset=UTF-8'
-    end
-  end
-
-  describe "with an attached audio", requires_ffmpeg: true do
-    let(:filename) { File.expand_path('../../fixtures/piano_note.wav', __FILE__) }
-    let(:attachment) { File.open(filename) }
-    let(:file) do
-      GenericFile.new(mime_type_from_fits: 'audio/x-wav').tap do |t|
-        t.original_file.content = attachment
-        t.original_file.mime_type = t.mime_type_from_fits
-        t.save
-      end
-    end
-
-    it "transcodes" do
-      file.create_derivatives(filename)
-      file.reload
-      expect(file.attached_files['original_file_mp3']).to have_content
-      expect(file.attached_files['original_file_mp3'].mime_type).to eq('audio/mpeg')
-      expect(file.attached_files['original_file_ogg']).to have_content
-      expect(file.attached_files['original_file_ogg'].mime_type).to eq('audio/ogg')
-    end
-  end
-
-  describe "when the source datastrem has an unknown mime_type", requires_ffmpeg: true do
-    let(:filename) { File.expand_path('../../fixtures/piano_note.wav', __FILE__) }
-    let(:attachment) { File.open(filename) }
-    let(:file) do
-      GenericFile.new(mime_type_from_fits: 'audio/x-wav').tap do |t|
-        t.original_file.content = attachment
-        t.original_file.mime_type = 'audio/vnd.wav'
-        t.save
-      end
-    end
-
-    it "transcodes" do
-      allow_any_instance_of(::Logger).to receive(:warn)
-      file.create_derivatives(filename)
-      file.reload
-      expect(file.attached_files['original_file_mp3']).to have_content
-      expect(file.attached_files['original_file_mp3'].mime_type).to eq('audio/mpeg')
-    end
-  end
-
-  describe "with an attached video", requires_ffmpeg: true do
-    let(:filename) { File.expand_path('../../fixtures/countdown.avi', __FILE__) }
-    let(:attachment) { File.open(filename) }
-    let(:file) do
-      GenericFile.create(mime_type_from_fits: 'video/x-msvideo') do |t|
-        t.original_file.content = attachment
-        t.original_file.mime_type = t.mime_type_from_fits
-        t.save
-      end
-    end
-
-    it "transcodes" do
-      file.create_derivatives(filename)
-      file.reload
-      expect(file.attached_files['original_file_mp4']).to have_content
-      expect(file.attached_files['original_file_mp4'].mime_type).to eq('video/mp4')
-      expect(file.attached_files['original_file_webm']).to have_content
-      expect(file.attached_files['original_file_webm'].mime_type).to eq('video/webm')
-      expect(file.attached_files['thumbnail']).to have_content
-      expect(file.attached_files['thumbnail'].mime_type).to eq('image/jpeg')
-    end
-
-    context "when the timeout is set" do
-      before do
-        Hydra::Derivatives::Processors::Video::Processor.timeout = 0.2 # 200ms
-      end
-      after do
-        Hydra::Derivatives::Processors::Video::Processor.timeout = nil # clear timeout
-      end
-
-      it "raises a timeout" do
-        expect { file.create_derivatives(filename) }.to raise_error Hydra::Derivatives::TimeoutError
-      end
-    end
-  end
-
-  describe "with an attached Powerpoint", requires_libreoffice: true do
-    let(:filename) { File.expand_path('../../fixtures/FlashPix.ppt', __FILE__) }
-    let(:attachment) { File.open(filename) }
-    let(:file) do
-      GenericFile.create(mime_type_from_fits: 'application/vnd.ms-powerpoint') do |t|
-        t.original_file.content = attachment
-        t.original_file.mime_type = t.mime_type_from_fits
-        t.save
-      end
-    end
-
-    it "transcodes" do
-      file.create_derivatives(filename)
-      file.reload
-      expect(file.attached_files['original_file_thumbnail']).to have_content
-      expect(file.attached_files['original_file_thumbnail'].mime_type).to eq('image/jpeg')
-      expect(file.attached_files['original_file_access']).to have_content
-      expect(file.attached_files['original_file_access'].mime_type).to eq('application/pdf')
-      expect(file.attached_files['original_file_preservation']).to have_content
-      expect(file.attached_files['original_file_preservation'].mime_type).to eq('application/vnd.openxmlformats-officedocument.presentationml.presentation')
-    end
-  end
-
-  describe "with an attached rich text format", requires_libreoffice: true do
-    let(:filename) { File.expand_path('../../fixtures/sample.rtf', __FILE__) }
-    let(:attachment) { File.open(filename) }
-    let(:file) do
-      GenericFile.new(mime_type_from_fits: 'text/rtf').tap do |t|
-        t.original_file.content = attachment
-        t.original_file.mime_type = t.mime_type_from_fits
-        t.save
-      end
-    end
-
-    it "transcodes" do
-      file.create_derivatives(filename)
-      file.reload
-      expect(file.attached_files['original_file_thumbnail']).to have_content
-      expect(file.attached_files['original_file_thumbnail'].mime_type).to eq('image/jpeg')
-      expect(file.attached_files['original_file_access']).to have_content
-      expect(file.attached_files['original_file_access'].mime_type).to eq('application/pdf')
-      expect(file.attached_files['original_file_preservation']).to have_content
-      expect(file.attached_files['original_file_preservation'].mime_type).to eq('application/vnd.oasis.opendocument.text')
-    end
-  end
-
-  describe "with an attached word doc format", requires_libreoffice: true do
-    let(:filename)   { File.expand_path('../../fixtures/test.doc', __FILE__) }
-    let(:attachment) { File.open(filename) }
-
-    let(:file) do
-      GenericFile.new(mime_type_from_fits: 'application/msword').tap do |t|
-        t.original_file.content = attachment
-        t.original_file.mime_type = t.mime_type_from_fits
-        t.save
-      end
-    end
-
-    it "transcodes" do
-      file.create_derivatives(filename)
-      file.reload
-      expect(file.attached_files['original_file_thumbnail']).to have_content
-      expect(file.attached_files['original_file_thumbnail'].mime_type).to eq('image/jpeg')
-      expect(file.attached_files['original_file_access']).to have_content
-      expect(file.attached_files['original_file_access'].mime_type).to eq('application/pdf')
-      expect(file.attached_files['original_file_preservation']).to have_content
-      expect(file.attached_files['original_file_preservation'].mime_type).to eq('application/vnd.openxmlformats-officedocument.wordprocessingml.document')
-    end
-  end
-
-  describe "with an attached excel format", requires_libreoffice: true do
-    let(:filename)   { File.expand_path('../../fixtures/test.xls', __FILE__) }
-    let(:attachment) { File.open(filename) }
-
-    let(:file) do
-      GenericFile.new(mime_type_from_fits: 'application/vnd.ms-excel').tap do |t|
-        t.original_file.content = attachment
-        t.original_file.mime_type = t.mime_type_from_fits
-        t.save
-      end
-    end
-
-    it "transcodes" do
-      file.create_derivatives(filename)
-      file.reload
-      expect(file.attached_files['original_file_thumbnail']).to have_content
-      expect(file.attached_files['original_file_thumbnail'].mime_type).to eq('image/jpeg')
-      expect(file.attached_files['original_file_access']).to have_content
-      expect(file.attached_files['original_file_access'].mime_type).to eq('application/pdf')
-      expect(file.attached_files['original_file_preservation']).to have_content
-      expect(file.attached_files['original_file_preservation'].mime_type).to eq('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
-    end
-  end
-
-  describe "with an attached tiff", requires_kdu_compress: true do
-    let(:filename) { File.expand_path('../../fixtures/test.tif', __FILE__) }
-    let(:attachment) { File.open(filename) }
-
-    let(:file) do
-      GenericFile.new(mime_type_from_fits: 'image/tiff').tap do |t|
-        t.original_file.content = attachment
-        t.original_file.mime_type = t.mime_type_from_fits
-        t.save
-      end
-    end
-
-    it "transcodes" do
-      file.create_derivatives(filename)
-      file.reload
-      expect(file.attached_files['original_file_diy']).to have_content
-      expect(file.attached_files['original_file_diy'].mime_type).to eq('image/jp2')
-      expect(file.attached_files['config_lookup']).to have_content
-      expect(file.attached_files['config_lookup'].mime_type).to eq('image/jp2')
-      expect(file.attached_files['resized']).to have_content
-      expect(file.attached_files['resized'].mime_type).to eq('image/jp2')
-      expect(file.attached_files['string_recipe']).to have_content
-      expect(file.attached_files['string_recipe'].mime_type).to eq('image/jp2')
-    end
-  end
-end