admin_data 1.0.0

data/test/functional/migration_controller_test.rb

@@ -0,0 +1,30 @@
+pwd = File.dirname(__FILE__)
+require File.join(pwd, '..', 'test_helper')
+#require 'test_helper'
+
+pwd = File.dirname(__FILE__)
+f = File.join(pwd, '..', '..', 'app', 'views')
+AdminData::MainController.prepend_view_path(f)
+AdminData::MigrationController.prepend_view_path(f)
+
+class AdminData::MigrationControllerTest < ActionController::TestCase
+
+  def setup
+    @controller = AdminData::MigrationController.new
+    @request = ActionController::TestRequest.new
+    @response = ActionController::TestResponse.new
+    grant_read_only_access
+  end
+
+  context 'GET index' do
+    setup do
+      get :index
+    end
+    should_respond_with :success
+    should_assign_to :data
+    should 'contain title' do
+      assert_tag(:tag => 'h2', :content => 'Migration Information from schema_migrations table')
+    end
+  end
+
+end

data/test/functional/routes_test.rb

@@ -0,0 +1,61 @@
+pwd = File.dirname(__FILE__)
+
+require File.join(pwd, '..', 'test_helper')
+
+class AdminData::MainControllerTest < ActionController::TestCase
+
+  should route(:get, '/admin_data/quick_search/article').to(:controller => 'admin_data/search', 
+                                                            :action => :quick_search, 
+                                                            :klass => 'article')
+
+  should route(:get, '/admin_data/advance_search/article').to(:controller => 'admin_data/search', 
+                                                              :action => :advance_search, 
+                                                              :klass => 'article')
+
+  should route(:get, '/admin_data/migration').to(:controller => 'admin_data/migration', 
+                                                 :action => :index)
+
+  should route(:get, '/admin_data').to(:controller => 'admin_data/main', 
+                                       :action => :all_models)
+
+  should route(:get, '/admin_data').to(:controller => 'admin_data/main', 
+                                       :action => :all_models)
+
+  should route(:get, '/admin_data/klass/article/1').to(:controller => 'admin_data/main', 
+                                                       :action => :show, 
+                                                       :klass => 'article', 
+                                                       :id => 1)
+
+  should route(:delete, '/admin_data/klass/article/1').to(:controller => 'admin_data/main', 
+                                                          :action => :destroy, 
+                                                          :klass => 'article', 
+                                                          :id => 1)
+
+  should route(:delete, '/admin_data/klass/article/1/del').to(:controller => 'admin_data/main', 
+                                                              :action => :del, 
+                                                              :klass => 'article', 
+                                                              :id => 1)
+
+  should route(:get, '/admin_data/klass/article/1/edit').to(:controller => 'admin_data/main', 
+                                                            :action => :edit, 
+                                                            :klass => 'article', 
+                                                            :id => 1)
+
+  should route(:put, '/admin_data/klass/article/1').to(:controller => 'admin_data/main', 
+                                                       :action => :update, 
+                                                       :klass => 'article', 
+                                                       :id => 1)
+
+  should route(:get, '/admin_data/klass/article/new').to(:controller => 'admin_data/main', 
+                                                         :action => :new, 
+                                                         :klass => 'article')
+
+  should route(:post, '/admin_data/klass/article').to(:controller => 'admin_data/main', 
+                                                      :action => :create, 
+                                                      :klass => 'article')
+
+  should route(:get, '/admin_data/klass/article/table_structure').to(:controller => 'admin_data/main', 
+                                                                     :action => :table_structure, 
+                                                                     :klass => 'article')
+
+end

data/test/functional/search_controller_test.rb

@@ -0,0 +1,814 @@
+
+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
+    @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
+
+  # write filters test 
+
+
+  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