ddr-models 2.11.0 → 3.0.0.alpha.1

data/spec/models/struct_div_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'support/structural_metadata_helper'
+
+module Ddr
+  module Models
+    RSpec.describe StructDiv, type: :model, structural_metadata: true do
+
+      let(:structmap_node) { nested_structure_document.xpath('//xmlns:structMap').first }
+      let(:struct_div) { described_class.new(structmap_node) }
+
+      describe "#initialize" do
+        it "should create the correct object" do
+          expect(struct_div.divs.size).to eq(2)
+          expect(struct_div.divs.first.label).to eq("Front")
+          expect(struct_div.divs.first.divs).to be_empty
+          expect(struct_div.divs.first.fptrs).to eq([ "test:5" ])
+          expect(struct_div.divs.last.label).to eq("Back")
+          expect(struct_div.divs.last.divs.size).to eq(2)
+          expect(struct_div.divs.last.fptrs).to be_empty
+          expect(struct_div.divs.last.divs.first.label).to eq("Top")
+          expect(struct_div.divs.last.divs.first.divs).to be_empty
+          expect(struct_div.divs.last.divs.first.fptrs).to eq([ "test:7" ])
+          expect(struct_div.divs.last.divs.last.label).to eq("Bottom")
+          expect(struct_div.divs.last.divs.last.divs).to be_empty
+          expect(struct_div.divs.last.divs.last.fptrs).to eq([ "test:6" ])
+        end
+      end
+
+      describe "#pids" do
+        context "top level" do
+          it "should return all pids in the structMap" do
+            expect(struct_div.pids).to match_array([ 'test:5', 'test:6', 'test:7' ])
+          end
+        end
+      end
+
+      describe "#docs" do
+        let(:solr_response) { [ { 'id'=>'test:5' }, { 'id'=>'test:6' }, { 'id'=>'test:7'} ] }
+        before do
+          allow(ActiveFedora::SolrService).to receive(:query) { solr_response }
+        end
+        it "should return a hash of Solr documents" do
+          results = struct_div.docs
+          expect(results.keys).to match_array([ 'test:5', 'test:6', 'test:7' ])
+          results.keys.each do |key|
+            expect(results[key]).to be_a(SolrDocument)
+            expect(results[key].id).to eq(key)
+          end
+        end
+      end
+
+      describe "#objects" do
+        let(:repo_objects) { [ Component.new(pid: 'test:5'), Component.new(pid: 'test:6'), Component.new(pid: 'test:7') ] }
+        before do
+          allow(ActiveFedora::Base).to receive(:find).with('test:5') { repo_objects[0] }
+          allow(ActiveFedora::Base).to receive(:find).with('test:6') { repo_objects[1] }
+          allow(ActiveFedora::Base).to receive(:find).with('test:7') { repo_objects[2] }
+        end
+        it "should return a hash of Active Fedora objects" do
+          results = struct_div.objects
+          expect(results.keys).to match_array([ 'test:5', 'test:6', 'test:7' ])
+          expect(results['test:5']).to eq(repo_objects[0])
+          expect(results['test:6']).to eq(repo_objects[1])
+          expect(results['test:7']).to eq(repo_objects[2])
+        end
+      end
+
+    end
+  end
+end

data/spec/models/structure_spec.rb

@@ -1,99 +1,21 @@
 require 'spec_helper'
 require 'support/structural_metadata_helper'
 
-module Ddr::Models
-  RSpec.describe Structure, type: :model, structural_metadata: true do
+module Ddr
+  module Models
+    RSpec.describe Structure, type: :model, structural_metadata: true 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
+      let(:structure) { FactoryGirl.build(:multiple_struct_maps_structure) }
 
-    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(Ddr::Models::Structures::Agent::NAME_REPOSITORY_DEFAULT)
+      describe "#struct_maps" do
+        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)
         end
       end
-      describe "structure does not have a metsHdr" do
-        let(:structure) { FactoryGirl.build(:multiple_struct_maps_structure) }
-        it "returns the creator" do
-          expect(structure.creator).to be nil
-        end
-      end
-    end
 
-    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
+end

data/spec/models/target_spec.rb

@@ -1,11 +1,9 @@
+require 'spec_helper'
+
 RSpec.describe Target, type: :model, targets: true do
 
   it_behaves_like "a DDR model"
   it_behaves_like "an object that can have content"
-  it_behaves_like "it has an association", :has_many, :components, :has_external_target, "Component"
-  it_behaves_like "it has an association", :belongs_to, :collection, :is_external_target_for, "Collection"
   it_behaves_like "a non-collection model"
-  it_behaves_like "an unpublishable object"
-  it_behaves_like "an object that cannot be streamable"
 
 end

data/spec/models/year_facet_spec.rb

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

data/spec/spec_helper.rb

@@ -1,7 +1,5 @@
 ENV['RAILS_ENV'] ||= "test"
 
-ENV['DDR_AUX_API_URL'] ||= "http://localhost:3000/api"
-
 require File.expand_path("../dummy/config/environment.rb",  __FILE__)
 
 require "ddr-models"
@@ -25,6 +23,10 @@ Dir[File.join(File.dirname(__FILE__), "support", "*.rb")].each { |f| require f }
 
 DatabaseCleaner.strategy = :truncation
 
+# Silence deprecation warnings
+warn "Default deprecation behavior set to :silence!"
+Deprecation.default_deprecation_behavior = :silence
+
 RSpec.configure do |config|
 
   config.include ActionDispatch::TestProcess
@@ -85,7 +87,7 @@ RSpec.configure do |config|
   # Print the 10 slowest examples and example groups at the
   # end of the spec run, to help surface which specs are running
   # particularly slow.
-  # config.profile_examples = 10
+  config.profile_examples = 10
 
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing
@@ -108,26 +110,20 @@ RSpec.configure do |config|
       config.update_derivatives = [ :multires_image, :thumbnail ]
     end
     Ddr::Models.configure do |config|
+      config.external_file_store = Dir.mktmpdir
+      config.multires_image_external_file_store = Dir.mktmpdir
+      config.external_file_subpath_pattern = "--"
       config.fits_home = Dir.mktmpdir
     end
-    Ddr::Datastreams::ExternalFileDatastream.file_store = Dir.mktmpdir
   end
 
   config.after(:suite) do
-    if Ddr::Datastreams::ExternalFileDatastream.file_store
-      FileUtils.rm_rf Ddr::Datastreams::ExternalFileDatastream.file_store
+    if Ddr::Models.external_file_store && Dir.exist?(Ddr::Models.external_file_store)
+      FileUtils.remove_entry_secure(Ddr::Models.external_file_store)
+    end
+    if Ddr::Models.multires_image_external_file_store && Dir.exist?(Ddr::Models.multires_image_external_file_store)
+      FileUtils.remove_entry_secure(Ddr::Models.multires_image_external_file_store)
     end
-  end
-
-  config.before(:each) do
-    allow(Ddr::Models::AdminSet).to receive(:find_by_code).with("foo") {
-      Ddr::Models::AdminSet.new(code: 'foo', title: 'Foo Admin Set')
-    }
-    allow(Ddr::Models::Language).to receive(:find_by_code).with("cym") {
-      Ddr::Models::Language.new(code: 'cym', label: 'Welsh')
-    }
-    allow(Ddr::Models::Language).to receive(:find_by_code).with("Not a Code")
-                                     .and_raise(ActiveResource::ResourceNotFound, "404")
   end
 
   config.after(:each) do

data/spec/support/ezid_mock_identifier.rb

@@ -6,8 +6,8 @@ module Ezid
 
     self.defaults = {}
 
-    def load_metadata; self; end
-    def reset_metadata; self; end
+    def reload; self; end
+    def reset; self; end
 
     private
 

data/spec/support/shared_examples_for_auth_contexts.rb

@@ -23,39 +23,6 @@ module Ddr::Auth
       end
     end
 
-    describe "#metadata_manager?" do
-      describe "when a user is present" do
-        before { allow(subject).to receive(:user) { double(agent: "bob@example.com") } }
-        describe "and there is no metadata managers group" do
-          before {
-            allow(Ddr::Auth).to receive(:metadata_managers_group) { nil }
-          }
-          its(:metadata_manager?) { should be false }
-        end
-        describe "and there is a metadata managers group" do
-          before {
-            allow(Ddr::Auth).to receive(:metadata_managers_group) { "metadata_managers" }
-          }
-          describe "and the auth context is a member of the group" do
-            before {
-              allow(subject).to receive(:groups) { [ Group.new("metadata_managers") ] }
-            }
-            its(:metadata_manager?) { should be true }
-          end
-          describe "and the auth context is not a member of the group" do
-            before {
-              allow(subject).to receive(:groups) { [ Group.new("foo"), Group.new("bar") ] }
-            }
-            its(:metadata_manager?) { should be false }
-          end
-        end
-      end
-      describe "when no user is present" do
-        before { allow(subject).to receive(:user) { nil } }
-        its(:metadata_manager?) { should be false }
-      end
-    end
-
     describe "#duke_agent?" do
       describe "when the auth context is anonymous" do
         before { allow(subject).to receive(:user) { nil } }

data/spec/support/shared_examples_for_ddr_models.rb

@@ -5,165 +5,117 @@ RSpec.shared_examples "a DDR model" do
   it_behaves_like "an object that has a display title"
   it_behaves_like "an object that has identifiers"
 
-  describe "ingested by" do
-    let(:user) { User.new(username: "foo@bar.com") }
-    describe "on create" do
-      describe "when :user option passed to #save" do
-        describe "and ingested_by is not set" do
-          it "sets ingested by" do
-            expect { subject.save(user: user) }.to change(subject, :ingested_by).from(nil).to("foo@bar.com")
-          end
-        end
-        describe "and ingested_by is set" do
-          before { subject.ingested_by = "bob@example.com" }
-          it "does not set ingested by" do
-            expect { subject.save(user: user) }.not_to change(subject, :ingested_by)
-          end
-        end
-      end
-      describe "when :user option passed to #save!" do
-        describe "and ingested_by is not set" do
-          it "sets ingested by" do
-            expect { subject.save!(user: user) }.to change(subject, :ingested_by).from(nil).to("foo@bar.com")
-          end
-        end
-        describe "and ingested_by is set" do
-          before { subject.ingested_by = "bob@example.com" }
-          it "does not set ingested by" do
-            expect { subject.save!(user: user) }.not_to change(subject, :ingested_by)
-          end
-        end
+  describe "events" do
+    describe "on deletion with #destroy" do
+      before { subject.save(validate: false) }
+      it "should create a deletion event" do
+        expect { subject.destroy }.to change { Ddr::Events::DeletionEvent.for_object(subject).count }.from(0).to(1)
       end
     end
-    describe "saving after create" do
-      before { subject.save! }
-      it "does not set ingested_by" do
-        expect { subject.save(user: user) }.not_to change(subject, :ingested_by)
-        expect { subject.save!(user: user) }.not_to change(subject, :ingested_by)
-      end
+
+    describe "last virus check" do
+      let!(:fixity_check) { Ddr::Events::FixityCheckEvent.new }
+      before { allow(subject).to receive(:last_fixity_check) { fixity_check } }
+      its(:last_fixity_check_on) { should eq(fixity_check.event_date_time) }
+      its(:last_fixity_check_outcome) { should eq(fixity_check.outcome) }
     end
   end
 
-  describe "ingestion date" do
-    describe "on create" do
-      describe "when it's set" do
-        before { subject.ingestion_date = "2017-01-13T19:03:15Z" }
-        it "preserves the date" do
-          expect { subject.save! }.not_to change(subject, :ingestion_date)
-        end
-      end
-      describe "when it's not set" do
-        it "sets the date" do
-          expect { subject.save! }.to change(subject, :ingestion_date)
+  describe "move first desc metadata identifier to local id" do
+    let(:local_id) { 'locl001' }
+    let(:identifiers) { [ 'id001', 'id002' ] }
+    context "no desc metadata identifiers" do
+      context "local id present" do
+        before { subject.local_id = local_id }
+        it "should not change the local id" do
+          result = subject.move_first_identifier_to_local_id
+          expect(result).to be false
+          expect(subject.local_id).to eq(local_id)
         end
       end
     end
-  end
-
-  describe "permanent ID assignment" do
-    describe "when auto assignment is enabled" do
-      before do
-        allow(Ddr::Models).to receive(:auto_assign_permanent_id) { true }
-      end
-      describe "and a permanent ID is pre-assigned" do
-        before do
-          subject.permanent_id = "foo"
-        end
-        it "does not assign a permanent ID" do
-          expect { subject.save(validate: false) }.not_to change(subject, :permanent_id)
+    context "one desc metadata identifier" do
+      before { subject.descMetadata.identifier = Array(identifiers.first) }
+      context "local id not present" do
+        it "should set the local id and remove the identifier" do
+          result = subject.move_first_identifier_to_local_id
+          expect(result).to be true
+          expect(subject.local_id).to eq(identifiers.first)
+          expect(subject.descMetadata.identifier).to be_empty
         end
       end
-      describe "and no permanent ID has been pre-assigned" do
-        before do
-          expect(Ddr::Models::PermanentId).to receive(:assign!).with(subject) { nil }
-          subject.save(validate: false)
+      context "local id present" do
+        before { subject.local_id = local_id }
+        context "replace option is true" do
+          it "should set the local id and remove the identifier" do
+            result = subject.move_first_identifier_to_local_id
+            expect(result).to be true
+            expect(subject.local_id).to eq(identifiers.first)
+            expect(subject.descMetadata.identifier).to be_empty
+          end
         end
-      end
-    end
-    describe "when auto assignment is disabled" do
-      before do
-        allow(Ddr::Models).to receive(:auto_assign_permanent_id) { false }
-      end
-      it "does not assign a permanent ID" do
-        expect { subject.save(validate: false) }.not_to change(subject, :permanent_id)
-      end
-    end
-  end
-
-  describe "events" do
-    describe "ingestion" do
-      it "creates an ingestion event" do
-        expect { subject.save! }.to change { Ddr::Events::IngestionEvent.for_object(subject).count }.by(1)
-      end
-    end
-    describe "update" do
-      before { subject.save! }
-      it "creates an update event" do
-        expect { subject.save! }.to change { Ddr::Events::UpdateEvent.for_object(subject).count }.by(1)
-      end
-      describe "with options" do
-        let(:user) { FactoryGirl.create(:user) }
-        it "creates an update event with options" do
-          subject.title = [ "Changed Title" ]
-          subject.save(user: user, summary: "This event rocks!", comment: "I was testing things", detail: "A bunch of extra stuff I want to record")
-          event = Ddr::Events::UpdateEvent.for_object(subject).last
-          expect(event.user_key).to eq(user.to_s)
-          expect(event.summary).to eq "This event rocks!"
-          expect(event.comment).to eq "I was testing things"
+        context "replace option is false" do
+          context "local id matches first identifier" do
+            before { subject.descMetadata.identifier = Array(local_id) }
+            it "should remove the identifier" do
+              result = subject.move_first_identifier_to_local_id(replace: false)
+              expect(result).to be true
+              expect(subject.local_id).to eq(local_id)
+              expect(subject.descMetadata.identifier).to be_empty
+            end
+          end
+          context "local id does not match first identifier" do
+            it "should not change the local id and not remove the identifier" do
+              result = subject.move_first_identifier_to_local_id(replace: false)
+              expect(result).to be false
+              expect(subject.local_id).to eq(local_id)
+              expect(subject.descMetadata.identifier).to eq(Array(identifiers.first))
+            end
+          end
         end
       end
     end
-    describe "deaccession" do
-      before { subject.save! }
-      it "creates a deaccession event" do
-        expect { subject.deaccession }.to change { Ddr::Events::DeaccessionEvent.for_object(subject).count }.by(1)
-      end
-      it "records attributes with the event" do
-        allow(subject).to receive(:permanent_id) { "foo" }
-        subject.deaccession
-        event = Ddr::Events::DeaccessionEvent.for_object(subject).first
-        expect(event.permanent_id).to eq "foo"
-      end
-    end
-    describe "on deletion with #destroy" do
-      before { subject.save! }
-      it "creates a deletion event" do
-        expect { subject.destroy }.to change { Ddr::Events::DeletionEvent.for_object(subject).count }.from(0).to(1)
-      end
-      it "records attributes with the event" do
-        allow(subject).to receive(:permanent_id) { "foo" }
-        subject.destroy
-        event = Ddr::Events::DeletionEvent.for_object(subject).first
-        expect(event.permanent_id).to eq "foo"
+    context "more than one desc metadata identifer" do
+      before { subject.descMetadata.identifier = identifiers }
+      context "local id not present" do
+        it "should set the local id and remove the identifier" do
+          result = subject.move_first_identifier_to_local_id
+          expect(result).to be true
+          expect(subject.local_id).to eq(identifiers.first)
+          expect(subject.descMetadata.identifier).to eq(Array(identifiers.last))
+        end
       end
-    end
-    describe "last virus check" do
-      before { subject.save! }
-      let!(:fixity_check) { Ddr::Events::FixityCheckEvent.new }
-      before { allow(subject).to receive(:last_fixity_check) { fixity_check } }
-      its(:last_fixity_check_on) { should eq(fixity_check.event_date_time) }
-      its(:last_fixity_check_outcome) { should eq(fixity_check.outcome) }
-    end
-  end
-
-  describe "thumbnails" do
-    its(:can_have_thumbnail?) { is_expected.to be true }
-    it { is_expected.not_to have_thumbnail }
-    specify {
-      allow(subject.thumbnail).to receive(:has_content?) { true }
-      expect(subject).to have_thumbnail
-    }
-  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" }
+      context "local id present" do
+        before { subject.local_id = local_id }
+        context "replace option is true" do
+          it "should set the local id and remove the identifier" do
+            result = subject.move_first_identifier_to_local_id
+            expect(result).to be true
+            expect(subject.local_id).to eq(identifiers.first)
+            expect(subject.descMetadata.identifier).to eq(Array(identifiers.last))
+          end
+        end
+        context "replace option is false" do
+          context "local id matches first identifier" do
+            before { subject.descMetadata.identifier = [ local_id, identifiers.last ] }
+            it "should remove the identifier" do
+              result = subject.move_first_identifier_to_local_id(replace: false)
+              expect(result).to be true
+              expect(subject.local_id).to eq(local_id)
+              expect(subject.descMetadata.identifier).to eq(Array(identifiers.last))
+            end
+          end
+          context "local id does not match first identifier" do
+            it "should not change the local id and not remove the identifier" do
+              result = subject.move_first_identifier_to_local_id(replace: false)
+              expect(result).to be false
+              expect(subject.local_id).to eq(local_id)
+              expect(subject.descMetadata.identifier).to eq(identifiers)
+            end
+          end
+        end
       end
-      subject.rights = ["http://example.com"]
     end
-    its(:rights_statement) { is_expected.to eq rights_statement }
   end
 
 end