active-fedora 6.7.8 → 6.8.0

data/spec/unit/rspec_matchers/belong_to_associated_active_fedora_object_matcher_spec.rb

@@ -1,8 +1,8 @@
-require "spec_helper"
+require 'spec_helper'
 require 'ostruct'
-require "active_fedora/rspec_matchers/belong_to_associated_active_fedora_object_matcher"
+require 'active_fedora/rspec_matchers/belong_to_associated_active_fedora_object_matcher'
 
-describe RSpec::Matchers, "belong_to_associated_active_fedora_object_matcher" do
+describe RSpec::Matchers, 'belong_to_associated_active_fedora_object_matcher' do
   subject { OpenStruct.new(:pid => pid )}
   let(:pid) { 123 }
   let(:object1) { Object.new }
@@ -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,12 +29,12 @@ 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>)"
+        'subject.should belong_to_associated_active_fedora_object(<association_name>).with_object(<object>)'
       )
     )
   end

data/spec/unit/rspec_matchers/have_many_associated_active_fedora_objects_matcher_spec.rb

@@ -1,8 +1,8 @@
-require "spec_helper"
+require 'spec_helper'
 require 'ostruct'
-require "active_fedora/rspec_matchers/have_many_associated_active_fedora_objects_matcher"
+require 'active_fedora/rspec_matchers/have_many_associated_active_fedora_objects_matcher'
 
-describe RSpec::Matchers, "have_many_associated_active_fedora_objects_matcher" do
+describe RSpec::Matchers, 'have_many_associated_active_fedora_objects_matcher' do
   subject { OpenStruct.new(:pid => pid )}
   let(:pid) { 123 }
   let(:object1) { Object.new }
@@ -11,17 +11,17 @@ describe RSpec::Matchers, "have_many_associated_active_fedora_objects_matcher" d
   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,object2])
-    subject.should have_many_associated_active_fedora_objects(association).with_objects([object1, object2])
+    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject).to receive(association).and_return([object1, object2])
+    expect(subject).to have_many_associated_active_fedora_objects(association).with_objects([object1, object2])
   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,object3])
-    lambda {
-      subject.should have_many_associated_active_fedora_objects(association).with_objects([object1, object2])
-    }.should (
+    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject).to receive(association).and_return([object1, object3])
+    expect {
+      expect(subject).to have_many_associated_active_fedora_objects(association).with_objects([object1, object2])
+    }.to (
       raise_error(
         RSpec::Expectations::ExpectationNotMetError,
         /expected #{subject.class} PID=#{pid} association: #{association.inspect}/
@@ -30,12 +30,12 @@ describe RSpec::Matchers, "have_many_associated_active_fedora_objects_matcher" d
   end
 
   it 'should require :with_objects option' do
-    lambda {
-      subject.should have_many_associated_active_fedora_objects(association)
-    }.should(
+    expect {
+      expect(subject).to have_many_associated_active_fedora_objects(association)
+    }.to(
       raise_error(
         ArgumentError,
-        "subject.should have_many_associated_active_fedora_objects(<association_name>).with_objects(<objects[]>)"
+        'subject.should have_many_associated_active_fedora_objects(<association_name>).with_objects(<objects[]>)'
       )
     )
   end

data/spec/unit/rspec_matchers/have_predicate_matcher_spec.rb

@@ -1,8 +1,8 @@
-require "spec_helper"
+require 'spec_helper'
 require 'ostruct'
-require "active_fedora/rspec_matchers/have_predicate_matcher"
+require 'active_fedora/rspec_matchers/have_predicate_matcher'
 
-describe RSpec::Matchers, "have_predicate_matcher" do
+describe RSpec::Matchers, 'have_predicate_matcher' do
   subject { OpenStruct.new(:pid => pid )}
   let(:pid) { 123 }
   let(:object1) { Object.new }
@@ -11,17 +11,17 @@ describe RSpec::Matchers, "have_predicate_matcher" do
   let(:predicate) { :predicate }
 
   it 'should match when relationship is "what we have in Fedora"' do
-    subject.class.should_receive(:find).with(pid).and_return(subject)
-    subject.should_receive(:relationships).with(predicate).and_return([object1,object2])
-    subject.should have_predicate(predicate).with_objects([object1, object2])
+    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject).to receive(:relationships).with(predicate).and_return([object1, object2])
+    expect(subject).to have_predicate(predicate).with_objects([object1, object2])
   end
 
   it 'should not match when relationship is different' do
-    subject.class.should_receive(:find).with(pid).and_return(subject)
-    subject.should_receive(:relationships).with(predicate).and_return([object1,object3])
-    lambda {
-      subject.should have_predicate(predicate).with_objects([object1, object2])
-    }.should (
+    expect(subject.class).to receive(:find).with(pid).and_return(subject)
+    expect(subject).to receive(:relationships).with(predicate).and_return([object1, object3])
+    expect {
+      expect(subject).to have_predicate(predicate).with_objects([object1, object2])
+    }.to (
       raise_error(
         RSpec::Expectations::ExpectationNotMetError,
         /expected #{subject.class} PID=#{pid} relationship: #{predicate.inspect}/
@@ -30,12 +30,12 @@ describe RSpec::Matchers, "have_predicate_matcher" do
   end
 
   it 'should require :with_objects option' do
-    lambda {
-      subject.should have_predicate(predicate)
-    }.should(
+    expect {
+      expect(subject).to have_predicate(predicate)
+    }.to(
       raise_error(
         ArgumentError,
-        "subject.should have_predicate(<predicate>).with_objects(<objects[]>)"
+        'subject.should have_predicate(<predicate>).with_objects(<objects[]>)'
       )
     )
   end

data/spec/unit/rspec_matchers/match_fedora_datastream_matcher_spec.rb

@@ -1,28 +1,28 @@
-require "spec_helper"
+require 'spec_helper'
 require 'ostruct'
 require 'webmock/rspec'
 WebMock.allow_net_connect!
-require "active_fedora/rspec_matchers/match_fedora_datastream_matcher"
+require 'active_fedora/rspec_matchers/match_fedora_datastream_matcher'
 
-describe RSpec::Matchers, "match_fedora_datastream" do
+describe RSpec::Matchers, 'match_fedora_datastream' do
   let(:pid) { 123 }
   let(:expected_xml) { '<xml><node>Value</node></xml>' }
   let(:datastream_name) { 'metadata' }
   let(:datastream_url) {
-    File.join(ActiveFedora.config.credentials[:url], 'objects', pid.to_s,'datastreams', datastream_name, 'content')
+    File.join(ActiveFedora.config.credentials[:url], 'objects', pid.to_s, 'datastreams', datastream_name, 'content')
   }
   subject { OpenStruct.new(:pid => pid )}
 
   it 'should match based on request' do
     stub_request(:get, datastream_url).to_return(:body => expected_xml, :status => 200)
-    subject.should match_fedora_datastream(datastream_name).with(expected_xml)
+    expect(subject).to match_fedora_datastream(datastream_name).with(expected_xml)
   end
 
   it 'should handle non-matching requests' do
     stub_request(:get, datastream_url).to_return(:body => "<parent>#{expected_xml}</parent>", :status => 200)
-    lambda {
-      subject.should match_fedora_datastream(datastream_name).with(expected_xml)
-    }.should(
+    expect {
+      expect(subject).to match_fedora_datastream(datastream_name).with(expected_xml)
+    }.to(
       raise_error(
         RSpec::Expectations::ExpectationNotMetError,
         /expected #{subject.class} PID=#{pid} datastream: #{datastream_name.inspect} to match Fedora/
@@ -32,12 +32,12 @@ describe RSpec::Matchers, "match_fedora_datastream" do
 
   it 'should require :with option' do
     stub_request(:get, datastream_url).to_return(:body => "<parent>#{expected_xml}</parent>", :status => 200)
-    lambda {
-      subject.should match_fedora_datastream(datastream_name)
-    }.should(
+    expect {
+      expect(subject).to match_fedora_datastream(datastream_name)
+    }.to(
       raise_error(
         ArgumentError,
-        "match_fedora_datastream(<datastream_name>).with(<expected_xml>)"
+        'match_fedora_datastream(<datastream_name>).with(<expected_xml>)'
       )
     )
   end

data/spec/unit/rubydora_connection_spec.rb

@@ -3,11 +3,11 @@ require 'active_fedora/rubydora_connection'
 
 describe ActiveFedora::RubydoraConnection do
   describe 'initialize' do
-    it "should pass through valid options" do
-      @instance = ActiveFedora::RubydoraConnection.new :timeout => 3600, :fake_option => :missing, :force => true, :validateChecksum=>true
-      @instance.connection.client.options[:timeout].should == 3600
-      @instance.connection.config[:validateChecksum].should == true
-      @instance.connection.client.options.has_key?(:fake_option).should be_false
+    it 'should pass through valid options' do
+      @instance = ActiveFedora::RubydoraConnection.new :timeout => 3600, :fake_option => :missing, :force => true, :validateChecksum => true
+      expect(@instance.connection.client.options[:timeout]).to eq(3600)
+      expect(@instance.connection.config[:validateChecksum]).to eq(true)
+      expect(@instance.connection.client.options.has_key?(:fake_option)).to be_falsey
     end
   end
 end

data/spec/unit/semantic_node_spec.rb

@@ -6,7 +6,7 @@ require 'xmlsimple'
 
 class SpecNode2
   include ActiveFedora::SemanticNode
-  
+
   attr_accessor :pid
   def internal_uri
     'info:fedora/' + pid.to_s
@@ -15,43 +15,43 @@ end
 
 describe ActiveFedora::SemanticNode do
 
-  
-  describe "with a bunch of objects" do
+
+  describe 'with a bunch of objects' do
     def increment_pid
-      @@last_pid += 1    
+      @@last_pid += 1
     end
-    
+
     before(:each) do
       class SpecNode
         include ActiveFedora::SemanticNode
-        
+
         attr_accessor :pid
-        def initialize (params={}) 
+        def initialize(params = {})
           self.pid = params[:pid]
         end
         def internal_uri
           'info:fedora/' + pid.to_s
         end
       end
-    
+
       class AudioRecord
         attr_accessor :pid
-        def initialize (params={}) 
+        def initialize(params = {})
           self.pid = params[:pid]
         end
         def internal_uri
           'info:fedora/' + pid.to_s
         end
       end
-      
+
       @node = SpecNode.new
-      @node.stub(:rels_ext).and_return(double("rels_ext", :content_will_change! => true, :content=>''))
+      allow(@node).to receive(:rels_ext).and_return(double('rels_ext', :content_will_change! => true, :content => ''))
       @node.pid = increment_pid
       @test_object = SpecNode2.new
-      @test_object.pid = increment_pid    
-      @test_object.stub(:rels_ext).and_return(double("rels_ext", :content_will_change! => true, :content=>''))
+      @test_object.pid = increment_pid
+      allow(@test_object).to receive(:rels_ext).and_return(double('rels_ext', :content_will_change! => true, :content => ''))
     end
-    
+
     after(:each) do
       Object.send(:remove_const, :SpecNode)
       begin
@@ -75,82 +75,82 @@ describe ActiveFedora::SemanticNode do
       rescue
       end
     end
-   
+
 
     it 'should provide .internal_uri' do
-      @node.should  respond_to(:internal_uri)
+      expect(@node).to  respond_to(:internal_uri)
     end
-    
-    
-    describe ".add_relationship" do
-      it "should add relationship to the relationships graph" do
-        @node.add_relationship("isMemberOf", 'demo:9')
-        @node.ids_for_outbound("isMemberOf").should == ['demo:9']
+
+
+    describe '.add_relationship' do
+      it 'should add relationship to the relationships graph' do
+        @node.add_relationship('isMemberOf', 'demo:9')
+        expect(@node.ids_for_outbound('isMemberOf')).to eq(['demo:9'])
       end
-      it "should not be written into the graph until it is saved" do
+      it 'should not be written into the graph until it is saved' do
         @n1 = ActiveFedora::Base.new
         @node.add_relationship(:has_part, @n1)
-        @node.relationships.statements.to_a.first.object.to_s.should == 'info:fedora/' 
+        expect(@node.relationships.statements.to_a.first.object.to_s).to eq('info:fedora/')
         @n1.save
-        @node.relationships.statements.to_a.first.object.to_s.should == @n1.internal_uri
+        expect(@node.relationships.statements.to_a.first.object.to_s).to eq(@n1.internal_uri)
       end
 
-      it "should add a literal relationship to the relationships graph" do
-        @node.add_relationship("isMemberOf", 'demo:9', true)
-        @node.relationships("isMemberOf").should == ['demo:9']
+      it 'should add a literal relationship to the relationships graph' do
+        @node.add_relationship('isMemberOf', 'demo:9', true)
+        expect(@node.relationships('isMemberOf')).to eq(['demo:9'])
       end
-      
-      it "adding relationship to an instance should not affect class-level relationships hash" do 
+
+      it 'adding relationship to an instance should not affect class-level relationships hash' do
         local_test_node1 = SpecNode.new
         local_test_node2 = SpecNode.new
-        local_test_node1.stub(:rels_ext).and_return(double("rels_ext", :content_will_change! => true, :content=>''))
+        allow(local_test_node1).to receive(:rels_ext).and_return(double('rels_ext', :content_will_change! => true, :content => ''))
         local_test_node1.add_relationship(:is_member_of, 'demo:10')
-        local_test_node2.stub(:rels_ext).and_return(double('rels-ext', :content=>''))
-        
-        local_test_node1.relationships(:is_member_of).should == ["demo:10"]
-        local_test_node2.relationships(:is_member_of).should == []
+        allow(local_test_node2).to receive(:rels_ext).and_return(double('rels-ext', :content => ''))
+
+        expect(local_test_node1.relationships(:is_member_of)).to eq(['demo:10'])
+        expect(local_test_node2.relationships(:is_member_of)).to eq([])
       end
-      
+
     end
 
-    describe ".clear_relationship" do
+    describe '.clear_relationship' do
       before do
         @node.add_relationship(:is_member_of, 'demo:9')
         @node.add_relationship(:is_member_of, 'demo:7')
         @node.add_relationship(:has_description, 'demo:9')
       end
-      it "should clear the specified relationship" do
+      it 'should clear the specified relationship' do
         @node.clear_relationship(:is_member_of)
-        @node.relationships(:is_member_of).should == []
-        @node.relationships(:has_description).should == ['demo:9']
+        expect(@node.relationships(:is_member_of)).to eq([])
+        expect(@node.relationships(:has_description)).to eq(['demo:9'])
       end
-      
+
     end
-    
-    
-    it "should provide .outbound_relationships" do 
-      @node.should respond_to(:outbound_relationships)
+
+
+    it 'should provide .outbound_relationships' do
+      expect(@node).to respond_to(:outbound_relationships)
     end
-    
-      
+
+
     describe '#remove_relationship' do
       it 'should remove a relationship from the relationships hash' do
-        @test_object.stub(:rels_ext).and_return(double("rels_ext", :content_will_change! => true, :content=>''))
-        @test_object.add_relationship(:has_part, "info:fedora/3")
-        @test_object.add_relationship(:has_part, "info:fedora/4")
+        allow(@test_object).to receive(:rels_ext).and_return(double('rels_ext', :content_will_change! => true, :content => ''))
+        @test_object.add_relationship(:has_part, 'info:fedora/3')
+        @test_object.add_relationship(:has_part, 'info:fedora/4')
         #check both are there
-        @test_object.ids_for_outbound(:has_part).should include "3", "4"
-        @test_object.remove_relationship(:has_part, "info:fedora/3")
+        expect(@test_object.ids_for_outbound(:has_part)).to include '3', '4'
+        @test_object.remove_relationship(:has_part, 'info:fedora/3')
         #check returns false if relationship does not exist and does nothing with different predicate
-        @test_object.remove_relationship(:has_member,"info:fedora/4")
+        @test_object.remove_relationship(:has_member, 'info:fedora/4')
         #check only one item removed
-        @test_object.ids_for_outbound(:has_part).should == ['4']
-        @test_object.remove_relationship(:has_part,"info:fedora/4")
+        expect(@test_object.ids_for_outbound(:has_part)).to eq(['4'])
+        @test_object.remove_relationship(:has_part, 'info:fedora/4')
         #check last item removed and predicate removed since now emtpy
-        @test_object.ids_for_outbound(:has_part).should == []
+        expect(@test_object.ids_for_outbound(:has_part)).to eq([])
+
+        expect(@test_object.relationships_are_dirty).to eq(true)
 
-        @test_object.relationships_are_dirty.should == true
-        
       end
     end
 
@@ -162,7 +162,7 @@ describe ActiveFedora::SemanticNode do
         rescue
           had_exception = true
         end
-        raise "Failed to throw exception with kind of mismatch" unless had_exception
+        raise 'Failed to throw exception with kind of mismatch' unless had_exception
         #now should not throw any exception
         @test_object.assert_kind_of 'SpecNode2', @test_object, SpecNode2
       end

data/spec/unit/serializers_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe ActiveFedora::Attributes::Serializers do
   subject { ActiveFedora::Base }
-  describe "deserialize_dates_from_form" do
+  describe 'deserialize_dates_from_form' do
     before do
       class Foo < ActiveFedora::Base
         attr_accessor :birthday
@@ -12,9 +12,9 @@ describe ActiveFedora::Attributes::Serializers do
       Object.send(:remove_const, :Foo)
     end
     subject { Foo.new }
-    it "should deserialize dates" do
-      subject.attributes = {'birthday(1i)' =>'2012', 'birthday(2i)' =>'10', 'birthday(3i)' => '31'}
-      subject.birthday.should == '2012-10-31'
+    it 'should deserialize dates' do
+      subject.attributes = {'birthday(1i)' => '2012', 'birthday(2i)' => '10', 'birthday(3i)' => '31'}
+      expect(subject.birthday).to eq('2012-10-31')
     end
   end