ddr-models 2.0.1 → 2.1.0.rc1

data/spec/index/filters_spec.rb

@@ -0,0 +1,17 @@
+module Ddr::Index
+  RSpec.describe Filters do
+
+    describe "HAS_CONTENT" do
+      subject { Filters::HAS_CONTENT }
+      its(:clauses) { is_expected.to eq(["active_fedora_model_ssi:(Component OR Attachment OR Target)"]) }
+    end
+
+    describe "class methods" do
+      describe "is_governed_by(pid)" do
+        subject { Filters.is_governed_by("test:1") }
+        its(:clauses) { is_expected.to eq(["{!term f=is_governed_by_ssim}info:fedora/test:1"]) }
+      end
+    end
+
+  end
+end

data/spec/index/query_spec.rb

@@ -0,0 +1,19 @@
+module Ddr::Index
+  RSpec.describe Query do
+
+    subject do
+      QueryBuilder.build do |query|
+        query
+          .q("foo:bar")
+          .where("spam"=>"eggs")
+          .fields("id", "foo", "spam")
+          .limit(50)
+      end
+    end
+
+    its(:to_s) { is_expected.to eq("q=foo%3Abar&fq=%7B%21term+f%3Dspam%7Deggs&fl=id%2Cfoo%2Cspam&rows=50") }
+
+    its(:params) { is_expected.to eq({q: "foo:bar", fl: "id,foo,spam", fq: ["{!term f=spam}eggs"], rows: 50}) }
+
+  end
+end

data/spec/jobs/fits_file_characterization_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+module Ddr::Jobs
+  RSpec.describe FitsFileCharacterization, jobs: true, file_characterization: true do
+
+    shared_examples "has a fits update event" do
+      let(:event) { object.update_events.last }
+      it "should have the correct event attributes" do
+        expect(event.outcome).to eq(expected_outcome)
+        expect(event.detail).to eq(expected_detail)
+        expect(event.software).to eq("fits #{fits_version}")
+      end
+    end
+
+    context "content-bearing object" do
+      let(:object) { TestContent.create }
+      let(:stdout_msg) { '<fits />' }
+      let(:stderr_msg) { 'stderr msg' }
+      let(:fits_version) { '0.9.9 '}
+      before { allow(Ddr::Jobs::FitsFileCharacterization).to receive(:fits_version) { fits_version } }
+      context "fits command is successful" do
+        let(:expected_outcome) { Ddr::Events::Event::SUCCESS }
+        let(:expected_detail) { nil }
+        before do
+          allow(Open3).to receive(:capture3) { [ stdout_msg, stderr_msg,  $? ] }
+          allow_any_instance_of(Process::Status).to receive(:success?) { true }
+          Ddr::Jobs::FitsFileCharacterization.perform(object.pid)
+          object.reload
+        end
+        it "should populate the fits datastream" do
+          expect(object.fits.content).to be_present
+        end
+        it_behaves_like "has a fits update event"
+      end
+      context "fits command is not successful" do
+        let(:expected_outcome) { Ddr::Events::Event::FAILURE }
+        let(:expected_detail) { stderr_msg }
+        before do
+          allow(Open3).to receive(:capture3) { [ stdout_msg, stderr_msg,  $? ] }
+          allow_any_instance_of(Process::Status).to receive(:success?) { false }
+          Ddr::Jobs::FitsFileCharacterization.perform(object.pid)
+          object.reload
+        end
+        it "should not populate the fits datastream" do
+          expect(object.fits.content).to_not be_present
+        end
+        it_behaves_like "has a fits update event"
+      end
+    end
+
+  end
+end

data/spec/managers/technical_metadata_manager_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+module Ddr::Managers
+  RSpec.describe TechnicalMetadataManager do
+
+    subject { described_class.new(obj) }
+
+    let(:obj) { Component.new }
+
+    describe "when fits datastream not present" do
+      its(:valid) { is_expected.to be_empty }
+      its(:well_formed) { is_expected.to be_empty }
+      its(:format_label) { is_expected.to be_empty }
+      its(:media_type) { is_expected.to be_empty }
+      its(:format_version) { is_expected.to be_empty }
+      its(:last_modified) { is_expected.to be_empty }
+      its(:modification_time) { is_expected.to be_empty }
+      its(:created) { is_expected.to be_empty }
+      its(:creation_time) { is_expected.to be_empty }
+      its(:pronom_identifier) { is_expected.to be_empty }
+      its(:creating_application) { is_expected.to be_empty }
+      its(:file_size) { is_expected.to be_empty }
+      its(:fits_version) { is_expected.to be_nil }
+      its(:fits_datetime) { is_expected.to be_nil }
+      its(:fits?) { is_expected.to be false }
+    end
+
+    describe "when content is not present" do
+      its(:checksum_digest) { is_expected.to be_nil }
+      its(:checksum_value) { is_expected.to be_nil }
+    end
+
+    describe "common metadata" do
+      before do
+        obj.fits.content = fixture_file_upload(File.join("fits", "document.xml"))
+      end
+      its(:fits?) { is_expected.to be true }
+      its(:valid) { is_expected.to eq(["false"]) }
+      its(:well_formed) { is_expected.to eq(["true"]) }
+      its(:format_label) { is_expected.to eq(["Portable Document Format"]) }
+      its(:media_type) { is_expected.to eq(["application/pdf"]) }
+      its(:format_version) { is_expected.to eq(["1.6"]) }
+      its(:last_modified) { is_expected.to eq(["2015-06-08T21:22:35Z"]) }
+      its(:created) { is_expected.to eq(["2015:06:05 15:16:23-04:00"]) }
+      its(:pronom_identifier) { is_expected.to eq(["fmt/20"]) }
+      its(:creating_application) { is_expected.to contain_exactly("Adobe Acrobat Pro 11.0.3 Paper Capture Plug-in/PREMIS Editorial Committee", "Adobe Acrobat Pro 11.0.3 Paper Capture Plug-in/Acrobat PDFMaker 11 for Word") }
+      its(:fits_version) { is_expected.to eq("0.8.5") }
+      its(:extent) { is_expected.to eq(["3786205"]) }
+      its(:file_size) { is_expected.to eq([3786205]) }
+      its(:media_type) { is_expected.to eq(["application/pdf"]) }
+
+      describe "datetime fields" do
+        its(:creation_time) { is_expected.to contain_exactly(DateTime.parse("2015-06-05 15:16:23-04:00").to_time.utc) }
+        its(:modification_time) { is_expected.to contain_exactly(DateTime.parse("2015-06-08T21:22:35Z").to_time.utc) }
+      end
+    end
+
+    describe "checksum fields" do
+      before do
+        allow(obj.content).to receive(:checksumType) { "SHA-256" }
+        allow(obj.content).to receive(:checksum) { "b744b4b308a11a7b6282b383ec428a91d77b21701d4bd09021bf0543dc8946fa" }
+      end
+
+      its(:checksum_digest) { is_expected.to eq("SHA-256") }
+      its(:checksum_value) { is_expected.to eq("b744b4b308a11a7b6282b383ec428a91d77b21701d4bd09021bf0543dc8946fa") }
+    end
+
+    describe "image metadata" do
+      before do
+        obj.fits.content = fixture_file_upload(File.join("fits", "image.xml"))
+      end
+      its(:image_width) { is_expected.to eq(["500"]) }
+      its(:image_height) { is_expected.to eq(["569"]) }
+      its(:color_space) { is_expected.to eq(["YCbCr"]) }
+    end
+
+    describe "valid? / invalid?" do
+      describe "when #valid has a 'false' value" do
+        before do
+          allow(subject).to receive(:valid) { ["false"] }
+        end
+        it { is_expected.to be_invalid }
+        it { is_expected.not_to be_valid }
+      end
+      describe "when #valid has 'false' and 'true' values" do
+        before do
+          allow(subject).to receive(:valid) { ["false", "true"] }
+        end
+        it { is_expected.to be_invalid }
+        it { is_expected.not_to be_valid }
+      end
+      describe "when #valid has a 'true' value" do
+        before do
+          allow(subject).to receive(:valid) { ["true"] }
+        end
+        it { is_expected.not_to be_invalid }
+        it { is_expected.to be_valid }
+      end
+      describe "when #valid is empty" do
+        before do
+          allow(subject).to receive(:valid) { [] }
+        end
+        it { is_expected.not_to be_invalid }
+        it { is_expected.to be_valid }
+      end
+    end
+
+    describe "ill_formed? / well_formed?" do
+      describe "when #well_formed has a 'false' value" do
+        before do
+          allow(subject).to receive(:well_formed) { ["false"] }
+        end
+        it { is_expected.to be_ill_formed }
+        it { is_expected.not_to be_well_formed }
+      end
+      describe "when #well_formed has 'false' and 'true' values" do
+        before do
+          allow(subject).to receive(:well_formed) { ["false", "true"] }
+        end
+        it { is_expected.to be_ill_formed }
+        it { is_expected.not_to be_well_formed }
+      end
+      describe "when #well_formed has a 'true' value" do
+        before do
+          allow(subject).to receive(:well_formed) { ["true"] }
+        end
+        it { is_expected.not_to be_ill_formed }
+        it { is_expected.to be_well_formed }
+      end
+      describe "when #well_formed is empty" do
+        before do
+          allow(subject).to receive(:well_formed) { [] }
+        end
+        it { is_expected.not_to be_ill_formed }
+        it { is_expected.to be_well_formed }
+      end
+    end
+
+  end
+end

data/spec/models/active_fedora_datastream_spec.rb

@@ -3,6 +3,50 @@ require 'spec_helper'
 module ActiveFedora
   RSpec.describe Datastream do
 
+    describe "#tempfile" do
+      subject { described_class.new(nil, "DS1", controlGroup: "M") }
+      describe "when the datastream has no content" do
+        it "should raise an exception" do
+          expect { subject.tempfile { |f| puts f.path } }.to raise_error(Ddr::Models::Error)
+        end
+      end
+      describe "when the datastream has content" do
+        let(:file) { fixture_file_upload("sample.pdf", "application/pdf") }
+        before do
+          subject.content = file.read
+          subject.mimeType = file.content_type
+          allow(subject).to receive(:pid) { "test:1" }
+        end
+        describe "the yielded file" do
+          it "should by default have an extension for the datastream media type" do
+            subject.tempfile do |f|
+              expect(f.path.end_with?(".pdf")).to be true
+            end
+          end
+          it "should use the prefix provided" do
+            subject.tempfile(prefix: "foo") do |f|
+              expect(File.basename(f.path).start_with?("foo")).to be true
+            end
+          end
+          it "should use the sufffix provided" do
+            subject.tempfile(suffix: "bar") do |f|
+              expect(f.path.end_with?("bar")).to be true
+            end
+          end
+          it "should by default have a prefix based on the PID" do
+            subject.tempfile do |f|
+              expect(File.basename(f.path).start_with?("test_1_DS1--")).to be true
+            end
+          end
+          it "should have the same size as the datastream content" do
+            subject.tempfile do |f|
+              expect(f.size).to eq(subject.content.length)
+            end
+          end
+        end
+      end
+    end
+
     describe "#validate_checksum!" do
       subject { described_class.new(nil, nil, controlGroup: "M") }
       let!(:checksum) { "dea56f15b309e47b74fa24797f85245dda0ca3d274644a96804438bbd659555a" }

data/spec/models/collection_spec.rb

@@ -6,21 +6,16 @@ RSpec.describe Collection, type: :model do
   it_behaves_like "it has an association", :has_many, :children, :is_member_of_collection, "Item"
   it_behaves_like "it has an association", :has_many, :targets, :is_external_target_for, "Target"
 
-  describe "terms delegated to defaultRights" do
+  describe "legacy license information" do
     before do
-      subject.default_license_title = "License Title"
-      subject.default_license_description = "License Description"
-      subject.default_license_url = "http://library.duke.edu"
-    end
-    it "should set the terms correctly" do
-      expect(subject.defaultRights.license.title.first).to eq("License Title")
-      expect(subject.defaultRights.license.description.first).to eq("License Description")
-      expect(subject.defaultRights.license.url.first).to eq("http://library.duke.edu")
+      subject.defaultRights.license.title = ["License Title"]
+      subject.defaultRights.license.description = ["License Description"]
+      subject.defaultRights.license.url = ["http://library.duke.edu"]
     end
     it "should index the terms" do
-      expect(subject.to_solr[Ddr::IndexFields::DEFAULT_LICENSE_TITLE]).to eq("License Title")
-      expect(subject.to_solr[Ddr::IndexFields::DEFAULT_LICENSE_DESCRIPTION]).to eq("License Description")
-      expect(subject.to_solr[Ddr::IndexFields::DEFAULT_LICENSE_URL]).to eq("http://library.duke.edu")
+      expect(subject.to_solr[Ddr::Index::Fields::DEFAULT_LICENSE_TITLE]).to eq("License Title")
+      expect(subject.to_solr[Ddr::Index::Fields::DEFAULT_LICENSE_DESCRIPTION]).to eq("License Description")
+      expect(subject.to_solr[Ddr::Index::Fields::DEFAULT_LICENSE_URL]).to eq("http://library.duke.edu")
     end
   end
 

data/spec/models/component_spec.rb

@@ -9,14 +9,11 @@ RSpec.describe Component, type: :model, components: true do
   it_behaves_like "a non-collection model"
 
   describe "indexing" do
-    let(:component) { FactoryGirl.build(:component) }
+    subject { FactoryGirl.build(:component) }
     before do
-      allow_any_instance_of(Component).to receive(:collection) { Collection.new(pid: 'test:1') }
-    end
-    it "should include the COLLECTION_URI field in its indexing" do
-      expect(component.index_fields).to have_key(Ddr::IndexFields::COLLECTION_URI)
-      expect(component.index_fields[Ddr::IndexFields::COLLECTION_URI]).to eq('info:fedora/test:1')
+      allow(subject).to receive(:collection) { Collection.new(pid: "test:1") }
     end
+    its(:index_fields) { is_expected.to include(Ddr::Index::Fields::COLLECTION_URI => "info:fedora/test:1") }
   end
 
 end

data/spec/models/effective_license_spec.rb

@@ -0,0 +1,49 @@
+module Ddr::Models
+  RSpec.describe EffectiveLicense do
+
+    subject { described_class.call(obj) }
+
+    let(:mock) { Struct.new(:license, :parent, :admin_policy, :pid) }
+    let(:obj) { mock.new }
+
+    let(:url) { "https://creativecommons.org/licenses/by-nc-nd/4.0/" }
+    let(:license) { License.new(url: url) }
+    before { allow(License).to receive(:get).with(url) { license } }
+
+    describe "when the object has a licence" do
+      before { obj.license = url }
+      it { is_expected.to eq(license) }
+    end
+
+    describe "when the object does not have a license" do
+      describe "when the object has a parent" do
+        let(:parent) { mock.new }
+        before do
+          parent.license = url
+          obj.parent = parent
+        end
+        it { is_expected.to eq(license) }
+      end
+      describe "when the object does not have a parent" do
+        describe "when the object has an admin policy" do
+          describe "and the admin policy is a different object" do
+            let(:admin_policy) { mock.new }
+            before do
+              admin_policy.license = url
+              obj.admin_policy = admin_policy
+            end
+            it { is_expected.to eq(license) }
+          end
+          describe "and the admin policy is the object itself" do
+            before { obj.admin_policy = obj }
+            it { is_expected.to be_nil }
+          end
+        end
+        describe "otherwise" do
+          it { is_expected.to be_nil }
+        end
+      end
+    end
+
+  end
+end

data/spec/models/has_admin_metadata_spec.rb

@@ -1,246 +1,195 @@
 require 'spec_helper'
 require 'support/ezid_mock_identifier'
 
-module Ddr
-  module Models
-    RSpec.describe HasAdminMetadata, type: :model, contacts: true do
-
-      describe "local id" do
-        subject { FactoryGirl.build(:item) }
-        describe "indexing" do
-          before { subject.local_id = "foo" }
-          it "should index the local id value" do
-            expect(subject.to_solr).to include(Ddr::IndexFields::LOCAL_ID => "foo")
-          end
-        end
-      end
+module Ddr::Models
+  RSpec.describe HasAdminMetadata, type: :model, contacts: true do
 
-      describe "permanent id and permanent url" do
-        subject { FactoryGirl.build(:item) }
+    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
+      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 "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
+          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
-
-        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
-          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
-        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)
+        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 "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
+          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
+        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
+        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
+      end
 
-        describe "indexing" do
-          let(:permanent_id) { "ark:/99999/fk4zzz" }
-          let(:permanent_url) { "http://id.library.duke.edu/ark:/99999/fk4zzz" }
-          let(:display_format) { "Image" }
+      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
-            subject.permanent_id = permanent_id
-            subject.permanent_url = permanent_url
-            subject.display_format = display_format
+            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 index the permanent id value" do
-            expect(subject.to_solr[Ddr::IndexFields::PERMANENT_ID]).to eq(permanent_id)
+          it "should create a success event" do
+            expect { subject.save }.to change { subject.update_events.count }.by(1)
           end
-          it "should index the permanent url" do
-            expect(subject.to_solr[Ddr::IndexFields::PERMANENT_URL]).to eq(permanent_url)
-          end
-          it "should index the display format" do
-            expect(subject.to_solr[Ddr::IndexFields::DISPLAY_FORMAT]).to eq(display_format)
+        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
+    describe "workflow" do
 
-        subject { FactoryGirl.build(:item) }
+      subject { FactoryGirl.build(:item) }
 
-        describe "#published?" do
-          context "object is published" do
-            before { allow(subject).to receive(:workflow_state) { Ddr::Managers::WorkflowManager::PUBLISHED } }
-            it "should return true" do
-              expect(subject).to be_published
-            end
+      describe "#published?" do
+        context "object is published" do
+          before { allow(subject).to receive(:workflow_state) { Ddr::Managers::WorkflowManager::PUBLISHED } }
+          it "should return true" do
+            expect(subject).to be_published
           end
-          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 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
+      end
 
-        describe "#publish" do
-          it "should publish the object" do
-            subject.publish
-            expect(subject).to be_published
-          end
+      describe "#publish" do
+        it "should publish the object" do
+          subject.publish
+          expect(subject).to be_published
         end
+      end
 
-        describe "#publish!" do
-          it "should publish and persist the object" do
-            subject.publish!
-            expect(subject.reload).to be_published
-          end
+      describe "#publish!" do
+        it "should publish and persist the object" do
+          subject.publish!
+          expect(subject.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
+      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 { subject.publish! }
-          it "should unpublish and persist the object" do
-            subject.unpublish!
-            expect(subject.reload).not_to be_published
-          end
+      describe "#unpublish!" do
+        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
+    describe "roles" do
 
-        subject { FactoryGirl.build(:item) }
+      subject { FactoryGirl.build(:item) }
 
-        describe "#copy_resource_roles_from" do
-          let(:other) { FactoryGirl.build(:collection) }
-          let(:resource_roles) do
-            [ FactoryGirl.build(:role, :viewer, :public, :resource),
-              FactoryGirl.build(:role, :editor, :group, :resource) ]
-          end
-          let(:policy_roles) do
-            [ FactoryGirl.build(:role, :curator, :person, :policy) ]
-          end
-          before do
-            other.roles.grant *resource_roles
-            other.roles.grant *policy_roles
-            subject.copy_resource_roles_from(other)
-          end
-          its(:roles) { should include(*resource_roles) }
-          its(:roles) { should_not include(*policy_roles) }
+      describe "#copy_resource_roles_from" do
+        let(:other) { FactoryGirl.build(:collection) }
+        let(:resource_roles) do
+          [ FactoryGirl.build(:role, :viewer, :public, :resource),
+            FactoryGirl.build(:role, :editor, :group, :resource) ]
         end
-
-        describe "#grant_roles_to_creator" do
-          let(:user) { FactoryGirl.build(:user) }
-          before { subject.grant_roles_to_creator(user) }
-          its(:roles) { should include(Ddr::Auth::Roles::Role.build(type: "Editor", agent: user.agent, scope: "resource")) }
+        let(:policy_roles) do
+          [ FactoryGirl.build(:role, :curator, :person, :policy) ]
         end
-
-        describe "persistence" do
-          let(:role) { FactoryGirl.build(:role, :downloader, :public) }
-          it "should persist the role information" do
-            subject.roles.grant role
-            subject.save!
-            subject.reload
-            expect(subject.roles).to contain_exactly(role)
-          end
+        before do
+          other.roles.grant *resource_roles
+          other.roles.grant *policy_roles
+          subject.copy_resource_roles_from(other)
         end
+        its(:roles) { should include(*resource_roles) }
+        its(:roles) { should_not include(*policy_roles) }
+      end
 
-        describe "indexing" do
-          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) }
-          let(:indexed) { subject.to_solr }
-          before { subject.roles.grant role1, role2, role3, role4 }
-          it "should index the role data serialized as JSON" do
-            expect(indexed[Ddr::IndexFields::ACCESS_ROLE]).to eq(subject.roles.to_json)
-          end
-          it "should index the agents having roles in policy scope" do
-            expect(indexed[Ddr::IndexFields::POLICY_ROLE]).to contain_exactly(role2.agent.first, role3.agent.first, role4.agent.first)
-          end
-          it "should index the agents having roles in resource scope" do
-            expect(indexed[Ddr::IndexFields::RESOURCE_ROLE]).to contain_exactly(role1.agent.first)
-          end
+      describe "#grant_roles_to_creator" do
+        let(:user) { FactoryGirl.build(:user) }
+        before { subject.grant_roles_to_creator(user) }
+        its(:roles) { should include(Ddr::Auth::Roles::Role.build(type: "Editor", agent: user.agent, scope: "resource")) }
+      end
+
+      describe "persistence" do
+        let(:role) { FactoryGirl.build(:role, :downloader, :public) }
+        it "should persist the role information" do
+          subject.roles.grant role
+          subject.save!
+          subject.reload
+          expect(subject.roles).to contain_exactly(role)
         end
+      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
+      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
+
     end
   end
 end