ddr-models 2.5.3 → 2.6.0.rc1

data/spec/models/active_fedora_datastream_spec.rb

@@ -55,13 +55,13 @@ module ActiveFedora
         context "the datstream is new" do
           before { allow(subject).to receive(:new?) { true } }
           it "should raise an exception" do
-            expect { subject.validate_checksum!(checksum, checksum_type) }.to raise_error
+            expect { subject.validate_checksum!(checksum, checksum_type) }.to raise_error(Ddr::Models::Error)
           end
         end
         context "the datastream content has changed" do
           before { allow(subject).to receive(:content_changed?) { true } }
           it "should raise an exception" do
-            expect { subject.validate_checksum!(checksum, checksum_type) }.to raise_error
+            expect { subject.validate_checksum!(checksum, checksum_type) }.to raise_error(Ddr::Models::Error)
           end
         end
       end
@@ -76,14 +76,15 @@ module ActiveFedora
         context "and the repository internal checksum in invalid" do
           before { allow(subject).to receive(:dsChecksumValid) { false } }
           it "should raise an error" do
-            expect { subject.validate_checksum!(checksum, checksum_type) }.to raise_error
+            expect { subject.validate_checksum!(checksum, checksum_type) }.to raise_error(Ddr::Models::ChecksumInvalid)
           end
         end
         context "and the repository internal checksum is valid" do
           before { allow(subject).to receive(:dsChecksumValid) { true } }
           context "and the checksum type is invalid" do
+            before { allow(subject).to receive(:content) { "foo" } }
             it "should raise an exception" do
-              expect { subject.validate_checksum!("0123456789abcdef", "FOO-BAR") }.to raise_error
+              expect { subject.validate_checksum!("0123456789abcdef", "FOO-BAR") }.to raise_error(ArgumentError)
             end
           end
           context "and the checksum type is nil" do
@@ -106,7 +107,7 @@ module ActiveFedora
           end
           context "and the checksum doesn't match" do
             it "should raise an exception" do
-              expect { subject.validate_checksum!("0123456789abcdef", checksum_type) }.to raise_error
+              expect { subject.validate_checksum!("0123456789abcdef", checksum_type) }.to raise_error(Ddr::Models::ChecksumInvalid)
             end
           end
         end

data/spec/models/has_admin_metadata_spec.rb

@@ -4,113 +4,7 @@ require 'support/ezid_mock_identifier'
 module Ddr::Models
   RSpec.describe HasAdminMetadata, type: :model, contacts: true do
 
-    describe "permanent id and permanent url" do
-      subject { FactoryGirl.build(:item) }
-
-      describe "#assign_permanent_id!" do
-        it "should assign the permanent id later" do
-          expect(subject.permanent_id_manager).to receive(:assign_later) { nil }
-          subject.assign_permanent_id!
-        end
-        context "when the object is created (first saved)" do
-          context "and auto-assignment is enabled" do
-            before { allow(Ddr::Models).to receive(:auto_assign_permanent_ids) { true } }
-            it "should assign a permanent id" do
-              expect(subject).to receive(:assign_permanent_id!) { nil }
-              subject.save!
-            end
-          end
-          context "and auto-assignment is disabled" do
-            before { allow(Ddr::Models).to receive(:auto_assign_permanent_ids) { false } }
-            it "should not assign a permanent id" do
-              expect(subject).not_to receive(:assign_permanent_id!)
-              subject.save!
-            end
-          end
-        end
-        context "when saved" do
-          context "and auto-assignment is enabled" do
-            before { allow(Ddr::Models).to receive(:auto_assign_permanent_ids) { true } }
-            it "should assign a permanent id once" do
-              expect(subject).to receive(:assign_permanent_id!).once { nil }
-              subject.save!
-              subject.title = ["New Title"]
-              subject.save!
-            end
-          end
-          context "and auto-assignment is disabled" do
-            before { allow(Ddr::Models).to receive(:auto_assign_permanent_ids) { false } }
-            it "should not assign a permanent id" do
-              expect(subject).not_to receive(:assign_permanent_id!)
-              subject.save!
-            end
-          end
-        end
-      end
-
-      describe "lifecycle" do
-        subject { FactoryGirl.create(:item) }
-        let!(:identifier) {
-          Ezid::MockIdentifier.create(subject.permanent_id_manager.default_metadata)
-        }
-        before do
-          allow(Ddr::Models).to receive(:auto_assign_permanent_ids) { false }
-          allow(Ezid::Identifier).to receive(:find).with(identifier.id) { identifier }
-          subject.permanent_id = identifier.id
-          subject.save!
-        end
-        describe "identifier creation" do
-          it "sets default metadata" do
-            expect(identifier.profile).to eq("dc")
-            expect(identifier.export).to eq("no")
-            expect(identifier["fcrepo3.pid"]).to eq(subject.pid)
-          end
-        end
-        describe "object destruction" do
-          it "marks the identifier as unavailable" do
-            expect { subject.destroy }
-              .to change(identifier, :status)
-                   .to("unavailable | deleted")
-          end
-        end
-        describe "object deaccession" do
-          it "marks the identifier as unavailable" do
-            expect { subject.deaccession }
-              .to change(identifier, :status)
-                   .to("unavailable | deaccessioned")
-          end
-        end
-      end
-
-      describe "events" do
-        before { allow(Ddr::Models).to receive(:auto_assign_permanent_ids) { true } }
-        context "when the operation succeeds" do
-          let!(:mock_identifier) { Ezid::MockIdentifier.new(id: "ark:/99999/fk4zzz",
-                                                            metadata: "_target: http://example.com") }
-          before do
-            allow(Ezid::Identifier).to receive(:create) { mock_identifier }
-            allow(Ezid::Identifier).to receive(:find) { mock_identifier }
-            allow(subject.permanent_id_manager).to receive(:record) { mock_identifier }
-          end
-          it "should create a success event" do
-            expect { subject.save }.to change { subject.update_events.count }.by(1)
-          end
-        end
-        context "when there's an exception" do
-          before { allow(Ezid::Identifier).to receive(:create).and_raise(Ezid::Error) }
-          it "should create a failure event" do
-            begin
-              subject.save
-            rescue Ezid::Error
-            end
-            expect(subject.update_events.last).to be_failure
-          end
-        end
-      end
-    end
-
     describe "workflow" do
-
       let(:collection) { FactoryGirl.create(:collection) }
       let(:item) { FactoryGirl.create(:item) }
       let(:component) { FactoryGirl.create(:component) }
@@ -122,17 +16,34 @@ module Ddr::Models
       end
 
       describe "#published?" do
+        subject { collection }
         context "object is published" do
-          before { allow(collection).to receive(:workflow_state) { Ddr::Managers::WorkflowManager::PUBLISHED } }
-          it "should return true" do
-            expect(collection).to be_published
-          end
+          before { subject.workflow_state = Ddr::Managers::WorkflowManager::PUBLISHED }
+          it { is_expected.to be_published }
         end
-        context "object is not published" do
-          before { allow(collection).to receive(:workflow_state) { nil } }
-          it "should return false" do
-            expect(collection).not_to be_published
-          end
+        context "object workflow is not set" do
+          before { subject.workflow_state = nil }
+          it { is_expected.not_to be_published }
+        end
+        context "object is unpublished" do
+          before { subject.workflow_state = Ddr::Managers::WorkflowManager::UNPUBLISHED }
+          it { is_expected.not_to be_published }
+        end
+      end
+
+      describe "#unpublished?" do
+        subject { collection }
+        context "object is published" do
+          before { subject.workflow_state = Ddr::Managers::WorkflowManager::PUBLISHED }
+          it { is_expected.not_to be_unpublished }
+        end
+        context "object is unpublished" do
+          before { subject.workflow_state = Ddr::Managers::WorkflowManager::UNPUBLISHED }
+          it { is_expected.to be_unpublished }
+        end
+        context "object workflow is not set" do
+          before { subject.workflow_state = nil }
+          it { is_expected.not_to be_unpublished }
         end
       end
 
@@ -167,7 +78,6 @@ module Ddr::Models
     end
 
     describe "roles" do
-
       subject { FactoryGirl.build(:item) }
 
       describe "#copy_resource_roles_from" do
@@ -207,9 +117,7 @@ module Ddr::Models
     end
 
     describe "contacts" do
-
       subject { FactoryGirl.build(:item) }
-
       before do
         allow(Ddr::Models::Contact).to receive(:get).with(:find, slug: 'xa') do
           {'id'=>1, 'slug'=>'xa', 'name'=>'Contact A', 'short_name'=>'A'}
@@ -227,19 +135,37 @@ module Ddr::Models
     end
 
     describe "locking" do
-
       subject { FactoryGirl.build(:item) }
 
       describe "#locked?" do
         context "object is locked" do
           before { subject.is_locked = true }
-          it "should be true" do
-            expect(subject.locked?).to be true
+          context "repository is locked" do
+            before { Ddr::Models.repository_locked = true }
+            after { Ddr::Models.repository_locked = false }
+            it "should be true" do
+              expect(subject.locked?).to be true
+            end
+          end
+          context "repository is not locked" do
+            it "should be true" do
+              expect(subject.locked?).to be true
+            end
           end
         end
         context "object is not locked" do
-          it "should be false" do
-            expect(subject.locked?).to be false
+          before { subject.is_locked = false }
+          context "repository is locked" do
+            before { Ddr::Models.repository_locked = true }
+            after { Ddr::Models.repository_locked = false }
+            it "should be true" do
+              expect(subject.locked?).to be true
+            end
+          end
+          context "repository is not locked" do
+            it "should be false" do
+              expect(subject.locked?).to be false
+            end
           end
         end
       end
@@ -273,8 +199,6 @@ module Ddr::Models
           expect(subject.locked?).to be false
         end
       end
-
     end
-
   end
 end

data/spec/models/indexing_spec.rb

@@ -23,39 +23,71 @@ module Ddr::Models
         obj.rightsMetadata.license.title = ["License Title"]
         obj.rightsMetadata.license.url = ["http://library.duke.edu"]
         obj.roles.grant role1, role2, role3, role4
-        obj.set_desc_metadata_values(:category, "Category Facet")
-        obj.set_desc_metadata_values(:company, "Company Facet")
-        obj.set_desc_metadata_values(:folder, "Folder Facet")
-        obj.set_desc_metadata_values(:medium, "Medium Facet")
-        obj.set_desc_metadata_values(:placement_company, "Placement Company Facet")
-        obj.set_desc_metadata_values(:product, "Product Facet")
-        obj.set_desc_metadata_values(:publication, "Publication Facet")
-        obj.set_desc_metadata_values(:setting, "Setting Facet")
-        obj.set_desc_metadata_values(:tone, "Tone Facet")
+        obj.set_desc_metadata_values(:arranger, "Arranger Value")
+        obj.set_desc_metadata_values(:category, "Category Value")
+        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(: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
 
       its([Indexing::ACCESS_ROLE]) { is_expected.to eq(obj.roles.to_json) }
+      its([Indexing::ARRANGER_FACET]) { is_expected.to eq(["Arranger Value"]) }
       its([Indexing::ASPACE_ID]) { is_expected.to eq("aspace_dccea43034e1b8261e14cf999e86449d") }
-      its([Indexing::CATEGORY_FACET]) { is_expected.to eq(["Category Facet"]) }
-      its([Indexing::COMPANY_FACET]) { is_expected.to eq(["Company Facet"]) }
+      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::DISPLAY_FORMAT]) { is_expected.to eq("Image") }
       its([Indexing::DOI]) { is_expected.to eq(["http://doi.org/10.1000/182"]) }
-      its([Indexing::FOLDER_FACET]) { is_expected.to eq(["Folder Facet"]) }
+      its([Indexing::ENGRAVER_FACET]) { is_expected.to eq(["Engraver Value"]) }
+      its([Indexing::FOLDER_FACET]) { is_expected.to eq(["Folder Value"]) }
+      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::INSTRUMENTATION_FACET]) { is_expected.to eq(["Instrumentation Value"]) }
+      its([Indexing::INTERVIEWER_NAME_FACET]) { is_expected.to eq(["Interviewer Name Value"]) }
       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::MEDIUM_FACET]) { is_expected.to eq(["Medium Facet"]) }
+      its([Indexing::LYRICIST_FACET]) { is_expected.to eq(["Lyricist Value"]) }
+      its([Indexing::MEDIUM_FACET]) { is_expected.to eq(["Medium Value"]) }
+      its([Indexing::PERFORMER_FACET]) { is_expected.to eq(["Performer Value"]) }
       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::PLACEMENT_COMPANY_FACET]) { is_expected.to eq(["Placement Company Facet"]) }
+      its([Indexing::PLACEMENT_COMPANY_FACET]) { is_expected.to eq(["Placement Company Value"]) }
       its([Indexing::POLICY_ROLE]) { is_expected.to contain_exactly(role2.agent.first, role3.agent.first, role4.agent.first) }
-      its([Indexing::PRODUCT_FACET]) { is_expected.to eq(["Product Facet"]) }
-      its([Indexing::PUBLICATION_FACET]) { is_expected.to eq(["Publication Facet"]) }
+      its([Indexing::PRODUCER_FACET]) { is_expected.to eq(["Producer Value"]) }
+      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::SETTING_FACET]) { is_expected.to eq(["Setting Facet"]) }
-      its([Indexing::TONE_FACET]) { is_expected.to eq(["Tone Facet"]) }
+      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/solr_document_spec.rb

@@ -2,6 +2,33 @@ require 'spec_helper'
 
 RSpec.describe SolrDocument, type: :model, contacts: true do
 
+  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
+
   describe "index field method access" do
     describe "when there is an index field" do
       before { Ddr::Index::Fields.const_set(:FOO_BAR, "foo_bar_ssim") }
@@ -195,4 +222,5 @@ RSpec.describe SolrDocument, type: :model, contacts: true do
       end
     end
   end
+
 end

data/spec/models/year_facet_spec.rb

@@ -1,64 +1,91 @@
 module Ddr::Models
   RSpec.describe YearFacet do
 
-    subject { described_class.new(obj) }
+    subject { described_class.call(obj) }
     let(:obj) { Item.new }
     before { obj.date = [ date ] }
 
     describe "splitting on semicolons" do
       let(:date) { "1935; 1936; 1937; 1938" }
-      its(:values) { is_expected.to eq([1935, 1936, 1937, 1938]) }
+      it { is_expected.to eq([1935, 1936, 1937, 1938]) }
     end
 
     describe "year range" do
-      %w( 1935-1940 1935/1940 ).each do |value|
+      %w( 1935-1940 1935/1940 1935?/1940? 1935~/1940~ ).each do |value|
         describe value do
           let(:date) { value }
-          its(:values) { is_expected.to eq((1935..1940).to_a) }
+          it { is_expected.to eq((1935..1940).to_a) }
         end
       end
     end
 
-    describe "in decade" do
-      %w( 192x 192X 192? 192- 192-? ).each do |value|
+    describe "decade" do
+      %w( 192u 192x 192X 192? 192- 192-? 1920s 1920s? ).each do |value|
         describe value do
           let(:date) { value }
-          its(:values) { is_expected.to eq((1920..1929).to_a) }
+          it { is_expected.to eq((1920..1929).to_a) }
         end
       end
     end
 
-    describe "in century -- YYxx (19xx)" do
-      let(:date) { "19xx" }
-      its(:values) { is_expected.to eq((1900..1999).to_a) }
+    describe "century" do
+      %w( 19xx 19uu ).each do |value|
+        describe value do
+          let(:date) { value }
+          it { is_expected.to eq((1900..1999).to_a) }
+        end
+      end
     end
 
-    describe "decade" do
-      %w( 1920s 1920s? ).each do |value|
+    describe "uncertain interval" do
+      let(:date) { "199u/200u" }
+      it { is_expected.to eq((1990..2009).to_a) }
+    end
+
+    describe "set" do
+      let(:date) { "[1999,2000,2003]" }
+      it { is_expected.to eq([1999, 2000, 2003]) }
+    end
+
+    describe "year" do
+      %w( 2010 2010? 2010~ ).each do |value|
         describe value do
           let(:date) { value }
-          its(:values) { is_expected.to eq((1920..1929).to_a) }
+          it { is_expected.to eq([2010]) }
         end
       end
     end
 
-    describe "year + month" do
-      %w( 2010-01 2010/01 ).each do |value|
+    describe "month" do
+      %w( 2010-01 2010/01 2010-12? 2010-11/2010-12 ).each do |value|
         describe value do
           let(:date) { value }
-          its(:values) { is_expected.to eq([2010]) }
+          it { is_expected.to eq([2010]) }
         end
       end
     end
 
-    describe "between" do
-      let(:date) { "Between 1965 and 1968" }
-      its(:values) { is_expected.to eq((1965..1968).to_a) }
+    describe "day" do
+      %w( 2010-12-10 2010-12-10? 2010-12-10/2010-12-20 ).each do |value|
+        describe value do
+          let(:date) { value }
+          it { is_expected.to eq([2010]) }
+        end
+      end
     end
 
-    describe "year" do
-      let(:date) { "1965" }
-      its(:values) { is_expected.to eq([1965]) }
+    describe "season" do
+      %w( 2010-21 2010-22 2010-23 2010-24 ).each do |value|
+        describe value do
+          let(:date) { value }
+          it { is_expected.to eq([2010]) }
+        end
+      end
+    end
+
+    describe "between" do
+      let(:date) { "Between 1965 and 1968" }
+      it { is_expected.to eq((1965..1968).to_a) }
     end
 
   end