active-fedora 8.2.1 → 8.2.2

data/spec/integration/model_spec.rb

@@ -29,11 +29,11 @@ describe ActiveFedora::Model do
   describe "#all" do
     it "should return an array of instances of the calling Class" do
       result = ModelIntegrationSpec::Basic.all.to_a
-      result.should be_instance_of(Array)
+      expect(result).to be_instance_of(Array)
       # this test is meaningless if the array length is zero
-      result.length.should > 0
+      expect(result.length).to be > 0
       result.each do |obj|
-        obj.class.should == ModelIntegrationSpec::Basic
+        expect(obj.class).to eq(ModelIntegrationSpec::Basic)
       end
     end
   end
@@ -41,31 +41,31 @@ describe ActiveFedora::Model do
   describe '#find' do
     describe "#find with a valid pid without cast" do
       subject { ActiveFedora::Base.find(@test_instance.pid) }
-      it { should be_instance_of ModelIntegrationSpec::Basic}
+      it { is_expected.to be_instance_of ModelIntegrationSpec::Basic}
     end
     describe "#find with a valid pid with cast of false" do
       subject { ActiveFedora::Base.find(@test_instance.pid, cast: false) }
-      it { should be_instance_of ActiveFedora::Base}
+      it { is_expected.to be_instance_of ActiveFedora::Base}
     end
     describe "#find with a valid pid without cast on a model extending Base" do
       subject { ModelIntegrationSpec::Basic.find(@test_instance.pid) }
-      it { should be_instance_of ModelIntegrationSpec::Basic}
+      it { is_expected.to be_instance_of ModelIntegrationSpec::Basic}
     end
   end
 
   describe "#load_instance_from_solr" do
     describe "with a valid pid" do
       subject { ActiveFedora::Base.load_instance_from_solr(@test_instance.pid) }
-      it { should be_instance_of ModelIntegrationSpec::Basic}
+      it { is_expected.to be_instance_of ModelIntegrationSpec::Basic}
     end
     describe "with metadata datastream spec" do
       subject { ActiveFedora::Base.load_instance_from_solr(@test_instance.pid) }
       it "should create an xml datastream" do
-        subject.datastreams['properties'].should be_kind_of ActiveFedora::SimpleDatastream
+        expect(subject.datastreams['properties']).to be_kind_of ActiveFedora::SimpleDatastream
       end
 
       it "should know the datastreams properties" do
-        subject.properties.dsSize.should == 9
+        expect(subject.properties.dsSize).to eq(9)
       end
     end
   end

data/spec/integration/nested_attribute_spec.rb

@@ -43,31 +43,31 @@ describe "NestedAttribute behavior" do
   end
 
   it "should have _destroy" do
-    Bar.new._destroy.should be_false
+    expect(Bar.new._destroy).to be_falsey
   end
 
   it "should update the child objects" do
     @car, @bar1, @bar2 = create_car_with_bars
 
     @car.attributes = {:bars_attributes=>[{:id=>@bar1.pid, :uno=>"bar1 uno"}, {:uno=>"newbar uno"}, {:id=>@bar2.pid, :_destroy=>'1', :uno=>'bar2 uno'}]}
-    Bar.find(@bar1.pid).uno.should == 'bar1 uno'
-    Bar.where(:id => @bar2.pid).first.should be_nil
-    Bar.where(:uno => "newbar uno").first.should_not be_nil
+    expect(Bar.find(@bar1.pid).uno).to eq('bar1 uno')
+    expect(Bar.where(:id => @bar2.pid).first).to be_nil
+    expect(Bar.where(:uno => "newbar uno").first).not_to be_nil
 
     bars = @car.bars(true)
-    bars.should include(@bar1)
-    bars.should_not include(@bar2)
+    expect(bars).to include(@bar1)
+    expect(bars).not_to include(@bar2)
   end
 
   it "should reject attributes when all blank" do
     @car, @bar1, @bar2 = create_car_with_bars(CarAllBlank)
 
-    @car.bars.count.should == 2
+    expect(@car.bars.count).to eq(2)
     @car.attributes = {:bars_attributes=>[{}, {:id=>@bar1.pid, :uno=>"bar1 uno"}]}
-    @car.bars(true).count.should == 2
+    expect(@car.bars(true).count).to eq(2)
 
     @bar1.reload
-    @bar1.uno.should == "bar1 uno"
+    expect(@bar1.uno).to eq("bar1 uno")
   end
 
   it "should reject attributes based on proc" do
@@ -76,8 +76,8 @@ describe "NestedAttribute behavior" do
     @car.attributes = {:bars_attributes=>[{}, {:id=>@bar1.pid, :uno=>"bar1 uno"}, {:id=>@bar2.pid, :dos=>"bar2 dos"}]}
     @bar1.reload
     @bar2.reload
-    @bar1.uno.should == "bar1 uno"
-    @bar2.dos.should be_nil
+    expect(@bar1.uno).to eq("bar1 uno")
+    expect(@bar2.dos).to be_nil
   end
 
   it "should reject attributes base on method name" do
@@ -86,20 +86,20 @@ describe "NestedAttribute behavior" do
     @car.attributes = {:bars_attributes=>[{}, {:id=>@bar1.pid, :uno=>"bar1 uno"}, {:id=>@bar2.pid, :dos=>"bar2 dos"}]}
     @bar1.reload
     @bar2.reload
-    @bar1.uno.should == "bar1 uno"
-    @bar2.dos.should be_nil
+    expect(@bar1.uno).to eq("bar1 uno")
+    expect(@bar2.dos).to be_nil
   end
 
   it "should throw TooManyRecords" do
     @car, @bar1, @bar2 = create_car_with_bars(CarWithLimit)
 
-    lambda {
+    expect {
       @car.attributes = {:bars_attributes=>[{}]}
-    }.should_not raise_exception
+    }.not_to raise_exception
 
-    lambda {
+    expect {
       @car.attributes = {:bars_attributes=>[{}, {}]}
-    }.should raise_exception(ActiveFedora::NestedAttributes::TooManyRecords)
+    }.to raise_exception(ActiveFedora::NestedAttributes::TooManyRecords)
   end
 
   private

data/spec/integration/ntriples_datastream_spec.rb

@@ -49,25 +49,25 @@ describe ActiveFedora::NtriplesRDFDatastream do
     foo = RdfTest.new(pid: 'test:1') #Pid needs to match the subject in the loaded file
     foo.title = 'Hamlet'
     foo.save
-    foo.title.should == 'Hamlet'
+    expect(foo.title).to eq('Hamlet')
     foo.rdf.content = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
     foo.save
-    foo.title.should == 'Title of work'
+    expect(foo.title).to eq('Title of work')
   end
 
   it "should delegate as_json to the fields" do
     @subject = RdfTest.new(title: "Title of work")
-    @subject.rdf.title.as_json.should == ["Title of work"]
-    @subject.rdf.title.to_json.should == "\[\"Title of work\"\]"
+    expect(@subject.rdf.title.as_json).to eq(["Title of work"])
+    expect(@subject.rdf.title.to_json).to eq("\[\"Title of work\"\]")
   end
 
   it "should solrize even when the object is not new" do
     foo = RdfTest.new
-    foo.should_receive(:update_index).once
+    expect(foo).to receive(:update_index).once
     foo.title = "title1"
     foo.save
     foo = RdfTest.find(foo.pid)
-    foo.should_receive(:update_index).once
+    expect(foo).to receive(:update_index).once
     foo.title = "The Work2"
     foo.save  
   end
@@ -75,36 +75,36 @@ describe ActiveFedora::NtriplesRDFDatastream do
   describe "serializing" do
     it "should handle dates" do
       subject.date_uploaded = [Date.parse('2012-11-02')]
-      subject.date_uploaded.first.should be_kind_of Date
+      expect(subject.date_uploaded.first).to be_kind_of Date
       solr_document = subject.to_solr
-      solr_document[ActiveFedora::SolrService.solr_name('rdf__date_uploaded', type: :date)].should == ['2012-11-02T00:00:00Z']
+      expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__date_uploaded', type: :date)]).to eq(['2012-11-02T00:00:00Z'])
     end
     it "should handle integers" do
       subject.filesize = 12345 
-      subject.filesize.should be_kind_of Fixnum
+      expect(subject.filesize).to be_kind_of Fixnum
       solr_document = subject.to_solr
-      solr_document[ActiveFedora::SolrService.solr_name('rdf__filesize', :stored_sortable, type: :integer)].should == '12345'
+      expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__filesize', :stored_sortable, type: :integer)]).to eq('12345')
     end
   end
 
   it "should produce a solr document" do
     @subject = RdfTest.new(title: "War and Peace")
     solr_document = @subject.to_solr
-    solr_document[ActiveFedora::SolrService.solr_name('rdf__title', :facetable)].should == ["War and Peace"]
-    solr_document[ActiveFedora::SolrService.solr_name('rdf__title', type: :string)].should == ["War and Peace"]
+    expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__title', :facetable)]).to eq(["War and Peace"])
+    expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__title', type: :string)]).to eq(["War and Peace"])
   end
 
   it "should set and recall values" do
     @subject.title = 'War and Peace'
-    @subject.rdf.should be_changed
+    expect(@subject.rdf).to be_changed
     @subject.based_near = ["Moscow, Russia"]
     @subject.related_url = ["http://en.wikipedia.org/wiki/War_and_Peace"]
     @subject.part = ["this is a part"]
     @subject.save
-    @subject.title.should == 'War and Peace'
-    @subject.based_near.should == ["Moscow, Russia"]
-    @subject.related_url.should == ["http://en.wikipedia.org/wiki/War_and_Peace"]
-    @subject.part.should == ["this is a part"]    
+    expect(@subject.title).to eq('War and Peace')
+    expect(@subject.based_near).to eq(["Moscow, Russia"])
+    expect(@subject.related_url).to eq(["http://en.wikipedia.org/wiki/War_and_Peace"])
+    expect(@subject.part).to eq(["this is a part"])    
   end
   it "should set, persist, and recall values" do
     @subject.title = 'War and Peace'
@@ -114,24 +114,24 @@ describe ActiveFedora::NtriplesRDFDatastream do
     @subject.save
 
     loaded = RdfTest.find(@subject.pid)
-    loaded.title.should == 'War and Peace'
-    loaded.based_near.should == ['Moscow, Russia']
-    loaded.related_url.should == ['http://en.wikipedia.org/wiki/War_and_Peace']
-    loaded.part.should == ['this is a part']
+    expect(loaded.title).to eq('War and Peace')
+    expect(loaded.based_near).to eq(['Moscow, Russia'])
+    expect(loaded.related_url).to eq(['http://en.wikipedia.org/wiki/War_and_Peace'])
+    expect(loaded.part).to eq(['this is a part'])
   end
   it "should set multiple values" do
     @subject.part = ["part 1", "part 2"]
     @subject.save
 
     loaded = RdfTest.find(@subject.pid)
-    loaded.part.should == ['part 1', 'part 2']
+    expect(loaded.part).to eq(['part 1', 'part 2'])
   end
   it "should append values" do
     @subject.part = ["thing 1"]
     @subject.save
 
     @subject.part << "thing 2"
-    @subject.part.should == ["thing 1", "thing 2"]
+    expect(@subject.part).to eq(["thing 1", "thing 2"])
   end
 
   it "should be able to save a blank document" do
@@ -144,7 +144,7 @@ describe ActiveFedora::NtriplesRDFDatastream do
 <http://oregondigital.org/ns/62> <http://purl.org/dc/terms/spatial> "Benton County (Ore.)" .
 '
     @subject.rdf.content = ntrip
-    @subject.rdf.graph.dump(:ntriples).should == ntrip
+    expect(@subject.rdf.graph.dump(:ntriples)).to eq(ntrip)
   end
 
   describe "using rdf_subject" do
@@ -165,7 +165,7 @@ describe ActiveFedora::NtriplesRDFDatastream do
       @subject.rdf.dctype = "Frog"
       @subject.save!
       @subject.reload
-      @subject.rdf.graph.dump(:ntriples).should == "<http://oregondigital.org/ns/99> <http://purl.org/dc/terms/type> \"Frog\" .\n"
+      expect(@subject.rdf.graph.dump(:ntriples)).to eq("<http://oregondigital.org/ns/99> <http://purl.org/dc/terms/type> \"Frog\" .\n")
       @subject.rdf.dctype == ['Frog']
 
     end
@@ -178,32 +178,32 @@ describe ActiveFedora::NtriplesRDFDatastream do
     @subject.related_url = ["http://psu.edu/"]
     @subject.related_url << "http://projecthydra.org/"
 
-    @subject.title.should == "Hamlet"
-    @subject.related_url.should include("http://psu.edu/")
-    @subject.related_url.should include("http://projecthydra.org/")
+    expect(@subject.title).to eq("Hamlet")
+    expect(@subject.related_url).to include("http://psu.edu/")
+    expect(@subject.related_url).to include("http://projecthydra.org/")
 
     @subject.title = "" #empty string can be meaningful, don't assume delete.
-    @subject.title.should == ''
+    expect(@subject.title).to eq('')
 
     @subject.title = nil
     @subject.related_url.delete("http://projecthydra.org/")
 
-    @subject.title.should be_nil
-    @subject.related_url.should == ["http://psu.edu/"]
+    expect(@subject.title).to be_nil
+    expect(@subject.related_url).to eq(["http://psu.edu/"])
   end
   it "should delete multiple values at once" do
     @subject.part = ["MacBeth"]
     @subject.part << "Hamlet"
     @subject.part << "Romeo & Juliet"
-    @subject.part.first.should == "MacBeth"
+    expect(@subject.part.first).to eq("MacBeth")
     @subject.part.delete("MacBeth", "Romeo & Juliet")
-    @subject.part.should == ["Hamlet"]
-    @subject.part.first.should == "Hamlet"
+    expect(@subject.part).to eq(["Hamlet"])
+    expect(@subject.part.first).to eq("Hamlet")
   end
   it "should ignore values to be deleted that do not exist" do
     @subject.part = ["title1", "title2", "title3"]
     @subject.part.delete("title2", "title4", "title6")
-    @subject.part.should == ["title1", "title3"]
+    expect(@subject.part).to eq(["title1", "title3"])
   end
   describe "term proxy methods" do
     before(:each) do
@@ -224,25 +224,25 @@ describe ActiveFedora::NtriplesRDFDatastream do
     end
 
     it "should support the count method to determine # of values" do
-      @subject.title.count.should == 3
+      expect(@subject.title.count).to eq(3)
     end
     it "should iterate over multiple values" do
-      @subject.title.should respond_to(:each)
+      expect(@subject.title).to respond_to(:each)
     end
     it "should get the first value" do
-      @subject.title.first.should == "title1"
+      expect(@subject.title.first).to eq("title1")
     end
     it "should evaluate equality predictably" do
-      @subject.title.should == ["title1", "title2", "title3"]
+      expect(@subject.title).to eq(["title1", "title2", "title3"])
     end
     it "should support the empty? method" do
-      @subject.title.should respond_to(:empty?)
-      @subject.title.empty?.should be_false
+      expect(@subject.title).to respond_to(:empty?)
+      expect(@subject.title.empty?).to be_falsey
       @subject.title.delete("title1", "title2", "title3")
-      @subject.title.empty?.should be_true
+      expect(@subject.title.empty?).to be_truthy
     end
     it "should support the is_a? method" do
-      @subject.title.is_a?(Array).should == true
+      expect(@subject.title.is_a?(Array)).to eq(true)
     end
   end
 end

data/spec/integration/om_datastream_spec.rb

@@ -26,28 +26,28 @@ describe ActiveFedora::OmDatastream do
     end
 
     it "should report being inline" do
-      @obj.descMetadata.should be_inline
+      expect(@obj.descMetadata).to be_inline
     end
 
     it "should not be changed when no fields have been set" do
-      @obj.descMetadata.should_not be_changed
+      expect(@obj.descMetadata).not_to be_changed
     end
     it "should be changed when a field has been set" do
       @obj.descMetadata.title = 'Foobar'
-      @obj.descMetadata.should be_changed
+      expect(@obj.descMetadata).to be_changed
     end
     describe "#changed?" do
       it "should not be changed if the new xml matches the old xml" do
         @obj.descMetadata.content = @obj.descMetadata.content
-        @obj.descMetadata.should_not be_changed
+        expect(@obj.descMetadata).not_to be_changed
       end
 
       it "should not be changed if there are minor differences in whitespace" do
         @obj.descMetadata.content = "<a><b>1</b></a>"
         @obj.save
-        @obj.descMetadata.should_not be_changed
+        expect(@obj.descMetadata).not_to be_changed
         @obj.descMetadata.content = "<a>\n<b>1</b>\n</a>"
-        @obj.descMetadata.should_not be_changed
+        expect(@obj.descMetadata).not_to be_changed
       end
     end
   end
@@ -75,21 +75,21 @@ describe ActiveFedora::OmDatastream do
     end
 
     it "should not report being inline" do
-      @obj.descMetadata.should be_managed
+      expect(@obj.descMetadata).to be_managed
     end
 
     describe "#changed?" do
       it "should not be changed if the new xml matches the old xml" do
         @obj.descMetadata.content = @obj.descMetadata.content
-        @obj.descMetadata.should_not be_changed
+        expect(@obj.descMetadata).not_to be_changed
       end
 
       it "should be changed if there are minor differences in whitespace" do
         @obj.descMetadata.content = "<a><b>1</b></a>"
         @obj.save
-        @obj.descMetadata.should_not be_changed
+        expect(@obj.descMetadata).not_to be_changed
         @obj.descMetadata.content = "<a>\n<b>1</b>\n</a>"
-        @obj.descMetadata.should be_changed
+        expect(@obj.descMetadata).to be_changed
       end
     end
 
@@ -109,31 +109,31 @@ describe ActiveFedora::OmDatastream do
       end
 
       it "should return the same values whether getting from solr or Fedora" do
-        @solr_obj.datastreams["descMetadata"].term_values(:name,:role,:text).should == ["Creator","Contributor","Funder","Host"]
-        @solr_obj.datastreams["descMetadata"].term_values({:name=>0},:role,:text).should == ["Creator"]
-        @solr_obj.datastreams["descMetadata"].term_values({:name=>1},:role,:text).should == ["Contributor"]
-        @solr_obj.datastreams["descMetadata"].term_values({:name=>0},{:role=>0},:text).should == ["Creator"]
-        @solr_obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>0},:text).should == ["Contributor"]
-        @solr_obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>1},:text).should == []
+        expect(@solr_obj.datastreams["descMetadata"].term_values(:name,:role,:text)).to eq(["Creator","Contributor","Funder","Host"])
+        expect(@solr_obj.datastreams["descMetadata"].term_values({:name=>0},:role,:text)).to eq(["Creator"])
+        expect(@solr_obj.datastreams["descMetadata"].term_values({:name=>1},:role,:text)).to eq(["Contributor"])
+        expect(@solr_obj.datastreams["descMetadata"].term_values({:name=>0},{:role=>0},:text)).to eq(["Creator"])
+        expect(@solr_obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>0},:text)).to eq(["Contributor"])
+        expect(@solr_obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>1},:text)).to eq([])
         ar = @solr_obj.datastreams["descMetadata"].term_values(:name,{:role=>0},:text)
-        ar.length.should == 4
-        ar.include?("Creator").should == true
-        ar.include?("Contributor").should == true
-        ar.include?("Funder").should == true
-        ar.include?("Host").should == true
-
-        @obj.datastreams["descMetadata"].term_values(:name,:role,:text).should == ["Creator","Contributor","Funder","Host"]
-        @obj.datastreams["descMetadata"].term_values({:name=>0},:role,:text).should == ["Creator"]
-        @obj.datastreams["descMetadata"].term_values({:name=>1},:role,:text).should == ["Contributor"]
-        @obj.datastreams["descMetadata"].term_values({:name=>0},{:role=>0},:text).should == ["Creator"]
-        @obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>0},:text).should == ["Contributor"]
-        @obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>1},:text).should == []
+        expect(ar.length).to eq(4)
+        expect(ar.include?("Creator")).to eq(true)
+        expect(ar.include?("Contributor")).to eq(true)
+        expect(ar.include?("Funder")).to eq(true)
+        expect(ar.include?("Host")).to eq(true)
+
+        expect(@obj.datastreams["descMetadata"].term_values(:name,:role,:text)).to eq(["Creator","Contributor","Funder","Host"])
+        expect(@obj.datastreams["descMetadata"].term_values({:name=>0},:role,:text)).to eq(["Creator"])
+        expect(@obj.datastreams["descMetadata"].term_values({:name=>1},:role,:text)).to eq(["Contributor"])
+        expect(@obj.datastreams["descMetadata"].term_values({:name=>0},{:role=>0},:text)).to eq(["Creator"])
+        expect(@obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>0},:text)).to eq(["Contributor"])
+        expect(@obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>1},:text)).to eq([])
         ar = @obj.datastreams["descMetadata"].term_values(:name,{:role=>0},:text)
-        ar.length.should == 4
-        ar.include?("Creator").should == true
-        ar.include?("Contributor").should == true
-        ar.include?("Funder").should == true
-        ar.include?("Host").should == true
+        expect(ar.length).to eq(4)
+        expect(ar.include?("Creator")).to eq(true)
+        expect(ar.include?("Contributor")).to eq(true)
+        expect(ar.include?("Funder")).to eq(true)
+        expect(ar.include?("Host")).to eq(true)
       end
     end
     
@@ -146,10 +146,10 @@ describe ActiveFedora::OmDatastream do
 
       it "should not be dirty after .update_values is saved" do
         @obj.datastreams["descMetadata"].update_values([{:name=>0},{:role=>0},:text] =>"Funder")
-        @obj.datastreams["descMetadata"].should be_changed
+        expect(@obj.datastreams["descMetadata"]).to be_changed
         @obj.save
-        @obj.datastreams["descMetadata"].should_not be_changed
-        @obj.datastreams["descMetadata"].term_values({:name=>0},{:role=>0},:text).should == ["Funder"]
+        expect(@obj.datastreams["descMetadata"]).not_to be_changed
+        expect(@obj.datastreams["descMetadata"].term_values({:name=>0},{:role=>0},:text)).to eq(["Funder"])
       end    
     end
 
@@ -161,7 +161,7 @@ describe ActiveFedora::OmDatastream do
         @obj.reload
       end
       it "should solrize terms with :type=>'date' to *_dt solr terms" do
-        @obj.to_solr[ActiveFedora::SolrService.solr_name('desc_metadata__journal_issue_publication_date', type: :date)].should == ['2012-11-02T00:00:00Z']
+        expect(@obj.to_solr[ActiveFedora::SolrService.solr_name('desc_metadata__journal_issue_publication_date', type: :date)]).to eq(['2012-11-02T00:00:00Z'])
       end
     end
   end