active-fedora 8.2.1 → 8.2.2

data/spec/unit/rdf_datastream_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 
 describe ActiveFedora::RDFDatastream do
   describe "a new instance" do
-    its(:metadata?) { should be_true}
-    its(:content_changed?) { should be_false}
+    its(:metadata?) { should be_truthy}
+    its(:content_changed?) { should be_falsey}
   end
   describe "an instance that exists in the datastore, but hasn't been loaded" do
     before do
@@ -27,30 +27,30 @@ describe ActiveFedora::RDFDatastream do
     end
     subject { @obj.descMetadata }
     it "should not load the descMetadata datastream when calling content_changed?" do
-      @obj.inner_object.repository.should_not_receive(:datastream_dissemination).with(hash_including(:dsid=>'descMetadata'))
-      subject.should_not be_content_changed
+      expect(@obj.inner_object.repository).not_to receive(:datastream_dissemination).with(hash_including(:dsid=>'descMetadata'))
+      expect(subject).not_to be_content_changed
     end
 
     it "should allow asserting an empty string" do
       subject.title = ['']
-      subject.title.should == ['']
+      expect(subject.title).to eq([''])
     end
 
     describe "when multivalue: false" do
       it "should return single values" do
         subject.description = 'my description'
-        subject.description.should == 'my description'
+        expect(subject.description).to eq('my description')
       end
     end
 
     it "should clear stuff" do
       subject.title = ['one', 'two', 'three']
       subject.title.clear
-      subject.graph.query([subject.rdf_subject,  RDF::DC.title, nil]).first.should be_nil
+      expect(subject.graph.query([subject.rdf_subject,  RDF::DC.title, nil]).first).to be_nil
     end
 
     it "should have a list of fields" do
-      MyDatastream.fields.should == [:title, :description]
+      expect(MyDatastream.fields).to eq([:title, :description])
     end
   end
 
@@ -98,8 +98,8 @@ describe ActiveFedora::RDFDatastream do
   describe 'legacy non-utf-8 characters' do
     let(:ds) do
       datastream = ActiveFedora::NtriplesRDFDatastream.new
-      datastream.stub(:new?).and_return(false)
-      datastream.stub(:datastream_content).and_return("<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n\xE2\x80\x99 \" .\n".force_encoding('ASCII-8BIT'))
+      allow(datastream).to receive(:new?).and_return(false)
+      allow(datastream).to receive(:datastream_content).and_return("<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n\xE2\x80\x99 \" .\n".force_encoding('ASCII-8BIT'))
       datastream
     end
     it "should not error on access" do

data/spec/unit/rdf_resource_datastream_spec.rb

@@ -159,7 +159,7 @@ describe ActiveFedora::RDFDatastream do
       context "persisted to repository" do
         before do
           DummySubnode.configure :repository => :default
-          DummySubnode.any_instance.stub(:repository).and_return(RDF::Repository.new)
+          allow_any_instance_of(DummySubnode).to receive(:repository).and_return(RDF::Repository.new)
           dummy = DummySubnode.new(RDF::URI('http://example.org/dummy/blah'))
           dummy.title = ['subbla']
           # We want to have to manually persist to the repository.
@@ -311,7 +311,7 @@ describe ActiveFedora::RDFDatastream do
     end
 
     it 'lets me specify a resource class' do
-      expect(DummyResource.resource_class < DummyATResource).to be_true
+      expect(DummyResource.resource_class < DummyATResource).to eq true
     end
 
     it 'creates underlying resource of type resource_class' do

data/spec/unit/rdf_xml_writer_spec.rb

@@ -35,7 +35,7 @@ describe ActiveFedora::RDFXMLWriter do
         writer << statement
       end
     end
-    content.should be_equivalent_to @rdf_xml_with_type
+    expect(content).to be_equivalent_to @rdf_xml_with_type
   end
   
   it 'should serialize graphs without rdf:type equivalently to RDF::RDFXML::Writer' do
@@ -57,7 +57,7 @@ describe ActiveFedora::RDFXMLWriter do
         writer << statement
       end
     end
-    EquivalentXml.equivalent?(local_content, @rdf_xml).should be_true
-    EquivalentXml.equivalent?(local_content, generic_content).should be_true
+    expect(EquivalentXml.equivalent?(local_content, @rdf_xml)).to be_truthy
+    expect(EquivalentXml.equivalent?(local_content, generic_content)).to be_truthy
   end
 end

data/spec/unit/rdfxml_rdf_datastream_spec.rb

@@ -7,14 +7,14 @@ describe ActiveFedora::RdfxmlRDFDatastream do
         property :publisher, :predicate => RDF::DC.publisher
       end
       @subject = MyRdfxmlDatastream.new(@inner_object, 'mixed_rdf')
-      @subject.stub(:pid => 'test:1')
+      allow(@subject).to receive_messages(:pid => 'test:1')
     end
     after(:each) do
       Object.send(:remove_const, :MyRdfxmlDatastream)
     end
     it "should save and reload" do
       @subject.publisher = ["St. Martin's Press"]
-      @subject.serialize.should =~ /<rdf:RDF/
+      expect(@subject.serialize).to match(/<rdf:RDF/)
     end
   end
 
@@ -79,7 +79,7 @@ describe ActiveFedora::RdfxmlRDFDatastream do
     describe "a new instance" do
       subject { MyDatastream.new(double('inner object', :pid=>'test:1', :new_record? =>true), 'descMetadata', about:"http://library.ucsd.edu/ark:/20775/") }
       it "should have a subject" do
-        subject.rdf_subject.to_s.should == "http://library.ucsd.edu/ark:/20775/"
+        expect(subject.rdf_subject.to_s).to eq("http://library.ucsd.edu/ark:/20775/")
       end
 
     end
@@ -91,20 +91,20 @@ describe ActiveFedora::RdfxmlRDFDatastream do
         subject
       end
       it "should have a subject" do
-        subject.rdf_subject.to_s.should == "http://library.ucsd.edu/ark:/20775/"
+        expect(subject.rdf_subject.to_s).to eq("http://library.ucsd.edu/ark:/20775/")
       end
       it "should have controlGroup" do
-        subject.controlGroup.should == 'M'
+        expect(subject.controlGroup).to eq('M')
       end
       it "should have mimeType" do
-        subject.mimeType.should == 'text/xml'
+        expect(subject.mimeType).to eq('text/xml')
       end
       it "should have dsid" do
-        subject.dsid.should == 'descMetadata'
+        expect(subject.dsid).to eq('descMetadata')
       end
       it "should have fields" do
-        subject.resource_type.should == ["image"]
-        subject.title.first.value.should == ["example title"]
+        expect(subject.resource_type).to eq(["image"])
+        expect(subject.title.first.value).to eq(["example title"])
       end
     end
   end

data/spec/unit/relationship_graph_spec.rb

@@ -4,17 +4,17 @@ describe ActiveFedora::RelationshipGraph do
   before do 
     @graph = ActiveFedora::RelationshipGraph.new
     @n1 = ActiveFedora::Base.new()
-    @n1.stub(:pid => 'foo:777')
+    allow(@n1).to receive_messages(:pid => 'foo:777')
   end
 
   describe "#relationships" do
     it "should have hash accessors" do
-      @graph.should respond_to(:[])
+      expect(@graph).to respond_to(:[])
     end
 
     it "should initialize new relation keys" do
-      @graph[:has_description].should be_empty
-      @graph[:has_description].should respond_to(:<<)
+      expect(@graph[:has_description]).to be_empty
+      expect(@graph[:has_description]).to respond_to(:<<)
     end
 
   end
@@ -22,94 +22,94 @@ describe ActiveFedora::RelationshipGraph do
   it "should add relationships" do
     @n2 = ActiveFedora::Base.new
     @graph.add(:has_part, @n1)
-    @graph[:has_part].should == [@n1]
+    expect(@graph[:has_part]).to eq([@n1])
     @graph.add(:has_part, @n2)
-    @graph[:has_part].should == [@n1, @n2]
+    expect(@graph[:has_part]).to eq([@n1, @n2])
     @graph.add(:has_part, @n2)
-    @graph[:has_part].should == [@n1, @n2]
-    @graph.dirty.should be_true
+    expect(@graph[:has_part]).to eq([@n1, @n2])
+    expect(@graph.dirty).to be_truthy
   end
 
   it "should create a rdf graph" do
     graph = @graph.to_graph('info:fedora/foo:1')
-    graph.should be_kind_of RDF::Graph
-    graph.statements.to_a.should == []
+    expect(graph).to be_kind_of RDF::Graph
+    expect(graph.statements.to_a).to eq([])
 
     @graph.add(:has_part, @n1)
     graph = @graph.to_graph('info:fedora/foo:1')
     stmts = graph.statements.to_a
-    stmts.size.should == 1
+    expect(stmts.size).to eq(1)
     stmt = stmts.first
-    stmt.subject.to_s.should == 'info:fedora/foo:1'
-    stmt.predicate.to_s.should == 'info:fedora/fedora-system:def/relations-external#hasPart'
-    stmt.object.to_s.should == 'info:fedora/foo:777'
+    expect(stmt.subject.to_s).to eq('info:fedora/foo:1')
+    expect(stmt.predicate.to_s).to eq('info:fedora/fedora-system:def/relations-external#hasPart')
+    expect(stmt.object.to_s).to eq('info:fedora/foo:777')
     
   end
 
   it "should have array accessor" do
     @graph.add(:has_part, @n1)
-    @graph[:has_part].should == [@n1]
+    expect(@graph[:has_part]).to eq([@n1])
   end
 
   describe "has_predicate?" do
     it "should return true when it has it" do
-      @graph.has_predicate?(:has_part).should be_false
+      expect(@graph.has_predicate?(:has_part)).to be_falsey
       @graph.add(:has_part, @n1)
-      @graph.has_predicate?(:has_part).should be_true
+      expect(@graph.has_predicate?(:has_part)).to be_truthy
     end
   end
 
   describe "delete" do
     it "should delete an object when an object is passed" do
       @graph.add(:has_part, @n1)
-      @graph[:has_part].should == [@n1]
+      expect(@graph[:has_part]).to eq([@n1])
       @graph.delete(:has_part, @n1)
-      @graph[:has_part].should == []
+      expect(@graph[:has_part]).to eq([])
     end
     it "should delete an pid when an object is passed" do
       #a reloaded rels-ext is just a list of uris, not inflated.
       @graph.add(:has_part, 'info:fedora/foo:777')
-      @graph[:has_part].should == ['info:fedora/foo:777']
+      expect(@graph[:has_part]).to eq(['info:fedora/foo:777'])
       @graph.delete(:has_part, @n1)
-      @graph[:has_part].should == []
+      expect(@graph[:has_part]).to eq([])
     end
     it "should delete an pid when a string is passed" do
       #a reloaded rels-ext is just a list of uris, not inflated.
       @graph.add(:has_part, 'info:fedora/foo:777')
-      @graph[:has_part].should == ['info:fedora/foo:777']
+      expect(@graph[:has_part]).to eq(['info:fedora/foo:777'])
       @graph.delete(:has_part, 'info:fedora/foo:777')
-      @graph[:has_part].should == []
+      expect(@graph[:has_part]).to eq([])
     end
     it "should delete an object when a pid is passed" do
       #a reloaded rels-ext is just a list of uris, not inflated.
       @graph.add(:has_part, @n1)
-      @graph[:has_part].should == [@n1]
+      expect(@graph[:has_part]).to eq([@n1])
       @graph.delete(:has_part, 'info:fedora/foo:777')
-      @graph[:has_part].should == []
+      expect(@graph[:has_part]).to eq([])
     end
 
     it "should delete all the predicates if only one arg is passed" do
       @graph.add(:has_part, @n1)
-      @graph[:has_part].should == [@n1]
+      expect(@graph[:has_part]).to eq([@n1])
       @graph.delete(:has_part)
-      @graph.has_predicate?(:has_part).should_not be_true
+      expect(@graph.has_predicate?(:has_part)).not_to be_truthy
     end
   end
   describe "build_statement" do
     it "should raise an error when the target is a pid, not a uri" do
-      lambda { @graph.build_statement('info:fedora/spec:9', :is_part_of, 'spec:7') }.should raise_error ArgumentError
+      expect { @graph.build_statement('info:fedora/spec:9', :is_part_of, 'spec:7') }.to raise_error ArgumentError
     end
     it "should run the happy path" do
       stm = @graph.build_statement('info:fedora/spec:9', :is_part_of, 'info:fedora/spec:7')
-      stm.object.to_s.should == "info:fedora/spec:7"
+      expect(stm.object.to_s).to eq("info:fedora/spec:7")
     end
     it "should also be happy with non-info URIs" do
       stm = @graph.build_statement('info:fedora/spec:9', :is_annotation_of, 'http://www.w3.org/standards/techs/rdf')
-      stm.object.to_s.should == "http://www.w3.org/standards/techs/rdf"
+      expect(stm.object.to_s).to eq("http://www.w3.org/standards/techs/rdf")
     end
     it "should also be happy with targets that are URI::Generics" do
       stm = @graph.build_statement('info:fedora/spec:9', :is_annotation_of, URI.parse('http://www.w3.org/standards/techs/rdf'))
-      stm.object.to_s.should == "http://www.w3.org/standards/techs/rdf"
+      expect(stm.object.to_s).to eq("http://www.w3.org/standards/techs/rdf")
     end
   end
 end

data/spec/unit/reload_on_save_spec.rb

@@ -4,19 +4,19 @@ describe ActiveFedora::ReloadOnSave do
   let(:file) {  ActiveFedora::Base.new  }
 
   it 'defaults to call not reload' do
-    file.should_not_receive(:reload)
+    expect(file).not_to receive(:reload)
     file.save
   end
 
   it 'reload can be turned on' do
     file.reload_on_save = true
-    file.should_receive(:reload)
+    expect(file).to receive(:reload)
     file.save
   end
 
   it 'allows reload to be turned off and on' do
     file.reload_on_save = true
-    file.should_receive(:reload).once
+    expect(file).to receive(:reload).once
     file.save
     file.reload_on_save = false
     file.save

data/spec/unit/rels_ext_datastream_spec.rb

@@ -10,30 +10,30 @@ describe ActiveFedora::RelsExtDatastream do
   before(:each) do
       mock_inner = double('inner object')
       @mock_repo = double('repository')
-      @mock_repo.stub(:datastream_dissemination=>'My Content', :config=>{})
-      mock_inner.stub(:repository).and_return(@mock_repo)
-      mock_inner.stub(:pid).and_return(@pid)
+      allow(@mock_repo).to receive_messages(:datastream_dissemination=>'My Content', :config=>{})
+      allow(mock_inner).to receive(:repository).and_return(@mock_repo)
+      allow(mock_inner).to receive(:pid).and_return(@pid)
       @test_ds = ActiveFedora::RelsExtDatastream.new(mock_inner, "RELS-EXT")
-      @test_ds.stub(:profile).and_return({})
+      allow(@test_ds).to receive(:profile).and_return({})
   end
 
-  its(:metadata?) { should be_true}
+  its(:metadata?) { should be_truthy}
   its(:controlGroup) { should == "X"}
 
   describe "#mimeType" do
     it 'should use the application/rdf+xml mime type' do
-      @test_ds.mimeType.should == 'application/rdf+xml'
+      expect(@test_ds.mimeType).to eq('application/rdf+xml')
     end
   end
 
   describe "#changed?" do
     it "should be false when no changes have been made" do
       subject.model = double(:relationships_are_dirty? => false)
-      subject.changed?.should == false
+      expect(subject.changed?).to eq(false)
     end
     it "should be true when the model has changes" do
       subject.model = double(:relationships_are_dirty? => true)
-      subject.changed?.should == true
+      expect(subject.changed?).to eq(true)
     end
   end
   
@@ -45,9 +45,9 @@ describe ActiveFedora::RelsExtDatastream do
       subject = RDF::URI.new "info:fedora/test:sample_pid"
       graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:is_member_of),  RDF::URI.new('demo:10'))
       
-      @test_ds.stub(:new? => true, :relationships => graph, :model => double(:relationships_are_dirty? =>true, :relationships_are_not_dirty! => true))
+      allow(@test_ds).to receive_messages(:new? => true, :relationships => graph, :model => double(:relationships_are_dirty? =>true, :relationships_are_not_dirty! => true))
       @test_ds.serialize!
-      EquivalentXml.equivalent?(@test_ds.content, "<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'>\n        <rdf:Description rdf:about='info:fedora/test:sample_pid'>\n        <isMemberOf rdf:resource='demo:10' xmlns='info:fedora/fedora-system:def/relations-external#'/></rdf:Description>\n      </rdf:RDF>").should be_true
+      expect(EquivalentXml.equivalent?(@test_ds.content, "<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'>\n        <rdf:Description rdf:about='info:fedora/test:sample_pid'>\n        <isMemberOf rdf:resource='demo:10' xmlns='info:fedora/fedora-system:def/relations-external#'/></rdf:Description>\n      </rdf:RDF>")).to be_truthy
     end
   
   end
@@ -78,8 +78,8 @@ describe ActiveFedora::RelsExtDatastream do
       graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:has_model),  RDF::URI.new("info:fedora/afmodel:OtherModel"))
       graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:has_model),  RDF::URI.new("info:fedora/afmodel:SampleModel"))
 
-      @test_ds.should_receive(:model).and_return(double("model", :relationships=>graph, :relationships_are_dirty= => true))
-      EquivalentXml.equivalent?(@test_ds.to_rels_ext(), @sample_rels_ext_xml).should be_true
+      expect(@test_ds).to receive(:model).and_return(double("model", :relationships=>graph, :relationships_are_dirty= => true))
+      expect(EquivalentXml.equivalent?(@test_ds.to_rels_ext(), @sample_rels_ext_xml)).to be_truthy
     end
     
     it 'should use mapped namespace prefixes when given' do
@@ -91,21 +91,21 @@ describe ActiveFedora::RelsExtDatastream do
       graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:has_model),  RDF::URI.new("info:fedora/afmodel:OtherModel"))
       graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:has_model),  RDF::URI.new("info:fedora/afmodel:SampleModel"))
 
-      @test_ds.stub(:model).and_return(double("model", :relationships=>graph, :relationships_are_dirty= => true))
+      allow(@test_ds).to receive(:model).and_return(double("model", :relationships=>graph, :relationships_are_dirty= => true))
       rels = @test_ds.to_rels_ext()
-      EquivalentXml.equivalent?(rels, @sample_rels_ext_xml).should be_true
-      rels.should_not =~ /fedora:isMemberOf/
-      rels.should_not =~ /fedora-model:hasModel/
-      rels.should =~ /ns\d:isMemberOf/
-      rels.should =~ /ns\d:hasModel/
+      expect(EquivalentXml.equivalent?(rels, @sample_rels_ext_xml)).to be_truthy
+      expect(rels).not_to match(/fedora:isMemberOf/)
+      expect(rels).not_to match(/fedora-model:hasModel/)
+      expect(rels).to match(/ns\d:isMemberOf/)
+      expect(rels).to match(/ns\d:hasModel/)
       
       ActiveFedora::Predicates.predicate_config[:predicate_namespaces] = {:"fedora-model"=>"info:fedora/fedora-system:def/model#", :fedora=>"info:fedora/fedora-system:def/relations-external#"}
       rels = @test_ds.to_rels_ext()
-      EquivalentXml.equivalent?(rels, @sample_rels_ext_xml).should be_true
-      rels.should =~ /fedora:isMemberOf/
-      rels.should =~ /fedora-model:hasModel/
-      rels.should_not =~ /ns\d:isMemberOf/
-      rels.should_not =~ /ns\d:hasModel/
+      expect(EquivalentXml.equivalent?(rels, @sample_rels_ext_xml)).to be_truthy
+      expect(rels).to match(/fedora:isMemberOf/)
+      expect(rels).to match(/fedora-model:hasModel/)
+      expect(rels).not_to match(/ns\d:isMemberOf/)
+      expect(rels).not_to match(/ns\d:hasModel/)
       ActiveFedora::Predicates.predicate_config[:predicate_namespaces] = nil
     end
     
@@ -125,8 +125,8 @@ describe ActiveFedora::RelsExtDatastream do
     it "should handle un-mapped predicates gracefully" do
       @test_obj.add_relationship("foo", "info:fedora/foo:bar")
       @test_obj.save
-      @test_obj.relationships.size.should == 5 
-      @test_obj.ids_for_outbound("foo").should == ["foo:bar"]
+      expect(@test_obj.relationships.size).to eq(5) 
+      expect(@test_obj.ids_for_outbound("foo")).to eq(["foo:bar"])
     end
     it "should automatically map un-mapped predicates" do
       xml = <<-EOS
@@ -144,8 +144,8 @@ describe ActiveFedora::RelsExtDatastream do
       model = ActiveFedora::Base.new
       new_ds = ActiveFedora::RelsExtDatastream.new
       new_ds.model = model
-      lambda { ActiveFedora::RelsExtDatastream.from_xml(xml, new_ds) }.should_not raise_exception
-      new_ds.to_rels_ext.should =~ /missing:hasOtherRelationship/
+      expect { ActiveFedora::RelsExtDatastream.from_xml(xml, new_ds) }.not_to raise_exception
+      expect(new_ds.to_rels_ext).to match(/missing:hasOtherRelationship/)
     end
     it "should handle un-mapped literals" do
       xml = "
@@ -162,7 +162,7 @@ describe ActiveFedora::RelsExtDatastream do
       new_ds.model = model
       ActiveFedora::RelsExtDatastream.from_xml(xml, new_ds)
       new_ext = new_ds.to_rels_ext()
-      new_ext.should match "<ns2:itemID>oai:hull.ac.uk:hull:2708</ns2:itemID>"
+      expect(new_ext).to match "<ns2:itemID>oai:hull.ac.uk:hull:2708</ns2:itemID>"
       
     end
   end

data/spec/unit/rspec_matchers/belong_to_associated_active_fedora_object_matcher_spec.rb

@@ -10,17 +10,17 @@ describe RSpec::Matchers, "belong_to_associated_active_fedora_object_matcher" do
   let(:association) { :association }
 
   it 'should match when association is properly stored in fedora' do
-    subject.class.should_receive(:find).with(pid).and_return(subject)
-    subject.should_receive(association).and_return(object1)
-    subject.should belong_to_associated_active_fedora_object(association).with_object(object1)
+    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject).to receive(association).and_return(object1)
+    expect(subject).to belong_to_associated_active_fedora_object(association).with_object(object1)
   end
 
   it 'should not match when association is different' do
-    subject.class.should_receive(:find).with(pid).and_return(subject)
-    subject.should_receive(association).and_return(object1)
-    lambda {
-      subject.should belong_to_associated_active_fedora_object(association).with_object(object2)
-    }.should (
+    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject).to receive(association).and_return(object1)
+    expect {
+      expect(subject).to belong_to_associated_active_fedora_object(association).with_object(object2)
+    }.to (
       raise_error(
         RSpec::Expectations::ExpectationNotMetError,
         /expected #{subject.class} PID=#{pid} association: #{association.inspect}/
@@ -29,9 +29,9 @@ describe RSpec::Matchers, "belong_to_associated_active_fedora_object_matcher" do
   end
 
   it 'should require :with_object option' do
-    lambda {
-      subject.should belong_to_associated_active_fedora_object(association)
-    }.should(
+    expect {
+      expect(subject).to belong_to_associated_active_fedora_object(association)
+    }.to(
       raise_error(
         ArgumentError,
         "subject.should belong_to_associated_active_fedora_object(<association_name>).with_object(<object>)"