ddr-models 2.11.0 → 3.0.0.alpha.1

data/spec/models/indexing_spec.rb

@@ -1,171 +1,34 @@
 module Ddr::Models
   RSpec.describe Indexing do
 
-    subject { obj.index_fields }
-
-    describe "general indexing" do
-      let(:obj) { FactoryGirl.build(:item) }
-
-      let(:role1) { FactoryGirl.build(:role, :curator, :person, :resource) }
-      let(:role2) { FactoryGirl.build(:role, :curator, :person, :policy) }
-      let(:role3) { FactoryGirl.build(:role, :editor, :group, :policy) }
-      let(:role4) { FactoryGirl.build(:role, :editor, :person, :policy) }
-
-      before do
-        obj.adminMetadata.doi << "http://doi.org/10.1000/182"
-        obj.affiliation << "Talk to me in the back alley."
-        obj.aleph_id = "lkheajklfwbsef"
-        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.rights_note = ["Public domain"]
-        obj.roles.grant role1, role2, role3, role4
-        obj.set_desc_metadata_values(:arranger, "Arranger Value")
-        obj.set_desc_metadata_values(:biblical_book, "Ecclesiastes")
-        obj.set_desc_metadata_values(:category, "Category Value")
-        obj.set_desc_metadata_values(:chapter_and_verse, "Ecclesiastes 3:19-4:3")
-        obj.set_desc_metadata_values(:company, "Company Value")
-        obj.set_desc_metadata_values(:composer, "Composer Value")
-        obj.set_desc_metadata_values(:engraver, "Engraver Value")
-        obj.set_desc_metadata_values(:folder, "Folder Value")
-        obj.set_desc_metadata_values(:genre, "Genre Value")
-        obj.set_desc_metadata_values(:illustrated, "Illustrated Value")
-        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")
-        obj.set_desc_metadata_values(:performer, "Performer Value")
-        obj.set_desc_metadata_values(:placement_company, "Placement Company Value")
-        obj.set_desc_metadata_values(:producer, "Producer Value")
-        obj.set_desc_metadata_values(:product, "Product Value")
-        obj.set_desc_metadata_values(:publication, "Publication Value")
-        obj.set_desc_metadata_values(:roll_number, "10")
-        obj.set_desc_metadata_values(:setting, "Setting Value")
-        obj.set_desc_metadata_values(:subseries, "Subseries Value")
-        obj.set_desc_metadata_values(:temporal, "Temporal Value")
-        obj.set_desc_metadata_values(:tone, "Tone Value")
-        obj.set_desc_metadata_values(:volume, "100")
-      end
-
-      specify {
-        expect(subject[Indexing::ACCESS_ROLE]).to eq(obj.roles.to_json)
-        expect(subject[Indexing::ADMIN_SET_TITLE]).to be_nil
-        expect(subject[Indexing::AFFILIATION]).to eq(["Talk to me in the back alley."])
-        expect(subject[Indexing::AFFILIATION_FACET]).to eq(["Talk to me in the back alley."])
-        expect(subject[Indexing::ALEPH_ID]).to eq "lkheajklfwbsef"
-        expect(subject[Indexing::ARRANGER_FACET]).to eq(["Arranger Value"])
-        expect(subject[Indexing::ASPACE_ID]).to eq("aspace_dccea43034e1b8261e14cf999e86449d")
-        expect(subject[Indexing::BIBLICAL_BOOK_FACET]).to eq(["Ecclesiastes"])
-        expect(subject[Indexing::CATEGORY_FACET]).to eq(["Category Value"])
-        expect(subject[Indexing::CHAPTER_AND_VERSE_FACET]).to eq(["Ecclesiastes 3:19-4:3"])
-        expect(subject[Indexing::COMPANY_FACET]).to eq(["Company Value"])
-        expect(subject[Indexing::COMPOSER_FACET]).to eq(["Composer Value"])
-        expect(subject[Indexing::DC_IS_PART_OF]).to eq(["RL10059CS1010"])
-        expect(subject[Indexing::DISPLAY_FORMAT]).to eq("Image")
-        expect(subject[Indexing::DOI]).to eq(["http://doi.org/10.1000/182"])
-        expect(subject[Indexing::ENGRAVER_FACET]).to eq(["Engraver Value"])
-        expect(subject[Indexing::FOLDER_FACET]).to eq(["Folder Value"])
-        expect(subject[Indexing::GENRE_FACET]).to eq(["Genre Value"])
-        expect(subject[Indexing::ILLUSTRATED_FACET]).to eq(["Illustrated Value"])
-        expect(subject[Indexing::ILLUSTRATOR_FACET]).to eq(["Illustrator Value"])
-        expect(subject[Indexing::INGESTED_BY]).to eq("foo@bar.com")
-        expect(subject[Indexing::INGESTION_DATE]).to eq("2017-01-13T18:55:29Z")
-        expect(subject[Indexing::INSTRUMENTATION_FACET]).to eq(["Instrumentation Value"])
-        expect(subject[Indexing::INTERVIEWER_NAME_FACET]).to eq(["Interviewer Name Value"])
-        expect(subject[Indexing::IS_FORMAT_OF]).to eq(["ark:/99999/fk4aaa"])
-        expect(subject[Indexing::LICENSE]).to eq("cc-by-nc-nd-40")
-        expect(subject[Indexing::LITHOGRAPHER_FACET]).to eq(["Lithographer Value"])
-        expect(subject[Indexing::LOCAL_ID]).to eq("foo")
-        expect(subject[Indexing::LYRICIST_FACET]).to eq(["Lyricist Value"])
-        expect(subject[Indexing::MEDIUM_FACET]).to eq(["Medium Value"])
-        expect(subject[Indexing::PERFORMER_FACET]).to eq(["Performer Value"])
-        expect(subject[Indexing::PERMANENT_ID]).to eq("ark:/99999/fk4zzz")
-        expect(subject[Indexing::PERMANENT_URL]).to eq("http://id.library.duke.edu/ark:/99999/fk4zzz")
-        expect(subject[Indexing::PLACEMENT_COMPANY_FACET]).to eq(["Placement Company Value"])
-        expect(subject[Indexing::POLICY_ROLE]).to contain_exactly(role2.agent.first, role3.agent.first, role4.agent.first)
-        expect(subject[Indexing::PRODUCER_FACET]).to eq(["Producer Value"])
-        expect(subject[Indexing::PRODUCT_FACET]).to eq(["Product Value"])
-        expect(subject[Indexing::PUBLICATION_FACET]).to eq(["Publication Value"])
-        expect(subject[Indexing::RESOURCE_ROLE]).to contain_exactly(role1.agent.first)
-        expect(subject[Indexing::RIGHTS_NOTE]).to eq(["Public domain"])
-        expect(subject[Indexing::ROLL_NUMBER_FACET]).to eq(["10"])
-        expect(subject[Indexing::SETTING_FACET]).to eq(["Setting Value"])
-        expect(subject[Indexing::STREAMABLE_MEDIA_TYPE]).to be_nil
-        expect(subject[Indexing::SUBSERIES_FACET]).to eq(["Subseries Value"])
-        expect(subject[Indexing::TEMPORAL_FACET]).to eq(["Temporal Value"])
-        expect(subject[Indexing::TONE_FACET]).to eq(["Tone Value"])
-        expect(subject[Indexing::VOLUME_FACET]).to eq(["100"])
-      }
-    end
+    let(:obj) { FactoryGirl.build(:item) }
 
-    describe "content-bearing object indexing" do
-      let(:obj) { FactoryGirl.create(:component) }
-      let!(:create_date) { Time.parse("2016-01-22T21:50:33Z") }
-      before {
-        allow(obj.content).to receive(:createDate) { create_date }
-      }
+    let(:role1) { FactoryGirl.build(:role, :curator, :person, :resource) }
+    let(:role2) { FactoryGirl.build(:role, :curator, :person, :policy) }
+    let(:role3) { FactoryGirl.build(:role, :editor, :group, :policy) }
+    let(:role4) { FactoryGirl.build(:role, :editor, :person, :policy) }
 
-      specify {
-        expect(subject[Indexing::CONTENT_CREATE_DATE]).to eq "2016-01-22T21:50:33Z"
-        expect(subject[Indexing::ATTACHED_FILES_HAVING_CONTENT]).to contain_exactly("content", "RELS-EXT", "descMetadata", "adminMetadata")
-        expect(subject[Indexing::CONTENT_SIZE]).to eq 230714
-        expect(subject[Indexing::CONTENT_SIZE_HUMAN]).to eq "225 KB"
-        expect(subject[Indexing::MEDIA_TYPE]).to eq "image/tiff"
-        expect(subject[Indexing::MEDIA_MAJOR_TYPE]).to eq "image"
-        expect(subject[Indexing::MEDIA_SUB_TYPE]).to eq "tiff"
-      }
+    subject { obj.index_fields }
 
-      describe "streamable object indexing" do
-        before {
-          obj.add_file(fixture_file_upload('bird.jpg', 'image/jpeg'), 'streamableMedia')
-          obj.save!
-        }
-        specify {
-          expect(subject[Indexing::STREAMABLE_MEDIA_TYPE]).to eq "image/jpeg"
-        }
-      end
+    before do
+      obj.license = "cc-by-nc-nd-40"
+      obj.local_id = "foo"
+      obj.doi << "http://doi.org/10.1000/182"
+      obj.permanent_id = "ark:/99999/fk4zzz"
+      obj.permanent_url = "http://id.library.duke.edu/ark:/99999/fk4zzz"
+      obj.display_format = "Image"
+      obj.roles.grant role1, role2, role3, role4
     end
 
-    describe "admin set title" do
-      subject { FactoryGirl.build(:item) }
-      let(:coll) { FactoryGirl.create(:collection) }
-      before do
-        subject.parent = coll
-        subject.admin_policy = coll
-      end
-      specify {
-        expect(subject.index_fields[Indexing::ADMIN_SET_TITLE]).to eq "Foo Admin Set"
-      }
-    end
+    its([Indexing::LICENSE]) { is_expected.to eq("cc-by-nc-nd-40") }
+    its([Indexing::LOCAL_ID]) { is_expected.to eq("foo") }
+    its([Indexing::DOI]) { is_expected.to eq(["http://doi.org/10.1000/182"]) }
+    its([Indexing::PERMANENT_ID]) { is_expected.to eq("ark:/99999/fk4zzz") }
+    its([Indexing::PERMANENT_URL]) { is_expected.to eq("http://id.library.duke.edu/ark:/99999/fk4zzz") }
+    its([Indexing::DISPLAY_FORMAT]) { is_expected.to eq("Image") }
+    its([Indexing::ACCESS_ROLE]) { is_expected.to eq(obj.roles.to_json) }
+    its([Indexing::POLICY_ROLE]) { is_expected.to contain_exactly(role2.agent.first, role3.agent.first, role4.agent.first) }
+    its([Indexing::RESOURCE_ROLE]) { is_expected.to contain_exactly(role1.agent.first) }
 
-    describe "language name" do
-      subject { FactoryGirl.build(:item) }
-      before do
-        subject.language = ["cym", "Not a Code"]
-        subject.save!
-      end
-      specify {
-        expect(subject.index_fields[Indexing::LANGUAGE_FACET]).to eq ["Welsh", "Not a Code"]
-        expect(subject.index_fields[Indexing::LANGUAGE_NAME]).to eq ["Welsh", "Not a Code"]
-      }
-    end
-
-    describe "nested path" do
-      subject { FactoryGirl.build(:item) }
-      before { subject.nested_path = "/foo/bar/baz" }
-      specify {
-        expect(subject.index_fields[Indexing::NESTED_PATH]).to eq "/foo/bar/baz"
-        expect(subject.index_fields[Indexing::NESTED_PATH_TEXT]).to eq "/foo/bar/baz"
-      }
-    end
   end
 end

data/spec/models/item_spec.rb

@@ -1,139 +1,8 @@
+require 'spec_helper'
+
 RSpec.describe Item, type: :model do
 
   it_behaves_like "a DDR model"
-  it_behaves_like "it has an association", :belongs_to, :parent, :is_member_of_collection, "Collection"
-  it_behaves_like "it has an association", :has_many, :children, :is_part_of, "Component"
   it_behaves_like "a non-collection model"
-  it_behaves_like "a potentially publishable object"
-  it_behaves_like "an object that cannot be streamable"
-
-  describe "indexing text" do
-    let(:children) { FactoryGirl.build_list(:component, 5) }
-
-    let(:text1) { fixture_file_upload('extractedText1.txt', 'text/plain') }
-    let(:text2) { fixture_file_upload('extractedText2.txt', 'text/plain') }
-    let(:text3) { fixture_file_upload('extractedText3.txt', 'text/plain') }
-
-    before {
-      children[0].extractedText.content = text1
-      children[0].save!
-      children[1].extractedText.content = text2
-      children[1].save!
-      children[2].extractedText.content = text3
-      children[2].save!
-      children[3].save!
-      children[4].save!
-      subject.children = children
-      subject.save!
-    }
-
-    it "indexes the combined text of its children" do
-      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
-
-  describe "#default_structure" do
-    describe "when the item has no components" do
-      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}" />
-            </mets>
-        EOS
-        xml
-      end
-      it "should be the appropriate structure" do
-        expect(subject.default_structure.to_xml).to be_equivalent_to(expected)
-      end
-    end
-    describe "when the item has components" do
-      let(:comp1) { Component.new }
-      let(:comp2) { Component.new }
-      let(:comp3) { Component.new }
-      let(:comp4) { Component.new }
-      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 TYPE="Documents">
-                  <div ORDER="1">
-                    <mptr LOCTYPE="ARK" xlink:href="ark:/99999/fk4ccc" />
-                  </div>
-                </div>
-                <div TYPE="Images">
-                  <div ORDER="1">
-                    <mptr LOCTYPE="ARK" xlink:href="ark:/99999/fk4bbb" />
-                  </div>
-                  <div ORDER="2">
-                    <mptr LOCTYPE="ARK" xlink:href="ark:/99999/fk4aaa" />
-                  </div>
-                </div>
-                <div TYPE="Other">
-                  <div ORDER="1">
-                    <mptr LOCTYPE="ARK" xlink:href="ark:/99999/fk4ddd" />
-                  </div>
-                </div>
-              </structMap>
-            </mets>
-        EOS
-        xml
-      end
-      before do
-        comp1.local_id = "test001002"
-        comp1.permanent_id = "ark:/99999/fk4aaa"
-        comp1.upload fixture_file_upload("imageB.tif", "image/tiff")
-        comp1.save!
-        comp2.local_id = "test001001"
-        comp2.permanent_id = "ark:/99999/fk4bbb"
-        comp2.upload fixture_file_upload("imageA.tif", "image/tiff")
-        comp2.save!
-        comp3.local_id = "test001"
-        comp3.permanent_id = "ark:/99999/fk4ccc"
-        comp3.upload fixture_file_upload("sample.pdf", "application/pdf")
-        comp3.save!
-        comp4.local_id = "test123"
-        comp4.permanent_id = "ark:/99999/fk4ddd"
-        comp4.upload fixture_file_upload("abcd1234.vtt", "application/octet-stream")
-        comp4.save!
-        subject.children << comp1
-        subject.children << comp2
-        subject.children << comp3
-        subject.children << comp4
-        subject.save!
-      end
-      after do
-        comp1.destroy
-        comp2.destroy
-        comp3.destroy
-      end
-      it "should be the appropriate structure" do
-        expect(subject.default_structure.to_xml).to be_equivalent_to(expected)
-      end
-    end
-  end
 
 end

data/spec/models/license_spec.rb

@@ -0,0 +1,24 @@
+module Ddr::Models
+  RSpec.describe License do
+
+    describe ".call" do
+      subject { described_class.call(obj) }
+
+      describe "when the object has a license URL" do
+        let(:url) { "http://example.com" }
+        let(:obj) { double(pid: "test:1", license: url) }
+        before do
+          allow(described_class).to receive(:find).with(url: url) { described_class.new(url: url, title: "A License") }
+        end
+        its(:pid) { is_expected.to eq("test:1") }
+        its(:to_s) { is_expected.to eq("A License") }
+      end
+
+      describe "when the object does not have a license" do
+        let(:obj) { double(pid: "test:1", license: nil) }
+        it { is_expected.to be_nil }
+      end
+    end
+
+  end
+end

data/spec/models/solr_document_spec.rb

@@ -1,31 +1,6 @@
-RSpec.describe SolrDocument, type: :model, contacts: true do
+require 'spec_helper'
 
-  describe "class methods" do
-    describe ".find" do
-      describe "when it exists" do
-        before { Item.create(pid: "test:1") }
-        subject { described_class.find("test:1") }
-        its(:id) { is_expected.to eq("test:1") }
-      end
-      describe "when not found" do
-        it "raises an error" do
-          expect { described_class.find("foo") }.to raise_error(SolrDocument::NotFound)
-        end
-      end
-    end
-    describe ".find_by_permanent_id" do
-      describe "when it exists" do
-        before { Item.create(pid: "test:1", permanent_id: "foo") }
-        subject { described_class.find_by_permanent_id("foo") }
-        its(:id) { is_expected.to eq("test:1") }
-      end
-      describe "when not found" do
-        it "raises an error" do
-          expect { described_class.find_by_permanent_id("foo") }.to raise_error(SolrDocument::NotFound)
-        end
-      end
-    end
-  end
+RSpec.describe SolrDocument, type: :model, contacts: true do
 
   describe "index field method access" do
     describe "when there is an index field" do
@@ -68,7 +43,7 @@ RSpec.describe SolrDocument, type: :model, contacts: true do
     describe "where there is an admin policy relationship" do
       let(:admin_policy) { FactoryGirl.create(:collection) }
       before do
-        subject[Ddr::Index::Fields::IS_GOVERNED_BY] = [ admin_policy.internal_uri ]
+        subject[Ddr::Index::Fields::IS_GOVERNED_BY] = [ admin_policy.id ]
       end
       it "should get the admin policy document" do
         expect(subject.admin_policy.id).to eq(admin_policy.id)
@@ -116,28 +91,46 @@ RSpec.describe SolrDocument, type: :model, contacts: true do
     end
   end
 
-  describe "#structure" do
-    context "no indexed structures" do
+  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
       it "should return nil" do
-        expect(subject.structure).to be_nil
+        expect(subject.struct_map('default')).to be_nil
       end
     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))
+    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
       end
     end
   end
 
   describe "contacts" do
     before do
-      allow(Ddr::Models::Contact).to receive(:get).with(:find, slug: 'xa') do
-        {'id'=>1, 'slug'=>'xa', 'name'=>'Contact A', 'short_name'=>'A'}
-      end
-      allow(Ddr::Models::Contact).to receive(:get).with(:find, slug: 'yb') do
-        {'id'=>1, 'slug'=>'yb', 'name'=>'Contact B', 'short_name'=>'B'}
-      end
+      allow(YAML).to receive(:load_file) { { 'xa' => { 'name' => 'Contact A', 'short_name' => 'A' },
+                                             'yb' => { 'name' => 'Contact B', 'short_name' => 'B' } } }
+      Ddr::Contacts.load_contacts
     end
     describe "#research_help" do
       context "object has research help contact" do
@@ -171,214 +164,32 @@ RSpec.describe SolrDocument, type: :model, contacts: true do
         its(:multires_image_file_paths) { is_expected.to match([]) }
       end
       context "structural metadata" do
-        before { allow(subject).to receive(:structure) { JSON.parse(simple_structure_to_json) } }
+        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 } }
         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: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") }
+            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") }
           end
           its(:multires_image_file_paths) { is_expected.to match(expected_result) }
         end
       end
     end
   end
-
-  describe "datastreams" do
-    let(:profile) do <<-EOS
-{"datastreams":{"DC":{"dsLabel":"Dublin Core Record for this object","dsVersionID":"DC1.0","dsCreateDate":"2016-02-09T12:38:56Z","dsState":"A","dsMIME":"text/xml","dsFormatURI":"http://www.openarchives.org/OAI/2.0/oai_dc/","dsControlGroup":"X","dsSize":340,"dsVersionable":true,"dsInfoType":null,"dsLocation":"duke:308221+DC+DC1.0","dsLocationType":null,"dsChecksumType":"SHA-1","dsChecksum":"69880409098d8dec1a5c41240a9daac2dd6832e0"}}}
-EOS
-    end
-    before {
-      subject[Ddr::Index::Fields::OBJECT_PROFILE] = [ profile ]
-    }
-    specify {
-      expect(subject.has_datastream?("DC")).to be true
-      expect(subject.has_datastream?("foo")).to be false
-    }
-  end
-
-  describe "#intermediate_type" do
-    specify {
-      allow(subject).to receive(:has_intermediate_file?) { false }
-      expect(subject.intermediate_path).to be_nil
-    }
-    specify {
-      allow(subject).to receive(:datastreams) do
-        {"intermediateFile"=>{"dsMIME"=>"audio/wav"}}
-      end
-      expect(subject.intermediate_type).to eq "audio/wav"
-    }
-  end
-
-  describe "#intermediate_path" do
-    specify {
-      allow(subject).to receive(:has_intermediate_file?) { false }
-      expect(subject.intermediate_path).to be_nil
-    }
-    specify {
-      allow(subject).to receive(:datastreams) do
-        {"intermediateFile"=>{"dsLocation"=>"file:/foo/bar/baz.txt"}}
-      end
-      expect(subject.intermediate_path).to eq "/foo/bar/baz.txt"
-    }
-  end
-
-  describe "#intermediate_extension" do
-    let(:extensions) { {'audio/wav' => 'wav', 'video/quicktime' => 'mov'} }
-    before { allow(Ddr::Models).to receive(:preferred_file_extensions) { extensions } }
-    before { allow(subject).to receive(:has_intermediate_file?) { true } }
-    specify {
-      allow(subject).to receive(:has_intermediate_file?) { false }
-      expect(subject.intermediate_extension).to be_nil
-    }
-    specify {
-      allow(subject).to receive(:intermediate_type) { 'audio/wav'}
-      expect(subject.intermediate_extension).to eq "wav"
-    }
-    specify {
-      allow(subject).to receive(:intermediate_type) { 'video/quicktime'}
-      expect(subject.intermediate_extension).to eq "mov"
-    }
-    specify {
-      allow(subject).to receive(:intermediate_type) { 'application/foo'}
-      allow(subject).to receive(:intermediate_extension_default) { "bin" }
-      expect(subject.intermediate_extension).to eq "bin"
-    }
-  end
-
-
-  describe "#captionable?" do
-    specify {
-      allow(subject).to receive(:has_datastream?).with(Ddr::Datastreams::CAPTION) { false }
-      expect(subject).not_to be_captionable
-    }
-    specify {
-      allow(subject).to receive(:has_datastream?).with(Ddr::Datastreams::CAPTION) { true }
-      expect(subject).to be_captionable
-    }
-  end
-
-  describe "#caption_type" do
-    specify {
-      allow(subject).to receive(:captionable?) { false }
-      expect(subject.caption_type).to be_nil
-    }
-    specify {
-      allow(subject).to receive(:datastreams) do
-        {"caption"=>{"dsMIME"=>"text/vtt"}}
-      end
-      expect(subject.caption_type).to eq "text/vtt"
-    }
-  end
-
-  describe "#caption_path" do
-    specify {
-      allow(subject).to receive(:captionable?) { false }
-      expect(subject.caption_path).to be_nil
-    }
-    specify {
-      allow(subject).to receive(:datastreams) do
-        {"caption"=>{"dsLocation"=>"file:/foo/bar/baz.txt"}}
-      end
-      expect(subject.caption_path).to eq "/foo/bar/baz.txt"
-    }
-  end
-
-  describe "#caption_extension" do
-    let(:extensions) { {'text/vtt' => 'vtt', 'application/zip' => 'zip'} }
-    before { allow(Ddr::Models).to receive(:preferred_file_extensions) { extensions } }
-    before { allow(subject).to receive(:captionable?) { true } }
-    specify {
-      allow(subject).to receive(:captionable?) { false }
-      expect(subject.caption_extension).to be_nil
-    }
-    specify {
-      allow(subject).to receive(:caption_type) { 'text/vtt'}
-      expect(subject.caption_extension).to eq "vtt"
-    }
-    specify {
-      allow(subject).to receive(:caption_type) { 'application/zip'}
-      expect(subject.caption_extension).to eq "zip"
-    }
-    specify {
-      allow(subject).to receive(:caption_type) { 'application/foo'}
-      allow(subject).to receive(:caption_extension_default) { "bin" }
-      expect(subject.caption_extension).to eq "bin"
-    }
-  end
-
-
-  describe "#streamable?" do
-    specify {
-      allow(subject).to receive(:has_datastream?).with(Ddr::Datastreams::STREAMABLE_MEDIA) { false }
-      expect(subject).not_to be_streamable
-    }
-    specify {
-      allow(subject).to receive(:has_datastream?).with(Ddr::Datastreams::STREAMABLE_MEDIA) { true }
-      expect(subject).to be_streamable
-    }
-  end
-
-  describe "#streamable_media_path" do
-    specify {
-      allow(subject).to receive(:streamable?) { false }
-      expect(subject.streamable_media_path).to be_nil
-    }
-    specify {
-      allow(subject).to receive(:datastreams) do
-        {"streamableMedia"=>{"dsLocation"=>"file:/foo/bar/baz.txt"}}
-      end
-      expect(subject.streamable_media_path).to eq "/foo/bar/baz.txt"
-    }
-  end
-
-  describe "#streamable_media_extension" do
-    let(:extensions) { {'audio/mpeg' => 'mp3', 'video/mp4' => 'mp4'} }
-    before { allow(Ddr::Models).to receive(:preferred_file_extensions) { extensions } }
-    before { allow(subject).to receive(:streamable?) { true } }
-    specify {
-      allow(subject).to receive(:streamable?) { false }
-      expect(subject.streamable_media_extension).to be_nil
-    }
-    specify {
-      allow(subject).to receive(:streamable_media_type) { 'audio/mpeg'}
-      expect(subject.streamable_media_extension).to eq "mp3"
-    }
-    specify {
-      allow(subject).to receive(:streamable_media_type) { 'application/foo'}
-      allow(subject).to receive(:streamable_media_extension_default) { "bin" }
-      expect(subject.streamable_media_extension).to eq "bin"
-    }
-  end
-
-
-  describe "#rights" do
-    specify {
-      obj = Item.create(rights: ["http://example.com"])
-      doc = described_class.find(obj.id)
-      expect(doc.rights).to eq ["http://example.com"]
-    }
-  end
-
-  describe "#rights_statement" do
-    let(:rights_statement) { Ddr::Models::RightsStatement.new(url: "http://example.com") }
-    before do
-      allow(Ddr::Models::RightsStatement).to receive(:get).with(:find, url: "http://example.com") do
-        { url: "http://example.com" }
-      end
-      allow(subject).to receive(:rights) { ["http://example.com"] }
-    end
-    its(:rights_statement) { is_expected.to eq rights_statement }
-  end
-
 end