active-fedora 11.0.0.rc1 → 11.0.0.rc2

data/spec/unit/aggregation/list_source_spec.rb

@@ -1,67 +1,67 @@
 require 'spec_helper'
 
 RSpec.describe ActiveFedora::Aggregation::ListSource do
-  subject { described_class.new }
+  subject(:list_source) { described_class.new }
 
   describe "#head" do
     it "is nil by default" do
-      expect(subject.head).to eq nil
+      expect(list_source.head).to eq nil
     end
 
     it "is settable" do
-      subject.head = RDF::URI("test.org")
+      list_source.head = RDF::URI("test.org")
 
-      expect(subject.head_id.first).to eq RDF::URI("test.org")
+      expect(list_source.head_id.first).to eq RDF::URI("test.org")
     end
 
     it "maps to IANA.first" do
-      expect(subject.class.properties["head"].predicate).to eq ::RDF::Vocab::IANA["first"]
+      expect(list_source.class.properties["head"].predicate).to eq ::RDF::Vocab::IANA["first"]
     end
   end
 
   describe "#order_will_change!" do
     it "marks it as changed" do
-      expect(subject).not_to be_changed
-      subject.order_will_change!
-      expect(subject).to be_changed
-      expect(subject.ordered_self).to be_changed
+      expect(list_source).not_to be_changed
+      list_source.order_will_change!
+      expect(list_source).to be_changed
+      expect(list_source.ordered_self).to be_changed
     end
   end
 
   describe "#tail" do
     it "is nil by default" do
-      expect(subject.tail).to eq nil
+      expect(list_source.tail).to eq nil
     end
 
     it "is settable" do
-      subject.tail = RDF::URI("test.org")
+      list_source.tail = RDF::URI("test.org")
 
-      expect(subject.tail_id.first).to eq RDF::URI("test.org")
+      expect(list_source.tail_id.first).to eq RDF::URI("test.org")
     end
 
     it "maps to IANA.last" do
-      expect(subject.class.properties["tail"].predicate).to eq ::RDF::Vocab::IANA["last"]
+      expect(list_source.class.properties["tail"].predicate).to eq ::RDF::Vocab::IANA["last"]
     end
   end
 
   describe "#changed?" do
     context "when nothing has changed" do
       it "is false" do
-        expect(subject).not_to be_changed
+        expect(list_source).not_to be_changed
       end
     end
     context "when the ordered list is changed" do
       it "is true" do
-        allow(subject.ordered_self).to receive(:changed?).and_return(true)
+        allow(list_source.ordered_self).to receive(:changed?).and_return(true)
 
-        expect(subject).to be_changed
+        expect(list_source).to be_changed
       end
     end
     context "when the ordered list is not changed" do
       it "is false" do
-        allow(subject.ordered_self).to receive(:changed?).and_return(false)
+        allow(list_source.ordered_self).to receive(:changed?).and_return(false)
 
-        expect(subject).not_to be_changed
+        expect(list_source).not_to be_changed
       end
     end
   end
@@ -69,50 +69,50 @@ RSpec.describe ActiveFedora::Aggregation::ListSource do
   describe "#save" do
     context "when nothing has changed" do
       it "does not persist ordered_self" do
-        allow(subject.ordered_self).to receive(:to_graph)
+        allow(list_source.ordered_self).to receive(:to_graph)
 
-        subject.save
+        list_source.save
 
-        expect(subject.ordered_self).not_to have_received(:to_graph)
+        expect(list_source.ordered_self).not_to have_received(:to_graph)
       end
     end
     context "when attributes have changed, but not ordered list" do
       it "does not persist ordered self" do
-        allow(subject.ordered_self).to receive(:to_graph)
-        subject.nodes += [RDF::URI("http://test.org")]
+        allow(list_source.ordered_self).to receive(:to_graph)
+        list_source.nodes += [RDF::URI("http://test.org")]
 
-        subject.save
+        list_source.save
 
-        expect(subject.ordered_self).not_to have_received(:to_graph)
+        expect(list_source.ordered_self).not_to have_received(:to_graph)
       end
     end
     context "when ordered list has changed" do
       it "persists it" do
-        allow(subject.ordered_self).to receive(:to_graph).and_call_original
-        allow(subject.ordered_self).to receive(:changed?).and_return(true)
+        allow(list_source.ordered_self).to receive(:to_graph).and_call_original
+        allow(list_source.ordered_self).to receive(:changed?).and_return(true)
 
-        subject.save
+        list_source.save
 
-        expect(subject.ordered_self).to have_received(:to_graph)
+        expect(list_source.ordered_self).to have_received(:to_graph)
       end
     end
   end
 
   describe "#serializable_hash" do
     it "does not serialize nodes" do
-      subject.nodes += [RDF::URI("http://test.org")]
+      list_source.nodes += [RDF::URI("http://test.org")]
 
-      expect(subject.serializable_hash).not_to have_key "nodes"
+      expect(list_source.serializable_hash).not_to have_key "nodes"
     end
     it "does not serialize head" do
-      subject.head = RDF::URI("http://test.org")
+      list_source.head = RDF::URI("http://test.org")
 
-      expect(subject.serializable_hash).not_to have_key "head"
+      expect(list_source.serializable_hash).not_to have_key "head"
     end
     it "does not serialize tail" do
-      subject.tail = RDF::URI("http://test.org")
+      list_source.tail = RDF::URI("http://test.org")
 
-      expect(subject.serializable_hash).not_to have_key "tail"
+      expect(list_source.serializable_hash).not_to have_key "tail"
     end
   end
 
@@ -127,8 +127,8 @@ RSpec.describe ActiveFedora::Aggregation::ListSource do
     it "can index" do
       m = Member.create
       proxy_in = RDF::URI(ActiveFedora::Base.translate_id_to_uri.call("banana"))
-      subject.ordered_self.append_target m, proxy_in: proxy_in
-      expect(subject.to_solr).to include ordered_targets_ssim: [m.id], proxy_in_ssi: "banana"
+      list_source.ordered_self.append_target m, proxy_in: proxy_in
+      expect(list_source.to_solr).to include ordered_targets_ssim: [m.id], proxy_in_ssi: "banana"
     end
   end
 end

data/spec/unit/aggregation/ordered_reader_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 RSpec.describe ActiveFedora::Aggregation::OrderedReader do
-  subject { described_class.new(root) }
+  subject(:ordered_reader) { described_class.new(root) }
   let(:root) { instance_double(ActiveFedora::Aggregation::ListSource) }
 
   describe "#each" do
@@ -10,14 +10,14 @@ RSpec.describe ActiveFedora::Aggregation::OrderedReader do
       tail = build_node(prev_node: head)
       allow(head).to receive(:next).and_return(tail)
       allow(root).to receive(:head).and_return(head)
-      expect(subject.to_a).to eq [head, tail]
+      expect(ordered_reader.to_a).to eq [head, tail]
     end
     it "only goes as deep as necessary" do
       head = build_node
       tail = build_node(prev_node: head)
       allow(head).to receive(:next).and_return(tail)
       allow(root).to receive(:head).and_return(head)
-      expect(subject.first).to eq head
+      expect(ordered_reader.first).to eq head
       expect(head).not_to have_received(:next)
     end
     context "when the prev is wrong" do
@@ -28,7 +28,7 @@ RSpec.describe ActiveFedora::Aggregation::OrderedReader do
         allow(head).to receive(:next).and_return(tail)
         allow(root).to receive(:head).and_return(head)
         allow(tail).to receive(:prev=)
-        expect(subject.to_a).to eq [head, tail]
+        expect(ordered_reader.to_a).to eq [head, tail]
         expect(tail).to have_received(:prev=).with(head)
       end
     end

data/spec/unit/association_hash_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe ActiveFedora::AssociationHash do
-  subject { described_class.new(model, reflections) }
+  subject(:association_hash) { described_class.new(model, reflections) }
 
   let(:model) { double(association: nil) }
   let(:reflections) { double(keys: [:foo]) }
@@ -12,18 +12,18 @@ describe ActiveFedora::AssociationHash do
   describe "key reader" do
     describe "when the association exists" do
       before do
-        allow(subject).to receive(:association).with("foo") { association }
+        allow(association_hash).to receive(:association).with("foo") { association }
       end
       it "calls the association reader" do
-        expect(subject["foo"]).to eq(reader)
+        expect(association_hash["foo"]).to eq(reader)
       end
     end
     describe "when the association does not exist" do
       before do
-        allow(subject).to receive(:association).with("foo") { nil }
+        allow(association_hash).to receive(:association).with("foo") { nil }
       end
       it "returns nil" do
-        expect(subject["foo"]).to be_nil
+        expect(association_hash["foo"]).to be_nil
       end
     end
   end
@@ -35,20 +35,20 @@ describe ActiveFedora::AssociationHash do
     end
     describe "when the association exists" do
       before do
-        allow(subject).to receive(:association).with("foo") { association }
+        allow(association_hash).to receive(:association).with("foo") { association }
       end
       it "calls the association writer" do
         expect(association).to receive(:writer).with(obj)
-        subject["foo"] = obj
+        association_hash["foo"] = obj
       end
     end
     describe "when the association does not exist" do
       before do
-        allow(subject).to receive(:association).with("foo") { nil }
+        allow(association_hash).to receive(:association).with("foo") { nil }
       end
       it "doesn't call the association writer" do
         expect(association).not_to receive(:writer).with(obj)
-        subject["foo"] = obj
+        association_hash["foo"] = obj
       end
     end
   end
@@ -58,21 +58,21 @@ describe ActiveFedora::AssociationHash do
       allow(model).to receive(:association).with(:foo) { association }
     end
     it "works with a string key" do
-      expect(subject.association("foo")).to eq(association)
+      expect(association_hash.association("foo")).to eq(association)
     end
     it "works with a symbol key" do
-      expect(subject.association(:foo)).to eq(association)
+      expect(association_hash.association(:foo)).to eq(association)
     end
   end
 
   describe "#key?" do
     it "works with a string" do
-      expect(subject.key?("foo")).to be true
-      expect(subject.key?("bar")).to be false
+      expect(association_hash.key?("foo")).to be true
+      expect(association_hash.key?("bar")).to be false
     end
     it "works with a symbol" do
-      expect(subject.key?(:foo)).to be true
-      expect(subject.key?(:bar)).to be false
+      expect(association_hash.key?(:foo)).to be true
+      expect(association_hash.key?(:bar)).to be false
     end
   end
 end

data/spec/unit/attached_files_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe ActiveFedora::AttachedFiles do
-  subject { ActiveFedora::Base.new }
+  subject(:af_base) { ActiveFedora::Base.new }
   describe "has_subresource" do
     before do
       class Z < ActiveFedora::File
@@ -101,33 +101,33 @@ describe ActiveFedora::AttachedFiles do
 
       expect(m1).to receive(:serialize!)
       expect(m2).to receive(:serialize!)
-      allow(subject).to receive(:declared_attached_files).and_return(m1: m1, m2: m2)
-      subject.serialize_attached_files
+      allow(af_base).to receive(:declared_attached_files).and_return(m1: m1, m2: m2)
+      af_base.serialize_attached_files
     end
   end
 
   describe "#accessor_name" do
     it "uses the name" do
-      expect(subject.send(:accessor_name, 'abc')).to eq 'abc'
+      expect(af_base.send(:accessor_name, 'abc')).to eq 'abc'
     end
 
     it "uses the name" do
-      expect(subject.send(:accessor_name, 'ARCHIVAL_XML')).to eq 'ARCHIVAL_XML'
+      expect(af_base.send(:accessor_name, 'ARCHIVAL_XML')).to eq 'ARCHIVAL_XML'
     end
 
     it "uses the name" do
-      expect(subject.send(:accessor_name, 'descMetadata')).to eq 'descMetadata'
+      expect(af_base.send(:accessor_name, 'descMetadata')).to eq 'descMetadata'
     end
 
     it "hash-erizes underscores" do
-      expect(subject.send(:accessor_name, 'a-b')).to eq 'a_b'
+      expect(af_base.send(:accessor_name, 'a-b')).to eq 'a_b'
     end
   end
 
   describe "#attached_files" do
     it "returns the datastream hash proxy" do
-      allow(subject).to receive(:load_datastreams)
-      expect(subject.attached_files).to be_a_kind_of(ActiveFedora::FilesHash)
+      allow(af_base).to receive(:load_datastreams)
+      expect(af_base.attached_files).to be_a_kind_of(ActiveFedora::FilesHash)
     end
   end
 
@@ -136,37 +136,37 @@ describe ActiveFedora::AttachedFiles do
 
     it "does not call save on the file" do
       expect(file).to receive(:save).never
-      subject.attach_file(file, 'part1')
+      af_base.attach_file(file, 'part1')
     end
 
     it "adds the file to the attached_files hash" do
       expect {
-        subject.attach_file(file, 'part1')
-      }.to change { subject.attached_files.key?(:part1) }.from(false).to(true)
+        af_base.attach_file(file, 'part1')
+      }.to change { af_base.attached_files.key?(:part1) }.from(false).to(true)
     end
 
     context "after attaching the file" do
       let(:dsid) { 'Abc' }
       before do
-        subject.attach_file(file, dsid)
+        af_base.attach_file(file, dsid)
       end
 
       it "adds the datastream to the object" do
-        expect(subject.attached_files['Abc']).to eq file
+        expect(af_base.attached_files['Abc']).to eq file
       end
 
       describe "dynamic accessors" do
         context "when the file is named with dash" do
           let(:dsid) { 'eac-cpf' }
           it "converts dashes to underscores" do
-            expect(subject.eac_cpf).to eq file
+            expect(af_base.eac_cpf).to eq file
           end
         end
 
         context "when the file is named with underscore" do
           let(:dsid) { 'foo_bar' }
           it "preserves the underscore" do
-            expect(subject.foo_bar).to eq file
+            expect(af_base.foo_bar).to eq file
           end
         end
       end
@@ -179,9 +179,9 @@ describe ActiveFedora::AttachedFiles do
       ds2 = double(metadata?: true)
       ds3 = double(metadata?: true)
       file_ds = double(metadata?: false)
-      allow(subject).to receive(:attached_files).and_return(a: ds1, b: ds2, c: ds3, e: file_ds)
-      expect(subject.metadata_streams).to include(ds1, ds2, ds3)
-      expect(subject.metadata_streams).to_not include(file_ds)
+      allow(af_base).to receive(:attached_files).and_return(a: ds1, b: ds2, c: ds3, e: file_ds)
+      expect(af_base.metadata_streams).to include(ds1, ds2, ds3)
+      expect(af_base.metadata_streams).to_not include(file_ds)
     end
   end
 end

data/spec/unit/attributes_spec.rb

@@ -16,12 +16,12 @@ describe ActiveFedora::Base do
     end
 
     let(:obj) { BarHistory4.new(title: ['test1']) }
-    subject { obj }
+    subject(:history) { obj }
 
     describe "#attribute_names" do
       context "on an instance" do
         it "lists the attributes" do
-          expect(subject.attribute_names).to eq ["title", "abstract"]
+          expect(history.attribute_names).to eq ["title", "abstract"]
         end
       end
 
@@ -34,21 +34,21 @@ describe ActiveFedora::Base do
 
     describe "#inspect" do
       it "shows the attributes" do
-        expect(subject.inspect).to eq "#<BarHistory4 id: nil, title: [\"test1\"], abstract: nil>"
+        expect(history.inspect).to eq "#<BarHistory4 id: nil, title: [\"test1\"], abstract: nil>"
       end
 
       describe "with a id" do
-        before { allow(subject).to receive(:id).and_return('test:123') }
+        before { allow(history).to receive(:id).and_return('test:123') }
 
         it "shows a id" do
-          expect(subject.inspect).to eq "#<BarHistory4 id: \"test:123\", title: [\"test1\"], abstract: nil>"
+          expect(history.inspect).to eq "#<BarHistory4 id: \"test:123\", title: [\"test1\"], abstract: nil>"
         end
       end
 
       describe "with no attributes" do
-        subject { described_class.new }
+        subject(:object) { described_class.new }
         it "shows a id" do
-          expect(subject.inspect).to eq "#<ActiveFedora::Base id: nil>"
+          expect(object.inspect).to eq "#<ActiveFedora::Base id: nil>"
         end
       end
 
@@ -57,18 +57,18 @@ describe ActiveFedora::Base do
           class BarHistory2 < BarHistory4
             belongs_to :library, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.hasConstituent, class_name: 'BarHistory4'
           end
-          subject.library = library
+          history.library = library
         end
 
         let(:library) { BarHistory4.create }
-        subject { BarHistory2.new }
+        subject(:history) { BarHistory2.new }
 
         after do
           Object.send(:remove_const, :BarHistory2)
         end
 
         it "shows the library_id" do
-          expect(subject.inspect).to eq "#<BarHistory2 id: nil, title: [], abstract: nil, library_id: \"#{library.id}\">"
+          expect(history.inspect).to eq "#<BarHistory2 id: nil, title: [], abstract: nil, library_id: \"#{library.id}\">"
         end
       end
     end
@@ -83,36 +83,36 @@ describe ActiveFedora::Base do
     describe "accessing attributes" do
       context "using generated methods" do
         it "returns values" do
-          expect(subject.title).to eq ['test1']
+          expect(history.title).to eq ['test1']
         end
       end
 
       context "using hash accessors" do
         context "on single value fields" do
           it "has a default value" do
-            expect(subject[:abstract]).to be_nil
+            expect(history[:abstract]).to be_nil
           end
 
           context "when there are two assertions for the predicate" do
             before do
-              subject.resource[:abstract] = ['foo', 'bar']
+              history.resource[:abstract] = ['foo', 'bar']
             end
             it "raises an error if just returning the first value would cause data loss" do
-              expect { subject[:abstract] }.to raise_error ActiveFedora::ConstraintError, "Expected \"abstract\" to have 0-1 statements, but there are 2"
+              expect { history[:abstract] }.to raise_error ActiveFedora::ConstraintError, "Expected \"abstract\" to have 0-1 statements, but there are 2"
             end
           end
         end
 
         context "multiple values" do
           it "returns values" do
-            expect(subject[:title]).to eq ['test1']
+            expect(history[:title]).to eq ['test1']
           end
         end
 
         context "on Fedora attributes" do
           it "return values" do
-            expect(subject[:type]).to be_empty
-            expect(subject[:rdf_label]).to contain_exactly("test1")
+            expect(history[:type]).to be_empty
+            expect(history[:rdf_label]).to contain_exactly("test1")
           end
         end
       end
@@ -121,8 +121,8 @@ describe ActiveFedora::Base do
     describe 'change tracking' do
       it "is able to track change status" do
         expect {
-          subject.abstract = "Moo"
-        }.to change { subject.abstract_changed? }.from(false).to(true)
+          history.abstract = "Moo"
+        }.to change { history.abstract_changed? }.from(false).to(true)
       end
     end
 
@@ -136,16 +136,16 @@ describe ActiveFedora::Base do
 
     describe "when an object of the wrong cardinality is set" do
       it "does not allow passing a string to a multiple property writer" do
-        expect { subject.title = "Quack" }.to raise_error ArgumentError
-        expect { subject.title = ["Quack"] }.not_to raise_error
-        expect { subject.title = nil }.not_to raise_error
+        expect { history.title = "Quack" }.to raise_error ArgumentError
+        expect { history.title = ["Quack"] }.not_to raise_error
+        expect { history.title = nil }.not_to raise_error
       end
 
       it "does not allow an enumerable to a unique attribute writer" do
-        expect { subject.abstract = "Low" }.not_to raise_error
-        expect { subject.abstract = ["Low"]
+        expect { history.abstract = "Low" }.not_to raise_error
+        expect { history.abstract = ["Low"]
         }.to raise_error ArgumentError, "You attempted to set the property `abstract' to an enumerable value. However, this property is declared as singular."
-        expect { subject.abstract = nil }.not_to raise_error
+        expect { history.abstract = nil }.not_to raise_error
       end
     end
   end