active-fedora 6.7.8 → 6.8.0

data/spec/integration/nested_attribute_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-describe "NestedAttribute behavior" do
+describe 'NestedAttribute behavior' do
   before do
     class Bar < ActiveFedora::Base
-      belongs_to :car, :property=>:has_member
-      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"someData" do |m|
-        m.field "uno", :string
-        m.field "dos", :string
+      belongs_to :car, :property => :has_member
+      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'someData' do |m|
+        m.field 'uno', :string
+        m.field 'dos', :string
       end
       delegate :uno, to: 'someData', multiple: false
       delegate :dos, to: 'someData', multiple: false
@@ -14,23 +14,23 @@ describe "NestedAttribute behavior" do
 
     # base Car class, used in test for association updates and :allow_destroy flag
     class Car < ActiveFedora::Base
-      has_many :bars, :property=>:has_member
-      accepts_nested_attributes_for :bars, :allow_destroy=>true
+      has_many :bars, :property => :has_member
+      accepts_nested_attributes_for :bars, :allow_destroy => true
     end
 
     # class used in test for :reject_if=>:all_blank
     class CarAllBlank < Car
-      accepts_nested_attributes_for :bars, :reject_if=>:all_blank
+      accepts_nested_attributes_for :bars, :reject_if => :all_blank
     end
 
     # class used in test for :reject_if with proc object
     class CarProc < Car
-      accepts_nested_attributes_for :bars, :reject_if=>proc { |attributes| attributes['uno'].blank? }
+      accepts_nested_attributes_for :bars, :reject_if => proc { |attributes| attributes['uno'].blank? }
     end
 
     # class used in test for :reject_if with method name as symbol
     class CarSymbol < Car
-      accepts_nested_attributes_for :bars, :reject_if=>:uno_blank
+      accepts_nested_attributes_for :bars, :reject_if => :uno_blank
 
       def uno_blank(attributes)
         attributes['uno'].blank?
@@ -43,64 +43,64 @@ describe "NestedAttribute behavior" do
     end
   end
 
-  it "should have _destroy" do
-    Bar.new._destroy.should be_false
+  it 'should have _destroy' do
+    expect(Bar.new._destroy).to be_falsey
   end
 
-  it "should update the child objects" do
+  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
+    @car.attributes = {:bars_attributes => [{:id => @bar1.pid, :uno => 'bar1 uno'}, {:uno => 'newbar uno'}, {:id => @bar2.pid, :_destroy => '1', :uno => 'bar2 uno'}]}
+    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
+  it 'should reject attributes when all blank' do
     @car, @bar1, @bar2 = create_car_with_bars(CarAllBlank)
 
-    @car.bars.count.should == 2
-    @car.attributes = {:bars_attributes=>[{}, {:id=>@bar1.pid, :uno=>"bar1 uno"}]}
-    @car.bars(true).count.should == 2
+    expect(@car.bars.count).to eq(2)
+    @car.attributes = {:bars_attributes => [{}, {:id => @bar1.pid, :uno => 'bar1 uno'}]}
+    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
+  it 'should reject attributes based on proc' do
     @car, @bar1, @bar2 = create_car_with_bars(CarProc)
 
-    @car.attributes = {:bars_attributes=>[{}, {:id=>@bar1.pid, :uno=>"bar1 uno"}, {:id=>@bar2.pid, :dos=>"bar2 dos"}]}
+    @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
+  it 'should reject attributes base on method name' do
     @car, @bar1, @bar2 = create_car_with_bars(CarSymbol)
 
-    @car.attributes = {:bars_attributes=>[{}, {:id=>@bar1.pid, :uno=>"bar1 uno"}, {:id=>@bar2.pid, :dos=>"bar2 dos"}]}
+    @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
+  it 'should throw TooManyRecords' do
     @car, @bar1, @bar2 = create_car_with_bars(CarWithLimit)
 
-    lambda {
-      @car.attributes = {:bars_attributes=>[{}]}
-    }.should_not raise_exception
+    expect {
+      @car.attributes = {:bars_attributes => [{}]}
+    }.not_to raise_exception
 
-    lambda {
-      @car.attributes = {:bars_attributes=>[{}, {}]}
-    }.should raise_exception(ActiveFedora::NestedAttributes::TooManyRecords)
+    expect {
+      @car.attributes = {:bars_attributes => [{}, {}]}
+    }.to raise_exception(ActiveFedora::NestedAttributes::TooManyRecords)
   end
 
   private
@@ -114,8 +114,8 @@ describe "NestedAttribute behavior" do
   def create_car_with_bars(car_class = Car, bar_class = Bar)
     car = car_class.new; car.save
 
-    bar1 = bar_class.new(:car=>car); bar1.save
-    bar2 = bar_class.new(:car=>car); bar2.save
+    bar1 = bar_class.new(:car => car); bar1.save
+    bar2 = bar_class.new(:car => car); bar2.save
     [car, bar1, bar2]
   end
 

data/spec/integration/ntriples_datastream_spec.rb

@@ -7,17 +7,17 @@ describe ActiveFedora::NtriplesRDFDatastream do
         map.title(:in => RDF::DC) do |index|
           index.as :stored_searchable, :facetable
         end
-        map.date_uploaded(:to => "dateSubmitted", :in => RDF::DC) do |index|
+        map.date_uploaded(:to => 'dateSubmitted', :in => RDF::DC) do |index|
           index.type :date
           index.as :stored_searchable, :sortable
         end
-        map.part(:to => "hasPart", :in => RDF::DC)
+        map.part(:to => 'hasPart', :in => RDF::DC)
         map.based_near(:in => RDF::FOAF)
-        map.related_url(:to => "seeAlso", :in => RDF::RDFS)
+        map.related_url(:to => 'seeAlso', :in => RDF::RDFS)
       end
     end
-    class RdfTest < ActiveFedora::Base 
-      has_metadata :name=>'rdf', :type=>MyDatastream
+    class RdfTest < ActiveFedora::Base
+      has_metadata :name => 'rdf', :type => MyDatastream
       delegate_to 'rdf', [:based_near, :related_url, :part, :date_uploaded], multiple: true
       delegate :title, to: 'rdf', multiple: false
     end
@@ -33,105 +33,105 @@ describe ActiveFedora::NtriplesRDFDatastream do
     Object.send(:remove_const, :MyDatastream)
   end
 
-  it "should not try to send an empty datastream" do
+  it 'should not try to send an empty datastream' do
     @subject.save
   end
 
-  it "should save content properly upon save" do
-    foo = RdfTest.new(:pid=>'test:1') #Pid needs to match the subject in the loaded file
+  it 'should save content properly upon save' 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\"\]"
+  it 'should delegate as_json to the fields' do
+    @subject = RdfTest.new(title: '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
+  it 'should solrize even when the object is not new' do
     foo = RdfTest.new
-    foo.should_receive(:update_index).once
-    foo.title = "title1"
+    expect(foo).to receive(:update_index).once
+    foo.title = 'title1'
     foo.save
     foo = RdfTest.find(foo.pid)
-    foo.should_receive(:update_index).once
-    foo.title = "The Work2"
-    foo.save  
+    expect(foo).to receive(:update_index).once
+    foo.title = 'The Work2'
+    foo.save
   end
 
-  it "should serialize dates" do
+  it 'should serialize 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 produce a solr document" do
-    @subject = RdfTest.new(title: "War and Peace")
+  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
+  it 'should set and recall values' do
     @subject.title = 'War and Peace'
-    @subject.rdf.should be_changed
-    @subject.based_near = "Moscow, Russia"
-    @subject.related_url = "http://en.wikipedia.org/wiki/War_and_Peace"
-    @subject.part = "this is a part"
+    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
+  it 'should set, persist, and recall values' do
     @subject.title = 'War and Peace'
-    @subject.based_near = "Moscow, Russia"
-    @subject.related_url = "http://en.wikipedia.org/wiki/War_and_Peace"
-    @subject.part = "this is a part"
+    @subject.based_near = 'Moscow, Russia'
+    @subject.related_url = 'http://en.wikipedia.org/wiki/War_and_Peace'
+    @subject.part = 'this is a part'
     @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"]
+  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"
+  it 'should append values' do
+    @subject.part = 'thing 1'
     @subject.save
 
-    @subject.part << "thing 2"
-    @subject.part.should == ["thing 1", "thing 2"]
+    @subject.part << 'thing 2'
+    expect(@subject.part).to eq(['thing 1', 'thing 2'])
   end
 
-  it "should be able to save a blank document" do
-    @subject.title = ""
+  it 'should be able to save a blank document' do
+    @subject.title = ''
     @subject.save
   end
 
-  it "should load n-triples into the graph" do
+  it 'should load n-triples into the graph' do
     ntrip = '<http://oregondigital.org/ns/62> <http://purl.org/dc/terms/type> "Image" .
 <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
+  describe 'using rdf_subject' do
     before do
       # reopening existing class
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
@@ -146,12 +146,12 @@ describe ActiveFedora::NtriplesRDFDatastream do
       @subject.destroy
     end
 
-    it "should write rdf with proper subjects" do
+    it 'should write rdf with proper subjects' do
       @subject.inner_object.pid = 'test:99'
-      @subject.rdf.type = "Frog"
+      @subject.rdf.type = '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.type == ['Frog']
 
     end
@@ -159,49 +159,49 @@ describe ActiveFedora::NtriplesRDFDatastream do
   end
 
 
-  it "should delete values" do
-    @subject.title = "Hamlet"
-    @subject.related_url = "http://psu.edu/"
-    @subject.related_url << "http://projecthydra.org/"
+  it 'should delete values' do
+    @subject.title = 'Hamlet'
+    @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 == ''
+    @subject.title = '' #empty string can be meaningful, don't assume delete.
+    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/"]
-  end
-  it "should delete multiple values at once" do
-    @subject.part = "MacBeth"
-    @subject.part << "Hamlet"
-    @subject.part << "Romeo & Juliet"
-    @subject.part.first.should == "MacBeth"
-    @subject.part.delete("MacBeth", "Romeo & Juliet")
-    @subject.part.should == ["Hamlet"]
-    @subject.part.first.should == "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"]
-  end
-  describe "term proxy methods" do
+    @subject.related_url.delete('http://projecthydra.org/')
+
+    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'
+    expect(@subject.part.first).to eq('MacBeth')
+    @subject.part.delete('MacBeth', 'Romeo & Juliet')
+    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')
+    expect(@subject.part).to eq(['title1', 'title3'])
+  end
+  describe 'term proxy methods' do
     before(:each) do
       class TitleDatastream < ActiveFedora::NtriplesRDFDatastream
         map_predicates { |map| map.title(:in => RDF::DC) }
       end
-      class Foobar < ActiveFedora::Base 
-        has_metadata :name=>'rdf', :type=>TitleDatastream
-        delegate :title, :to=>'rdf', multiple: true
+      class Foobar < ActiveFedora::Base
+        has_metadata :name => 'rdf', :type => TitleDatastream
+        delegate :title, :to => 'rdf', multiple: true
       end
       @subject = Foobar.new
-      @subject.title = ["title1", "title2", "title3"]
+      @subject.title = ['title1', 'title2', 'title3']
     end
 
     after(:each) do
@@ -209,26 +209,26 @@ describe ActiveFedora::NtriplesRDFDatastream do
       Object.send(:remove_const, :TitleDatastream)
     end
 
-    it "should support the count method to determine # of values" do
-      @subject.title.count.should == 3
+    it 'should support the count method to determine # of values' do
+      expect(@subject.title.count).to eq(3)
     end
-    it "should iterate over multiple values" do
-      @subject.title.should respond_to(:each)
+    it 'should iterate over multiple values' do
+      expect(@subject.title).to respond_to(:each)
     end
-    it "should get the first value" do
-      @subject.title.first.should == "title1"
+    it 'should get the first value' do
+      expect(@subject.title.first).to eq('title1')
     end
-    it "should evaluate equality predictably" do
-      @subject.title.should == ["title1", "title2", "title3"]
+    it 'should evaluate equality predictably' do
+      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
-      @subject.title.delete("title1", "title2", "title3")
-      @subject.title.empty?.should be_true
+    it 'should support the empty? method' do
+      expect(@subject.title).to respond_to(:empty?)
+      expect(@subject.title.empty?).to be_falsey
+      @subject.title.delete('title1', 'title2', 'title3')
+      expect(@subject.title.empty?).to be_truthy
     end
-    it "should support the is_a? method" do
-      @subject.title.is_a?(Array).should == true
+    it 'should support the is_a? method' do
+      expect(@subject.title.is_a?(Array)).to eq(true)
     end
   end
 end