hydra-derivatives 3.5.0 → 3.7.0

data/spec/processors/processor_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Derivatives::Processors::Processor do
-  subject { described_class.new(file_path, directives) }
-
-  let(:object)        { "Fake Object" }
-  let(:source_name)   { 'content' }
-  let(:directives)    { { thumb: "100x100>" } }
-  let(:file_path)     { Pathname.new("test/unicorn.jpg") }
-
-  describe "output_file_service" do
-    let(:custom_output_file_service) { "fake service" }
-    let(:another_custom_output_file_service) { "another fake service" }
-
-    context "with a global configuration setting" do
-      before do
-        allow(Hydra::Derivatives).to receive(:output_file_service).and_return(custom_output_file_service)
-      end
-      it "utilizes the default output file service" do
-        expect(subject.output_file_service).to eq(custom_output_file_service)
-      end
-    end
-
-    context "with an instance level configuration setting" do
-      subject do
-        described_class.new('/opt/derivatives/foo.mp4', directives,
-                            output_file_service: another_custom_output_file_service)
-      end
-
-      it "accepts a custom output file service as an option" do
-        expect(subject.output_file_service).to eq(another_custom_output_file_service)
-      end
-    end
-  end
-
-  describe "#process" do
-    it "raises an implementation error" do
-      expect { subject.process }.to raise_error "Processor is an abstract class. Implement `process' on Hydra::Derivatives::Processors::Processor"
-    end
-  end
-
-  describe "#output_file" do
-    it "raises an implementation error" do
-      expect { subject.output_file }.to raise_error "Processor is an abstract class. Utilize an implementation of a PersistOutputFileService class in Hydra::Derivatives::Processors::Processor"
-    end
-  end
-
-  describe "#output_filename_for" do
-    it "returns the basename of the source file" do
-      expect(subject.output_filename_for("ignored")).to eq "unicorn.jpg"
-    end
-  end
-end

data/spec/processors/shell_based_processor_spec.rb

@@ -1,28 +0,0 @@
-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 }
-  let(:proc_class) { TestProcessor }
-
-  describe "options_for" do
-    it "returns a hash" do
-      expect(processor.options_for("a")).to be_a Hash
-    end
-  end
-
-  describe ".execute" do
-    context "when an EOF error occurs" do
-      it "doesn't crash" do
-        proc_class.execute("echo foo")
-      end
-    end
-  end
-end

data/spec/processors/video_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Derivatives::Processors::Video::Processor do
-  subject { described_class.new(file_name, directives) }
-
-  let(:file_name) { 'foo/bar.mov' }
-
-  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 "is 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 "when 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 "when a 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
-
-    context "when an mkv is requested" do
-      let(:directives) { { label: :thumb, format: 'mkv', 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("mkv", Hydra::Derivatives::Processors::Ffmpeg::OUTPUT_OPTIONS => "-s 320x240 -vcodec ffv1 -g 30 -b:v 345k -ac 2 -ab 96k -ar 44100", Hydra::Derivatives::Processors::Ffmpeg::INPUT_OPTIONS => "")
-        subject.process
-      end
-    end
-
-    context "when an unknown format is requested" do
-      let(:directives) { { label: :thumb, format: 'nocnv', url: 'http://localhost:8983/fedora/rest/dev/1234/thumbnail' } }
-
-      it "raises an ArgumentError" do
-        expect { subject.process }.to raise_error ArgumentError, "Unknown format `nocnv'"
-      end
-    end
-  end
-end

data/spec/runners/active_encode_derivatives_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Derivatives::ActiveEncodeDerivatives do
-  describe '.create' do
-    before do
-      class TestVideo < ActiveFedora::Base
-        attr_accessor :remote_file_name
-      end
-    end
-
-    after { Object.send(:remove_const, :TestVideo) }
-
-    let(:file_path) { 'some/path/to/my_video.mp4' }
-    let(:video_record) { TestVideo.new(remote_file_name: file_path) }
-    let(:options) { { source: :remote_file_name, outputs: [low_res_video] } }
-    let(:low_res_video) { { some_key: 'some options to pass to my encoder service' } }
-    let(:processor) { instance_double('processor') }
-
-    it 'calls the processor with the right arguments' do
-      expect(Hydra::Derivatives::Processors::ActiveEncode).to receive(:new).with(file_path, low_res_video, output_file_service: Hydra::Derivatives::PersistExternalFileOutputFileService).and_return(processor)
-      expect(processor).to receive(:process)
-      described_class.create(video_record, options)
-    end
-
-    context 'with a custom encode class' do
-      before { class TestEncode < ::ActiveEncode::Base; end }
-      after { Object.send(:remove_const, :TestEncode) }
-
-      let(:options) { { encode_class: TestEncode, source: :remote_file_name, outputs: [low_res_video] } }
-
-      it 'calls the processor with the right arguments' do
-        expect(Hydra::Derivatives::Processors::ActiveEncode).to receive(:new).with(file_path, low_res_video, output_file_service: Hydra::Derivatives::PersistExternalFileOutputFileService, encode_class: TestEncode).and_return(processor)
-        expect(processor).to receive(:process)
-        described_class.create(video_record, options)
-      end
-    end
-  end
-end

data/spec/runners/runner_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Hydra::Derivatives::Runner do
-  describe ".processor_class" do
-    it "raises an error if it's not overridden" do
-      expect { described_class.processor_class }.to raise_error "Overide the processor_class method in a sub class"
-    end
-  end
-end

data/spec/services/audio_derivatives_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Derivatives::AudioDerivatives do
-  describe ".create" do
-    let(:filename) { 'spec/fixtures/piano_note.wav' }
-    let(:af_path) { ActiveFedora.fedora.host + ActiveFedora.fedora.base_path }
-
-    context "with a filename", requires_ffmpeg: true 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: "#{af_path}/1234/mp3" },
-                                         { label: 'ogg', format: 'ogg', url: "#{af_path}/1234/ogg" }])
-      end
-    end
-
-    context "with an object" do
-      let(:object)      { "Fake Object" }
-      let(:source_name) { :content }
-      let(:file)        { instance_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

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Derivatives::PersistBasicContainedOutputFileService do
-  before(:all) do
-    class BasicContainerObject < ActiveFedora::Base
-      has_subresource "the_derivative_name"
-    end
-  end
-
-  let(:object)            { BasicContainerObject.new }
-  let(:file_path)         { File.join(fixture_path, 'test.tif') }
-  let(:file)              { File.new(file_path) }
-  let(:destination_name)  { 'the_derivative_name' }
-
-  # 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.create }
-    let(:content) { StringIO.new("fake file content") }
-    let(:resource) { object.public_send(destination_name.to_sym) }
-
-    context "when the content is a stream" do
-      it "persists the file to the specified destination on the given object" do
-        described_class.call(content, format: 'jpg', url: "#{object.uri}/the_derivative_name")
-        expect(resource.content).to start_with("fake file content")
-        expect(resource.content_changed?).to eq false
-        expect(resource.mime_type).to eq 'image/jpeg'
-      end
-    end
-
-    context "when the content is a string" do
-      let(:content) { "fake file content - ÅÄÖ" }
-
-      it "persists the file to the specified destination on the given object" do
-        described_class.call(content, format: 'txt', url: "#{object.uri}/the_derivative_name")
-        expect(resource.content).to eq("fake file content - ÅÄÖ")
-        expect(resource.mime_type).to eq 'text/plain;charset=UTF-8'
-      end
-    end
-  end
-end

data/spec/services/persist_external_file_output_file_service_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Derivatives::PersistExternalFileOutputFileService do
-  before do
-    class ExternalDerivativeContainerObject < ActiveFedora::Base
-      has_subresource "external_derivative"
-    end
-  end
-  after do
-    Object.send(:remove_const, :ExternalDerivativeContainerObject)
-  end
-
-  let(:object)            { ExternalDerivativeContainerObject.create }
-  let(:directives)        { { url: "#{object.uri}/external_derivative" } }
-  let(:external_url)      { 'http://www.example.com/external/content' }
-  let(:output)            { { url: external_url } }
-  let(:destination_name)  { 'external_derivative' }
-
-  describe '.call' do
-    it "persists the external file to the specified destination on the given object" do
-      described_class.call(output, directives)
-      expect(object.send(destination_name.to_sym).mime_type).to eq "message/external-body;access-type=URL;url=\"http://www.example.com/external/content\""
-      expect(object.send(destination_name.to_sym).content).to eq ''
-    end
-  end
-end

data/spec/services/persist_output_file_service_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Hydra::Derivatives::PersistOutputFileService do
-  let(:original_filename_class) do
-    Class.new do
-      def original_filename
-        "original filename"
-      end
-
-      def mime_type
-        "image/tiff"
-      end
-    end
-  end
-
-  describe ".call" do
-    it "raises an error if not implemented" do
-      expect { described_class.call(nil, nil) }.to raise_error NotImplementedError, "PersistOutputFileService is an abstract class. Implement `call' on Class"
-    end
-  end
-
-  describe ".determine_original_name" do
-    context "when given something with an original filename" do
-      it "returns it from that file" do
-        expect(described_class.determine_original_name(original_filename_class.new)).to eq "original filename"
-      end
-    end
-    context "when given something without an original filename" do
-      it "returns derivative" do
-        expect(described_class.determine_original_name("tardis")).to eq "derivative"
-      end
-    end
-  end
-
-  describe ".determine_mime_type" do
-    context "when given something with #mime_type" do
-      it "returns it from that file" do
-        expect(described_class.determine_mime_type(original_filename_class.new)).to eq "image/tiff"
-      end
-    end
-    context "when given something without #mime_type" do
-      it "returns application/octet-stream" do
-        expect(described_class.determine_mime_type("tardis")).to eq "application/octet-stream"
-      end
-    end
-  end
-end

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