ddr-models 2.11.0 → 3.0.0.alpha.1

data/spec/models/finding_aid_spec.rb

@@ -15,32 +15,15 @@ module Ddr::Models
               findaidstatus="published"
               langencoding="iso639-2b"
               repositoryencoding="iso15511">
-     <eadid url="http://example.com/ead/">ead</eadid>
-     <filedesc>
-       <titlestmt>
-         <titleproper>Guide to the Perplexed
-           <num>00001</num>
-         </titleproper>
-       </titlestmt>
-     </filedesc>
+      <eadid url="http://example.com/ead/">ead</eadid>
+      <filedesc>
+         <titlestmt>
+            <titleproper>Guide to the Perplexed
+              <num>00001</num>
+            </titleproper>
+          </titlestmt>
+      </filedesc>
    </eadheader>
-   <archdesc level="collection">
-     <did>
-       <repository>
-         <corpname>Library of the Perplexed</corpname>
-       </repository>
-       <unittitle>Perplexities</unittitle>
-       <unitid>RL.00327</unitid>
-       <physdesc altrender="whole">
-         <extent altrender="materialtype spaceoccupied">6.5 Linear Feet</extent>
-       </physdesc>
-       <unitdate normal="1876/1953" type="inclusive">1876-1953</unitdate>
-       <abstract>Abstract of Perplexities.</abstract>
-       <physdesc id="aspace_foobar">
-         <extent>4000 Items</extent>
-       </physdesc>
-     </did>
-   </archdesc>
 </ead>
 EOS
     end
@@ -51,12 +34,6 @@ EOS
 
     its(:title) { is_expected.to eq("Guide to the Perplexed") }
     its(:url) { is_expected.to eq("http://example.com/ead/") }
-    its(:repository) { is_expected.to eq("Library of the Perplexed") }
-    its(:collection_date_span) { is_expected.to eq("1876-1953") }
-    its(:collection_number) { is_expected.to eq("RL.00327") }
-    its(:collection_title) { is_expected.to eq("Perplexities") }
-    its(:extent) { is_expected.to eq("6.5 Linear Feet; 4000 Items") }
-    its(:abstract) { is_expected.to eq("Abstract of Perplexities.") }
 
   end
 end

data/spec/models/has_admin_metadata_spec.rb

@@ -4,80 +4,142 @@ require 'support/ezid_mock_identifier'
 module Ddr::Models
   RSpec.describe HasAdminMetadata, type: :model, contacts: true do
 
-    describe "workflow" do
-      let(:collection) { FactoryGirl.create(:collection) }
-      let(:item) { FactoryGirl.create(:item) }
-      let(:component) { FactoryGirl.create(:component) }
-      before do
-        item.parent = collection
-        item.save!
-        component.parent = item
-        component.save!
+    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.dc_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 "#published?" do
-        subject { collection }
-        context "object is published" do
-          before { subject.workflow_state = Ddr::Managers::WorkflowManager::PUBLISHED }
-          it { is_expected.to be_published }
+      describe "lifecycle" do
+        let!(:identifier) { Ezid::MockIdentifier.new(id: "ark:/99999/fk4zzz", status: "public") }
+        before do
+          allow(Ddr::Models).to receive(:auto_assign_permanent_ids) { false }
+          allow(Ezid::Identifier).to receive(:find).with("ark:/99999/fk4zzz") { identifier }
+          subject.permanent_id = "ark:/99999/fk4zzz"
+          subject.save!
         end
-        context "object workflow is not set" do
-          before { subject.workflow_state = nil }
-          it { is_expected.not_to be_published }
+        it "should update the status of the identifier when the object is destroyed" do
+          expect { subject.destroy }.to change(identifier, :status).from("public").to("unavailable | deleted")
         end
-        context "object is unpublished" do
-          before { subject.workflow_state = Ddr::Managers::WorkflowManager::UNPUBLISHED }
-          it { is_expected.not_to be_published }
+      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
+
+      subject { FactoryGirl.build(:item) }
 
-      describe "#unpublished?" do
-        subject { collection }
+      describe "#published?" do
         context "object is published" do
-          before { subject.workflow_state = Ddr::Managers::WorkflowManager::PUBLISHED }
-          it { is_expected.not_to be_unpublished }
+          before { allow(subject).to receive(:workflow_state) { Ddr::Managers::WorkflowManager::PUBLISHED } }
+          it "should return true" do
+            expect(subject).to be_published
+          end
         end
-        context "object is unpublished" do
-          before { subject.workflow_state = Ddr::Managers::WorkflowManager::UNPUBLISHED }
-          it { is_expected.to be_unpublished }
+        context "object is not published" do
+          before { allow(subject).to receive(:workflow_state) { nil } }
+          it "should return false" do
+            expect(subject).not_to be_published
+          end
         end
-        context "object workflow is not set" do
-          before { subject.workflow_state = nil }
-          it { is_expected.not_to be_unpublished }
+      end
+
+      describe "#publish" do
+        it "should publish the object" do
+          subject.publish
+          expect(subject).to be_published
         end
       end
 
       describe "#publish!" do
-        context "do not include descendants" do
-          it "should publish and persist the object" do
-            collection.publish!(include_descendants: false)
-            expect(collection.reload).to be_published
-            expect(item.reload).not_to be_published
-            expect(component.reload).not_to be_published
-          end
+        it "should publish and persist the object" do
+          subject.publish!
+          expect(subject.reload).to be_published
         end
-        context "do include descendants" do
-          it "should publish and persist the object and descendants" do
-            collection.publish!
-            expect(collection.reload).to be_published
-            expect(item.reload).to be_published
-            expect(component.reload).to be_published
-          end
+      end
+
+      describe "#unpublish" do
+        before { subject.publish }
+        it "should unpublish the object" do
+          subject.unpublish
+          expect(subject).not_to be_published
         end
       end
 
       describe "#unpublish!" do
-        before { collection.publish! }
-        it "should unpublish and persist the object and descendants" do
-          collection.unpublish!
-          expect(collection.reload).not_to be_published
-          expect(item.reload).not_to be_published
-          expect(component.reload).not_to be_published
+        before { subject.publish! }
+        it "should unpublish and persist the object" do
+          subject.unpublish!
+          expect(subject.reload).not_to be_published
         end
       end
     end
 
     describe "roles" do
+
       subject { FactoryGirl.build(:item) }
 
       describe "#copy_resource_roles_from" do
@@ -114,91 +176,20 @@ module Ddr::Models
         end
       end
 
-    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'}
-        end
-        allow(Ddr::Models::Contact).to receive(:get).with(:find, slug: 'yb') do
-          {'id'=>1, 'slug'=>'yb', 'name'=>'Contact B', 'short_name'=>'B'}
-        end
-      end
-      describe "#research_help" do
-        before { subject.research_help_contact = 'yb' }
-        it "should return the appropriate contact" do
-          expect(subject.research_help.slug).to eq('yb')
-        end
-      end
-    end
-
-    describe "locking" do
-      subject { FactoryGirl.build(:item) }
-
-      describe "#locked?" do
-        context "object is locked" do
-          before { subject.is_locked = 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
-          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
+      describe "contacts" do
+        before do
+          allow(YAML).to receive(:load_file) { { 'a' => { 'name' => 'Contact A', 'short_name' => 'A' },
+                                                 'b' => { 'name' => 'Contact B', 'short_name' => 'B' } } }
+          Ddr::Contacts.load_contacts
+        end
+        describe "#research_help" do
+          before { subject.research_help_contact = 'b' }
+          it "should return the appropriate contact" do
+            expect(subject.research_help.slug).to eq('b')
           end
         end
       end
 
-      describe "lock" do
-        it "should lock the object" do
-          expect { subject.lock }.to change(subject, :locked?).from(false).to(true)
-        end
-      end
-
-      describe "unlock" do
-        before { subject.lock }
-        it "should unlock the object" do
-          expect { subject.unlock }.to change(subject, :locked?).from(true).to(false)
-        end
-      end
-
-      describe "lock!" do
-        it "should lock and save the object" do
-          subject.lock!
-          subject.reload
-          expect(subject.locked?).to be true
-        end
-      end
-
-      describe "unlock!" do
-        before { subject.lock! }
-        it "should unlock and save the object" do
-          subject.unlock!
-          subject.reload
-          expect(subject.locked?).to be false
-        end
-      end
     end
   end
 end

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)

data/spec/models/has_struct_metadata_spec.rb

@@ -1,61 +1,48 @@
-module Ddr::Models
-  RSpec.describe HasStructMetadata, type: :model, structural_metadata: true do
+require 'spec_helper'
 
-    let(:item) { Item.new(pid: 'test:2') }
+module Ddr
+  module Models
+    RSpec.describe HasStructMetadata, type: :model, structural_metadata: true do
 
-    describe "#structures" do
-      context "no existing structural metadata" do
-        it "should return nil" do
-          expect(item.structure).to eq(nil)
+      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
-      end
-      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)
+        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
         end
       end
-    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[Ddr::Index::Fields::STRUCTURE]).to eq(expected_json)
-      end
-      describe "structure source" do
-        describe "repository maintained" do
-          before do
-            item.datastreams[Ddr::Datastreams::STRUCT_METADATA].content = simple_structure_xml
-          end
-          it "should index the structure source as repository maintained" do
-            indexing = item.to_solr
-            expect(indexing[Ddr::Index::Fields::STRUCTURE_SOURCE]).to eq(Ddr::Models::Structure::REPOSITORY_MAINTAINED)
-          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)
         end
-        describe "externally provided" do
-          before do
-            item.datastreams[Ddr::Datastreams::STRUCT_METADATA].content = nested_structure_xml
-          end
-          it "should index the structure source as repository maintained" do
-            indexing = item.to_solr
-            expect(indexing[Ddr::Index::Fields::STRUCTURE_SOURCE]).to eq(Ddr::Models::Structure::EXTERNALLY_PROVIDED)
-          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
       end
-    end
 
+    end
   end
-end
+end