Merge pull request #7 from bdpiprava/feature/clone-support

feat: add tests

Author: bdpiprava

test-integration/data.go

@@ -29,6 +29,77 @@ func NewTestTraceEvent() *types.TraceEvent {
 	}
 }
 
+// NewTestGenerationEvent returns a sample GenerationEvent for testing purposes
+func NewTestGenerationEvent() *types.GenerationEvent {
+	traceID := uuid.New()
+	generationID := uuid.New()
+	now := time.Now().UTC()
+
+	return &types.GenerationEvent{
+		ID:        &generationID,
+		Name:      "TestGeneration",
+		TraceID:   &traceID,
+		StartTime: &now,
+		Model:     "gpt-3.5-turbo",
+		Input:     "Test input for generation",
+		Output:    "Test output for generation",
+		Metadata: map[string]any{
+			"test":    "generation",
+			"version": float64(1),
+		},
+		Level: types.Default,
+		Usage: types.Usage{
+			Input:  10,
+			Output: 5,
+			Total:  15,
+			Unit:   "TOKENS",
+		},
+		ModelParameters: map[string]any{
+			"temperature": 0.7,
+			"max_tokens":  float64(100),
+		},
+		PromptName:    "",
+		PromptVersion: 0,
+	}
+}
+
+// NewTestSpanEvent returns a sample SpanEvent for testing purposes
+func NewTestSpanEvent() *types.SpanEvent {
+	traceID := uuid.New()
+	spanID := uuid.New()
+	now := time.Now().UTC()
+
+	return &types.SpanEvent{
+		ID:        &spanID,
+		Name:      "TestSpan",
+		TraceID:   &traceID,
+		StartTime: &now,
+		Input:     "Test input for span",
+		Output:    "Test output for span",
+		Metadata: map[string]any{
+			"test":      "span",
+			"operation": "test_operation",
+		},
+		Level:   types.Default,
+		Version: "1.0",
+	}
+}
+
+// NewTestScoreEvent returns a sample ScoreEvent for testing purposes
+func NewTestScoreEvent() *types.ScoreEvent {
+	scoreID := uuid.New()
+	traceID := uuid.New().String()
+	comment := "Test score comment"
+
+	return &types.ScoreEvent{
+		ID:      &scoreID,
+		Name:    "TestScore",
+		TraceID: &traceID,
+		Value:   0.85,
+		Comment: &comment,
+	}
+}
+
 // BuildSession constructs a Session from a slice of TraceEvents.
 func BuildSession(traceEvents ...*types.TraceEvent) *types.Session {
 	if len(traceEvents) == 0 {

test-integration/data_test.go

@@ -0,0 +1,118 @@
+package integration_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/bdpiprava/GoLangfuse/types"
+)
+
+func TestNewTestTraceEvent(t *testing.T) {
+	traceEvent := NewTestTraceEvent()
+
+	require.NotNil(t, traceEvent)
+	assert.NotNil(t, traceEvent.ID)
+	assert.Equal(t, "SendTrace", traceEvent.Name)
+	assert.NotEmpty(t, traceEvent.SessionID)
+	assert.NotEmpty(t, traceEvent.UserID)
+	assert.Equal(t, "Test input for SendTrace", traceEvent.Input)
+	assert.Equal(t, "Test output for SendTrace", traceEvent.Output)
+	assert.NotNil(t, traceEvent.Metadata)
+	assert.Contains(t, traceEvent.Tags, "test")
+	assert.Contains(t, traceEvent.Tags, "integration")
+	assert.True(t, traceEvent.Public)
+}
+
+func TestNewTestGenerationEvent(t *testing.T) {
+	generationEvent := NewTestGenerationEvent()
+
+	require.NotNil(t, generationEvent)
+	assert.NotNil(t, generationEvent.ID)
+	assert.Equal(t, "TestGeneration", generationEvent.Name)
+	assert.NotNil(t, generationEvent.TraceID)
+	assert.NotNil(t, generationEvent.StartTime)
+	assert.Equal(t, "gpt-3.5-turbo", generationEvent.Model)
+	assert.Equal(t, "Test input for generation", generationEvent.Input)
+	assert.Equal(t, "Test output for generation", generationEvent.Output)
+	assert.NotNil(t, generationEvent.Metadata)
+	assert.Equal(t, types.Default, generationEvent.Level)
+	assert.Equal(t, 10, generationEvent.Usage.Input)
+	assert.Equal(t, 5, generationEvent.Usage.Output)
+	assert.Equal(t, 15, generationEvent.Usage.Total)
+	assert.NotNil(t, generationEvent.ModelParameters)
+	assert.Equal(t, 0, generationEvent.PromptVersion)
+}
+
+func TestNewTestSpanEvent(t *testing.T) {
+	spanEvent := NewTestSpanEvent()
+
+	require.NotNil(t, spanEvent)
+	assert.NotNil(t, spanEvent.ID)
+	assert.Equal(t, "TestSpan", spanEvent.Name)
+	assert.NotNil(t, spanEvent.TraceID)
+	assert.NotNil(t, spanEvent.StartTime)
+	assert.Equal(t, "Test input for span", spanEvent.Input)
+	assert.Equal(t, "Test output for span", spanEvent.Output)
+	assert.NotNil(t, spanEvent.Metadata)
+	assert.Equal(t, types.Default, spanEvent.Level)
+	assert.Equal(t, "1.0", spanEvent.Version)
+}
+
+func TestNewTestScoreEvent(t *testing.T) {
+	scoreEvent := NewTestScoreEvent()
+
+	require.NotNil(t, scoreEvent)
+	assert.NotNil(t, scoreEvent.ID)
+	assert.Equal(t, "TestScore", scoreEvent.Name)
+	assert.NotNil(t, scoreEvent.TraceID)
+	assert.Equal(t, float32(0.85), scoreEvent.Value)
+	assert.NotNil(t, scoreEvent.Comment)
+	assert.Equal(t, "Test score comment", *scoreEvent.Comment)
+}
+
+func TestBuildSession(t *testing.T) {
+	traceEvent := NewTestTraceEvent()
+	session := BuildSession(traceEvent)
+
+	require.NotNil(t, session)
+	assert.Equal(t, traceEvent.SessionID, session.ID)
+	assert.Equal(t, "test-project", session.ProjectID)
+	assert.Len(t, session.Traces, 1)
+
+	trace := session.Traces[0]
+	assert.Equal(t, traceEvent.ID.String(), trace.ID)
+	assert.Equal(t, traceEvent.Name, trace.Name)
+	assert.Equal(t, traceEvent.UserID, trace.UserID)
+	assert.Equal(t, traceEvent.SessionID, trace.SessionID)
+	assert.Equal(t, "test-project", trace.ProjectID)
+	assert.Equal(t, traceEvent.Public, trace.Public)
+	assert.Equal(t, traceEvent.Tags, trace.Tags)
+	assert.Equal(t, traceEvent.Input, trace.Input)
+	assert.Equal(t, traceEvent.Output, trace.Output)
+}
+
+func TestBuildSessionEmpty(t *testing.T) {
+	session := BuildSession()
+	assert.Nil(t, session)
+}
+
+func TestEventTimestamps(t *testing.T) {
+	before := time.Now()
+
+	generationEvent := NewTestGenerationEvent()
+	spanEvent := NewTestSpanEvent()
+
+	after := time.Now()
+
+	require.NotNil(t, generationEvent.StartTime)
+	require.NotNil(t, spanEvent.StartTime)
+
+	assert.True(t, generationEvent.StartTime.After(before) || generationEvent.StartTime.Equal(before))
+	assert.True(t, generationEvent.StartTime.Before(after) || generationEvent.StartTime.Equal(after))
+
+	assert.True(t, spanEvent.StartTime.After(before) || spanEvent.StartTime.Equal(before))
+	assert.True(t, spanEvent.StartTime.Before(after) || spanEvent.StartTime.Equal(after))
+}

test-integration/integration_test.go

@@ -73,6 +73,59 @@ func (s *LangfuseIntegrationTestSuite) Test_SendTrace() {
 	}, 10*time.Second, 100*time.Millisecond, "Trace event should be sent successfully")
 }
 
+func (s *LangfuseIntegrationTestSuite) Test_SendGeneration() {
+	generationEvent := NewTestGenerationEvent()
+
+	s.subject.AddEvent(context.TODO(), generationEvent)
+
+	s.Eventually(func() bool {
+		observationPath := fmt.Sprintf("/api/public/observations/%s", generationEvent.ID.String())
+		got, err := getEventType[types.GenerationEvent](s.cfg, observationPath)
+		if err != nil {
+			s.T().Logf("Failed to get generation event: %v", err)
+			return false
+		}
+
+		return s.Equal(generationEvent, got,
+			cmpopts.IgnoreFields(types.GenerationEvent{}, "StartTime", "CompletionStartTime", "EndTime"))
+	}, 10*time.Second, 100*time.Millisecond, "Generation event should be sent successfully")
+}
+
+func (s *LangfuseIntegrationTestSuite) Test_SendSpan() {
+	spanEvent := NewTestSpanEvent()
+
+	s.subject.AddEvent(context.TODO(), spanEvent)
+
+	s.Eventually(func() bool {
+		observationPath := fmt.Sprintf("/api/public/observations/%s", spanEvent.ID.String())
+		got, err := getEventType[types.SpanEvent](s.cfg, observationPath)
+		if err != nil {
+			s.T().Logf("Failed to get span event: %v", err)
+			return false
+		}
+
+		return s.Equal(spanEvent, got,
+			cmpopts.IgnoreFields(types.SpanEvent{}, "StartTime", "EndTime"))
+	}, 10*time.Second, 100*time.Millisecond, "Span event should be sent successfully")
+}
+
+func (s *LangfuseIntegrationTestSuite) Test_SendScore() {
+	scoreEvent := NewTestScoreEvent()
+
+	s.subject.AddEvent(context.TODO(), scoreEvent)
+
+	s.Eventually(func() bool {
+		scorePath := fmt.Sprintf("/api/public/scores/%s", scoreEvent.ID.String())
+		got, err := getEventType[types.ScoreEvent](s.cfg, scorePath)
+		if err != nil {
+			s.T().Logf("Failed to get score event: %v", err)
+			return false
+		}
+
+		return s.Equal(scoreEvent, got)
+	}, 10*time.Second, 100*time.Millisecond, "Score event should be sent successfully")
+}
+
 func (s *LangfuseIntegrationTestSuite) Equal(expected, got any, opts ...cmp.Option) bool {
 	less := func(a, b string) bool { return a < b }
 	opts = append(opts, cmpopts.SortSlices(less))
@@ -97,8 +150,15 @@ func getEventType[T any](cfg *config.Langfuse, path string) (*T, error) {
 		return nil, fmt.Errorf("failed to get event type: %w", err)
 	}
 
+	if r.StatusCode == 404 {
+		return nil, fmt.Errorf("event not found")
+	}
+
 	var t T
 	err = json.Unmarshal(r.RawBody, &t)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal response: %w, body: %s", err, string(r.RawBody))
+	}
 	return &t, err
 }