hydra-derivatives 3.3.2 → 3.6.0

data/spec/processors/jpeg2k_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-require 'yaml'
-
-describe Hydra::Derivatives::Processors::Jpeg2kImage do
-  let(:object) { ActiveFedora::Base.new }
-  let(:filename) { File.expand_path('../../fixtures/test.tif', __FILE__) }
-  let(:image) { MiniMagick::Image.open(filename) }
-
-  describe "#calculate_recipe" do
-    it "calculates the number of levels from a size" do
-      dim = 7200
-      expect(described_class.level_count_for_size(dim)).to eq(6)
-    end
-
-    it "calculates the compression rates for each quality layer" do
-      compression_num = 10
-      layers = 8
-      calc = described_class.layer_rates(layers, compression_num)
-      expect(calc).to eq("2.4,1.48331273,0.91675694,0.56659885,0.3501847,0.21643059,0.13376427,0.0826726")
-    end
-  end
-
-  describe ".srgb_profile_path" do
-    it "exists" do
-      expect(File.exist?(described_class.srgb_profile_path)).to eq true
-    end
-  end
-
-  describe "#kdu_compress_recipe" do
-    before(:all) do
-      @sample_cfg = YAML.load_file(File.expand_path('../../fixtures/jpeg2k_config.yml', __FILE__))['test']
-      Hydra::Derivatives.kdu_compress_recipes = @sample_cfg['jp2_recipes']
-    end
-    after(:all) do
-      Hydra::Derivatives.reset_config!
-    end
-
-    it "can get the recipe from a config file" do
-      args = { recipe: :myrecipe }
-      r = described_class.kdu_compress_recipe(args, 'grey', 7200)
-      expect(r).to eq(@sample_cfg['jp2_recipes'][:myrecipe_grey])
-    end
-
-    it "can take a recipe as a string" do
-      args = { recipe: '-my -excellent -recipe' }
-      r = described_class.kdu_compress_recipe(args, 'grey', 7200)
-      expect(r).to eq(args[:recipe])
-    end
-
-    it "will fall back to a #calculate_recipe if a symbol is passed but no recipe is found" do
-      args = { recipe: :x }
-      r = described_class.kdu_compress_recipe(args, 'grey', 7200)
-      expect(r).to eq(described_class.calculate_recipe(args, 'grey', 7200))
-    end
-
-    it "will fall back to a #calculate_recipe if there is no attempt to provide one" do
-      args = {}
-      r = described_class.kdu_compress_recipe(args, 'grey', 7200)
-      expect(r).to eq(described_class.calculate_recipe(args, 'grey', 7200))
-    end
-  end
-
-  describe "#encode" do
-    it "executes the external utility" do
-      expect(described_class).to receive(:execute) { 0 }
-      described_class.encode('infile', 'recipe', 'outfile')
-    end
-  end
-
-  describe "#tmp_file" do
-    it "returns a temp file with the correct extension" do
-      f = described_class.tmp_file('.test')
-      expect(f).to end_with('.test')
-    end
-  end
-
-  describe "long_dim" do
-    it "returns the image's largest dimension" do
-      expect(described_class.long_dim(image)).to eq(386)
-    end
-  end
-end

data/spec/processors/processor_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Derivatives::Processors::Processor do
-  let(:object)        { "Fake Object" }
-  let(:source_name)   { 'content' }
-  let(:directives)    { { thumb: "100x100>" } }
-  let(:file_path)     { double }
-
-  subject { described_class.new(file_path, directives) }
-
-  describe "output_file_service" do
-    let(:custom_output_file_service) { "fake service" }
-    let(:another_custom_output_file_service) { "another fake service" }
-
-    context "as 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 "as 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
-end

data/spec/processors/shell_based_processor_spec.rb

@@ -1,19 +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 }
-
-  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

@@ -1,40 +0,0 @@
-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 "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 "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/runners/active_encode_derivatives_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Derivatives::ActiveEncodeDerivatives do
-  context '.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) { 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/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)        { 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,40 +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 "and 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 "and 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/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) { Hash.new }
-
-      it '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 '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