rubydora 1.8.1 → 1.9.0

data/spec/lib/integration_test_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 
-
 # These tests require a fedora repository with the resource index enabled (and with syncUpdates = true)
 describe "Integration testing against a live Fedora repository", :integration => true do
   REPOSITORY_CONFIG = { :url => "http://localhost:#{ENV['TEST_JETTY_PORT'] || 8983}/fedora", :user => 'fedoraAdmin', :password => 'fedoraAdmin' }
@@ -81,54 +80,54 @@ describe "Integration testing against a live Fedora repository", :integration =>
 
   describe "datastream stuff" do
 
-  it "should create a managed datastream" do
-    obj = @repository.find_or_initialize('test:1')
-    obj.save
-    ds = obj.datastreams["Test"]
+    it "should create a managed datastream" do
+      obj = @repository.find_or_initialize('test:1')
+      obj.save
+      ds = obj.datastreams["Test"]
 
-    ds.content = open(__FILE__).read
-    ds.mimeType = 'text/plain'
-    ds.save
-  end
+      ds.content = open(__FILE__).read
+      ds.mimeType = 'text/plain'
+      ds.save
+    end
 
-  it "should create a redirect datastream" do
-    obj = @repository.find_or_initialize('test:1')
-    ds = obj.datastreams["Redirect"]
-    ds.controlGroup = "R"
-    ds.dsLocation = "http://example.org"
-    ds.save
-  end
+    it "should create a redirect datastream" do
+      obj = @repository.find_or_initialize('test:1')
+      ds = obj.datastreams["Redirect"]
+      ds.controlGroup = "R"
+      ds.dsLocation = "http://example.org"
+      ds.save
+    end
 
-  it "should have datastreams" do
-    obj = @repository.find_or_initialize('test:1')
-    obj.datastreams.keys.should include("Test")
-    obj.datastreams.keys.should include("Redirect")
-  end
+    it "should have datastreams" do
+      obj = @repository.find_or_initialize('test:1')
+      obj.datastreams.keys.should include("Test")
+      obj.datastreams.keys.should include("Redirect")
+    end
 
-  it "should have datastream content" do
-    obj = @repository.find('test:1')
-    obj.datastreams["Test"].content.should match( "Integration testing against a live Fedora repository")
-  end
+    it "should have datastream content" do
+      obj = @repository.find('test:1')
+      obj.datastreams["Test"].content.should match( "Integration testing against a live Fedora repository")
+    end
 
-  it "should have profile attributes" do
-    obj = @repository.find_or_initialize('test:1')
-    ds = obj.datastreams["Test"]
+    it "should have profile attributes" do
+      obj = @repository.find_or_initialize('test:1')
+      ds = obj.datastreams["Test"]
 
-    ds.versionID.should == "Test.0"
+      ds.versionID.should == "Test.0"
 
-    (Time.now - ds.createDate).should be < 60*60 # 1 hour
-    ds.state.should == "A"
-    ds.controlGroup.should == "M"
-    ds.size.should be > 100
-  end
+      (Time.now - ds.createDate).should be < 60*60 # 1 hour
+      ds.state.should == "A"
+      ds.controlGroup.should == "M"
+      ds.size.should be > 100
+    end
 
-  it "should not mark existing datastreams as changed on load" do
-    obj = @repository.find('fedora-system:ContentModel-3.0')
-    obj.datastreams.each do |k,v|
-      v.changed?.should be false
-      v.new?.should be false
+    it "should not mark existing datastreams as changed on load" do
+      obj = @repository.find('fedora-system:ContentModel-3.0')
+      obj.datastreams.each do |k,v|
+        v.changed?.should be false
+        v.new?.should be false
+      end
     end
-  end
 
   end
 
@@ -186,99 +185,98 @@ describe "Integration testing against a live Fedora repository", :integration =>
     obj.save
   end
 
-
   describe "with transactions" do
     it "should work on ingest" do
-       @repository.find('transactions:1').delete rescue nil
+      @repository.find('transactions:1').delete rescue nil
 
-       @repository.transaction do |t|
-         obj = @repository.find_or_initialize('transactions:1')
-         obj.save
+      @repository.transaction do |t|
+        obj = @repository.find_or_initialize('transactions:1')
+        obj.save
 
-         t.rollback
-       end
+        t.rollback
+      end
 
-       lambda { @repository.find('transactions:1') }.should raise_error Rubydora::RecordNotFound
+      lambda { @repository.find('transactions:1') }.should raise_error Rubydora::RecordNotFound
     end
 
     it "should work on purge" do
-       @repository.find('transactions:1').delete rescue nil
+      @repository.find('transactions:1').delete rescue nil
 
-       obj = @repository.find_or_initialize('transactions:1')
-       obj.save
+      obj = @repository.find_or_initialize('transactions:1')
+      obj.save
 
-       @repository.transaction do |t|
-         obj.delete
+      @repository.transaction do |t|
+        obj.delete
 
-         t.rollback
-       end
+        t.rollback
+      end
 
-       obj = @repository.find('transactions:1')
-       obj.should_not be_new
+      obj = @repository.find('transactions:1')
+      obj.should_not be_new
     end
 
     it "should work on datastreams" do
-       @repository.find('transactions:1').delete rescue nil
-       obj = Rubydora::DigitalObject.new('transactions:1', @repository)
-       obj.save
-
-       ds = obj.datastreams['datastream_to_delete']
-       ds.content = 'asdf'
-       ds.save
-
-       ds2 = obj.datastreams['datastream_to_change']
-       ds2.content = 'asdf'
-       ds2.save
-
-       ds3 = obj.datastreams['datastream_to_change_properties']
-       ds3.content = 'asdf'
-       ds3.versionable = true
-       ds3.dsState = 'I'
-       ds3.save
-
-       @repository.transaction do |t|
-         ds.delete
-
-         ds2.content = '1234'
-         ds2.save
-
-         @repository.set_datastream_options :pid => obj.pid, :dsid => 'datastream_to_change_properties', :state => 'A'
-         @repository.set_datastream_options :pid => obj.pid, :dsid => 'datastream_to_change_properties', :versionable => false
-
-         ds4 = obj.datastreams['datastream_to_create']
-         ds4.content = 'asdf'
-         ds4.save
-
-         t.rollback
-       end
-
-       obj = @repository.find('transactions:1')
-       obj.datastreams.keys.should_not include('datsatream_to_create')
-       obj.datastreams.keys.should include('datastream_to_delete')
-       obj.datastreams['datastream_to_change'].content.should == 'asdf'
-       obj.datastreams['datastream_to_change_properties'].versionable.should == true
-       obj.datastreams['datastream_to_change_properties'].dsState.should == 'I'
+      @repository.find('transactions:1').delete rescue nil
+      obj = Rubydora::DigitalObject.new('transactions:1', @repository)
+      obj.save
+
+      ds = obj.datastreams['datastream_to_delete']
+      ds.content = 'asdf'
+      ds.save
+
+      ds2 = obj.datastreams['datastream_to_change']
+      ds2.content = 'asdf'
+      ds2.save
+
+      ds3 = obj.datastreams['datastream_to_change_properties']
+      ds3.content = 'asdf'
+      ds3.versionable = true
+      ds3.dsState = 'I'
+      ds3.save
+
+      @repository.transaction do |t|
+        ds.delete
+
+        ds2.content = '1234'
+        ds2.save
+
+        @repository.set_datastream_options :pid => obj.pid, :dsid => 'datastream_to_change_properties', :state => 'A'
+        @repository.set_datastream_options :pid => obj.pid, :dsid => 'datastream_to_change_properties', :versionable => false
+
+        ds4 = obj.datastreams['datastream_to_create']
+        ds4.content = 'asdf'
+        ds4.save
+
+        t.rollback
+      end
+
+      obj = @repository.find('transactions:1')
+      obj.datastreams.keys.should_not include('datsatream_to_create')
+      obj.datastreams.keys.should include('datastream_to_delete')
+      obj.datastreams['datastream_to_change'].content.should == 'asdf'
+      obj.datastreams['datastream_to_change_properties'].versionable.should == true
+      obj.datastreams['datastream_to_change_properties'].dsState.should == 'I'
     end
 
     it "should work on relationships" do
       pending("fcrepo 3.6's relationship api is busted; skipping") if @repository.version == 3.6
-       @repository.find('transactions:1').delete rescue nil
+      @repository.find('transactions:1').delete rescue nil
 
       obj = @repository.find_or_initialize('transactions:1')
-       obj.save
-       @repository.add_relationship :subject => obj.pid, :predicate => 'uri:asdf', :object => 'fedora:object'
+      obj.save
+      @repository.add_relationship :subject => obj.pid, :predicate => 'uri:asdf', :object => 'fedora:object'
 
-       ds = obj.datastreams['RELS-EXT'].content
+      ds = obj.datastreams['RELS-EXT'].content
 
-       @repository.transaction do |t|
-         @repository.purge_relationship :subject => obj.pid, :predicate => 'uri:asdf', :object => 'fedora:object'
-         @repository.add_relationship :subject => obj.pid, :predicate => 'uri:qwerty', :object => 'fedora:object'
+      @repository.transaction do |t|
+        @repository.purge_relationship :subject => obj.pid, :predicate => 'uri:asdf', :object => 'fedora:object'
+        @repository.add_relationship :subject => obj.pid, :predicate => 'uri:qwerty', :object => 'fedora:object'
 
-         t.rollback
+        t.rollback
 
-       end
-       obj = @repository.find('transactions:1')
-       obj.datastreams['RELS-EXT'].content.should == ds
+      end
+      obj = @repository.find('transactions:1')
+      obj.datastreams['RELS-EXT'].content.should == ds
     end
   end
 
@@ -341,7 +339,7 @@ describe "Integration testing against a live Fedora repository", :integration =>
       ds.save
 
       versions = obj.datastreams["my_ds"].versions
-      versions.map { |x| x.content }.should include("XXX", "YYY") 
+      versions.map { |x| x.content }.should include("XXX", "YYY")
     end
 
     it "should allow the user to go from a versioned datastream to an unversioned datastream" do
@@ -451,20 +449,19 @@ describe "Integration testing against a live Fedora repository", :integration =>
   end
 
   it "should not destroy content when datastream properties are changed" do
-      obj = @repository.find('test:1')
-      obj.datastreams["my_ds"].content = "XXX"
-      obj.datastreams["my_ds"].mimeType = "text/plain"
-      obj.save
+    obj = @repository.find('test:1')
+    obj.datastreams["my_ds"].content = "XXX"
+    obj.datastreams["my_ds"].mimeType = "text/plain"
+    obj.save
 
-      obj = @repository.find('test:1')
-      obj.datastreams["my_ds"].mimeType = 'application/json'
-      obj.save
+    obj = @repository.find('test:1')
+    obj.datastreams["my_ds"].mimeType = 'application/json'
+    obj.save
 
-      obj = @repository.find('test:1')
-      obj.datastreams["my_ds"].content.should == "XXX"
+    obj = @repository.find('test:1')
+    obj.datastreams["my_ds"].content.should == "XXX"
   end
 
-
   after(:all) do
     @repository.find('test:1').delete rescue nil
     @repository.find('test:2').delete rescue nil

data/spec/lib/profile_parser_spec.rb

@@ -17,4 +17,4 @@ describe Rubydora::ProfileParser do
       end
     end
   end
-end
+end

data/spec/lib/repository_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 describe Rubydora::Repository do
   include Rubydora::FedoraUrlHelpers
-  
+
   before(:each) do
-    @repository = Rubydora::Repository.new 
+    @repository = Rubydora::Repository.new
   end
 
   describe "initialize" do
@@ -34,17 +34,17 @@ describe Rubydora::Repository do
   describe "mint" do
     before do
       xml = "<resp xmlns:fedora=\"http://www.fedora.info/definitions/1/0/management/\"><fedora:pid>test:123</fedora:pid></resp>"
-      @repository.api.should_receive(:next_pid).and_return xml 
+      @repository.api.should_receive(:next_pid).and_return xml
     end
     it "should call nextPID" do
       @repository.mint.should == 'test:123'
     end
   end
-  
+
   describe "mint (Fedora 3.4)" do
     before do
       xml = "<resp><pid>test:123</pid></resp>"
-      @repository.api.should_receive(:next_pid).and_return xml 
+      @repository.api.should_receive(:next_pid).and_return xml
     end
     it "should call nextPID" do
       @repository.mint.should == 'test:123'

data/spec/lib/rest_api_client_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper' 
+require 'spec_helper'
 
 describe Rubydora::RestApiClient do
-  
+
   include Rubydora::FedoraUrlHelpers
 
   class FakeException < Exception
@@ -13,12 +13,10 @@ describe Rubydora::RestApiClient do
     attr_accessor :config
   end
 
-
-
   describe "exception handling" do
-  
+
     shared_examples "RestClient error handling" do
-      subject { 
+      subject {
         mock_repository = MockRepository.new
         mock_repository.config = { :url => 'http://example.org' }
 
@@ -47,12 +45,10 @@ describe Rubydora::RestApiClient do
 
   end
 
-
   let :base_url do
     "http://example.org"
   end
 
-
   before(:each) do
     @fedora_user = 'fedoraAdmin'
     @fedora_password = 'fedoraAdmin'
@@ -62,11 +58,11 @@ describe Rubydora::RestApiClient do
 
   it "should create a REST client" do
     client = @mock_repository.client
-    
+
     client.should be_a_kind_of(RestClient::Resource)
     client.options[:user].should == @fedora_user
   end
-  
+
   it "should create a REST client with a client certificate" do
     client = @mock_repository.client :ssl_client_cert => OpenSSL::X509::Certificate.new, :ssl_client_key => OpenSSL::PKey::RSA.new
 
@@ -80,21 +76,20 @@ describe Rubydora::RestApiClient do
     lambda { client.should == @mock_repository.client }.should_not raise_error
     lambda { @mock_repository.client(:timeout => 120) }.should raise_error(ArgumentError)
   end
-  
+
   it "should call nextPID" do
     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + next_pid_url(:format => 'xml')))
     @mock_repository.next_pid
   end
 
   it "should find objects" do
-     RestClient::Request.should_receive(:execute) do |params|
-       params.should have_key(:url)
-       params[:url].should =~ /^#{Regexp.escape(base_url + "/" + find_objects_url + "?")}.*query=a/
-     end
+    RestClient::Request.should_receive(:execute) do |params|
+      params.should have_key(:url)
+      params[:url].should =~ /^#{Regexp.escape(base_url + "/" + find_objects_url + "?")}.*query=a/
+    end
     @mock_repository.find_objects :query => 'a'
   end
 
-
   it "should show object properties" do
     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + object_url('z', :format => 'xml')))
     @mock_repository.object :pid => 'z'
@@ -104,26 +99,25 @@ describe Rubydora::RestApiClient do
     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + object_url('z', :format => 'xml'))).and_raise( RestClient::ResourceNotFound)
     lambda {@mock_repository.object(:pid => 'z')}.should raise_error RestClient::ResourceNotFound
   end
-  
+
   it "ingest" do
     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + new_object_url))
     @mock_repository.ingest
   end
 
-
   it "mint_pid_and_ingest" do
     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + new_object_url))
     @mock_repository.ingest
   end
 
   it "ingest with pid" do
-     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + object_url('mypid')))
+    RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + object_url('mypid')))
     @mock_repository.ingest :pid => 'mypid'
   end
 
   describe "export" do
     it "should work on the happy path" do
-       RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + export_object_url('mypid')))
+      RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + export_object_url('mypid')))
       @mock_repository.export :pid => 'mypid'
     end
     it "should require a pid" do
@@ -132,15 +126,15 @@ describe Rubydora::RestApiClient do
   end
 
   it "modify_object" do
-     RestClient::Request.should_receive(:execute) do |params|
-       params.should have_key(:url)
-       params[:url].should =~ /^#{Regexp.escape(base_url + "/" + object_url('mypid'))}.*state=Z/
-     end
+    RestClient::Request.should_receive(:execute) do |params|
+      params.should have_key(:url)
+      params[:url].should =~ /^#{Regexp.escape(base_url + "/" + object_url('mypid'))}.*state=Z/
+    end
     @mock_repository.modify_object :pid => 'mypid', :state => 'Z'
   end
 
   it "purge_object" do
-     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + object_url('mypid')))
+    RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + object_url('mypid')))
     @mock_repository.purge_object :pid => 'mypid'
   end
 
@@ -150,12 +144,12 @@ describe Rubydora::RestApiClient do
   end
 
   it "object_versions" do
-     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + object_versions_url('mypid', :format => 'xml')))
+    RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + object_versions_url('mypid', :format => 'xml')))
     @mock_repository.object_versions :pid => 'mypid'
   end
 
   it "object_xml" do
-     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + object_xml_url('mypid', :format => 'xml')))
+    RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + object_xml_url('mypid', :format => 'xml')))
     @mock_repository.object_xml :pid => 'mypid'
   end
 
@@ -205,45 +199,45 @@ describe Rubydora::RestApiClient do
     after { Rubydora.logger = @initial_logger }
 
     it "datastream" do
-       RestClient::Request.should_receive(:execute).with(hash_including(request_options))
+      RestClient::Request.should_receive(:execute).with(hash_including(request_options))
       my_logger.should_receive(:debug) # squelch message "Loaded datastream mypid/aaa (time)"
       @mock_repository.datastream :pid => 'mypid', :dsid => 'aaa'
     end
 
     it "should raise not found exception when getting a datastream" do
-       RestClient::Request.should_receive(:execute).with(hash_including(request_options)).and_raise(RestClient::ResourceNotFound)
+      RestClient::Request.should_receive(:execute).with(hash_including(request_options)).and_raise(RestClient::ResourceNotFound)
       lambda {@mock_repository.datastream :pid => 'mypid', :dsid => 'aaa'}.should raise_error RestClient::ResourceNotFound
     end
 
     it "should raise Unauthorized exception when getting a datastream" do
-       RestClient::Request.should_receive(:execute).with(hash_including(request_options)).and_raise(RestClient::Unauthorized)
+      RestClient::Request.should_receive(:execute).with(hash_including(request_options)).and_raise(RestClient::Unauthorized)
       my_logger.should_receive(:error).with("Unauthorized at #{base_url + "/" + datastream_url('mypid', 'aaa', :format => 'xml')}")
       lambda {@mock_repository.datastream :pid => 'mypid', :dsid => 'aaa'}.should raise_error RestClient::Unauthorized
     end
   end
 
   it "datastream_dissemination" do
-     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + datastream_content_url('mypid', 'aaa')))
+    RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + datastream_content_url('mypid', 'aaa')))
     @mock_repository.datastream_dissemination :pid => 'mypid', :dsid => 'aaa'
   end
   it "should allow http methods besides GET on datastream_dissemination" do
-     RestClient::Request.should_receive(:execute).with(hash_including(:method => :head))
+    RestClient::Request.should_receive(:execute).with(hash_including(:method => :head))
     @mock_repository.datastream_dissemination :pid => 'mypid', :dsid => 'aaa', :method => :head
   end
   it "should pass a block to the rest client to process the response in datastream_dissemination" do
-     _proc = lambda { |x| x }
-     RestClient::Request.should_receive(:execute).with(hash_including(:block_response => _proc))
+    _proc = lambda { |x| x }
+    RestClient::Request.should_receive(:execute).with(hash_including(:block_response => _proc))
     @mock_repository.datastream_dissemination :pid => 'mypid', :dsid => 'aaa', &_proc
   end
   it "should raise not found exception when retrieving datastream_dissemination" do
-     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + datastream_content_url('mypid', 'aaa'))).and_raise( RestClient::ResourceNotFound)
+    RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + datastream_content_url('mypid', 'aaa'))).and_raise( RestClient::ResourceNotFound)
     lambda {@mock_repository.datastream_dissemination :pid => 'mypid', :dsid => 'aaa'}.should raise_error RestClient::ResourceNotFound
   end
 
   describe "add_datastream" do
     it "should post to the correct url" do
       RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + datastream_url('mypid', 'aaa')))
-      @mock_repository.add_datastream :pid => 'mypid', :dsid => 'aaa' 
+      @mock_repository.add_datastream :pid => 'mypid', :dsid => 'aaa'
     end
     describe "when a file is passed" do
       let!(:file) { StringIO.new('test', 'r') } # StringIO is a good stand it for a real File (it has read, rewind and close)
@@ -279,15 +273,15 @@ describe Rubydora::RestApiClient do
 
   describe "modify datastream" do
     it "should not set mime-type when it's not provided (and a file is not passed)" do
-       RestClient::Request.should_receive(:execute).with(:url => base_url + "/" + datastream_url('mypid', 'aaa'),:open_timeout=>nil, :payload=>nil, :user=>@fedora_user, :password=>@fedora_password, :method=>:put, :headers=>{})
-      @mock_repository.modify_datastream :pid => 'mypid', :dsid => 'aaa' 
+      RestClient::Request.should_receive(:execute).with(:url => base_url + "/" + datastream_url('mypid', 'aaa'),:open_timeout=>nil, :payload=>nil, :user=>@fedora_user, :password=>@fedora_password, :method=>:put, :headers=>{})
+      @mock_repository.modify_datastream :pid => 'mypid', :dsid => 'aaa'
     end
     it "should pass the provided mimeType header" do
-       RestClient::Request.should_receive(:execute).with(:url => base_url + "/" + datastream_url('mypid', 'aaa', :mimeType => 'application/json'),:open_timeout=>nil, :payload=>nil, :user=>@fedora_user, :password=>@fedora_password, :method=>:put, :headers=>{})
+      RestClient::Request.should_receive(:execute).with(:url => base_url + "/" + datastream_url('mypid', 'aaa', :mimeType => 'application/json'),:open_timeout=>nil, :payload=>nil, :user=>@fedora_user, :password=>@fedora_password, :method=>:put, :headers=>{})
       @mock_repository.modify_datastream :pid => 'mypid', :dsid => 'aaa', :mimeType=>'application/json'
     end
     describe "when a file is passed" do
-      let!(:file) { StringIO.new('test', 'r') } # StringIO is a good stand it for a real File (it has read, rewind and close) 
+      let!(:file) { StringIO.new('test', 'r') } # StringIO is a good stand it for a real File (it has read, rewind and close)
       it "should rewind the file" do
         RestClient::Request.any_instance.should_receive(:transmit) #stub transmit so that Request.execute can close the file we pass
         @mock_repository.modify_datastream :pid => 'mypid', :dsid => 'aaa', :content=>file
@@ -319,74 +313,74 @@ describe Rubydora::RestApiClient do
   end
 
   it "purge_datastream" do
-     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + datastream_url('mypid', 'aaa')))
-    @mock_repository.purge_datastream :pid => 'mypid', :dsid => 'aaa' 
+    RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + datastream_url('mypid', 'aaa')))
+    @mock_repository.purge_datastream :pid => 'mypid', :dsid => 'aaa'
   end
 
   it "set_datastream_options" do
-     RestClient::Request.should_receive(:execute) do |params|
-       params.should have_key(:url)
-       params[:url].should =~ /^#{Regexp.escape(base_url + "/" + datastream_url('mypid', 'aaa') + "?")}.*aparam=true/ 
-     end
-    @mock_repository.set_datastream_options :pid => 'mypid', :dsid => 'aaa', :aparam => true 
+    RestClient::Request.should_receive(:execute) do |params|
+      params.should have_key(:url)
+      params[:url].should =~ /^#{Regexp.escape(base_url + "/" + datastream_url('mypid', 'aaa') + "?")}.*aparam=true/
+    end
+    @mock_repository.set_datastream_options :pid => 'mypid', :dsid => 'aaa', :aparam => true
   end
 
   describe "datastream_versions" do
     it "should be successful" do
-       RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + datastream_history_url('mypid', 'aaa', :format=>'xml'))).and_return("expected result")
+      RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + datastream_history_url('mypid', 'aaa', :format=>'xml'))).and_return("expected result")
       @mock_repository.datastream_versions(:pid => 'mypid', :dsid => 'aaa').should == 'expected result'
     end
     it "should not break when fedora doesn't have datastream history" do
-       RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + datastream_history_url('mypid', 'aaa', :format=>'xml'))).and_raise(RestClient::ResourceNotFound)
+      RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + datastream_history_url('mypid', 'aaa', :format=>'xml'))).and_raise(RestClient::ResourceNotFound)
       @mock_repository.datastream_versions(:pid => 'mypid', :dsid => 'aaa').should be_nil
     end
   end
 
   it "datastream_history" do
-     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + datastream_history_url('mypid', 'aaa', :format=>'xml')))
+    RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + datastream_history_url('mypid', 'aaa', :format=>'xml')))
     @mock_repository.datastream_history :pid => 'mypid', :dsid => 'aaa'
   end
 
   it "relationships" do
-     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + object_relationship_url('mypid', :format => 'xml')))
+    RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + object_relationship_url('mypid', :format => 'xml')))
     @mock_repository.relationships :pid => 'mypid'
   end
 
   it "add_relationship" do
-     RestClient::Request.should_receive(:execute) do |params|
-       params.should have_key(:url)
-       params[:url].should =~ /^#{Regexp.escape(base_url + "/" + new_object_relationship_url('mypid') + "?")}.*subject=z/
-     end
+    RestClient::Request.should_receive(:execute) do |params|
+      params.should have_key(:url)
+      params[:url].should =~ /^#{Regexp.escape(base_url + "/" + new_object_relationship_url('mypid') + "?")}.*subject=z/
+    end
     @mock_repository.add_relationship :pid => 'mypid', :subject => 'z'
   end
 
   it "purge_relationships" do
-     RestClient::Request.should_receive(:execute) do |params|
-       params.should have_key(:url)
-       params[:url].should =~ /^#{Regexp.escape(base_url + "/" + object_relationship_url('mypid') + "?")}.*subject=z/
-     end
-    @mock_repository.purge_relationship :pid => 'mypid', :subject => 'z' 
+    RestClient::Request.should_receive(:execute) do |params|
+      params.should have_key(:url)
+      params[:url].should =~ /^#{Regexp.escape(base_url + "/" + object_relationship_url('mypid') + "?")}.*subject=z/
+    end
+    @mock_repository.purge_relationship :pid => 'mypid', :subject => 'z'
   end
 
   it "dissemination" do
-     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + dissemination_url('mypid', nil, nil, :format => 'xml')))
+    RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + dissemination_url('mypid', nil, nil, :format => 'xml')))
     @mock_repository.dissemination :pid => 'mypid'
   end
 
   it "dissemination" do
-     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + dissemination_url('mypid', 'sdef', nil, :format => 'xml')))
+    RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + dissemination_url('mypid', 'sdef', nil, :format => 'xml')))
     @mock_repository.dissemination :pid => 'mypid', :sdef => 'sdef'
   end
 
   it "dissemination" do
-     RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + dissemination_url('mypid', 'sdef', 'method')))
+    RestClient::Request.should_receive(:execute).with(hash_including(:url => base_url + "/" + dissemination_url('mypid', 'sdef', 'method')))
     @mock_repository.dissemination :pid => 'mypid', :sdef => 'sdef', :method => 'method'
   end
 
   it "should pass a block to the rest client to process the response in datastream_dissemination" do
-     _proc = lambda { |x| x }
-     RestClient::Request.should_receive(:execute).with(hash_including(:block_response => _proc))
-     @mock_repository.dissemination :pid => 'mypid', :sdef => 'sdef', :method => 'method', &_proc
+    _proc = lambda { |x| x }
+    RestClient::Request.should_receive(:execute).with(hash_including(:block_response => _proc))
+    @mock_repository.dissemination :pid => 'mypid', :sdef => 'sdef', :method => 'method', &_proc
   end
 
 end