errors_test.go

package mcpp

import (
	"errors"
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestMCPError(t *testing.T) {
	t.Run("basic error creation", func(t *testing.T) {
		err := NewMCPError(ErrorTypeConnection, "test_code", "test message", nil, nil)
		
		assert.Equal(t, ErrorTypeConnection, err.Type)
		assert.Equal(t, "test_code", err.Code)
		assert.Equal(t, "test message", err.Message)
		assert.Nil(t, err.Cause)
		assert.Nil(t, err.Context)
	})
	
	t.Run("error with cause", func(t *testing.T) {
		cause := errors.New("underlying error")
		err := NewMCPError(ErrorTypeProtocol, "proto_error", "protocol failed", cause, nil)
		
		assert.Equal(t, cause, err.Cause)
		assert.Equal(t, cause, err.Unwrap())
		assert.Contains(t, err.Error(), "caused by: underlying error")
	})
	
	t.Run("error with context", func(t *testing.T) {
		context := map[string]any{
			"server": "test-server",
			"port":   8080,
		}
		err := NewMCPError(ErrorTypeConnection, "conn_failed", "connection failed", nil, context)
		
		assert.Equal(t, context, err.Context)
		assert.Contains(t, err.Error(), "server=test-server")
		assert.Contains(t, err.Error(), "port=8080")
	})
	
	t.Run("error with context method", func(t *testing.T) {
		err := NewMCPError(ErrorTypeValidation, "invalid_input", "input validation failed", nil, nil)
		err = err.WithContext("field", "username").WithContext("value", "")
		
		assert.Equal(t, "username", err.Context["field"])
		assert.Equal(t, "", err.Context["value"])
	})
	
	t.Run("error Is method", func(t *testing.T) {
		err1 := NewMCPError(ErrorTypeConnection, "conn_timeout", "connection timeout", nil, nil)
		err2 := NewMCPError(ErrorTypeConnection, "conn_timeout", "connection timeout", nil, nil)
		err3 := NewMCPError(ErrorTypeConnection, "conn_refused", "connection refused", nil, nil)
		
		assert.True(t, err1.Is(err2))
		assert.False(t, err1.Is(err3))
	})
}

func TestErrorConstructors(t *testing.T) {
	t.Run("connection error", func(t *testing.T) {
		err := NewConnectionError("conn_failed", "connection failed", nil)
		assert.Equal(t, ErrorTypeConnection, err.Type)
		assert.Equal(t, "conn_failed", err.Code)
	})
	
	t.Run("protocol error", func(t *testing.T) {
		err := NewProtocolError("invalid_response", "invalid response", nil)
		assert.Equal(t, ErrorTypeProtocol, err.Type)
		assert.Equal(t, "invalid_response", err.Code)
	})
	
	t.Run("configuration error", func(t *testing.T) {
		err := NewConfigurationError("missing_field", "required field missing", nil)
		assert.Equal(t, ErrorTypeConfiguration, err.Type)
		assert.Equal(t, "missing_field", err.Code)
	})
	
	t.Run("timeout error", func(t *testing.T) {
		err := NewTimeoutError("operation_timeout", "operation timed out", nil)
		assert.Equal(t, ErrorTypeTimeout, err.Type)
		assert.Equal(t, "operation_timeout", err.Code)
	})
	
	t.Run("validation error", func(t *testing.T) {
		err := NewValidationError("invalid_format", "invalid format", nil)
		assert.Equal(t, ErrorTypeValidation, err.Type)
		assert.Equal(t, "invalid_format", err.Code)
	})
	
	t.Run("session error", func(t *testing.T) {
		err := NewSessionError("session_expired", "session expired", nil)
		assert.Equal(t, ErrorTypeSession, err.Type)
		assert.Equal(t, "session_expired", err.Code)
	})
	
	t.Run("tool error", func(t *testing.T) {
		err := NewToolError("tool_not_found", "tool not found", nil)
		assert.Equal(t, ErrorTypeTool, err.Type)
		assert.Equal(t, "tool_not_found", err.Code)
	})
}

func TestWrapError(t *testing.T) {
	t.Run("wrap regular error", func(t *testing.T) {
		originalErr := errors.New("original error")
		wrappedErr := WrapError(originalErr, ErrorTypeConnection, "wrapped", "wrapped error")
		
		assert.Equal(t, ErrorTypeConnection, wrappedErr.Type)
		assert.Equal(t, "wrapped", wrappedErr.Code)
		assert.Equal(t, originalErr, wrappedErr.Cause)
	})
	
	t.Run("wrap nil error", func(t *testing.T) {
		wrappedErr := WrapError(nil, ErrorTypeConnection, "wrapped", "wrapped error")
		assert.Nil(t, wrappedErr)
	})
	
	t.Run("wrap MCP error returns original", func(t *testing.T) {
		originalErr := NewConnectionError("original", "original error", nil)
		wrappedErr := WrapError(originalErr, ErrorTypeProtocol, "wrapped", "wrapped error")
		
		assert.Equal(t, originalErr, wrappedErr)
	})
}

func TestErrorTypeRetryable(t *testing.T) {
	t.Run("retryable error types", func(t *testing.T) {
		assert.True(t, ErrorTypeConnection.IsRetryable())
		assert.True(t, ErrorTypeTimeout.IsRetryable())
	})
	
	t.Run("non-retryable error types", func(t *testing.T) {
		assert.False(t, ErrorTypeProtocol.IsRetryable())
		assert.False(t, ErrorTypeConfiguration.IsRetryable())
		assert.False(t, ErrorTypeValidation.IsRetryable())
	})
}

func TestErrorUtilities(t *testing.T) {
	t.Run("IsErrorType", func(t *testing.T) {
		err := NewConnectionError("conn_failed", "connection failed", nil)
		
		assert.True(t, IsErrorType(err, ErrorTypeConnection))
		assert.False(t, IsErrorType(err, ErrorTypeProtocol))
		
		regularErr := errors.New("regular error")
		assert.False(t, IsErrorType(regularErr, ErrorTypeConnection))
	})
	
	t.Run("GetErrorCode", func(t *testing.T) {
		err := NewConnectionError("conn_failed", "connection failed", nil)
		assert.Equal(t, "conn_failed", GetErrorCode(err))
		
		regularErr := errors.New("regular error")
		assert.Equal(t, "", GetErrorCode(regularErr))
	})
	
	t.Run("GetErrorContext", func(t *testing.T) {
		context := map[string]any{"server": "test"}
		err := NewMCPError(ErrorTypeConnection, "conn_failed", "connection failed", nil, context)
		
		retrievedContext := GetErrorContext(err)
		assert.Equal(t, context, retrievedContext)
		
		regularErr := errors.New("regular error")
		assert.Nil(t, GetErrorContext(regularErr))
	})
}

func TestErrorChain(t *testing.T) {
	t.Run("empty chain", func(t *testing.T) {
		chain := NewErrorChain()
		
		assert.False(t, chain.HasErrors())
		assert.Empty(t, chain.Errors())
		assert.Equal(t, "", chain.Error())
		assert.Nil(t, chain.First())
		assert.Nil(t, chain.Last())
	})
	
	t.Run("single error", func(t *testing.T) {
		chain := NewErrorChain()
		err := errors.New("test error")
		chain.Add(err)
		
		assert.True(t, chain.HasErrors())
		assert.Len(t, chain.Errors(), 1)
		assert.Equal(t, "test error", chain.Error())
		assert.Equal(t, err, chain.First())
		assert.Equal(t, err, chain.Last())
	})
	
	t.Run("multiple errors", func(t *testing.T) {
		chain := NewErrorChain()
		err1 := errors.New("error 1")
		err2 := errors.New("error 2")
		err3 := errors.New("error 3")
		
		chain.Add(err1).Add(err2).Add(err3)
		
		assert.True(t, chain.HasErrors())
		assert.Len(t, chain.Errors(), 3)
		assert.Contains(t, chain.Error(), "error 1")
		assert.Contains(t, chain.Error(), "error 2")
		assert.Contains(t, chain.Error(), "error 3")
		assert.Equal(t, err1, chain.First())
		assert.Equal(t, err3, chain.Last())
	})
	
	t.Run("add nil error", func(t *testing.T) {
		chain := NewErrorChain()
		chain.Add(nil)
		
		assert.False(t, chain.HasErrors())
	})
}

func TestErrorCollector(t *testing.T) {
	t.Run("empty collector", func(t *testing.T) {
		collector := NewErrorCollector()
		
		assert.False(t, collector.HasErrors())
		assert.Equal(t, 0, collector.Count())
		assert.Empty(t, collector.Errors())
		assert.Nil(t, collector.Error())
	})
	
	t.Run("single error", func(t *testing.T) {
		collector := NewErrorCollector()
		err := errors.New("test error")
		collector.Add(err)
		
		assert.True(t, collector.HasErrors())
		assert.Equal(t, 1, collector.Count())
		assert.Len(t, collector.Errors(), 1)
		assert.Equal(t, err, collector.Error())
	})
	
	t.Run("multiple errors", func(t *testing.T) {
		collector := NewErrorCollector()
		err1 := errors.New("error 1")
		err2 := errors.New("error 2")
		
		collector.Add(err1)
		collector.Add(err2)
		
		assert.True(t, collector.HasErrors())
		assert.Equal(t, 2, collector.Count())
		assert.Len(t, collector.Errors(), 2)
		
		combinedErr := collector.Error()
		assert.NotNil(t, combinedErr)
		assert.Contains(t, combinedErr.Error(), "error 1")
		assert.Contains(t, combinedErr.Error(), "error 2")
	})
	
	t.Run("add nil error", func(t *testing.T) {
		collector := NewErrorCollector()
		collector.Add(nil)
		
		assert.False(t, collector.HasErrors())
		assert.Equal(t, 0, collector.Count())
	})
	
	t.Run("clear errors", func(t *testing.T) {
		collector := NewErrorCollector()
		collector.Add(errors.New("error 1"))
		collector.Add(errors.New("error 2"))
		
		assert.True(t, collector.HasErrors())
		
		collector.Clear()
		
		assert.False(t, collector.HasErrors())
		assert.Equal(t, 0, collector.Count())
		assert.Empty(t, collector.Errors())
	})
}

func TestDefaultRetryPolicy(t *testing.T) {
	policy := DefaultRetryPolicy()
	
	assert.Equal(t, 3, policy.MaxAttempts)
	assert.Greater(t, policy.InitialDelay.Nanoseconds(), int64(0))
	assert.Greater(t, policy.MaxDelay.Nanoseconds(), policy.InitialDelay.Nanoseconds())
	assert.Greater(t, policy.BackoffFactor, 1.0)
	assert.Contains(t, policy.RetryableErrors, ErrorTypeConnection)
	assert.Contains(t, policy.RetryableErrors, ErrorTypeTimeout)
}