mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-16 22:57:53 +08:00
- Use `context.AfterFunc` and buffered delivery in websocket relay sessions to avoid per-request goroutine leaks. - Synchronize in-flight puts and drain queued connections upon mux listener close. - Ensure home streaming log writer goroutines terminate cleanly when the log client is unhealthy. - Prevent integer arithmetic overflow in token breakdown validations and calculations. - Clone request headers in logging middleware to prevent concurrent mutation issues. - Implement standard `io.WriterTo` return signature for file body sources. Closes: #4709
223 lines
8.3 KiB
Go
223 lines
8.3 KiB
Go
package usage
|
|
|
|
import (
|
|
"math"
|
|
"testing"
|
|
)
|
|
|
|
func TestNewSubsetTokenBreakdownAvoidsCacheAndReasoningDoubleCount(t *testing.T) {
|
|
breakdown := NewSubsetTokenBreakdown(100, 40, 10, 30, 12, 130)
|
|
if !breakdown.Valid() {
|
|
t.Fatalf("breakdown is invalid: %+v", breakdown)
|
|
}
|
|
if breakdown.Input.UncachedTokens != 50 || breakdown.Output.NonReasoningTokens != 18 {
|
|
t.Fatalf("breakdown = %+v", breakdown)
|
|
}
|
|
if breakdown.TotalTokens != 130 {
|
|
t.Fatalf("total = %d, want 130", breakdown.TotalTokens)
|
|
}
|
|
}
|
|
|
|
func TestNewPartialSubsetTokenBreakdownPreservesKnownBuckets(t *testing.T) {
|
|
breakdown := NewPartialSubsetTokenBreakdown(10, 4, 0, 0, 0, 15)
|
|
if !breakdown.Valid() {
|
|
t.Fatalf("breakdown is invalid: %+v", breakdown)
|
|
}
|
|
if breakdown.Quality != TokenAccountingQualityUnclassified || breakdown.Input.TotalTokens != 10 ||
|
|
breakdown.UnclassifiedTokens != 5 {
|
|
t.Fatalf("breakdown = %+v", breakdown)
|
|
}
|
|
}
|
|
|
|
func TestNewIndependentTokenBreakdownKeepsClaudeCacheBucketsIndependent(t *testing.T) {
|
|
breakdown := NewIndependentTokenBreakdown(30, 7, 13, 5, 0, 55)
|
|
if !breakdown.Valid() {
|
|
t.Fatalf("breakdown is invalid: %+v", breakdown)
|
|
}
|
|
if breakdown.Input.TotalTokens != 50 || breakdown.TotalTokens != 55 {
|
|
t.Fatalf("breakdown = %+v", breakdown)
|
|
}
|
|
}
|
|
|
|
func TestNewSeparateReasoningTokenBreakdownAddsReasoningToOutput(t *testing.T) {
|
|
breakdown := NewSeparateReasoningTokenBreakdown(20, 5, 0, 7, 3, 30)
|
|
if !breakdown.Valid() {
|
|
t.Fatalf("breakdown is invalid: %+v", breakdown)
|
|
}
|
|
if breakdown.Output.TotalTokens != 10 || breakdown.TotalTokens != 30 {
|
|
t.Fatalf("breakdown = %+v", breakdown)
|
|
}
|
|
}
|
|
|
|
func TestTokenBreakdownMarksContradictoryParentsInconsistent(t *testing.T) {
|
|
breakdown := NewSubsetTokenBreakdown(10, 4, 0, 3, 1, 20)
|
|
if !breakdown.Valid() {
|
|
t.Fatalf("breakdown is invalid: %+v", breakdown)
|
|
}
|
|
if breakdown.Quality != TokenAccountingQualityInconsistent || breakdown.UnclassifiedTokens != 20 {
|
|
t.Fatalf("breakdown = %+v", breakdown)
|
|
}
|
|
}
|
|
|
|
func TestNewUnclassifiedTokenBreakdownDoesNotGuessBuckets(t *testing.T) {
|
|
breakdown := NewUnclassifiedTokenBreakdown(42)
|
|
if !breakdown.Valid() {
|
|
t.Fatalf("breakdown is invalid: %+v", breakdown)
|
|
}
|
|
if breakdown.Quality != TokenAccountingQualityUnclassified || breakdown.UnclassifiedTokens != 42 {
|
|
t.Fatalf("breakdown = %+v", breakdown)
|
|
}
|
|
}
|
|
|
|
func TestEnsureTokenBreakdownForProviderUsesKnownSemantics(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
provider string
|
|
executorType string
|
|
detail Detail
|
|
wantTotal int64
|
|
wantInput int64
|
|
wantOutput int64
|
|
}{
|
|
{
|
|
name: "OpenAI subsets cache and reasoning",
|
|
provider: "openai",
|
|
detail: Detail{InputTokens: 100, OutputTokens: 30, ReasoningTokens: 12, CacheReadTokens: 40, CacheCreationTokens: 10},
|
|
wantTotal: 130,
|
|
wantInput: 100,
|
|
wantOutput: 30,
|
|
},
|
|
{
|
|
name: "OpenAI compatible executor takes precedence",
|
|
provider: "anthropic",
|
|
executorType: "OpenAICompatExecutor",
|
|
detail: Detail{InputTokens: 100, OutputTokens: 30, ReasoningTokens: 12, CacheReadTokens: 40, CacheCreationTokens: 10},
|
|
wantTotal: 130,
|
|
wantInput: 100,
|
|
wantOutput: 30,
|
|
},
|
|
{
|
|
name: "Gemini keeps reasoning separate",
|
|
provider: "gemini",
|
|
detail: Detail{InputTokens: 100, OutputTokens: 30, ReasoningTokens: 12, CacheReadTokens: 40, CacheCreationTokens: 10},
|
|
wantTotal: 142,
|
|
wantInput: 100,
|
|
wantOutput: 42,
|
|
},
|
|
{
|
|
name: "Claude keeps cache and reasoning independent",
|
|
provider: "anthropic",
|
|
detail: Detail{InputTokens: 100, OutputTokens: 30, ReasoningTokens: 12, CacheReadTokens: 40, CacheCreationTokens: 10},
|
|
wantTotal: 192,
|
|
wantInput: 150,
|
|
wantOutput: 42,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
detail := EnsureTokenBreakdownForProvider(tt.detail, tt.provider, tt.executorType)
|
|
if !detail.TokenBreakdown.Valid() || detail.TokenBreakdown.Quality != TokenAccountingQualityComplete {
|
|
t.Fatalf("token breakdown = %+v", detail.TokenBreakdown)
|
|
}
|
|
if detail.TotalTokens != tt.wantTotal || detail.TokenBreakdown.TotalTokens != tt.wantTotal ||
|
|
detail.TokenBreakdown.Input.TotalTokens != tt.wantInput || detail.TokenBreakdown.Output.TotalTokens != tt.wantOutput {
|
|
t.Fatalf("detail = %+v, want total=%d input=%d output=%d", detail, tt.wantTotal, tt.wantInput, tt.wantOutput)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEnsureTokenBreakdownForUnknownProviderDoesNotGuessReasoning(t *testing.T) {
|
|
detail := EnsureTokenBreakdownForProvider(Detail{InputTokens: 100, OutputTokens: 30, ReasoningTokens: 12}, "plugin-provider", "")
|
|
if detail.TotalTokens != 130 || detail.TokenBreakdown.Quality != TokenAccountingQualityUnclassified || detail.TokenBreakdown.UnclassifiedTokens != 130 {
|
|
t.Fatalf("detail = %+v", detail)
|
|
}
|
|
}
|
|
|
|
func TestEnsureTokenBreakdownForUnknownProviderPreservesAuxiliaryOnlyUsage(t *testing.T) {
|
|
detail := EnsureTokenBreakdownForProvider(Detail{ReasoningTokens: 12, CacheReadTokens: 7}, "plugin-provider", "")
|
|
if detail.TotalTokens != 19 || detail.TokenBreakdown.Quality != TokenAccountingQualityUnclassified || detail.TokenBreakdown.UnclassifiedTokens != 19 {
|
|
t.Fatalf("detail = %+v", detail)
|
|
}
|
|
}
|
|
|
|
func TestEnsureTokenBreakdownForGeminiClassifiesReasoningOnlyUsage(t *testing.T) {
|
|
detail := EnsureTokenBreakdownForProvider(Detail{ReasoningTokens: 12}, "gemini", "")
|
|
if detail.TotalTokens != 12 || detail.TokenBreakdown.Quality != TokenAccountingQualityComplete ||
|
|
detail.TokenBreakdown.Output.ReasoningTokens != 12 {
|
|
t.Fatalf("detail = %+v", detail)
|
|
}
|
|
}
|
|
|
|
func TestEnsureTokenBreakdownPreservesLegacyCachedOnlyUsage(t *testing.T) {
|
|
detail := EnsureTokenBreakdownForProvider(Detail{CachedTokens: 13}, "openai", "")
|
|
if detail.TotalTokens != 13 || detail.CacheReadTokens != 13 || detail.TokenBreakdown.Quality != TokenAccountingQualityUnclassified ||
|
|
detail.TokenBreakdown.UnclassifiedTokens != 13 {
|
|
t.Fatalf("detail = %+v", detail)
|
|
}
|
|
}
|
|
|
|
func TestEnsureTokenBreakdownDoesNotOverrideCanonicalZeroCacheRead(t *testing.T) {
|
|
detail := EnsureTokenBreakdownForProvider(Detail{CachedTokens: 13, CacheCreationTokens: 13}, "openai", "")
|
|
if detail.CacheReadTokens != 0 {
|
|
t.Fatalf("detail = %+v", detail)
|
|
}
|
|
}
|
|
|
|
func TestTokenBreakdown_Valid_RejectsArithmeticOverflow(t *testing.T) {
|
|
// MaxInt64 + MaxInt64 + 2 wraps to 0 in int64 arithmetic:
|
|
// math.MaxInt64 (0x7fff_ffff_ffff_ffff) + math.MaxInt64 + 2 = -2 + 2 = 0
|
|
b := TokenBreakdown{
|
|
SchemaVersion: TokenAccountingSchemaVersion,
|
|
Quality: TokenAccountingQualityComplete,
|
|
TotalTokens: 0,
|
|
Input: TokenInputBreakdown{
|
|
TotalTokens: 0,
|
|
UncachedTokens: math.MaxInt64,
|
|
CacheReadTokens: math.MaxInt64,
|
|
CacheWriteTokens: 2,
|
|
},
|
|
}
|
|
if b.Valid() {
|
|
t.Fatalf("Valid() accepted overflowing input tokens sum: %+v", b)
|
|
}
|
|
|
|
bOutput := TokenBreakdown{
|
|
SchemaVersion: TokenAccountingSchemaVersion,
|
|
Quality: TokenAccountingQualityComplete,
|
|
TotalTokens: 0,
|
|
Output: TokenOutputBreakdown{
|
|
TotalTokens: -2, // will overflow if nonNegativeSum not used or negative
|
|
NonReasoningTokens: math.MaxInt64,
|
|
ReasoningTokens: math.MaxInt64,
|
|
},
|
|
}
|
|
if bOutput.Valid() {
|
|
t.Fatalf("Valid() accepted overflowing output tokens sum: %+v", bOutput)
|
|
}
|
|
}
|
|
|
|
func TestNewSubsetTokenBreakdown_RejectsArithmeticOverflow(t *testing.T) {
|
|
// Passing MaxInt64 for cacheRead and cacheWrite will overflow cacheRead + cacheWrite to negative (-2).
|
|
// If unchecked, cacheRead + cacheWrite > inputTotal comparison evaluates -2 > MaxInt64 (false),
|
|
// returning complete quality with negative uncached tokens.
|
|
b := NewSubsetTokenBreakdown(math.MaxInt64, math.MaxInt64, math.MaxInt64, 0, 0, math.MaxInt64)
|
|
if b.Quality == TokenAccountingQualityComplete {
|
|
t.Fatalf("expected inconsistent quality for overflowing breakdown, got Complete: %+v", b)
|
|
}
|
|
if b.Input.UncachedTokens < 0 {
|
|
t.Fatalf("uncached tokens negative: %d", b.Input.UncachedTokens)
|
|
}
|
|
}
|
|
|
|
func TestNewSeparateReasoningTokenBreakdown_RejectsArithmeticOverflow(t *testing.T) {
|
|
// Passing MaxInt64 for cacheRead and cacheWrite will overflow cacheRead + cacheWrite to negative (-2).
|
|
b := NewSeparateReasoningTokenBreakdown(math.MaxInt64, math.MaxInt64, math.MaxInt64, 0, 0, math.MaxInt64)
|
|
if b.Quality == TokenAccountingQualityComplete {
|
|
t.Fatalf("expected inconsistent quality for overflowing breakdown, got Complete: %+v", b)
|
|
}
|
|
if b.Input.UncachedTokens < 0 {
|
|
t.Fatalf("uncached tokens negative: %d", b.Input.UncachedTokens)
|
|
}
|
|
}
|