atrium 0.0.1.alpha

data/test_support/spec/controllers/atrium/showcases_controller_spec.rb

@@ -0,0 +1,185 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Atrium::ShowcasesController do
+   before do
+     @collection = mock("atrium_collection")
+     controller.stubs(:initialize_collection).returns(@collection)
+     controller.stubs(:current_layout).returns("atrium")
+   end
+
+  describe '#determine_collection_id' do
+    #before do
+    #  @description = Atrium::Description.new(:atrium_showcase_id=>@collection_showcase.id)
+    #  @description.save
+    #  @collection_showcase.stub(:parent).returns(@collection)
+    #end
+    it 'should return collection id of collection showcase from params ' do
+      collection = Atrium::Collection.new
+      collection.save
+      showcase = Atrium::Showcase.new(:showcases_id=> collection.id, :showcases_type=>collection.class.name)
+      showcase.save
+      Atrium::Showcase.stubs(:find).with("1").returns(showcase)
+      controller.params[:id] = '1'
+      collection_id=controller.send(:determine_collection_id)
+      collection_id.should == 1
+    end
+
+    it 'should return collection id of exhibit showcase from params ' do
+      collection = Atrium::Collection.new
+      collection.save
+      exhibit = Atrium::Exhibit.new(:atrium_collection_id=> collection.id, :set_number=>1)
+      exhibit.save
+      showcase = Atrium::Showcase.new(:showcases_id=> exhibit.id, :showcases_type=>exhibit.class.name)
+      showcase.save
+      Atrium::Showcase.stubs(:find).with("1").returns(showcase)
+      showcase.stubs(:parent).returns(exhibit)
+      #showcase.should_receive(:parent).and_return(exhibit)
+      controller.params[:id] = '1'
+      collection_id=controller.send(:determine_collection_id)
+      collection_id.should == 1
+    end
+
+    it 'return nil if exhibit id not available in params' do
+      collection_id=controller.send(:determine_collection_id)
+      collection_id.should == nil
+    end
+  end
+
+  describe "Get New"   do
+    before do
+      @collection = mock("atrium_collection")
+      @exhibit = mock("atrium_exhibit")
+      @showcase = mock("atrium_showcase")
+      @showcase.stubs(:showcases_id).returns(1)
+      @showcase.stubs(:build).returns(@showcase)
+      @showcase.stubs(:showcases_id).returns(1)
+      Atrium::Collection.stubs(:find_by_id).returns(@collection)
+      Atrium::Exhibit.stubs(:find_by_id).returns(@exhibit)
+    end
+    it "create showcase for collection" do
+      Atrium::Showcase.expects(:with_selected_facets).returns([])
+      @collection.expects(:showcases).returns(@showcase)
+      @showcase.stubs(:for_exhibit?).returns(false)
+      @showcase.expects(:save!)
+      xhr :get, :new, {:collection_id => 1}
+      session[:edit_showcase].should == true
+      response.should redirect_to atrium_collection_showcase_path(1,@showcase.id)
+    end
+    it "create showcase for exhibit" do
+      Atrium::Showcase.expects(:with_selected_facets).returns([])
+      @showcase.stubs(:for_exhibit?).returns(true)
+      @exhibit.expects(:showcases).returns(@showcase)
+      @showcase.expects(:save!)
+      xhr :get, :new, {:exhibit_id => 1}
+      session[:edit_showcase].should == true
+      response.should redirect_to atrium_exhibit_path(1)
+    end
+    it "return existing showcase for collection" do
+      Atrium::Showcase.expects(:with_selected_facets).returns([@showcase])
+      @showcase.expects(:for_exhibit?).returns(false)
+      xhr :get, :new, {:collection_id => 1}
+      assigns[:atrium_showcase].should == @showcase
+    end
+    it "show redirect to collection page" do
+      Atrium::Showcase.expects(:with_selected_facets).returns([@showcase])
+      @showcase.expects(:for_exhibit?).returns(false)
+      xhr :get, :new, {:collection_id => 1}
+      session[:edit_showcase].should == true
+      response.should redirect_to atrium_collection_showcase_path(1,@showcase.id)
+    end
+  end
+
+
+  describe "Get Show"  do
+    it "should assign showcase to mocked showcase" do
+      session[:folder_document_ids]=nil
+      @showcase = mock("atrium_showcase")
+      Atrium::Showcase.stubs(:find).returns(@showcase)
+      @showcase.stubs(:showcase_items=).returns({})
+      @showcase.stubs(:showcase_items).returns({})
+      @showcase.expects(:save)
+      get :show, {:id=>1}
+      assigns[:atrium_showcase].should == @showcase
+    end
+    it "redirect to show view when featured items are not selected" do
+      session[:folder_document_ids]=nil
+      @showcase = mock("atrium_showcase")
+      Atrium::Showcase.stubs(:find).returns(@showcase)
+      @showcase.stubs(:showcase_items=).returns({})
+      @showcase.stubs(:showcase_items).returns({})
+      @showcase.expects(:save)
+      get :show, {:id=>1}
+      response.should render_template 'layouts/atrium'
+      response.should render_template("show")
+    end
+    it "should not assign layout when params is passed" do
+      session[:folder_document_ids]=nil
+      @showcase = mock("atrium_showcase")
+      @showcase.stubs(:showcase_items=).returns({})
+      @showcase.stubs(:showcase_items).returns({})
+      @showcase.expects(:save)
+      Atrium::Showcase.stubs(:find).returns(@showcase)
+      get :show, { :id => "1", :no_layout=>true }
+      response.should_not render_template 'layouts/atrium'
+      response.should render_template("show")
+    end
+
+    it "save session documents to showcase showcase_items" do
+      @showcase = Atrium::Showcase.new({:showcases_id=>1, :showcases_type=>"Atrium::Collection"})
+      @showcase.save!
+      Atrium::Showcase.stubs(:find).returns(@showcase)
+      #@showcase.expects(:save)
+      session[:folder_document_ids]=["1", "2", "3"]
+      get :show, { :id => 1, :no_layout=>true }
+      assigns[:atrium_showcase].should == @showcase
+      response.should_not render_template 'layouts/atrium'
+      response.should render_template("show")
+    end
+  end
+
+  describe "Get featured" do
+    before do
+      session[:folder_document_ids]=nil
+      @showcase = mock("atrium_showcase")
+      Atrium::Showcase.stubs(:find).with("1").returns(@showcase)
+    end
+
+    it "set session documents to showcase featured items  solr documents if present" do
+      @showcase.stubs(:showcase_items).returns(nil)
+      @showcase.stubs(:parent).returns(nil)
+      get :featured, {:id => "1"}
+      response.should redirect_to(catalog_index_path(:add_featured=>true, :search_field=>"all_fields"))
+    end
+
+    it "set session documents to exhibit filter query params  solr documents if present" do
+      @showcase.stubs(:showcase_items).returns({:solr_doc_ids=>"1,2,3"})
+      @showcase.stubs(:parent).returns(nil)
+      get :featured, {:id => "1"}
+      session[:folder_document_ids] == ["1", "2", "3"]
+    end
+  end
+
+  describe "Get refresh_showcase" do
+    before do
+      @showcase = mock("atrium_showcase")
+     Atrium::Showcase.stubs(:find).returns(@showcase)
+    end
+    it "should return collection path for collection showcase" do
+      @showcase.expects(:showcases_id).returns(1)
+      @showcase.stubs(:for_exhibit?).returns(false)
+      get :refresh_showcase, {:id=>1}
+      assigns[:atrium_showcase].should == @showcase
+      session[:edit_showcase].should be_nil
+      response.should redirect_to atrium_collection_path(1)
+    end
+    it "should return exhibit path for exhibit showcase" do
+      @showcase.expects(:showcases_id).returns(1)
+      @showcase.stubs(:for_exhibit?).returns(true)
+      get :refresh_showcase, {:id=>1, :f=>{"continent"=>["North America"]}}
+      assigns[:atrium_showcase].should == @showcase
+      session[:edit_showcase].should be_nil
+      response.should redirect_to atrium_exhibit_path(1, :f=>{"continent"=>["North America"]})
+    end
+  end
+
+end

data/test_support/spec/helpers/atrium_collections_helper_spec.rb

@@ -0,0 +1,147 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Atrium::CollectionsHelper do
+
+  before(:each) do
+    @collection = Atrium::Collection.new
+  end
+
+  after(:each) do
+    begin
+      @collection.delete
+    rescue
+    end
+  end
+  describe "get_collections_list" do
+    it "should call find with all on Atrium::Collection class" do
+      Atrium::Collection.expects(:find).with(:all)
+      helper.get_collections_list
+    end
+  end
+
+  describe "edit_collection_link" do
+    it "should return properly formatted edit collection link" do
+      helper.stubs(:params).returns({:controller=>"atrium_collections", :id=>"my_collection_id"})
+      helper.edit_collection_link.should == "/atrium/collections/my_collection_id/edit?render_search=false"
+      helper.stubs(:params).returns({:collection_id=>"my_collection_id"})
+      helper.edit_collection_link.should == "/atrium/collections/my_collection_id/edit?render_search=false"
+      helper.edit_collection_link("my_class").should == "/atrium/collections/my_collection_id/edit?class=my_class&render_search=false"
+    end
+  end
+
+  describe "browse_collection_link" do
+    it "should return properly formatted browse collection link" do
+      helper.stubs(:params).returns({:controller=>"atrium_collections",:id=>"my_collection_id"})
+      helper.browse_collection_link.should == "/atrium/collections/my_collection_id"
+      helper.stubs(:params).returns({:collection_id=>"my_collection_id"})
+      helper.browse_collection_link.should == "/atrium/collections/my_collection_id"
+    end
+  end
+
+  describe "add_browse_facet_params" do
+    it "should return a params hash with a field pointing to an array with the new value" do
+      p = HashWithIndifferentAccess.new
+      helper.add_browse_facet_params(:test, "testing", p).should == {"f"=>{"test"=>["testing"]}}
+      #test if p is nil
+      helper.add_browse_facet_params(:test, "testing").should == {"f"=>{"test"=>["testing"]}}
+    end
+  end
+
+  describe "get_browse_facet_path" do
+    before do
+      catalog_facet_params = HashWithIndifferentAccess.new({:q => "query",
+                :search_field => "search_field",
+                :f => {"facet_field_1" => ["value1"], "facet_field_2" => ["value2", "value2a"]},
+                :exhibit_id => 'exhibit_PID',
+                :collection_id => 'collection_PID',
+                :controller => "catalog"
+      })
+      helper.stubs(:params).returns(catalog_facet_params)
+    end
+    it "should redirect to exhibit action" do
+      response = CGI::unescape(helper.get_browse_facet_path("facet_solr_field", "item_value", ["facet_field_1","facet_field_2"], "exhibit_number", "exhibit_id"))
+      response.should == "/atrium/exhibits/exhibit_id?class=browse_facet_select&collection_id=collection_PID&f[facet_field_1][]=value1&f[facet_field_2][]=value2&f[facet_field_2][]=value2a&f[facet_solr_field][]=item_value"
+    end
+
+    it "if an item is selected and generating a path for alternate selection at the same level then the path should not include any child facet selections that may exist" do
+      catalog_facet_params = {:q => "query",
+                :search_field => "search_field",
+                :f => {"facet_field_1" => ["value1"], "facet_field_2" => ["value2a"]},
+                :exhibit_id => 'exhibit_PID',
+                :collection_id => 'collection_PID',
+                :controller => "catalog"
+      }
+      helper.stubs(:params).returns(catalog_facet_params)
+      # browse level data to work with.....
+      # browse_level_data = [{:solr_facet_name=>"facet_field_1",:label=>"my_label",:selected=>"value1",:values=>["value1","value1a","value1b"]},
+      #                     {:solr_facet_name=>"facet_field_2",:label=>"my_label2",:selected=>"value2a",:values=>["value2","value2a"]}]
+      #test making link for something not currently selected that should have child facet selection removed
+      browse_facets = ["facet_field_1","facet_field_2"]
+      response = CGI::unescape(helper.get_browse_facet_path("facet_field_1","value1a",browse_facets,"exhibit_number", "exhibit_id"))
+      response.should == "/atrium/exhibits/exhibit_id?class=browse_facet_select&collection_id=collection_PID&f[facet_field_1][]=value1a"
+    end
+  end
+
+  describe "get_selected_browse_facet_path" do
+    before do
+      @catalog_facet_params = {
+                :f => {"facet_field_1" => ["value1"], "facet_field_2" => ["value2", "value2a"]},
+                :id => 'exhibit_PID',
+                :controller => "atrium/exhibits",
+                :collection_id => 'collection_PID',
+                :action=>"show"
+      }
+      helper.stubs(:params).returns(@catalog_facet_params)
+    end
+    it "should redirect to exhibit action" do
+      helper.stubs(:params).returns(@catalog_facet_params)
+      item = {"facet_field" => ["facet_value"]}
+      item.stubs(:value).returns(["value1"])
+      #helper.stubs(:remove_facet_params).returns({"f" => {"facet_field_1" => ["value1"], "facet_field_2" => ["value2", "value2a"]},
+      #          "id" => 'collection_PID',
+      #          "controller" => "atrium/collections"
+      #})
+      response = CGI::unescape(helper.get_selected_browse_facet_path("facet_field_1", item, ["facet_field_1", "browse_facet"],"exhibit_number", "exhibit_id"))
+      #all browse facets should be removed since at the top, and the only current facet in the params is facet_field_1, so facet_field_2 stays
+      response.should == "/atrium/exhibits/exhibit_id?collection_id=collection_PID&f[facet_field_2][]=value2&f[facet_field_2][]=value2a"
+    end
+  end
+
+  describe "get_selected_browse_facets" do
+    before do
+      @catalog_facet_params = {
+                :f => {"facet_field_1" => ["value1"], "facet_field_2" => ["value2", "value2a"]},
+                :id => 'exhibit_PID',
+                :controller => "atrium/exhibits",
+                 :action=>"show"
+      }
+      helper.stubs(:params).returns(@catalog_facet_params)
+    end
+    it "should return a hash of selected facet mapped to value not in array" do
+      browse_facets = ["facet_field_1","facet_field_2","facet_field_3"]
+      helper.get_selected_browse_facets(browse_facets).should == {:facet_field_1=>"value1",:facet_field_2=>"value2"}
+    end
+  end
+
+  describe "remove_related_facet_params" do
+    before(:each) do
+      @params = {
+                :f => {:facet_field_1 => ["value1"], :facet_field_2 => ["value2"], :facet_field_4=>["value4"]}
+      }
+      @browse_facets = [:facet_field_1,:facet_field_2,:facet_field_3]
+      helper.stubs(:params).returns(@params)
+    end
+    it "should return a params hash with a selected facet field removed" do
+      helper.remove_related_facet_params(:facet_field_2,@params,@browse_facets,"1").should == {:f=>{:facet_field_1 => ["value1"],:facet_field_4=>["value4"]}}
+    end
+
+     it "should remove any lower selected facets if parent facet is removed" do
+      helper.remove_related_facet_params(:facet_field_1,@params,@browse_facets,"1").should == {:f=>{:facet_field_4=>["value4"]}}
+    end
+
+    it "should ignore one that is not a browse facet" do
+      helper.remove_related_facet_params(:facet_field_4,@params,@browse_facets,"1").should == {:f=>{:facet_field_1 => ["value1"], :facet_field_2 => ["value2"], :facet_field_4=>["value4"]}}
+    end
+  end
+
+end

data/test_support/spec/helpers/atrium_description_helper_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+Blacklight::SolrHelper.stubs(:class_inheritable_accessor)
+include Blacklight::SolrHelper
+
+describe Atrium::DescriptionsHelper do
+
+  before(:each) do
+    @collection = Atrium::Collection.new
+    @collection.save
+    @collection_showcase = Atrium::Showcase.new(:showcases_id=>@collection.id, :showcases_type=>@collection.class.name)
+    @collection_showcase.save
+    @exhibit = Atrium::Exhibit.new
+    @exhibit_showcase = Atrium::Showcase.new(:showcases_id=>@exhibit.id, :showcases_type=>@exhibit.class.name)
+    @exhibit_showcase.save
+
+  end
+
+  after(:each) do
+    begin
+      @collection.delete
+      @collection_showcase.delete
+    rescue
+    end
+    begin
+      @exhibit.delete
+      @exhibit_showcase.delete
+    rescue
+    end
+  end
+
+  describe "get_description_for_showcase" do
+    it "return description hash from solr for any given collection" do
+      helper.stubs(:showcase).returns(@collection_showcase)
+      description_hash=helper.get_description_for_showcase(@collection_showcase)
+      description_hash.size.should == 0
+    end
+
+    it "returns description details from solr for given showcase" do
+      @description = Atrium::Description.new(:atrium_showcase_id=>@collection_showcase.id)
+      @description.save!
+      @description.update_attributes({:description_solr_id=>"RBSC-CURRENCY:715"})
+      helper.expects(:get_solr_response_for_field_values).with("id",["RBSC-CURRENCY:715"]).returns([[:docs => ["id"=>"RBSC-CURRENCY:715", "title_t"=>["title"],"description_content_s"=>["description content"]]],["id"=>"RBSC-CURRENCY:715", "title_t"=>["title"],"description_content_s"=>["description content"]]])
+      helper.get_description_for_showcase(@collection_showcase)
+    end
+  end
+end

data/test_support/spec/helpers/atrium_solr_helper_spec.rb

@@ -0,0 +1,512 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+Blacklight::SolrHelper.stubs(:class_inheritable_accessor)
+include Blacklight::SolrHelper
+
+describe Atrium::SolrHelper do
+
+  before(:each) do
+    @collection = Atrium::Collection.new
+    @collection.save
+  end
+
+  after(:each) do
+    begin
+      @collection.delete
+    rescue
+    end
+    begin
+      @exhibit.delete
+    rescue
+    end
+  end
+
+  describe "initialize_collection" do
+    before(:each) do
+      helper.stubs(:get_all_children).returns([])
+    end
+    it "atrium_collection should be nil if both :id (if atrium_collections controller) and :collection_id not in params" do
+      helper.stubs(:params).returns({:id=>"test_id"})
+      helper.__initialize_collection(nil)
+      helper.atrium_collection.should == nil
+      #helper.stubs(:params).returns({:controller=>"atrium_collections",:collection_id=>"test_id"})
+      #helper.atrium_collection.should == nil
+    end
+
+    it "should raise an exception if the collection_id passed in does not exist" do
+      helper.expects(:params).returns({:id=>"test_id",:controller=>"atrium_collections"})
+      #these only get called once if an collection is found
+      helper.expects(:build_lucene_query).returns("_query_:id\:test_id")
+      helper.expects(:get_search_results)
+      @collection.save!
+      logger.expects(:error).twice
+      helper.__initialize_collection("test_id")
+      #check valid case as well
+      helper.expects(:params).returns({:id=>@collection.id,:controller=>"atrium_collections"})
+      helper.__initialize_collection(@collection.id)
+    end
+
+    it "should configure params correctly if facet selected and facet in filter" do
+      helper.stubs(:params).returns({:collection_id=>"test_id",:f=>{"continent"=>["North America"]}})
+      @collection.filter_query_params = {:q=>"testing",:f=>{"season"=>["spring"]}}
+      Atrium::Collection.expects(:find).with("test_id").returns(@collection)
+      helper.expects(:solr_search_params).with(@collection.filter_query_params).returns(:q=>"testing",:fq=>["{!raw f=season_facet}Spring"]).at_least_once
+      helper.expects(:solr_search_params).with({:collection_id=>"test_id",:f=>{"continent"=>["North America"]}}).returns(:fq=>["{!raw f=continent}North America"])
+      #it will combine param facet and filter facet into extra params so that the params facets are not overwritten when the filter facet is applied
+      extra_params = {:q=>"testing", :fq=>["{!raw f=continent}North America","{!raw f=season_facet}Spring"]}
+      helper.expects(:get_search_results).with({:collection_id=>"test_id",:f=>{"continent"=>["North America"]}},extra_params)
+      helper.__initialize_collection("test_id")
+    end
+
+    it "should configure params correctly if facet selected and no facet in filter" do
+      helper.stubs(:params).returns({:collection_id=>"test_id",:f=>{"continent"=>["North America"]}})
+      @collection.filter_query_params = {:q=>"testing"}
+      Atrium::Collection.expects(:find).with("test_id").returns(@collection)
+      helper.expects(:prepare_extra_controller_params_for_collection_query).returns(:q=>"testing")
+      helper.expects(:reset_extra_controller_params_after_collection_query).returns(:fq=>["{!raw f=continent}North America"])
+      #it will combine param facet and filter facet into extra params so that the params facets are not overwritten when the filter facet is applied
+      extra_params = {:q=>"testing"}
+      helper.expects(:get_search_results).with({:collection_id=>"test_id",:f=>{"continent"=>["North America"]}},extra_params)
+      helper.__initialize_collection("test_id")
+    end
+
+    it "should configure params correctly if facet selected with same facet in filter" do
+      helper.stubs(:params).returns({:collection_id=>"test_id",:f=>{"continent"=>["North America"]}})
+      @collection.filter_query_params = {:q=>"testing",:f=>{"continent"=>["North America"]}}
+      Atrium::Collection.expects(:find).with("test_id").returns(@collection)
+      helper.expects(:prepare_extra_controller_params_for_collection_query).returns(:q=>"testing",:fq=>["{!raw f=continent}North America"])
+      helper.expects(:reset_extra_controller_params_after_collection_query).returns(:fq=>["{!raw f=continent}North America"])
+      #it will combine param facet and filter facet into extra params so that the params facets are not overwritten when the filter facet is applied
+      extra_params = {:q=>"testing", :fq=>["{!raw f=continent}North America"]}
+      helper.expects(:get_search_results).with({:collection_id=>"test_id",:f=>{"continent"=>["North America"]}},extra_params)
+      helper.__initialize_collection("test_id")
+    end
+  end
+
+  describe "get_exhibit_navigation_data" do
+    it "if atrium collection still nil after calling initialize collection than should return empty array" do
+      helper.expects(:initialize_collection).returns(nil)
+      helper.expects(:params).returns({:collection_id=>"test_id"})
+      Atrium::Collection.expects(:find).with("test_id").returns(nil)
+      helper.expects(:get_browse_level_data).returns([])
+      helper.get_exhibit_navigation_data.should == []
+    end
+
+    it "if no atrium collection exhibits it should return an empty array" do
+      collection = mock()
+      collection.stubs(:exhibits).returns([])
+      helper.stubs(:atrium_collection).returns(collection)
+      helper.stubs(:check_for_scope).returns(false)
+      helper.get_exhibit_navigation_data.should == []
+    end
+
+    it "if atrium collection is not nil and has exhibits it should call get browse level data for each browse set" do
+      collection = Atrium::Collection.new
+      collection.save
+      collection.stubs(:exhibits).returns([])
+      helper.stubs(:atrium_collection).returns(collection)
+      exhibit1 = Atrium::Exhibit.new({:atrium_collection_id=>collection.id,:set_number=>1})
+      exhibit1.save
+      exhibit2 = Atrium::Exhibit.new({:atrium_collection_id=>collection.id,:set_number=>2})
+      exhibit2.save
+      browse_level1 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>exhibit1.id,:solr_facet_name=>"my_facet",:label=>"my_label"})
+      browse_level2 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>exhibit2.id,:solr_facet_name=>"my_facet2",:label=>"my_label2"})
+      browse_level3 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>exhibit2.id,:solr_facet_name=>"my_facet3",:label=>"my_label3"})
+      exhibit1.stubs(:browse_levels).returns([browse_level1])
+      exhibit2.stubs(:browse_levels).returns([browse_level2,browse_level3])
+      collection.expects(:exhibits).returns([exhibit1,exhibit2]).at_least_once
+      browse_response = mock()
+      helper.stubs(:browse_response).returns(browse_response)
+      extra_con_params = mock()
+      helper.stubs(:current_extra_controller_params).returns(extra_con_params)
+      updated_browse_level1 = browse_level1.clone
+      updated_browse_level1.expects(:values).returns(["test1","test2"])
+      updated_browse_level1.expects(:selected).returns("test1")
+      updated_browse_level2 = browse_level2.clone
+      updated_browse_level2.expects(:values).returns(["test3","test4"])
+      helper.expects(:get_browse_level_data).with(collection,exhibit1,[browse_level1],browse_response,extra_con_params,true).returns([updated_browse_level1])
+      helper.expects(:get_browse_level_data).with(collection,exhibit2,[browse_level2,browse_level3],browse_response,extra_con_params,true).returns([updated_browse_level2,browse_level3])
+      #check that the array returned is flattened appropriately on concat
+      browse_data = helper.get_exhibit_navigation_data
+      browse_data.size.should == 2
+      #order is important here for both browse sets and esp. nested levels
+      browse_data.first.should == exhibit1
+      browse_data.second.should == exhibit2
+      browse_data.first.browse_levels.first.values.should == ["test1","test2"]
+      browse_data.first.browse_levels.first.selected.should == "test1"
+      browse_data.second.browse_levels.first.values.should == ["test3","test4"]
+      browse_data.second.browse_levels.first.selected.should == nil
+      #for the other browse level of the second browse set values should be empty since nothing selected in parent
+      browse_data.second.browse_levels.second.values.should == []
+    end
+  end
+
+  describe "get_browse_level_data" do
+    it "should return an array of exhibit objects with browse levels objects sorted by level number if any defined" do
+      @exhibit = Atrium::Exhibit.new({:atrium_collection_id=>@collection.id,:set_number=>1})
+      @exhibit.save
+      @exhibit2 = Atrium::Exhibit.new({:atrium_collection_id=>@collection.id,:set_number=>2})
+      @exhibit2.save
+      helper.expects(:facet_field_labels).returns("my_label").times(3)
+      #label will be nil
+      browse_level1 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit.id,:solr_facet_name=>"my_facet", :level_number=>1})
+      browse_level1.save
+      browse_level2 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit.id,:solr_facet_name=>"my_facet2", :level_number=>2})
+      browse_level2.save
+      @exhibit.stubs(:browse_levels).returns([browse_level1,browse_level2])
+      browse_level3 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit2.id,:solr_facet_name=>"my_facet2", :level_number=>1})
+      browse_level3.save
+      browse_level4 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit2.id,:solr_facet_name=>"my_facet3", :level_number=>2})
+      browse_level4.save
+      @exhibit2.stubs(:browse_levels).returns([browse_level3,browse_level4])
+      @collection.expects(:exhibits).returns([@exhibit,@exhibit2]).at_least_once
+      helper.expects(:atrium_collection).returns(@collection).at_least_once
+      
+      browse_response = mock()
+      facet1 = mock()
+      facet2 = mock()
+      facet3 = mock()
+      item1 = mock()
+      item2 = mock()
+      item3 = mock()
+      item4 = mock()
+      item5 = mock()
+      
+      item1.expects(:value).returns("val1").at_least_once
+      item2.expects(:value).returns("val2").at_least_once
+      item3.expects(:value).returns("val3").at_least_once
+      item4.expects(:value).returns("val4").at_least_once
+      item5.expects(:value).returns("val5").at_least_once
+
+      facet1.expects(:items).returns([item1,item2]).at_least_once
+      facet1.expects(:name).returns("my_facet").at_least_once
+      facet2.expects(:items).returns([item3,item4,item5]).at_least_once
+      facet2.expects(:name).returns("my_facet2").at_least_once
+      browse_response.expects(:facets).returns([facet1,facet2,facet3]).at_least_once
+      helper.stubs(:browse_response).returns(browse_response)
+      helper.expects(:facet_in_params?).returns(false).at_least_once
+      #this will make it have something be selected
+      helper.expects(:facet_in_params?).with('my_facet','val2').returns(true)
+      helper.stubs(:get_search_results).returns([browse_response,mock()])
+
+      browse_data = helper.get_exhibit_navigation_data
+      browse_data.size.should == 2
+      browse_data.first.should == @exhibit
+      browse_data.second.should == @exhibit2
+
+      browse_data.first.browse_levels.first.should == browse_level1
+      browse_data.first.browse_levels.second.should == browse_level2
+      browse_data.second.browse_levels.first.should == browse_level3
+      browse_data.second.browse_levels.second.should == browse_level4
+
+      browse_data.first.browse_levels.first.values.should == ["val1","val2"]
+      browse_data.first.browse_levels.second.values.should == ["val3","val4","val5"]
+      browse_data.second.browse_levels.first.values.should == ["val3","val4","val5"]
+      browse_data.second.browse_levels.second.values.should == []
+
+      browse_data.first.browse_levels.first.selected.should == "val2"
+      browse_data.first.browse_levels.second.selected.should == nil
+      browse_data.second.browse_levels.first.selected.should == nil
+      browse_data.second.browse_levels.second.selected.should == nil
+    end
+
+    it "should use the blacklight facet field label if no label defined in a browse level" do
+      #must have a browse set and collection not nil
+      @collection.save
+      @exhibit = Atrium::Exhibit.new({:atrium_collection_id=>@collection.id,:set_number=>1})
+      @exhibit.save
+      #add a browse level with label nil
+      browse_level = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit.id,:solr_facet_name=>"my_facet",:level_number=>1})
+      @exhibit.expects(:browse_levels).returns([browse_level]).at_least_once
+      @collection.expects(:exhibits).returns([@exhibit]).at_least_once
+      helper.stubs(:atrium_collection).returns(@collection)
+      helper.expects(:facet_field_labels).returns({"my_facet"=>"my_label"}).times(2)
+      #response must have facet for this level
+      response = mock()
+      facet = mock()
+      facet.expects(:name).returns("my_facet").times(4)
+      #no items in facet to skip calling get_browse_set_data
+      facet.expects(:items).returns([]).twice
+      response.expects(:facets).returns([facet]).times(4)
+      helper.stubs(:browse_response).returns(response)
+      helper.stubs(:get_search_results).returns([response,mock()])
+      browse_data = helper.get_exhibit_navigation_data
+      browse_data.first.browse_levels.first.label.should == "my_label"
+      #check if label is blank instead
+      browse_level.label = ""
+      browse_data = helper.get_exhibit_navigation_data
+      browse_data.first.browse_levels.first.label.should == "my_label"
+    end
+
+    it "should use the label in a browse level if defined" do
+      helper.expects(:facet_field_labels).returns("my_label").times(0)
+      #must have a browse set and collection not nil
+      @collection.save
+      @exhibit = Atrium::Exhibit.new({:atrium_collection_id=>@collection.id,:set_number=>1})
+      @exhibit.save
+      browse_level = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit.id,:solr_facet_name=>"my_facet",:label=>"my_label_2"})
+      @exhibit.expects(:browse_levels).returns([browse_level]).at_least_once
+      @collection.expects(:exhibits).returns([@exhibit]).at_least_once
+      helper.stubs(:atrium_collection).returns(@collection)
+      response = mock()
+      facet = mock()
+      facet.expects(:items).returns([]).at_least_once
+      facet.expects(:name).returns("my_facet").at_least_once
+      response.expects(:facets).returns([facet]).at_least_once
+      helper.stubs(:browse_response).returns(response)
+      helper.stubs(:get_search_results).returns([response,mock()])
+      helper.get_exhibit_navigation_data.first.browse_levels.first.label.should == "my_label_2"
+    end
+
+    it "if no f param is defined it should set the response without f param to be response" do
+      #if they are the same then response.facets should be called twice
+      @collection.save
+      @exhibit = Atrium::Exhibit.new({:atrium_collection_id=>@collection.id,:set_number=>1})
+      @exhibit.save
+      browse_level = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit.id,:solr_facet_name=>"my_facet",:label=>"my_label"})
+      @exhibit.expects(:browse_levels).returns([browse_level]).at_least_once
+      @collection.expects(:exhibits).returns([@exhibit]).at_least_once
+      helper.stubs(:atrium_collection).returns(@collection)
+      response = mock()
+      facet = mock()
+      facet.expects(:name).returns("other_facet").at_least_once
+      #it will call this twice if response is same for without f param
+      response.expects(:facets).returns([facet]).twice
+      helper.expects(:browse_response).returns(response)
+      helper.stubs(:get_search_results).returns([response,mock()])
+      helper.get_exhibit_navigation_data
+    end
+
+    it "if multiple browse levels defined and f defined for anything but top level it should only have values set for the top level" do
+      #must have a browse set and collection not nil
+      @collection.save
+      @exhibit = Atrium::Exhibit.new({:atrium_collection_id=>@collection.id,:set_number=>1})
+      @exhibit.save
+      #add a browse level with label nil
+      browse_level1 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit.id,:solr_facet_name=>"my_facet",:level_number=>1})
+      browse_level2 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit.id,:solr_facet_name=>"my_facet2",:level_number=>2})
+      @exhibit.expects(:browse_levels).returns([browse_level1,browse_level2]).at_least_once
+      @collection.expects(:exhibits).returns([@exhibit]).at_least_once
+      helper.stubs(:atrium_collection).returns(@collection)
+      
+      #put something in params different from our facet, use facet at second level but should be ignored
+      helper.expects(:params).returns({:f=>{"my_facet2"=>["val3"]}}).at_least_once
+      facet1 = mock()
+      facet1.expects(:name).returns("my_facet").at_least_once
+      item1 = mock()
+      item1.expects(:value).returns("val1").at_least_once
+      item2 = mock()
+      item2.expects(:value).returns("val2").at_least_once
+      item3 = mock()
+      item3.stubs(:value).returns("val3")
+      facet1.expects(:items).returns([item1,item2]).at_least_once
+      facet2 = mock()
+      facet2.expects(:name).returns("my_facet2").at_least_once
+      #stub so it can be called but not necessarily expected
+      facet2.stubs(:items).returns([item3])
+      response = mock()
+      response.expects(:facets).returns([facet2,facet1]).at_least_once
+      helper.expects(:browse_response).returns(response)
+      helper.expects(:facet_field_labels).returns("my_label")
+      helper.expects(:get_search_results).returns([response,mock()])
+      browse_data = helper.get_exhibit_navigation_data
+      browse_data.first.browse_levels.first.values.should == ["val1","val2"]
+      browse_data.first.browse_levels.first.selected.should == nil
+      browse_data.first.browse_levels.second.values.should == []
+      browse_data.first.browse_levels.second.selected.should == nil
+    end
+
+    it "if 3 browse levels defined and two items selected in each browse level then it should return 2 browse levels with values" do
+      #must have a browse set and collection not nil
+      @collection.save
+      @exhibit = Atrium::Exhibit.new({:atrium_collection_id=>@collection.id,:set_number=>1})
+      @exhibit.save
+      #add a browse level with label nil
+      browse_level1 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit.id,:solr_facet_name=>"my_facet",:level_number=>1})
+      browse_level2 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit.id,:solr_facet_name=>"my_facet2",:level_number=>2})
+      browse_level3 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit.id,:solr_facet_name=>"my_facet3",:level_number=>3})
+      @exhibit.expects(:browse_levels).returns([browse_level1,browse_level2,browse_level3]).at_least_once
+      @collection.expects(:exhibits).returns([@exhibit]).at_least_once
+      helper.stubs(:atrium_collection).returns(@collection)
+      helper.expects(:params).returns({:collection_id=>@collection.id,:f=>{"my_facet"=>["my_val2"],"my_facet2"=>"my_val3"}}).at_least_once
+      helper.expects(:atrium_collection).returns(@collection)
+      facet = mock()
+      facet.expects(:name).returns("my_facet").at_least_once
+      item = mock()
+      item.expects(:value).returns("my_val").at_least_once
+      item2 = mock()
+      item2.expects(:value).returns("my_val2").at_least_once
+      facet.expects(:items).returns([item,item2]).at_least_once
+
+      facet2 = mock()
+      facet2.expects(:name).returns("my_facet2").at_least_once
+      item3 = mock()
+      item3.expects(:value).returns("my_val3").at_least_once
+      item4 = mock()
+      item4.expects(:value).returns("my_val4").at_least_once
+      facet2.expects(:items).returns([item3,item4]).at_least_once
+
+      facet3 = mock()
+      facet3.expects(:name).returns("my_facet3").at_least_once
+      item5 = mock()
+      item5.expects(:value).returns("my_val5").at_least_once
+      item6 = mock()
+      item6.expects(:value).returns("my_val6").at_least_once
+      facet3.expects(:items).returns([item5,item6]).at_least_once
+      response = mock()
+      response.expects(:facets).returns([facet2,facet,facet3]).at_least_once
+      helper.expects(:browse_response).returns(response)
+      helper.expects(:facet_field_labels).returns("my_label").at_least_once
+      helper.expects(:get_search_results).returns([response,mock()]).at_least_once
+      browse_data = helper.get_exhibit_navigation_data
+      browse_data.first.browse_levels.first.values.should == ["my_val","my_val2"]
+      browse_data.first.browse_levels.first.selected.should == "my_val2"
+      browse_data.first.browse_levels.second.values.should == ["my_val3","my_val4"]
+      browse_data.first.browse_levels.second.selected.should == "my_val3"
+      browse_data.first.browse_levels.fetch(2).values.should == ["my_val5","my_val6"]
+      browse_data.first.browse_levels.fetch(2).selected.should == nil
+    end
+
+    it "should ignore a facet that is not present" do
+      #must have a browse set and collection not nil
+      @collection.save
+      @exhibit = Atrium::Exhibit.new({:atrium_collection_id=>@collection.id,:set_number=>1})
+      @exhibit.save
+      #add a browse level with label nil
+      browse_level1 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit.id,:solr_facet_name=>"my_facet",:level_number=>1})
+      browse_level2 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit.id,:solr_facet_name=>"my_facet2",:level_number=>2})
+      @exhibit.expects(:browse_levels).returns([browse_level1,browse_level2]).at_least_once
+      @collection.expects(:exhibits).returns([@exhibit]).at_least_once
+      helper.stubs(:atrium_collection).returns(@collection)
+
+      helper.expects(:params).returns({:collection_id=>@collection.id,:f=>{"my_facet"=>["my_val2"],"my_facet2"=>["my_val3"]}}).at_least_once
+      facet = mock()
+      facet.expects(:name).returns("my_facet").at_least_once
+      item = mock()
+      item.expects(:value).returns("my_val").at_least_once
+      item2 = mock()
+      item2.expects(:value).returns("my_val2").at_least_once
+      facet.expects(:items).returns([item,item2]).at_least_once
+      response = mock()
+      response.expects(:facets).returns([facet]).at_least_once
+      helper.expects(:browse_response).returns(response)
+      helper.expects(:facet_field_labels).returns("my_label").at_least_once
+      helper.expects(:get_search_results).returns([response,mock()]).at_least_once
+      #second level facet not present so it should only return second level with no values even though first level has something selected
+      browse_data = helper.get_exhibit_navigation_data
+      browse_data.first.browse_levels.size.should == 2
+      browse_data.first.browse_levels.first.values.should == ["my_val","my_val2"]
+      browse_data.first.browse_levels.first.selected.should == "my_val2"
+      browse_data.first.browse_levels.second.values.should == []
+    end
+
+    it "if 2 browse levels defined and two items selected it should handle having something selected at the lowest browse level" do
+      #must have a browse set and collection not nil
+      @collection.save
+      @exhibit = Atrium::Exhibit.new({:atrium_collection_id=>@collection.id,:set_number=>1})
+      @exhibit.save
+      #add a browse level with label nil
+      browse_level1 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit.id,:solr_facet_name=>"my_facet",:level_number=>1})
+      browse_level2 = Atrium::BrowseLevel.new({:atrium_exhibit_id=>@exhibit.id,:solr_facet_name=>"my_facet2",:level_number=>2})
+      @exhibit.expects(:browse_levels).returns([browse_level1,browse_level2]).at_least_once
+      @collection.expects(:exhibits).returns([@exhibit]).at_least_once
+      helper.stubs(:atrium_collection).returns(@collection)
+
+      helper.expects(:params).returns({:collection_id=>@collection.id,:f=>{"my_facet"=>["my_val2"],"my_facet2"=>["my_val3"]}}).at_least_once
+      facet = mock()
+      facet.expects(:name).returns("my_facet").at_least_once
+      item = mock()
+      item.expects(:value).returns("my_val").at_least_once
+      item2 = mock()
+      item2.expects(:value).returns("my_val2").at_least_once
+      facet.expects(:items).returns([item,item2]).at_least_once
+      facet2 = mock()
+      facet2.expects(:name).returns("my_facet2").at_least_once
+      item3 = mock()
+      item3.expects(:value).returns("my_val3").at_least_once
+      item4 = mock()
+      item4.expects(:value).returns("my_val4").at_least_once
+      facet2.expects(:items).returns([item3,item4]).at_least_once
+      response = mock()
+      response.expects(:facets).returns([facet2,facet]).at_least_once
+      helper.expects(:browse_response).returns(response)
+      helper.expects(:facet_field_labels).returns("my_label").at_least_once
+      helper.expects(:get_search_results).returns([response,mock()]).at_least_once
+      browse_data = helper.get_exhibit_navigation_data
+      browse_data.first.browse_levels.size.should == 2
+      browse_data.first.browse_levels.first.values.should == ["my_val","my_val2"]
+      browse_data.first.browse_levels.first.selected.should == "my_val2"
+      browse_data.first.browse_levels.second.values.should == ["my_val3","my_val4"]
+      browse_data.first.browse_levels.second.selected.should == "my_val3"
+    end
+  end
+
+  describe "add_exclude_fq_to_solr" do
+    before(:each) do
+      @exclude_facets = {:test=>'exclude'}
+    end
+    self.solr_search_params_logic += [:add_exclude_fq_to_solr]
+    it "should have exclude solr parameters included in proper way" do
+      solr_params = solr_search_params(:exclude => @exclude_facets)
+      solr_params[:q].should be_blank
+      solr_params["spellcheck.q"].should be_blank
+      solr_params[:"facet.field"].should == blacklight_config[:default_solr_params][:"facet.field"]
+
+      @exclude_facets.each_value do |value|
+        solr_params[:fq].should include("-({!raw f=#{@exclude_facets.keys[0]}}#{value})")
+      end
+    end
+  end
+
+  describe "get_current_filter_query_params" do
+    self.solr_search_params_logic += [:add_exclude_fq_to_solr]
+    it "should return filters from collection in solr way" do
+      @collection.filter_query_params = {:q=>"testing",:f=>{"continent"=>["North America"]}}
+      filter_queries= get_current_filter_query_params(@collection,nil,nil)
+      filter_queries[:q].should == "testing"
+      filter_queries[:fq].should_not be_blank
+    end
+
+    it "should return filters from collection, exhibit and browse level in solr way" do
+      @collection.filter_query_params = {:q=>"testing",:f=>{"continent"=>["North America"]}}
+      exhibit=mock("atrium_exhibit")
+      exhibit.stubs(:filter_query_params).returns({:f=>{"format"=>["books"]}})
+      browse_level=mock("atrium_browse_level")
+      browse_level.stubs(:filter_query_params).returns({:f=>{"bl"=>["exhibit_level_1"]}})
+      ex_facet={:bl_exclude=>["disc"]}
+      browse_level.stubs(:exclude_query_params).returns({:exclude=>ex_facet})
+      filter_queries= get_current_filter_query_params(@collection,exhibit,browse_level)
+       ex_facet.each_value do |value|
+        filter_queries[:fq].should include("-({!raw f=#{ex_facet.keys[0]}}#{value})")
+       end
+      ##TODO need to test other filters in the same way as above test in different scenarios
+    end
+  end
+
+
+  describe "prepare_extra_controller_params_for_collection_query" do
+
+    it "should add collection query params with params to extra_controller_params" do
+      @collection.filter_query_params = {:q=>"testing",:f=>{"continent"=>["North America"]}}
+      helper.expects(:get_current_filter_query_params).returns({:q=>"testing", :fq=>["{!raw f=continent}North America"]})
+      extra_queries= prepare_extra_controller_params_for_collection_query(@collection,nil,nil,{:q=>"include params"},{})
+      extra_queries[:q].should == "testing AND include params"
+      extra_queries[:fq].should_not be_blank
+    end
+
+  end
+
+  describe "get_all_children" do
+    #TODO need to have solr running and process the real solr response for this test
+    #before do
+    #  @mock_response = mock()
+    #  @mock_response.stubs(:docs => [])
+    #  @mock_document = mock()
+    #  helper.expects(:get_solr_response_for_field_values).returns([@mock_response,@mock_document])
+    #end
+    #  it "should return document matching given relationship name" do
+    #    get_all_children([], "is_member_of")
+    #  end
+  end
+
+end