active-fedora 11.0.0.rc1 → 11.0.0.rc2

data/spec/unit/orders/list_node_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 RSpec.describe ActiveFedora::Orders::ListNode do
-  subject { described_class.new(node_cache, rdf_subject, graph) }
+  let(:list_node) { described_class.new(node_cache, rdf_subject, graph) }
   let(:node_cache) { {} }
   let(:rdf_subject) { RDF::URI("#bla") }
   let(:graph) { ActiveTriples::Resource.new }
@@ -10,14 +10,14 @@ RSpec.describe ActiveFedora::Orders::ListNode do
     context "when a target is set" do
       it "returns it" do
         member = instance_double("member")
-        subject.target = member
-        expect(subject.target).to eq member
+        list_node.target = member
+        expect(list_node.target).to eq member
       end
     end
     context "when no target is set" do
       context "and it's not in the graph" do
         it "returns nil" do
-          expect(subject.target).to eq nil
+          expect(list_node.target).to eq nil
         end
       end
       context "and it's set in the graph" do
@@ -31,13 +31,13 @@ RSpec.describe ActiveFedora::Orders::ListNode do
         it "returns it" do
           member = Member.create
           graph << [rdf_subject, RDF::Vocab::ORE.proxyFor, member.resource.rdf_subject]
-          expect(subject.target).to eq member
+          expect(list_node.target).to eq member
         end
         context "and it doesn't exist" do
           it "returns an AT::Resource" do
             member = Member.new("testing")
             graph << [rdf_subject, RDF::Vocab::ORE.proxyFor, member.resource.rdf_subject]
-            expect(subject.target.rdf_subject).to eq member.uri
+            expect(list_node.target.rdf_subject).to eq member.uri
           end
         end
       end
@@ -47,7 +47,7 @@ RSpec.describe ActiveFedora::Orders::ListNode do
   describe "#target_uri" do
     context "with a null target_id" do
       it "returns nil" do
-        expect(subject.target_uri).to eq nil
+        expect(list_node.target_uri).to eq nil
       end
     end
     context "with a target" do
@@ -61,9 +61,9 @@ RSpec.describe ActiveFedora::Orders::ListNode do
       it "returns a built URI" do
         m = Member.new
         allow(m).to receive(:id).and_return("test")
-        subject.target = m
+        list_node.target = m
 
-        expect(subject.target_uri).to eq ActiveFedora::Base.translate_id_to_uri.call("test")
+        expect(list_node.target_uri).to eq ActiveFedora::Base.translate_id_to_uri.call("test")
       end
     end
   end
@@ -72,8 +72,8 @@ RSpec.describe ActiveFedora::Orders::ListNode do
     context "when a target is set" do
       it "returns its id" do
         member = instance_double("member", id: "member1")
-        subject.target = member
-        expect(subject.target_id).to eq "member1"
+        list_node.target = member
+        expect(list_node.target_id).to eq "member1"
       end
     end
     context "when a target is from the graph" do
@@ -89,9 +89,9 @@ RSpec.describe ActiveFedora::Orders::ListNode do
           member = Member.create
           graph << [rdf_subject, RDF::Vocab::ORE.proxyFor, member.resource.rdf_subject]
           allow(ActiveFedora::Base).to receive(:from_uri).and_return(ActiveTriples::Resource.new(member.resource.rdf_subject))
-          subject.target
+          list_node.target
 
-          expect(subject.target_id).to eq member.id
+          expect(list_node.target_id).to eq member.id
         end
       end
       it "doesn't re-ify the target" do
@@ -99,7 +99,7 @@ RSpec.describe ActiveFedora::Orders::ListNode do
         graph << [rdf_subject, RDF::Vocab::ORE.proxyFor, member.resource.rdf_subject]
         allow(ActiveFedora::Base).to receive(:from_uri).and_call_original
 
-        expect(subject.target_id).to eq member.id
+        expect(list_node.target_id).to eq member.id
         expect(ActiveFedora::Base).not_to have_received(:from_uri)
       end
     end
@@ -108,8 +108,8 @@ RSpec.describe ActiveFedora::Orders::ListNode do
     context "when a target is set" do
       it "returns its id" do
         member = instance_double("member", id: "member1")
-        subject.proxy_in = member
-        expect(subject.proxy_in_id).to eq "member1"
+        list_node.proxy_in = member
+        expect(list_node.proxy_in_id).to eq "member1"
       end
     end
     context "when a proxy_in is from the graph" do
@@ -125,9 +125,9 @@ RSpec.describe ActiveFedora::Orders::ListNode do
           member = Member.create
           graph << [rdf_subject, RDF::Vocab::ORE.proxyIn, member.resource.rdf_subject]
           allow(ActiveFedora::Base).to receive(:from_uri).and_return(ActiveTriples::Resource.new(member.resource.rdf_subject))
-          subject.target
+          list_node.target
 
-          expect(subject.proxy_in_id).to eq member.id
+          expect(list_node.proxy_in_id).to eq member.id
         end
       end
       it "doesn't re-ify the target" do
@@ -135,7 +135,7 @@ RSpec.describe ActiveFedora::Orders::ListNode do
         graph << [rdf_subject, RDF::Vocab::ORE.proxyIn, member.resource.rdf_subject]
         allow(ActiveFedora::Base).to receive(:from_uri).and_call_original
 
-        expect(subject.proxy_in_id).to eq member.id
+        expect(list_node.proxy_in_id).to eq member.id
         expect(ActiveFedora::Base).not_to have_received(:from_uri)
       end
     end
@@ -144,7 +144,7 @@ RSpec.describe ActiveFedora::Orders::ListNode do
   describe "#to_graph" do
     context "with no data" do
       it "returns an empty graph" do
-        expect(subject.to_graph.statements.to_a.length).to eq 0
+        expect(list_node.to_graph.statements.to_a.length).to eq 0
       end
     end
   end

data/spec/unit/orders/ordered_list_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 RSpec.describe ActiveFedora::Orders::OrderedList do
-  subject { described_class.new(graph, head_uri, tail_uri) }
+  let(:ordered_list) { described_class.new(graph, head_uri, tail_uri) }
 
   let(:graph) { ActiveTriples::Resource.new(RDF::URI("stuff")) }
   let(:head_uri) { nil }
@@ -9,34 +9,34 @@ RSpec.describe ActiveFedora::Orders::OrderedList do
   describe "#last" do
     context "with no nodes" do
       it "is nil" do
-        expect(subject.last).to eq nil
+        expect(ordered_list.last).to eq nil
       end
     end
     context "with one node" do
       it "is that node" do
         member = instance_double(ActiveFedora::Base)
-        subject.append_target member
+        ordered_list.append_target member
 
-        expect(subject.last.target).to eq member
+        expect(ordered_list.last.target).to eq member
       end
     end
     context "with two nodes" do
       it "is the last node" do
         member = instance_double(ActiveFedora::Base)
         member_2 = instance_double(ActiveFedora::Base)
-        subject.append_target member
-        subject.append_target member_2
+        ordered_list.append_target member
+        ordered_list.append_target member_2
 
-        expect(subject.last.target).to eq member_2
+        expect(ordered_list.last.target).to eq member_2
       end
     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(ordered_list).not_to be_changed
+      ordered_list.order_will_change!
+      expect(ordered_list).to be_changed
     end
   end
 
@@ -52,16 +52,16 @@ RSpec.describe ActiveFedora::Orders::OrderedList do
         graph << [node_subject, RDF::Vocab::ORE.proxyIn, parent_uri]
         allow(ActiveFedora::Base).to receive(:from_uri)
 
-        expect(subject.target_ids).to eq ["member1"]
+        expect(ordered_list.target_ids).to eq ["member1"]
         expect(ActiveFedora::Base).not_to have_received(:from_uri)
       end
     end
     context "from a built up list" do
       it "returns the IDs" do
         member = instance_double(ActiveFedora::Base, id: "member1")
-        subject.append_target member
+        ordered_list.append_target member
 
-        expect(subject.target_ids).to eq ["member1"]
+        expect(ordered_list.target_ids).to eq ["member1"]
       end
     end
   end
@@ -70,29 +70,29 @@ RSpec.describe ActiveFedora::Orders::OrderedList do
     context "when there's one proxy in" do
       it "returns it" do
         member = instance_double(ActiveFedora::Base)
-        subject.append_target member, proxy_in: RDF::URI("http://tar.dis")
+        ordered_list.append_target member, proxy_in: RDF::URI("http://tar.dis")
 
-        expect(subject.proxy_in).to eq RDF::URI("http://tar.dis")
+        expect(ordered_list.proxy_in).to eq RDF::URI("http://tar.dis")
       end
     end
     context "when the proxy in is an AF::Base object" do
       it "returns the ID" do
         member = instance_double(ActiveFedora::Base)
         owner = instance_double(ActiveFedora::Base, id: "member1")
-        subject.append_target member, proxy_in: owner
+        ordered_list.append_target member, proxy_in: owner
 
-        expect(subject.proxy_in).to eq "member1"
+        expect(ordered_list.proxy_in).to eq "member1"
       end
     end
     context "when there's two proxy ins" do
       it "returns the first and throws a warning" do
         member = instance_double(ActiveFedora::Base)
-        subject.append_target member, proxy_in: RDF::URI("http://tar.dis")
-        subject.append_target member, proxy_in: RDF::URI("http://tar.di")
+        ordered_list.append_target member, proxy_in: RDF::URI("http://tar.dis")
+        ordered_list.append_target member, proxy_in: RDF::URI("http://tar.di")
         ActiveFedora::Base.logger = Logger.new(STDERR)
         allow(ActiveFedora::Base.logger).to receive(:warn)
 
-        expect(subject.proxy_in).to eq RDF::URI("http://tar.dis")
+        expect(ordered_list.proxy_in).to eq RDF::URI("http://tar.dis")
         expect(ActiveFedora::Base.logger).to have_received(:warn).with("WARNING: List contains nodes aggregated under different URIs. Returning only the first.")
       end
     end
@@ -101,39 +101,39 @@ RSpec.describe ActiveFedora::Orders::OrderedList do
   describe "#[]" do
     context "with no nodes" do
       it "is always nil" do
-        expect(subject[0]).to eq nil
+        expect(ordered_list[0]).to eq nil
       end
     end
     context "with two nodes" do
       let(:member) { instance_double(ActiveFedora::Base) }
       let(:member_2) { instance_double(ActiveFedora::Base) }
       before do
-        subject.append_target member
-        subject.append_target member_2
+        ordered_list.append_target member
+        ordered_list.append_target member_2
       end
       it "can return the first" do
-        expect(subject[0].target).to eq member
+        expect(ordered_list[0].target).to eq member
       end
       it "can return the last" do
-        expect(subject[1].target).to eq member_2
+        expect(ordered_list[1].target).to eq member_2
       end
       it "returns nil for out of bounds values" do
-        expect(subject[3]).to eq nil
+        expect(ordered_list[3]).to eq nil
       end
     end
   end
   describe "#first" do
     context "with no nodes" do
       it "is nil" do
-        expect(subject.first).to eq nil
+        expect(ordered_list.first).to eq nil
       end
     end
     context "with a node" do
       it "returns that node" do
         member = instance_double(ActiveFedora::Base)
-        subject.append_target member
-        expect(subject.first.target).to eq member
-        expect(subject).to be_changed
+        ordered_list.append_target member
+        expect(ordered_list.first.target).to eq member
+        expect(ordered_list).to be_changed
       end
     end
     context "with an item from the graph" do
@@ -145,10 +145,10 @@ RSpec.describe ActiveFedora::Orders::OrderedList do
         parent_uri = RDF::URI.new("parent")
         graph << [node_subject, RDF::Vocab::ORE.proxyFor, member_uri]
         graph << [node_subject, RDF::Vocab::ORE.proxyIn, parent_uri]
-        expect(subject.first.proxy_for).to eq member_uri
-        expect(subject.first.proxy_for).to be_kind_of RDF::URI
-        expect(subject.first.proxy_in).to eq parent_uri
-        expect(subject.first).not_to eq nil
+        expect(ordered_list.first.proxy_for).to eq member_uri
+        expect(ordered_list.first.proxy_for).to be_kind_of RDF::URI
+        expect(ordered_list.first.proxy_in).to eq parent_uri
+        expect(ordered_list.first).not_to eq nil
       end
       it "is changed by a delete" do
         node_subject = RDF::URI.new("parent#bla")
@@ -157,9 +157,9 @@ RSpec.describe ActiveFedora::Orders::OrderedList do
         graph << [node_subject, RDF::Vocab::ORE.proxyFor, member_uri]
         graph << [node_subject, RDF::Vocab::ORE.proxyIn, parent_uri]
 
-        expect(subject).not_to be_changed
-        subject.delete_at(0)
-        expect(subject).to be_changed
+        expect(ordered_list).not_to be_changed
+        ordered_list.delete_at(0)
+        expect(ordered_list).to be_changed
       end
       context "with multiple nodes" do
         let(:tail_uri) { RDF::URI.new("parent#bla2") }
@@ -174,10 +174,10 @@ RSpec.describe ActiveFedora::Orders::OrderedList do
           graph << [node_2_subject, RDF::Vocab::IANA.prev, node_subject]
           graph << [node_2_subject, RDF::Vocab::ORE.proxyFor, member_uri]
           graph << [node_2_subject, RDF::Vocab::ORE.proxyIn, parent_uri]
-          expect(subject.length).to eq 2
-          expect(subject.tail.prev.prev).to eq subject.head.next
-          expect(subject.map(&:target).map(&:rdf_subject)).to eq [member_uri, member_uri]
-          expect(subject).not_to be_changed
+          expect(ordered_list.length).to eq 2
+          expect(ordered_list.tail.prev.prev).to eq ordered_list.head.next
+          expect(ordered_list.map(&:target).map(&:rdf_subject)).to eq [member_uri, member_uri]
+          expect(ordered_list).not_to be_changed
         end
       end
     end
@@ -188,11 +188,11 @@ RSpec.describe ActiveFedora::Orders::OrderedList do
       member = instance_double(ActiveFedora::Base)
       proxy_in = instance_double(ActiveFedora::Base, uri: RDF::URI("obj1"))
       600.times do
-        subject.append_target member, proxy_in: proxy_in
+        ordered_list.append_target member, proxy_in: proxy_in
       end
-      expect(subject.length).to eq 600
-      expect(subject.to_a.last.next).not_to eq nil
-      expect(subject.to_a.last.proxy_in).to eq proxy_in
+      expect(ordered_list.length).to eq 600
+      expect(ordered_list.to_a.last.next).not_to eq nil
+      expect(ordered_list.to_a.last.proxy_in).to eq proxy_in
     end
   end
 
@@ -201,24 +201,24 @@ RSpec.describe ActiveFedora::Orders::OrderedList do
       member = instance_double(ActiveFedora::Base)
       member_2 = instance_double(ActiveFedora::Base)
       3.times do
-        subject.append_target member
+        ordered_list.append_target member
       end
 
-      subject.insert_at(1, member_2)
+      ordered_list.insert_at(1, member_2)
 
-      expect(subject.to_a.map(&:target)).to eq [member, member_2, member, member]
-      expect(subject).to be_changed
+      expect(ordered_list.to_a.map(&:target)).to eq [member, member_2, member, member]
+      expect(ordered_list).to be_changed
     end
     it "can insert at the beginning" do
       member = instance_double(ActiveFedora::Base)
       member_2 = instance_double(ActiveFedora::Base)
       2.times do
-        subject.append_target member
+        ordered_list.append_target member
       end
 
-      subject.insert_at(0, member_2)
+      ordered_list.insert_at(0, member_2)
 
-      expect(subject.to_a.map(&:target)).to eq [member_2, member, member]
+      expect(ordered_list.to_a.map(&:target)).to eq [member_2, member, member]
     end
   end
 
@@ -226,35 +226,35 @@ RSpec.describe ActiveFedora::Orders::OrderedList do
     it "can delete a node in the middle" do
       member = instance_double(ActiveFedora::Base)
       member_2 = instance_double(ActiveFedora::Base)
-      subject.append_target member
-      subject.append_target member_2
-      subject.append_target member
+      ordered_list.append_target member
+      ordered_list.append_target member_2
+      ordered_list.append_target member
 
-      subject.delete_node(subject.to_a[1])
+      ordered_list.delete_node(ordered_list.to_a[1])
 
-      expect(subject.map(&:target)).to eq [member, member]
+      expect(ordered_list.map(&:target)).to eq [member, member]
     end
     it "can delete a node at the start" do
       member = instance_double(ActiveFedora::Base)
       member_2 = instance_double(ActiveFedora::Base)
-      subject.append_target member_2
-      subject.append_target member
-      subject.append_target member
+      ordered_list.append_target member_2
+      ordered_list.append_target member
+      ordered_list.append_target member
 
-      subject.delete_node(subject.to_a[0])
+      ordered_list.delete_node(ordered_list.to_a[0])
 
-      expect(subject.map(&:target)).to eq [member, member]
+      expect(ordered_list.map(&:target)).to eq [member, member]
     end
     it "can delete a node at the end" do
       member = instance_double(ActiveFedora::Base)
       member_2 = instance_double(ActiveFedora::Base)
-      subject.append_target member
-      subject.append_target member
-      subject.append_target member_2
+      ordered_list.append_target member
+      ordered_list.append_target member
+      ordered_list.append_target member_2
 
-      subject.delete_node(subject.to_a[2])
+      ordered_list.delete_node(ordered_list.to_a[2])
 
-      expect(subject.map(&:target)).to eq [member, member]
+      expect(ordered_list.map(&:target)).to eq [member, member]
     end
   end
 
@@ -262,47 +262,47 @@ RSpec.describe ActiveFedora::Orders::OrderedList do
     it "can delete a node in the middle" do
       member = instance_double(ActiveFedora::Base)
       member_2 = instance_double(ActiveFedora::Base)
-      subject.append_target member
-      subject.append_target member_2
-      subject.append_target member
+      ordered_list.append_target member
+      ordered_list.append_target member_2
+      ordered_list.append_target member
 
-      subject.delete_at(1)
+      ordered_list.delete_at(1)
 
-      expect(subject.map(&:target)).to eq [member, member]
+      expect(ordered_list.map(&:target)).to eq [member, member]
     end
     it "can delete a node at the start" do
       member = instance_double(ActiveFedora::Base)
       member_2 = instance_double(ActiveFedora::Base)
-      subject.append_target member_2
-      subject.append_target member
-      subject.append_target member
+      ordered_list.append_target member_2
+      ordered_list.append_target member
+      ordered_list.append_target member
 
-      subject.delete_at(0)
+      ordered_list.delete_at(0)
 
-      expect(subject.map(&:target)).to eq [member, member]
+      expect(ordered_list.map(&:target)).to eq [member, member]
     end
     it "can delete a node at the end" do
       member = instance_double(ActiveFedora::Base)
       member_2 = instance_double(ActiveFedora::Base)
-      subject.append_target member
-      subject.append_target member
-      subject.append_target member_2
+      ordered_list.append_target member
+      ordered_list.append_target member
+      ordered_list.append_target member_2
 
-      subject.delete_at(2)
+      ordered_list.delete_at(2)
 
-      expect(subject.map(&:target)).to eq [member, member]
+      expect(ordered_list.map(&:target)).to eq [member, member]
     end
     it "does not delete nodes if the loc is out of bounds" do
       member = instance_double(ActiveFedora::Base)
       member_2 = instance_double(ActiveFedora::Base)
-      subject.append_target member
-      subject.append_target member
-      subject.append_target member_2
+      ordered_list.append_target member
+      ordered_list.append_target member
+      ordered_list.append_target member_2
 
-      subject.delete_at(3)
-      subject.delete_at(nil)
+      ordered_list.delete_at(3)
+      ordered_list.delete_at(nil)
 
-      expect(subject.map(&:target)).to eq [member, member, member_2]
+      expect(ordered_list.map(&:target)).to eq [member, member, member_2]
     end
   end
 
@@ -310,13 +310,13 @@ RSpec.describe ActiveFedora::Orders::OrderedList do
     it "creates a good graph" do
       member = instance_double(ActiveFedora::Base, id: '123/456')
       owner = instance_double(ActiveFedora::Base, uri: RDF::URI("http://owner.org"))
-      subject.append_target member
-      subject.append_target member, proxy_in: owner
+      ordered_list.append_target member
+      ordered_list.append_target member, proxy_in: owner
 
-      graph = subject.to_graph
+      graph = ordered_list.to_graph
 
       expect(graph.statements.to_a.length).to eq 5
-      expect(graph.subjects.to_a).to contain_exactly(*subject.to_a.map(&:rdf_subject))
+      expect(graph.subjects.to_a).to contain_exactly(*ordered_list.to_a.map(&:rdf_subject))
       expect(graph.query([nil, RDF::Vocab::ORE.proxyFor, nil]).to_a.last.object).to be_kind_of RDF::URI
     end
   end
@@ -324,12 +324,12 @@ RSpec.describe ActiveFedora::Orders::OrderedList do
   describe "#changes_committed!" do
     it "sets changed back to false" do
       member = instance_double(ActiveFedora::Base, uri: RDF::URI("http://test.org"))
-      subject.append_target member
-      expect(subject).to be_changed
+      ordered_list.append_target member
+      expect(ordered_list).to be_changed
 
-      subject.changes_committed!
+      ordered_list.changes_committed!
 
-      expect(subject).not_to be_changed
+      expect(ordered_list).not_to be_changed
     end
   end
 end