independent test cases

Author: github-actions[bot]

core/providers/anthropic_test.go

@@ -0,0 +1,248 @@
+package providers
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/maximhq/bifrost/core/schemas"
+)
+
+func TestAnthropicChatCompletion(t *testing.T) {
+	apiKey := os.Getenv("ANTHROPIC_API_KEY")
+	if apiKey == "" {
+		t.Skip("ANTHROPIC_API_KEY not set")
+	}
+
+	provider := NewAnthropicProvider(&schemas.ProviderConfig{
+		NetworkConfig: schemas.NetworkConfig{
+			BaseURL:                        "https://api.anthropic.com",
+			DefaultRequestTimeoutInSeconds: 30,
+		},
+		ConcurrencyAndBufferSize: schemas.ConcurrencyAndBufferSize{
+			Concurrency: 10,
+		},
+	}, newTestLogger())
+
+	ctx := context.Background()
+	key := schemas.Key{Value: apiKey}
+
+	request := &schemas.BifrostChatRequest{
+		Provider: schemas.Anthropic,
+		Model:    "claude-3-haiku-20240307",
+		Input: []schemas.ChatMessage{
+			{
+				Role:    "user",
+				Content: &schemas.ChatMessageContent{ContentStr: stringPtr("Say hello in one word")},
+			},
+		},
+		Params: &schemas.ChatParameters{
+			Temperature:         float64Ptr(0.7),
+			MaxCompletionTokens: intPtr(10),
+		},
+	}
+
+	resp, err := provider.ChatCompletion(ctx, key, request)
+	if err != nil {
+		t.Fatalf("ChatCompletion failed: %v", err)
+	}
+
+	if resp == nil {
+		t.Fatal("Expected non-nil response")
+	}
+	if len(resp.Choices) == 0 {
+		t.Fatal("Expected at least one choice")
+	}
+	if resp.Choices[0].Message.Content == nil {
+		t.Fatal("Expected message content")
+	}
+	t.Logf("Response: %v", resp.Choices[0].Message.Content)
+}
+
+func TestAnthropicChatCompletionWithTools(t *testing.T) {
+	apiKey := os.Getenv("ANTHROPIC_API_KEY")
+	if apiKey == "" {
+		t.Skip("ANTHROPIC_API_KEY not set")
+	}
+
+	provider := NewAnthropicProvider(&schemas.ProviderConfig{
+		NetworkConfig: schemas.NetworkConfig{
+			BaseURL:                        "https://api.anthropic.com",
+			DefaultRequestTimeoutInSeconds: 30,
+		},
+		ConcurrencyAndBufferSize: schemas.ConcurrencyAndBufferSize{
+			Concurrency: 10,
+		},
+	}, newTestLogger())
+
+	ctx := context.Background()
+	key := schemas.Key{Value: apiKey}
+
+	props := map[string]interface{}{
+		"location": map[string]interface{}{
+			"type":        "string",
+			"description": "The city name",
+		},
+	}
+
+	request := &schemas.BifrostChatRequest{
+		Provider: schemas.Anthropic,
+		Model:    "claude-3-haiku-20240307",
+		Input: []schemas.ChatMessage{
+			{
+				Role:    "user",
+				Content: &schemas.ChatMessageContent{ContentStr: stringPtr("What's the weather in San Francisco?")},
+			},
+		},
+		Params: &schemas.ChatParameters{
+			Temperature:         float64Ptr(0.7),
+			MaxCompletionTokens: intPtr(100),
+			Tools: []schemas.ChatTool{
+				{
+					Type: schemas.ChatToolTypeFunction,
+					Function: &schemas.ChatToolFunction{
+						Name:        "get_weather",
+						Description: stringPtr("Get the current weather"),
+						Parameters: &schemas.ToolFunctionParameters{
+							Type:       "object",
+							Properties: &props,
+							Required:   []string{"location"},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	resp, err := provider.ChatCompletion(ctx, key, request)
+	if err != nil {
+		t.Fatalf("ChatCompletion with tools failed: %v", err)
+	}
+
+	if resp == nil {
+		t.Fatal("Expected non-nil response")
+	}
+	if len(resp.Choices) == 0 {
+		t.Fatal("Expected at least one choice")
+	}
+	t.Logf("Tool calls: %d", len(resp.Choices[0].Message.ToolCalls))
+}
+
+func TestAnthropicChatCompletionStream(t *testing.T) {
+	apiKey := os.Getenv("ANTHROPIC_API_KEY")
+	if apiKey == "" {
+		t.Skip("ANTHROPIC_API_KEY not set")
+	}
+
+	provider := NewAnthropicProvider(&schemas.ProviderConfig{
+		NetworkConfig: schemas.NetworkConfig{
+			BaseURL:                        "https://api.anthropic.com",
+			DefaultRequestTimeoutInSeconds: 30,
+		},
+		ConcurrencyAndBufferSize: schemas.ConcurrencyAndBufferSize{
+			Concurrency: 10,
+		},
+	}, newTestLogger())
+
+	ctx := context.Background()
+	key := schemas.Key{Value: apiKey}
+
+	request := &schemas.BifrostChatRequest{
+		Provider: schemas.Anthropic,
+		Model:    "claude-3-haiku-20240307",
+		Input: []schemas.ChatMessage{
+			{
+				Role:    "user",
+				Content: &schemas.ChatMessageContent{ContentStr: stringPtr("Count from 1 to 3")},
+			},
+		},
+		Params: &schemas.ChatParameters{
+			Temperature: float64Ptr(0.7),
+		},
+	}
+
+	streamChan, err := provider.ChatCompletionStream(ctx, mockPostHookRunner, key, request)
+	if err != nil {
+		t.Fatalf("ChatCompletionStream failed: %v", err)
+	}
+
+	count := 0
+	for chunk := range streamChan {
+		if chunk == nil {
+			continue
+		}
+		if chunk.BifrostError != nil {
+			t.Fatalf("Stream error: %v", chunk.BifrostError)
+		}
+		count++
+	}
+
+	if count == 0 {
+		t.Fatal("Expected at least one chunk")
+	}
+	t.Logf("Received %d chunks", count)
+}
+
+func TestAnthropicResponses(t *testing.T) {
+	apiKey := os.Getenv("ANTHROPIC_API_KEY")
+	if apiKey == "" {
+		t.Skip("ANTHROPIC_API_KEY not set")
+	}
+
+	provider := NewAnthropicProvider(&schemas.ProviderConfig{
+		NetworkConfig: schemas.NetworkConfig{
+			BaseURL:                        "https://api.anthropic.com",
+			DefaultRequestTimeoutInSeconds: 30,
+		},
+		ConcurrencyAndBufferSize: schemas.ConcurrencyAndBufferSize{
+			Concurrency: 10,
+		},
+	}, newTestLogger())
+
+	ctx := context.Background()
+	key := schemas.Key{Value: apiKey}
+
+	userRole := schemas.ResponsesInputMessageRoleUser
+	request := &schemas.BifrostResponsesRequest{
+		Provider: schemas.Anthropic,
+		Model:    "claude-3-5-sonnet-20241022",
+		Input: []schemas.ResponsesMessage{
+			{
+				Role:    &userRole,
+				Content: &schemas.ResponsesMessageContent{ContentStr: stringPtr("What is 2+2?")},
+			},
+		},
+		Params: &schemas.ResponsesParameters{
+			MaxOutputTokens: intPtr(100),
+		},
+	}
+
+	resp, err := provider.Responses(ctx, key, request)
+	if err != nil {
+		t.Fatalf("Responses failed: %v", err)
+	}
+
+	if resp == nil {
+		t.Fatal("Expected non-nil response")
+	}
+	if len(resp.Output) == 0 {
+		t.Fatal("Expected at least one output message")
+	}
+	t.Logf("Response output messages: %d", len(resp.Output))
+}
+
+func TestAnthropicGetProviderKey(t *testing.T) {
+	provider := NewAnthropicProvider(&schemas.ProviderConfig{
+		NetworkConfig: schemas.NetworkConfig{
+			BaseURL: "https://api.anthropic.com",
+		},
+		ConcurrencyAndBufferSize: schemas.ConcurrencyAndBufferSize{
+			Concurrency: 10,
+		},
+	}, newTestLogger())
+
+	key := provider.GetProviderKey()
+	if key != schemas.Anthropic {
+		t.Errorf("Expected provider key %s, got %s", schemas.Anthropic, key)
+	}
+}