hydra-works 0.1.0 → 0.2.0

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

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Hydra::Works::FullTextExtractionService do
+  let(:generic_file) { Hydra::Works::GenericFile::Base.new }
+
+  describe 'integration test' do
+    before do
+      Hydra::Works::UploadFileToGenericFile.call(generic_file, File.open(File.join(fixture_path, 'sample-file.pdf')))
+    end
+    subject { described_class.run(generic_file) }
+    it 'extracts fulltext and stores the results' do
+      expect(subject).to include('This is some original content')
+    end
+  end
+
+  describe "run" do
+    let(:generic_file) { double(id: '123') }
+    subject { described_class.run(generic_file) }
+
+    context "when it is successful" do
+      before do
+        allow_any_instance_of(described_class).to receive(:fetch).and_return('{"":"one two three"}')
+      end
+      it { is_expected.to eq 'one two three' }
+    end
+
+    context "when solr raises an error" do
+      before do
+        allow_any_instance_of(described_class).to receive(:fetch).and_raise(Hydra::Works::FullTextExtractionError.new, "Solr failed")
+      end
+      it "raises an error" do
+        expect { subject }.to raise_error Hydra::Works::FullTextExtractionError, 'Solr failed'
+      end
+    end
+
+    context "network error" do
+      before do
+        allow_any_instance_of(described_class).to receive(:fetch).and_raise(Errno::ECONNRESET)
+      end
+      it "raises an error" do
+        expect { subject }.to raise_error Hydra::Works::FullTextExtractionError, 'Error extracting content from 123: #<Errno::ECONNRESET: Connection reset by peer>'
+      end
+    end
+  end
+
+  describe "fetch" do
+    let(:generic_file) { double('generic file', id: '123', original_file: original) }
+    let(:original) { double(content: content, size: 13, mime_type: 'text/plain') }
+    let(:service) { described_class.new(generic_file) }
+    subject { service.fetch }
+    let(:request) { double }
+    let(:response_body) { 'returned by Solr' }
+    let(:resp) { double(code: '200', body: response_body) }
+    let(:uri) { URI('http://example.com:99/solr/update') }
+    let(:content) { 'file contents' }
+
+    before do
+      allow(service).to receive(:uri).and_return(URI('http://example.com:99/solr/update'))
+      allow(Net::HTTP).to receive(:new).with('example.com', 99).and_return(request)
+    end
+
+    context "that is successful" do
+      let(:resp) { double(code: '200', body: response_body) }
+      it "calls the extraction service" do
+        expect(request).to receive(:post).with('http://example.com:99/solr/update', content, "Content-Type" => "text/plain;charset=utf-8", "Content-Length" => "13").and_return(resp)
+        expect(subject).to eq response_body
+      end
+    end
+
+    context "that fails" do
+      let(:resp) { double(code: '500', body: response_body) }
+      it "raises an error" do
+        expect(request).to receive(:post).with('http://example.com:99/solr/update', content, "Content-Type" => "text/plain;charset=utf-8", "Content-Length" => "13").and_return(resp)
+        expect { subject }.to raise_error Hydra::Works::FullTextExtractionError, "Solr Extract service was unsuccessful. 'http://example.com:99/solr/update' returned code 500 for 123\nreturned by Solr"
+      end
+    end
+  end
+
+  describe "uri" do
+    let(:generic_file) { double }
+    let(:service) { described_class.new(generic_file) }
+    subject { service.uri }
+
+    it "points at the extraction service" do
+      expect(subject).to be_kind_of URI
+      expect(subject.to_s).to end_with '/update/extract?extractOnly=true&wt=json&extractFormat=text'
+    end
+  end
+end

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

@@ -1,110 +1,108 @@
 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(: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(:type)                { ::RDF::URI('http://pcdm.org/use#ExtractedText') }
   let(:update_existing)     { true }
-  let(:mime_type)           { "application/pdf" }
+  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
+  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
+  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
+    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
+  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)
+      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
+    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)
+  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
+  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")
+    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
+  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")
+      expect(generic_file.extracted_text.content).to start_with('%PDF-1.3')
     end
   end
 
-  context "when :versioning => true" do
+  context 'when :versioning => true' do
     let(:type)        { :original_file }
     let(:versioning)  { true }
     subject     { generic_file }
-    it "updates the file and creates a version" do
+    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")
+      expect(subject.original_file.content).to start_with('%PDF-1.3')
     end
-    context "and there are already versions" do
+    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
+      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
+  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
+    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")
+      expect(subject.original_file.content).to start_with('%PDF-1.3')
     end
   end
 
-  context "type_to_uri" do
+  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"))
+    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/generate/thumbnail_spec.rb

@@ -1,21 +1,19 @@
 require 'spec_helper'
 
 describe Hydra::Works::GenerateThumbnail do
-
-  context "when the object has no original file" do
-    let(:error_message) { "object has no content at original_file from which to generate a thumbnail" }
-    let(:object) { double("object", original_file: nil ) }
-    it "raises an error" do
-      expect(lambda{ described_class.call(object) }).to raise_error(ArgumentError, error_message)
+  context 'when the object has no original file' do
+    let(:error_message) { 'object has no content at original_file from which to generate a thumbnail' }
+    let(:object) { double('object', original_file: nil) }
+    it 'raises an error' do
+      expect(-> { described_class.call(object) }).to raise_error(ArgumentError, error_message)
     end
   end
 
-  context "when the object has no content at specified location" do
-    let(:error_message) { "object has no content at my_location from which to generate a thumbnail" }
-    let(:object) { double("object", my_location: nil ) }
-    it "raises an error" do
-      expect(lambda{ described_class.call(object, content: :my_location) }).to raise_error(ArgumentError, error_message)
+  context 'when the object has no content at specified location' do
+    let(:error_message) { 'object has no content at my_location from which to generate a thumbnail' }
+    let(:object) { double('object', my_location: nil) }
+    it 'raises an error' do
+      expect(-> { described_class.call(object, content: :my_location) }).to raise_error(ArgumentError, error_message)
     end
   end
-
 end

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

@@ -1,64 +1,63 @@
 require 'spec_helper'
 
 describe Hydra::Works::UploadFileToGenericFile do
-
   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(:original_name)       { "my_original.pdf" }
-  let(:updated_mime_type)   { "text/plain" }
-  let(:updated_name)        { "my_updated.txt" }
+  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(:original_name)       { 'my_original.pdf' }
+  let(:updated_mime_type)   { 'text/plain' }
+  let(:updated_name)        { 'my_updated.txt' }
   let(:additional_services) { [Hydra::Works::GenerateThumbnail] }
 
-  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 )
+  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
 
   # 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_work, file) }).to raise_error(ArgumentError, error_message)
+  context 'without a proper generic file' do
+    let(:error_message) { 'supplied object must be a generic file' }
+    it 'raises an error' do
+      expect(-> { described_class.call(generic_work, file) }).to raise_error(ArgumentError, error_message)
     end
   end
 
   # 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, ["this does not respond to read."]) }).to raise_error(ArgumentError, error_message)
+  context 'without file that responds to read.' do
+    let(:error_message) { 'supplied file must respond to read' }
+    it 'raises an error' do
+      expect(-> { 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 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) 
+  context 'with an empty generic file' 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, additional_services: additional_services)
     end
 
-    describe "the uploaded file" do
+    describe 'the uploaded file' do
       subject { generic_file.original_file }
-      it "has content" do
-        expect(subject.content).to start_with("%PDF-1.3")
+      it 'has content' do
+        expect(subject.content).to start_with('%PDF-1.3')
       end
-      it "has a mime type" do
+      it 'has a mime type' do
         expect(subject.mime_type).to eql mime_type
       end
-      it "has a name" do
+      it 'has a name' do
         expect(subject.original_name).to eql original_name
       end
     end
 
     describe "the generic file's generated files" do
       subject { generic_file }
-      it "has content and generated files" do
-        expect(subject.original_file.content).to start_with("%PDF-1.3")
+      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
@@ -66,34 +65,32 @@ describe Hydra::Works::UploadFileToGenericFile do
     end
   end
 
-  context "when updating an existing file" do
+  context 'when updating an existing file' do
     let(:additional_services) { [] }
 
     before do
-      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)
+      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
+    describe 'the new file' do
       subject { generic_file.original_file }
-      it "has updated content" do
+      it 'has updated content' do
         updated_file.rewind
         expect(subject.content).to eql updated_file.read
       end
-      it "has an updated name" do
+      it 'has an updated name' do
         expect(subject.original_name).to eql updated_name
       end
-      it "has a updated mime type" do
+      it 'has a updated mime type' do
         expect(subject.mime_type).to eql updated_mime_type
         expect(subject.versions.all.count).to eql 2
       end
     end
   end
-
 end
-  

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

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Hydra::Works::PersistDerivative do
-
   describe 'thumbnail generation' do
     before do
       file = File.open(File.join(fixture_path, file_name), 'r')
@@ -37,7 +36,7 @@ describe Hydra::Works::PersistDerivative do
 
       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(Hydra::Derivatives.output_file_service).to eq(described_class)
         expect(generic_file.thumbnail).to have_content
         expect(generic_file.thumbnail.mime_type).to eq('image/jpeg')
       end
@@ -90,4 +89,4 @@ describe Hydra::Works::PersistDerivative do
       end
     end
   end
-end
+end

data/spec/hydra/works_spec.rb

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