active-fedora 6.8.0 → 7.0.0.pre1

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
-    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)
+    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)
   end
 
   it 'should not match when association is different' do
-    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 (
+    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 (
       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
-    expect {
-      expect(subject).to belong_to_associated_active_fedora_object(association)
-    }.to(
+    lambda {
+      subject.should belong_to_associated_active_fedora_object(association)
+    }.should(
       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
-    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])
+    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])
   end
 
   it 'should not match when association is different' do
-    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 (
+    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 (
       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
-    expect {
-      expect(subject).to have_many_associated_active_fedora_objects(association)
-    }.to(
+    lambda {
+      subject.should have_many_associated_active_fedora_objects(association)
+    }.should(
       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
-    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])
+    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])
   end
 
   it 'should not match when relationship is different' do
-    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 (
+    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 (
       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
-    expect {
-      expect(subject).to have_predicate(predicate)
-    }.to(
+    lambda {
+      subject.should have_predicate(predicate)
+    }.should(
       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)
-    expect(subject).to match_fedora_datastream(datastream_name).with(expected_xml)
+    subject.should 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)
-    expect {
-      expect(subject).to match_fedora_datastream(datastream_name).with(expected_xml)
-    }.to(
+    lambda {
+      subject.should match_fedora_datastream(datastream_name).with(expected_xml)
+    }.should(
       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)
-    expect {
-      expect(subject).to match_fedora_datastream(datastream_name)
-    }.to(
+    lambda {
+      subject.should match_fedora_datastream(datastream_name)
+    }.should(
       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
-      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
+    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
     end
   end
 end

data/spec/unit/semantic_node_spec.rb

@@ -1,42 +1,19 @@
 require 'spec_helper'
 
-require 'xmlsimple'
-
 @@last_pid = 0
-
-class SpecNode2
-  include ActiveFedora::SemanticNode
-
-  attr_accessor :pid
-  def internal_uri
-    'info:fedora/' + pid.to_s
-  end
-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 = {})
-          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
@@ -45,126 +22,90 @@ describe ActiveFedora::SemanticNode do
       end
 
       @node = SpecNode.new
-      allow(@node).to receive(:rels_ext).and_return(double('rels_ext', :content_will_change! => true, :content => ''))
+      @node.stub(: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
-      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
-      @test_object.delete
-      rescue
-      end
-      begin
-      @test_object2.delete
-      rescue
-      end
-      begin
-      @test_object3.delete
-      rescue
-      end
-      begin
-      @test_object4.delete
-      rescue
-      end
-      begin
-      @test_object5.delete
-      rescue
-      end
     end
 
-
-    it 'should provide .internal_uri' do
-      expect(@node).to  respond_to(:internal_uri)
+    describe "pid_from_uri" do
+      it "should strip the info:fedora/ out of a given string" do 
+        SpecNode.pid_from_uri("info:fedora/FOO:BAR").should == "FOO:BAR"
+      end
     end
-
-
-    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'])
+    
+    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']
       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)
-        expect(@node.relationships.statements.to_a.first.object.to_s).to eq('info:fedora/')
+        @node.relationships.statements.to_a.first.object.to_s.should == 'info:fedora/' 
         @n1.save
-        expect(@node.relationships.statements.to_a.first.object.to_s).to eq(@n1.internal_uri)
+        @node.relationships.statements.to_a.first.object.to_s.should == @n1.internal_uri
       end
 
-      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'])
+      it "should add a literal relationship to the relationships graph" do
+        @node.add_relationship("isMemberOf", 'demo:9', true)
+        @node.relationships("isMemberOf").should == ['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
-        allow(local_test_node1).to receive(:rels_ext).and_return(double('rels_ext', :content_will_change! => true, :content => ''))
+        local_test_node1.stub(:rels_ext).and_return(double("rels_ext", :content_will_change! => true, :content=>''))
         local_test_node1.add_relationship(:is_member_of, 'demo:10')
-        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([])
+        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 == []
       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)
-        expect(@node.relationships(:is_member_of)).to eq([])
-        expect(@node.relationships(:has_description)).to eq(['demo:9'])
+        @node.relationships(:is_member_of).should == []
+        @node.relationships(:has_description).should == ['demo:9']
       end
-
-    end
-
-
-    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
-        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')
+        @node.stub(:rels_ext).and_return(double("rels_ext", :content_will_change! => true, :content=>''))
+        @node.add_relationship(:has_part, "info:fedora/3")
+        @node.add_relationship(:has_part, "info:fedora/4")
         #check both are there
-        expect(@test_object.ids_for_outbound(:has_part)).to include '3', '4'
-        @test_object.remove_relationship(:has_part, 'info:fedora/3')
+        @node.ids_for_outbound(:has_part).should include "3", "4"
+        @node.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')
+        @node.remove_relationship(:has_member,"info:fedora/4")
         #check only one item removed
-        expect(@test_object.ids_for_outbound(:has_part)).to eq(['4'])
-        @test_object.remove_relationship(:has_part, 'info:fedora/4')
+        @node.ids_for_outbound(:has_part).should == ['4']
+        @node.remove_relationship(:has_part,"info:fedora/4")
         #check last item removed and predicate removed since now emtpy
-        expect(@test_object.ids_for_outbound(:has_part)).to eq([])
-
-        expect(@test_object.relationships_are_dirty).to eq(true)
+        @node.ids_for_outbound(:has_part).should == []
 
+        @node.relationships_are_dirty.should == true
+        
       end
     end
 
     describe '#assert_kind_of' do
       it 'should raise an exception if object supplied is not the correct type' do
-        had_exception = false
-        begin
-          @test_object.assert_kind_of 'SpecNode2', @test_object, ActiveFedora::Base
-        rescue
-          had_exception = true
-        end
-        raise 'Failed to throw exception with kind of mismatch' unless had_exception
+        expect {@node.assert_kind_of 'SpecNode', @node, ActiveFedora::Base}.to raise_error
         #now should not throw any exception
-        @test_object.assert_kind_of 'SpecNode2', @test_object, SpecNode2
+        @node.assert_kind_of 'SpecNode', @node, SpecNode
       end
     end
   end