Fixes #39002 - Handle nil hostgroup in GroupParameter search

When searching for hosts by parameters, the search_by_params method
would crash with "NoMethodError: undefined method 'subtree_ids' for
nil:NilClass" if it encountered a GroupParameter with a nil hostgroup
association (orphaned parameter).

This can occur due to the polymorphic nature of the Parameter model's
reference_id column in the STI table design, where database-level
foreign key constraints are not possible. If a hostgroup is deleted
outside of Rails or cascade delete fails, orphaned GroupParameters
can exist.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

This commit properly handles negated
searches like "not params.foo = bar".

When conditions were blank (due to orphaned parameters) but negate was
present, the code would create a string starting with " NOT(...)" which
caused invalid SQL generation: "NOT COALESCE(, false)".

This commit fixes the issue by ensuring we always build valid SQL:
- If conditions is blank but negate is present: "NOT(negate)"
- If both conditions and negate are present: "conditions AND NOT(negate)"
- If only conditions is present: "conditions" (unchanged)
- If both are blank: "1 = 0" (no results)

This prevents SQL syntax errors while maintaining correct search semantics.

Also added test coverage for negated searches with orphaned parameters.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: jeremylenz

app/models/concerns/hostext/search.rb

@@ -196,8 +196,18 @@ def search_by_params(key, operator, value)
         conditions = param_conditions(p)
         negate = param_conditions(n)
 
-        conditions += " AND " unless conditions.blank? || negate.blank?
-        conditions += " NOT(#{negate})" if negate.present?
+        # If we have parameters but no valid conditions (e.g., all GroupParameters have nil hostgroup),
+        # return no results instead of matching all hosts
+        return {:conditions => '1 = 0'} if conditions.blank? && negate.blank?
+
+        # If only the positive conditions are blank (orphaned), but we have negations,
+        # we need to negate from a base of "all hosts"
+        if conditions.blank? && negate.present?
+          conditions = "NOT(#{negate})"
+        elsif conditions.present? && negate.present?
+          conditions += " AND NOT(#{negate})"
+        end
+
         {:joins => :primary_interface, :conditions => conditions}
       end
 
@@ -274,7 +284,9 @@ def param_conditions(p)
             when 'OsParameter'
               conditions << "hosts.operatingsystem_id = #{param.reference_id}"
             when 'GroupParameter'
-              conditions << "hosts.hostgroup_id IN (#{param.hostgroup.subtree_ids.join(', ')})"
+              if param.hostgroup.present?
+                conditions << "hosts.hostgroup_id IN (#{param.hostgroup.subtree_ids.join(', ')})"
+              end
             when 'HostParameter'
               conditions << "hosts.id = #{param.reference_id}"
             when 'OrganizationParameter'

test/models/concerns/hostext/search_test.rb

@@ -271,6 +271,56 @@ class SearchTest < ActiveSupport::TestCase
         it { assert_includes(subject, built_status.host) }
         it { assert_not_includes(subject, build_failed_status.host) }
       end
+
+      context "search by parameters" do
+        let(:hostgroup) { FactoryBot.create(:hostgroup) }
+        let(:group_param) { FactoryBot.create(:hostgroup_parameter, name: 'test_param', value: 'test_value', hostgroup: hostgroup) }
+        let(:host_with_param) { FactoryBot.create(:host, hostgroup: hostgroup) }
+        let(:host_without_param) { FactoryBot.create(:host) }
+
+        setup do
+          group_param
+          host_with_param
+          host_without_param
+        end
+
+        test "can search hosts by GroupParameter value" do
+          result = Host.search_for("params.test_param = test_value")
+          assert_includes result, host_with_param
+          assert_not_includes result, host_without_param
+        end
+
+        test "handles orphaned GroupParameter with nil hostgroup gracefully" do
+          # Create an orphaned GroupParameter (bypassing validation)
+          orphaned_param = GroupParameter.new(name: 'orphaned_param', value: 'orphaned_value')
+          orphaned_param.save(validate: false)
+
+          # Search should not crash even with orphaned parameter
+          assert_nothing_raised do
+            Host.search_for("params.orphaned_param = orphaned_value")
+          end
+
+          # Should return empty results since no host has this orphaned param
+          result = Host.search_for("params.orphaned_param = orphaned_value")
+          assert_empty result
+        end
+
+        test "handles negated search with orphaned GroupParameter" do
+          # Create an orphaned GroupParameter with value 'f'
+          orphaned_param = GroupParameter.new(name: 'test_negation', value: 'f')
+          orphaned_param.save(validate: false)
+
+          # Search "not params.test_negation = f" should not crash with SQL syntax error
+          assert_nothing_raised do
+            Host.search_for("not params.test_negation = f")
+          end
+
+          # Since the orphaned param doesn't apply to any host, no host has test_negation=f,
+          # therefore all hosts match "not params.test_negation = f"
+          result = Host.search_for("not params.test_negation = f")
+          assert_equal Host.count, result.count
+        end
+      end
     end
   end
 end