Download plugins/semanticcache/plugin_conversation_config_test.go from shimen/yapapaway: direct link, hf CLI and curl.
- Browser
- Download file 16.4 kB
-
https://huggingface.co/spaces/shimen/yapapaway/resolve/main/plugins/semanticcache/plugin_conversation_config_test.go
- Command line
-
hf download hf://spaces/shimen/yapapaway/plugins/semanticcache/plugin_conversation_config_test.go
-
curl -L -o plugin_conversation_config_test.go https://huggingface.co/spaces/shimen/yapapaway/resolve/main/plugins/semanticcache/plugin_conversation_config_test.go
16.4 kB
| package semanticcache | |
| import ( | |
| "strconv" | |
| "testing" | |
| bifrost "github.com/maximhq/bifrost/core" | |
| "github.com/maximhq/bifrost/core/schemas" | |
| ) | |
| // TestConversationHistoryThresholdBasic tests basic conversation history threshold functionality | |
| func TestConversationHistoryThresholdBasic(t *testing.T) { | |
| // Test with threshold of 2 messages | |
| setup := CreateTestSetupWithConversationThreshold(t, 2) | |
| defer setup.Cleanup() | |
| ctx := CreateContextWithCacheKey("test-conversation-threshold-basic") | |
| // Test 1: Conversation with exactly 2 messages (should cache) | |
| conversation1 := BuildConversationHistory("", | |
| []string{"Hello", "Hi there!"}, | |
| ) | |
| request1 := CreateConversationRequest(conversation1, 0.7, 50) | |
| t.Log("Testing conversation with exactly 2 messages (at threshold)...") | |
| response1, err1 := setup.Client.ChatCompletionRequest(ctx, request1) | |
| if err1 != nil { | |
| return // Test will be skipped by retry function | |
| } | |
| AssertNoCacheHit(t, &schemas.BifrostResponse{ChatResponse: response1}) // Fresh request | |
| WaitForCache(setup.Plugin) | |
| // Verify it was cached | |
| response2, err2 := setup.Client.ChatCompletionRequest(ctx, request1) | |
| if err2 != nil { | |
| if err2.Error != nil { | |
| t.Fatalf("Second request failed: %v", err2.Error.Message) | |
| } else { | |
| t.Fatalf("Second request failed: %v", err2) | |
| } | |
| } | |
| AssertCacheHit(t, &schemas.BifrostResponse{ChatResponse: response2}, "direct") // Should be cached | |
| // Test 2: Conversation with 3 messages (exceeds threshold, should NOT cache) | |
| conversation2 := BuildConversationHistory("", | |
| []string{"Hello", "Hi there!"}, | |
| []string{"How are you?", "I'm doing well!"}, | |
| ) | |
| messages2 := AddUserMessage(conversation2, "What's the weather?") | |
| request2 := CreateConversationRequest(messages2, 0.7, 50) // 5 messages total > 2 | |
| t.Log("Testing conversation with 5 messages (exceeds threshold)...") | |
| response3, err3 := setup.Client.ChatCompletionRequest(ctx, request2) | |
| if err3 != nil { | |
| return // Test will be skipped by retry function | |
| } | |
| AssertNoCacheHit(t, &schemas.BifrostResponse{ChatResponse: response3}) // Should not cache | |
| WaitForCache(setup.Plugin) | |
| // Verify it was NOT cached | |
| t.Log("Verifying conversation exceeding threshold was not cached...") | |
| response4, err4 := setup.Client.ChatCompletionRequest(ctx, request2) | |
| if err4 != nil { | |
| return // Test will be skipped by retry function | |
| } | |
| AssertNoCacheHit(t, &schemas.BifrostResponse{ChatResponse: response4}) // Should still be fresh (not cached) | |
| t.Log("β Conversation history threshold works correctly") | |
| } | |
| // TestConversationHistoryThresholdWithSystemPrompt tests threshold with system messages | |
| func TestConversationHistoryThresholdWithSystemPrompt(t *testing.T) { | |
| // Test with threshold of 3, ExcludeSystemPrompt = false | |
| setup := CreateTestSetupWithConversationThreshold(t, 3) | |
| defer setup.Cleanup() | |
| ctx := CreateContextWithCacheKey("test-threshold-system-prompt") | |
| // System prompt + 2 user/assistant pairs = 5 messages total > 3 | |
| conversation := BuildConversationHistory( | |
| "You are a helpful assistant", // System message (counts toward threshold) | |
| []string{"Hello", "Hi there!"}, | |
| []string{"How are you?", "I'm doing well!"}, | |
| ) | |
| request := CreateConversationRequest(conversation, 0.7, 50) | |
| t.Log("Testing conversation with system prompt (5 total messages > 3 threshold)...") | |
| response1, err1 := setup.Client.ChatCompletionRequest(ctx, request) | |
| if err1 != nil { | |
| return // Test will be skipped by retry function | |
| } | |
| AssertNoCacheHit(t, &schemas.BifrostResponse{ChatResponse: response1}) // Should not cache (exceeds threshold) | |
| WaitForCache(setup.Plugin) | |
| // Verify not cached | |
| response2, err2 := setup.Client.ChatCompletionRequest(ctx, request) | |
| if err2 != nil { | |
| return // Test will be skipped by retry function | |
| } | |
| AssertNoCacheHit(t, &schemas.BifrostResponse{ChatResponse: response2}) // Should not be cached | |
| t.Log("β Conversation threshold correctly counts system messages") | |
| } | |
| // TestConversationHistoryThresholdWithExcludeSystemPrompt tests interaction between threshold and exclude system prompt | |
| func TestConversationHistoryThresholdWithExcludeSystemPrompt(t *testing.T) { | |
| // Create setup with both threshold=3 and ExcludeSystemPrompt=true | |
| setup := CreateTestSetupWithThresholdAndExcludeSystem(t, 3, true) | |
| defer setup.Cleanup() | |
| ctx := CreateContextWithCacheKey("test-threshold-exclude-system") | |
| // Create conversation with exactly 3 non-system messages to test threshold boundary | |
| // System + 1.5 user/assistant pairs = 4 messages total | |
| // With ExcludeSystemPrompt=true, should only count 3 non-system messages for threshold | |
| conversation := BuildConversationHistory( | |
| "You are helpful", // System (excluded from count) | |
| []string{"Hello", "Hi"}, // User + Assistant = 2 messages | |
| []string{"Thanks", ""}, // User only = 1 message (no assistant response) | |
| ) | |
| // No slicing needed; BuildConversationHistory skips empty assistant entries. | |
| request := CreateConversationRequest(conversation, 0.7, 50) // 3 non-system messages exactly | |
| t.Log("Testing threshold with ExcludeSystemPrompt=true (3 non-system messages = at threshold)...") | |
| // Test logic: | |
| // - Total messages: 4 (1 system + 3 others) | |
| // - With ExcludeSystemPrompt=true: counts as 3 non-system messages | |
| // - Threshold is 3, so 3 <= 3 should allow caching | |
| response1, err1 := setup.Client.ChatCompletionRequest(ctx, request) | |
| if err1 != nil { | |
| return // Test will be skipped by retry function | |
| } | |
| AssertNoCacheHit(t, &schemas.BifrostResponse{ChatResponse: response1}) // Fresh request, should not hit cache | |
| WaitForCache(setup.Plugin) | |
| // Second request should hit cache (3 non-system messages <= 3 threshold) | |
| response2, err2 := setup.Client.ChatCompletionRequest(ctx, request) | |
| if err2 != nil { | |
| if err2.Error != nil { | |
| t.Fatalf("Second request failed: %v", err2.Error.Message) | |
| } else { | |
| t.Fatalf("Second request failed: %v", err2) | |
| } | |
| } | |
| AssertCacheHit(t, &schemas.BifrostResponse{ChatResponse: response2}, "direct") // Should cache since 3 <= 3 after excluding system | |
| t.Log("β Conversation threshold respects ExcludeSystemPrompt setting") | |
| } | |
| // TestConversationHistoryThresholdDifferentValues tests different threshold values | |
| func TestConversationHistoryThresholdDifferentValues(t *testing.T) { | |
| testCases := []struct { | |
| name string | |
| threshold int | |
| messages int | |
| shouldCache bool | |
| }{ | |
| {"Threshold 1, 1 message", 1, 1, true}, | |
| {"Threshold 1, 2 messages", 1, 2, false}, | |
| {"Threshold 5, 4 messages", 5, 4, true}, | |
| {"Threshold 5, 6 messages", 5, 6, false}, | |
| } | |
| for _, tc := range testCases { | |
| t.Run(tc.name, func(t *testing.T) { | |
| setup := CreateTestSetupWithConversationThreshold(t, tc.threshold) | |
| defer setup.Cleanup() | |
| ctx := CreateContextWithCacheKey("test-threshold-" + tc.name) | |
| // Build conversation with specified number of messages | |
| var conversation []schemas.ChatMessage | |
| for i := 0; i < tc.messages; i++ { | |
| role := schemas.ChatMessageRoleUser | |
| if i%2 == 1 { | |
| role = schemas.ChatMessageRoleAssistant | |
| } | |
| message := schemas.ChatMessage{ | |
| Role: role, | |
| Content: &schemas.ChatMessageContent{ | |
| ContentStr: bifrost.Ptr("Message " + strconv.Itoa(i+1)), | |
| }, | |
| } | |
| conversation = append(conversation, message) | |
| } | |
| request := CreateConversationRequest(conversation, 0.7, 50) | |
| response1, err1 := setup.Client.ChatCompletionRequest(ctx, request) | |
| if err1 != nil { | |
| return // Test will be skipped by retry function | |
| } | |
| AssertNoCacheHit(t, &schemas.BifrostResponse{ChatResponse: response1}) // Always fresh first time | |
| WaitForCache(setup.Plugin) | |
| response2, err2 := setup.Client.ChatCompletionRequest(ctx, request) | |
| if err2 != nil { | |
| return // Test will be skipped by retry function | |
| } | |
| if tc.shouldCache { | |
| AssertCacheHit(t, &schemas.BifrostResponse{ChatResponse: response2}, "direct") | |
| } else { | |
| AssertNoCacheHit(t, &schemas.BifrostResponse{ChatResponse: response2}) | |
| } | |
| }) | |
| } | |
| t.Log("β Different conversation threshold values work correctly") | |
| } | |
| // TestExcludeSystemPromptBasic tests basic ExcludeSystemPrompt functionality | |
| func TestExcludeSystemPromptBasic(t *testing.T) { | |
| // Test with ExcludeSystemPrompt = true | |
| setup := CreateTestSetupWithExcludeSystemPrompt(t, true) | |
| defer setup.Cleanup() | |
| ctx := CreateContextWithCacheKey("test-exclude-system-basic") | |
| // Create two conversations with different system prompts but same user/assistant messages | |
| conversation1 := BuildConversationHistory( | |
| "You are a helpful assistant", | |
| []string{"What is AI?", "AI is artificial intelligence."}, | |
| ) | |
| conversation2 := BuildConversationHistory( | |
| "You are a technical expert", // Different system prompt | |
| []string{"What is AI?", "AI is artificial intelligence."}, // Same user/assistant | |
| ) | |
| request1 := CreateConversationRequest(conversation1, 0.7, 50) | |
| request2 := CreateConversationRequest(conversation2, 0.7, 50) | |
| t.Log("Caching conversation with system prompt 1...") | |
| response1, err1 := setup.Client.ChatCompletionRequest(ctx, request1) | |
| if err1 != nil { | |
| return // Test will be skipped by retry function | |
| } | |
| AssertNoCacheHit(t, &schemas.BifrostResponse{ChatResponse: response1}) | |
| WaitForCache(setup.Plugin) | |
| t.Log("Testing conversation with different system prompt (should hit cache due to ExcludeSystemPrompt=true)...") | |
| response2, err2 := setup.Client.ChatCompletionRequest(ctx, request2) | |
| if err2 != nil { | |
| if err2.Error != nil { | |
| t.Fatalf("Second request failed: %v", err2.Error.Message) | |
| } else { | |
| t.Fatalf("Second request failed: %v", err2) | |
| } | |
| } | |
| // Should hit cache because system prompts are excluded from cache key | |
| AssertCacheHit(t, &schemas.BifrostResponse{ChatResponse: response2}, "direct") | |
| t.Log("β ExcludeSystemPrompt=true correctly ignores system prompts in cache keys") | |
| } | |
| // TestExcludeSystemPromptComparison tests ExcludeSystemPrompt true vs false | |
| func TestExcludeSystemPromptComparison(t *testing.T) { | |
| // Test 1: ExcludeSystemPrompt = false (default) | |
| setup1 := CreateTestSetupWithExcludeSystemPrompt(t, false) | |
| defer setup1.Cleanup() | |
| ctx1 := CreateContextWithCacheKey("test-exclude-system-false") | |
| conversation1 := BuildConversationHistory( | |
| "You are helpful", | |
| []string{"Hello", "Hi there!"}, | |
| ) | |
| conversation2 := BuildConversationHistory( | |
| "You are an expert", // Different system prompt | |
| []string{"Hello", "Hi there!"}, // Same user/assistant | |
| ) | |
| request1 := CreateConversationRequest(conversation1, 0.7, 50) | |
| request2 := CreateConversationRequest(conversation2, 0.7, 50) | |
| t.Log("Testing ExcludeSystemPrompt=false...") | |
| response1, err1 := setup1.Client.ChatCompletionRequest(ctx1, request1) | |
| if err1 != nil { | |
| return // Test will be skipped by retry function | |
| } | |
| AssertNoCacheHit(t, &schemas.BifrostResponse{ChatResponse: response1}) | |
| WaitForCache(setup1.Plugin) | |
| response2, err2 := setup1.Client.ChatCompletionRequest(ctx1, request2) | |
| if err2 != nil { | |
| if err2.Error != nil { | |
| t.Fatalf("Second request failed: %v", err2.Error.Message) | |
| } else { | |
| t.Fatalf("Second request failed: %v", err2) | |
| } | |
| } | |
| // Should NOT hit direct cache, but might hit semantic cache due to similar content | |
| if response2.ExtraFields.CacheDebug != nil && response2.ExtraFields.CacheDebug.CacheHit { | |
| if response2.ExtraFields.CacheDebug.HitType != nil && *response2.ExtraFields.CacheDebug.HitType == "semantic" { | |
| t.Log("β Found semantic cache match (expected with similar content)") | |
| } else { | |
| t.Error("β Unexpected direct cache hit with different system prompts") | |
| } | |
| } else { | |
| t.Log("β No cache hit (system prompts create different cache keys)") | |
| } | |
| // Test 2: ExcludeSystemPrompt = true | |
| setup2 := CreateTestSetupWithExcludeSystemPrompt(t, true) | |
| defer setup2.Cleanup() | |
| ctx2 := CreateContextWithCacheKey("test-exclude-system-true") | |
| t.Log("Testing ExcludeSystemPrompt=true...") | |
| response3, err3 := setup2.Client.ChatCompletionRequest(ctx2, request1) | |
| if err3 != nil { | |
| return // Test will be skipped by retry function | |
| } | |
| AssertNoCacheHit(t, &schemas.BifrostResponse{ChatResponse: response3}) | |
| WaitForCache(setup2.Plugin) | |
| response4, err4 := setup2.Client.ChatCompletionRequest(ctx2, request2) | |
| if err4 != nil { | |
| t.Fatalf("Fourth request failed: %v", err4) | |
| } | |
| // Should hit cache because system prompts are excluded from cache key | |
| AssertCacheHit(t, &schemas.BifrostResponse{ChatResponse: response4}, "direct") | |
| t.Log("β ExcludeSystemPrompt true vs false comparison works correctly") | |
| } | |
| // TestExcludeSystemPromptWithMultipleSystemMessages tests behavior with multiple system messages | |
| func TestExcludeSystemPromptWithMultipleSystemMessages(t *testing.T) { | |
| setup := CreateTestSetupWithExcludeSystemPrompt(t, true) | |
| defer setup.Cleanup() | |
| ctx := CreateContextWithCacheKey("test-multiple-system-messages") | |
| // Manually create conversation with multiple system messages | |
| conversation1 := []schemas.ChatMessage{ | |
| { | |
| Role: schemas.ChatMessageRoleSystem, | |
| Content: &schemas.ChatMessageContent{ContentStr: bifrost.Ptr("You are helpful")}, | |
| }, | |
| { | |
| Role: schemas.ChatMessageRoleSystem, | |
| Content: &schemas.ChatMessageContent{ContentStr: bifrost.Ptr("Be concise")}, | |
| }, | |
| { | |
| Role: schemas.ChatMessageRoleUser, | |
| Content: &schemas.ChatMessageContent{ContentStr: bifrost.Ptr("Hello")}, | |
| }, | |
| { | |
| Role: schemas.ChatMessageRoleAssistant, | |
| Content: &schemas.ChatMessageContent{ContentStr: bifrost.Ptr("Hi!")}, | |
| }, | |
| } | |
| conversation2 := []schemas.ChatMessage{ | |
| { | |
| Role: schemas.ChatMessageRoleSystem, | |
| Content: &schemas.ChatMessageContent{ContentStr: bifrost.Ptr("You are an expert")}, | |
| }, | |
| { | |
| Role: schemas.ChatMessageRoleSystem, | |
| Content: &schemas.ChatMessageContent{ContentStr: bifrost.Ptr("Be detailed")}, | |
| }, | |
| { | |
| Role: schemas.ChatMessageRoleUser, | |
| Content: &schemas.ChatMessageContent{ContentStr: bifrost.Ptr("Hello")}, | |
| }, | |
| { | |
| Role: schemas.ChatMessageRoleAssistant, | |
| Content: &schemas.ChatMessageContent{ContentStr: bifrost.Ptr("Hi!")}, | |
| }, | |
| } | |
| request1 := CreateConversationRequest(conversation1, 0.7, 50) | |
| request2 := CreateConversationRequest(conversation2, 0.7, 50) | |
| t.Log("Caching conversation with multiple system messages...") | |
| response1, err1 := setup.Client.ChatCompletionRequest(ctx, request1) | |
| if err1 != nil { | |
| return // Test will be skipped by retry function | |
| } | |
| AssertNoCacheHit(t, &schemas.BifrostResponse{ChatResponse: response1}) | |
| WaitForCache(setup.Plugin) | |
| t.Log("Testing conversation with different multiple system messages...") | |
| response2, err2 := setup.Client.ChatCompletionRequest(ctx, request2) | |
| if err2 != nil { | |
| if err2.Error != nil { | |
| t.Fatalf("Second request failed: %v", err2.Error.Message) | |
| } else { | |
| t.Fatalf("Second request failed: %v", err2) | |
| } | |
| } | |
| // Should hit cache because all system messages are excluded | |
| AssertCacheHit(t, &schemas.BifrostResponse{ChatResponse: response2}, "direct") | |
| t.Log("β ExcludeSystemPrompt works with multiple system messages") | |
| } | |
| // TestExcludeSystemPromptWithNoSystemMessages tests behavior when there are no system messages | |
| func TestExcludeSystemPromptWithNoSystemMessages(t *testing.T) { | |
| setup := CreateTestSetupWithExcludeSystemPrompt(t, true) | |
| defer setup.Cleanup() | |
| ctx := CreateContextWithCacheKey("test-no-system-messages") | |
| // Conversation with no system messages | |
| conversation := []schemas.ChatMessage{ | |
| { | |
| Role: schemas.ChatMessageRoleUser, | |
| Content: &schemas.ChatMessageContent{ContentStr: bifrost.Ptr("Hello")}, | |
| }, | |
| { | |
| Role: schemas.ChatMessageRoleAssistant, | |
| Content: &schemas.ChatMessageContent{ContentStr: bifrost.Ptr("Hi there!")}, | |
| }, | |
| } | |
| request := CreateConversationRequest(conversation, 0.7, 50) | |
| t.Log("Testing conversation with no system messages...") | |
| response1, err1 := setup.Client.ChatCompletionRequest(ctx, request) | |
| if err1 != nil { | |
| return // Test will be skipped by retry function | |
| } | |
| AssertNoCacheHit(t, &schemas.BifrostResponse{ChatResponse: response1}) | |
| WaitForCache(setup.Plugin) | |
| // Should cache normally | |
| response2, err2 := setup.Client.ChatCompletionRequest(ctx, request) | |
| if err2 != nil { | |
| if err2.Error != nil { | |
| t.Fatalf("Second request failed: %v", err2.Error.Message) | |
| } else { | |
| t.Fatalf("Second request failed: %v", err2) | |
| } | |
| } | |
| AssertCacheHit(t, &schemas.BifrostResponse{ChatResponse: response2}, "direct") | |
| t.Log("β ExcludeSystemPrompt works correctly when no system messages present") | |
| } | |