active-fedora 6.7.8 → 6.8.0

data/spec/integration/datastream_spec.rb

@@ -1,90 +1,90 @@
 require 'spec_helper'
 
 require 'active_fedora'
-require "rexml/document"
+require 'rexml/document'
 
 describe ActiveFedora::Datastream do
 
   before(:all) do
     class MockAFBase < ActiveFedora::Base
-      has_metadata :name => "descMetadata", :type => ActiveFedora::QualifiedDublinCoreDatastream, :autocreate => true
+      has_metadata :name => 'descMetadata', :type => ActiveFedora::QualifiedDublinCoreDatastream, :autocreate => true
     end
   end
-  
+
   before(:each) do
     @test_object = MockAFBase.new
     @test_object.save
   end
-  
+
   after(:each) do
     @test_object.delete
   end
 
-  it "should be able to access Datastreams using datastreams method" do
-    descMetadata = @test_object.datastreams["descMetadata"]
-    descMetadata.should be_a_kind_of(ActiveFedora::Datastream)
-    descMetadata.dsid.should eql("descMetadata")
+  it 'should be able to access Datastreams using datastreams method' do
+    descMetadata = @test_object.datastreams['descMetadata']
+    expect(descMetadata).to be_a_kind_of(ActiveFedora::Datastream)
+    expect(descMetadata.dsid).to eql('descMetadata')
   end
 
-  it "should be able to access Datastream content using content method" do    
-    descMetadata = @test_object.datastreams["descMetadata"].content
-    descMetadata.should_not be_nil
+  it 'should be able to access Datastream content using content method' do
+    descMetadata = @test_object.datastreams['descMetadata'].content
+    expect(descMetadata).not_to be_nil
   end
-  
-  it "should be able to update XML Datastream content and save to Fedora" do    
-    xml_content = Nokogiri::XML::Document.parse(@test_object.datastreams["descMetadata"].content)
-    title = Nokogiri::XML::Element.new "title", xml_content
-    title.content = "Test Title"
+
+  it 'should be able to update XML Datastream content and save to Fedora' do
+    xml_content = Nokogiri::XML::Document.parse(@test_object.datastreams['descMetadata'].content)
+    title = Nokogiri::XML::Element.new 'title', xml_content
+    title.content = 'Test Title'
     xml_content.root.add_child title
-    
-    @test_object.datastreams["descMetadata"].stub(:before_save)
-    @test_object.datastreams["descMetadata"].content = xml_content.to_s
-    @test_object.datastreams["descMetadata"].save
-    
+
+    allow(@test_object.datastreams['descMetadata']).to receive(:before_save)
+    @test_object.datastreams['descMetadata'].content = xml_content.to_s
+    @test_object.datastreams['descMetadata'].save
+
     found = Nokogiri::XML::Document.parse(@test_object.class.find(@test_object.pid).datastreams['descMetadata'].content)
-    found.xpath('//dc/title/text()').first.inner_text.should == title.content
+    expect(found.xpath('//dc/title/text()').first.inner_text).to eq(title.content)
   end
-  
-  it "should be able to update Blob Datastream content and save to Fedora" do    
+
+  it 'should be able to update Blob Datastream content and save to Fedora' do
     dsid = "ds#{Time.now.to_i}"
     ds = ActiveFedora::Datastream.new(@test_object.inner_object, dsid)
     ds.content = fixture('dino.jpg')
-    @test_object.add_datastream(ds).should be_true
+    expect(@test_object.add_datastream(ds)).to be_truthy
     @test_object.save
-    @test_object.datastreams[dsid].should_not be_changed
-    to = ActiveFedora::Base.find(@test_object.pid) 
-    to.should_not be_nil 
-    to.datastreams[dsid].should_not be_nil
-    to.datastreams[dsid].content.should == fixture('dino.jpg').read
+    expect(@test_object.datastreams[dsid]).not_to be_changed
+    to = ActiveFedora::Base.find(@test_object.pid)
+    expect(to).not_to be_nil
+    expect(to.datastreams[dsid]).not_to be_nil
+    expect(to.datastreams[dsid].content).to eq(fixture('dino.jpg').read)
   end
-  
-  it "should be able to set the versionable attribute" do
+
+  it 'should be able to set the versionable attribute' do
     dsid = "ds#{Time.now.to_i}"
-    v1 = "<version1>data</version1>"
-    v2 = "<version2>data</version2>"
+    v1 = '<version1>data</version1>'
+    v2 = '<version2>data</version2>'
     ds = ActiveFedora::Datastream.new(@test_object.inner_object, dsid)
     ds.content = v1
     ds.versionable = false
-    @test_object.add_datastream(ds).should be_true
+    expect(@test_object.add_datastream(ds)).to be_truthy
     @test_object.save
     to = ActiveFedora::Base.find(@test_object.pid)
     ds = to.datastreams[dsid]
-    ds.versionable.should be_false
+    expect(ds.versionable).to be_falsey
     ds.versionable = true
     to.save
     ds.content = v2
     to.save
     versions = ds.versions
-    versions.length.should == 2
+    expect(versions.length).to eq(2)
     # order of versions not guaranteed
     if versions[0].content == v2
-      versions[1].content.should == v1
-      versions[0].asOfDateTime.should be >= versions[1].asOfDateTime
+      expect(versions[1].content).to eq(v1)
+      expect(versions[0].asOfDateTime).to be >= versions[1].asOfDateTime
     else
-      versions[0].content.should == v1
-      versions[1].content.should == v2   
-      versions[1].asOfDateTime.should be >= versions[0].asOfDateTime
+      expect(versions[0].content).to eq(v1)
+      expect(versions[1].content).to eq(v2)
+      expect(versions[1].asOfDateTime).to be >= versions[0].asOfDateTime
     end
-    ds.content.should == v2
+    expect(ds.content).to eq(v2)
   end
 end

data/spec/integration/datastreams_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 require 'active_fedora'
-require "rexml/document"
+require 'rexml/document'
 
 describe ActiveFedora::Datastreams do
-  describe "serializing datastreams" do
+  describe 'serializing datastreams' do
     before :all do
       class TestingMetadataSerializing < ActiveFedora::Base
-        has_metadata :name => "nokogiri_autocreate_on", :autocreate => true, :type => ActiveFedora::OmDatastream
-        has_metadata :name => "nokogiri_autocreate_off", :autocreate => false, :type => ActiveFedora::OmDatastream
+        has_metadata :name => 'nokogiri_autocreate_on', :autocreate => true, :type => ActiveFedora::OmDatastream
+        has_metadata :name => 'nokogiri_autocreate_off', :autocreate => false, :type => ActiveFedora::OmDatastream
       end
     end
 
@@ -18,115 +18,115 @@ describe ActiveFedora::Datastreams do
 
     subject { TestingMetadataSerializing.new }
 
-    it "should work" do
+    it 'should work' do
       subject.save(:validate => false)
-      subject.nokogiri_autocreate_on.should_not be_new
-      subject.nokogiri_autocreate_off.should be_new
+      expect(subject.nokogiri_autocreate_on).not_to be_new
+      expect(subject.nokogiri_autocreate_off).to be_new
     end
   end
 
 
-  describe "#has_metadata" do
+  describe '#has_metadata' do
     before :all do
       class HasMetadata < ActiveFedora::Base
-        has_metadata :name => "with_versions", :autocreate => true, :label => "Versioned DS", :type => ActiveFedora::SimpleDatastream
-        has_metadata :name => "without_versions", :autocreate => true, :versionable => false, :type => ActiveFedora::SimpleDatastream
+        has_metadata :name => 'with_versions', :autocreate => true, :label => 'Versioned DS', :type => ActiveFedora::SimpleDatastream
+        has_metadata :name => 'without_versions', :autocreate => true, :versionable => false, :type => ActiveFedora::SimpleDatastream
       end
     end
     after :all do
       Object.send(:remove_const, :HasMetadata)
     end
     before :each do
-      @base = ActiveFedora::Base.new(:pid=>"test:has_metadata_base")
-      @base.add_datastream(@base.create_datastream(ActiveFedora::Datastream, "testDS", :dsLabel => "Test DS"))
-      @base.datastreams["testDS"].content = "blah blah blah"
+      @base = ActiveFedora::Base.new(:pid => 'test:has_metadata_base')
+      @base.add_datastream(@base.create_datastream(ActiveFedora::Datastream, 'testDS', :dsLabel => 'Test DS'))
+      @base.datastreams['testDS'].content = 'blah blah blah'
       @base.save
-      @test = HasMetadata.new(:pid=>"test:has_metadata_model")
+      @test = HasMetadata.new(:pid => 'test:has_metadata_model')
       @test.save
     end
-    
+
     after :each do
       @base.delete
       @test.delete
     end
-    
-    it "should create datastreams from the spec on new objects" do
-      @test.without_versions.versionable.should be_false
-      @test.with_versions.versionable.should be_true
-      @test.with_versions.dsLabel.should == "Versioned DS"
-      @test.without_versions.content= "blah blah blah"
+
+    it 'should create datastreams from the spec on new objects' do
+      expect(@test.without_versions.versionable).to be_falsey
+      expect(@test.with_versions.versionable).to be_truthy
+      expect(@test.with_versions.dsLabel).to eq('Versioned DS')
+      @test.without_versions.content = 'blah blah blah'
       @test.save
-      HasMetadata.find(@test.pid).without_versions.versionable.should be_false
+      expect(HasMetadata.find(@test.pid).without_versions.versionable).to be_falsey
     end
-    
-    it "should use ds_specs and preserve existing datastreams on migrated objects" do
+
+    it 'should use ds_specs and preserve existing datastreams on migrated objects' do
       test_obj = HasMetadata.find(@base.pid)
-      test_obj.datastreams["testDS"].dsLabel.should == "Test DS"
-      test_obj.datastreams["testDS"].new?.should be_false
-      test_obj.with_versions.dsLabel.should == "Versioned DS"
-      test_obj.without_versions.versionable.should be_false
-      test_obj.with_versions.new?.should be_true
+      expect(test_obj.datastreams['testDS'].dsLabel).to eq('Test DS')
+      expect(test_obj.datastreams['testDS'].new?).to be_falsey
+      expect(test_obj.with_versions.dsLabel).to eq('Versioned DS')
+      expect(test_obj.without_versions.versionable).to be_falsey
+      expect(test_obj.with_versions.new?).to be_truthy
     end
-    
+
   end
-  
-  describe "#has_file_datastream" do
+
+  describe '#has_file_datastream' do
     before :all do
       class HasFile < ActiveFedora::Base
-        has_file_datastream :name => "file_ds", :versionable => false
-        has_file_datastream :name => "file_ds2", :versionable => false, :autocreate => false
+        has_file_datastream :name => 'file_ds', :versionable => false
+        has_file_datastream :name => 'file_ds2', :versionable => false, :autocreate => false
       end
     end
     after :all do
       Object.send(:remove_const, :HasFile)
     end
     before :each do
-      @base = ActiveFedora::Base.new(:pid=>"test:ds_versionable_base")
+      @base = ActiveFedora::Base.new(:pid => 'test:ds_versionable_base')
       @base.save
-      @base2 = ActiveFedora::Base.new(:pid=>"test:ds_versionable_base2")
-      @base2.add_datastream(@base2.create_datastream(ActiveFedora::Datastream,"file_ds", :versionable=>true,:dsLabel=>"Pre-existing DS"))
-      @base2.datastreams["file_ds"].content = "blah blah blah"
+      @base2 = ActiveFedora::Base.new(:pid => 'test:ds_versionable_base2')
+      @base2.add_datastream(@base2.create_datastream(ActiveFedora::Datastream, 'file_ds', :versionable => true, :dsLabel => 'Pre-existing DS'))
+      @base2.datastreams['file_ds'].content = 'blah blah blah'
       @base2.save
-      @has_file = HasFile.new(:pid=>"test:ds_versionable_has_file")
+      @has_file = HasFile.new(:pid => 'test:ds_versionable_has_file')
       @has_file.save
     end
-    
+
     after :each do
       @base.delete
       @base2.delete
       @has_file.delete
     end
-    
-    it "should create datastreams from the spec on new objects" do
-      @has_file.file_ds.versionable.should be_false
-      @has_file.file_ds.content = "blah blah blah"
-      @has_file.file_ds.changed?.should be_true
-      @has_file.file_ds2.changed?.should be_false # no autocreate
-      @has_file.file_ds2.new?.should be_true
+
+    it 'should create datastreams from the spec on new objects' do
+      expect(@has_file.file_ds.versionable).to be_falsey
+      @has_file.file_ds.content = 'blah blah blah'
+      expect(@has_file.file_ds.changed?).to be_truthy
+      expect(@has_file.file_ds2.changed?).to be_falsey # no autocreate
+      expect(@has_file.file_ds2.new?).to be_truthy
       @has_file.save
-      @has_file.file_ds.versionable.should be_false
+      expect(@has_file.file_ds.versionable).to be_falsey
       test_obj = HasFile.find(@has_file.pid)
-      test_obj.file_ds.versionable.should be_false
-      test_obj.rels_ext.changed?.should be_false
-      test_obj.file_ds.changed?.should be_false
-      test_obj.file_ds2.changed?.should be_false
-      test_obj.file_ds2.new?.should be_true
+      expect(test_obj.file_ds.versionable).to be_falsey
+      expect(test_obj.rels_ext.changed?).to be_falsey
+      expect(test_obj.file_ds.changed?).to be_falsey
+      expect(test_obj.file_ds2.changed?).to be_falsey
+      expect(test_obj.file_ds2.new?).to be_truthy
     end
-    
-    it "should use ds_specs on migrated objects" do
+
+    it 'should use ds_specs on migrated objects' do
       test_obj = HasFile.find(@base.pid)
-      test_obj.file_ds.versionable.should be_false
-      test_obj.file_ds.new?.should be_true
-      test_obj.file_ds.content = "blah blah blah"
+      expect(test_obj.file_ds.versionable).to be_falsey
+      expect(test_obj.file_ds.new?).to be_truthy
+      test_obj.file_ds.content = 'blah blah blah'
       test_obj.save
-      test_obj.file_ds.versionable.should be_false
+      expect(test_obj.file_ds.versionable).to be_falsey
       # look it up again to check datastream profile
       test_obj = HasFile.find(@base.pid)
-      test_obj.file_ds.versionable.should be_false
-      test_obj.file_ds.dsLabel.should == "File Datastream"
+      expect(test_obj.file_ds.versionable).to be_falsey
+      expect(test_obj.file_ds.dsLabel).to eq('File Datastream')
       test_obj = HasFile.find(@base2.pid)
-      test_obj.file_ds.versionable.should be_true
-      test_obj.file_ds.dsLabel.should == "Pre-existing DS"
+      expect(test_obj.file_ds.versionable).to be_truthy
+      expect(test_obj.file_ds.dsLabel).to eq('Pre-existing DS')
     end
   end
 end

data/spec/integration/delegating_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe "delegating properties" do
-  describe "that have a reader and writer" do
+describe 'delegating properties' do
+  describe 'that have a reader and writer' do
     before :all do
       class TitledObject < ActiveFedora::Base
         has_metadata 'foo', type: ActiveFedora::SimpleDatastream do |m|
-          m.field "title", :string
+          m.field 'title', :string
         end
         delegate :title, to: 'foo', multiple: false
       end
@@ -14,25 +14,25 @@ describe "delegating properties" do
       Object.send(:remove_const, :TitledObject)
     end
 
-    describe "save" do
+    describe 'save' do
       subject do
-        obj = TitledObject.create 
-        obj.title = "Hydra for Dummies"
+        obj = TitledObject.create
+        obj.title = 'Hydra for Dummies'
         obj.save
         obj
       end
-      it "should keep a list of changes after a successful save" do
-        subject.previous_changes.should_not be_empty
-        subject.previous_changes.keys.should include("title")
+      it 'should keep a list of changes after a successful save' do
+        expect(subject.previous_changes).not_to be_empty
+        expect(subject.previous_changes.keys).to include('title')
       end
-      it "should clean out changes" do
-        subject.title_changed?.should be_false
-        subject.changes.should be_empty
+      it 'should clean out changes' do
+        expect(subject.title_changed?).to be_falsey
+        expect(subject.changes).to be_empty
       end
     end
   end
 
-  describe "that only have a writer" do
+  describe 'that only have a writer' do
     before :all do
       class TestDatastream < ActiveFedora::NtriplesRDFDatastream
         # accepts_nested_attributes_for :title, would generate a method like this:
@@ -51,7 +51,7 @@ describe "delegating properties" do
 
     subject { TitledObject.new }
 
-    it "Should delegate the method" do
+    it 'Should delegate the method' do
       subject.title_attributes = {'0' => {'title' => 'Hello'}}
     end
 

data/spec/integration/delete_all_spec.rb

@@ -1,60 +1,56 @@
 require 'spec_helper'
 
-describe ActiveFedora::Base do
-  
-  before(:all) do
-    module SpecModel
-      class Basic < ActiveFedora::Base
-        class_attribute :callback_counter
-        
-        before_destroy :inc_counter
-
-        def inc_counter
-          self.class.callback_counter += 1
-        end
-      end
+module SpecModelD
+  class Basic < ActiveFedora::Base
+    class_attribute :callback_counter
+    before_destroy :inc_counter
+
+    def inc_counter
+      self.class.callback_counter += 1
     end
   end
-  
-  after(:all) do
-    Object.send(:remove_const, :SpecModel)
-  end
+end
+
+describe ActiveFedora::Base do
 
-  let!(:model1) { SpecModel::Basic.create! }
-  let!(:model2) { SpecModel::Basic.create! }
+  let!(:model1) { SpecModelD::Basic.create! }
+  let!(:model2) { SpecModelD::Basic.create! }
 
-  before do
-    SpecModel::Basic.callback_counter = 0
+  before :each do
+    SpecModelD::Basic.callback_counter = 0
   end
 
-
-  describe ".destroy_all" do
-    it "should remove both and run callbacks" do 
-      SpecModel::Basic.destroy_all
-      SpecModel::Basic.count.should == 0 
-      SpecModel::Basic.callback_counter.should == 2
+  describe '.destroy_all' do
+    it 'should remove both and run callbacks' do
+      model1
+      model2
+      expect(SpecModelD::Basic.count).to eq(2)
+      expect(SpecModelD::Basic.callback_counter).to eq(0)
+      SpecModelD::Basic.destroy_all
+      expect(SpecModelD::Basic.count).to eq(0)
+      expect(SpecModelD::Basic.callback_counter).to eq(2)
     end
 
-    describe "when a model is missing" do
-      let(:model3) { SpecModel::Basic.create! }
+    describe 'when a model is missing' do
+      let(:model3) { SpecModelD::Basic.create! }
       after { model3.delete }
-      it "should be able to skip a missing model" do 
-        model1.should_receive(:destroy).and_call_original
-        model2.should_receive(:destroy).and_call_original
-        model3.should_receive(:destroy).and_raise(ActiveFedora::ObjectNotFoundError)
-        ActiveFedora::Relation.any_instance.should_receive(:to_a).and_return([model1, model3, model2])
-        ActiveFedora::Relation.logger.should_receive(:error).with("When trying to destroy #{model3.pid}, encountered an ObjectNotFoundError. Solr may be out of sync with Fedora")
-        SpecModel::Basic.destroy_all
-        SpecModel::Basic.count.should == 1 
+      it 'should be able to skip a missing model' do
+        expect(model1).to receive(:destroy).and_call_original
+        expect(model2).to receive(:destroy).and_call_original
+        expect(model3).to receive(:destroy).and_raise(ActiveFedora::ObjectNotFoundError)
+        expect_any_instance_of(ActiveFedora::Relation).to receive(:to_a).and_return([model1, model3, model2])
+        expect(ActiveFedora::Relation.logger).to receive(:error).with("When trying to destroy #{model3.pid}, encountered an ObjectNotFoundError. Solr may be out of sync with Fedora")
+        SpecModelD::Basic.destroy_all
+        expect(SpecModelD::Basic.count).to eq(1)
       end
     end
   end
 
-  describe ".delete_all" do
-    it "should remove both and not run callbacks" do 
-      SpecModel::Basic.delete_all
-      SpecModel::Basic.count.should == 0
-      SpecModel::Basic.callback_counter.should == 0
+  describe '.delete_all' do
+    it 'should remove both and not run callbacks' do
+      SpecModelD::Basic.delete_all
+      expect(SpecModelD::Basic.count).to eq(0)
+      expect(SpecModelD::Basic.callback_counter).to eq(0)
     end
   end
 end