kaui 1.0.0 → 1.1.0

data/app/views/kaui/subscriptions/_subscriptions_table.html.erb

@@ -43,7 +43,7 @@
           </td>
         <% end %>
         <td>
-          <span class="subscription-id-popover" data-toggle="popover" data-trigger="hover" title="Subscription ID"  data-content="<%= sub.subscription_id %>">
+          <span id="<%= sub.subscription_id %>-popover" class="object-id-popover" title="Subscription ID" data-id="<%= sub.subscription_id %>">
             <%= humanized_subscription_product_category(sub) %>
           </span>
         </td>

data/app/views/kaui/tag_definitions/index.html.erb

@@ -22,7 +22,7 @@
       <tbody>
       <% @tag_definitions.each do |tag_definition| %>
           <tr>
-            <td><%= truncate_uuid(tag_definition.id) %></td>
+            <td><%= object_id_popover(tag_definition.id) %></td>
             <td><%= tag_definition.name %></td>
             <td><%= tag_definition.description %></td>
             <td><%= tag_definition.is_system_tag? %></td>

data/config/routes.rb

@@ -186,6 +186,8 @@ Kaui::Engine.routes.draw do
     match '/allowed_users' => 'admin_tenants#allowed_users', :via => :get, :as => 'admin_tenant_allowed_users'
     match '/catalog_by_effective_date' => 'admin_tenants#catalog_by_effective_date', :via => :get, :as => 'catalog_by_effective_date'
     match '/suggest_plugin_name' => 'admin_tenants#suggest_plugin_name', :via => :get, :as => 'suggest_plugin_name'
+    match '/switch' => 'admin_tenants#switch_tenant', :via => :get, :as => 'switch_tenant'
+    match '/:id/download_catalog' => 'admin_tenants#download_catalog_xml', :via => :get, :as => 'download_catalog_xml'
   end
   resources :admin_tenants, :only => [ :index, :new, :create, :show ]
 

data/lib/kaui/version.rb

@@ -1,3 +1,3 @@
 module Kaui
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/test/functional/kaui/accounts_controller_test.rb

@@ -55,6 +55,41 @@ class Kaui::AccountsControllerTest < Kaui::FunctionalTestHelper
     assert_not_nil assigns(:payment_methods)
   end
 
+  test 'should check that overdue state is Good' do
+    get :show, :account_id => @account.account_id
+    assert_response 200
+
+    overdue_status_proc_count = 0
+
+    assert_select 'table' do |tables|
+      tables.each do |table|
+        assert_select table, 'tr' do |rows|
+          rows.each do |row|
+            # find overdue status in the response
+           is_overdue_state = false
+            assert_select row, 'th' do |col|
+              is_overdue_state = col[0].text.eql?('Overdue status')
+            end
+
+            # if found
+            if is_overdue_state
+              overdue_status_proc_count += 1
+              assert_select row, 'td' do |col|
+                assert_select col, 'span' do |content|
+                  assert 'Good', content[0].text
+                  overdue_status_proc_count += 1 if content[0].text.eql?('Good')
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # assert that overdue state is found with result equal to Good
+    assert overdue_status_proc_count, 2
+  end
+
   test 'should handle Kill Bill errors when creating account' do
     post :create
     assert_redirected_to home_path

data/test/functional/kaui/admin_allowed_users_controller_test.rb

@@ -10,10 +10,10 @@ module Kaui
 
     test 'should get create local only' do
       parameters = {
-          :allowed_user => {:kb_username => 'Albator', :description => 'My french super hero'},
+          :allowed_user => {:kb_username => 'Albator', :description => 'My french super hero' },
+          :external => '1' ,
           :password => 'Albator',
           :roles => nil,
-          :external => '1'
       }
       post :create, parameters
       assert_equal 'User was successfully configured', flash[:notice]
@@ -156,6 +156,59 @@ module Kaui
       assert response_path.include?(expected_response_path(au.id)), "#{response_path} is expected to contain #{expected_response_path(au.id)}"
     end
 
+    test 'should detect if a user is managed externally' do
+      allowed_user = {:kb_username => 'Local', :description => 'adding only locally'}
+
+      # adding only locally will make the user managed externally
+      au = Kaui::AllowedUser.new
+      au.kb_username = allowed_user[:kb_username]
+      au.description = allowed_user[:description]
+      au.save!
+
+      # edit the added user and validate that the checkbox of managed externally is disabled
+      get :edit, :id => au.id
+      assert_response :success
+      assert_select 'form input#external' do |checkbox|
+        assert_equal checkbox[0]['disabled'], 'disabled'
+      end
+
+      # create a user that is managed externally
+      parameters = {
+          :allowed_user => {:kb_username => 'LDAP', :description => 'LDAP' },
+          :external => '1'
+      }
+      post :create, parameters
+      assert_equal 'User was successfully configured', flash[:notice]
+      assert_response 302
+      added_au_id = response_path.gsub('/kaui/admin_allowed_users/','')
+
+      # edit the added user and validate that the checkbox of managed externally is disabled
+      get :edit, :id => added_au_id
+      assert_response :success
+      assert_select 'form input#external' do |checkbox|
+        assert_equal checkbox[0]['disabled'], 'disabled'
+      end
+
+      # create a user that is not managed externally
+      parameters = {
+          :allowed_user => {:kb_username => 'JDBC', :description => 'Kill Bill JDBC Realm' },
+          :external => '0',
+          :password => 'jdbc',
+          :roles => nil
+      }
+      post :create, parameters
+      assert_equal 'User was successfully configured', flash[:notice]
+      assert_response 302
+      added_au_id = response_path.gsub('/kaui/admin_allowed_users/','')
+
+      # edit the added user and validate that the password is not disabled
+      get :edit, :id => added_au_id
+      assert_response :success
+      assert_select 'form input#password' do |input|
+        assert_nil input[0]['disabled']
+      end
+    end
+
     private
       def expected_response_path(id=nil)
         "/kaui/admin_allowed_users#{id.nil? ? '' : "/#{id}" }"

data/test/functional/kaui/admin_tenants_controller_test.rb

@@ -192,7 +192,7 @@ class Kaui::AdminTenantsControllerTest < Kaui::FunctionalTestHelper
         :states => { '0' => {
           :name =>	'Overdue_test',
           :external_message => 'Overdue_Test_Ya',
-          :block_changes =>	true,
+          :is_block_changes =>	true,
           :subscription_cancellation_policy => 'NONE',
           :condition => {
             :time_since_earliest_unpaid_invoice_equals_or_exceeds => 1,
@@ -285,15 +285,60 @@ class Kaui::AdminTenantsControllerTest < Kaui::FunctionalTestHelper
   end
 
   test 'should suggest a plugin name' do
-    plugin_anchor = "'<a id=\"suggested\" data-plugin-name=\"killbill-paypal-express\" data-plugin-key=\"paypal\" href=\"#\">killbill-paypal-express</a>'"
+    plugin_anchor = "'<a id=\"suggested\" data-plugin-name=\"killbill-paypal-express\" data-plugin-key=\"paypal_express\" data-plugin-type=\"ruby\" href=\"#\">killbill-paypal-express</a>'"
+
+    # Similar plugin already installed test will run, if there are plugin installed
+    installed_plugins = installed_plugins()
+    unless installed_plugins.blank?
+      installed_plugins.each do |plugin|
+        installed_plugin_anchor = "'<a id=\"suggested\" data-plugin-name=\"#{plugin[:plugin_name]}\" data-plugin-key=\"#{plugin[:plugin_key]}\".*href=\"#\">#{plugin[:plugin_name]}</a>'"
+
+        get :suggest_plugin_name, :plugin_name => plugin[:plugin_name][0, plugin[:plugin_name].length - 1]
+        assert_response :success
+        assert_match /Similar plugin already installed: #{installed_plugin_anchor}/, JSON[@response.body]['suggestion']
+      end
+    end
 
-    get :validate_plugin_name, :plugin_name => 'paypal-express'
+    get :suggest_plugin_name, :plugin_name => 'pypl'
     assert_response :success
-    assert_equal JSON[@response.body]['suggestion'], "Similar plugin already installed: #{plugin_anchor}"
+    assert_equal "Did you mean #{plugin_anchor}?", JSON[@response.body]['suggestion']
+  end
+
+  test 'should switch tenant' do
+    other_tenant = setup_and_create_test_tenant(1)
+    other_tenant_kaui = Kaui::Tenant.find_by_kb_tenant_id(other_tenant.tenant_id)
+
+    get :switch_tenant, :kb_tenant_id => other_tenant.tenant_id
+    assert_redirected_to admin_tenant_path(other_tenant_kaui.id)
+    assert_equal flash[:notice], "Tenant was switched to #{other_tenant_kaui.name}"
+
+    # switch back
+    tenant_kaui = Kaui::Tenant.find_by_kb_tenant_id(@tenant.tenant_id)
+    get :switch_tenant, :kb_tenant_id => @tenant.tenant_id
+    assert_redirected_to admin_tenant_path(tenant_kaui.id)
+    assert_equal flash[:notice], "Tenant was switched to #{tenant_kaui.name}"
+  end
+
+  test 'should download a catalog' do
+    effective_date = '2013-02-08T00:00:00+00:00'
+    tenant = create_kaui_tenant
+    post :upload_catalog, :id => tenant.id, :catalog => fixture_file_upload('catalog-v1.xml')
+
+    assert_redirected_to admin_tenant_path(tenant.id)
+    assert_equal 'Catalog was successfully uploaded', flash[:notice]
 
-    get :validate_plugin_name, :plugin_name => 'pypl'
+    get :download_catalog_xml, :effective_date => effective_date, :id => tenant.id
     assert_response :success
-    assert_equal JSON[@response.body]['suggestion'], "Did you mean #{plugin_anchor}?"
+    assert_equal 'application/xml', @response.header['Content-Type']
+    assert_equal "attachment; filename=\"catalog_#{effective_date}.xml\"", @response.header['Content-Disposition']
+
+    doc = nil
+    assert_nothing_raised { doc = Nokogiri::XML(@response.body) { |config| config.strict } }
+
+    catalog = doc.xpath("//catalog")
+    expected_effective_date = Date.parse(catalog[0].search("effectiveDate").text)
+
+    assert_equal Date.parse(effective_date), expected_effective_date
   end
 
   private
@@ -308,4 +353,20 @@ class Kaui::AdminTenantsControllerTest < Kaui::FunctionalTestHelper
     assert_equal 'Tenant was successfully configured', flash[:notice]
     tenant
   end
+
+  def installed_plugins
+    installed_plugins = []
+    nodes_info = KillBillClient::Model::NodesInfo.nodes_info(build_options(@tenant, USERNAME, PASSWORD)) || []
+    plugins_info = nodes_info.first.plugins_info || []
+    plugins_info.each do |plugin|
+      next if plugin.version.nil?
+      next if installed_plugins.any? { |p| p[:plugin_name].eql?(plugin.plugin_name) }
+      installed_plugins << {
+          plugin_key: Kaui::AdminTenant.rewrite_plugin_key(plugin.plugin_key),
+          plugin_name: plugin.plugin_name
+      }
+    end
+
+    installed_plugins
+  end
 end

data/test/functional/kaui/home_controller_test.rb

@@ -7,27 +7,401 @@ class Kaui::HomeControllerTest < Kaui::FunctionalTestHelper
     assert_response :success
   end
 
-  test 'should understand search queries' do
-    get :search, :q => 'John Doe'
-    assert_redirected_to accounts_path(:q => 'John Doe')
+  test 'should understand account search queries' do
+    dummy_uuid = SecureRandom.uuid.to_s
+    # search defaults using a UUID
+    get :search, :q => @account.account_id
+    assert_redirected_to account_path(@account.account_id)
 
-    get :search, :q => 'de305d54-75b4-431b-adb2-eb6b9e546014'
-    assert_redirected_to accounts_path(:q => 'de305d54-75b4-431b-adb2-eb6b9e546014')
+    # search defaults using a String
+    get :search, :q => @account.name
+    assert_redirected_to accounts_path(:fast => 0, :q => @account.name)
 
-    get :search, :q => 'invoice:de305d54-75b4-431b-adb2-eb6b9e546014'
-    assert_redirected_to invoice_path(:id => 'de305d54-75b4-431b-adb2-eb6b9e546014')
+    # search by ID
+    get :search, :q => query_builder('ACCOUNT',@account.account_id, 'ID')
+    assert_redirected_to account_path(@account.account_id)
 
-    get :search, :q => 'payment:de305d54-75b4-431b-adb2-eb6b9e546014'
-    assert_redirected_to payment_path(:id => 'de305d54-75b4-431b-adb2-eb6b9e546014')
+    # search by ID and fails
+    get :search, :q => query_builder('ACCOUNT',dummy_uuid, 'ID')
+    assert_redirected_to home_path
+    assert_equal "No account matches \"#{dummy_uuid}\"", flash[:error]
 
-    get :search, :q => 'invoice:546014'
-    assert_redirected_to invoice_path(:id => '546014')
+    # search by EXTERNAL_KEY
+    get :search, :q => query_builder('ACCOUNT',@account.external_key, 'EXTERNAL_KEY')
+    assert_redirected_to account_path(@account.account_id)
 
-    get :search, :q => 'payment:546014'
-    assert_redirected_to payment_path(:id => '546014')
+    # search by EXTERNAL_KEY and fails
+    get :search, :q => query_builder('ACCOUNT',dummy_uuid, 'EXTERNAL_KEY')
+    assert_redirected_to home_path
+    assert_equal "No account matches \"#{dummy_uuid}\"", flash[:error]
 
-    get :search, :q => "transaction:#{@payment.transactions.first.transaction_id}"
-    assert_redirected_to transaction_path(:id => @payment.transactions.first.transaction_id)
+    # search by BLANK only first
+    get :search, :q => query_builder('ACCOUNT',@account.name, nil, '1')
+    assert_redirected_to account_path(@account.account_id)
 
+    # search by BLANK
+    get :search, :q => query_builder('ACCOUNT',@account.name)
+    assert_redirected_to accounts_path(:fast => 0, :q => @account.name)
+
+    # search by BLANK and fails
+    get :search, :q => query_builder('ACCOUNT',dummy_uuid)
+    assert_redirected_to home_path
+    assert_equal "No account matches \"#{dummy_uuid}\"", flash[:error]
+  end
+
+  test 'should understand invoice search queries' do
+    # search by ID
+    get :search, :q => query_builder('INVOICE',@invoice_item.invoice_id, 'ID')
+    assert_redirected_to account_invoice_path(@invoice_item.account_id, @invoice_item.invoice_id)
+
+    # search by ID and fails
+    get :search, :q => query_builder('INVOICE','112', 'ID')
+    assert_redirected_to home_path
+    assert_equal "No invoice matches \"112\"", flash[:error]
+
+    # search by EXTERNAL_KEY and fails
+    get :search, :q => query_builder('INVOICE','112', 'EXTERNAL_KEY')
+    assert_redirected_to home_path
+    assert_equal "\"INVOICE\": Search by \"EXTERNAL KEY\" is not supported.", flash[:error]
+
+    # search by BLANK only first
+    get :search, :q => query_builder('INVOICE',@bundle_invoice.invoice_number, nil, '1')
+    assert_redirected_to account_invoice_path(@bundle_invoice.account_id, @bundle_invoice.invoice_id)
+
+    # search by BLANK only first (invoice item)
+    get :search, :q => query_builder('INVOICE',@bundle_invoice.items[0].invoice_item_id, nil, '1')
+    assert_redirected_to account_invoice_path(@bundle_invoice.account_id, @bundle_invoice.invoice_id)
+
+    # search by BLANK
+    get :search, :q => query_builder('INVOICE',@bundle_invoice.invoice_number)
+    assert_redirected_to account_invoices_path(:account_id => @bundle_invoice.account_id, :q => @bundle_invoice.invoice_number, :fast => '0')
+
+    # search by BLANK and fails
+    get :search, :q => query_builder('INVOICE','112')
+    assert_redirected_to home_path
+    assert_equal "No invoice matches \"112\"", flash[:error]
+  end
+
+  test 'should understand payment search queries' do
+    dummy_uuid = SecureRandom.uuid.to_s
+    # search by ID
+    get :search, :q => query_builder('PAYMENT',@payment.payment_id, 'ID')
+    assert_redirected_to account_payment_path(@payment.account_id,@payment.payment_id)
+
+    # search by ID and fails
+    get :search, :q => query_builder('PAYMENT',dummy_uuid, 'ID')
+    assert_redirected_to home_path
+    assert_equal "No payment matches \"#{dummy_uuid}\"", flash[:error]
+
+    # search by EXTERNAL_KEY
+    get :search, :q => query_builder('PAYMENT',@payment.payment_external_key, 'EXTERNAL_KEY')
+    assert_redirected_to account_payment_path(@payment.account_id,@payment.payment_id)
+
+    # search by EXTERNAL_KEY and fails
+    get :search, :q => query_builder('PAYMENT',dummy_uuid, 'EXTERNAL_KEY')
+    assert_redirected_to home_path
+    assert_equal "No payment matches \"#{dummy_uuid}\"", flash[:error]
+
+    # search by BLANK only first
+    get :search, :q => query_builder('PAYMENT','SUCCESS', nil, '1')
+    assert_redirected_to account_payment_path(@payment.account_id,@payment.payment_id)
+
+    # search by BLANK
+    get :search, :q => query_builder('PAYMENT','SUCCESS')
+    assert_redirected_to account_payments_path(:account_id => @payment.account_id, :q => 'SUCCESS', :fast => '0')
+
+    # search by BLANK and fails
+    get :search, :q => query_builder('PAYMENT','FAILED')
+    assert_redirected_to home_path
+    assert_equal "No payment matches \"FAILED\"", flash[:error]
+  end
+
+  test 'should understand transaction search queries' do
+    dummy_uuid = SecureRandom.uuid.to_s
+    # search by ID
+    get :search, :q => query_builder('TRANSACTION',@payment.transactions[0].transaction_id, 'ID')
+    assert_redirected_to account_payment_path(@payment.account_id, @payment.payment_id)
+
+    # search by ID and fails
+    get :search, :q => query_builder('TRANSACTION',dummy_uuid, 'ID')
+    assert_redirected_to home_path
+    assert_equal "No transaction matches \"#{dummy_uuid}\"", flash[:error]
+
+    # search by EXTERNAL_KEY
+    get :search, :q => query_builder('TRANSACTION',@payment.transactions[0].transaction_external_key, 'EXTERNAL_KEY')
+    assert_redirected_to account_payment_path(@payment.account_id,@payment.payment_id)
+
+    # search by EXTERNAL_KEY and fails
+    get :search, :q => query_builder('TRANSACTION',dummy_uuid, 'EXTERNAL_KEY')
+    assert_redirected_to home_path
+    assert_equal "No transaction matches \"#{dummy_uuid}\"", flash[:error]
+
+    # search by BLANK only first
+    get :search, :q => query_builder('TRANSACTION',@payment.transactions[0].transaction_id, nil, '1')
+    assert_redirected_to account_payment_path(@payment.account_id, @payment.payment_id)
+
+    # search by BLANK
+    get :search, :q => query_builder('TRANSACTION',@payment.transactions[0].transaction_id)
+    assert_redirected_to account_payment_path(@payment.account_id, @payment.payment_id)
+
+    # search by BLANK and fails
+    get :search, :q => query_builder('TRANSACTION','112')
+    assert_redirected_to home_path
+    assert_equal "No transaction matches \"112\"", flash[:error]
+  end
+
+  test 'should understand bundle search queries' do
+    dummy_uuid = SecureRandom.uuid.to_s
+    # search by ID
+    get :search, :q => query_builder('BUNDLE',@bundle.bundle_id, 'ID')
+    assert_redirected_to account_bundles_path(@bundle.account_id)
+
+    # search by ID and fails
+    get :search, :q => query_builder('BUNDLE',dummy_uuid, 'ID')
+    assert_redirected_to home_path
+    assert_equal "No bundle matches \"#{dummy_uuid}\"", flash[:error]
+
+    # search by EXTERNAL_KEY
+    get :search, :q => query_builder('BUNDLE',@bundle.external_key, 'EXTERNAL_KEY')
+    assert_redirected_to account_bundles_path(@bundle.account_id)
+
+    # search by EXTERNAL_KEY and fails
+    get :search, :q => query_builder('BUNDLE',dummy_uuid, 'EXTERNAL_KEY')
+    assert_redirected_to home_path
+    assert_equal "No bundle matches \"#{dummy_uuid}\"", flash[:error]
+
+    # search by BLANK only first
+    get :search, :q => query_builder('BUNDLE',@bundle.account_id, nil, '1')
+    assert_redirected_to account_bundles_path(@bundle.account_id)
+
+    # search by BLANK
+    get :search, :q => query_builder('BUNDLE',@bundle.account_id)
+    assert_redirected_to account_bundles_path(@bundle.account_id)
+
+    # search by BLANK and fails
+    get :search, :q => query_builder('BUNDLE',dummy_uuid)
+    assert_redirected_to home_path
+    assert_equal "No bundle matches \"#{dummy_uuid}\"", flash[:error]
+  end
+
+  test 'should understand credit search queries' do
+    dummy_uuid = SecureRandom.uuid.to_s
+    credit = create_credit
+    # search by ID
+    get :search, :q => query_builder('CREDIT',credit.credit_id, 'ID')
+    assert_redirected_to account_invoice_path(credit.account_id, credit.invoice_id)
+
+    # search by ID and fails
+    get :search, :q => query_builder('CREDIT',dummy_uuid, 'ID')
+    assert_redirected_to home_path
+    assert_equal "No credit matches \"#{dummy_uuid}\"", flash[:error]
+
+    # search by EXTERNAL_KEY and fails
+    get :search, :q => query_builder('CREDIT',dummy_uuid, 'EXTERNAL_KEY')
+    assert_redirected_to home_path
+    assert_equal "\"CREDIT\": Search by \"EXTERNAL KEY\" is not supported.", flash[:error]
+
+    # search by BLANK only first
+    get :search, :q => query_builder('CREDIT',credit.credit_id, nil, '1')
+    assert_redirected_to account_invoice_path(credit.account_id, credit.invoice_id)
+
+    # search by BLANK
+    get :search, :q => query_builder('CREDIT',credit.credit_id)
+    assert_redirected_to account_invoice_path(credit.account_id, credit.invoice_id)
+
+    # search by BLANK and fails
+    get :search, :q => query_builder('CREDIT',dummy_uuid)
+    assert_redirected_to home_path
+    assert_equal "No credit matches \"#{dummy_uuid}\"", flash[:error]
+  end
+
+  test 'should understand custom field search queries' do
+    dummy_uuid = SecureRandom.uuid.to_s
+    custom_field = create_custom_field
+    # search by ID
+    get :search, :q => query_builder('CUSTOM_FIELD',custom_field[0].custom_field_id, 'ID')
+    assert_redirected_to custom_fields_path(:q => custom_field[0].custom_field_id, :fast => '0')
+
+    # search by ID and fails
+    get :search, :q => query_builder('CUSTOM_FIELD',dummy_uuid, 'ID')
+    assert_redirected_to home_path
+    assert_equal "No custom field matches \"#{dummy_uuid}\"", flash[:error]
+
+    # search by EXTERNAL_KEY and fails
+    get :search, :q => query_builder('CUSTOM_FIELD','test', 'EXTERNAL_KEY')
+    assert_redirected_to home_path
+    assert_equal "\"CUSTOM FIELD\": Search by \"EXTERNAL KEY\" is not supported.", flash[:error]
+
+    # search by BLANK only first
+    get :search, :q => query_builder('CUSTOM_FIELD','test', nil, '1')
+    assert_redirected_to custom_fields_path(:q => 'test', :fast => '1')
+
+    # search by BLANK
+    get :search, :q => query_builder('CUSTOM_FIELD','test')
+    assert_redirected_to custom_fields_path(:q => 'test', :fast => '0')
+
+    # search by BLANK and fails
+    get :search, :q => query_builder('CUSTOM_FIELD','test_uui')
+    assert_redirected_to home_path
+    assert_equal "No custom field matches \"test_uui\"", flash[:error]
+  end
+
+  test 'should understand invoice payment search queries' do
+    dummy_uuid = SecureRandom.uuid.to_s
+    # search by ID
+    get :search, :q => query_builder('INVOICE_PAYMENT', @payment.payment_id, 'ID')
+    assert_redirected_to account_payment_path(@payment.account_id, @payment.payment_id)
+
+    # search by ID and fails
+    get :search, :q => query_builder('INVOICE_PAYMENT',dummy_uuid, 'ID')
+    assert_redirected_to home_path
+    assert_equal "No invoice payment matches \"#{dummy_uuid}\"", flash[:error]
+
+    # search by EXTERNAL_KEY and fails
+    get :search, :q => query_builder('INVOICE_PAYMENT','test', 'EXTERNAL_KEY')
+    assert_redirected_to home_path
+    assert_equal "\"INVOICE PAYMENT\": Search by \"EXTERNAL KEY\" is not supported.", flash[:error]
+
+    # search by BLANK only first
+    get :search, :q => query_builder('INVOICE_PAYMENT',@payment.payment_id, nil, '1')
+    assert_redirected_to account_payment_path(@payment.account_id, @payment.payment_id)
+
+    # search by BLANK
+    get :search, :q => query_builder('INVOICE_PAYMENT',@payment.payment_id)
+    assert_redirected_to account_payment_path(@payment.account_id, @payment.payment_id)
+
+    # search by BLANK and fails
+    get :search, :q => query_builder('INVOICE_PAYMENT',dummy_uuid)
+    assert_redirected_to home_path
+    assert_equal "No invoice payment matches \"#{dummy_uuid}\"", flash[:error]
+  end
+
+  test 'should understand subscription search queries' do
+    dummy_uuid = SecureRandom.uuid.to_s
+    subscription = @bundle.subscriptions[0]
+    # search by ID
+    get :search, :q => query_builder('SUBSCRIPTION', subscription.subscription_id, 'ID')
+    assert_redirected_to account_bundles_path(subscription.account_id)
+
+    # search by ID and fails
+    get :search, :q => query_builder('SUBSCRIPTION',dummy_uuid, 'ID')
+    assert_redirected_to home_path
+    assert_equal "No subscription matches \"#{dummy_uuid}\"", flash[:error]
+
+    # search by EXTERNAL_KEY and fails
+    get :search, :q => query_builder('SUBSCRIPTION','test', 'EXTERNAL_KEY')
+    assert_redirected_to home_path
+    assert_equal "\"SUBSCRIPTION\": Search by \"EXTERNAL KEY\" is not supported.", flash[:error]
+
+    # search by BLANK only first
+    get :search, :q => query_builder('SUBSCRIPTION',subscription.subscription_id, nil, '1')
+    assert_redirected_to account_bundles_path(subscription.account_id)
+
+    # search by BLANK
+    get :search, :q => query_builder('SUBSCRIPTION',subscription.subscription_id)
+    assert_redirected_to account_bundles_path(subscription.account_id)
+
+    # search by BLANK and fails
+    get :search, :q => query_builder('SUBSCRIPTION',dummy_uuid)
+    assert_redirected_to home_path
+    assert_equal "No subscription matches \"#{dummy_uuid}\"", flash[:error]
+  end
+
+  test 'should understand tag search queries' do
+    dummy_uuid = SecureRandom.uuid.to_s
+    tag = create_tag
+    # search by ID
+    get :search, :q => query_builder('TAG', tag[0].tag_id, 'ID')
+    assert_redirected_to tags_path(:q => tag[0].tag_id, :fast => '0')
+
+    # search by ID and fails
+    get :search, :q => query_builder('TAG',dummy_uuid, 'ID')
+    assert_redirected_to home_path
+    assert_equal "No tag matches \"#{dummy_uuid}\"", flash[:error]
+
+    # search by EXTERNAL_KEY and fails
+    get :search, :q => query_builder('TAG','test', 'EXTERNAL_KEY')
+    assert_redirected_to home_path
+    assert_equal "\"TAG\": Search by \"EXTERNAL KEY\" is not supported.", flash[:error]
+
+    # search by BLANK only first
+    get :search, :q => query_builder('TAG','account', nil, '1')
+    assert_redirected_to tags_path(:q => 'account', :fast => '1')
+
+    # search by BLANK
+    get :search, :q => query_builder('TAG','account')
+    assert_redirected_to tags_path(:q => 'account', :fast => '0')
+
+    # search by BLANK and fails
+    get :search, :q => query_builder('TAG',dummy_uuid)
+    assert_redirected_to home_path
+    assert_equal "No tag matches \"#{dummy_uuid}\"", flash[:error]
+  end
+
+  test 'should understand tag definition search queries' do
+    dummy_uuid = SecureRandom.uuid.to_s
+    tag_definition = create_account_tag_definition
+    # search by ID
+    get :search, :q => query_builder('TAG_DEFINITION', tag_definition.id, 'ID')
+    assert_redirected_to tag_definitions_path(:q => tag_definition.id, :fast => '0')
+
+    # search by ID and fails
+    get :search, :q => query_builder('TAG_DEFINITION',dummy_uuid, 'ID')
+    assert_redirected_to home_path
+    assert_equal "No tag definition matches \"#{dummy_uuid}\"", flash[:error]
+
+    # search by EXTERNAL_KEY and fails
+    get :search, :q => query_builder('TAG_DEFINITION','test', 'EXTERNAL_KEY')
+    assert_redirected_to home_path
+    assert_equal "\"TAG DEFINITION\": Search by \"EXTERNAL KEY\" is not supported.", flash[:error]
+
+    # search by BLANK only first
+    get :search, :q => query_builder('TAG_DEFINITION','account', nil, '1')
+    assert_redirected_to tag_definitions_path(:q => 'account', :fast => '1')
+
+    # search by BLANK
+    get :search, :q => query_builder('TAG_DEFINITION','account')
+    assert_redirected_to tag_definitions_path(:q => 'account', :fast => '0')
+
+    # search by BLANK and fails
+    get :search, :q => query_builder('TAG_DEFINITION',dummy_uuid)
+    assert_redirected_to home_path
+    assert_equal "No tag definition matches \"#{dummy_uuid}\"", flash[:error]
+  end
+
+  private
+
+  def query_builder(object_type, search_for, search_by = nil, fast = nil)
+    "FIND:#{object_type} #{(search_by.nil? ? '' : "BY:#{search_by}")} FOR:#{search_for} #{(fast.nil? ? '' : "ONLY_FIRST:#{fast}")}"
+  end
+
+  def create_credit
+    credit = KillBillClient::Model::Credit.new(:invoice_id => nil, :account_id => @account.account_id, :credit_amount => 2.22)
+    credit = credit.create(true, 'kaui search test', nil, nil, build_options(@tenant, USERNAME, PASSWORD))
+    credit
+  end
+
+  def create_custom_field
+    custom_field = Kaui::CustomField.new({ object_id: @account.account_id,
+                                             objectType: 'ACCOUNT',
+                                             name: 'test',
+                                             value: 'test' })
+    @account.add_custom_field(custom_field, 'kaui search test', nil, nil, build_options(@tenant, USERNAME, PASSWORD))
+  end
+
+  def create_account_tag_definition(name = 'account', description = 'i am an account')
+
+    tag_definition = Kaui::TagDefinition.new({is_control_tag: false,
+                                              name: name,
+                                              description: description,
+                                              applicable_object_types: ['ACCOUNT']})
+
+    tag_definition.create('kaui search test', nil, nil, build_options(@tenant, USERNAME, PASSWORD))
+  end
+
+  def create_tag
+    tag_definition = create_account_tag_definition
+    tags = [tag_definition.id]
+    Kaui::Tag.set_for_account(@account.account_id, tags, 'kaui search test', nil, nil, build_options(@tenant, USERNAME, PASSWORD ))
   end
 end