refactor(trade): expose a single buildInfluenceFilters helper

The three helpers resolveInfluenceQueryState / needsHasInfluenceFilter /
countInfluenceFilters were each exported to the test mock so the spec
could assert on intermediate state. That surface tested the shape of the
computation rather than its outcome.

Introduce buildInfluenceFilters(selection1, selection2) that returns the
exact query fragments ExecuteQuery needs — the and-group filters, the
top-level NOT stats (only populated for "no influences"), and the total
filter-slot count. ExecuteQuery now computes the influence filters and
the slot budget in a single call and inlines the fragments, dropping
~20 lines of duplicated query-building logic.

Tests are rewritten to exercise the helper directly and assert on the
resulting filter table, giving genuine end-to-end coverage of the nine
pair combinations. Only _buildInfluenceFilters, _hasAnyInfluenceModId
and the INFLUENCE_*_INDEX constants remain as test accessors; the three
internal-state helpers are no longer reachable from outside the module.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: mcagnion

spec/System/TestTradeQueryGenerator_spec.lua

@@ -37,88 +37,89 @@ describe("TradeQueryGenerator", function()
 		end)
 	end)
 
-	describe("Influence query state", function()
+	describe("Influence query fragments", function()
 		local IGNORE = mock_queryGen._INFLUENCE_IGNORE_INDEX  -- 1
 		local NONE   = mock_queryGen._INFLUENCE_NONE_INDEX    -- 2
 		local ANY    = mock_queryGen._INFLUENCE_ANY_INDEX     -- 3
 		local SHAPER = ANY + 1  -- 4
 		local ELDER  = ANY + 2  -- 5
-		local resolve = mock_queryGen._resolveInfluenceQueryState
-		local count   = mock_queryGen._countInfluenceFilters
-		local needs   = mock_queryGen._needsHasInfluenceFilter
+		local build  = mock_queryGen._buildInfluenceFilters
+		local HAS_INFLUENCE = mock_queryGen._hasAnyInfluenceModId  -- "pseudo.pseudo_has_influence_count"
+		local HAS_SHAPER = "pseudo.pseudo_has_shaper_influence"
 
-		-- None: uses pseudo_has_influence=0 (1 slot instead of 6-slot NOT filter)
-		it("None uses 1-slot pseudo_has_influence=0", function()
-			local state = resolve(NONE, IGNORE)
-			assert.are.equal(state.exactCount, 0)
-			assert.is_true(state.hasNoneConstraint)
-			assert.are.equal(count(state), 1)
-			assert.is_true(needs(state))
+		it("Ignore / Ignore produces no filters", function()
+			local andGroup, topStats, slots = build(IGNORE, IGNORE)
+			assert.are.equal(#andGroup, 0)
+			assert.are.equal(#topStats, 0)
+			assert.are.equal(slots, 0)
 		end)
 
-		-- Shaper+None: needs pseudo_has_influence=1 to cap at 1 influence (avoids Shaper+Elder matches)
-		it("Shaper+None uses 2-slot filter (specific + pseudo_has_influence=1)", function()
-			local state = resolve(SHAPER, NONE)
-			assert.are.equal(state.exactCount, 1)
-			assert.is_true(state.hasNoneConstraint)
-			assert.are.equal(#state.specificInfluenceModIds, 1)
-			assert.are.equal(count(state), 2)
-			assert.is_true(needs(state))
+		it("None / None emits a NOT clause at the top level (no influences)", function()
+			local andGroup, topStats, slots = build(NONE, NONE)
+			assert.are.equal(#andGroup, 0)
+			assert.are.equal(#topStats, 1)
+			assert.are.same(topStats[1], { type = "not", filters = { { id = HAS_INFLUENCE } } })
+			assert.are.equal(slots, 1)
 		end)
 
-		-- Shaper+Elder: 2 named influences, no None → no pseudo_has_influence needed (saves 1 slot)
-		it("Shaper+Elder uses 2-slot filter (specific mods only, no pseudo_has_influence)", function()
-			local state = resolve(SHAPER, ELDER)
-			assert.are.equal(state.exactCount, 2)
-			assert.is_false(state.hasNoneConstraint)
-			assert.are.equal(#state.specificInfluenceModIds, 2)
-			assert.are.equal(count(state), 2)
-			assert.is_false(needs(state))
+		it("Any / Ignore caps min=1 (at least one influence)", function()
+			local andGroup, topStats, slots = build(ANY, IGNORE)
+			assert.are.equal(#topStats, 0)
+			assert.are.same(andGroup, { { id = HAS_INFLUENCE, value = { min = 1 } } })
+			assert.are.equal(slots, 1)
 		end)
 
-		-- Any+Ignore: minCount=1 → pseudo_has_influence min=1 (1 slot)
-		it("Any uses 1-slot pseudo_has_influence min=1", function()
-			local state = resolve(ANY, IGNORE)
-			assert.are.equal(state.minCount, 1)
-			assert.are.equal(state.exactCount, nil)
-			assert.are.equal(count(state), 1)
-			assert.is_true(needs(state))
+		it("Shaper / None caps exactly 1 of that specific", function()
+			local andGroup, topStats, slots = build(SHAPER, NONE)
+			assert.are.equal(#topStats, 0)
+			assert.are.same(andGroup, {
+				{ id = HAS_INFLUENCE, value = { min = 1, max = 1 } },
+				{ id = HAS_SHAPER },
+			})
+			assert.are.equal(slots, 2)
 		end)
 
-		-- Any+Shaper: exactCount=2 with one unnamed slot → needs pseudo_has_influence=2
-		it("Any+Shaper uses 2-slot filter (specific + pseudo_has_influence=2)", function()
-			local state = resolve(ANY, SHAPER)
-			assert.are.equal(state.exactCount, 2)
-			assert.is_false(state.hasNoneConstraint)
-			assert.are.equal(#state.specificInfluenceModIds, 1)
-			assert.are.equal(count(state), 2)
-			assert.is_true(needs(state))
+		it("Shaper / Ignore requires the specific without a count cap", function()
+			local andGroup, topStats, slots = build(SHAPER, IGNORE)
+			assert.are.equal(#topStats, 0)
+			assert.are.same(andGroup, { { id = HAS_SHAPER } })
+			assert.are.equal(slots, 1)
 		end)
 
-		-- pseudo_has_influence mod ID is correct
-		it("hasAnyInfluenceModId is pseudo.pseudo_has_influence_count", function()
-			assert.are.equal(mock_queryGen._hasAnyInfluenceModId, "pseudo.pseudo_has_influence_count")
+		it("Any / Any caps exactly 2 influences", function()
+			local andGroup, topStats, slots = build(ANY, ANY)
+			assert.are.equal(#topStats, 0)
+			assert.are.same(andGroup, { { id = HAS_INFLUENCE, value = { min = 2, max = 2 } } })
+			assert.are.equal(slots, 1)
 		end)
 
-		-- Same specific influence on both sides is redundant at the item level and must
-		-- collapse to the <specific> / None semantic (exactly 1 of that type), not
-		-- double-count and not collapse to <specific> / Ignore. Verify via the
-		-- needsHasInfluenceFilter gate that builds the pseudo_has_influence cap — without
-		-- it, the query would match items with any number of influences including Shaper.
-		it("Shaper+Shaper produces the full Shaper+None query state", function()
-			local dup = resolve(SHAPER, SHAPER)
-			local paired = resolve(SHAPER, NONE)
-			assert.are.equal(dup.exactCount, paired.exactCount)
-			assert.are.equal(dup.hasNoneConstraint, paired.hasNoneConstraint)
-			assert.are.equal(#dup.specificInfluenceModIds, #paired.specificInfluenceModIds)
-			assert.are.equal(dup.specificInfluenceModIds[1], paired.specificInfluenceModIds[1])
-			assert.are.equal(count(dup), count(paired))
-			assert.are.equal(needs(dup), needs(paired))
+		it("Shaper / Any caps exactly 2 including Shaper", function()
+			local andGroup, topStats, slots = build(SHAPER, ANY)
+			assert.are.equal(#topStats, 0)
+			assert.are.same(andGroup, {
+				{ id = HAS_INFLUENCE, value = { min = 2, max = 2 } },
+				{ id = HAS_SHAPER },
+			})
+			assert.are.equal(slots, 2)
 		end)
 
-		it("Shaper+Shaper needs the pseudo_has_influence cap to enforce exactly 1", function()
-			local state = resolve(SHAPER, SHAPER)
-			assert.is_true(needs(state))
+		it("Shaper / Elder requires both specifics without a count cap", function()
+			local andGroup, topStats, slots = build(SHAPER, ELDER)
+			assert.are.equal(#topStats, 0)
+			assert.are.equal(#andGroup, 2)
+			assert.are.equal(slots, 2)
+		end)
+
+		-- Same specific on both sides is redundant at the item level and must produce
+		-- the exact same filter set as <specific> / None (exactly 1 of that type).
+		-- Without the None-constraint dedup, it would silently fall back to the
+		-- <specific> / Ignore form and fail to cap the influence count.
+		it("Shaper / Shaper produces the same filters as Shaper / None", function()
+			local dupAnd, dupStats, dupSlots = build(SHAPER, SHAPER)
+			local pairedAnd, pairedStats, pairedSlots = build(SHAPER, NONE)
+			assert.are.same(dupAnd, pairedAnd)
+			assert.are.same(dupStats, pairedStats)
+			assert.are.equal(dupSlots, pairedSlots)
 		end)
 	end)
 

src/Classes/TradeQueryGenerator.lua

@@ -193,11 +193,39 @@ local function needsHasInfluenceFilter(influenceState)
 end
 
 local function countInfluenceFilters(influenceState)
-	local cost = #influenceState.specificInfluenceModIds
+	local count = #influenceState.specificInfluenceModIds
 	if needsHasInfluenceFilter(influenceState) then
-		cost = cost + 1
+		count = count + 1
 	end
-	return cost
+	return count
+end
+
+-- Builds the influence-related trade query fragments from the two dropdown
+-- selections. Returns three values so callers can plug the fragments into the
+-- final query and size the remaining filter budget in a single call:
+--   andGroup: filters to append inside the top-level AND group
+--   topStats: filters to append directly to queryTable.query.stats
+--            (only non-empty when the pair represents "no influences", which
+--            requires a NOT clause rather than a value range)
+--   slotCount: total filter slots the influence fragments will consume
+local function buildInfluenceFilters(selection1, selection2)
+	local state = resolveInfluenceQueryState(selection1, selection2)
+	local andGroup = { }
+	local topStats = { }
+	if needsHasInfluenceFilter(state) then
+		if state.exactCount == 0 then
+			-- "has 0 influences" cannot be queried with a value range; use NOT instead.
+			t_insert(topStats, { type = "not", filters = { { id = hasAnyInfluenceModId } } })
+		elseif state.exactCount ~= nil then
+			t_insert(andGroup, { id = hasAnyInfluenceModId, value = { min = state.exactCount, max = state.exactCount } })
+		else
+			t_insert(andGroup, { id = hasAnyInfluenceModId, value = { min = state.minCount } })
+		end
+	end
+	for _, modId in ipairs(state.specificInfluenceModIds) do
+		t_insert(andGroup, { id = modId })
+	end
+	return andGroup, topStats, countInfluenceFilters(state)
 end
 
 local TradeQueryGeneratorClass = newClass("TradeQueryGenerator", function(self, queryTab)
@@ -1081,8 +1109,8 @@ function TradeQueryGeneratorClass:FinishQuery()
 	}
 
 	local options = self.calcContext.options
-	local influenceState = resolveInfluenceQueryState(options.influence1, options.influence2)
-	local num_extra = countInfluenceFilters(influenceState)
+	local influenceAndGroup, influenceTopStats, influenceSlotCount = buildInfluenceFilters(options.influence1, options.influence2)
+	local num_extra = influenceSlotCount
 	if not options.includeMirrored then
 		num_extra = num_extra + 1
 	end
@@ -1115,22 +1143,13 @@ function TradeQueryGeneratorClass:FinishQuery()
 
 	local andFilters = { type = "and", filters = { } }
 	local options = self.calcContext.options
-	if needsHasInfluenceFilter(influenceState) then
-		if influenceState.exactCount == 0 then
-			-- "has 0 influences" cannot be queried with a value range; use NOT instead
-			t_insert(queryTable.query.stats, { type = "not", filters = { { id = hasAnyInfluenceModId } } })
-		elseif influenceState.exactCount ~= nil then
-			t_insert(andFilters.filters, { id = hasAnyInfluenceModId, value = { min = influenceState.exactCount, max = influenceState.exactCount } })
-		else
-			t_insert(andFilters.filters, { id = hasAnyInfluenceModId, value = { min = influenceState.minCount } })
-		end
-		filters = filters + 1
+	for _, stat in ipairs(influenceTopStats) do
+		t_insert(queryTable.query.stats, stat)
 	end
-
-	for _, modId in ipairs(influenceState.specificInfluenceModIds) do
-		t_insert(andFilters.filters, { id = modId })
-		filters = filters + 1
+	for _, filter in ipairs(influenceAndGroup) do
+		t_insert(andFilters.filters, filter)
 	end
+	filters = filters + influenceSlotCount
 
 	if #andFilters.filters > 0 then
 		t_insert(queryTable.query.stats, andFilters)
@@ -1222,10 +1241,7 @@ function TradeQueryGeneratorClass:FinishQuery()
 	main:ClosePopup()
 end
 
--- Test accessors for influence query state logic (not used in production paths)
-TradeQueryGeneratorClass._resolveInfluenceQueryState = resolveInfluenceQueryState
-TradeQueryGeneratorClass._countInfluenceFilters = countInfluenceFilters
-TradeQueryGeneratorClass._needsHasInfluenceFilter = needsHasInfluenceFilter
+TradeQueryGeneratorClass._buildInfluenceFilters = buildInfluenceFilters
 TradeQueryGeneratorClass._hasAnyInfluenceModId = hasAnyInfluenceModId
 TradeQueryGeneratorClass._INFLUENCE_IGNORE_INDEX = INFLUENCE_IGNORE_INDEX
 TradeQueryGeneratorClass._INFLUENCE_NONE_INDEX = INFLUENCE_NONE_INDEX