hydra-works 0.0.1 → 0.1.0

data/spec/hydra/works/services/generic_file/add_file_to_generic_file_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Hydra::Works::AddFileToGenericFile do
+
+  let(:generic_file)        { Hydra::Works::GenericFile::Base.new }
+  let(:filename)            { "sample-file.pdf" }
+  let(:filename2)           { "updated-file.txt" }
+  let(:original_name)       { "original-name.pdf" }
+  let(:file)                { File.open(File.join(fixture_path, filename)) }
+  let(:file2)               { File.open(File.join(fixture_path, filename2)) }
+  let(:type)                { ::RDF::URI("http://pcdm.org/use#ExtractedText") }
+  let(:update_existing)     { true }
+  let(:mime_type)           { "application/pdf" }
+
+  context "when generic_file is not persisted" do
+    let(:generic_file)        { Hydra::Works::GenericFile::Base.new }
+    it "saves generic_file" do
+      described_class.call(generic_file, file, type)
+      expect(generic_file.persisted?).to be true
+    end
+  end
+
+  context "when generic_file is not valid" do
+    before do
+      generic_file.save
+      allow(generic_file).to receive(:valid?).and_return(false)
+    end
+    it "returns false" do
+      expect( described_class.call(generic_file, file, type) ).to be false
+    end
+  end
+
+  context "file responds to :mime_type and :original_name" do
+    before do
+      allow(file).to         receive(:mime_type).and_return(mime_type)
+      allow(file).to         receive(:original_name).and_return(original_name)
+      described_class.call(generic_file, file, type)
+    end
+    subject { generic_file.filter_files_by_type(type).first }
+    it "uses the mime_type and original_name methods" do
+      expect(subject.mime_type).to eq(mime_type)
+      expect(subject.original_name).to eq(original_name)
+    end
+  end
+
+  context "file responds to :path but not to :mime_type nor :original_name" do
+    it "defaults to Hydra::PCDM for mimetype and ::File for basename." do
+    expect(Hydra::PCDM::GetMimeTypeForFile).to receive(:call).with(file.path)
+    expect(::File).to receive(:basename).with(file.path)
+    described_class.call(generic_file, file, type)
+    end
+  end
+
+  it "adds the given file and applies the specified type to it" do
+    described_class.call(generic_file, file, type, update_existing: update_existing)
+    expect(generic_file.filter_files_by_type(type).first.content).to start_with("%PDF-1.3")
+  end
+
+  context "when :type is the name of an association" do
+    let(:type)  { :extracted_text }
+    before do
+      described_class.call(generic_file, file, type)
+    end
+    it "builds and uses the association's target" do
+      expect(generic_file.extracted_text.content).to start_with("%PDF-1.3")
+    end
+  end
+
+  context "when :versioning => true" do
+    let(:type)        { :original_file }
+    let(:versioning)  { true }
+    subject     { generic_file }
+    it "updates the file and creates a version" do
+      described_class.call(generic_file, file, type, versioning: versioning)
+      expect(subject.original_file.versions.all.count).to eq(1)
+      expect(subject.original_file.content).to start_with("%PDF-1.3")
+    end
+    context "and there are already versions" do
+      before do
+        described_class.call(generic_file, file, type, versioning: versioning)
+        described_class.call(generic_file, file2, type, versioning: versioning)
+      end
+      it "adds to the version history" do
+        expect(subject.original_file.versions.all.count).to eq(2)
+        expect(subject.original_file.content).to eq("some updated content\n")
+      end
+    end
+  end
+
+  context "when :versioning => false" do
+    let(:type)        { :original_file }
+    let(:versioning)  { false }
+    before do
+      described_class.call(generic_file, file, type, versioning: versioning)
+    end
+    subject     { generic_file }
+    it "skips creating versions" do
+      expect(subject.original_file.versions.all.count).to eq(0)
+      expect(subject.original_file.content).to start_with("%PDF-1.3")
+    end
+  end
+
+  context "type_to_uri" do
+    subject { Hydra::Works::AddFileToGenericFile::Updater.allocate }
+    it "converts URI strings to RDF::URI" do
+      expect(subject.send(:type_to_uri, "http://example.com/CustomURI" )).to eq(::RDF::URI("http://example.com/CustomURI"))
+    end
+  end
+
+end

data/spec/hydra/works/services/generic_file/upload_file_spec.rb

@@ -2,39 +2,45 @@ require 'spec_helper'
 
 describe Hydra::Works::UploadFileToGenericFile do
 
-  let(:generic_work)        { Hydra::Works::GenericWork::Base.create }
-  let(:generic_file)        { Hydra::Works::GenericFile::Base.create }
-  let(:filename)            { "sample-file.pdf" }
-  let(:file)                { File.join(fixture_path, filename) }
-  let(:updated_filename)    { "updated-file.txt"}
-  let(:updated_file)        { File.join(fixture_path, updated_filename) }
+  let(:generic_work)        { Hydra::Works::GenericWork::Base.new }
+  let(:generic_file)        { Hydra::Works::GenericFile::Base.new }
+  let(:file)                { File.open(File.join(fixture_path, "sample-file.pdf")) }
+  let(:updated_file)        { File.open(File.join(fixture_path, "updated-file.txt")) }
   let(:mime_type)           { "application/pdf" }
-  let(:updated_mime_type)   { "text/plain" }  
+  let(:original_name)       { "my_original.pdf" }
+  let(:updated_mime_type)   { "text/plain" }
+  let(:updated_name)        { "my_updated.txt" }
   let(:additional_services) { [Hydra::Works::GenerateThumbnail] }
 
-  context "without a proper generic file" do
-    let(:error_message) { "supplied object must be a generic file" }
-    it "raises an error" do
-      expect( lambda { described_class.call(generic_work, file) }).to raise_error(ArgumentError, error_message)
+  context "when you provide mime_type and original_name, etc" do
+    it "uses the provided values" do
+      expect(Hydra::Works::AddFileToGenericFile).to receive(:call).with(generic_file, file, :original_file, update_existing: true, versioning: true )
+      described_class.call(generic_file, file )
     end
   end
 
-  context "without a proper path" do
-    let(:error_message) { "supplied path must be a string" }
+  # Duplicate test from add_file_spec
+  context "without a proper generic file" do
+    let(:error_message) { "supplied object must be a generic file" }
     it "raises an error" do
-      expect( lambda { described_class.call(generic_file, ["this isn't a path"]) }).to raise_error(ArgumentError, error_message)
+      expect( lambda { described_class.call(generic_work, file) }).to raise_error(ArgumentError, error_message)
     end
   end
 
-  context "with a non-existent file" do
-    let(:error_message) { "supplied path to file does not exist" }
+  # Duplicate test from add_file_spec
+  context "without file that responds to read." do
+    let(:error_message) { "supplied file must respond to read" }
     it "raises an error" do
-      expect( lambda { described_class.call(generic_file, "/i/do/not/exist") }).to raise_error(ArgumentError, error_message)
+      expect( lambda { described_class.call(generic_file, ["this does not respond to read."]) }).to raise_error(ArgumentError, error_message)
     end
   end
 
   context "with an empty generic file" do
-    before { described_class.call(generic_file, file, additional_services) }
+    before do 
+      allow(file).to         receive(:mime_type).and_return(mime_type)
+      allow(file).to         receive(:original_name).and_return(original_name)
+      described_class.call(generic_file, file, additional_services: additional_services) 
+    end
 
     describe "the uploaded file" do
       subject { generic_file.original_file }
@@ -45,38 +51,49 @@ describe Hydra::Works::UploadFileToGenericFile do
         expect(subject.mime_type).to eql mime_type
       end
       it "has a name" do
-        expect(subject.original_name).to eql filename
+        expect(subject.original_name).to eql original_name
       end
     end
 
     describe "the generic file's generated files" do
       subject { generic_file }
-      it "has a thumbnail" do
+      it "has content and generated files" do
+        expect(subject.original_file.content).to start_with("%PDF-1.3")
+        expect(subject.original_file.mime_type).to eql mime_type
+        expect(subject.original_file.original_name).to eql original_name
         expect(subject.thumbnail.content).not_to be_nil
       end
     end
   end
 
-  context "when replacing an existing file" do
+  context "when updating an existing file" do
+    let(:additional_services) { [] }
+
     before do
-      described_class.call(generic_file, file, additional_services)
-      described_class.call(generic_file, updated_file, additional_services, replace: true)
-      generic_file.reload
+      allow(file).to         receive(:mime_type).and_return(mime_type)
+      allow(file).to         receive(:original_name).and_return(original_name)
+      allow(updated_file).to         receive(:mime_type).and_return(updated_mime_type)
+      allow(updated_file).to         receive(:original_name).and_return(updated_name)
+
+      described_class.call(generic_file, file, additional_services: additional_services)
+      described_class.call(generic_file, updated_file, additional_services: additional_services, update_existing: true)
     end
 
     describe "the new file" do
       subject { generic_file.original_file }
       it "has updated content" do
-        expect(subject.content).to eql File.open(updated_file).read
+        updated_file.rewind
+        expect(subject.content).to eql updated_file.read
       end
       it "has an updated name" do
-        expect(subject.original_name).to eql updated_filename
+        expect(subject.original_name).to eql updated_name
       end
       it "has a updated mime type" do
         expect(subject.mime_type).to eql updated_mime_type
-      end 
+        expect(subject.versions.all.count).to eql 2
+      end
     end
   end
 
 end
-  
+  

data/spec/hydra/works/services/persist_derivatives_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Hydra::Works::PersistDerivative do
+
+  describe 'thumbnail generation' do
+    before do
+      file = File.open(File.join(fixture_path, file_name), 'r')
+      Hydra::Works::UploadFileToGenericFile.call(generic_file, file)
+      allow_any_instance_of(Hydra::Works::GenericFile::Base).to receive(:mime_type).and_return(mime_type)
+      generic_file.save!
+    end
+
+    context 'with a video (.avi) file' do
+      let(:mime_type) { 'video/avi' }
+      let(:file_name) { 'countdown.avi' }
+      let(:generic_file) { Hydra::Works::GenericFile::Base.new }
+
+      it 'lacks a thumbnail' do
+        expect(generic_file.thumbnail).to be_nil
+      end
+
+      it 'generates a thumbnail derivative', unless: ENV['CI'] do
+        generic_file.create_derivatives
+        expect(generic_file.thumbnail).to have_content
+        expect(generic_file.thumbnail.mime_type).to eq('image/jpeg')
+      end
+    end
+
+    context 'with an image file' do
+      let(:mime_type) { 'image/png' }
+      let(:file_name) { 'world.png' }
+      let(:generic_file) { Hydra::Works::GenericFile::Base.new }
+
+      it 'lacks a thumbnail' do
+        expect(generic_file.thumbnail).to be_nil
+      end
+
+      it 'uses PersistDerivative service to generate a thumbnail derivative' do
+        generic_file.create_derivatives
+        expect(Hydra::Derivatives.output_file_service).to eq(Hydra::Works::PersistDerivative)
+        expect(generic_file.thumbnail).to have_content
+        expect(generic_file.thumbnail.mime_type).to eq('image/jpeg')
+      end
+    end
+
+    context 'with an audio (.wav) file' do
+      let(:mime_type) { 'audio/wav' }
+      let(:file_name) { 'piano_note.wav' }
+      let(:generic_file) { Hydra::Works::GenericFile::Base.new }
+
+      it 'lacks a thumbnail' do
+        expect(generic_file.thumbnail).to be_nil
+      end
+
+      it 'does not generate a thumbnail when derivatives are created', unless: ENV['CI'] do
+        generic_file.create_derivatives
+        expect(generic_file.thumbnail).to be_nil
+      end
+    end
+
+    context 'with an image (.jp2) file' do
+      let(:mime_type) { 'image/jp2' }
+      let(:file_name) { 'image.jp2' }
+      let(:generic_file) { Hydra::Works::GenericFile::Base.new }
+
+      it 'lacks a thumbnail' do
+        expect(generic_file.thumbnail).to be_nil
+      end
+
+      it 'generates a thumbnail on job run' do
+        generic_file.create_derivatives
+        expect(generic_file.thumbnail).to have_content
+        expect(generic_file.thumbnail.mime_type).to eq('image/jpeg')
+      end
+    end
+
+    context 'with an office document (.docx) file' do
+      let(:mime_type) { 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' }
+      let(:file_name) { 'charter.docx' }
+      let(:generic_file) { Hydra::Works::GenericFile::Base.new }
+
+      it 'lacks a thumbnail' do
+        expect(generic_file.thumbnail).to be_nil
+      end
+
+      it 'generates a thumbnail on job run', unless: ENV['CI'] do
+        generic_file.create_derivatives
+        expect(generic_file.thumbnail).to have_content
+        expect(generic_file.thumbnail.mime_type).to eq('image/jpeg')
+      end
+    end
+  end
+end

data/spec/hydra/works_spec.rb

@@ -2,91 +2,91 @@ require 'spec_helper'
 
 describe Hydra::Works do
 
-  let(:works_coll)   { Hydra::Works::Collection.create }
-  let(:works_gwork)  { Hydra::Works::GenericWork::Base.create }
-  let(:works_gfile)  { Hydra::Works::GenericFile::Base.create }
+  let(:works_coll)   { Hydra::Works::Collection.new }
+  let(:works_gwork)  { Hydra::Works::GenericWork::Base.new }
+  let(:works_gfile)  { Hydra::Works::GenericFile::Base.new }
 
-  let(:pcdm_coll)  { Hydra::PCDM::Collection.create }
-  let(:pcdm_obj)   { Hydra::PCDM::Object.create }
+  let(:pcdm_coll)  { Hydra::PCDM::Collection.new }
+  let(:pcdm_obj)   { Hydra::PCDM::Object.new }
   let(:pcdm_file)  { Hydra::PCDM::File.new }
 
   describe 'Validations' do
 
-    describe "#collection?" do
+    describe "#works_collection?" do
       it "should return true for a works collection" do
-        expect( Hydra::Works.collection? works_coll ).to be true
+        expect( works_coll.works_collection? ).to be true
       end
 
       it "should return false for a works generic work" do
-        expect( Hydra::Works.collection? works_gwork ).to be false
+        expect( works_gwork.works_collection? ).to be false
       end
 
       it "should return false for a works generic file" do
-        expect( Hydra::Works.collection? works_gfile ).to be false
+        expect( works_gfile.works_collection? ).to be false
       end
 
-      it "should return false for a pcdm collection" do
-        expect( Hydra::Works.collection? pcdm_coll ).to be false
+      it "should return that method is not available for pcdm a collection" do
+        expect(pcdm_coll).not_to respond_to(:works_collection?)
       end
 
-      it "should return false for a pcdm object" do
-        expect( Hydra::Works.collection? pcdm_obj ).to be false
+      it "should return that method is not available for a pcdm object" do
+        expect(pcdm_obj).not_to respond_to(:works_collection?)
       end
 
-      it "should return false for a pcdm file" do
-        expect( Hydra::Works.collection? pcdm_file ).to be false
+      it "should return that method is not available for a pcdm file" do
+        expect(pcdm_file).not_to respond_to(:works_collection?)
       end
     end
 
-    describe "#generic_work?" do
+    describe "#works_generic_work?" do
       it "should return false for a works collection" do
-        expect( Hydra::Works.generic_work? works_coll ).to be false
+        expect( works_coll.works_generic_work? ).to be false
       end
 
       it "should return true for a works generic work" do
-        expect( Hydra::Works.generic_work? works_gwork ).to be true
+        expect( works_gwork.works_generic_work? ).to be true
       end
 
       it "should return false for a works generic file" do
-        expect( Hydra::Works.generic_work? works_gfile ).to be false
+        expect( works_gfile.works_generic_work? ).to be false
       end
 
-      it "should return false for a pcdm collection" do
-        expect( Hydra::Works.generic_work? pcdm_coll ).to be false
+      it "should return that method is not available for a pcdm collection" do
+        expect(pcdm_coll).not_to respond_to(:works_generic_work?)
       end
 
-      it "should return false for a pcdm object" do
-        expect( Hydra::Works.generic_work? pcdm_obj ).to be false
+      it "should return that method is not available for a pcdm object" do
+        expect(pcdm_obj).not_to respond_to(:works_generic_work?)
       end
 
-      it "should return false for a pcdm file" do
-        expect( Hydra::Works.generic_work? pcdm_file ).to be false
+      it "should return that method is not available for a pcdm file" do
+        expect(pcdm_file).not_to respond_to(:works_generic_work?)
       end
     end
 
-    describe "#generic_file?" do
+    describe "#works_generic_file?" do
       it "should return false for a works collection" do
-        expect( Hydra::Works.generic_file? works_coll ).to be false
+        expect( works_coll.works_generic_file? ).to be false
       end
 
       it "should return false for a works generic work" do
-        expect( Hydra::Works.generic_file? works_gwork ).to be false
+        expect( works_gwork.works_generic_file? ).to be false
       end
 
       it "should return true for a works generic file" do
-        expect( Hydra::Works.generic_file? works_gfile ).to be true
+        expect( works_gfile.works_generic_file? ).to be true
       end
 
-      it "should return false for a pcdm collection" do
-        expect( Hydra::Works.generic_file? pcdm_coll ).to be false
+      it "should return that method is not available for a pcdm collection" do
+        expect(pcdm_coll).not_to respond_to(:works_generic_file?)
       end
 
-      it "should return false for a pcdm object" do
-        expect( Hydra::Works.generic_file? pcdm_obj ).to be false
+      it "should return that method is not available for a pcdm object" do
+        expect(pcdm_obj).not_to respond_to(:works_generic_file?)
       end
 
-      it "should return false for a pcdm file" do
-        expect( Hydra::Works.generic_file? pcdm_file ).to be false
+      it "should return that method is not available for a pcdm file" do
+        expect(pcdm_file).not_to respond_to(:works_generic_file?)
       end
     end
   end