gomog/pkg/errors/errors_test.go

package errors

import (
	"errors"
	"testing"
)

func TestGomogError_Error(t *testing.T) {
	tests := []struct {
		name     string
		err      *GomogError
		expected string
	}{
		{
			name:     "simple error",
			err:      &GomogError{Code: ErrInternalError, Message: "internal error"},
			expected: "[1] internal error",
		},
		{
			name:     "error with details",
			err:      (&GomogError{Code: ErrInternalError, Message: "internal error"}).WithDetails("connection failed"),
			expected: "[1] internal error: connection failed",
		},
		{
			name:     "wrapped error",
			err:      Wrap(errors.New("underlying error"), ErrDatabaseError, "database error"),
			expected: "[4] database error: underlying error",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.err.Error() != tt.expected {
				t.Errorf("expected %s, got %s", tt.expected, tt.err.Error())
			}
		})
	}
}

func TestGomogError_WithDetails(t *testing.T) {
	err := ErrInternal.WithDetails("test details")
	if err.Details != "test details" {
		t.Errorf("expected details to be 'test details', got %s", err.Details)
	}
}

func TestGomogError_WithMetadata(t *testing.T) {
	err := ErrInternal.WithMetadata("key", "value")
	if err.Metadata["key"] != "value" {
		t.Errorf("expected metadata key to be 'value', got %s", err.Metadata["key"])
	}
}

func TestGomogError_GetHTTPStatus(t *testing.T) {
	tests := []struct {
		name     string
		err      *GomogError
		expected int
	}{
		{"internal error", ErrInternal, 500},
		{"invalid request", ErrInvalidReq, 400},
		{"not found", ErrCollectionNotFnd, 404},
		{"duplicate key", ErrDuplicate, 409},
		{"permission denied", ErrPermDenied, 403},
		{"timeout", ErrTimeoutErr, 408},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			status := tt.err.GetHTTPStatus()
			if status != tt.expected {
				t.Errorf("expected status %d, got %d", tt.expected, status)
			}
		})
	}
}

func TestNewf(t *testing.T) {
	err := Newf(ErrInvalidRequest, "field %s is required", "username")
	if err.Message != "field username is required" {
		t.Errorf("expected 'field username is required', got %s", err.Message)
	}
}

func TestWrapf(t *testing.T) {
	underlying := errors.New("underlying error")
	err := Wrapf(underlying, ErrDatabaseError, "failed to connect to %s", "database")
	if err.Message != "failed to connect to database" {
		t.Errorf("expected 'failed to connect to database', got %s", err.Message)
	}
	if !errors.Is(err, underlying) {
		t.Error("expected wrapped error to contain underlying error")
	}
}

func TestIsFunctions(t *testing.T) {
	tests := []struct {
		name     string
		err      error
		testFunc func(error) bool
		expected bool
	}{
		{"collection not found", ErrCollectionNotFnd, IsCollectionNotFound, true},
		{"document not found", ErrDocumentNotFnd, IsDocumentNotFound, true},
		{"duplicate key", ErrDuplicate, IsDuplicateKey, true},
		{"invalid request", ErrInvalidReq, IsInvalidRequest, true},
		{"type mismatch", ErrTypeMis, IsTypeMismatch, true},
		{"timeout", ErrTimeoutErr, IsTimeout, true},
		{"other error", ErrInternal, IsCollectionNotFound, false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := tt.testFunc(tt.err)
			if result != tt.expected {
				t.Errorf("expected %v, got %v", tt.expected, result)
			}
		})
	}
}

func TestGetErrorCode(t *testing.T) {
	code := GetErrorCode(ErrInternal)
	if code != ErrInternalError {
		t.Errorf("expected ErrInternalError, got %d", code)
	}
}

func TestGetErrorMessage(t *testing.T) {
	msg := GetErrorMessage(ErrInternal)
	if msg != "internal error" {
		t.Errorf("expected 'internal error', got %s", msg)
	}
}

func TestToHTTPStatus(t *testing.T) {
	status := ToHTTPStatus(ErrCollectionNotFnd)
	if status != 404 {
		t.Errorf("expected 404, got %d", status)
	}
}

func TestEqual(t *testing.T) {
	tests := []struct {
		name     string
		err1     error
		err2     error
		expected bool
	}{
		{"same error", ErrInternal, ErrInternal, true},
		{"different errors", ErrInternal, ErrInvalidReq, false},
		{"nil errors", nil, nil, true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := Equal(tt.err1, tt.err2)
			if result != tt.expected {
				t.Errorf("expected %v, got %v", tt.expected, result)
			}
		})
	}
}

func TestUnwrap(t *testing.T) {
	underlying := errors.New("underlying error")
	wrapped := Wrap(underlying, ErrDatabaseError, "database error")

	unwrapped := errors.Unwrap(wrapped)
	if unwrapped != underlying {
		t.Errorf("expected underlying error, got %v", unwrapped)
	}
}