Add some unit tests

errors_test.go

@@ -0,0 +1,82 @@
+package bot
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestTooManyRequestsError(t *testing.T) {
+	err := &TooManyRequestsError{
+		Message:    "rate limit exceeded",
+		RetryAfter: 30,
+	}
+
+	expectedErrorMsg := "rate limit exceeded: retry_after 30"
+	if err.Error() != expectedErrorMsg {
+		t.Errorf("expected %s, got %s", expectedErrorMsg, err.Error())
+	}
+
+	if !IsTooManyRequestsError(err) {
+		t.Errorf("expected IsTooManyRequestsError to return true")
+	}
+
+	var genericError error = err
+	if !IsTooManyRequestsError(genericError) {
+		t.Errorf("expected IsTooManyRequestsError to return true for generic error type")
+	}
+}
+
+func TestMigrateError(t *testing.T) {
+	err := &MigrateError{
+		Message:         "chat migrated",
+		MigrateToChatID: 12345,
+	}
+
+	expectedErrorMsg := "chat migrated: migrate_to_chat_id 12345"
+	if err.Error() != expectedErrorMsg {
+		t.Errorf("expected %s, got %s", expectedErrorMsg, err.Error())
+	}
+
+	if !IsMigrateError(err) {
+		t.Errorf("expected IsMigrateError to return true")
+	}
+
+	var genericError error = err
+	if !IsMigrateError(genericError) {
+		t.Errorf("expected IsMigrateError to return true for generic error type")
+	}
+}
+
+func TestStandardErrors(t *testing.T) {
+	tests := []struct {
+		err      error
+		expected string
+	}{
+		{ErrorForbidden, "forbidden"},
+		{ErrorBadRequest, "bad request"},
+		{ErrorUnauthorized, "unauthorized"},
+		{ErrorTooManyRequests, "too many requests"},
+		{ErrorNotFound, "not found"},
+		{ErrorConflict, "conflict"},
+	}
+
+	for _, tt := range tests {
+		if tt.err.Error() != tt.expected {
+			t.Errorf("expected %s, got %s", tt.expected, tt.err.Error())
+		}
+	}
+}
+
+func TestIsTooManyRequestsErrorFalse(t *testing.T) {
+	err := errors.New("some other error")
+	if IsTooManyRequestsError(err) {
+		t.Errorf("expected IsTooManyRequestsError to return false")
+	}
+}
+
+func TestIsMigrateErrorFalse(t *testing.T) {
+	err := errors.New("some other error")
+	if IsMigrateError(err) {
+		t.Errorf("expected IsMigrateError to return false")
+	}
+}

process_update_test.go

@@ -0,0 +1,134 @@
+package bot
+
+import (
+	"context"
+	"sync"
+	"testing"
+
+	"github.com/go-telegram/bot/models"
+)
+
+func Test_applyMiddlewares(t *testing.T) {
+	h := func(ctx context.Context, bot *Bot, update *models.Update) {}
+
+	middleware1 := func(next HandlerFunc) HandlerFunc {
+		return func(ctx context.Context, bot *Bot, update *models.Update) {
+			next(ctx, bot, update)
+		}
+	}
+
+	middleware2 := func(next HandlerFunc) HandlerFunc {
+		return func(ctx context.Context, bot *Bot, update *models.Update) {
+			next(ctx, bot, update)
+		}
+	}
+
+	wrapped := applyMiddlewares(h, middleware1, middleware2)
+	if wrapped == nil {
+		t.Fatal("Expected wrapped handler to be non-nil")
+	}
+}
+
+func TestProcessUpdate(t *testing.T) {
+	var called bool
+	h := func(ctx context.Context, bot *Bot, update *models.Update) {
+		called = true
+	}
+
+	bot := &Bot{
+		defaultHandlerFunc: h,
+		middlewares:        []Middleware{},
+		handlersMx:         &sync.RWMutex{},
+		handlers:           map[string]handler{},
+	}
+
+	ctx := context.Background()
+	upd := &models.Update{Message: &models.Message{Text: "test"}}
+
+	bot.ProcessUpdate(ctx, upd)
+	if !called {
+		t.Fatal("Expected default handler to be called")
+	}
+}
+
+func TestProcessUpdate_WithMiddlewares(t *testing.T) {
+	var called bool
+	h := func(ctx context.Context, bot *Bot, update *models.Update) {
+		called = true
+	}
+
+	middleware := func(next HandlerFunc) HandlerFunc {
+		return func(ctx context.Context, bot *Bot, update *models.Update) {
+			next(ctx, bot, update)
+		}
+	}
+
+	bot := &Bot{
+		defaultHandlerFunc: h,
+		middlewares:        []Middleware{middleware},
+		handlersMx:         &sync.RWMutex{},
+		handlers:           map[string]handler{},
+	}
+
+	ctx := context.Background()
+	upd := &models.Update{Message: &models.Message{Text: "test"}}
+
+	bot.ProcessUpdate(ctx, upd)
+	if !called {
+		t.Fatal("Expected default handler to be called")
+	}
+}
+
+func Test_findHandler(t *testing.T) {
+	var called bool
+	h := func(ctx context.Context, bot *Bot, update *models.Update) {
+		called = true
+	}
+
+	bot := &Bot{
+		defaultHandlerFunc: h,
+		handlersMx:         &sync.RWMutex{},
+		handlers:           map[string]handler{},
+	}
+
+	// Register a handler
+	bot.handlers["test"] = handler{
+		handlerType: HandlerTypeMessageText,
+		matchType:   MatchTypeExact,
+		pattern:     "test",
+		handler:     h,
+	}
+
+	ctx := context.Background()
+	upd := &models.Update{Message: &models.Message{Text: "test"}}
+
+	handler := bot.findHandler(HandlerTypeMessageText, upd)
+	handler(ctx, bot, upd)
+
+	if !called {
+		t.Fatal("Expected registered handler to be called")
+	}
+}
+
+func Test_findHandler_Default(t *testing.T) {
+	var called bool
+	h := func(ctx context.Context, bot *Bot, update *models.Update) {
+		called = true
+	}
+
+	bot := &Bot{
+		defaultHandlerFunc: h,
+		handlersMx:         &sync.RWMutex{},
+		handlers:           map[string]handler{},
+	}
+
+	ctx := context.Background()
+	upd := &models.Update{Message: &models.Message{Text: "test"}}
+
+	handler := bot.findHandler(HandlerTypeCallbackQueryData, upd)
+	handler(ctx, bot, upd)
+
+	if !called {
+		t.Fatal("Expected default handler to be called")
+	}
+}

webhook_handler.go

@@ -32,7 +32,13 @@ func (b *Bot) WebhookHandler() http.HandlerFunc {
 		case <-req.Context().Done():
 			b.error("some updates lost, ctx done")
 			return
+		default:
+		}
+
+		select {
 		case b.updates <- update:
+		case <-req.Context().Done():
+			b.error("failed to send update, ctx done")
 		}
 	}
 }