test: udpate specs

app/controllers/api/v1/accounts/search_controller.rb

@@ -21,6 +21,7 @@ class Api::V1::Accounts::SearchController < Api::V1::Accounts::BaseController
     SearchService.new(
       current_user: Current.user,
       current_account: Current.account,
+      current_account_user: Current.account_user,
       search_type: search_type,
       params: params
     ).perform

app/services/search_service.rb

@@ -1,5 +1,5 @@
 class SearchService
-  pattr_initialize [:current_user!, :current_account!, :params!, :search_type!]
+  pattr_initialize [:current_user!, :current_account!, :current_account_user!, :params!, :search_type!]
 
   def perform
     case search_type
@@ -25,13 +25,16 @@ class SearchService
   end
 
   def filter_conversations
-    @conversations = current_account.conversations.where(inbox_id: accessable_inbox_ids)
-                                    .joins('INNER JOIN contacts ON conversations.contact_id = contacts.id')
-                                    .where("cast(conversations.display_id as text) ILIKE :search OR contacts.name ILIKE :search OR contacts.email
-                            ILIKE :search OR contacts.phone_number ILIKE :search OR contacts.identifier ILIKE :search", search: "%#{search_query}%")
-                                    .order('conversations.created_at DESC')
-                                    .page(params[:page])
-                                    .per(15)
+    query = current_account.conversations
+    # admins can see all conversations anyway, so no need to add the heavy IN clause
+    query = query.where(inbox_id: accessable_inbox_ids) unless @current_account_user.administrator?
+
+    @conversations = query.joins('INNER JOIN contacts ON conversations.contact_id = contacts.id')
+                          .where("cast(conversations.display_id as text) ILIKE :search OR contacts.name ILIKE :search OR contacts.email
+                      ILIKE :search OR contacts.phone_number ILIKE :search OR contacts.identifier ILIKE :search", search: "%#{search_query}%")
+                          .order('conversations.created_at DESC')
+                          .page(params[:page])
+                          .per(15)
   end
 
   def filter_messages
@@ -47,16 +50,7 @@ class SearchService
 
     if search_query.present?
       # Use the @@ operator with to_tsquery for better GIN index utilization
-      # Convert search query to tsquery format with prefix matching
-
-      # Use this if we wanna match splitting the words
-      # split_query = search_query.split.map { |term| "#{term} | #{term}:*" }.join(' & ')
-
-      # This will do entire sentence matching using phrase distance operator
-      tsquery = search_query.split.join(' <-> ')
-
-      # Apply the text search using the GIN index
-      base_query.where('content @@ to_tsquery(?)', tsquery)
+      base_query.where('content @@ to_tsquery(?)', search_query)
                 .reorder('created_at DESC')
                 .page(params[:page])
                 .per(15)
@@ -76,12 +70,14 @@ class SearchService
   end
 
   def message_base_query
-    current_account.messages.where(inbox_id: accessable_inbox_ids)
-                   .where('created_at >= ?', 3.months.ago)
+    query = current_account.messages
+    # admins can see all conversations anyway, so no need to add the heavy IN clause
+    query = query.where(inbox_id: accessable_inbox_ids) unless @current_account_user.administrator?
+    query.where('created_at >= ?', 3.months.ago)
   end
 
   def use_gin_search
-    current_account.feature_enabled?('search_with_gin')
+    search_query.split.size == 1
   end
 
   def filter_contacts

spec/services/search_service_spec.rb

@@ -1,7 +1,10 @@
 require 'rails_helper'
 
 describe SearchService do
-  subject(:search) { described_class.new(current_user: user, current_account: account, params: params, search_type: search_type) }
+  subject(:search) do
+    described_class.new(current_user: user, current_account: account, current_account_user: user.account_users.find_by(account: account),
+                        params: params, search_type: search_type)
+  end
 
   let(:search_type) { 'all' }
   let!(:account) { create(:account) }
@@ -26,25 +29,33 @@ describe SearchService do
 
       it 'returns all for all' do
         search_type = 'all'
-        search = described_class.new(current_user: user, current_account: account, params: params, search_type: search_type)
+        search = described_class.new(current_user: user, current_account: account,
+                                     current_account_user: user.account_users.find_by(account: account),
+                                     params: params, search_type: search_type)
         expect(search.perform.keys).to match_array(%i[contacts messages conversations])
       end
 
       it 'returns contacts for contacts' do
         search_type = 'Contact'
-        search = described_class.new(current_user: user, current_account: account, params: params, search_type: search_type)
+        search = described_class.new(current_user: user, current_account: account,
+                                     current_account_user: user.account_users.find_by(account: account),
+                                     params: params, search_type: search_type)
         expect(search.perform.keys).to match_array(%i[contacts])
       end
 
       it 'returns messages for messages' do
         search_type = 'Message'
-        search = described_class.new(current_user: user, current_account: account, params: params, search_type: search_type)
+        search = described_class.new(current_user: user, current_account: account,
+                                     current_account_user: user.account_users.find_by(account: account),
+                                     params: params, search_type: search_type)
         expect(search.perform.keys).to match_array(%i[messages])
       end
 
       it 'returns conversations for conversations' do
         search_type = 'Conversation'
-        search = described_class.new(current_user: user, current_account: account, params: params, search_type: search_type)
+        search = described_class.new(current_user: user, current_account: account,
+                                     current_account_user: user.account_users.find_by(account: account),
+                                     params: params, search_type: search_type)
         expect(search.perform.keys).to match_array(%i[conversations])
       end
     end
@@ -61,7 +72,8 @@ describe SearchService do
         harry4 = create(:contact, identifier: 'Potter1235', account_id: account.id, last_activity_at: 2.minutes.ago)
 
         params = { q: 'Potter ' }
-        search = described_class.new(current_user: user, current_account: account, params: params, search_type: 'Contact')
+        search = described_class.new(current_user: user, current_account: account,
+                                     current_account_user: user.account_users.find_by(account: account), params: params, search_type: 'Contact')
         expect(search.perform[:contacts].map(&:id)).to eq([harry4.id, harry3.id, harry2.id, harry.id])
       end
     end
@@ -75,17 +87,19 @@ describe SearchService do
         # random messsage in inbox with out access
         create(:message, account: account, inbox: create(:inbox, account: account), content: 'Harry Potter is a wizard')
         params = { q: 'Harry' }
-        search = described_class.new(current_user: user, current_account: account, params: params, search_type: 'Message')
+        search = described_class.new(current_user: user, current_account: account,
+                                     current_account_user: user.account_users.find_by(account: account), params: params, search_type: 'Message')
         expect(search.perform[:messages].map(&:id)).to eq([message2.id, message.id])
       end
 
-      context 'with feature flag for search type' do
-        let(:params) { { q: 'Harry' } }
+      context 'with different search methods' do
         let(:search_type) { 'Message' }
 
-        it 'uses LIKE search when search_with_gin feature is disabled' do
-          allow(account).to receive(:feature_enabled?).with('search_with_gin').and_return(false)
-          search_service = described_class.new(current_user: user, current_account: account, params: params, search_type: search_type)
+        it 'uses LIKE search for multi-word queries' do
+          params = { q: 'Harry Potter' }
+          search_service = described_class.new(current_user: user, current_account: account,
+                                               current_account_user: user.account_users.find_by(account: account),
+                                               params: params, search_type: search_type)
 
           expect(search_service).to receive(:filter_messages_with_like).and_call_original
           expect(search_service).not_to receive(:filter_messages_with_gin)
@@ -93,9 +107,11 @@ describe SearchService do
           search_service.perform
         end
 
-        it 'uses GIN search when search_with_gin feature is enabled' do
-          allow(account).to receive(:feature_enabled?).with('search_with_gin').and_return(true)
-          search_service = described_class.new(current_user: user, current_account: account, params: params, search_type: search_type)
+        it 'uses GIN search for single-word queries' do
+          params = { q: 'Harry' }
+          search_service = described_class.new(current_user: user, current_account: account,
+                                               current_account_user: user.account_users.find_by(account: account),
+                                               params: params, search_type: search_type)
 
           expect(search_service).to receive(:filter_messages_with_gin).and_call_original
           expect(search_service).not_to receive(:filter_messages_with_like)
@@ -103,24 +119,39 @@ describe SearchService do
           search_service.perform
         end
 
-        it 'returns same results regardless of search type' do
+        it 'returns same results for single word regardless of search method' do
           # Create test messages
           message3 = create(:message, account: account, inbox: inbox, content: 'Harry is a wizard apprentice')
+          params = { q: 'Harry' }
 
-          # Test with GIN search
-          allow(account).to receive(:feature_enabled?).with('search_with_gin').and_return(true)
-          gin_search = described_class.new(current_user: user, current_account: account, params: params, search_type: search_type)
+          # Test with GIN search (single word)
+          gin_search = described_class.new(current_user: user, current_account: account,
+                                           current_account_user: user.account_users.find_by(account: account),
+                                           params: params, search_type: search_type)
+          allow(gin_search).to receive(:use_gin_search).and_return(true)
           gin_results = gin_search.perform[:messages].map(&:id)
 
-          # Test with LIKE search
-          allow(account).to receive(:feature_enabled?).with('search_with_gin').and_return(false)
-          like_search = described_class.new(current_user: user, current_account: account, params: params, search_type: search_type)
+          # Test with LIKE search (forcing LIKE for comparison)
+          like_search = described_class.new(current_user: user, current_account: account,
+                                            current_account_user: user.account_users.find_by(account: account),
+                                            params: params, search_type: search_type)
+          allow(like_search).to receive(:use_gin_search).and_return(false)
           like_results = like_search.perform[:messages].map(&:id)
 
           # Both search types should return the same messages
           expect(gin_results).to match_array(like_results)
           expect(gin_results).to include(message.id, message2.id, message3.id)
         end
+
+        it 'handles empty search queries' do
+          params = { q: '' }
+          search_service = described_class.new(current_user: user, current_account: account,
+                                               current_account_user: user.account_users.find_by(account: account),
+                                               params: params, search_type: search_type)
+
+          results = search_service.perform[:messages]
+          expect(results).to be_a(ActiveRecord::Relation)
+        end
       end
     end
 
@@ -131,7 +162,8 @@ describe SearchService do
         create(:conversation, contact: random, inbox: inbox, account: account)
         conv2 = create(:conversation, contact: harry, inbox: inbox, account: account)
         params = { q: 'Harry' }
-        search = described_class.new(current_user: user, current_account: account, params: params, search_type: 'Conversation')
+        search = described_class.new(current_user: user, current_account: account,
+                                     current_account_user: user.account_users.find_by(account: account), params: params, search_type: 'Conversation')
         expect(search.perform[:conversations].map(&:id)).to eq([conv2.id, conversation.id])
       end
 
@@ -139,28 +171,86 @@ describe SearchService do
         random = create(:contact, account_id: account.id, name: 'random', email: 'random@random.test', identifier: 'random')
         new_converstion = create(:conversation, contact: random, inbox: inbox, account: account)
         params = { q: new_converstion.display_id }
-        search = described_class.new(current_user: user, current_account: account, params: params, search_type: 'Conversation')
+        search = described_class.new(current_user: user, current_account: account,
+                                     current_account_user: user.account_users.find_by(account: account), params: params, search_type: 'Conversation')
         expect(search.perform[:conversations].map(&:id)).to include new_converstion.id
       end
     end
   end
 
   describe '#use_gin_search' do
-    let(:params) { { q: 'test' } }
-
-    it 'checks if the account has the search_with_gin feature enabled' do
-      expect(account).to receive(:feature_enabled?).with('search_with_gin')
-      search.send(:use_gin_search)
-    end
-
-    it 'returns true when search_with_gin feature is enabled' do
-      allow(account).to receive(:feature_enabled?).with('search_with_gin').and_return(true)
+    it 'returns true for single-word queries' do
+      params = { q: 'test' }
+      search = described_class.new(current_user: user, current_account: account, current_account_user: user.account_users.find_by(account: account),
+                                   params: params, search_type: 'Message')
       expect(search.send(:use_gin_search)).to be true
     end
 
-    it 'returns false when search_with_gin feature is disabled' do
-      allow(account).to receive(:feature_enabled?).with('search_with_gin').and_return(false)
+    it 'returns false for multi-word queries' do
+      params = { q: 'test query' }
+      search = described_class.new(current_user: user, current_account: account, current_account_user: user.account_users.find_by(account: account),
+                                   params: params, search_type: 'Message')
+      expect(search.send(:use_gin_search)).to be false
+    end
+
+    it 'returns false for empty queries' do
+      params = { q: '' }
+      search = described_class.new(current_user: user, current_account: account, current_account_user: user.account_users.find_by(account: account),
+                                   params: params, search_type: 'Message')
+      expect(search.send(:use_gin_search)).to be false
+    end
+
+    it 'returns false for nil queries' do
+      params = { q: nil }
+      search = described_class.new(current_user: user, current_account: account, current_account_user: user.account_users.find_by(account: account),
+                                   params: params, search_type: 'Message')
       expect(search.send(:use_gin_search)).to be false
     end
   end
+
+  describe '#accessable_inbox_ids' do
+    it 'returns inbox ids assigned to the user' do
+      search = described_class.new(current_user: user, current_account: account, current_account_user: user.account_users.find_by(account: account),
+                                   params: {}, search_type: 'Message')
+      expect(search.send(:accessable_inbox_ids)).to eq([inbox.id])
+    end
+  end
+
+  describe '#message_base_query' do
+    it 'returns messages from the last 3 months' do
+      old_message = create(:message, account: account, inbox: inbox, content: 'old message', created_at: 4.months.ago)
+      recent_message = create(:message, account: account, inbox: inbox, content: 'recent message', created_at: 2.months.ago)
+
+      search = described_class.new(current_user: user, current_account: account, current_account_user: user.account_users.find_by(account: account),
+                                   params: {}, search_type: 'Message')
+      base_query = search.send(:message_base_query)
+
+      expect(base_query).to include(recent_message)
+      expect(base_query).not_to include(old_message)
+    end
+
+    it 'filters by inbox_id for non-administrators' do
+      other_inbox = create(:inbox, account: account)
+      other_inbox_message = create(:message, account: account, inbox: other_inbox, content: 'other inbox message')
+
+      search = described_class.new(current_user: user, current_account: account, current_account_user: user.account_users.find_by(account: account),
+                                   params: {}, search_type: 'Message')
+      base_query = search.send(:message_base_query)
+
+      expect(base_query).not_to include(other_inbox_message)
+    end
+
+    it 'does not filter by inbox_id for administrators' do
+      # Create a new user with administrator role
+      admin_user = create(:user, account: account, role: :administrator)
+      other_inbox = create(:inbox, account: account)
+      other_inbox_message = create(:message, account: account, inbox: other_inbox, content: 'other inbox message')
+
+      search = described_class.new(current_user: admin_user, current_account: account,
+                                   current_account_user: admin_user.account_users.find_by(account: account), params: {}, search_type: 'Message')
+      base_query = search.send(:message_base_query)
+
+      expect(base_query).to include(other_inbox_message)
+    end
+  end
 end