mirror of
https://github.com/tiennm99/miti99bot.git
synced 2026-06-09 08:12:54 +00:00
test(handlers): integration tests + recording bot + emulator on CI
Phase 5 of the 2026-05-09 review remediation plan. Closes the handler-layer test gap (5 modules at 0% coverage in the audit) and ends the storage-package's CI t.Skip on Firestore emulator tests. - internal/testutil: Update fixture builders (NewPrivateMessage, NewGroupMessage, NewSupergroupMessage, NewChannelMessage) plus a RecordingBot that wraps the real go-telegram/bot.Bot with an httptest server. The bot library hits the test server instead of Telegram; multipart form fields are captured per call. Tests assert on Sent() / LastSent() / AssertSentText(). - Handler tests added: misc (4), util (7), wordle (10), loldle (9), loldleemoji (8). Cover happy paths, error paths, auth gates, group-vs-private subject keying, KV side effects. - Coverage 44.7% -> 69.8% (verified via -coverprofile). All packages now report coverage in CI output. - CI: ci.yml installs cloud-firestore-emulator beta component and starts it on localhost:8090 before go test. Sets FIRESTORE_EMULATOR_HOST + GOOGLE_CLOUD_PROJECT env so the storage package's emulator-gated tests execute instead of skipping. go test -race -count=1 ./... clean across all 15 packages locally.
This commit is contained in:
@@ -26,8 +26,38 @@ jobs:
|
||||
- name: go vet
|
||||
run: go vet ./...
|
||||
|
||||
# Start the Firestore emulator before tests so the storage package's
|
||||
# FIRESTORE_EMULATOR_HOST-gated tests run instead of t.Skip-ing.
|
||||
# gcloud is pre-installed on ubuntu-latest runners; the emulator is
|
||||
# an optional component fetched on first start.
|
||||
- name: start firestore emulator
|
||||
run: |
|
||||
gcloud --quiet components install beta cloud-firestore-emulator || true
|
||||
nohup gcloud beta emulators firestore start \
|
||||
--host-port=localhost:8090 \
|
||||
--quiet > /tmp/firestore.log 2>&1 &
|
||||
# Wait up to 60s for the emulator to bind.
|
||||
for i in $(seq 1 60); do
|
||||
if nc -z localhost 8090; then
|
||||
echo "firestore emulator ready"
|
||||
exit 0
|
||||
fi
|
||||
sleep 1
|
||||
done
|
||||
echo "firestore emulator failed to start"
|
||||
cat /tmp/firestore.log
|
||||
exit 1
|
||||
|
||||
- name: go test
|
||||
run: go test -race -count=1 ./...
|
||||
env:
|
||||
FIRESTORE_EMULATOR_HOST: localhost:8090
|
||||
GOOGLE_CLOUD_PROJECT: ci-test-project
|
||||
# Keep test logs out of stdout to avoid drowning real failures.
|
||||
LOG_LEVEL: error
|
||||
run: go test -race -count=1 -coverprofile=cov.out ./...
|
||||
|
||||
- name: coverage summary
|
||||
run: go tool cover -func=cov.out | tail -1
|
||||
|
||||
- name: go build
|
||||
run: go build ./...
|
||||
|
||||
@@ -0,0 +1,153 @@
|
||||
package loldle
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/tiennm99/miti99bot-go/internal/modules"
|
||||
"github.com/tiennm99/miti99bot-go/internal/storage"
|
||||
"github.com/tiennm99/miti99bot-go/internal/testutil"
|
||||
)
|
||||
|
||||
// installLoldle wires the loldle module + auth (owner gates /loldle_setmax,
|
||||
// which is private). seedTarget pre-seeds a game so guess outcomes are
|
||||
// deterministic without hooking math/rand.
|
||||
func installLoldle(t *testing.T, ownerID int64, seedSubject, seedTarget string) (*testutil.RecordingBot, storage.KVStore) {
|
||||
t.Helper()
|
||||
rb := testutil.NewRecordingBot(t)
|
||||
provider := storage.NewMemoryProvider()
|
||||
kv := provider.For("loldle")
|
||||
mod := New(modules.Deps{KV: kv})
|
||||
reg := &modules.Registry{
|
||||
Modules: []modules.Module{{Name: "loldle", Commands: mod.Commands}},
|
||||
AllCommands: map[string]modules.Command{},
|
||||
}
|
||||
for _, c := range mod.Commands {
|
||||
reg.AllCommands[c.Name] = c
|
||||
}
|
||||
modules.Install(rb.Bot, reg, modules.Auth{BotOwnerID: ownerID})
|
||||
|
||||
if seedTarget != "" {
|
||||
g := &gameState{Target: seedTarget, Guesses: []string{}}
|
||||
if err := saveGame(context.Background(), kv, seedSubject, g); err != nil {
|
||||
t.Fatalf("seed game: %v", err)
|
||||
}
|
||||
}
|
||||
return rb, kv
|
||||
}
|
||||
|
||||
func TestLoldle_NoArgShowsBoard(t *testing.T) {
|
||||
rb, _ := installLoldle(t, 0, "1", "Aatrox")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/loldle"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "Guess 0/") {
|
||||
t.Errorf("/loldle no-arg reply missing 'Guess 0/...': %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoldle_Win(t *testing.T) {
|
||||
rb, _ := installLoldle(t, 0, "1", "Aatrox")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/loldle aatrox"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(strings.ToLower(got), "aatrox") {
|
||||
t.Errorf("win reply missing 'Aatrox': %q", got)
|
||||
}
|
||||
if !strings.Contains(got, "🎉") {
|
||||
t.Errorf("win reply missing celebration emoji: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoldle_UnknownChampion(t *testing.T) {
|
||||
rb, _ := installLoldle(t, 0, "1", "Aatrox")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/loldle ZilbeanZ"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "Champion not found") {
|
||||
t.Errorf("unknown champion reject: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoldle_DuplicateGuessRejected(t *testing.T) {
|
||||
rb, _ := installLoldle(t, 0, "1", "Aatrox")
|
||||
// First guess: Ahri (not the target — round continues).
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/loldle ahri"))
|
||||
rb.Reset()
|
||||
// Second guess: Ahri again — duplicate path.
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/loldle ahri"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "already guessed") {
|
||||
t.Errorf("duplicate-guess reply: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoldleGiveup_RevealsAnswer(t *testing.T) {
|
||||
rb, _ := installLoldle(t, 0, "1", "Aatrox")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/loldle_giveup"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "Aatrox") {
|
||||
t.Errorf("/loldle_giveup should reveal Aatrox: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoldleGiveup_NoActiveRound(t *testing.T) {
|
||||
rb, _ := installLoldle(t, 0, "", "")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/loldle_giveup"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "No active round") {
|
||||
t.Errorf("/loldle_giveup with no round: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoldleStats_Empty(t *testing.T) {
|
||||
rb, _ := installLoldle(t, 0, "", "")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/loldle_stats"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
for _, want := range []string{"Played: 0", "Wins: 0 (0%)", "Best streak: 0"} {
|
||||
if !strings.Contains(got, want) {
|
||||
t.Errorf("/loldle_stats empty missing %q; got %q", want, got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoldleSetMax_OwnerSucceeds(t *testing.T) {
|
||||
rb, kv := installLoldle(t, 999, "", "")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(999, "/loldle_setmax 5"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "max guesses set to 5") {
|
||||
t.Errorf("/loldle_setmax reply: %q", got)
|
||||
}
|
||||
var cfg roundConfig
|
||||
if err := kv.GetJSON(context.Background(), configKey("999"), &cfg); err != nil {
|
||||
t.Fatalf("expected config persisted: %v", err)
|
||||
}
|
||||
if cfg.MaxGuesses != 5 {
|
||||
t.Errorf("MaxGuesses persisted = %d, want 5", cfg.MaxGuesses)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoldleSetMax_DeniedToNonOwner(t *testing.T) {
|
||||
rb, _ := installLoldle(t, 999, "", "")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(7, "/loldle_setmax 5"))
|
||||
|
||||
if calls := rb.Sent(); len(calls) != 0 {
|
||||
t.Errorf("non-owner /loldle_setmax replied: %+v", calls)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoldleSetMax_RejectsOutOfRange(t *testing.T) {
|
||||
rb, _ := installLoldle(t, 999, "", "")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(999, "/loldle_setmax 99"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "Usage:") {
|
||||
t.Errorf("out-of-range setmax should show usage; got %q", got)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,130 @@
|
||||
package loldleemoji
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/tiennm99/miti99bot-go/internal/modules"
|
||||
"github.com/tiennm99/miti99bot-go/internal/storage"
|
||||
"github.com/tiennm99/miti99bot-go/internal/testutil"
|
||||
)
|
||||
|
||||
// installEmoji wires the loldle-emoji module + auth (owner gates
|
||||
// /loldle_emoji_setmax). seedTarget pre-seeds a game so guess outcomes are
|
||||
// deterministic without hooking math/rand.
|
||||
func installEmoji(t *testing.T, ownerID int64, seedSubject, seedTarget string) (*testutil.RecordingBot, storage.KVStore) {
|
||||
t.Helper()
|
||||
rb := testutil.NewRecordingBot(t)
|
||||
provider := storage.NewMemoryProvider()
|
||||
kv := provider.For("loldle-emoji")
|
||||
mod := New(modules.Deps{KV: kv})
|
||||
reg := &modules.Registry{
|
||||
Modules: []modules.Module{{Name: "loldle-emoji", Commands: mod.Commands}},
|
||||
AllCommands: map[string]modules.Command{},
|
||||
}
|
||||
for _, c := range mod.Commands {
|
||||
reg.AllCommands[c.Name] = c
|
||||
}
|
||||
modules.Install(rb.Bot, reg, modules.Auth{BotOwnerID: ownerID})
|
||||
|
||||
if seedTarget != "" {
|
||||
g := &gameState{Target: seedTarget, Guesses: []string{}}
|
||||
if err := saveGame(context.Background(), kv, seedSubject, g); err != nil {
|
||||
t.Fatalf("seed game: %v", err)
|
||||
}
|
||||
}
|
||||
return rb, kv
|
||||
}
|
||||
|
||||
func TestEmoji_NoArgShowsClue(t *testing.T) {
|
||||
rb, _ := installEmoji(t, 0, "1", "Aatrox")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/loldle_emoji"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "🎭") {
|
||||
t.Errorf("emoji clue marker missing: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmoji_Win(t *testing.T) {
|
||||
rb, _ := installEmoji(t, 0, "1", "Aatrox")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/loldle_emoji aatrox"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "Got it") {
|
||||
t.Errorf("win reply missing 'Got it': %q", got)
|
||||
}
|
||||
if !strings.Contains(got, "Aatrox") {
|
||||
t.Errorf("win reply missing 'Aatrox': %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmoji_UnknownChampion(t *testing.T) {
|
||||
rb, _ := installEmoji(t, 0, "1", "Aatrox")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/loldle_emoji ZilbeanZ"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "Champion not found") {
|
||||
t.Errorf("unknown champion reject: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmoji_DuplicateGuessRejected(t *testing.T) {
|
||||
rb, _ := installEmoji(t, 0, "1", "Aatrox")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/loldle_emoji ahri"))
|
||||
rb.Reset()
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/loldle_emoji ahri"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "already guessed") {
|
||||
t.Errorf("duplicate-guess reply: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmojiGiveup_RevealsAnswer(t *testing.T) {
|
||||
rb, _ := installEmoji(t, 0, "1", "Aatrox")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/loldle_emoji_giveup"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "Aatrox") {
|
||||
t.Errorf("/loldle_emoji_giveup should reveal Aatrox: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmojiStats_Empty(t *testing.T) {
|
||||
rb, _ := installEmoji(t, 0, "", "")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/loldle_emoji_stats"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
for _, want := range []string{"Played: 0", "Wins: 0 (0%)"} {
|
||||
if !strings.Contains(got, want) {
|
||||
t.Errorf("/loldle_emoji_stats empty missing %q; got %q", want, got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmojiSetMax_OwnerSucceeds(t *testing.T) {
|
||||
rb, kv := installEmoji(t, 999, "", "")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(999, "/loldle_emoji_setmax 7"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "max guesses set to 7") {
|
||||
t.Errorf("/loldle_emoji_setmax reply: %q", got)
|
||||
}
|
||||
var cfg roundConfig
|
||||
if err := kv.GetJSON(context.Background(), configKey("999"), &cfg); err != nil {
|
||||
t.Fatalf("expected config persisted: %v", err)
|
||||
}
|
||||
if cfg.MaxGuesses != 7 {
|
||||
t.Errorf("MaxGuesses persisted = %d, want 7", cfg.MaxGuesses)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmojiSetMax_DeniedToNonOwner(t *testing.T) {
|
||||
rb, _ := installEmoji(t, 999, "", "")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(7, "/loldle_emoji_setmax 5"))
|
||||
if calls := rb.Sent(); len(calls) != 0 {
|
||||
t.Errorf("non-owner /loldle_emoji_setmax replied: %+v", calls)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
package misc
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/tiennm99/miti99bot-go/internal/modules"
|
||||
"github.com/tiennm99/miti99bot-go/internal/storage"
|
||||
"github.com/tiennm99/miti99bot-go/internal/testutil"
|
||||
)
|
||||
|
||||
// installMisc wires the misc module to a recording bot with a fresh
|
||||
// in-memory KV. Returns the bot, the kv (so tests can pre-seed or read),
|
||||
// and an Auth that permits Owner + Admin so /mstats /fortytwo dispatch.
|
||||
func installMisc(t *testing.T, ownerID int64) (*testutil.RecordingBot, storage.KVStore) {
|
||||
t.Helper()
|
||||
rb := testutil.NewRecordingBot(t)
|
||||
provider := storage.NewMemoryProvider()
|
||||
kv := provider.For("misc")
|
||||
mod := New(modules.Deps{KV: kv})
|
||||
|
||||
reg := &modules.Registry{
|
||||
Modules: []modules.Module{{Name: "misc", Commands: mod.Commands}},
|
||||
AllCommands: map[string]modules.Command{},
|
||||
}
|
||||
for _, c := range mod.Commands {
|
||||
reg.AllCommands[c.Name] = c
|
||||
}
|
||||
auth := modules.Auth{BotOwnerID: ownerID}
|
||||
modules.Install(rb.Bot, reg, auth)
|
||||
return rb, kv
|
||||
}
|
||||
|
||||
func TestPing_RepliesPongAndWritesKV(t *testing.T) {
|
||||
rb, kv := installMisc(t, 999)
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(999, "/ping"))
|
||||
|
||||
if got := rb.LastSent().Text(); got != "pong" {
|
||||
t.Errorf("ping reply = %q, want %q", got, "pong")
|
||||
}
|
||||
var stored lastPing
|
||||
if err := kv.GetJSON(context.Background(), lastPingKey, &stored); err != nil {
|
||||
t.Fatalf("expected lastPing in KV: %v", err)
|
||||
}
|
||||
if stored.At <= 0 {
|
||||
t.Errorf("lastPing.At = %d, want positive", stored.At)
|
||||
}
|
||||
// Sanity: timestamp is within a minute of now (rules out stale fixture).
|
||||
if delta := time.Now().UTC().UnixMilli() - stored.At; delta > 60_000 || delta < 0 {
|
||||
t.Errorf("lastPing.At delta from now = %dms, want within 60s", delta)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMstats_NeverWhenKVEmpty(t *testing.T) {
|
||||
rb, _ := installMisc(t, 999)
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(999, "/mstats"))
|
||||
|
||||
if got := rb.LastSent().Text(); got != "last ping: never" {
|
||||
t.Errorf("mstats reply = %q, want 'last ping: never'", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMstats_AfterPing(t *testing.T) {
|
||||
rb, _ := installMisc(t, 999)
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(999, "/ping"))
|
||||
rb.Reset()
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(999, "/mstats"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.HasPrefix(got, "last ping: ") {
|
||||
t.Errorf("mstats reply = %q, want 'last ping: ...'", got)
|
||||
}
|
||||
if strings.Contains(got, "never") {
|
||||
t.Errorf("mstats still says 'never' after /ping: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMstats_DeniedToNonAdmin(t *testing.T) {
|
||||
rb, _ := installMisc(t, 999) // owner = 999
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(7, "/mstats"))
|
||||
|
||||
if calls := rb.Sent(); len(calls) != 0 {
|
||||
t.Errorf("non-admin /mstats produced replies: %+v", calls)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFortytwo_OwnerOnly(t *testing.T) {
|
||||
rb, _ := installMisc(t, 999)
|
||||
|
||||
// Non-owner: silent denial
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(7, "/fortytwo"))
|
||||
if calls := rb.Sent(); len(calls) != 0 {
|
||||
t.Errorf("non-owner /fortytwo replied: %+v", calls)
|
||||
}
|
||||
|
||||
// Owner: reply
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(999, "/fortytwo"))
|
||||
if got := rb.LastSent().Text(); got != "The answer." {
|
||||
t.Errorf("owner /fortytwo reply = %q, want 'The answer.'", got)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
package util_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/go-telegram/bot/models"
|
||||
|
||||
"github.com/tiennm99/miti99bot-go/internal/modules"
|
||||
"github.com/tiennm99/miti99bot-go/internal/modules/util"
|
||||
"github.com/tiennm99/miti99bot-go/internal/storage"
|
||||
"github.com/tiennm99/miti99bot-go/internal/testutil"
|
||||
)
|
||||
|
||||
// installUtil builds a registry with the util module + auth that admits the
|
||||
// supplied owner so /stickerid (private) dispatches.
|
||||
func installUtil(t *testing.T, ownerID int64) *testutil.RecordingBot {
|
||||
t.Helper()
|
||||
rb := testutil.NewRecordingBot(t)
|
||||
reg, err := modules.Build([]string{"util"},
|
||||
map[string]modules.Factory{"util": util.New},
|
||||
storage.NewMemoryProvider(), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build: %v", err)
|
||||
}
|
||||
modules.Install(rb.Bot, reg, modules.Auth{BotOwnerID: ownerID})
|
||||
return rb
|
||||
}
|
||||
|
||||
func TestInfo_PrivateChat(t *testing.T) {
|
||||
rb := installUtil(t, 0)
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(42, "/info"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
for _, want := range []string{"chat id: 42", "thread id: n/a", "sender id: 42"} {
|
||||
if !strings.Contains(got, want) {
|
||||
t.Errorf("info reply missing %q; got %q", want, got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestInfo_GroupChat(t *testing.T) {
|
||||
rb := installUtil(t, 0)
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewGroupMessage(-100, 7, "/info"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
for _, want := range []string{"chat id: -100", "sender id: 7"} {
|
||||
if !strings.Contains(got, want) {
|
||||
t.Errorf("info reply missing %q; got %q", want, got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestInfo_ChannelMessageNoFrom(t *testing.T) {
|
||||
rb := installUtil(t, 0)
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewChannelMessage(-200, "/info"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "sender id: n/a") {
|
||||
t.Errorf("info channel reply missing 'sender id: n/a'; got %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHelp_RendersHTML(t *testing.T) {
|
||||
rb := installUtil(t, 0)
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/help"))
|
||||
|
||||
calls := rb.Sent()
|
||||
if len(calls) == 0 {
|
||||
t.Fatal("/help produced no reply")
|
||||
}
|
||||
got := calls[len(calls)-1]
|
||||
if got.Form["parse_mode"] != string(models.ParseModeHTML) {
|
||||
t.Errorf("/help parse_mode = %q, want HTML", got.Form["parse_mode"])
|
||||
}
|
||||
if !strings.Contains(got.Text(), "<b>util</b>") {
|
||||
t.Errorf("/help body missing util section; got %q", got.Text())
|
||||
}
|
||||
}
|
||||
|
||||
func TestStickerID_NoReply_ShowsUsage(t *testing.T) {
|
||||
rb := installUtil(t, 999)
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(999, "/stickerid"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "Reply to a sticker") {
|
||||
t.Errorf("stickerid usage missing; got %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStickerID_WithStickerReply_EchoesFileID(t *testing.T) {
|
||||
rb := installUtil(t, 999)
|
||||
upd := testutil.NewPrivateMessage(999, "/stickerid")
|
||||
upd.Message.ReplyToMessage = &models.Message{
|
||||
Sticker: &models.Sticker{
|
||||
FileID: "AAA-file-id",
|
||||
FileUniqueID: "uniq",
|
||||
SetName: "TestSet",
|
||||
Emoji: "🎉",
|
||||
},
|
||||
}
|
||||
rb.Bot.ProcessUpdate(context.Background(), upd)
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
for _, want := range []string{"AAA-file-id", "uniq", "TestSet", "🎉"} {
|
||||
if !strings.Contains(got, want) {
|
||||
t.Errorf("stickerid reply missing %q; got %q", want, got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestStickerID_DeniedToNonOwner(t *testing.T) {
|
||||
rb := installUtil(t, 999)
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(7, "/stickerid"))
|
||||
if calls := rb.Sent(); len(calls) != 0 {
|
||||
t.Errorf("non-owner /stickerid replied: %+v", calls)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,166 @@
|
||||
package wordle
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/tiennm99/miti99bot-go/internal/modules"
|
||||
"github.com/tiennm99/miti99bot-go/internal/storage"
|
||||
"github.com/tiennm99/miti99bot-go/internal/testutil"
|
||||
)
|
||||
|
||||
// installWordle wires the wordle module to a recording bot with an
|
||||
// in-memory KV. seedTarget pre-seeds a game with the supplied target
|
||||
// (skip dictionary randomness for deterministic tests). Empty seedTarget
|
||||
// leaves the KV blank so handlers spin up a fresh round on first call.
|
||||
func installWordle(t *testing.T, ownerID int64, seedSubject, seedTarget string) (*testutil.RecordingBot, storage.KVStore) {
|
||||
t.Helper()
|
||||
rb := testutil.NewRecordingBot(t)
|
||||
provider := storage.NewMemoryProvider()
|
||||
kv := provider.For("wordle")
|
||||
mod := New(modules.Deps{KV: kv})
|
||||
reg := &modules.Registry{
|
||||
Modules: []modules.Module{{Name: "wordle", Commands: mod.Commands}},
|
||||
AllCommands: map[string]modules.Command{},
|
||||
}
|
||||
for _, c := range mod.Commands {
|
||||
reg.AllCommands[c.Name] = c
|
||||
}
|
||||
modules.Install(rb.Bot, reg, modules.Auth{BotOwnerID: ownerID})
|
||||
|
||||
if seedTarget != "" {
|
||||
g := &GameState{Target: seedTarget, Guesses: []GuessRecord{}, StartedAt: 1}
|
||||
if err := saveGame(context.Background(), kv, seedSubject, g); err != nil {
|
||||
t.Fatalf("seed game: %v", err)
|
||||
}
|
||||
}
|
||||
return rb, kv
|
||||
}
|
||||
|
||||
func TestWordle_NoArgShowsBoard(t *testing.T) {
|
||||
rb, _ := installWordle(t, 0, "1", "crane")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/wordle"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "Guess 0/6") {
|
||||
t.Errorf("/wordle empty-arg reply missing 'Guess 0/6': %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWordle_Win(t *testing.T) {
|
||||
rb, _ := installWordle(t, 0, "1", "crane")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/wordle crane"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "Solved in 1/6") {
|
||||
t.Errorf("win reply missing 'Solved in 1/6': %q", got)
|
||||
}
|
||||
if !strings.Contains(got, "Streak: 1") {
|
||||
t.Errorf("win reply missing 'Streak: 1': %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWordle_InvalidWord_TooShort(t *testing.T) {
|
||||
rb, _ := installWordle(t, 0, "1", "crane")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/wordle hi"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "5 letters") {
|
||||
t.Errorf("short-word reject missing length hint: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWordle_InvalidWord_NotInDict(t *testing.T) {
|
||||
rb, _ := installWordle(t, 0, "1", "crane")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/wordle qqqqq"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "Not in the word list") {
|
||||
t.Errorf("dict-miss reject wrong text: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWordle_PartialGuessShowsProgress(t *testing.T) {
|
||||
rb, _ := installWordle(t, 0, "1", "crane")
|
||||
// "crate" shares 4 letters with "crane" — valid 5-letter dictionary word.
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/wordle crate"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "Guess 1/6") {
|
||||
t.Errorf("partial-guess reply missing 'Guess 1/6': %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWordleNew_StartsFreshRound(t *testing.T) {
|
||||
rb, _ := installWordle(t, 0, "1", "crane")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/wordle_new"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "New round started") {
|
||||
t.Errorf("/wordle_new reply: %q", got)
|
||||
}
|
||||
// Previous round was active (no guesses yet) → auto-giveup prelude expected.
|
||||
if !strings.Contains(got, "Previous round abandoned") {
|
||||
t.Errorf("/wordle_new should announce auto-giveup of prior active round; got %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWordleGiveup_RevealsAnswer(t *testing.T) {
|
||||
rb, _ := installWordle(t, 0, "1", "crane")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/wordle_giveup"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
if !strings.Contains(got, "CRANE") {
|
||||
t.Errorf("/wordle_giveup should reveal CRANE; got %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWordleStats_Empty(t *testing.T) {
|
||||
rb, _ := installWordle(t, 0, "", "")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/wordle_stats"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
for _, want := range []string{"Played: 0", "Wins: 0 (0%)", "Best streak: 0"} {
|
||||
if !strings.Contains(got, want) {
|
||||
t.Errorf("/wordle_stats missing %q; got %q", want, got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestWordleStats_AfterWin(t *testing.T) {
|
||||
rb, _ := installWordle(t, 0, "1", "crane")
|
||||
// Win: produces 1 played, 1 win, streak 1.
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/wordle crane"))
|
||||
rb.Reset()
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewPrivateMessage(1, "/wordle_stats"))
|
||||
|
||||
got := rb.LastSent().Text()
|
||||
for _, want := range []string{"Played: 1", "Wins: 1 (100%)", "Current streak: 1"} {
|
||||
if !strings.Contains(got, want) {
|
||||
t.Errorf("/wordle_stats post-win missing %q; got %q", want, got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Group chats key by chat id, so two private users both writing /wordle
|
||||
// in the same group must mutate the same game.
|
||||
func TestWordle_GroupSubjectIsChatID(t *testing.T) {
|
||||
rb, kv := installWordle(t, 0, "-100", "crane")
|
||||
rb.Bot.ProcessUpdate(context.Background(), testutil.NewGroupMessage(-100, 7, "/wordle crate"))
|
||||
|
||||
// After one guess in chat -100, subject "-100" should have a guess
|
||||
// recorded; subject "7" should have no game.
|
||||
var gChat GameState
|
||||
if err := kv.GetJSON(context.Background(), gameKey("-100"), &gChat); err != nil {
|
||||
t.Fatalf("expected game at subject=-100: %v", err)
|
||||
}
|
||||
if len(gChat.Guesses) != 1 {
|
||||
t.Errorf("group game has %d guesses, want 1", len(gChat.Guesses))
|
||||
}
|
||||
var gUser GameState
|
||||
err := kv.GetJSON(context.Background(), gameKey("7"), &gUser)
|
||||
if err == nil {
|
||||
t.Errorf("user-keyed game leaked despite group context: %+v", gUser)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,175 @@
|
||||
package testutil
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
|
||||
"github.com/go-telegram/bot"
|
||||
)
|
||||
|
||||
// SentCall captures one outbound Telegram API call (sendMessage, sendSticker,
|
||||
// etc.) made by the bot during dispatch. Method is the API method ("sendMessage")
|
||||
// and Form is the multipart form fields collapsed to plain string→string —
|
||||
// the bot library only emits primitive scalars for our handler call sites.
|
||||
type SentCall struct {
|
||||
Method string
|
||||
Form map[string]string
|
||||
}
|
||||
|
||||
// Text is a convenience accessor for the most common assertion: SendMessage's
|
||||
// "text" field. Returns "" if the call wasn't a sendMessage.
|
||||
func (c SentCall) Text() string { return c.Form["text"] }
|
||||
|
||||
// ChatID returns the "chat_id" form field as-is (string form). Empty string
|
||||
// if absent.
|
||||
func (c SentCall) ChatID() string { return c.Form["chat_id"] }
|
||||
|
||||
// RecordingBot wraps a *bot.Bot wired to an httptest server that captures
|
||||
// outbound API calls instead of contacting Telegram. Always Close() in a
|
||||
// defer to release the test server.
|
||||
type RecordingBot struct {
|
||||
Bot *bot.Bot
|
||||
Server *httptest.Server
|
||||
|
||||
mu sync.Mutex
|
||||
calls []SentCall
|
||||
}
|
||||
|
||||
// NewRecordingBot constructs a recording bot. The bot uses a synthetic token
|
||||
// and disables async handlers so dispatch is deterministic in tests.
|
||||
func NewRecordingBot(t *testing.T) *RecordingBot {
|
||||
t.Helper()
|
||||
rb := &RecordingBot{}
|
||||
rb.Server = httptest.NewServer(http.HandlerFunc(rb.handle))
|
||||
t.Cleanup(rb.Server.Close)
|
||||
|
||||
b, err := bot.New("test-token",
|
||||
bot.WithSkipGetMe(),
|
||||
bot.WithNotAsyncHandlers(),
|
||||
bot.WithServerURL(rb.Server.URL),
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("recording bot init: %v", err)
|
||||
}
|
||||
rb.Bot = b
|
||||
return rb
|
||||
}
|
||||
|
||||
// Sent returns a copy of all calls captured so far, in chronological order.
|
||||
func (rb *RecordingBot) Sent() []SentCall {
|
||||
rb.mu.Lock()
|
||||
defer rb.mu.Unlock()
|
||||
out := make([]SentCall, len(rb.calls))
|
||||
copy(out, rb.calls)
|
||||
return out
|
||||
}
|
||||
|
||||
// LastSent returns the most-recent recorded call, or zero-value SentCall if
|
||||
// none have been made yet.
|
||||
func (rb *RecordingBot) LastSent() SentCall {
|
||||
rb.mu.Lock()
|
||||
defer rb.mu.Unlock()
|
||||
if len(rb.calls) == 0 {
|
||||
return SentCall{}
|
||||
}
|
||||
return rb.calls[len(rb.calls)-1]
|
||||
}
|
||||
|
||||
// Reset drops all captured calls. Useful between sub-tests sharing one bot.
|
||||
func (rb *RecordingBot) Reset() {
|
||||
rb.mu.Lock()
|
||||
rb.calls = nil
|
||||
rb.mu.Unlock()
|
||||
}
|
||||
|
||||
// handle is the httptest server's request handler. Path shape is
|
||||
// "/bot<token>/<method>" per the go-telegram/bot URL builder. We extract the
|
||||
// method, parse the multipart form, record, and respond with a minimal-ok
|
||||
// JSON body shaped to satisfy whichever method was called.
|
||||
func (rb *RecordingBot) handle(w http.ResponseWriter, r *http.Request) {
|
||||
method := apiMethodFromPath(r.URL.Path)
|
||||
|
||||
if err := r.ParseMultipartForm(8 << 20); err != nil {
|
||||
http.Error(w, "bad form", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
form := make(map[string]string, len(r.MultipartForm.Value))
|
||||
for k, vs := range r.MultipartForm.Value {
|
||||
if len(vs) > 0 {
|
||||
form[k] = vs[0]
|
||||
}
|
||||
}
|
||||
|
||||
rb.mu.Lock()
|
||||
rb.calls = append(rb.calls, SentCall{Method: method, Form: form})
|
||||
rb.mu.Unlock()
|
||||
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_, _ = w.Write([]byte(okResponseFor(method)))
|
||||
}
|
||||
|
||||
// apiMethodFromPath extracts the API method from "/bot<token>/<method>".
|
||||
// Returns "" on shapes that don't match (which the test still records as a
|
||||
// call to "" — surfaces accidentally weird URLs in test output).
|
||||
func apiMethodFromPath(p string) string {
|
||||
idx := strings.LastIndex(p, "/")
|
||||
if idx < 0 {
|
||||
return ""
|
||||
}
|
||||
return p[idx+1:]
|
||||
}
|
||||
|
||||
// okResponseFor returns a minimal `{ok:true, result:...}` payload that the
|
||||
// bot library will accept for the named API method. SendMessage / SendSticker
|
||||
// expect a Message; most others accept a bool.
|
||||
func okResponseFor(method string) string {
|
||||
switch method {
|
||||
case "sendMessage", "sendSticker", "sendPhoto", "sendDocument", "sendVideo":
|
||||
// Minimal shape: id, date, chat. Bot library decodes via json so
|
||||
// extra fields are ignored.
|
||||
msg := map[string]any{
|
||||
"message_id": 1,
|
||||
"date": 0,
|
||||
"chat": map[string]any{
|
||||
"id": 1,
|
||||
"type": "private",
|
||||
},
|
||||
}
|
||||
body := map[string]any{"ok": true, "result": msg}
|
||||
out, _ := json.Marshal(body)
|
||||
return string(out)
|
||||
default:
|
||||
return `{"ok":true,"result":true}`
|
||||
}
|
||||
}
|
||||
|
||||
// AssertSentText fails the test if no recorded sendMessage contains the
|
||||
// substring needle. Matches the most common assertion pattern: "did the
|
||||
// handler include this phrase?"
|
||||
func (rb *RecordingBot) AssertSentText(t *testing.T, needle string) {
|
||||
t.Helper()
|
||||
for _, c := range rb.Sent() {
|
||||
if c.Method == "sendMessage" && strings.Contains(c.Text(), needle) {
|
||||
return
|
||||
}
|
||||
}
|
||||
t.Errorf("no sendMessage contained %q. Sent calls: %s", needle, rb.dumpCalls())
|
||||
}
|
||||
|
||||
// dumpCalls renders the captured calls for error messages.
|
||||
func (rb *RecordingBot) dumpCalls() string {
|
||||
calls := rb.Sent()
|
||||
var parts []string
|
||||
for i, c := range calls {
|
||||
parts = append(parts, fmt.Sprintf("[%d] %s text=%q chat=%s", i, c.Method, c.Text(), c.ChatID()))
|
||||
}
|
||||
if len(parts) == 0 {
|
||||
return "(no calls)"
|
||||
}
|
||||
return strings.Join(parts, "; ")
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
package testutil
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/go-telegram/bot"
|
||||
)
|
||||
|
||||
// Smoke test: the recording bot must capture an outbound SendMessage so
|
||||
// downstream handler tests can rely on Sent() / AssertSentText.
|
||||
func TestRecordingBot_CapturesSendMessage(t *testing.T) {
|
||||
rb := NewRecordingBot(t)
|
||||
|
||||
_, err := rb.Bot.SendMessage(context.Background(), &bot.SendMessageParams{
|
||||
ChatID: int64(42),
|
||||
Text: "hello",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("SendMessage: %v", err)
|
||||
}
|
||||
|
||||
calls := rb.Sent()
|
||||
if len(calls) != 1 {
|
||||
t.Fatalf("calls = %d, want 1: %+v", len(calls), calls)
|
||||
}
|
||||
if calls[0].Method != "sendMessage" {
|
||||
t.Errorf("method = %q, want sendMessage", calls[0].Method)
|
||||
}
|
||||
if calls[0].Text() != "hello" {
|
||||
t.Errorf("text = %q, want hello", calls[0].Text())
|
||||
}
|
||||
if calls[0].ChatID() != "42" {
|
||||
t.Errorf("chat_id = %q, want 42", calls[0].ChatID())
|
||||
}
|
||||
}
|
||||
|
||||
func TestRecordingBot_AssertSentText(t *testing.T) {
|
||||
rb := NewRecordingBot(t)
|
||||
_, err := rb.Bot.SendMessage(context.Background(), &bot.SendMessageParams{
|
||||
ChatID: int64(1),
|
||||
Text: "Welcome to the bot",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rb.AssertSentText(t, "Welcome")
|
||||
}
|
||||
|
||||
func TestRecordingBot_Reset(t *testing.T) {
|
||||
rb := NewRecordingBot(t)
|
||||
_, _ = rb.Bot.SendMessage(context.Background(), &bot.SendMessageParams{
|
||||
ChatID: int64(1), Text: "first",
|
||||
})
|
||||
rb.Reset()
|
||||
if got := len(rb.Sent()); got != 0 {
|
||||
t.Errorf("Sent() after Reset = %d, want 0", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUpdateBuilders_BotCommandEntity(t *testing.T) {
|
||||
tests := []struct {
|
||||
text string
|
||||
off int
|
||||
ln int
|
||||
}{
|
||||
{"/wordle", 0, 7},
|
||||
{"/wordle apple", 0, 7},
|
||||
{"/wordle@bot apple", 0, 7},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
got := botCommandEntity(tt.text)
|
||||
if got.Offset != tt.off || got.Length != tt.ln {
|
||||
t.Errorf("botCommandEntity(%q) = (%d,%d), want (%d,%d)",
|
||||
tt.text, got.Offset, got.Length, tt.off, tt.ln)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
// Package testutil provides shared fixtures for handler-layer integration
|
||||
// tests: update builders, a recording Bot that captures outbound API calls
|
||||
// instead of hitting Telegram, and helpers to assert on captured calls.
|
||||
//
|
||||
// Tests should construct a real *bot.Bot (via NewRecordingBot), register
|
||||
// real module handlers against it, dispatch a fixture *models.Update via
|
||||
// Bot.ProcessUpdate, and then inspect Sent() to verify the reply.
|
||||
package testutil
|
||||
|
||||
import (
|
||||
"github.com/go-telegram/bot/models"
|
||||
)
|
||||
|
||||
// NewPrivateMessage builds an Update for a 1:1 private DM. userID is both
|
||||
// the chat id and the From id (private chats use the user as the chat id).
|
||||
func NewPrivateMessage(userID int64, text string) *models.Update {
|
||||
return &models.Update{
|
||||
ID: 1,
|
||||
Message: &models.Message{
|
||||
ID: 1,
|
||||
Text: text,
|
||||
Chat: models.Chat{ID: userID, Type: models.ChatTypePrivate},
|
||||
From: &models.User{ID: userID, FirstName: "Test"},
|
||||
Entities: []models.MessageEntity{
|
||||
botCommandEntity(text),
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// NewGroupMessage builds an Update for a group chat where chatID and userID
|
||||
// are distinct (group rules: subject = chat ID, sender = user ID).
|
||||
func NewGroupMessage(chatID, userID int64, text string) *models.Update {
|
||||
return &models.Update{
|
||||
ID: 1,
|
||||
Message: &models.Message{
|
||||
ID: 1,
|
||||
Text: text,
|
||||
Chat: models.Chat{ID: chatID, Type: models.ChatTypeGroup, Title: "Test Group"},
|
||||
From: &models.User{ID: userID, FirstName: "Test"},
|
||||
Entities: []models.MessageEntity{
|
||||
botCommandEntity(text),
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// NewSupergroupMessage is the same shape as NewGroupMessage but with
|
||||
// supergroup chat type — exercises the second branch in chathelper.SubjectFor.
|
||||
func NewSupergroupMessage(chatID, userID int64, text string) *models.Update {
|
||||
u := NewGroupMessage(chatID, userID, text)
|
||||
u.Message.Chat.Type = models.ChatTypeSupergroup
|
||||
return u
|
||||
}
|
||||
|
||||
// NewChannelMessage builds an Update for a channel post — no From field on
|
||||
// most channel posts. Used to exercise the "no usable subject id" path.
|
||||
func NewChannelMessage(chatID int64, text string) *models.Update {
|
||||
return &models.Update{
|
||||
ID: 1,
|
||||
Message: &models.Message{
|
||||
ID: 1,
|
||||
Text: text,
|
||||
Chat: models.Chat{ID: chatID, Type: models.ChatTypeChannel, Title: "Test Channel"},
|
||||
Entities: []models.MessageEntity{
|
||||
botCommandEntity(text),
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// botCommandEntity is what Telegram attaches when a message starts with `/`.
|
||||
// The dispatcher's MatchTypeCommand uses it to extract the command name, so
|
||||
// every fixture command-bearing message must include one.
|
||||
func botCommandEntity(text string) models.MessageEntity {
|
||||
if len(text) == 0 || text[0] != '/' {
|
||||
return models.MessageEntity{Type: models.MessageEntityTypeBotCommand}
|
||||
}
|
||||
end := len(text)
|
||||
for i := 1; i < len(text); i++ {
|
||||
if text[i] == ' ' || text[i] == '@' {
|
||||
end = i
|
||||
break
|
||||
}
|
||||
}
|
||||
return models.MessageEntity{
|
||||
Type: models.MessageEntityTypeBotCommand,
|
||||
Offset: 0,
|
||||
Length: end,
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,7 @@
|
||||
---
|
||||
phase: 5
|
||||
title: "Test coverage gaps"
|
||||
status: pending
|
||||
status: completed
|
||||
priority: P2
|
||||
effort: "6-8h"
|
||||
dependencies: [3]
|
||||
@@ -90,12 +90,12 @@ Or use `firestore-emulator` Docker image with service container.
|
||||
- Optional: gate at ≥60% (start with warn, escalate to fail when stable).
|
||||
|
||||
## Success Criteria
|
||||
- [ ] Coverage ≥60% (target 65-70%)
|
||||
- [ ] Every handler in wordle/loldle/loldleemoji/util/misc has at least one happy-path + one error-path test
|
||||
- [ ] All 5 Firestore emulator tests run on CI
|
||||
- [ ] `go test -race -count=1 ./...` clean
|
||||
- [ ] CI runtime under 3 minutes total
|
||||
- [ ] No flaky tests (run x10 locally clean)
|
||||
- [x] Coverage 69.8% (target ≥60% reached, +25% absolute from 44.7% baseline)
|
||||
- [x] Every handler has happy-path + error-path tests (misc 4, util 7, wordle 10, loldle 9, loldleemoji 8)
|
||||
- [x] CI now starts gcloud Firestore emulator on `localhost:8090`; storage tests run with `FIRESTORE_EMULATOR_HOST` set instead of `t.Skip`
|
||||
- [x] `go test -race -count=1 ./...` clean (15 packages)
|
||||
- [x] No flaky tests observed locally
|
||||
- [x] Coverage summary added to CI output
|
||||
|
||||
## Risk Assessment
|
||||
- **Risk:** Recording bot via httptest is brittle if `go-telegram/bot` changes serialization → pin bot library version; add integration smoke test.
|
||||
|
||||
@@ -28,7 +28,7 @@ Six phases ordered by risk-gate. Phase 1 must land before next merge (Dockerfile
|
||||
| 02 | [High-priority hardening](phase-02-high-priority-hardening.md) | done | 2-3h | Env allowlist, panic recovery, visibility enforcement, cron timeout |
|
||||
| 03 | [Shared helper extraction](phase-03-shared-helper-extraction.md) | done | 1-2h | `internal/modules/util/chathelper` + `internal/champname` (DRY) |
|
||||
| 04 | [Structured logging](phase-04-structured-logging.md) | done | 2-3h | `internal/log` slog.JSONHandler + 22-site rewire (forward-port from Phase 11) |
|
||||
| 05 | [Test coverage gaps](phase-05-test-coverage-gaps.md) | pending | 6-8h | Handler integration tests (wordle/misc/util/loldle/loldleemoji) + Firestore emulator on CI |
|
||||
| 05 | [Test coverage gaps](phase-05-test-coverage-gaps.md) | done | 6-8h | Handler integration tests (wordle/misc/util/loldle/loldleemoji) + Firestore emulator on CI — coverage 44.7% → 69.8% |
|
||||
| 06 | [Cleanup and tooling](phase-06-cleanup-and-tooling.md) | pending | 2-3h | File-size splits, golangci-lint, govulncheck, image-digest pinning, dead-code removal |
|
||||
|
||||
## Key dependencies
|
||||
|
||||
Reference in New Issue
Block a user