ddr-models 2.11.0 → 3.0.0.alpha.1

data/spec/models/active_fedora_base_spec.rb

@@ -1,10 +1,12 @@
+require 'spec_helper'
+
 RSpec.describe ActiveFedora::Base do
 
   describe ".find" do
     let!(:collection) { FactoryGirl.create(:collection) }
     describe "when called on the wrong class" do
       it "should raise an exception" do
-        expect { Item.find(collection.pid) }.to raise_error(Ddr::Models::ContentModelError)
+        expect { Item.find(collection.pid) }.to raise_error(ActiveFedora::ActiveFedoraError)
       end
     end
     describe "when called on Ddr::Models::Base" do
@@ -24,10 +26,108 @@ RSpec.describe ActiveFedora::Base do
     end
   end
 
-  its(:captionable?) { is_expected.to be false }
-  it { is_expected.not_to be_captioned }
+  describe "attachments", attachments: true do
+    before do
+      class AttachToable < ActiveFedora::Base
+        include Ddr::Models::HasAttachments
+      end
+    end
+    after do
+      Object.send(:remove_const, :AttachToable)
+    end
+    describe "#can_have_attachments?" do
+      it "#should return true if the object can have attachments, otherwise false" do
+        expect(AttachToable.new.can_have_attachments?).to be_truthy
+        expect(ActiveFedora::Base.new.can_have_attachments?).to be_falsey
+      end
+    end
+    describe "#has_attachments?" do
+      let(:attach_toable) { AttachToable.new }
+      before { attach_toable.attachments << Attachment.new }
+      it "should return true if the object has Attachments, otherwise false" do
+        expect(AttachToable.new).not_to have_attachments
+        expect(ActiveFedora::Base.new).not_to have_attachments
+        expect(attach_toable).to have_attachments
+      end
+    end
+  end
+
+  describe "children", children: true do
+    before do
+      class Childrenable < ActiveFedora::Base
+        has_many :children, property: :is_member_of, class_name: 'ActiveFedora::Base'
+      end
+    end
+    after do
+      Object.send(:remove_const, :Childrenable)
+    end
+    describe "#can_have_children?" do
+      it "should return true if object can have children, otherwise false" do
+        expect(Childrenable.new.can_have_children?).to be_truthy
+        expect(ActiveFedora::Base.new.can_have_children?).to be_falsey
+      end
+    end
+    describe "#has_children?" do
+      let(:childrenable) { Childrenable.new }
+      before { childrenable.children << ActiveFedora::Base.new }
+      it "should return true if object has children, otherwise false" do
+        expect(Childrenable.new).not_to have_children
+        expect(ActiveFedora::Base.new).not_to have_children
+        expect(childrenable).to have_children
+      end
+    end
+  end
 
-  its(:can_be_streamable?) { is_expected.to be false }
-  it { is_expected.not_to be_streamable }
+  describe "thumbnail" do
+    before do
+      class Thumbnailable < ActiveFedora::Base
+        include Ddr::Models::HasThumbnail
+      end
+    end
+    after do
+      Object.send(:remove_const, :Thumbnailable)
+    end
+    describe "#can_have_thumbnail?" do
+      it "should return true if object can have a thumbnail, else false" do
+        expect(Thumbnailable.new.can_have_thumbnail?).to be_truthy
+        expect(ActiveFedora::Base.new.can_have_thumbnail?).to be_falsey
+      end
+    end
+    describe "#has_thumbnail?" do
+      let(:thumbnailable) { Thumbnailable.new }
+      before { allow(thumbnailable.datastreams[Ddr::Datastreams::THUMBNAIL]).to receive(:has_content?).and_return(true) }
+      it "should return true if object has a thumbnail, else false" do
+        expect(thumbnailable).to have_thumbnail
+        expect(Thumbnailable.new).not_to have_thumbnail
+        expect(ActiveFedora::Base.new).not_to have_thumbnail
+      end
+    end
+  end
+
+  describe "content" do
+    before do
+      class Contentable < ActiveFedora::Base
+        include Ddr::Models::HasContent
+      end
+    end
+    after do
+      Object.send(:remove_const, :Contentable)
+    end
+    describe "#can_have_content?" do
+      it "should return true if object can have content, else false" do
+        expect(Contentable.new.can_have_content?).to be_truthy
+        expect(ActiveFedora::Base.new.can_have_content?).to be_falsey
+      end
+    end
+    describe "#has_content?" do
+      let(:contentable) { Contentable.new }
+      before { allow(contentable.datastreams[Ddr::Datastreams::CONTENT]).to receive(:has_content?).and_return(true) }
+      it "should return true if object has content, else false" do
+        expect(contentable).to have_content
+        expect(Contentable.new).not_to have_content
+        expect(ActiveFedora::Base.new).not_to have_content
+      end
+    end
+  end
 
 end

data/spec/models/active_fedora_datastream_spec.rb

@@ -1,8 +1,9 @@
+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)
@@ -12,7 +13,7 @@ module ActiveFedora
         let(:file) { fixture_file_upload("sample.pdf", "application/pdf") }
         before do
           subject.content = file.read
-          subject.mimeType = file.content_type
+          subject.mime_type = file.content_type
           allow(subject).to receive(:pid) { "test:1" }
         end
         describe "the yielded file" do
@@ -23,7 +24,7 @@ module ActiveFedora
           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
+              expect(::File.basename(f.path).start_with?("foo")).to be true
             end
           end
           it "should use the sufffix provided" do
@@ -31,9 +32,21 @@ module ActiveFedora
               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
+          describe "default prefix" do
+            describe "when the file has an id" do
+              it "should start with the id" do
+                allow(subject).to receive(:id) { "4f/78/97/71/4f789771-c663-466a-98a8-fd7c6fa0f452/foo" }
+                subject.tempfile do |f|
+                  expect(::File.basename(f.path).start_with?("4f_78_97_71_4f789771-c663-466a-98a8-fd7c6fa0f452_foo--")).to be true
+                end
+              end
+            end
+            describe "when the file has no id" do
+              it "should be NEW" do
+                subject.tempfile do |f|
+                  expect(::File.basename(f.path).start_with?("NEW--")).to be true
+                end
+              end
             end
           end
           it "should have the same size as the datastream content" do
@@ -46,152 +59,72 @@ module ActiveFedora
     end
 
     describe "#validate_checksum!" do
-      subject { described_class.new(nil, nil, controlGroup: "M") }
-      let!(:checksum) { "dea56f15b309e47b74fa24797f85245dda0ca3d274644a96804438bbd659555a" }
-      let!(:checksum_type) { "SHA-256" }
+      let(:checksum) { ActiveFedora::Checksum.new(obj) }
+      let(:obj) { double(digest: [::RDF::URI("urn:sha1:bb3200c2ddaee4bd7b9a4dc1ad3e10ed886eaef1")]) }
       context "with unpersisted content" do
         context "the datstream is new" do
-          before { allow(subject).to receive(:new?) { true } }
+          before { allow(subject).to receive(:new_record?) { true } }
           it "should raise an exception" do
-            expect { subject.validate_checksum!(checksum, checksum_type) }.to raise_error(Ddr::Models::Error)
+            expect { subject.validate_checksum!(checksum, checksum_type) }.to raise_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(Ddr::Models::Error)
+            expect { subject.validate_checksum!(checksum, checksum_type) }.to raise_error
           end
         end
       end
       context "with persisted content" do
         before do
-          allow(subject).to receive(:new?) { false }
+          allow(subject).to receive(:new_record?) { false }
           allow(subject).to receive(:pid) { "foobar:1" }
-          allow(subject).to receive(:dsCreateDate) { DateTime.now }
           allow(subject).to receive(:checksum) { checksum }
-          allow(subject).to receive(:checksumType) { checksum_type }
         end
         context "and the repository internal checksum in invalid" do
-          before { allow(subject).to receive(:dsChecksumValid) { false } }
+          before { allow(subject).to receive(:check_fixity) { false } }
           it "should raise an error" do
-            expect { subject.validate_checksum!(checksum, checksum_type) }.to raise_error(Ddr::Models::ChecksumInvalid)
+            expect { subject.validate_checksum!(checksum.value, checksum.algorithm) }
+              .to raise_error(Ddr::Models::ChecksumInvalid)
           end
         end
         context "and the repository internal checksum is valid" do
-          before { allow(subject).to receive(:dsChecksumValid) { true } }
+          before { allow(subject).to receive(:check_fixity) { true } }
           context "and the checksum type is invalid" do
-            before { allow(subject).to receive(:content) { "foo" } }
+            before { allow(subject).to receive(:content) { double } }
             it "should raise an exception" do
-              expect { subject.validate_checksum!("0123456789abcdef", "FOO-BAR") }.to raise_error(ArgumentError)
+              expect { subject.validate_checksum!("0123456789abcdef", "FOO-BAR") }
+                .to raise_error(ArgumentError)
             end
           end
           context "and the checksum type is nil" do
             it "should compare the provided checksum with the datastream checksum" do
-              expect { subject.validate_checksum!(checksum) }.not_to raise_error
+              expect { subject.validate_checksum!(checksum.value) }
+                .not_to raise_error(Ddr::Models::Error)
             end
           end
           context "and the checksum type is the same as the datastream checksum type" do
             it "should compare the provided checksum with the datastream checksum" do
-              expect { subject.validate_checksum!(checksum, checksum_type) }.not_to raise_error
+              expect { subject.validate_checksum!(checksum.value, checksum.algorithm) }
+                .not_to raise_error(Ddr::Models::Error)
             end
           end
           context "and the checksum type differs from the datastream checksum type" do
             let!(:md5digest) { "273ae0f4aa60d94e89bc0e0652ae2c8f" }
             it "should generate a checksum for comparison" do
-              expect(subject).not_to receive(:checksum)
               allow(subject).to receive(:content_digest).with("MD5") { md5digest }
-              expect { subject.validate_checksum!(md5digest, "MD5") }.not_to raise_error
+              expect { subject.validate_checksum!(md5digest, "MD5") }.not_to raise_error(Ddr::Models::Error)
             end
           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(Ddr::Models::ChecksumInvalid)
+              expect { subject.validate_checksum!("0123456789abcdef", checksum.algorithm) }
+                .to raise_error(Ddr::Models::ChecksumInvalid)
             end
           end
         end
       end
     end
 
-    describe "extensions for external datastreams" do
-      subject { described_class.new(nil, nil, controlGroup: "E") }
-
-      describe "#file_path" do
-        it "should return nil when dsLocation is not set" do
-          expect(subject.file_path).to be_nil
-        end
-        it "should return nil when dsLocation is not a file URI" do
-          subject.dsLocation = "http://library.duke.edu/"
-          expect(subject.file_path).to be_nil
-        end
-        it "should return the file path when dsLocation is a file URI" do
-          subject.dsLocation = "file:/tmp/foo/bar.txt"
-          expect(subject.file_path).to eq "/tmp/foo/bar.txt"
-        end
-      end
-
-      describe "#file_name" do
-        it "should return nil when dsLocation is not set" do
-          expect(subject.file_name).to be_nil
-        end
-        it "should return nil when dsLocation is not a file URI" do
-          subject.dsLocation = "http://library.duke.edu/"
-          expect(subject.file_name).to be_nil
-        end
-        it "should return the file name when dsLocation is a file URI" do
-          subject.dsLocation = "file:/tmp/foo/bar.txt"
-          expect(subject.file_name).to eq "bar.txt"
-        end
-      end
-
-      describe "#file_size" do
-        it "should return nil when dsLocation is not set" do
-          expect(subject.file_size).to be_nil
-        end
-        it "should return nil when dsLocation is not a file URI" do
-          subject.dsLocation = "http://library.duke.edu/"
-          expect(subject.file_size).to be_nil
-        end
-        it "should return the file name when dsLocation is a file URI" do
-          allow(File).to receive(:size).with("/tmp/foo/bar.txt") { 42 }
-          subject.dsLocation = "file:/tmp/foo/bar.txt"
-          expect(subject.file_size).to eq 42
-        end
-      end
-
-    end # external datastreams
-
-    describe "notifications" do
-      let(:events) { [] }
-      before {
-        @subscriber = ActiveSupport::Notifications.subscribe(event_name) do |name, start, finish, id, payload|
-          events << payload
-        end
-      }
-      after {
-        ActiveSupport::Notifications.unsubscribe(@subscriber)
-      }
-      describe "on create" do
-        let(:obj) { ActiveFedora::Base.create }
-        let(:event_name) { "save.repo_file" }
-        specify {
-          obj.add_file_datastream("foo", dsid: "DS1", controlGroup: "M")
-          obj.save!
-          expect(events.last[:pid]).to eq obj.pid
-          expect(events.last[:file_id]).to eq "DS1"
-          expect(events.last[:profile]).to be_present
-        }
-      end
-      describe "on destroy" do
-        let(:obj) { FactoryGirl.create(:item) }
-        let(:event_name) { "delete.repo_file" }
-        specify {
-          obj.descMetadata.delete
-          expect(events.first[:pid]).to eq obj.pid
-          expect(events.first[:file_id]).to eq "descMetadata"
-          expect(events.first[:profile]).to be_present
-        }
-      end
-    end
-
   end
 end

data/spec/models/admin_set_spec.rb

@@ -1,58 +1,25 @@
 module Ddr::Models
-  RSpec.describe AdminSet, ddr_aux: true, admin_set: true do
+  RSpec.describe AdminSet do
 
     describe ".call" do
-      let(:obj) { Item.new }
+      subject { described_class.call(obj) }
 
       describe "when the object has an admin set" do
-        before { obj.admin_set = "dvs" }
-        let(:admin_set) {
-          described_class.new("id"=>1, "code"=>"dvs", "title"=>"Data and Visualization Services", "created_at"=>"2015-09-15T16:15:58.514Z", "updated_at"=>"2015-09-15T16:15:58.514Z")
-        }
-        describe "and the admin set code is found" do
-          before {
-            allow(described_class).to receive(:find_by_code).with("dvs") { admin_set }
-          }
-          it "returns an AdminSet instance" do
-            expect(described_class.call(obj)).to eq(admin_set)
+        let(:obj) { double(admin_set: "dvs") }
+        before do
+          allow(described_class).to receive(:find).with(code: "dvs") do
+            described_class.new("id"=>1, "code"=>"dvs", "title"=>"Data and Visualization Services", "created_at"=>"2015-09-15T16:15:58.514Z", "updated_at"=>"2015-09-15T16:15:58.514Z")
           end
         end
-        describe "and the admin set is not found" do
-          before {
-            allow(described_class).to receive(:find_by_code).with("dvs")
-                                       .and_raise(ActiveResource::ResourceNotFound, "404")
-          }
-          it "raises an exception" do
-            expect { described_class.call(obj) }.to raise_error(Ddr::Models::NotFoundError)
-          end
-        end
-      end
 
-      describe "when the object does not have an admin set" do
-        it "returns nil" do
-          expect(described_class).to receive(:find_by_code).and_call_original
-          expect(described_class.call(obj)).to be_nil
-        end
+        its(:to_s) { is_expected.to eq("Data and Visualization Services") }
       end
-    end
 
-    describe ".keys" do
-      let(:entries) { [ described_class.new(id: 1, code: 'dvs', title: 'D and V S Department'),
-                        described_class.new(id: 2, code: 'abc', title: 'ABC Department') ] }
-      let(:response_collection) { ActiveResource::Collection.new }
-      before do
-        response_collection.elements = entries
-        allow(described_class).to receive(:all) { response_collection }
-      end
-      it "returns the defined codes" do
-        expect(described_class.keys).to match_array([ entries[0].code, entries[1].code ])
+      describe "when the object does not have an admin set" do
+        let(:obj) { double(admin_set: nil) }
+        it { is_expected.to be_nil }
       end
     end
 
-    describe "instance methods" do
-      subject { described_class.new("id"=>1, "code"=>"dvs", "title"=>"Data and Visualization Services", "created_at"=>"2015-09-15T16:15:58.514Z", "updated_at"=>"2015-09-15T16:15:58.514Z") }
-      its(:to_s) { is_expected.to eq("Data and Visualization Services") }
-    end
-
   end
 end

data/spec/models/attachment_spec.rb

@@ -1,10 +1,9 @@
+require 'spec_helper'
+
 RSpec.describe Attachment, type: :model, attachments: true do
 
   it_behaves_like "a DDR model"
   it_behaves_like "an object that can have content"
-  it_behaves_like "it has an association", :belongs_to, :attached_to, :is_attached_to, "ActiveFedora::Base"
   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/collection_spec.rb

@@ -1,34 +1,15 @@
-RSpec.describe Collection, type: :model do
+require 'spec_helper'
 
-  subject { described_class.new(title: ["Test Collection"], admin_set: "foo") }
+RSpec.describe Collection, type: :model do
 
   it_behaves_like "a DDR model"
-  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"
-  it_behaves_like "a publishable object"
-  it_behaves_like "an object that cannot be streamable"
-
-  describe "admin set" do
-    before do
-      subject.admin_set = "foo"
-    end
-    it "indexes the admin set title" do
-      expect(subject.to_solr[Ddr::Index::Fields::ADMIN_SET_TITLE]).to eq("Foo Admin Set")
-    end
-  end
-
-  describe "title" do
-    it "indexes the collection title" do
-      expect(subject.to_solr[Ddr::Index::Fields::COLLECTION_TITLE]).to eq("Test Collection")
-    end
-  end
 
   describe "#components_from_solr" do
-    subject { Collection.new(pid: 'test:1') }
+    subject { Collection.new(id: 'test-1') }
     before do
-      allow_any_instance_of(Component).to receive(:collection_uri).and_return(subject.internal_uri)
+      allow_any_instance_of(Component).to receive(:collection_id).and_return(subject.id)
     end
-    it "returns the correct component(s)" do
+    it "should return the correct component(s)" do
       component = Component.create
       docs = subject.components_from_solr
       expect(docs.size).to eq(1)
@@ -37,18 +18,15 @@ RSpec.describe Collection, type: :model do
   end
 
   describe "validation" do
-    before do
-      subject.title = nil
-    end
-    it "requires a title" do
+    it "should require a title" do
       expect(subject).to_not be_valid
-      expect(subject.errors.messages).to have_key(:title)
+      expect(subject.errors.messages).to have_key(:dc_title)
     end
   end
 
   describe "creation" do
-    before { subject.save! }
-    it "is governed by itself" do
+    subject { Collection.create(dc_title: [ "Test Collection" ]) }
+    it "should be governed by itself" do
       expect(subject.admin_policy).to eq(subject)
     end
   end
@@ -56,200 +34,8 @@ RSpec.describe Collection, type: :model do
   describe "roles granted to creator" do
     let(:user) { FactoryGirl.build(:user) }
     before { subject.grant_roles_to_creator(user) }
-    its(:roles) { is_expected.to include(Ddr::Auth::Roles::Role.build(type: "Curator", agent: user, scope: "policy")) }
-  end
-
-  describe "default roles granted" do
-    describe "and the metadata managers group is set" do
-      before do
-        allow(Ddr::Auth).to receive(:metadata_managers_group) { "metadata_managers" }
-        subject.save!
-      end
-      it "includes the MetadataEditor role in policy scope for the Metadata Managers group" do
-        expect(subject.roles.to_a).to eq([Ddr::Auth::Roles::Role.build(type: "MetadataEditor", agent: "metadata_managers", scope: "policy")])
-      end
-    end
-    describe "and the metadata managers group is not set" do
-      before do
-        allow(Ddr::Auth).to receive(:metadata_managers_group) { nil }
-        subject.save!
-      end
-      its(:roles) { is_expected.to be_empty }
-    end
-  end
-
-  describe "attachments" do
-    its(:can_have_attachments?) { is_expected.to be true }
-    it { is_expected.not_to have_attachments }
-    specify {
-      subject.attachments << Attachment.new
-      expect(subject).to have_attachments
-    }
-  end
-
-  describe "content" do
-    its(:can_have_content?) { is_expected.to be false }
-    it { is_expected.to_not have_content }
-  end
-
-  describe "children" do
-    its(:can_have_children?) { is_expected.to be true }
-    it { is_expected.to_not have_children }
-    specify {
-      subject.children << Item.new
-      expect(subject).to have_children
-    }
-  end
-
-  describe "#default_structure" do
-    before do
-      allow(SecureRandom).to receive(:uuid).and_return("abc-def", "ghi-jkl", "mno-pqr", "stu-vwx", "yza-bcd", "efg-hij")
-    end
-    describe "when the collection has no items" do
-      let(:expected) do
-        xml = <<-EOS
-            <mets xmlns="http://www.loc.gov/METS/" xmlns:xlink="http://www.w3.org/1999/xlink">
-              <metsHdr>
-                <agent ROLE="#{Ddr::Models::Structures::Agent::ROLE_CREATOR}">
-                  <name>#{Ddr::Models::Structures::Agent::NAME_REPOSITORY_DEFAULT}</name>
-                </agent>
-              </metsHdr>
-              <structMap TYPE="#{Ddr::Models::Structure::TYPE_DEFAULT}" />
-            </mets>
-        EOS
-        xml
-      end
-      it "should be the appropriate structure" do
-        expect(subject.default_structure.to_xml).to be_equivalent_to(expected)
-      end
-    end
-    describe "when the collection has items" do
-      let(:item1) { FactoryGirl.create(:item) }
-      let(:item2) { FactoryGirl.create(:item) }
-      before do
-        item1.local_id = "test002"
-        item1.permanent_id = "ark:/99999/fk4aaa"
-        item1.save!
-        item2.local_id = "test001"
-        item2.permanent_id = "ark:/99999/fk4bbb"
-        item2.save!
-        subject.children << item1
-        subject.children << item2
-        subject.save!
-      end
-      after do
-        item1.destroy
-        item2.destroy
-      end
-      describe "without nested paths" do
-        let(:expected) do
-          xml = <<-EOS
-            <mets xmlns="http://www.loc.gov/METS/" xmlns:xlink="http://www.w3.org/1999/xlink">
-              <metsHdr>
-                <agent ROLE="#{Ddr::Models::Structures::Agent::ROLE_CREATOR}">
-                  <name>#{Ddr::Models::Structures::Agent::NAME_REPOSITORY_DEFAULT}</name>
-                </agent>
-              </metsHdr>
-              <structMap TYPE="#{Ddr::Models::Structure::TYPE_DEFAULT}">
-                <div ORDER="1">
-                  <mptr LOCTYPE="ARK" xlink:href="ark:/99999/fk4bbb" />
-                </div>
-                <div ORDER="2">
-                  <mptr LOCTYPE="ARK" xlink:href="ark:/99999/fk4aaa" />
-                </div>
-              </structMap>
-            </mets>
-          EOS
-          xml
-        end
-        it "should be the appropriate structure" do
-          expect(subject.default_structure.to_xml).to be_equivalent_to(expected)
-        end
-      end
-      describe "with nested paths" do
-        let(:item3) { FactoryGirl.create(:item) }
-        let(:item4) { FactoryGirl.create(:item) }
-        let(:item5) { FactoryGirl.create(:item) }
-        let(:item6) { FactoryGirl.create(:item) }
-        let(:expected) do
-          xml = <<-EOS
-            <mets xmlns="http://www.loc.gov/METS/" xmlns:xlink="http://www.w3.org/1999/xlink">
-              <metsHdr>
-                <agent ROLE="#{Ddr::Models::Structures::Agent::ROLE_CREATOR}">
-                  <name>#{Ddr::Models::Structures::Agent::NAME_REPOSITORY_DEFAULT}</name>
-                </agent>
-              </metsHdr>
-              <structMap TYPE="#{Ddr::Models::Structure::TYPE_DEFAULT}">
-                <div LABEL="foo" ORDER="1" TYPE="Directory">
-                  <div LABEL="b&amp;apos;a&amp;quot;r&amp;quot;" ORDER="1" TYPE="Directory">
-                    <div ORDER="1">
-                      <mptr LOCTYPE="ARK" xlink:href="ark:/99999/fk4aaa" />
-                    </div>
-                    <div ORDER="2">
-                      <mptr LOCTYPE="ARK" xlink:href="ark:/99999/fk4bbb" />
-                    </div>
-                  </div>
-                  <div LABEL="baz" ORDER="2" TYPE="Directory">
-                    <div ORDER="1">
-                      <mptr LOCTYPE="ARK" xlink:href="ark:/99999/fk4ddd" />
-                    </div>
-                    <div ORDER="2">
-                      <mptr LOCTYPE="ARK" xlink:href="ark:/99999/fk4ccc" />
-                    </div>
-                  </div>
-                  <div ORDER="3">
-                    <mptr LOCTYPE="ARK" xlink:href="ark:/99999/fk4fff" />
-                  </div>
-                  <div ORDER="4">
-                    <mptr LOCTYPE="ARK" xlink:href="ark:/99999/fk4eee" />
-                  </div>
-                </div>
-              </structMap>
-            </mets>
-          EOS
-          xml
-        end
-        before do
-          item3.local_id = "test003"
-          item3.permanent_id = "ark:/99999/fk4ccc"
-          item3.save!
-          item4.local_id = "test004"
-          item4.permanent_id = "ark:/99999/fk4ddd"
-          item4.save!
-          item5.local_id = "test005"
-          item5.permanent_id = "ark:/99999/fk4eee"
-          item5.save!
-          item6.local_id = "test006"
-          item6.permanent_id = "ark:/99999/fk4fff"
-          item6.save!
-          subject.children << item3
-          subject.children << item4
-          subject.children << item5
-          subject.children << item6
-          subject.save!
-          item1.nested_path = %Q[foo/b'a"r"/a.doc]
-          item1.save!
-          item2.nested_path = %Q[foo/b'a"r"/b.txt]
-          item2.save!
-          item3.nested_path = %Q[foo/baz/d.pdf]
-          item3.save!
-          item4.nested_path = %Q[foo/baz/c.txt]
-          item4.save!
-          item5.nested_path = %Q[foo/f.doc]
-          item5.save!
-          item6.nested_path = %Q[foo/e.pdf]
-          item6.save!
-        end
-        after do
-          item3.destroy
-          item4.destroy
-          item5.destroy
-          item6.destroy
-        end
-        it "should be the appropriate structure" do
-          expect(subject.default_structure.to_xml).to be_equivalent_to(expected)
-        end
-      end
+    it "should include Curator roles in both resource abd policy scopes" do
+      expect(subject.roles.to_a).to eq([Ddr::Auth::Roles::Role.build(type: "Curator", agent: user.agent, scope: "resource"), Ddr::Auth::Roles::Role.build(type: "Curator", agent: user.agent, scope: "policy")])
     end
   end