ddr-models 2.6.2 → 2.7.0.rc1

data/spec/models/has_children_spec.rb

@@ -14,12 +14,12 @@ module Ddr::Models
         let(:child2) { FactoryGirl.create(:item) }
         before do
           child1.local_id = "test002"
-          child1.save
+          child1.save!
           child2.local_id = "test001"
-          child2.save
+          child2.save!
           subject.children << child1
           subject.children << child2
-          subject.save
+          subject.save!
         end
         it "should return the first child as sorted by local ID" do
           expect(subject.first_child).to eq(child2)
@@ -27,5 +27,56 @@ module Ddr::Models
       end
     end
 
+    describe "#default_structure" do
+      describe "when the object has no children" do
+        it "should be nil" do
+          expect(subject.default_structure).to be_nil
+        end
+      end
+      describe "when the object has children" do
+        let(:child1) { FactoryGirl.create(:item) }
+        let(:child2) { FactoryGirl.create(:item) }
+        let(:expected) do
+          xml = <<-EOS
+            <mets xmlns="http://www.loc.gov/METS/" xmlns:xlink="http://www.w3.org/1999/xlink">
+              <metsHdr>
+                <agent ROLE="#{Ddr::Models::Structures::Agent::ROLE_CREATOR}">
+                  <name>#{Ddr::Models::Structures::Agent::NAME_REPOSITORY_DEFAULT}</name>
+                </agent>
+              </metsHdr>
+              <structMap TYPE="#{Ddr::Models::Structure::TYPE_DEFAULT}">
+                <div ORDER="1">
+                  <mptr LOCTYPE="ARK" xlink:href="ark:/99999/fk4bbb" />
+                </div>
+                <div ORDER="2">
+                  <mptr LOCTYPE="ARK" xlink:href="ark:/99999/fk4aaa" />
+                </div>
+              </structMap>
+            </mets>
+          EOS
+          xml
+        end
+        before do
+          child1.local_id = "test002"
+          child1.permanent_id = "ark:/99999/fk4aaa"
+          child1.save!
+          child2.local_id = "test001"
+          child2.permanent_id = "ark:/99999/fk4bbb"
+          child2.save!
+          subject.children << child1
+          subject.children << child2
+          subject.save!
+          allow(SecureRandom).to receive(:uuid).and_return("abc-def", "ghi-jkl")
+        end
+        after do
+          child1.destroy
+          child2.destroy
+        end
+        it "should be the appropriate structure" do
+          expect(subject.default_structure.to_xml).to be_equivalent_to(expected)
+        end
+      end
+    end
+
   end
 end

data/spec/models/has_struct_metadata_spec.rb

@@ -1,48 +1,42 @@
-require 'spec_helper'
+module Ddr::Models
+  RSpec.describe HasStructMetadata, type: :model, structural_metadata: true do
 
-module Ddr
-  module Models
-    RSpec.describe HasStructMetadata, type: :model, structural_metadata: true do
+    let(:item) { Item.new(pid: 'test:2') }
 
-      let(:item) { Item.new(pid: 'test:2') }
-
-      describe "#structure" do
-        context "no existing structural metadata" do
-          it "should return nil" do
-            expect(item.structure).to eq(nil)
-          end
-        end
-        context "existing structural metadata" do
-          before { item.datastreams[Ddr::Datastreams::STRUCT_METADATA].content = simple_structure }
-          it "should return the structural metadata" do
-            expect(item.structure.to_xml).to be_equivalent_to(simple_structure)
-          end
+    describe "#structures" do
+      context "no existing structural metadata" do
+        it "should return nil" do
+          expect(item.structure).to eq(nil)
         end
       end
-
-      describe "#build_default_structure" do
-        let(:components) { [ Component.new(pid: 'test:5', identifier: [ 'abc002' ]),
-                             Component.new(pid: 'test:6', identifier: [ 'abc001' ]),
-                             Component.new(pid: 'test:7', identifier: [ 'abc003' ])
-                           ] }
-        let(:expected) { FactoryGirl.build(:simple_structure) }
-        before { allow(item).to receive(:find_children) { simple_structure_query_response } }
-        it "should build the appropriate structural metadata" do
-          results = item.build_default_structure
-          expect(results).to be_equivalent_to(expected)
+      context "existing structural metadata" do
+        before { item.datastreams[Ddr::Datastreams::STRUCT_METADATA].content = simple_structure_xml }
+        it "should return the structural metadata" do
+          expect(item.structure.to_xml).to be_equivalent_to(simple_structure_xml)
         end
       end
+    end
 
-      describe "indexing" do
-        let(:expected_json) { multiple_struct_maps_structure_to_json }
-        before { item.datastreams[Ddr::Datastreams::STRUCT_METADATA].content = multiple_struct_maps_structure }
-        it "should index the JSON representation of the structure" do
-          indexing = item.to_solr
-          expect(indexing.keys).to include(Ddr::Index::Fields::STRUCT_MAPS)
-          expect(indexing[Ddr::Index::Fields::STRUCT_MAPS]).to eq(expected_json)
-        end
+    describe "indexing" do
+      let(:expected_json) { nested_structure_to_json }
+      before do
+        item.datastreams[Ddr::Datastreams::STRUCT_METADATA].content = nested_structure_xml
+        flocat_x = instance_double("Structures::FLocat", effective_use: 'foo')
+        flocat_y = instance_double("Structures::FLocat", effective_use: 'bar')
+        flocat_z = instance_double("Structures::FLocat", effective_use: 'baz')
+        file_a = instance_double("Structures::File", repo_ids: [ 'test:7' ], flocats: [ flocat_x ])
+        file_b = instance_double("Structures::File", repo_ids: [ 'test:8' ], flocats: [ flocat_y ])
+        file_c = instance_double("Structures::File", repo_ids: [ 'test:9' ], flocats: [ flocat_z ])
+        allow(Structures::File).to receive(:find).with(an_instance_of(Ddr::Models::Structure), 'abc') { file_a }
+        allow(Structures::File).to receive(:find).with(an_instance_of(Ddr::Models::Structure), 'def') { file_b }
+        allow(Structures::File).to receive(:find).with(an_instance_of(Ddr::Models::Structure), 'ghi') { file_c }
+      end
+      it "should index the JSON representation of the structures" do
+        indexing = item.to_solr
+        expect(indexing.keys).to include(Ddr::Index::Fields::STRUCTURE)
+        expect(indexing[Ddr::Index::Fields::STRUCTURE]).to eq(expected_json)
       end
-
     end
+
   end
-end
+end

data/spec/models/indexing_spec.rb

@@ -15,13 +15,13 @@ module Ddr::Models
         obj.adminMetadata.doi << "http://doi.org/10.1000/182"
         obj.aspace_id = "aspace_dccea43034e1b8261e14cf999e86449d"
         obj.display_format = "Image"
+        obj.ingested_by = "foo@bar.com"
+        obj.ingestion_date = "2017-01-13T18:55:29Z"
         obj.license = "cc-by-nc-nd-40"
         obj.local_id = "foo"
         obj.permanent_id = "ark:/99999/fk4zzz"
         obj.permanent_url = "http://id.library.duke.edu/ark:/99999/fk4zzz"
-        obj.rightsMetadata.license.description = ["License Description"]
-        obj.rightsMetadata.license.title = ["License Title"]
-        obj.rightsMetadata.license.url = ["http://library.duke.edu"]
+        obj.rights_note = ["Public domain"]
         obj.roles.grant role1, role2, role3, role4
         obj.set_desc_metadata_values(:arranger, "Arranger Value")
         obj.set_desc_metadata_values(:category, "Category Value")
@@ -34,6 +34,8 @@ module Ddr::Models
         obj.set_desc_metadata_values(:illustrator, "Illustrator Value")
         obj.set_desc_metadata_values(:instrumentation, "Instrumentation Value")
         obj.set_desc_metadata_values(:interviewer_name, "Interviewer Name Value")
+        obj.set_desc_metadata_values(:isFormatOf, "ark:/99999/fk4aaa")
+        obj.set_desc_metadata_values(:isPartOf, "RL10059CS1010")
         obj.set_desc_metadata_values(:lithographer, "Lithographer Value")
         obj.set_desc_metadata_values(:lyricist, "Lyricist Value")
         obj.set_desc_metadata_values(:medium, "Medium Value")
@@ -56,6 +58,7 @@ module Ddr::Models
       its([Indexing::CATEGORY_FACET]) { is_expected.to eq(["Category Value"]) }
       its([Indexing::COMPANY_FACET]) { is_expected.to eq(["Company Value"]) }
       its([Indexing::COMPOSER_FACET]) { is_expected.to eq(["Composer Value"]) }
+      its([Indexing::DC_IS_PART_OF]) { is_expected.to eq(["RL10059CS1010"])}
       its([Indexing::DISPLAY_FORMAT]) { is_expected.to eq("Image") }
       its([Indexing::DOI]) { is_expected.to eq(["http://doi.org/10.1000/182"]) }
       its([Indexing::ENGRAVER_FACET]) { is_expected.to eq(["Engraver Value"]) }
@@ -63,12 +66,12 @@ module Ddr::Models
       its([Indexing::GENRE_FACET]) { is_expected.to eq(["Genre Value"]) }
       its([Indexing::ILLUSTRATED_FACET]) { is_expected.to eq(["Illustrated Value"]) }
       its([Indexing::ILLUSTRATOR_FACET]) { is_expected.to eq(["Illustrator Value"]) }
+      its([Indexing::INGESTED_BY]) { is_expected.to eq("foo@bar.com") }
+      its([Indexing::INGESTION_DATE]) { is_expected.to eq("2017-01-13T18:55:29Z") }
       its([Indexing::INSTRUMENTATION_FACET]) { is_expected.to eq(["Instrumentation Value"]) }
       its([Indexing::INTERVIEWER_NAME_FACET]) { is_expected.to eq(["Interviewer Name Value"]) }
+      its([Indexing::IS_FORMAT_OF]) { is_expected.to eq(["ark:/99999/fk4aaa"]) }
       its([Indexing::LICENSE]) { is_expected.to eq("cc-by-nc-nd-40") }
-      its([Indexing::LICENSE_DESCRIPTION]) { is_expected.to eq("License Description") }
-      its([Indexing::LICENSE_TITLE]) { is_expected.to eq("License Title") }
-      its([Indexing::LICENSE_URL]) { is_expected.to eq("http://library.duke.edu") }
       its([Indexing::LITHOGRAPHER_FACET]) { is_expected.to eq(["Lithographer Value"]) }
       its([Indexing::LOCAL_ID]) { is_expected.to eq("foo") }
       its([Indexing::LYRICIST_FACET]) { is_expected.to eq(["Lyricist Value"]) }
@@ -82,12 +85,14 @@ module Ddr::Models
       its([Indexing::PRODUCT_FACET]) { is_expected.to eq(["Product Value"]) }
       its([Indexing::PUBLICATION_FACET]) { is_expected.to eq(["Publication Value"]) }
       its([Indexing::RESOURCE_ROLE]) { is_expected.to contain_exactly(role1.agent.first) }
+      its([Indexing::RIGHTS_NOTE]) { is_expected.to eq(["Public domain"]) }
       its([Indexing::ROLL_NUMBER_FACET]) { is_expected.to eq(["10"]) }
       its([Indexing::SETTING_FACET]) { is_expected.to eq(["Setting Value"]) }
       its([Indexing::SUBSERIES_FACET]) { is_expected.to eq(["Subseries Value"]) }
       its([Indexing::TEMPORAL_FACET]) { is_expected.to eq(["Temporal Value"]) }
       its([Indexing::TONE_FACET]) { is_expected.to eq(["Tone Value"]) }
       its([Indexing::VOLUME_FACET]) { is_expected.to eq(["100"]) }
+
     end
 
     describe "content-bearing object indexing" do

data/spec/models/item_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 RSpec.describe Item, type: :model do
 
   it_behaves_like "a DDR model"
@@ -17,18 +15,34 @@ RSpec.describe Item, type: :model do
 
     before {
       children[0].extractedText.content = text1
-      children[0].save
+      children[0].save!
       children[1].extractedText.content = text2
-      children[1].save
+      children[1].save!
       children[2].extractedText.content = text3
-      children[2].save
+      children[2].save!
+      children[3].save!
+      children[4].save!
       subject.children = children
-      subject.save
+      subject.save!
     }
 
     it "indexes the combined text of its children" do
-      expect(subject.index_fields[Ddr::Index::Fields::ALL_TEXT]).to contain_exactly(text1.read, text2.read, text3.read)
+      expect(subject.index_fields[Ddr::Index::Fields::ALL_TEXT]).to contain_exactly(File.read(text1.path), File.read(text2.path), File.read(text3.path))
     end
   end
 
+  describe "content" do
+    its(:can_have_content?) { is_expected.to be false }
+    it { is_expected.to_not have_content }
+  end
+
+  describe "children" do
+    its(:can_have_children?) { is_expected.to be true }
+    it { is_expected.to_not have_children }
+    specify {
+      subject.children << Component.new
+      expect(subject).to have_children
+    }
+  end
+
 end

data/spec/models/permanent_id_spec.rb

@@ -39,12 +39,8 @@ module Ddr::Models
         allow(described_class.identifier_class).to receive(:mint) { id }
         allow(described_class.identifier_class).to receive(:find).with("foo") { id }
       end
-      after do
-        obj.permanent_id = nil
-        obj.save!
-      end
       it "creates an update event" do
-        expect { described_class.assign!(obj) }.to change(Ddr::Events::UpdateEvent, :count).to(1)
+        expect { described_class.assign!(obj) }.to change(Ddr::Events::UpdateEvent, :count).by(1)
       end
     end
 

data/spec/models/solr_document_spec.rb

@@ -118,37 +118,16 @@ RSpec.describe SolrDocument, type: :model, contacts: true do
     end
   end
 
-  describe "#struct_maps" do
-    context "no indexed struct maps" do
-      it "should return an empty hash" do
-        expect(subject.struct_maps).to be_empty
-      end
-    end
-    context "indexed struct maps" do
-      before { subject[Ddr::Index::Fields::STRUCT_MAPS] = multiple_struct_maps_structure_to_json }
-      it "should return a hash of the struct maps" do
-        expect(subject.struct_maps).to eq(JSON.parse(multiple_struct_maps_structure_to_json))
-      end
-    end
-  end
-
-  describe "#struct_map" do
-    context "no indexed struct maps" do
+  describe "#structure" do
+    context "no indexed structures" do
       it "should return nil" do
-        expect(subject.struct_map('default')).to be_nil
+        expect(subject.structure).to be_nil
       end
     end
-    context "indexed struct maps" do
-      before { subject[Ddr::Index::Fields::STRUCT_MAPS] = multiple_struct_maps_structure_to_json }
-      context "requested struct map is indexed" do
-        it "should return the struct map" do
-          expect(subject.struct_map('default')).to eq(JSON.parse(multiple_struct_maps_structure_to_json)["default"])
-        end
-      end
-      context "requested struct map is not indexed" do
-        it "should raise a KeyError" do
-          expect { subject.struct_map('foo') }.to raise_error(KeyError)
-        end
+    context "indexed structure" do
+      before { subject[Ddr::Index::Fields::STRUCTURE] = simple_structure_to_json }
+      it "should return the structures map" do
+        expect(subject.structure).to eq(JSON.parse(simple_structure_to_json))
       end
     end
   end
@@ -194,28 +173,21 @@ RSpec.describe SolrDocument, type: :model, contacts: true do
         its(:multires_image_file_paths) { is_expected.to match([]) }
       end
       context "structural metadata" do
-        let(:struct_map) do
-          {"type"=>"default", "divs"=>
-            [{"id"=>"viccb010010010", "label"=>"1", "order"=>"1", "type"=>"Image", "fptrs"=>["test:5"], "divs"=>[]},
-             {"id"=>"viccb010020010", "label"=>"2", "order"=>"2", "type"=>"Image", "fptrs"=>["test:6"], "divs"=>[]},
-             {"id"=>"viccb010030010", "label"=>"3", "order"=>"3", "type"=>"Image", "fptrs"=>["test:7"], "divs"=>[]}]
-          }
-        end
-        before { allow(subject).to receive(:struct_map) { struct_map } }
+        before { allow(subject).to receive(:structure) { JSON.parse(simple_structure_to_json) } }
         context "no structural objects with multi-res images" do
           before do
-            allow(SolrDocument).to receive(:find).with('test:5') { double(multires_image_file_path: nil) }
-            allow(SolrDocument).to receive(:find).with('test:6') { double(multires_image_file_path: nil) }
             allow(SolrDocument).to receive(:find).with('test:7') { double(multires_image_file_path: nil) }
+            allow(SolrDocument).to receive(:find).with('test:8') { double(multires_image_file_path: nil) }
+            allow(SolrDocument).to receive(:find).with('test:9') { double(multires_image_file_path: nil) }
           end
           its(:multires_image_file_paths) { is_expected.to match([]) }
         end
         context "structural objects with multi-res images" do
           let(:expected_result) { [ "/path/file1.ptif", "/path/file2.ptif" ] }
           before do
-            allow(SolrDocument).to receive(:find).with('test:5') { double(multires_image_file_path: "/path/file1.ptif") }
-            allow(SolrDocument).to receive(:find).with('test:6') { double(multires_image_file_path: nil) }
-            allow(SolrDocument).to receive(:find).with('test:7') { double(multires_image_file_path: "/path/file2.ptif") }
+            allow(SolrDocument).to receive(:find).with('test:7') { double(multires_image_file_path: "/path/file1.ptif") }
+            allow(SolrDocument).to receive(:find).with('test:8') { double(multires_image_file_path: nil) }
+            allow(SolrDocument).to receive(:find).with('test:9') { double(multires_image_file_path: "/path/file2.ptif") }
           end
           its(:multires_image_file_paths) { is_expected.to match(expected_result) }
         end

data/spec/models/structure_spec.rb

@@ -1,30 +1,99 @@
 require 'spec_helper'
 require 'support/structural_metadata_helper'
 
-module Ddr
-  module Models
-    RSpec.describe Structure, type: :model, structural_metadata: true do
+module Ddr::Models
+  RSpec.describe Structure, type: :model, structural_metadata: true do
 
-      describe "#struct_maps" do
+    describe "#files" do
+      let(:structure) { FactoryGirl.build(:simple_structure)}
+      it "returns a hash of structure files" do
+        expect(structure.files.keys).to match_array([ 'abc', 'def', 'ghi' ])
+        structure.files.values.each do |value|
+          expect(value).to be_a(Structures::File)
+        end
+      end
+    end
+
+    describe "#uses" do
+      let(:structure) { FactoryGirl.build(:simple_structure)}
+      it "returns a hash of uses" do
+        expect(structure.uses.keys).to match_array([ 'foo', 'bar', 'baz' ])
+        expect(structure.uses['foo'].first.href).to eq('ark:/99999/fk4ab3')
+        expect(structure.uses['bar'].first.href).to eq('ark:/99999/fk4cd9')
+        expect(structure.uses['baz'].first.href).to eq('ark:/99999/fk4ef1')
+      end
+    end
+
+    describe "#creator" do
+      describe "structure has a metsHdr" do
+        let(:structure) { FactoryGirl.build(:simple_structure) }
+        it "returns the creator" do
+          expect(structure.creator).to eq("Sam Spade")
+        end
+      end
+      describe "structure does not have a metsHdr" do
         let(:structure) { FactoryGirl.build(:multiple_struct_maps_structure) }
-        let(:struct_maps) { structure.struct_maps }
-        it "should include struct divs for each struct map" do
-          expect(struct_maps.keys).to match_array([ 'default', 'reverse' ])
-          expect(struct_maps['default']).to be_a(Ddr::Models::StructDiv)
-          expect(struct_maps['reverse']).to be_a(Ddr::Models::StructDiv)
+        it "returns the creator" do
+          expect(structure.creator).to be nil
         end
       end
+    end
 
-      describe "#fptr_nodes" do
-        let(:structure) { FactoryGirl.build(:nested_structure) }
-        it "should return all fptr nodes" do
-          results = structure.fptr_nodes
-          expect(results.size).to eq(3)
-          ids = results.map { |entry| entry['CONTENTIDS'] }
-          expect(ids).to match_array([ 'info:fedora/test:5', 'info:fedora/test:6', 'info:fedora/test:7' ])
+    describe "#repository_maintained?" do
+      let(:structure) { FactoryGirl.build(:simple_structure)}
+      before do
+        allow(structure).to receive(:creator) { creator }
+      end
+      describe "maintained by the repository" do
+        let(:creator) { Ddr::Models::Structures::Agent::NAME_REPOSITORY_DEFAULT }
+        it "is true" do
+          expect(structure.repository_maintained?).to be true
         end
       end
+      describe "not maintained by the repository" do
+        let(:creator) { 'foo' }
+        it "is false" do
+          expect(structure.repository_maintained?).to be false
+        end
+      end
+    end
 
+    describe "#dereferenced_structure" do
+      describe "fptr case" do
+        let(:structure) { FactoryGirl.build(:nested_structure) }
+        let(:expected) { nested_structure_dereferenced_hash }
+        before do
+          flocat_x = instance_double("Structures::FLocat", effective_use: 'foo')
+          flocat_y = instance_double("Structures::FLocat", effective_use: 'bar')
+          flocat_z = instance_double("Structures::FLocat", effective_use: 'baz')
+          file_a = instance_double("Structures::File", repo_ids: [ 'test:7' ], flocats: [ flocat_x ])
+          file_b = instance_double("Structures::File", repo_ids: [ 'test:8' ], flocats: [ flocat_y ])
+          file_c = instance_double("Structures::File", repo_ids: [ 'test:9' ], flocats: [ flocat_z ])
+          allow(Structures::File).to receive(:find).with(an_instance_of(Ddr::Models::Structure), 'abc') { file_a }
+          allow(Structures::File).to receive(:find).with(an_instance_of(Ddr::Models::Structure), 'def') { file_b }
+          allow(Structures::File).to receive(:find).with(an_instance_of(Ddr::Models::Structure), 'ghi') { file_c }
+        end
+        it "returns the dereferenced structure" do
+          expect(structure.dereferenced_structure).to eq(expected)
+        end
+      end
+      describe "mptr case" do
+        let(:structure) { FactoryGirl.build(:nested_structure_mptr) }
+        let(:expected) { nested_structure_mptr_dereferenced_hash }
+        before do
+          solr_doc_a = instance_double("SolrDocument", id: 'test:7')
+          solr_doc_b = instance_double("SolrDocument", id: 'test:8')
+          solr_doc_c = instance_double("SolrDocument", id: 'test:9')
+          allow_any_instance_of(Ddr::Models::Structures::Mptr).to receive(:ark?) { true }
+          allow(::SolrDocument).to receive(:find_by_permanent_id).with('ark:/99999/fk4ab3') { solr_doc_a }
+          allow(::SolrDocument).to receive(:find_by_permanent_id).with('ark:/99999/fk4cd9') { solr_doc_b }
+          allow(::SolrDocument).to receive(:find_by_permanent_id).with('ark:/99999/fk4ef1') { solr_doc_c }
+        end
+        it "returns the dereferenced structure" do
+          expect(structure.dereferenced_structure).to eq(expected)
+        end
+      end
     end
+
   end
 end