[test] Add tests for server.parseRateLimitResetFromText edge cases (#6021)

## Test Coverage Improvement: `parseRateLimitResetFromText`

### Function Analyzed

- **Package**: `internal/server`
- **Function**: `parseRateLimitResetFromText`
- **File**: `internal/server/circuit_breaker.go` (lines 320–340)
- **Previous test file**: `internal/server/circuit_breaker_test.go` (4
cases)
- **New test file**:
`internal/server/circuit_breaker_parse_coverage_test.go` (8 cases)
- **Complexity**: Medium — regex-adjacent string parsing with multiple
exit paths

### Why This Function?

`parseRateLimitResetFromText` is called on every rate-limit tool result
to extract the GitHub API rate-limit reset window. It has several
distinct code branches that were not covered by the existing four test
cases:

| Branch | Existing coverage |
|---|---|
| Pattern not found | ✅ (`"some other error"`) |
| No `s`/`]`/`)` terminator | ✅ (`"rate reset in 42"`) |
| `secs == 0` | ✅ (`"rate reset in 0s"`) |
| `secs > 0` (happy path) | ✅ (`"rate reset in 42s"`) |
| `secs < 0` | ❌ |
| `ParseInt` error (non-numeric) | ❌ |
| Case-insensitive pattern search with correct offset into original text
| ❌ |
| `]` as terminator (vs `s`) | ❌ |
| Large value (3600 s) | ❌ |
| Whitespace padding before digits (`TrimSpace` path) | ❌ |

An additional case documents a subtle behaviour: the terminator search
in `IndexAny(rest, "s])")` is **case-sensitive**, so an uppercase `'S'`
is not recognised as the `'s'` terminator and the function falls through
to `']'`. This causes `ParseInt("10S")` to fail and the function returns
zero time — a non-obvious edge case now pinned as a test.

### Tests Added

- ✅ Negative seconds (`secs <= 0` branch) → zero time
- ✅ Non-numeric content (`ParseInt` error branch) → zero time
- ✅ Uppercase input + lowercase `'s'` terminator → verifies offset
arithmetic
- ✅ Uppercase `'S'` terminator — documents case-sensitive `IndexAny`
behaviour
- ✅ `']'` bracket terminator (second `IndexAny` character) → valid reset
time
- ✅ Large value (3600 s / 1-hour window) → valid reset time
- ✅ Whitespace-padded number → `TrimSpace` path → valid reset time
- ✅ Minimum positive value (1 s) → boundary test

### Notes

⚠️ **Module dependencies unavailable in CI**: The environment running
this workflow has no network access and the Go module cache contains
only lock files — `go test` cannot be run to verify compilation. The
tests were validated manually by tracing through the function logic and
cross-checking with Python. All expected values were confirmed correct
before submission.

---
*Generated by Test Coverage Improver*
*Next run will target the next most complex under-tested function*




> [!WARNING]
> <details>
> <summary>Firewall blocked 1 domain</summary>
>
> The following domain was blocked by the firewall during workflow
execution:
>
> - `proxy.golang.org`
>> To allow these domains, add them to the `network.allowed` list in
your workflow frontmatter:
>
> ```yaml
> network:
>   allowed:
>     - defaults
>     - "proxy.golang.org"
> ```
>
> See [Network
Configuration](https://github.github.com/gh-aw/reference/network/) for
more information.
>
> </details>


> Generated by [Test Coverage
Improver](https://github.com/github/gh-aw-mcpg/actions/runs/26113617009/agentic_workflow)
· ● 15.5M ·
[◷](https://github.com/search?q=repo%3Agithub%2Fgh-aw-mcpg+%22gh-aw-workflow-id%3A+test-coverage-improver%22&type=pullrequests)

<!-- gh-aw-agentic-workflow: Test Coverage Improver, engine: copilot,
version: 1.0.40, model: claude-sonnet-4.6, id: 26113617009, workflow_id:
test-coverage-improver, run:
https://github.com/github/gh-aw-mcpg/actions/runs/26113617009 -->

<!-- gh-aw-workflow-id: test-coverage-improver -->

Author: lpcox

internal/server/circuit_breaker_parse_coverage_test.go

@@ -0,0 +1,106 @@
+package server
+
+// Additional coverage tests for parseRateLimitResetFromText edge cases
+// not covered by circuit_breaker_test.go.
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// TestParseRateLimitResetFromText_AdditionalEdgeCases covers code paths in
+// parseRateLimitResetFromText that are not exercised by the existing test suite:
+//
+//   - Negative seconds: exercises the secs <= 0 branch
+//   - Non-numeric digits: exercises the err != nil branch from strconv.ParseInt
+//   - Uppercase/mixed-case input: verifies that the case-insensitive search
+//     ("rate reset in") still correctly slices into the original string
+//   - Bracket terminator: the IndexAny call accepts ']' as well as 's'; ensure
+//     the number is still parsed correctly when the text ends with ']'
+//   - Large value (3600 s): a 1-hour reset window — valid, should return a
+//     future time
+//   - Whitespace padding: TrimSpace is called on the captured digit substring;
+//     confirm padding before the number is handled
+func TestParseRateLimitResetFromText_AdditionalEdgeCases(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		text     string
+		wantZero bool
+	}{
+		{
+			// secs == -5, which satisfies secs <= 0 → zero time.
+			name:     "negative seconds returns zero time",
+			text:     "API rate limit exceeded [rate reset in -5s]",
+			wantZero: true,
+		},
+		{
+			// ParseInt("abc", 10, 64) returns an error → zero time.
+			name:     "non-numeric seconds returns zero time",
+			text:     "rate limit exceeded [rate reset in abcs]",
+			wantZero: true,
+		},
+		{
+			// The function lower-cases the input to locate the pattern but
+			// then indexes into the *original* text for the digit substring.
+			// The digit terminator search is case-sensitive ('s' not 'S'), so
+			// the test uses a lowercase 's' terminator to ensure the offset
+			// arithmetic from the case-insensitive search is still correct.
+			name:     "uppercase input with lowercase terminator succeeds",
+			text:     "RATE LIMIT EXCEEDED [RATE RESET IN 10s]",
+			wantZero: false,
+		},
+		{
+			// When the terminator is uppercase 'S' (not in IndexAny's "s])")
+			// the search falls through to ']', making the captured substring
+			// "10S" which fails ParseInt — returns zero time.
+			name:     "uppercase terminator S is not recognised, falls to bracket",
+			text:     "RATE LIMIT EXCEEDED [RATE RESET IN 10S]",
+			wantZero: true,
+		},
+		{
+			// IndexAny(rest, "s])") will match ']' before it sees 's'; the
+			// digit portion must still be parsed correctly.
+			name:     "bracket terminator is accepted",
+			text:     "API rate limit exceeded [rate reset in 30]",
+			wantZero: false,
+		},
+		{
+			// A 1-hour (3600 s) reset window is a valid large value.
+			name:     "large seconds value is valid",
+			text:     "secondary rate limit exceeded [rate reset in 3600s]",
+			wantZero: false,
+		},
+		{
+			// TrimSpace is applied to the digit slice before ParseInt.
+			// A leading space inside the bracket (" 15") should still parse.
+			name:     "whitespace-padded seconds are trimmed and parsed",
+			text:     "rate limit exceeded [rate reset in  15s]",
+			wantZero: false,
+		},
+		{
+			// A reset of exactly 1 second — minimum positive value.
+			name:     "one second reset is valid",
+			text:     "rate reset in 1s",
+			wantZero: false,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			before := time.Now()
+			got := parseRateLimitResetFromText(tt.text)
+			if tt.wantZero {
+				assert.True(t, got.IsZero(), "expected zero time for %q, got %v", tt.text, got)
+			} else {
+				assert.False(t, got.IsZero(), "expected non-zero time for %q", tt.text)
+				assert.True(t, got.After(before), "expected future reset time for %q, got %v", tt.text, got)
+			}
+		})
+	}
+}