hydra-derivatives 2.0.0 → 3.0.0

data/spec/processors/shell_based_processor_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Hydra::Derivatives::Processors::ShellBasedProcessor do
+  before do
+    class TestProcessor
+      include Hydra::Derivatives::Processors::ShellBasedProcessor
+    end
+  end
+
+  after { Object.send(:remove_const, :TestProcessor) }
+
+  let (:processor) { TestProcessor.new }
+
+  describe "options_for" do
+    it "returns a hash" do
+      expect(processor.options_for("a")).to be_a Hash
+    end
+  end
+end

data/spec/processors/video_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Hydra::Derivatives::Processors::Video::Processor do
+  let(:file_name) { 'foo/bar.mov' }
+  subject { described_class.new(file_name, directives)}
+
+  describe ".config" do
+    before do
+      @original_config = described_class.config.dup
+      described_class.config.mpeg4.codec = "-vcodec mpeg4 -acodec aac -strict -2"
+    end
+
+    after { described_class.config = @original_config }
+    let(:directives) { { label: :thumb, format: "mp4", url: 'http://localhost:8983/fedora/rest/dev/1234/thumbnail' } }
+
+    it "should be configurable" do
+      expect(subject).to receive(:encode_file).with("mp4", { Hydra::Derivatives::Processors::Ffmpeg::OUTPUT_OPTIONS => "-s 320x240 -vcodec mpeg4 -acodec aac -strict -2 -g 30 -b:v 345k -ac 2 -ab 96k -ar 44100", Hydra::Derivatives::Processors::Ffmpeg::INPUT_OPTIONS => "" })
+      subject.process
+    end
+  end
+
+  context "when arguments are passed as a hash" do
+    context "and a video format is requested" do
+      let(:directives) { { label: :thumb, format: 'webm', url: 'http://localhost:8983/fedora/rest/dev/1234/thumbnail' } }
+
+      it "creates a fedora resource and infers the name" do
+        expect(subject).to receive(:encode_file).with("webm", { Hydra::Derivatives::Processors::Ffmpeg::OUTPUT_OPTIONS => "-s 320x240 -vcodec libvpx -acodec libvorbis -g 30 -b:v 345k -ac 2 -ab 96k -ar 44100", Hydra::Derivatives::Processors::Ffmpeg::INPUT_OPTIONS => "" })
+        subject.process
+      end
+    end
+
+    context "and jpg is requested" do
+      let(:directives) { { label: :thumb, format: 'jpg', url: 'http://localhost:8983/fedora/rest/dev/1234/thumbnail' } }
+      it "creates a fedora resource and infers the name" do
+        expect(subject).to receive(:encode_file).with("jpg", output_options: "-s 320x240 -vcodec mjpeg -vframes 1 -an -f rawvideo", input_options: " -itsoffset -2")
+        subject.process
+      end
+    end
+  end
+end

data/spec/services/audio_derivatives_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Hydra::Derivatives::AudioDerivatives do
+  describe ".create" do
+    let(:filename) { 'spec/fixtures/piano_note.wav' }
+    context "with a filename", unless: $in_travis do
+      before do
+        class LocalFileService
+          def self.call(file_name, options, &block)
+            yield File.open(file_name)
+          end
+        end
+        described_class.source_file_service = LocalFileService
+      end
+
+      after do
+        # restore the default
+        described_class.source_file_service = Hydra::Derivatives::RetrieveSourceFileService
+        Object.send(:remove_const, :LocalFileService)
+      end
+
+      it "creates derivatives" do
+        described_class.create(filename,
+                               outputs: [{ label: 'mp3', format: 'mp3', url: 'http://localhost:8983/fedora/rest/dev/1234/mp3' },
+                                         { label: 'ogg', format: 'ogg', url: 'http://localhost:8983/fedora/rest/dev/1234/ogg' }])
+      end
+    end
+
+    context "with an object" do
+      let(:object)      { "Fake Object"  }
+      let(:source_name) { :content }
+      let(:file)        { double("the file") }
+
+      before do
+        allow(object).to receive(:original_file).and_return(file)
+        allow(Hydra::Derivatives::TempfileService).to receive(:create).with(file)
+      end
+
+      it "creates derivatives" do
+        described_class.create(object,
+                               source: :original_file,
+                               outputs: [{ label: 'mp3', format: 'mp3' },
+                                         { label: 'ogg', format: 'ogg' }])
+      end
+    end
+  end
+
+  describe "source_file" do
+    subject { described_class }
+
+    it "relies on the source_file_service" do
+      expect(subject.source_file_service).to receive(:call).with('foo/bar.aiff', { baz: true })
+      subject.source_file('foo/bar.aiff', { baz: true })
+    end
+  end
+
+  describe "output_file_service" do
+    before do
+      class FakeOutputService
+      end
+      Hydra::Derivatives.output_file_service = FakeOutputService
+    end
+
+    after do
+      # restore the default
+      Hydra::Derivatives.output_file_service = Hydra::Derivatives::PersistBasicContainedOutputFileService
+      Object.send(:remove_const, :FakeOutputService)
+    end
+
+    subject { described_class.output_file_service }
+
+    it "defaults to the value set on Hydra::Derivatives" do
+      expect(subject).to eq FakeOutputService
+    end
+  end
+end

data/spec/services/persist_basic_contained_output_file_service_spec.rb

@@ -16,10 +16,11 @@ describe Hydra::Derivatives::PersistBasicContainedOutputFileService do
   # alas, we have to support this as the default because all legacy code (and fedora 3 systems) created basic contained files
   # The new signature does not have a destination_name option.  There is a default string that will get applied, but his might
   # not be sufficient.
-  context "when file is basic contained (default assumption)" do  
-    let(:object)          { BasicContainerObject.new  }
+  context "when file is basic contained (default assumption)" do
+    let(:object) { BasicContainerObject.create  }
+    let(:stream) { StringIO.new("fake file content") }
     it "persists the file to the specified destination on the given object" do
-      described_class.call(object, "fake file content", destination_name)
+      described_class.call(stream, { format: 'jpg', url: "#{object.uri}/the_derivative_name" })
       expect(object.send(destination_name.to_sym).content).to eq("fake file content")
       expect(object.send(destination_name.to_sym).content_changed?).to eq false
     end

data/spec/services/retrieve_source_file_service_spec.rb

@@ -1,16 +1,14 @@
 require 'spec_helper'
 
 describe Hydra::Derivatives::RetrieveSourceFileService do
-
   before(:all) do
-    
-    # Need a class that: 
+    # 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
       contains "contained_file"
     end
@@ -22,19 +20,24 @@ describe Hydra::Derivatives::RetrieveSourceFileService do
     end
   end
 
-  subject { described_class.call(object, source_name) }
-  
   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
-      expect(subject).to eq(object.contained_file)
+      described_class.call(object, { source: source_name }) do |f|
+        expect(f.read).to eq(object.contained_file.content)
+      end
     end
   end
 
@@ -42,15 +45,16 @@ describe Hydra::Derivatives::RetrieveSourceFileService do
     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
-      expect(subject).to eq(object.directly_contained_file)
+      described_class.call(object, { source: source_name }) do |f|
+        expect(f.read).to eq(object.directly_contained_file.content)
+      end
     end
   end
-  
-end
+end

data/spec/units/derivatives_spec.rb

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
 describe Hydra::Derivatives do
-  
   before(:all) do
     class CustomFile < ActiveFedora::Base
       include Hydra::Derivatives
     end
-    class CustomProcessor < Hydra::Derivatives::Processor
+    class CustomProcessor < Hydra::Derivatives::Processors::Processor
     end
     class CustomSourceFileService
     end
@@ -21,34 +20,27 @@ describe Hydra::Derivatives do
     Object.send(:remove_const, :CustomOutputFileService)
   end
 
-  describe "initialize_processor" do
-    subject{ CustomFile.new.send(:initialize_processor, :content, { thumb: '100x100>' }, processor: Hydra::Derivatives::Video::Processor, source_file_service: CustomSourceFileService, output_file_service: CustomOutputFileService) }
-    it "passes source_file_service and output_file_service options to the processor" do
-      expect(subject.class).to eq(Hydra::Derivatives::Video::Processor)
-      expect(subject.source_file_service).to eq(CustomSourceFileService)
-      expect(subject.output_file_service).to eq(CustomOutputFileService)
+  describe "source_file_service" do
+    let(:custom_source_file_service) { "fake service" }
+    before do
+      allow(Hydra::Derivatives).to receive(:source_file_service).and_return(custom_source_file_service)
     end
-  end
+    subject { Class.new { include Hydra::Derivatives } }
 
-  context "when using an included processor" do
-    subject { CustomFile.new.processor_class(:image) }
-    it { is_expected.to eql Hydra::Derivatives::Image }
-  end
+    context "as a global configuration setting" do
+      it "utilizes the default source file service" do
+        expect(subject.source_file_service).to eq(custom_source_file_service)
+      end
+    end
 
-  context "when using the video processor" do
-    subject { CustomFile.new.processor_class(:video) }
-    it { is_expected.to eql Hydra::Derivatives::Video::Processor }
-  end
-  
-  context "when using the video processor" do
-    subject { CustomFile.new.processor_class("CustomProcessor") }
-    it { is_expected.to eql CustomProcessor }
-  end
+    context "as an instance level configuration setting" do
+      let(:another_custom_source_file_service) { "another fake service" }
+      subject { Class.new { include Hydra::Derivatives }.new }
+      before { subject.source_file_service = another_custom_source_file_service }
 
-  context "when using a fake processor" do
-    it "raises an error" do
-      expect( lambda{ CustomFile.new.processor_class("BogusProcessor") }).to raise_error(NameError)
+      it "accepts a custom source file service as an option" do
+        expect(subject.source_file_service).to eq(another_custom_source_file_service)
+      end
     end
   end
-
 end

data/spec/units/io_decorator_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'stringio'
+
+describe Hydra::Derivatives::IoDecorator do
+  let(:file) { StringIO.new('hello') }
+
+  context "one argument" do
+    let(:decorator) { described_class.new(file) }
+    describe "#read" do
+      subject { decorator.read }
+      it { is_expected.to eq 'hello' }
+    end
+  end
+
+  context "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_name" do
+      subject { decorator.original_name }
+      it { is_expected.to eq 'help.txt' }
+    end
+  end
+end

data/spec/units/transcoding_spec.rb

@@ -2,10 +2,6 @@ require 'spec_helper'
 
 describe "Transcoder" do
   before(:all) do
-    class ContentDatastream < ActiveFedora::File
-      include Hydra::Derivatives::ExtractMetadata
-    end
-
     class GenericFile < ActiveFedora::Base
       include Hydra::Derivatives
       contains 'characterization', class_name: 'ActiveFedora::SimpleDatastream' do |m|
@@ -13,62 +9,65 @@ describe "Transcoder" do
         m.field "flag_as", :string
       end
 
-      has_attributes :mime_type_from_fits, :flag_as, datastream: :characterization, multiple: false
-      contains 'original_file', class_name: 'ContentDatastream'
+      property :mime_type_from_fits, delegate_to: :characterization, multiple: false
+      property :flag_as, delegate_to: :characterization, multiple: false
+      contains 'original_file'
 
-      makes_derivatives do |obj|
-        case obj.mime_type_from_fits
+      def create_derivatives(filename)
+        case mime_type_from_fits
         when 'application/pdf'
-          obj.transform_file :original_file, { thumb: '100x100>' }
+          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/wav'
-          obj.transform_file :original_file, { mp3: { format: 'mp3' }, ogg: { format: 'ogg'} }, processor: :audio
+          AudioDerivatives.create(self, source: :original_file, outputs: [{ label: :mp3, format: 'mp3', url: "#{uri}/mp3" }, { label: :ogg, format: 'ogg', url: "#{uri}/ogg" }])
         when 'video/avi'
-          obj.transform_file :original_file, { mp4: { format: 'mp4' }, webm: { format: 'webm'}, thumbnail: { format: 'jpg', datastream: 'thumbnail' } }, processor: :video
+          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'
-          obj.transform_file :original_file, { medium: "300x300>", thumb: "100x100>", access: { format: 'jpg', datastream: 'access'} }
+          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, url: "#{uri}/access", format: 'jpg' },
+          ])
         when 'application/vnd.ms-powerpoint'
-          obj.transform_file :original_file, { preservation: { format: 'pptx'}, access: { format: 'pdf' }, thumbnail: { format: 'jpg' } }, processor: 'document'
+          DocumentDerivatives.create(self, source: :original_file, outputs: [{ label: :preservation, format: 'pptx' }, { label: :access, format: 'pdf' }, { label: :thumnail, format: 'jpg' }])
         when 'text/rtf'
-          obj.transform_file :original_file, { preservation: { format: 'odf' }, access: { format: 'pdf' }, thumbnail: { format: 'jpg' } }, processor: 'document'
+          DocumentDerivatives.create(self, source: :original_file, outputs: [{ label: :preservation, format: 'odf' }, { label: :access, format: 'pdf' }, { label: :thumnail, format: 'jpg' }])
         when 'application/msword'
-          obj.transform_file :original_file, { access: { format: 'pdf' }, preservation: { format: 'docx' }, thumbnail: { format: 'jpg' } }, processor: 'document'
+          DocumentDerivatives.create(self, source: :original_file, outputs: [{ label: :preservation, format: 'docx' }, { label: :access, format: 'pdf' }, { label: :thumnail, format: 'jpg' }])
         when 'application/vnd.ms-excel'
-          obj.transform_file :original_file, { access: { format: 'pdf' }, preservation: { format: 'xslx' }, thumbnail: { format: 'jpg' } }, processor: 'document'
+          DocumentDerivatives.create(self, source: :original_file, outputs: [{ label: :preservation, format: 'xslx' }, { label: :access, format: 'pdf' }, { label: :thumnail, format: 'jpg' }])
         when 'image/tiff'
-          obj.transform_file :original_file, {
-            resized: { recipe: :default, resize: "600x600>", datastream: 'resized' },
-            config_lookup: { recipe: :default, datastream: 'config_lookup' },
-            string_recipe: { recipe: '-quiet', datastream: 'string_recipe' },
-            diy: { }
-          }, processor: 'jpeg2k_image'
+          Jpeg2kImageDerivatives.create(self, source: :original_file, outputs: [
+            { label: :resized, recipe: :default, resize: "600x600>", processor: 'jpeg2k_image', url: "#{uri}/resized" },
+            { label: :config_lookup, recipe: :default, processor: 'jpeg2k_image', url: "#{uri}/config_lookup" },
+            { label: :string_recipe, recipe: '-quiet', processor: 'jpeg2k_image', url: "#{uri}/string_recipe" },
+            { label: :diy, processor: 'jpeg2k_image', url: "#{uri}/original_file_diy" }
+          ])
         when 'image/x-adobe-dng'
-          obj.transform_file :original_file, 
-		 	{
-				access: { size: "300x300>", format: "jpg", datastream: "access" },
-				thumb: { size: "100x100>", format: "jpg", datastream: "thumb" }
-		  	}, processor: :raw_image
+          ImageDerivatives.create(self, source: :original_file, outputs: [
+            { label: :access, size: "300x300>", format: 'jpg', processor: :raw_image },
+            { label: :thumb, size: "100x100>", format: 'jpg', processor: :raw_image }
+          ])
          end
       end
-
-      makes_derivatives :generate_special_derivatives
-
-      def generate_special_derivatives
-        if flag_as == "special" && mime_type_from_fits == 'image/png'
-          transform_file :original_file, { medium: { size: "200x300>", datastream: 'special_ds' } }
-        end
-      end
     end
   end
 
   after(:all) do
     Object.send(:remove_const, :GenericFile);
-    Object.send(:remove_const, :ContentDatastream);
   end
 
   describe "with an attached image" do
-    let(:attachment) { File.open(File.expand_path('../../fixtures/world.png', __FILE__))}
+    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').tap do |f|
+      GenericFile.new(mime_type_from_fits: 'image/png') do |f|
         f.original_file.content = attachment
         f.save!
       end
@@ -76,7 +75,8 @@ describe "Transcoder" do
 
     it "should transcode" do
       expect(file.attached_files.key?('original_file_medium')).to be_falsey
-      file.create_derivatives
+      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
@@ -88,7 +88,8 @@ describe "Transcoder" do
   end
 
   describe "with an attached RAW image", unless: $in_travis do
-    let(:attachment) { File.open(File.expand_path('../../fixtures/test.dng', __FILE__))}
+    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
@@ -101,7 +102,7 @@ describe "Transcoder" do
      expect(file.attached_files.key?('access')).to be_falsey
       expect(file.attached_files.key?('thumb')).to be_falsey
 
-      file.create_derivatives
+      file.create_derivatives(filename)
       expect(file.attached_files['access']).to have_content
       expect(file.attached_files['access'].mime_type).to eq('image/jpeg')
       expect(file.attached_files['thumb']).to have_content
@@ -109,24 +110,36 @@ describe "Transcoder" do
     end
   end
 
-  describe "with an attached pdf" do
-    let(:attachment) { File.open(File.expand_path('../../fixtures/test.pdf', __FILE__))}
-    let(:file) { GenericFile.new(mime_type_from_fits: 'application/pdf').tap { |t| t.original_file.content = attachment; t.save } }
+  describe "with an attached pdf", unless: $in_travis 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 = 'application/pdf'
+        t.save
+      end
+    end
 
     it "should transcode" do
       expect(file.attached_files.key?('original_file_thumb')).to be_falsey
-      file.create_derivatives
+      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'
     end
   end
 
-  describe "with an attached audio", unless: ENV['TRAVIS'] == 'true' do
-    let(:attachment) { File.open(File.expand_path('../../fixtures/piano_note.wav', __FILE__))}
+  describe "with an attached audio", unless: $in_travis do
+    let(:filename) { File.expand_path('../../fixtures/piano_note.wav', __FILE__) }
+    let(:attachment) { File.open(filename) }
     let(:file) { GenericFile.new(mime_type_from_fits: 'audio/wav').tap { |t| t.original_file.content = attachment; t.save } }
 
     it "should transcode" do
-      file.create_derivatives
+      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
@@ -134,8 +147,9 @@ describe "Transcoder" do
     end
   end
 
-  describe "when the source datastrem has an unknown mime_type", unless: ENV['TRAVIS'] == 'true' do
-    let(:attachment) { File.open(File.expand_path('../../fixtures/piano_note.wav', __FILE__))}
+  describe "when the source datastrem has an unknown mime_type", unless: $in_travis 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/wav').tap do |t|
         t.original_file.content = attachment;
@@ -146,18 +160,26 @@ describe "Transcoder" do
 
     it "should transcode" do
       allow_any_instance_of(::Logger).to receive(:warn)
-      file.create_derivatives
+      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", unless: ENV['TRAVIS'] == 'true' do
-    let(:attachment) { File.open(File.expand_path('../../fixtures/countdown.avi', __FILE__))}
-    let(:file) { GenericFile.new(mime_type_from_fits: 'video/avi').tap { |t| t.original_file.content = attachment; t.save } }
+  describe "with an attached video", unless: $in_travis 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/avi') do |t|
+        t.original_file.content = attachment
+        t.original_file.mime_type = 'video/msvideo'
+      end
+    end
 
     it "should transcode" do
-      file.create_derivatives
+      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
@@ -168,37 +190,30 @@ describe "Transcoder" do
 
     context "and the timeout is set" do
       before do
-        Hydra::Derivatives::Video::Processor.timeout = 1 # one second
+        Hydra::Derivatives::Processors::Video::Processor.timeout = 0.2 # 200ms
       end
       after do
-        Hydra::Derivatives::Video::Processor.timeout = nil # clear timeout
+        Hydra::Derivatives::Processors::Video::Processor.timeout = nil # clear timeout
       end
 
       it "should raise a timeout" do
-        expect { file.create_derivatives }.to raise_error Hydra::Derivatives::TimeoutError
+        expect { file.create_derivatives(filename) }.to raise_error Hydra::Derivatives::TimeoutError
       end
     end
   end
 
-  describe "using callback methods" do
-    let(:attachment) { File.open(File.expand_path('../../fixtures/world.png', __FILE__))}
-    let(:file) { GenericFile.new(mime_type_from_fits: 'image/png', flag_as: "special").tap { |t| t.original_file.content = attachment; t.save } }
-
-    it "should transcode" do
-      expect(file.attached_files.key?('special_ds')).to be_falsey
-      file.create_derivatives
-      expect(file.attached_files['special_ds']).to have_content
-      expect(file.attached_files['special_ds'].mime_type).to eq('image/png')
-      expect(file.attached_files['special_ds']).to have_content
+  describe "with an attached Powerpoint", unless: $in_travis 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
+      end
     end
-  end
-
-  describe "with an attached Powerpoint", unless: ENV['TRAVIS'] == 'true' do
-    let(:attachment) { File.open(File.expand_path('../../fixtures/FlashPix.ppt', __FILE__))}
-    let(:file) { GenericFile.new(mime_type_from_fits: 'application/vnd.ms-powerpoint').tap { |t| t.original_file.content = attachment; t.save } }
 
     it "should transcode" do
-      file.create_derivatives
+      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
@@ -208,12 +223,14 @@ describe "Transcoder" do
     end
   end
 
-  describe "with an attached rich text format", unless: ENV['TRAVIS'] == 'true' do
-    let(:attachment) { File.open(File.expand_path('../../fixtures/sample.rtf', __FILE__))}
+  describe "with an attached rich text format", unless: $in_travis do
+    let(:filename) { File.expand_path('../../fixtures/sample.rtf', __FILE__) }
+    let(:attachment) { File.open(filename) }
     let(:file) { GenericFile.new(mime_type_from_fits: 'text/rtf').tap { |t| t.original_file.content = attachment; t.save } }
 
     it "should transcode" do
-      file.create_derivatives
+      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
@@ -223,12 +240,14 @@ describe "Transcoder" do
     end
   end
 
-  describe "with an attached word doc format", unless: ENV['TRAVIS'] == 'true' do
-    let(:attachment) { File.open(File.expand_path('../../fixtures/test.doc', __FILE__))}
+  describe "with an attached word doc format", unless: $in_travis do
+    let(:filename) { File.expand_path('../../fixtures/test.doc', __FILE__) }
+    let(:attachment) { File.open(filename) }
     let(:file) { GenericFile.new(mime_type_from_fits: 'application/msword').tap { |t| t.original_file.content = attachment; t.save } }
 
     it "should transcode" do
-      file.create_derivatives
+      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
@@ -238,12 +257,14 @@ describe "Transcoder" do
     end
   end
 
-  describe "with an attached excel format", unless: ENV['TRAVIS'] == 'true' do
-    let(:attachment) { File.open(File.expand_path('../../fixtures/test.xls', __FILE__))}
+  describe "with an attached excel format", unless: $in_travis do
+    let(:filename) { File.expand_path('../../fixtures/test.xls', __FILE__) }
+    let(:attachment) { File.open(filename)}
     let(:file) { GenericFile.new(mime_type_from_fits: 'application/vnd.ms-excel').tap { |t| t.original_file.content = attachment; t.save } }
 
     it "should transcode" do
-      file.create_derivatives
+      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
@@ -253,11 +274,13 @@ describe "Transcoder" do
     end
   end
 
-  describe "with an attached tiff", unless: ENV['TRAVIS'] == 'true' do
-    let(:attachment) { File.open(File.expand_path('../../fixtures/test.tif', __FILE__))}
+  describe "with an attached tiff", unless: $in_travis do
+    let(:filename) { File.expand_path('../../fixtures/test.tif', __FILE__) }
+    let(:attachment) { File.open(filename)}
     let(:file) { GenericFile.new(mime_type_from_fits: 'image/tiff').tap { |t| t.original_file.content = attachment; t.save } }
     it "should transcode" do
-      file.create_derivatives
+      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