pkg/passive/ratelimit_test.go (2)

64-69: Test name is misleading: tests empty struct, not nil pointer.

The test is named TestResolveSourceRateLimit_NilRateLimit but passes &subscraping.CustomRateLimit{} (a zero-valued struct with nil internal maps), not an actual nil pointer. This distinction matters because:

1. The function doesn't receive a nil pointer here
2. The zero-valued struct has nil Map fields inside, which may panic

Consider renaming to TestResolveSourceRateLimit_EmptyRateLimit or TestResolveSourceRateLimit_ZeroValuedRateLimit to accurately describe what's being tested.

♻️ Suggested rename

-func TestResolveSourceRateLimit_NilRateLimit(t *testing.T) {
-	// nil CustomRateLimit should not panic
+func TestResolveSourceRateLimit_ZeroValuedRateLimit(t *testing.T) {
+	// Zero-valued CustomRateLimit (with nil internal maps) should not panic
 	rl, dur := resolveSourceRateLimit(5, &subscraping.CustomRateLimit{}, "crtsh")

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@pkg/passive/ratelimit_test.go` around lines 64 - 69, Rename the test
TestResolveSourceRateLimit_NilRateLimit to accurately reflect that it passes a
zero-valued struct (not a nil pointer); for example
TestResolveSourceRateLimit_EmptyRateLimit or
TestResolveSourceRateLimit_ZeroValuedRateLimit, and update the test name string
accordingly where the function resolveSourceRateLimit is invoked with
&subscraping.CustomRateLimit{} so readers understand it is testing the
empty/zero-valued struct case rather than a nil pointer.

---

115-125: Remove dead code reference.

Line 124 (_ = math.MaxUint32) serves no purpose—it doesn't assert anything and the comment "referenced for clarity" doesn't clarify the test behavior. Consider removing it or adding a meaningful assertion about the unlimited behavior.

♻️ Proposed cleanup

 func TestBuildMultiRateLimiter_UnlimitedWhenNoLimits(t *testing.T) {
 	// Without any rate limits, sources should get MaxUint32 (effectively unlimited)
 	agent := New([]string{"hackertarget"}, []string{}, false, false)
 	crl := newCustomRateLimit(nil, nil)

 	limiter, err := agent.buildMultiRateLimiter(context.Background(), 0, crl)
 	require.NoError(t, err)
 	require.NotNil(t, limiter)
-	// No assertion on internal state - just verify it doesn't error
-	_ = math.MaxUint32 // referenced for clarity
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@pkg/passive/ratelimit_test.go` around lines 115 - 125, The test
TestBuildMultiRateLimiter_UnlimitedWhenNoLimits contains a dead reference "_ =
math.MaxUint32" that should be removed or replaced; locate the test and either
delete the pointless line or add a meaningful assertion that verifies the
returned limiter from agent.buildMultiRateLimiter (created with
newCustomRateLimit(nil, nil)) grants unlimited behavior (e.g., check limiter is
non-nil and/or its per-source limit equals math.MaxUint32) and remove the unused
math.MaxUint32 assignment if you opt to keep the test minimal.

pkg/passive/ratelimit_test.go (1)

115-125: Remove dead code: the math.MaxUint32 reference is a no-op.

Line 124 assigns to the blank identifier and has no effect. The comment says "referenced for clarity" but this doesn't verify any behavior. Either add an actual assertion or remove this line along with the unused math import.

🧹 Proposed cleanup

 import (
 	"context"
-	"math"
 	"testing"
 	"time"

 func TestBuildMultiRateLimiter_UnlimitedWhenNoLimits(t *testing.T) {
 	// Without any rate limits, sources should get MaxUint32 (effectively unlimited)
 	agent := New([]string{"hackertarget"}, []string{}, false, false)
 	crl := newCustomRateLimit(nil, nil)
 
 	limiter, err := agent.buildMultiRateLimiter(context.Background(), 0, crl)
 	require.NoError(t, err)
 	require.NotNil(t, limiter)
-	// No assertion on internal state - just verify it doesn't error
-	_ = math.MaxUint32 // referenced for clarity
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@pkg/passive/ratelimit_test.go` around lines 115 - 125, In
TestBuildMultiRateLimiter_UnlimitedWhenNoLimits remove the dead no-op reference
to math.MaxUint32 (the line assigning it to the blank identifier) and delete the
now-unused math import; if you intended to assert behavior instead, replace that
line with a concrete assertion on the limiter (e.g., expected rate/limit) inside
the same test function.

pkg/passive/passive.go (2)

89-98: Centralize CustomRateLimit initialization.

This struct literal now exists here and in pkg/runner/runner.go. Since CustomDuration was just added, multiple hand-written initializers make the next field addition easy to miss again. A small constructor or ensureInitialized() helper in pkg/subscraping would keep that contract in one place.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@pkg/passive/passive.go` around lines 89 - 98, The code duplicates
construction of subscraping.CustomRateLimit (with fields Custom and
CustomDuration using mapsutil.SyncLockMap) in multiple places; add a single
constructor or ensureInitialized() function in the subscraping package (e.g.,
func NewCustomRateLimit() *CustomRateLimit or func (r *CustomRateLimit)
EnsureInitialized()) that returns/initializes a CustomRateLimit with both Custom
and CustomDuration maps set, then replace the inline struct literal here and in
pkg/runner/runner.go with a call to that constructor/EnsureInitialized to
centralize initialization and avoid future omissions.

---

121-126: Normalize custom source keys consistently.

The lookup lowercases sourceName, but WithCustomRateLimit callers populate Custom and CustomDuration directly, and pkg/runner/runner.go currently stores parsed keys as-is. That leaves a hidden casing contract where mixed-case entries silently miss and fall back to the global/unlimited path. Normalize keys on insert as well, or keep lookups case-sensitive and document the expected format.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@pkg/passive/passive.go` around lines 121 - 126, The code lowercases
sourceName for lookups (sourceLower) but callers like WithCustomRateLimit
populate rateLimit.Custom and rateLimit.CustomDuration without normalizing keys,
causing mismatches; update the code path that inserts custom keys (e.g., the
WithCustomRateLimit constructor or the runner code that parses and stores keys)
to normalize keys to strings.ToLower(...) on insert so that
rateLimit.Custom.Get(sourceLower) and rateLimit.CustomDuration.Get(sourceLower)
will match, or alternatively make the lookup use the exact stored key
consistently—ensure the change touches the insertion helpers
(WithCustomRateLimit and the runner's parsing/storing logic) and add a small
comment documenting the lowercase contract.

pkg/passive/ratelimit_test.go (1)

82-90: Consider adding behavioral assertions.

The test verifies that buildMultiRateLimiter completes without error, but doesn't validate that the global rate limit (5) was actually applied to both sources. If the MultiLimiter API allows inspecting configured limits, consider adding assertions to verify the expected behavior.

If the API doesn't expose this, the current smoke test approach is acceptable.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@pkg/passive/ratelimit_test.go` around lines 82 - 90,
TestBuildMultiRateLimiter_GlobalAppliedToAll currently only verifies no error
from agent.buildMultiRateLimiter but doesn't assert the global limit was
applied; update the test to inspect the returned limiter (from
buildMultiRateLimiter) and assert that each source's configured rate equals 5 by
using the MultiLimiter inspection API (e.g., any
GetLimit/GetRate/GetLimiterForSource or exported per-source limiter methods) or
unwrap the MultiLimiter to its child limiters and assert their limits; if the
MultiLimiter API doesn't expose limits, add a short exercise that sends
known-numbered requests per-source and asserts throttling behavior consistent
with rate=5, otherwise leave the smoke test as-is.