hydra-head 3.0.0pre3 → 3.0.0pre4

data/test_support/spec/controllers/assets_controller_spec.rb

@@ -88,8 +88,8 @@ describe AssetsController do
     it "should delete the asset identified by pid" do
       mock_obj = mock("asset", :delete)
       mock_obj.expects(:destroy_child_assets).returns([])
-      ActiveFedora::Base.expects(:load_instance_from_solr).with("__PID__").returns(mock_obj)
-      ActiveFedora::ContentModel.expects(:known_models_for).with(mock_obj).returns([ModsAsset])
+      ActiveFedora::Base.expects(:load_instance_from_solr).at_least_once.with("__PID__").returns(mock_obj)
+      ActiveFedora::ContentModel.expects(:known_models_for).at_least_once.with(mock_obj).returns([ModsAsset])
       ModsAsset.expects(:load_instance_from_solr).with("__PID__").returns(mock_obj)
       delete(:destroy, :id => "__PID__")
     end
@@ -101,8 +101,9 @@ describe AssetsController do
     it "should withdraw the asset identified by pid" do
       mock_obj = mock("asset", :delete)
       mock_obj.expects(:destroy_child_assets).returns([])
-      ActiveFedora::Base.expects(:load_instance_from_solr).with("__PID__").returns(mock_obj)
-      ActiveFedora::ContentModel.expects(:known_models_for).with(mock_obj).returns([ModsAsset])
+      ActiveFedora::Base.expects(:load_instance_from_solr).at_least_once.with("__PID__").returns(mock_obj)
+      ActiveFedora::Base
+      ActiveFedora::ContentModel.expects(:known_models_for).at_least_once.with(mock_obj).returns([ModsAsset])
       ModsAsset.expects(:load_instance_from_solr).with("__PID__").returns(mock_obj)
       delete(:withdraw, :id => "__PID__")
     end

data/test_support/spec/controllers/catalog_controller_spec.rb

@@ -67,7 +67,7 @@ describe CatalogController do
       it "should only return public documents if role does not have permissions" do
         controller.stubs(:current_user).returns(nil)
         get :index
-        assigns("response").docs.count.should == @public_only_results.docs.count
+        assigns(:document_list).count.should == @public_only_results.docs.count
       end
       it "should return all documents if role does have permissions" do
 	User.any_instance.stubs(:login).returns("BigWig")
@@ -75,7 +75,7 @@ describe CatalogController do
         session[:superuser_mode] = true
         controller.stubs(:current_user).returns(mock_user)
         get :index
-        assigns["response"].docs.count.should > @public_only_results.docs.count
+        assigns(:document_list).count.should > @public_only_results.docs.count
       end
     end
   end

data/test_support/spec/controllers/file_assets_controller_spec.rb

@@ -98,25 +98,30 @@ describe FileAssetsController do
   describe "create" do
     it "should create and save a file asset from the given params" do
       mock_fa = mock("FileAsset")
+      mock_file = mock("File")
+      mock_fa.expects(:label).returns("Foo File")
       mock_fa.stubs(:pid).returns("foo:pid")
-      controller.expects(:create_and_save_file_asset_from_params).returns(mock_fa)
-      xhr :post, :create, :Filedata=>mock("File"), :Filename=>"Foo File"
+      controller.expects(:create_and_save_file_assets_from_params).returns([mock_fa])
+      xhr :post, :create, :Filedata=>[mock_file], :Filename=>"Foo File"
     end
     it "if container_id is provided, should associate the created file asset wtih the container" do
       stub_fa = stub("FileAsset", :save)
       stub_fa.stubs(:pid).returns("foo:pid")
-      controller.expects(:create_and_save_file_asset_from_params).returns(stub_fa)
+      stub_fa.stubs(:label).returns("Foo File")
+      mock_file = mock("File")
+      controller.expects(:create_and_save_file_assets_from_params).returns([stub_fa])
       controller.expects(:associate_file_asset_with_container)      
-      xhr :post, :create, :Filedata=>stub("File"), :Filename=>"Foo File", :asset_id=>"_PID_"
+      xhr :post, :create, :Filedata=>[mock_file], :Filename=>"Foo File", :container_id=>"_PID_"
     end
-    it "should redirect back to container edit view if no Filedata is provided but container_id is provided" do
-      xhr :post, :create, :asset_id=>"_PID_"
-      response.should redirect_to(:controller=>"catalog", :id=>"_PID_", :action => 'edit')
-      # flash[:notice].should == "You must specify a file to upload."
+    it "should redirect back to edit view if no Filedata is provided but container_id is provided" do
+      controller.expects(:model_config).at_least_once.returns(controller.workflow_config[:mods_assets])
+      xhr :post, :create, :container_id=>"_PID_", :wf_step=>"files"
+      response.should redirect_to(:controller=>"catalog", :id=>"_PID_", :action => 'edit', :wf_step=>"permissions")
+      response.flash[:notice].should == "You must specify a file to upload."
     end
     it "should display a message that you need to select a file to upload if no Filedata is provided" do
       xhr :post, :create
-      # flash[:notice].should == "You must specify a file to upload."
+      response.flash[:notice].include?("You must specify a file to upload.").should be_true
     end
     
   end
@@ -180,7 +185,8 @@ describe FileAssetsController do
         
         test_file = fixture("empty_file.txt")
         filename = "My File Name"
-        post :create, {:Filedata=>test_file, :Filename=>filename, :asset_id=>@test_container.pid}
+        test_file.expects(:original_filename).twice.returns("My File Name")
+        post :create, {:Filedata=>[test_file], :Filename=>filename, :container_id=>@test_container.pid}
         assigns(:file_asset).relationships[:self][:is_part_of].should == ["info:fedora/#{@test_container.pid}"] 
         retrieved_fa = FileAsset.load_instance(@test_fa.pid).relationships[:self][:is_part_of].should == ["info:fedora/#{@test_container.pid}"]
       end

data/test_support/spec/controllers/hydra_controller_spec.rb

@@ -10,6 +10,8 @@ describe Hydra::Controller do
   it "should add the necessary helpers to classes that include it" do
     HydraControllerTest.expects(:helper).with(:hydra_assets)
     HydraControllerTest.expects(:helper).with(:hydra_fedora_metadata)
+    HydraControllerTest.expects(:helper).with(:generic_content_objects)
+    HydraControllerTest.stubs(:before_filter)
     HydraControllerTest.send(:include, Hydra::Controller)
   end
 end

data/test_support/spec/controllers/permissions_controller_spec.rb

@@ -68,7 +68,7 @@ describe PermissionsController do
       
       # this is what currently works 
       # post :update, :asset_id=>"_pid_", :actor_type=>"group", :actor_id=>"_group_id_", :permission => {"group"=>"_group_id_","level"=>"discover"}
-
+      
       post :update, :asset_id=>"_pid_", :permission => {"group"=>{"_group_id_"=>"discover"}}
     end
     it "should add a rightsMetadata datastream if it doesn't exist"

data/test_support/spec/helpers/access_controls_enforcement_spec.rb

@@ -2,126 +2,34 @@
 require File.expand_path( File.join( File.dirname(__FILE__),'..','spec_helper') )
 
 describe Hydra::AccessControlsEnforcement do
-  before(:each) do
-    @extra_controller_params = {}
-  end
-  
-  describe "enforce_access_controls" do
-    describe "[index]" do
-      it "should trigger enforce_index_permissions" do
-        helper.params[:action] = "index"
-        helper.expects(:enforce_index_permissions)
-        helper.enforce_access_controls
-      end
-    end
-    describe "[show]" do
-      it "should trigger enforce_show_permissions" do
-        helper.params[:action] = "show"
-        helper.expects(:enforce_show_permissions)
-        helper.enforce_access_controls
-      end
-    end
-    
-    describe "[edit]" do
-      it "should trigger enforce_edit_permissions" do
-        helper.params[:action] = "edit"
-        helper.expects(:enforce_edit_permissions)
-        helper.enforce_access_controls
-      end
-    end
-    describe "[update]" do
-      it "should trigger enforce_update_permissions" do
-        helper.params[:action] = "update"
-        helper.expects(:enforce_update_permissions)
-        helper.enforce_access_controls
-      end
-    end
-    
-  end
-  
-  describe "add_access_controls_to_solr_params" do
-    it "should set up gated discovery" do
-      stub_solr_params = {}
-      helper.stubs(:reader?).returns(false)
-      helper.stubs(:params).returns({:action=>:index})
-      helper.expects(:apply_gated_discovery).with(stub_solr_params, {})
-      helper.send(:add_access_controls_to_solr_params, stub_solr_params, {})
-    end
-    it "should make blacklight use the :public_qt response handler if user does not have read permissions" do
-      stub_solr_params = {}
-      helper.stubs(:solr_parameters).returns(stub_solr_params)
-      helper.stubs(:reader?).returns(false)
-      helper.stubs(:params).returns({:action=>:index})
-      helper.stubs(:apply_gated_discovery)
-      helper.send(:add_access_controls_to_solr_params, stub_solr_params, {})
-      stub_solr_params[:qt].should == Blacklight.config[:public_qt]
-    end
-  end
-  
-  describe "enforce_index_permissions" do
-    it "should be defined but do nothing (currently enforce_index_permissions doesn't do anything but it's there if you want to override)" do
-      # just ensure that calling the method does not raise an error
-      helper.send(:enforce_index_permissions)
-    end
-  end
-  
-  describe "enforce_show_permissions" do
-    it "should deny access to documents if role does not have read permissions" do
-      helper.stubs(:reader?).returns(false)
-      helper.stubs(:params).returns({:action=>:show,:id=>"hydrangea:fixture_mods_article1"}) # the permissions from this are not actually used because we stub the :reader? method
-      helper.expects(:redirect_to).with(:f => nil, :q => nil, :action => 'index')
-      helper.send(:enforce_show_permissions)
-      flash[:notice].should ==  "You do not have sufficient access privileges to read this document, which has been marked private."
-    end
-  end
-  describe "enforce_edit_permissions" do
-    it "should deny access to documents if role does not have edit permissions" do
-      helper.stubs(:editor?).returns(false)
-      helper.stubs(:params).returns({:action=>:edit,:id=>"hydrangea:fixture_mods_article1"} ) # the permissions from this are not actually used because we stub the :editor? method
-      helper.expects(:redirect_to).with(:action => :show)
-      helper.send(:enforce_edit_permissions)
-      flash[:notice].should == "You do not have sufficient privileges to edit this document. You have been redirected to the read-only view."
-    end  
-  end
-  describe "enforce_update_permissions" do
-    it "should deny access to documents if role does not have update permissions" do
-      helper.stubs(:editor?).returns(false)
-      helper.stubs(:params).returns({:action=>:edit,:id=>"hydrangea:fixture_mods_article1"} ) # the permissions from this are not actually used because we stub the :editor? method
-      helper.expects(:redirect_to).with(:action => :show)
-      helper.send(:enforce_update_permissions)
-      flash[:notice].should == "You do not have sufficient privileges to edit this document. You have been redirected to the read-only view."
-    end  
-  end
-  describe "apply_gated_discovery" do
-    it "should set the query using build_lucene_query" do
-      stub_solr_params = {}
-      helper.stubs(:solr_parameters).returns(stub_solr_params)
-      user_query = "my important query"
-      helper.stubs(:params).returns({:q=>user_query} )
-      helper.expects(:build_lucene_query).with(user_query).returns("stub lucene query")
-      helper.send(:apply_gated_discovery, stub_solr_params, {})
-      stub_solr_params[:q].should == "stub lucene query"
-    end
-  end
-  
-  describe "build_lucene_query" do
+ describe "build_lucene_query" do
 
-    it "should return fields for all roles the user is a member of checking against the discover, access, read fields" do
-     stub_user = User.new
+   it "should return fields for all roles the user is a member of checking against the discover, access, read fields" do
+     stub_user = User.new :email=>'archivist1@example.com'
      stub_user.stubs(:is_being_superuser?).returns false
-     stub_user.stubs(:login).returns "archivist1@example.com"
      helper.stubs(:current_user).returns(stub_user)
      # This example assumes that archivist1 is in the archivist and researcher groups.
      # Tried stubbing RoleMapper.roles instead, but that broke 26 other tests because mocha fails to release the expectation.
      # RoleMapper.stubs(:roles).with(stub_user.login).returns(["archivist", "researcher"])
-     query = helper.send(:build_lucene_query, "string")
+     query = helper.send(:build_lucene_query, "query_string")
+     # RoleMapper.stubs(:roles).with(stub_user.login).returns(["archivist", "researcher"])
+     # query = helper.send(:build_lucene_query, "string")
      
      ["discover","edit","read"].each do |type|
        query.should match(/_query_\:\"#{type}_access_group_t\:archivist/) and
        query.should match(/_query_\:\"#{type}_access_group_t\:researcher/)
      end
-    end
-    it "should return fields for all the person specific discover, access, read fields" do
+     query.should match /^_query_:"\{!dismax qf=\$qf_dismax pf=\$pf_dismax\}query_string" AND NOT _query_:"info\\\\:fedora\/afmodel\\\\:FileAsset"/
+   end
+   it "should not have dismax clause if no user_query is suplied" do
+     stub_user = User.new
+     stub_user.stubs(:is_being_superuser?).returns false
+     helper.stubs(:current_user).returns(stub_user)
+     query = helper.send(:build_lucene_query, nil)
+     query.should match /^NOT _query_:"info\\\\:fedora\/afmodel\\\\:FileAsset"/
+   end
+
+   it "should return fields for all the person specific discover, access, read fields" do
      stub_user = User.new
      stub_user.stubs(:is_being_superuser?).returns false
      helper.stubs(:current_user).returns(stub_user)
@@ -129,8 +37,8 @@ describe Hydra::AccessControlsEnforcement do
      ["discover","edit","read"].each do |type|
        query.should match(/_query_\:\"#{type}_access_person_t\:#{stub_user.login}/)
      end
-    end
-    describe "for superusers" do
+   end
+   describe "for superusers" do
      it "should return superuser access level" do
        stub_user = User.new
        stub_user.stubs(:is_being_superuser?).returns true
@@ -149,116 +57,9 @@ describe Hydra::AccessControlsEnforcement do
          query.should_not match(/_query_\:\"#{type}_access_person_t\:\[\* TO \*\]/)
        end
      end
-    end
-  end
-
-  it "should have necessary fieldnames from initializer" do
-   Hydra.config[:permissions][:catchall].should_not be_nil
-   Hydra.config[:permissions][:discover][:group].should_not be_nil
-   Hydra.config[:permissions][:discover][:individual].should_not be_nil
-   Hydra.config[:permissions][:read][:group].should_not be_nil
-   Hydra.config[:permissions][:read][:individual].should_not be_nil
-   Hydra.config[:permissions][:edit][:group].should_not be_nil
-   Hydra.config[:permissions][:edit][:individual].should_not be_nil
-   Hydra.config[:permissions][:owner].should_not be_nil
-   Hydra.config[:permissions][:embargo_release_date].should_not be_nil
-  end
-
-  # SPECS FOR SINGLE DOCUMENT REQUESTS
-  describe 'Get Document Permissions By Id' do
-   before(:each) do
-     @doc_id = 'hydrangea:fixture_mods_article1'
-     @bad_id = "redrum"
-     @permissions_solr_response2, @permissions_solr_document = helper.get_permissions_solr_response_for_doc_id(@doc_id)
-   end
-
-   it "should raise Blacklight::InvalidSolrID for an unknown id" do
-     lambda {
-       helper.get_permissions_solr_response_for_doc_id(@bad_id)
-     }.should raise_error(Blacklight::Exceptions::InvalidSolrID)
-   end
-   
-   it "should raise Blacklight::InvalidSolrID for nil id" do
-     lambda {
-       helper.get_permissions_solr_response_for_doc_id(nil)
-     }.should raise_error(Blacklight::Exceptions::InvalidSolrID)
-   end
-
-   it "should have a non-nil result for a known id" do
-     @permissions_solr_document.should_not == nil
-   end
-   it "should have a single document in the response for a known id" do
-     @permissions_solr_response2.docs.size.should == 1
-   end
-   it 'should have the expected value in the id field' do
-     @permissions_solr_document.id.should == @doc_id
-   end
-   it 'should have non-nil values for permissions fields that are set on the object' do
-     @permissions_solr_document.get(Hydra.config[:permissions][:catchall]).should_not be_nil
-     @permissions_solr_document.get(Hydra.config[:permissions][:discover][:group]).should_not be_nil
-     @permissions_solr_document.get(Hydra.config[:permissions][:edit][:group]).should_not be_nil
-     @permissions_solr_document.get(Hydra.config[:permissions][:edit][:individual]).should_not be_nil
-     @permissions_solr_document.get(Hydra.config[:permissions][:read][:group]).should_not be_nil
- 
-     # @document.get(Hydra.config[:permissions][:discover][:individual]).should_not be_nil
-     # @document.get(Hydra.config[:permissions][:read][:individual]).should_not be_nil
-     # @document.get(Hydra.config[:permissions][:owner]).should_not be_nil
-     # @document.get(Hydra.config[:permissions][:embargo_release_date]).should_not be_nil
    end
- 
-   describe "permissions helpers" do 
-     before :each do
-       @hydra_config_hash = { :permissions => {
-              :catchall => "access_t",
-              :discover => {:group =>"discover_access_group_t", :individual=>"discover_access_person_t"},
-              :read => {:group =>"read_foobar_group_t", :individual=>"read_foobar_person_t"},
-              :edit => {:group =>"edit_foobar_group_t", :individual=>"edit_foobar_person_t"},
-              :owner => "depositor_t",
-              :embargo_release_date => "embargo_release_date_dt"
-            }}
-        @stub_user = User.new
-        @stub_user.stubs(:is_being_superuser?).returns false
-      end
-      it "should check fields from Hydra.config when checking read permissions" do
-        Hydra.expects(:config).at_least(2).returns(@hydra_config_hash)
-        @permissions_solr_document.expects(:fetch).with("read_foobar_group_t",nil)
-        @permissions_solr_document.expects(:fetch).with("read_foobar_person_t",nil)
-        @permissions_solr_document.expects(:fetch).with("edit_foobar_group_t",nil)
-        @permissions_solr_document.expects(:fetch).with("edit_foobar_person_t",nil)
-        helper.stubs(:current_user).returns(@stub_user)
-        helper.reader?
-      end
-      it "should check fields from Hydra.config when checking edit permissions" do
-        Hydra.expects(:config).at_least(2).returns(@hydra_config_hash)
-        @permissions_solr_document.expects(:fetch).with("edit_foobar_group_t",nil)
-        @permissions_solr_document.expects(:fetch).with("edit_foobar_person_t",nil)
-        helper.stubs(:current_user).returns(@stub_user)
-        helper.editor?
-      end
-      it "should check fields from Hydra.config when executing test_permissions for editor" do
-        Hydra.expects(:config).at_least(2).returns(@hydra_config_hash)
-        @permissions_solr_document.expects(:fetch).with("edit_foobar_group_t",nil)
-        @permissions_solr_document.expects(:fetch).with("edit_foobar_person_t",nil)
-        helper.stubs(:current_user).returns(@stub_user)
-        helper.test_permission(:edit)
-      end
-      it "should check fields from Hydra.config when executing test_permissions for reader" do
-        Hydra.expects(:config).at_least(2).returns(@hydra_config_hash)
-        @permissions_solr_document.expects(:fetch).with("read_foobar_group_t",nil)
-        @permissions_solr_document.expects(:fetch).with("read_foobar_person_t",nil)
-        @permissions_solr_document.expects(:fetch).with("edit_foobar_group_t",nil)
-        @permissions_solr_document.expects(:fetch).with("edit_foobar_person_t",nil)
-        helper.stubs(:current_user).returns(@stub_user)
-        helper.test_permission(:read)
-      end
-    end
-  end
 
-  it "should include the methods from Hydra::AccessControlsEvaluation" do
-    helper.should respond_to(:reader?)
-    helper.should respond_to(:editor?)
-    helper.should respond_to(:test_permission)
-  end
+ end
 end
 
 

data/test_support/spec/helpers/blacklight_helper_spec.rb

@@ -17,9 +17,11 @@ describe BlacklightHelper do
     describe "render_head_content" do
       before (:each) do
         helper.expects(:content_for).with(:head).returns("My added content")
+        head_stuff = ["Something extra", "Stuff for unapi-server"]
+        helper.expects(:extra_head_content).twice().returns(head_stuff)
       end
       it "adds the content of content_for(:head) to the output" do
-        helper.render_head_content.should == "My added content"
+        helper.render_head_content.should == "Something extraMy added content"
       end
     end
     describe "link_to_document" do

data/test_support/spec/helpers/file_assets_helper_spec.rb

@@ -3,12 +3,12 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe Hydra::FileAssetsHelper do
   describe "create_and_save_file_asset_from_params" do
     it "should create the file asset, add posted blob to it and save the file asset" do
-      helper.stubs(:params).returns( { :Filedata => "" } )      
       mock_fa = mock("file asset")
+      helper.stubs(:params).returns( { :Filedata => [mock_fa] } )
       mock_fa.expects(:save)
-      helper.expects(:create_asset_from_params).returns(mock_fa)
+      helper.expects(:create_asset_from_file).returns(mock_fa)
       helper.expects(:add_posted_blob_to_asset)
-      helper.create_and_save_file_asset_from_params
+      helper.create_and_save_file_assets_from_params
     end
   end
   
@@ -16,34 +16,37 @@ describe Hydra::FileAssetsHelper do
     it "should set object title and label" do
       mock_file = mock("File")
       file_name = "Posted Filename.foo"
-      helper.stubs(:params).returns( :Filedata=>mock_file, :Filename=>file_name, "container_id"=>"hydrangea:2973" )      
+      helper.stubs(:params).returns( :Filedata=>[mock_file], :Filename=>file_name, "container_id"=>"hydrangea:2973" )      
       mock_fa = mock("file asset")
+      mock_file.expects(:original_filename).returns(file_name)
       mock_fa.expects(:add_file_datastream).with(mock_file, :label=>file_name, :mimeType=>"mymimetype")
       mock_fa.expects(:set_title_and_label).with( file_name, :only_if_blank=>true )
       helper.expects(:mime_type).with(file_name).returns("mymimetype")
-      helper.add_posted_blob_to_asset(mock_fa)
+      helper.add_posted_blob_to_asset(mock_fa,mock_file)
     end
     
     it "should support submissions from swfupload" do
       mock_file = mock("File")
       file_name = "Posted Filename.foo"
-      helper.stubs(:params).returns( :Filedata=>mock_file, :Filename=>file_name, "container_id"=>"hydrangea:2973" )      
+      helper.stubs(:params).returns( :Filedata=>[mock_file], :Filename=>file_name, "container_id"=>"hydrangea:2973" )      
       mock_fa = mock("file asset")
+      mock_file.expects(:original_filename).returns(file_name)
       mock_fa.expects(:add_file_datastream).with(mock_file, :label=>file_name, :mimeType=>"mymimetype")
       mock_fa.stubs(:set_title_and_label)
       helper.expects(:mime_type).with(file_name).returns("mymimetype")
-      helper.add_posted_blob_to_asset(mock_fa)
+      helper.add_posted_blob_to_asset(mock_fa,mock_file)
     end
     it "should support submissions from single-file uploader" do
       mock_file = mock("File")
       file_name = "Posted Filename.foo"
-      helper.expects(:filename_from_params).returns(file_name)
-      helper.stubs(:params).returns( :Filedata=>mock_file, :container_id=>"hydrangea:2973" )      
+#      helper.expects(:filename_from_params).returns(file_name)
+      helper.stubs(:params).returns( :Filedata=>[mock_file], :container_id=>"hydrangea:2973" )      
+      mock_file.expects(:original_filename).returns(file_name)
       mock_fa = mock("file asset")
       helper.expects(:mime_type).with(file_name).returns("mymimetype")
       mock_fa.expects(:add_file_datastream).with(mock_file, :label=>file_name, :mimeType=>"mymimetype")
       mock_fa.stubs(:set_title_and_label)
-      helper.add_posted_blob_to_asset(mock_fa)
+      helper.add_posted_blob_to_asset(mock_fa,mock_file)
     end
   end
   

data/test_support/spec/helpers/hydra_assets_helper_spec.rb

@@ -10,6 +10,9 @@ describe HydraAssetsHelper do
     end
     it "should generate login links with redirect params if user is not logged in" do
       helper.expects(:current_user).returns false
+      # rails 3.1.x
+      # helper.link_to_create_asset("Create a foo", "foo_model").should == "<a href=\"/users/sign_in?redirect_params%5Baction%5D=new&amp;redirect_params%5Bcontent_type%5D=foo_model&amp;redirect_params%5Bcontroller%5D=assets\" class=\"create_asset\">Create a foo</a>"      
+      # rails 3.0.x
       helper.link_to_create_asset("Create a foo", "foo_model").should == "<a href=\"/users/sign_in?redirect_params[action]=new&amp;redirect_params[content_type]=foo_model&amp;redirect_params[controller]=assets\" class=\"create_asset\">Create a foo</a>"      
     end
   end
@@ -17,7 +20,8 @@ describe HydraAssetsHelper do
   describe "delete_asset_link" do
     it "should generate a delete link and confirmation dialog" do
       generated_html = helper.delete_asset_link("__PID__", "whizbang")
-      generated_html.should have_selector "a.delete_asset[href='/catalog/__PID__/delete']", :content=> "Delete this whizbang" 
+                                          # "a.delete_asset[href='/catalog/__PID__/delete']", :content=> "Delete this whizbang" 
+      generated_html.should have_selector "a.delete_asset_link[href='/catalog/__PID__/delete']", :content=> "Delete this whizbang" 
       generated_html.should be_html_safe
 #      generated_html.should have_tag 'a.inline[href=#delete_dialog]',  "Delete this whizbang"
 #      generated_html.should have_tag 'div#delete_dialog' do

data/test_support/spec/helpers/hydra_djatoka_helper_spec.rb

@@ -24,7 +24,9 @@ describe HydraDjatokaHelper do
       mock_doc = mock("document")
       mock_doc.expects(:kind_of?).with(SolrDocument).returns(true)
       mock_doc.expects(:id).returns("myPid")
-
+      # rails 3.1.x
+      # hydra_djatoka_url_for(mock_doc, :scale=>"90").should == "/get/myPid.jp2?image_server%5Bscale%5D=90"
+      # rails 3.0.x
       hydra_djatoka_url_for(mock_doc, :scale=>"90").should == "/get/myPid.jp2?image_server[scale]=90"
     end
   end