hydra-derivatives 3.5.0 → 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,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