Files
go-telegram/test/benchmarks/call_bench_test.go
T
github-actions[bot]andGitHub bd9baca716 chore(deps): update module gopkg.in/telebot.v3 to v4
Automated dependency update. All tests passed.
2026-11-20 03:17:17 +00:00

192 lines
5.4 KiB
Go

// Round-trip benchmarks: build a SendMessage request, POST it to a local
// httptest.Server returning a canned `{"ok":true,"result":Message}` body,
// decode the response. Measures marshal + transport + unmarshal end-to-end.
//
// Each library's idiomatic "send a text message" call path is exercised
// through its public API. The mock server replies identically for every path,
// so any difference comes from serialization, HTTP plumbing, or response
// decoding inside each library.
package benchmarks
import (
"context"
"net/http"
"strings"
"testing"
"github.com/lukaszraczylo/go-telegram/api"
"github.com/lukaszraczylo/go-telegram/client"
"github.com/lukaszraczylo/go-telegram/test/benchmarks/shared"
echotron "github.com/NicoNex/echotron/v3"
tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
gobot "github.com/go-telegram/bot"
telego "github.com/mymmrac/telego"
tele "gopkg.in/telebot.v4"
)
// Telegram-format token (digits:[\w-]{35}). telego enforces this format on construction.
const benchToken = "1234567890:ABCDEFGHIJKLMNOPQRSTUVWXYZ_ab123456"
// BenchmarkCall_ours — lukaszraczylo/go-telegram with default net/http
// transport. Most users land here.
func BenchmarkCall_ours(b *testing.B) {
srv := shared.NewMockServer()
defer srv.Close()
bot := client.New(benchToken, client.WithBaseURL(srv.URL))
ctx := context.Background()
b.ReportAllocs()
b.ResetTimer()
for b.Loop() {
_, err := api.SendMessage(ctx, bot, &api.SendMessageParams{
ChatID: api.ChatIDFromInt(42),
Text: "hello",
})
if err != nil {
b.Fatal(err)
}
}
}
// BenchmarkCall_ours_fasthttp — lukaszraczylo/go-telegram with the
// opt-in fasthttp transport (client.NewFastHTTPDoer). Apples-to-apples
// against telego, which also runs on fasthttp by default.
func BenchmarkCall_ours_fasthttp(b *testing.B) {
srv := shared.NewMockServer()
defer srv.Close()
bot := client.New(benchToken,
client.WithBaseURL(srv.URL),
client.WithHTTPClient(client.NewFastHTTPDoer()),
)
ctx := context.Background()
b.ReportAllocs()
b.ResetTimer()
for b.Loop() {
_, err := api.SendMessage(ctx, bot, &api.SendMessageParams{
ChatID: api.ChatIDFromInt(42),
Text: "hello",
})
if err != nil {
b.Fatal(err)
}
}
}
// BenchmarkCall_gotba — go-telegram-bot-api/telegram-bot-api/v5.
func BenchmarkCall_gotba(b *testing.B) {
srv := shared.NewMockServer()
defer srv.Close()
// Endpoint is sprintf'd with token + method.
endpoint := srv.URL + "/bot%s/%s"
bot, err := tgbotapi.NewBotAPIWithClient(benchToken, endpoint, &http.Client{})
if err != nil {
b.Fatal(err)
}
msg := tgbotapi.NewMessage(42, "hello")
b.ReportAllocs()
b.ResetTimer()
for b.Loop() {
if _, err := bot.Send(msg); err != nil {
b.Fatal(err)
}
}
}
// BenchmarkCall_telebot — gopkg.in/telebot.v3 (tucnak).
func BenchmarkCall_telebot(b *testing.B) {
srv := shared.NewMockServer()
defer srv.Close()
bot, err := tele.NewBot(tele.Settings{
Token: benchToken,
URL: srv.URL,
Synchronous: true,
Offline: true, // skip eager getMe call; we test sending
})
if err != nil {
b.Fatal(err)
}
chat := &tele.Chat{ID: 42}
b.ReportAllocs()
b.ResetTimer()
for b.Loop() {
if _, err := bot.Send(chat, "hello"); err != nil {
b.Fatal(err)
}
}
}
// BenchmarkCall_gobot — go-telegram/bot.
func BenchmarkCall_gobot(b *testing.B) {
srv := shared.NewMockServer()
defer srv.Close()
bot, err := gobot.New(benchToken,
gobot.WithServerURL(srv.URL),
gobot.WithSkipGetMe(),
)
if err != nil {
b.Fatal(err)
}
ctx := context.Background()
params := &gobot.SendMessageParams{ChatID: int64(42), Text: "hello"}
b.ReportAllocs()
b.ResetTimer()
for b.Loop() {
if _, err := bot.SendMessage(ctx, params); err != nil {
b.Fatal(err)
}
}
}
// BenchmarkCall_telego — mymmrac/telego.
func BenchmarkCall_telego(b *testing.B) {
srv := shared.NewMockServer()
defer srv.Close()
bot, err := telego.NewBot(benchToken, telego.WithAPIServer(srv.URL))
if err != nil {
b.Fatal(err)
}
ctx := context.Background()
params := &telego.SendMessageParams{
ChatID: telego.ChatID{ID: 42},
Text: "hello",
}
b.ReportAllocs()
b.ResetTimer()
for b.Loop() {
if _, err := bot.SendMessage(ctx, params); err != nil {
b.Fatal(err)
}
}
}
// BenchmarkCall_echotron — NicoNex/echotron/v3.
//
// echotron expects a base URL ending in /bot<token>/ and ships built-in
// dual-level rate limiting (global 30/s, per-chat 20/min) on its unexported
// lclient field. The setters (SetGlobalRequestLimit / SetChatRequestLimit)
// are methods on the unexported type and have no public accessor through
// the API value, so the rate limiter cannot be disabled from outside the
// package without monkey-patching.
//
// Running this bench against the real path produces ~3s/op driven entirely
// by the per-chat token bucket — measuring rate limiting, not the library.
// We skip rather than publish a misleading number; the rate limiter is a
// feature of echotron and is documented as a caveat in the report.
func BenchmarkCall_echotron(b *testing.B) {
b.Skip("echotron has built-in rate limiting that cannot be disabled via the public API; see comment")
srv := shared.NewMockServer()
defer srv.Close()
base := srv.URL + "/bot" + benchToken + "/"
api := echotron.CustomAPI(base, benchToken)
b.ReportAllocs()
b.ResetTimer()
for b.Loop() {
if _, err := api.SendMessage("hello", 42, nil); err != nil {
b.Fatal(err)
}
}
}
// silence unused-import if a build tag strips a lib.
var _ = strings.NewReader