active-fedora 11.0.0.rc1 → 11.0.0.rc2

data/spec/unit/indexing_spec.rb

@@ -25,7 +25,7 @@ describe ActiveFedora::Indexing do
       Object.send(:remove_const, :SpecNode)
     end
 
-    subject { SpecNode.new }
+    subject(:node) { SpecNode.new }
 
     describe "#create_needs_index?" do
       subject { SpecNode.new.send(:create_needs_index?) }
@@ -55,10 +55,10 @@ describe ActiveFedora::Indexing do
 
     let(:test_object) { SpecNode.new(title: ['first title'], abstract: 'The abstract') }
 
-    subject { test_object.to_solr }
+    subject(:solr_doc) { test_object.to_solr }
 
     it "indexs the rdf properties" do
-      expect(subject).to include('title_tesim' => ['first title'], 'abstract_ssi' => 'The abstract')
+      expect(solr_doc).to include('title_tesim' => ['first title'], 'abstract_ssi' => 'The abstract')
     end
 
     it "adds id, system_create_date, system_modified_date from object attributes" do
@@ -80,7 +80,7 @@ describe ActiveFedora::Indexing do
         expect(mock2).to receive(:to_solr).and_return("two" => "title two")
 
         allow(test_object).to receive(:declared_attached_files).and_return(ds1: mock1, ds2: mock2)
-        expect(subject).to include('one' => 'title one', 'two' => 'title two')
+        expect(solr_doc).to include('one' => 'title one', 'two' => 'title two')
       end
     end
   end

data/spec/unit/loadable_from_json_spec.rb

@@ -23,17 +23,17 @@ describe ActiveFedora::LoadableFromJson::SolrBackedResource do
 
   describe "#query" do
     describe "a known relationship" do
-      subject { resource.query(predicate: ::RDF::Vocab::DC.extent) }
+      subject(:resources) { resource.query(predicate: ::RDF::Vocab::DC.extent) }
 
       it "is enumerable" do
-        expect(subject.map(&:object)).to eq [RDF::URI('http://example.org/123')]
+        expect(resources.map(&:object)).to eq [RDF::URI('http://example.org/123')]
       end
     end
 
     describe "a unknown relationship" do
-      subject { resource.query(predicate: ::RDF::Vocab::DC.accrualPeriodicity) }
+      subject(:resources) { resource.query(predicate: ::RDF::Vocab::DC.accrualPeriodicity) }
       it "raises an error" do
-        expect { subject }.to raise_error "Unable to find reflection for http://purl.org/dc/terms/accrualPeriodicity in Foo"
+        expect { resources }.to raise_error "Unable to find reflection for http://purl.org/dc/terms/accrualPeriodicity in Foo"
       end
     end
   end

data/spec/unit/model_classifier_spec.rb

@@ -11,7 +11,7 @@ describe ActiveFedora::ModelClassifier do
   end
 
   let(:class_names) { ["ParentClass::SiblingClass", "ParentClass::OtherSiblingClass", "ParentClass::SubclassClass", "ParentClass::NoSuchClass"] }
-  subject { described_class.new class_names }
+  subject(:classifier) { described_class.new class_names }
 
   describe ".class_from_string" do
     it "returns class constants based on strings" do
@@ -33,17 +33,17 @@ describe ActiveFedora::ModelClassifier do
 
   describe '#models' do
     it 'converts class names to classes' do
-      expect(subject.models).to match_array [ParentClass::SiblingClass, ParentClass::OtherSiblingClass, ParentClass::SubclassClass]
+      expect(classifier.models).to match_array [ParentClass::SiblingClass, ParentClass::OtherSiblingClass, ParentClass::SubclassClass]
     end
   end
 
   describe '#best_model' do
     it 'selects the most specific matching model' do
-      expect(subject.best_model(default: nil)).to eq ParentClass::SubclassClass
+      expect(classifier.best_model(default: nil)).to eq ParentClass::SubclassClass
     end
 
     it 'filters models to subclasses of the default' do
-      expect(subject.best_model(default: ActiveFedora::Base)).to eq ActiveFedora::Base
+      expect(classifier.best_model(default: ActiveFedora::Base)).to eq ActiveFedora::Base
     end
   end
 end

data/spec/unit/nom_datastream_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe ActiveFedora::NomDatastream do
   describe "test" do
-    subject {
+    subject(:datastream) {
       class MyNomDatastream < ActiveFedora::NomDatastream
         set_terminology do |t|
           t.a path: '//a', accessor: lambda { |x| x.text }, index: 'a_s'
@@ -13,21 +13,21 @@ describe ActiveFedora::NomDatastream do
       MyNomDatastream.new
     }
     before do
-      subject.content = '<root><a>123</a><b><c>asdf</c></b></root>'
+      datastream.content = '<root><a>123</a><b><c>asdf</c></b></root>'
     end
 
     it "works" do
-      expect(subject.a).to include("123")
+      expect(datastream.a).to include("123")
     end
 
     it "to_solrs" do
-      expect(subject.to_solr['a_s']).to include('123')
-      expect(subject.to_solr['b_s']).to include('asdf')
+      expect(datastream.to_solr['a_s']).to include('123')
+      expect(datastream.to_solr['b_s']).to include('asdf')
     end
   end
 
   describe "with options for .set_terminology" do
-    subject {
+    subject(:datastream) {
       class TerminologyOptions < ActiveFedora::NomDatastream
         set_terminology(namespaces: {
                           'dc' => "http://purl.org/dc/elements/1.1/",
@@ -41,7 +41,7 @@ describe ActiveFedora::NomDatastream do
     }
 
     before do
-      subject.content = %(
+      datastream.content = %(
         <root
           xmlns:dc="http://purl.org/dc/elements/1.1/"
           xmlns:dcterms="http://purl.org/dc/terms/"
@@ -54,7 +54,7 @@ describe ActiveFedora::NomDatastream do
     end
 
     it "scopes #a attribute to only the dc namespace" do
-      expect(subject.a).to eq ["123"]
+      expect(datastream.a).to eq ["123"]
     end
   end
 end

data/spec/unit/om_datastream_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe ActiveFedora::OmDatastream do
-  subject { described_class.new }
+  subject(:datastream) { described_class.new }
   it { should be_metadata }
 
   it "includes the Solrizer::XML::TerminologyBasedSolrizer for .to_solr support" do
@@ -23,16 +23,16 @@ describe ActiveFedora::OmDatastream do
   end
 
   describe "#prefix" do
-    subject { described_class.new }
+    subject(:datastream) { described_class.new }
     it "reflects the dsid" do
-      expect(subject.send(:prefix, 'descMetadata')).to eq "desc_metadata__"
+      expect(datastream.send(:prefix, 'descMetadata')).to eq "desc_metadata__"
     end
   end
 
   describe '#xml_template' do
-    subject { described_class.xml_template.to_xml }
+    subject(:datastream) { described_class.xml_template.to_xml }
     it "returns an empty xml document" do
-      expect(subject).to be_equivalent_to("<?xml version=\"1.0\"?>\n<xml/>\n")
+      expect(datastream).to be_equivalent_to("<?xml version=\"1.0\"?>\n<xml/>\n")
     end
   end
 
@@ -54,17 +54,17 @@ describe ActiveFedora::OmDatastream do
             "foo__"
           end
         end
-        subject.title = 'Science'
+        datastream.title = 'Science'
       end
       after do
         Object.send(:remove_const, :MyDatastream)
       end
-      subject { MyDatastream.new }
+      subject(:datastream) { MyDatastream.new }
       it "uses the prefix" do
-        expect(subject.to_solr).to have_key('foo__title_tesim')
+        expect(datastream.to_solr).to have_key('foo__title_tesim')
       end
       it "does not prefix fields that aren't defined by this datastream" do
-        expect(subject.to_solr('id' => 'test:123')).to have_key('id')
+        expect(datastream.to_solr('id' => 'test:123')).to have_key('id')
       end
     end
   end
@@ -170,55 +170,55 @@ describe ActiveFedora::OmDatastream do
     end
 
     before do
-      allow(subject).to receive(:ldp_source).and_return(ldp_source)
+      allow(datastream).to receive(:ldp_source).and_return(ldp_source)
     end
 
     it "persists the product of .to_xml in fedora" do
-      subject.serialize!
-      subject.save
-      expect(subject.mime_type).to eq 'text/xml'
+      datastream.serialize!
+      datastream.save
+      expect(datastream.mime_type).to eq 'text/xml'
     end
   end
 
   describe 'setting content' do
-    subject { described_class.new }
-    before { subject.content = "<a />" }
+    subject(:datastream) { described_class.new }
+    before { datastream.content = "<a />" }
 
     it "updates the content" do
-      expect(subject.content).to eq "<?xml version=\"1.0\"?>\n<a/>"
+      expect(datastream.content).to eq "<?xml version=\"1.0\"?>\n<a/>"
     end
 
     it "marks the object as changed" do
-      expect(subject).to be_changed
+      expect(datastream).to be_changed
     end
 
     it "update ngxml and mark the xml as loaded" do
-      expect(subject.ng_xml.to_xml).to match(/<a\/>/)
-      expect(subject.xml_loaded).to be true
+      expect(datastream.ng_xml.to_xml).to match(/<a\/>/)
+      expect(datastream.xml_loaded).to be true
     end
   end
 
   describe 'ng_xml=' do
     let(:sample_raw_xml) { "<foo><xmlelement/></foo>" }
 
-    subject { described_class.new }
+    subject(:datastream) { described_class.new }
 
     it "parses raw xml for you" do
-      subject.ng_xml = sample_raw_xml
-      expect(subject.ng_xml).to be_kind_of Nokogiri::XML::Document
-      expect(subject.ng_xml.to_xml).to be_equivalent_to(sample_raw_xml)
+      datastream.ng_xml = sample_raw_xml
+      expect(datastream.ng_xml).to be_kind_of Nokogiri::XML::Document
+      expect(datastream.ng_xml.to_xml).to be_equivalent_to(sample_raw_xml)
     end
 
     it "alwayses set a document when an Element is passed" do
-      subject.ng_xml = Nokogiri::XML(sample_raw_xml).xpath('//xmlelement').first
-      expect(subject.ng_xml).to be_kind_of Nokogiri::XML::Document
-      expect(subject.ng_xml.to_xml).to be_equivalent_to("<xmlelement/>")
+      datastream.ng_xml = Nokogiri::XML(sample_raw_xml).xpath('//xmlelement').first
+      expect(datastream.ng_xml).to be_kind_of Nokogiri::XML::Document
+      expect(datastream.ng_xml.to_xml).to be_equivalent_to("<xmlelement/>")
     end
 
     it "marks the datastream as changed" do
       expect {
-        subject.ng_xml = sample_raw_xml
-      }.to change { subject.changed? }.from(false).to(true)
+        datastream.ng_xml = sample_raw_xml
+      }.to change { datastream.changed? }.from(false).to(true)
     end
   end
 
@@ -226,23 +226,23 @@ describe ActiveFedora::OmDatastream do
     let(:doc) { Nokogiri::XML::Document.parse("<text_document/>") }
 
     it "ng_xml.to_xmls" do
-      allow(subject).to receive(:ng_xml).and_return(doc)
-      expect(subject.to_xml).to eq "<?xml version=\"1.0\"?>\n<text_document/>"
+      allow(datastream).to receive(:ng_xml).and_return(doc)
+      expect(datastream.to_xml).to eq "<?xml version=\"1.0\"?>\n<text_document/>"
     end
 
     it 'accepts an optional Nokogiri::XML Document as an argument and insert its fields into that (mocked test)' do
       expect(doc.root).to receive(:add_child) # .with(test_ds.ng_xml.root)
-      subject.to_xml(doc)
+      datastream.to_xml(doc)
     end
 
     context "with some existing content" do
       before do
-        subject.content = "<test_xml/>"
+        datastream.content = "<test_xml/>"
       end
       it 'accepts an optional Nokogiri::XML Document as an argument and insert its fields into that (functional test)' do
         expected_result = "<test_document><foo/><test_xml/></test_document>"
         doc = Nokogiri::XML::Document.parse("<test_document><foo/></test_document>")
-        result = subject.to_xml(doc)
+        result = datastream.to_xml(doc)
         expect(doc).to be_equivalent_to expected_result
         expect(result).to be_equivalent_to expected_result
       end
@@ -250,25 +250,25 @@ describe ActiveFedora::OmDatastream do
       it 'adds to root of Nokogiri::XML::Documents, but add directly to the elements if a Nokogiri::XML::Node is passed in' do
         doc = Nokogiri::XML::Document.parse("<test_document/>")
         el = Nokogiri::XML::Node.new("test_element", Nokogiri::XML::Document.new)
-        expect(subject.to_xml(doc)).to be_equivalent_to "<test_document><test_xml/></test_document>"
-        expect(subject.to_xml(el)).to be_equivalent_to "<test_element/>"
+        expect(datastream.to_xml(doc)).to be_equivalent_to "<test_document><test_xml/></test_document>"
+        expect(datastream.to_xml(el)).to be_equivalent_to "<test_element/>"
       end
     end
   end
 
   describe '.update_values' do
-    subject { described_class.new }
+    subject(:datastream) { described_class.new }
 
-    before { subject.content = fixture(File.join("mods_articles", "mods_article1.xml")).read }
+    before { datastream.content = fixture(File.join("mods_articles", "mods_article1.xml")).read }
 
     it "updates a value internally call OM::XML::TermValueOperators::update_values if internal_solr_doc is not set" do
-      expect(subject).to receive(:om_update_values)
-      subject.update_values([{ ":person" => "0" }, "role", "text"] => { "0" => "role1", "1" => "role2", "2" => "role3" })
+      expect(datastream).to receive(:om_update_values)
+      datastream.update_values([{ ":person" => "0" }, "role", "text"] => { "0" => "role1", "1" => "role2", "2" => "role3" })
     end
 
     it "sets changed to true" do
-      subject.update_values([{ ":person" => "0" }, "role", "text"] => { "0" => "role1", "1" => "role2", "2" => "role3" })
-      expect(subject).to be_changed
+      datastream.update_values([{ ":person" => "0" }, "role", "text"] => { "0" => "role1", "1" => "role2", "2" => "role3" })
+      expect(datastream).to be_changed
     end
   end
 
@@ -285,10 +285,10 @@ describe ActiveFedora::OmDatastream do
       @obj.destroy
       Object.send(:remove_const, :MyObj)
     end
-    subject { @obj.reload.descMetadata }
+    subject(:datastream) { @obj.reload.descMetadata }
     it "does not load the descMetadata datastream when calling content_changed?" do
       expect(@obj).to_not receive(:content)
-      expect(subject).to_not be_content_changed
+      expect(datastream).to_not be_content_changed
     end
   end
 end

data/spec/unit/ordered_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe ActiveFedora::Orders do
-  subject { Image.new }
+  subject(:image) { Image.new }
   before do
     class Member < ActiveFedora::Base
     end
@@ -19,9 +19,9 @@ describe ActiveFedora::Orders do
   describe "<<" do
     it "does not accept base objects" do
       member = Member.new
-      expect { subject.ordered_member_proxies << member }.to raise_error ActiveFedora::AssociationTypeMismatch
-      expect(subject).not_to be_changed
-      expect(subject.list_source).not_to be_changed
+      expect { image.ordered_member_proxies << member }.to raise_error ActiveFedora::AssociationTypeMismatch
+      expect(image).not_to be_changed
+      expect(image.list_source).not_to be_changed
     end
   end
 
@@ -62,53 +62,53 @@ describe ActiveFedora::Orders do
     describe "<<" do
       it "appends" do
         member = Member.new
-        subject.save!
-        expect(subject.ordered_members << member).to eq [member]
-        expect(subject.ordered_members).to eq [member]
-        expect(subject.members).to eq [member]
-        expect(subject.ordered_member_proxies.to_a.length).to eq 1
-        subject.save!
-        expect(subject.head).not_to be_blank
-        expect(subject.reload.head).not_to be_blank
+        image.save!
+        expect(image.ordered_members << member).to eq [member]
+        expect(image.ordered_members).to eq [member]
+        expect(image.members).to eq [member]
+        expect(image.ordered_member_proxies.to_a.length).to eq 1
+        image.save!
+        expect(image.head).not_to be_blank
+        expect(image.reload.head).not_to be_blank
       end
       it "maintains member associations" do
         member = Member.create
-        subject.ordered_members << member
-        subject.save
-        subject.reload
-        expect(subject.members).to eq [member]
+        image.ordered_members << member
+        image.save
+        image.reload
+        expect(image.members).to eq [member]
       end
     end
     describe "#=" do
       it "sets ordered members" do
         member = Member.new
         member_2 = Member.new
-        subject.ordered_members << member
-        expect(subject.ordered_members).to eq [member]
-        subject.ordered_members = [member_2, member_2]
-        expect(subject.ordered_members).to eq [member_2, member_2]
+        image.ordered_members << member
+        expect(image.ordered_members).to eq [member]
+        image.ordered_members = [member_2, member_2]
+        expect(image.ordered_members).to eq [member_2, member_2]
         # Removing from ordering is not the same as removing from aggregation.
-        expect(subject.members).to contain_exactly member, member_2
+        expect(image.members).to contain_exactly member, member_2
       end
     end
     describe "+=" do
       it "appends ordered members" do
         member = Member.new
         member_2 = Member.new
-        subject.ordered_members << member
-        expect(subject.ordered_members += [member, member_2]).to eq [member, member, member_2]
-        expect(subject.ordered_members).to eq [member, member, member_2]
-        expect(subject.ordered_member_proxies.map(&:target)).to eq [member, member, member_2]
+        image.ordered_members << member
+        expect(image.ordered_members += [member, member_2]).to eq [member, member, member_2]
+        expect(image.ordered_members).to eq [member, member, member_2]
+        expect(image.ordered_member_proxies.map(&:target)).to eq [member, member, member_2]
       end
     end
     describe "#delete_at" do
       it "deletes that position" do
         member = Member.new
         member_2 = Member.new
-        subject.ordered_members += [member, member_2]
+        image.ordered_members += [member, member_2]
 
-        expect(subject.ordered_members.delete_at(0)).to eq member
-        expect(subject.ordered_members).to eq [member_2]
+        expect(image.ordered_members.delete_at(0)).to eq member
+        expect(image.ordered_members).to eq [member_2]
       end
     end
 
@@ -116,27 +116,27 @@ describe ActiveFedora::Orders do
       let(:member) { Member.create }
       let(:member_2) { Member.create }
       before do
-        subject.ordered_members += [member, member_2, member]
-        subject.save!
+        image.ordered_members += [member, member_2, member]
+        image.save!
       end
 
       context "with an object found in the list" do
         it "deletes all occurences of the object" do
-          expect(subject.ordered_members.delete(member)).to eq member
-          expect(subject.ordered_members.to_a).to eq [member_2]
+          expect(image.ordered_members.delete(member)).to eq member
+          expect(image.ordered_members.to_a).to eq [member_2]
         end
         it "can delete all" do
-          expect(subject.ordered_members.delete(member)).to eq member
-          expect(subject.ordered_members.delete(member_2)).to eq member_2
-          subject.save!
-          expect(subject.reload.ordered_members.to_a).to eq []
+          expect(image.ordered_members.delete(member)).to eq member
+          expect(image.ordered_members.delete(member_2)).to eq member_2
+          image.save!
+          expect(image.reload.ordered_members.to_a).to eq []
         end
       end
 
       context "with an object not found in the list" do
         it "returns nil" do
-          expect(subject.ordered_members.delete(Member.create)).to be_nil
-          expect(subject.ordered_members.to_a).to eq [member, member_2, member]
+          expect(image.ordered_members.delete(Member.create)).to be_nil
+          expect(image.ordered_members.to_a).to eq [member, member_2, member]
         end
       end
     end
@@ -145,29 +145,29 @@ describe ActiveFedora::Orders do
       it "adds at a given position" do
         member = Member.new
         member_2 = Member.new
-        subject.ordered_members += [member, member_2]
+        image.ordered_members += [member, member_2]
 
-        subject.ordered_members.insert_at(0, member_2)
-        expect(subject.ordered_members).to eq [member_2, member, member_2]
+        image.ordered_members.insert_at(0, member_2)
+        expect(image.ordered_members).to eq [member_2, member, member_2]
       end
       it "adds a proxy_in statement" do
         member = Member.new
         member_2 = Member.new
-        subject.ordered_members += [member, member_2]
+        image.ordered_members += [member, member_2]
 
-        subject.ordered_members.insert_at(0, member_2)
-        expect(subject.ordered_member_proxies.map(&:proxy_in).uniq).to eq [subject]
+        image.ordered_members.insert_at(0, member_2)
+        expect(image.ordered_member_proxies.map(&:proxy_in).uniq).to eq [image]
       end
     end
     describe "lazy loading" do
       it "does not instantiate every record on append" do
         member = Member.new
         member_2 = Member.new
-        subject.ordered_members += [member, member_2]
-        subject.save
+        image.ordered_members += [member, member_2]
+        image.save
         allow(ActiveFedora::Base).to receive(:find).and_call_original
 
-        reloaded = subject.class.find(subject.id)
+        reloaded = image.class.find(image.id)
         reloaded.ordered_members << member
 
         expect(ActiveFedora::Base).not_to have_received(:find).with(member_2.id)
@@ -175,11 +175,11 @@ describe ActiveFedora::Orders do
       it "does not instantiate every record on #insert_at" do
         member = Member.new
         member_2 = Member.new
-        subject.ordered_members += [member, member_2]
-        subject.save
+        image.ordered_members += [member, member_2]
+        image.save
         allow(ActiveFedora::Base).to receive(:find).and_call_original
 
-        reloaded = subject.class.find(subject.id)
+        reloaded = image.class.find(image.id)
         reloaded.ordered_members.insert_at(0, member)
 
         expect(ActiveFedora::Base).not_to have_received(:find).with(member_2.id)
@@ -189,179 +189,179 @@ describe ActiveFedora::Orders do
   describe "append_target" do
     it "doesn't add all members" do
       member = Member.new
-      subject.members << member
-      expect(subject.ordered_members).to eq []
+      image.members << member
+      expect(image.ordered_members).to eq []
     end
     it "can handle adding many objects" do
       member = Member.new
       60.times do
-        subject.ordered_member_proxies.append_target member
+        image.ordered_member_proxies.append_target member
       end
-      expect(subject.ordered_member_proxies.to_a.length).to eq 60
+      expect(image.ordered_member_proxies.to_a.length).to eq 60
     end
     it "can't add items not accepted by indirect container" do
       bad_class = BadClass.new
-      expect { subject.ordered_member_proxies.append_target bad_class }.to raise_error ActiveFedora::AssociationTypeMismatch
+      expect { image.ordered_member_proxies.append_target bad_class }.to raise_error ActiveFedora::AssociationTypeMismatch
     end
     it "adds a member if it doesn't exist in members" do
       member = Member.new
-      subject.ordered_member_proxies.append_target member
-      expect(subject.members).to eq [member]
-      expect(subject.ordered_members).to eq [member]
+      image.ordered_member_proxies.append_target member
+      expect(image.members).to eq [member]
+      expect(image.ordered_members).to eq [member]
     end
     it "doesn't add a member twice" do
       member = Member.new
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies.append_target member
-      expect(subject.members).to eq [member]
-      expect(subject.ordered_members).to eq [member, member]
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies.append_target member
+      expect(image.members).to eq [member]
+      expect(image.ordered_members).to eq [member, member]
     end
     it "survives persistence" do
       member = Member.new
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies.append_target member
-      subject.save
-      subject.reload
-      expect(subject.ordered_members).to eq [member, member]
-      expect(subject.ordered_member_ids).to eq [member.id, member.id]
-      expect(subject.list_source.resource.query([nil, ::RDF::Vocab::ORE.proxyIn, subject.resource.rdf_subject]).to_a.length).to eq 2
-      expect(subject.head_ids).to eq subject.list_source.head_id
-      expect(subject.tail_ids).to eq subject.list_source.tail_id
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies.append_target member
+      image.save
+      image.reload
+      expect(image.ordered_members).to eq [member, member]
+      expect(image.ordered_member_ids).to eq [member.id, member.id]
+      expect(image.list_source.resource.query([nil, ::RDF::Vocab::ORE.proxyIn, image.resource.rdf_subject]).to_a.length).to eq 2
+      expect(image.head_ids).to eq image.list_source.head_id
+      expect(image.tail_ids).to eq image.list_source.tail_id
     end
     it "can add already persisted items" do
       member = Member.create
-      subject.ordered_member_proxies.append_target member
-      subject.save
-      subject.reload
-      expect(subject.ordered_members).to eq [member]
+      image.ordered_member_proxies.append_target member
+      image.save
+      image.reload
+      expect(image.ordered_members).to eq [member]
     end
     it "can append to a pre-persisted item" do
       member = Member.new
-      subject.ordered_member_proxies.append_target member
-      subject.save
-      subject.reload
+      image.ordered_member_proxies.append_target member
+      image.save
+      image.reload
       member_2 = Member.new
-      subject.ordered_member_proxies.append_target member_2
-      subject.save
-      subject.reload
-      expect(subject.ordered_members).to eq [member, member_2]
+      image.ordered_member_proxies.append_target member_2
+      image.save
+      image.reload
+      expect(image.ordered_members).to eq [member, member_2]
     end
   end
   describe "insert_target_at" do
     it "can add between items" do
       member = Member.new
       member2 = Member.new
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies.insert_target_at(1, member2)
-      expect(subject.ordered_members).to eq [member, member2, member]
-      subject.save
-      subject.reload
-      expect(subject.ordered_members).to eq [member, member2, member]
-      subject.ordered_member_proxies.insert_target_at(2, member2)
-      subject.save
-      subject.reload
-      expect(subject.ordered_members).to eq [member, member2, member2, member]
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies.insert_target_at(1, member2)
+      expect(image.ordered_members).to eq [member, member2, member]
+      image.save
+      image.reload
+      expect(image.ordered_members).to eq [member, member2, member]
+      image.ordered_member_proxies.insert_target_at(2, member2)
+      image.save
+      image.reload
+      expect(image.ordered_members).to eq [member, member2, member2, member]
     end
   end
   describe "insert_target_id_at" do
     it "can add between items" do
       member = Member.create
       member2 = Member.create
-      subject.ordered_members += [member, member2]
+      image.ordered_members += [member, member2]
 
       allow(ActiveFedora::Base).to receive(:find).and_call_original
-      subject.ordered_member_proxies.insert_target_id_at(1, member2.id)
+      image.ordered_member_proxies.insert_target_id_at(1, member2.id)
       expect(ActiveFedora::Base).not_to have_received(:find).with(member2.id)
-      expect(subject.ordered_members).to eq [member, member2, member2]
+      expect(image.ordered_members).to eq [member, member2, member2]
       expect(ActiveFedora::Base).to have_received(:find).with(member2.id)
     end
     context "when given a nil id" do
       it "raises an ArgumentError" do
-        expect { subject.ordered_member_proxies.insert_target_id_at(0, nil) }.to raise_error ArgumentError, "ID can not be nil"
+        expect { image.ordered_member_proxies.insert_target_id_at(0, nil) }.to raise_error ArgumentError, "ID can not be nil"
       end
     end
     context "when given an ID not in members" do
       it "raises an ArgumentError" do
-        expect { subject.ordered_member_proxies.insert_target_id_at(0, "test") }.to raise_error "test is not a part of members"
+        expect { image.ordered_member_proxies.insert_target_id_at(0, "test") }.to raise_error "test is not a part of members"
       end
     end
   end
   describe "-=" do
     it "can remove proxies" do
       member = Member.new
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies -= [subject.ordered_member_proxies.last]
-      expect(subject.ordered_members).to eq []
-      expect(subject.list_source.resource.statements.to_a.length).to eq 1
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies -= [image.ordered_member_proxies.last]
+      expect(image.ordered_members).to eq []
+      expect(image.list_source.resource.statements.to_a.length).to eq 1
     end
     it "can remove proxies in the middle" do
       member = Member.new
       member_2 = Member.new
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies.append_target member_2
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies -= [subject.ordered_member_proxies[1]]
-      expect(subject.ordered_members).to eq [member, member]
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies.append_target member_2
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies -= [image.ordered_member_proxies[1]]
+      expect(image.ordered_members).to eq [member, member]
     end
     it "can remove proxies post-create" do
       member = Member.new
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies.append_target member
-      subject.save
-      subject.reload
-      subject.ordered_member_proxies -= [subject.ordered_member_proxies[1]]
-      expect(subject.ordered_members).to eq [member, member]
-      subject.save
-      subject.reload
-      expect(subject.ordered_members).to eq [member, member]
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies.append_target member
+      image.save
+      image.reload
+      image.ordered_member_proxies -= [image.ordered_member_proxies[1]]
+      expect(image.ordered_members).to eq [member, member]
+      image.save
+      image.reload
+      expect(image.ordered_members).to eq [member, member]
       # THIS NEEDS TO PASS - can't delete fragment URI resources via sparql
       # update?
       # Blocked by https://jira.duraspace.org/browse/FCREPO-1764
-      # expect(subject.list_source.resource.subjects.to_a.length).to eq 5
+      # expect(image.list_source.resource.subjects.to_a.length).to eq 5
     end
   end
   describe ".delete_at" do
     it "can remove in the middle" do
       member = Member.new
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies.delete_at(1)
-      expect(subject.ordered_members).to eq [member, member]
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies.delete_at(1)
+      expect(image.ordered_members).to eq [member, member]
     end
     it "returns the node" do
       member = Member.new
-      subject.ordered_members << member
-      subject.ordered_members << member
-      second_node = subject.ordered_member_proxies[1]
-      expect(subject.ordered_member_proxies.delete_at(1)).to eq second_node
+      image.ordered_members << member
+      image.ordered_members << member
+      second_node = image.ordered_member_proxies[1]
+      expect(image.ordered_member_proxies.delete_at(1)).to eq second_node
     end
     context "when the node doesn't exist" do
       it "returns nil" do
-        expect(subject.ordered_member_proxies.delete_at(0)).to eq nil
+        expect(image.ordered_member_proxies.delete_at(0)).to eq nil
       end
     end
     it "doesn't do anything if passed a bad value" do
       member = Member.new
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies.delete_at(3)
-      subject.ordered_member_proxies.delete_at(nil)
-      expect(subject.ordered_members).to eq [member, member, member]
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies.delete_at(3)
+      image.ordered_member_proxies.delete_at(nil)
+      expect(image.ordered_members).to eq [member, member, member]
     end
     it "can persist a deletion" do
       member = Member.new
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies.append_target member
-      subject.ordered_member_proxies.append_target member
-      expect(subject.ordered_members).to eq [member, member, member]
-      subject.ordered_member_proxies.delete_at(1)
-      subject.save
-      subject.reload
-      expect(subject.ordered_members).to eq [member, member]
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies.append_target member
+      image.ordered_member_proxies.append_target member
+      expect(image.ordered_members).to eq [member, member, member]
+      image.ordered_member_proxies.delete_at(1)
+      image.save
+      image.reload
+      expect(image.ordered_members).to eq [member, member]
     end
   end
 end