admin_data 1.0.11 → 1.0.12

data/test/functional/search_controller_test.rb

@@ -1,811 +0,0 @@
-require 'test_helper'
-
-pwd = File.dirname(__FILE__)
-f = File.join(pwd, '..', '..', 'app', 'views')
-AdminData::MainController.prepend_view_path(f)
-AdminData::SearchController.prepend_view_path(f)
-
-class AdminData::SearchControllerTest < ActionController::TestCase
-
-  def setup
-    AdminData::Config.set = { :adapter_name =>  ActiveRecord::Base.connection.adapter_name }
-    @controller = AdminData::SearchController.new
-    @request = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-    @article = Factory(:article)
-    @car = Factory(:car, :year => 2000, :brand => 'bmw')
-    grant_read_only_access
-  end
-
-  context 'GET quick_search' do
-    context 'GET quick_search with wrong children class' do
-      setup do
-        get :quick_search, {  :base => 'article', 
-                              :klass => 'comment',
-                              :model_id => @article.id, 
-                              :children => 'wrong_children_name' }
-      end
-      should_respond_with :not_found
-    end
-
-    context 'with no klass param' do
-      setup do
-        assert_raises ActionController::RoutingError do
-          get :quick_search
-        end
-      end
-    end
-
-    context 'with no search query' do
-      setup do
-        get :quick_search, {:klass => Article.name.underscore}
-      end
-      should_respond_with :success
-      should_assign_to :records
-    end
-    context 'with has_many association' do
-      context 'for a nested model' do
-        setup do
-          Vehicle::Door.delete_all
-          @door1 = Factory(:door, :color => 'black', :car => @car)
-          @door2 = Factory(:door, :color => 'green', :car => @car)
-          get :quick_search, {  :klass => @door1.class.name.underscore, 
-                                :base => @car.class.name.underscore, 
-                                :model_id => @car.id, 
-                                :children => 'doors'}
-        end
-        #should_respond_with :success
-        #should_assign_to :records
-        #should 'have 2 records' do
-          #assert_equal 2, assigns(:records).size
-        #end
-        #should 'have 2 as total number of children' do
-          #assert_equal 2, assigns(:total_num_of_children)
-        #end
-        #should 'contain text' do
-          #assert_tag(:tag => 'h2', :attributes => {:class => 'title'}, :content => /has 2/m)
-        #end
-      end
-
-      context 'for a standard model' do
-        setup do
-          @comment1 = Factory(:comment, :article => @article)
-          @comment2 = Factory(:comment, :article => @article)
-          get :quick_search, { :klass => Comment.name.underscore, 
-                                :base => 'article', 
-                                :model_id => @article.id.to_s, 
-                                :children => 'comments' }
-        end
-        should_respond_with :success
-        should_assign_to :records
-        should 'have 2 records' do
-          assert_equal 2, assigns(:records).size
-        end
-        should 'contain text' do
-          assert_tag(:tag => 'h2', :attributes => {:class => 'title'}, :content => /has 2 comments/ )
-        end
-      end
-    end
-  end
-
-
-  context 'GET quick_search' do
-    context 'for a standard model' do
-      setup do
-        @comment = Factory(:comment)
-        @comment = Factory(:comment)
-        get :quick_search, {:klass => @comment.class.name.underscore}
-      end
-      should_respond_with :success
-      should 'contain valid link at header breadcrum' do
-        assert_tag( :tag => 'div', :attributes => {:class => 'breadcrum rounded'}, 
-                                    :descendant => {:tag => 'a', 
-                                                    :attributes => {:href => '/admin_data/quick_search/comment'}})
-      end
-      should 'contain proper link at table listing' do
-        url = "/admin_data/klass/comment/#{Comment.last.id}"
-        assert_tag( :tag => 'td', :descendant => {:tag => 'a', :attributes => {:href => url}})
-      end
-    end
-
-    context 'for a nested model' do
-      setup do
-        get :quick_search, {:klass => @car.class.name.underscore}
-      end
-      #should_respond_with :success
-      #should 'contain proper link at header breadcum' do
-        #s = CGI.escape('vehicle/car')
-        #assert_tag( :tag => 'div', 
-                    #:attributes => {:class => 'breadcrum rounded'}, 
-                    #:descendant => {:tag => 'a', :attributes => {:href => "/admin_data/quick_search/#{s}" }})
-      #end
-      #should 'contain proper link at table listing' do
-        #s = CGI.escape("vehicle/car")
-        #url = "/admin_data/klass/#{s}/#{@car.class.last.id}"
-        #assert_tag(:tag => 'td', :descendant => {:tag => 'a', :attributes => {:href => url}})
-      #end
-      #should 'have proper action name for search form' do
-        #url = admin_data_search_path(:klass=>Vehicle::Car)
-        #assert_tag( :tag => 'form', :attributes => {:action => url})
-      #end
-    end
-  end
-
-  context 'GET quick_search with search term' do
-    setup do
-      Article.delete_all
-      @python_beginner_book = Factory(:article, :title => 'python for beginners')
-      @python_book = Factory(:article, :title => 'python')
-      @java_book = Factory(:article, :title => 'java')
-      @clojure_book = Factory(:article, :title => 'clojure')
-    end
-    context 'with default order' do
-      setup do
-        get :quick_search, {:klass => 'Article', :query => 'python'}
-      end
-      should_respond_with :success
-      should_assign_to :records
-      should 'have only two records' do
-        assert_equal 2, assigns(:records).size
-      end
-      should 'have python beginner book as the first book' do
-        assert_equal @python_beginner_book.id, assigns(:records).last.id
-      end
-      should 'have python book as the last book' do
-        assert_equal @python_book.id, assigns(:records).first.id
-      end
-    end
-
-    context 'with article_id ascending order' do
-      setup do
-        get :quick_search, { :klass => 'Article', :query => 'python', :sortby => 'article_id asc'}
-      end
-      should_respond_with :success
-      should_assign_to :records
-      should 'have only two records' do
-        assert_equal 2, assigns(:records).size
-      end
-      should 'have python beginner book as the first book' do
-        assert_equal @python_beginner_book.id, assigns(:records).first.id
-      end
-      should 'have python book as the last book' do
-        assert_equal @python_book.id, assigns(:records).last.id
-      end
-    end
-  end
-
-  context 'GET advance_search' do
-    context 'with no klass param' do
-      setup do
-        assert_raises ActionController::RoutingError do
-          get :advance_search
-        end
-      end
-    end
-
-    context 'with klass param' do
-      setup do
-        get :advance_search, {:klass => Article.name.underscore}
-      end
-      should_respond_with :success
-      should_not_assign_to :records
-      should 'have proper action for advance search form' do
-        url = admin_data_advance_search_path(:klass => Article)
-        assert_tag( :tag => 'form', :attributes => {:action => url})
-      end
-    end
-  end
-
-
-  context 'xhr advance_search with does_not_contain first one' do
-    setup do
-      Article.delete_all
-      AdminData::Config.set = ({ :is_allowed_to_update => lambda {|controller| return false} })
-      Factory(:article, :short_desc => 'ruby')
-      Factory(:article, :short_desc => 'rails')
-      Factory(:article, :short_desc => nil)
-      xml_http_request  :post, 
-                        :advance_search, 
-                        { :klass => Article.name.underscore, 
-                          :sortby => 'article_id desc', 
-                          :adv_search => {'1_row' => {:col1 => 'short_desc', 
-                                                      :col2 => 'does_not_contain', 
-                                                      :col3 => 'ruby'} } }
-    end
-    should_respond_with :success
-    should 'contain text' do
-      assert_tag(:tag => 'h2', :attributes => {:class => 'title'}, :content => /Search result: 2 records found/ )
-    end
-    should 'not contain delete all link' do
-      assert_no_tag( :tag => 'a', :attributes => {:id => 'advance_search_delete_all'})
-    end
-    should 'not contain destroy all link' do
-      assert_no_tag( :tag => 'a', :attributes => {:id => 'advance_search_destroy_all'})
-    end
-  end
-
-  context 'xhr advance_search with delete_all action' do
-    setup do
-      Article.delete_all
-      AdminData::Config.set = ({ :is_allowed_to_update => lambda {|controller| return true} })
-      Factory(:article, :short_desc => 'ruby')
-      Factory(:article, :short_desc => 'rails')
-      so   = {'1_row' => {:col1 => 'short_desc', :col2 => 'contains', :col3 => 'ruby'} }
-      h = { :klass => Article.name.underscore,
-            :sortby => 'article_id desc',
-            :admin_data_advance_search_action_type => 'delete', 
-            :adv_search => so }
-      xml_http_request  :post, :advance_search, h
-      @json = JSON.parse(@response.body)
-    end
-    should_respond_with :success
-    should 'have only one record' do
-      assert_equal 1, Article.count
-    end
-    should 'have success key in the response message' do
-      assert @json.has_key?('success')
-    end
-    should 'have success message in the response message' do
-      assert_equal '1 record deleted', @json.fetch('success')
-    end
-  end
-
-  context 'xhr advance_search with destroy_all action' do
-    setup do
-      Article.delete_all
-      AdminData::Config.set = ({ :is_allowed_to_update => lambda {|controller| return true} })
-      Factory(:article, :short_desc => 'ruby')
-      Factory(:article, :short_desc => 'rails')
-      xml_http_request  :post,
-                        :advance_search, 
-                        {:klass => Article.name.underscore, 
-                        :sortby => 'article_id desc', 
-                        :admin_data_advance_search_action_type => 'destroy', 
-                        :adv_search => {'1_row' => {:col1 => 'short_desc', :col2 => 'contains', :col3 => 'ruby'} } }
-      @json = JSON.parse(@response.body)
-    end
-    should_respond_with :success
-    should 'have only one record' do
-      assert_equal 1, Article.count
-    end
-    should 'have success key in the response message' do
-      assert @json.has_key?('success')
-    end
-    should 'have success message in the response message' do
-      assert_equal '1 record destroyed', @json.fetch('success')
-    end
-  end
-
-  context 'xhr advance_search with does_not_contain' do
-    setup do
-      AdminData::Config.set = ({ :is_allowed_to_update => lambda {|controller| return true } })
-      Article.delete_all
-      Factory(:article, :short_desc => 'ruby')
-      Factory(:article, :short_desc => 'rails')
-      Factory(:article, :short_desc => nil)
-      xml_http_request  :post, 
-                        :advance_search, 
-                        {:klass => Article.name.underscore, 
-                        :sortby => 'article_id desc', 
-                        :adv_search => {'1_row' => {:col1 => 'short_desc', 
-                                                    :col2 => 'does_not_contain', 
-                                                    :col3 => 'ruby'} } }
-    end
-    should_respond_with :success
-    should 'contain search result' do
-      assert_tag(:tag => 'h2', :attributes => {:class => 'title'}, :content => /Search result: 2 records found/ )
-    end
-    should 'contain delete all link' do
-      assert_tag( :tag => 'a', :attributes => {:id => 'advance_search_delete_all'})
-    end
-    should 'contain destroy all link' do
-      assert_tag( :tag => 'a', :attributes => {:id => 'advance_search_destroy_all'})
-    end
-  end
-
-  context 'xhr advance_search with contains option with 2 records' do
-    setup do
-      Article.delete_all
-      @python_book = Factory(:article, :title => 'python')
-      @python_beginner_book = Factory(:article, :title => 'python for beginners')
-      @java_book = Factory(:article, :title => 'java')
-      @clojure_book = Factory(:article, :title => 'clojure')
-      xml_http_request  :post, 
-                        :advance_search, 
-                        {:klass => Article.name.underscore, 
-                        :sortby => 'article_id desc', 
-                        :adv_search => {'1_row' => {:col1 => 'title', :col2 => 'contains', :col3 => 'python'} } }
-    end
-    should_respond_with :success
-    should 'contain text' do
-      assert_tag(:tag => 'h2', :attributes => {:class => 'title'}, :content => /Search result: 2 records found/ )
-    end
-  end
-
-  context 'xhr advance_search with 1 result' do
-    setup do
-      Article.delete_all
-      @python_book = Factory(:article, :title => 'python')
-      @python_beginner_book = Factory(:article, :title => 'python for beginners')
-      @java_book = Factory(:article, :title => 'java')
-      @clojure_book = Factory(:article, :title => 'clojure')
-      xml_http_request  :post, 
-                        :advance_search, 
-                        { :klass => Article.name.underscore, 
-                          :sortby => 'article_id desc', 
-                          :adv_search => {'1_row' => {:col1 => 'title', :col2 => 'contains', :col3 => 'clojure'} } }
-    end
-    should_respond_with :success
-    should 'contain text' do
-      assert_tag(:tag => 'h2', :attributes => {:class => 'title'}, :content => /Search result: 1 record found/ )
-    end
-  end
-
-  context 'xhr advance_search with empty query term with contains option' do
-    setup do
-      Article.delete_all
-      @python_book = Factory(:article, :title => 'python')
-      @python_beginner_book = Factory(:article, :title => 'python for beginners')
-      @java_book = Factory(:article, :title => 'java')
-      @clojure_book = Factory(:article, :title => 'clojure')
-      xml_http_request  :post, 
-                        :advance_search, 
-                        { :klass => Article.name.underscore, 
-                          :sortby => 'article_id desc', 
-                          :adv_search => {'1_row' => {:col1 => 'title', :col2 => 'contains', :col3 => ''} } }
-    end
-    should_respond_with :success
-    should 'contain text' do
-      assert_tag(:tag => 'h2', :attributes => {:class => 'title'}, :content => /Search result: 4 records found/ )
-    end
-  end
-
-  context 'xhr advance_search with empty col2' do
-    setup do
-      Article.delete_all
-      @python_book = Factory(:article, :title => 'python')
-      @python_beginner_book = Factory(:article, :title => 'python for beginners')
-      xml_http_request  :post, 
-                        :advance_search, 
-                        { :klass => Article.name.underscore, 
-                          :sortby => 'article_id desc', 
-                          :adv_search => {'1_row' => {:col1 => 'title', :col2 => nil, :col3 => nil} } }
-    end
-    should_respond_with :success
-    should 'contain text' do
-      assert_tag(:tag => 'h2', :attributes => {:class => 'title'}, :content => /Search result: 2 records found/ )
-    end
-  end
-
-  context 'xhr advance_search with two search terms' do
-    setup do
-      Article.delete_all
-      @python_book = Factory(:article, :title => 'python')
-      @python_beginner_book = Factory(:article, :title => 'python for beginners', :body => 'for beginners')
-      @java_book = Factory(:article, :title => 'java')
-      @clojure_book = Factory(:article, :title => 'clojure', :body => 'not for beginners')
-      adv_search = { '1_row' => { :col1 => 'title', 
-                                  :col2 => 'contains', 
-                                  :col3 => 'python'}, 
-                      '2_row' => {:col1 => 'body', 
-                                  :col2 => 'contains', 
-                                  :col3 => 'beginners'} }
-      xml_http_request  :post, 
-                        :advance_search, 
-                        { :klass => Article.name.underscore, :sortby => 'article_id desc', :adv_search => adv_search }
-    end
-    should_respond_with :success
-    should 'contain text' do
-      assert_tag(:tag => 'h2', :attributes => {:class => 'title'}, :content => /Search result: 1 record found/ )
-    end
-  end
-
-  context 'advance search conditions' do
-    setup do
-      @klass = Object.const_get('Article')
-      @proc = Proc.new do
-        @controller.send(:build_advance_search_conditions, @klass, { '429440_row' => @hash })
-      end
-    end
-
-    context 'with col2 as null' do
-      should 'have sql as body is not null' do
-        @hash = { :col1 => 'body', :col2 => 'is_not_null'}
-        output = @proc.call
-        expected =  %Q{ SELECT "articles".* FROM "articles" WHERE (articles.body IS NOT NULL) }
-        assert_equal_sql expected, @proc.call[:cond].to_sql
-      end
-    end
-
-    context 'with col2 contains' do
-      should 'have sql with like' do
-        @hash = { :col1 => 'body', :col2 => 'contains', :col3 => 'python'}
-        expected =  %{ SELECT "articles".* FROM "articles" WHERE (articles.body LIKE '%python%') }
-        assert_equal_sql expected, @proc.call[:cond].to_sql
-      end
-    end
-
-    context 'with col2 as exactly' do
-      should 'have sql as body equals' do
-        @hash = { :col1 => 'body', :col2 => 'is_exactly', :col3 => 'python'}
-        expected = %{ SELECT "articles".* FROM "articles" WHERE (articles.body = 'python') }
-        assert_equal_sql expected , @proc.call[:cond].to_sql
-      end
-    end
-
-    context 'with does not contain' do
-      should 'have sql as body is null or not like' do
-        @hash = { :col1 => 'body', :col2 => 'does_not_contain', :col3 => 'python'}
-        expected =  %Q{SELECT "articles".* FROM "articles" WHERE (articles.body IS NULL OR articles.body NOT LIKE '%python%')}
-        assert_equal_sql expected, @proc.call[:cond].to_sql
-      end
-    end
-
-    context 'with col2 as false' do
-      should 'have sql with body as false' do
-        @hash = { :col1 => 'body', :col2 => 'is_false', :col3 => 'python'}
-        expected =  %{ SELECT "articles".* FROM "articles" WHERE (articles.body = 'f') }
-        assert_equal_sql expected, @proc.call[:cond].to_sql
-      end
-    end
-  end
-
-
-  context 'XHR advance_search' do
-    setup do
-      Article.delete_all
-      @proc = Proc.new do
-        @hash_big = { :klass => Article.name.underscore, :adv_search => {'2_row' => @hash } }
-      end
-    end
-    context 'with col2 contains' do
-      setup do
-        Factory(:article, :title => 'python')
-        @hash = {:col1 => 'title', :col2 => 'contains', :col3 => 'python'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should_respond_with :success
-      should 'contain content' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title'}, :content => /Search result: 1 record found/ )
-      end
-    end
-
-    context 'with col2 contains with no search result' do
-      setup do
-        Factory(:article, :title => 'ruby')
-        @hash = { :col1 => 'title', :col2 => 'contains', :col3 => 'python'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title' }, :content => /Search result: 0 records found/ )
-      end
-    end
-
-    context 'with col2 is_exactly' do
-      setup do
-        Factory(:article, :title => 'python')
-        @hash = { :col1 => 'title', :col2 => 'is_exactly', :col3 => 'python'}
-        xml_http_request :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title'}, :content => /Search result: 1 record found/ )
-      end
-    end
-
-    context 'with col2 is_exactly negative case' do
-      setup do
-        Factory(:article, :title => 'ruby')
-        @hash = {:col1 => 'title', :col2 => 'is_exactly', :col3 => 'python'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :id => 'search_result_title'}, :content => /Search result: 0 records found/ )
-      end
-    end
-
-    context 'with col2 does_not_contain' do
-      setup do
-        Factory(:article, :title => 'python')
-        @hash = {:col1 => 'title', :col2 => 'does_not_contain', :col3 => 'ruby'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title'}, :content => /Search result: 1 record found/ )
-      end
-    end
-
-    context 'with col2 does_not_conatin negative case' do
-      setup do
-        Factory(:article, :title => 'ruby')
-        @hash = {:col1 => 'title', :col2 => 'does_not_contain', :col3 => 'ruby'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes =>{ :class => 'title'}, :content => /Search result: 0 records found/ )
-      end
-    end
-
-    context 'with col2 is_false' do
-      setup do
-        Factory(:article, :approved => false)
-        @hash = {:col1 => 'approved', :col2 => 'is_false'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => {:class => 'title'}, :content => /Search result: 1 record found/ )
-      end
-    end
-
-    context 'with col2 is_false negative case' do
-      setup do
-        Factory(:article, :approved => true)
-        @hash = {:col1 => 'approved', :col2 => 'is_false'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag(:tag => 'h2', :attributes => {:class => 'title'}, :content => /Search result: 0 records found/ )
-      end
-    end
-
-    context 'with col2 is_true' do
-      setup do
-        Factory(:article, :approved => true)
-        @hash = {:col1 => 'approved', :col2 => 'is_true'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title'}, :content => /Search result: 1 record found/ )
-      end
-    end
-
-    context 'with col2 is_true negative case' do
-      setup do
-        Factory(:article, :approved => false)
-        @hash = {:col1 => 'approved', :col2 => 'is_true'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag(:tag => 'h2', :attributes => {:class => 'title'}, :content => /Search result: 0 records found/ )
-      end
-    end
-
-    context 'with col2 is_null' do
-      setup do
-        Factory(:article, :status => nil)
-        @hash = {:col1 => 'status', :col2 => 'is_null'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title' }, :content => /Search result: 1 record found/ )
-      end
-    end
-
-    context 'with col2 is_null negative case' do
-      setup do
-        Factory(:article, :status => 'something')
-        @hash = {:col1 => 'status', :col2 => 'is_null'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag(:tag => 'h2', :attributes => {:class => 'title'}, :content => /Search result: 0 records found/ )
-      end
-    end
-
-    context 'with col2 is_not_null' do
-      setup do
-        Factory(:article, :status => 'something')
-        @hash = {:col1 => 'status', :col2 => 'is_not_null'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title'}, :content => /Search result: 1 record found/ )
-      end
-    end
-
-    context 'with col2 is_not_null negative case' do
-      setup do
-        Factory(:article, :status => nil)
-        @hash = {:col1 => 'status', :col2 => 'is_not_null'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title'}, :content => /Search result: 0 records found/ )
-      end
-    end
-
-    context 'with col2 is_equal_to' do
-      setup do
-        Factory(:article, :hits_count => 100)
-        @hash = {:col1 => 'hits_count', :col2 => 'is_equal_to', :col3 => 100.to_s}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title' }, :content => /Search result: 1 record found/ )
-      end
-    end
-
-    context 'with col2 is_equal_to negative case' do
-      setup do
-        Factory(:article, :hits_count => 100)
-        @hash = {:col1 => 'hits_count', :col2 => 'is_equal_to', :col3 => 101.to_s}
-        xml_http_request :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title' }, :content => /Search result: 0 records found/ )
-      end
-    end
-
-    context 'with col2 greater_than' do
-      setup do
-        Factory(:article, :hits_count => 100)
-        @hash = {:col1 => 'hits_count', :col2 => 'greater_than', :col3 => 99.to_s}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title'}, :content => /Search result: 1 record found/ )
-      end
-    end
-
-    context 'with col2 greater_than negative case' do
-      setup do
-        Factory(:article, :hits_count => 100)
-        @hash = {:col1 => 'hits_count', :col2 => 'greater_than', :col3 => 101.to_s}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title'}, :content => /Search result: 0 records found/ )
-      end
-    end
-
-    context 'with col2 less_than' do
-      setup do
-        Factory(:article, :hits_count => 100)
-        @hash = {:col1 => 'hits_count', :col2 => 'less_than', :col3 => 101.to_s}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title' }, :content => /Search result: 1 record found/ )
-      end
-    end
-
-    context 'with col2 less_than negative case' do
-      setup do
-        Factory(:article, :hits_count => 100)
-        @hash = {:col1 => 'hits_count', :col2 => 'less_than', :col3 => 99.to_s}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title' }, :content => /Search result: 0 records found/ )
-      end
-    end
-
-    context 'with col2 is_on' do
-      setup do
-        Factory(:article, :published_at => Time.now)
-        d = Time.now.strftime('%d-%B-%Y')
-        @hash = {:col1 => 'published_at', :col2 => 'is_on', :col3 => d}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes =>{ :class => 'title'}, :content => /Search result: 1 record found/ )
-      end
-    end
-
-    context 'with col2 is_on negative case' do
-      setup do
-        Factory(:article, :published_at => Time.now)
-        d = 1.year.ago.strftime('%d-%B-%Y')
-        @hash = {:col1 => 'published_at', :col2 => 'is_on', :col3 => d}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title'}, :content => /Search result: 0 records found/ )
-      end
-    end
-
-    context 'with col2 is_on_or_after_date' do
-      setup do
-        Factory(:article, :published_at => Time.now)
-        @hash = {:col1 => 'published_at', :col2 => 'is_on_or_after_date', :col3 => 1.month.ago.strftime('%d-%B-%Y') }
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title'}, :descendant => /Search result: 1 record found/ )
-      end
-    end
-
-    context 'with col2 is_on_or_after_date negative case' do
-      setup do
-        Factory(:article, :published_at => Time.now)
-        @hash = {:col1 => 'published_at', :col2 => 'is_on_or_after_date', :col3 => 1.month.from_now.strftime('%d-%B-%Y') }
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title' }, :content => /Search result: 0 records found/ )
-      end
-    end
-
-    context 'with col2 is_on_or_before_date' do
-      setup do
-        Factory(:article, :published_at => Time.now)
-        @hash = {:col1 => 'published_at', :col2 => 'is_on_or_before_date', :col3 => 1.month.from_now.strftime('%d-%B-%Y') }
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag( :tag => 'h2', :attributes => { :class => 'title'}, :content => /Search result: 1 record found/ )
-      end
-    end
-
-    context 'with col2 is_on_or_before_date negative case' do
-      setup do
-        @hash = {:col1 => 'published_at', :col2 => 'is_on_or_before_date', :col3 => 1.year.ago.strftime('%d-%B-%Y') }
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'does contain text' do
-        assert_tag(:tag => 'h2', :attributes => {:class => 'title'}, :content => /Search result: 0 records found/ )
-      end
-    end
-
-    context 'with col2 is_on_or_before_date with invalid_date input' do
-      setup do
-        @hash = {:col1 => 'published_at', :col2 => 'is_on_or_before_date', :col3 => 'invalid_date'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag(:tag => 'p', :attributes => {:class => 'error'}, :content => /is not a valid date/ )
-      end
-    end
-
-    context 'with col2 is_on_or_after_date with invalid_date input' do
-      setup do
-        @hash = {:col1 => 'published_at', :col2 => 'is_on_or_after_date', :col3 => 'invalid_date'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag(:tag => 'p', :attributes => {:class => 'error'}, :content => /is not a valid date/ )
-      end
-    end
-
-    context 'is_on invalid date' do
-      setup do
-        @hash = {:col1 => 'published_at', :col2 => 'is_on', :col3 => 'invalid_date'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag(:tag => 'p', :attributes => {:class => 'error'}, :content => /is not a valid date/ )
-      end
-    end
-
-    context 'with col2 is_equal_to with invalid input' do
-      setup do
-        @hash = {:col1 => 'hits_count', :col2 => 'is_equal_to', :col3 => 'invalid_integer'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag(:tag => 'p', :attributes => {:class => 'error'}, :content => /is not a valid integer/ )
-      end
-    end
-
-    context 'with col2 less_than invalid_integer' do
-      setup do
-        @hash = {:col1 => 'hits_count', :col2 => 'less_than', :col3 => 'invalid_integer'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag(:tag => 'p', :attributes => {:class => 'error'}, :content => /is not a valid integer/ )
-      end
-    end
-
-    context 'with col2 greater_than invalid integer' do
-      setup do
-        @hash = {:col1 => 'hits_count', :col2 => 'greater_than', :col3 => 'invalid_integer'}
-        xml_http_request  :post, :advance_search, @proc.call
-      end
-      should 'contain text' do
-        assert_tag(:tag => 'p', :attributes => {:class => 'error'}, :content => /is not a valid integer/ )
-      end
-    end
-
-  end
-
-end