mirror of https://github.com/tucnak/telebot
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
763 lines
20 KiB
Go
763 lines
20 KiB
Go
package telebot
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
var (
|
|
// required to test send and edit methods
|
|
token = os.Getenv("TELEBOT_SECRET")
|
|
chatID, _ = strconv.ParseInt(os.Getenv("CHAT_ID"), 10, 64)
|
|
userID, _ = strconv.ParseInt(os.Getenv("USER_ID"), 10, 64)
|
|
|
|
b, _ = newTestBot() // cached bot instance to avoid getMe method flooding
|
|
to = &Chat{ID: chatID} // to chat recipient for send and edit methods
|
|
user = &User{ID: userID} // to user recipient for some special cases
|
|
|
|
logo = FromURL("https://telegra.ph/file/c95b8fe46dd3df15d12e5.png")
|
|
thumb = FromURL("https://telegra.ph/file/fe28e378784b3a4e367fb.png")
|
|
)
|
|
|
|
func defaultSettings() Settings {
|
|
return Settings{Token: token}
|
|
}
|
|
|
|
func newTestBot() (*Bot, error) {
|
|
return NewBot(defaultSettings())
|
|
}
|
|
|
|
func TestNewBot(t *testing.T) {
|
|
var pref Settings
|
|
_, err := NewBot(pref)
|
|
assert.Error(t, err)
|
|
|
|
pref.Token = "BAD TOKEN"
|
|
_, err = NewBot(pref)
|
|
assert.Error(t, err)
|
|
|
|
pref.URL = "BAD URL"
|
|
_, err = NewBot(pref)
|
|
assert.Error(t, err)
|
|
|
|
b, err := NewBot(Settings{Offline: true})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
assert.NotNil(t, b.Me)
|
|
assert.Equal(t, DefaultApiURL, b.URL)
|
|
assert.Equal(t, 100, cap(b.Updates))
|
|
assert.NotZero(t, b.client.Timeout)
|
|
|
|
pref = defaultSettings()
|
|
client := &http.Client{Timeout: time.Minute}
|
|
pref.URL = "http://api.telegram.org" // not https
|
|
pref.Client = client
|
|
pref.Poller = &LongPoller{Timeout: time.Second}
|
|
pref.Updates = 50
|
|
pref.ParseMode = ModeHTML
|
|
pref.Offline = true
|
|
|
|
b, err = NewBot(pref)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, client, b.client)
|
|
assert.Equal(t, pref.URL, b.URL)
|
|
assert.Equal(t, pref.Poller, b.Poller)
|
|
assert.Equal(t, 50, cap(b.Updates))
|
|
assert.Equal(t, ModeHTML, b.parseMode)
|
|
}
|
|
|
|
func TestBotHandle(t *testing.T) {
|
|
if b == nil {
|
|
t.Skip("Cached bot instance is bad (probably wrong or empty TELEBOT_SECRET)")
|
|
}
|
|
|
|
b.Handle("/start", func(c Context) error { return nil })
|
|
assert.Contains(t, b.handlers, "/start")
|
|
|
|
reply := ReplyButton{Text: "reply"}
|
|
b.Handle(&reply, func(c Context) error { return nil })
|
|
|
|
inline := InlineButton{Unique: "inline"}
|
|
b.Handle(&inline, func(c Context) error { return nil })
|
|
|
|
btnReply := (&ReplyMarkup{}).Text("btnReply")
|
|
b.Handle(&btnReply, func(c Context) error { return nil })
|
|
|
|
btnInline := (&ReplyMarkup{}).Data("", "btnInline")
|
|
b.Handle(&btnInline, func(c Context) error { return nil })
|
|
|
|
assert.Contains(t, b.handlers, btnReply.CallbackUnique())
|
|
assert.Contains(t, b.handlers, btnInline.CallbackUnique())
|
|
assert.Contains(t, b.handlers, reply.CallbackUnique())
|
|
assert.Contains(t, b.handlers, inline.CallbackUnique())
|
|
}
|
|
|
|
func TestBotStart(t *testing.T) {
|
|
if token == "" {
|
|
t.Skip("TELEBOT_SECRET is required")
|
|
}
|
|
|
|
pref := defaultSettings()
|
|
pref.Poller = &LongPoller{}
|
|
|
|
b, err := NewBot(pref)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// remove webhook to be sure that bot can poll
|
|
require.NoError(t, b.RemoveWebhook())
|
|
|
|
go b.Start()
|
|
b.Stop()
|
|
|
|
tp := newTestPoller()
|
|
go func() {
|
|
tp.updates <- Update{Message: &Message{Text: "/start"}}
|
|
}()
|
|
|
|
b, err = NewBot(pref)
|
|
require.NoError(t, err)
|
|
b.Poller = tp
|
|
|
|
var ok bool
|
|
b.Handle("/start", func(c Context) error {
|
|
assert.Equal(t, c.Text(), "/start")
|
|
tp.done <- struct{}{}
|
|
ok = true
|
|
return nil
|
|
})
|
|
|
|
go b.Start()
|
|
<-tp.done
|
|
b.Stop()
|
|
|
|
assert.True(t, ok)
|
|
}
|
|
|
|
func TestBotProcessUpdate(t *testing.T) {
|
|
b, err := NewBot(Settings{Synchronous: true, Offline: true})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
b.Handle(OnMedia, func(c Context) error {
|
|
assert.NotNil(t, c.Message().Photo)
|
|
return nil
|
|
})
|
|
b.ProcessUpdate(Update{Message: &Message{Photo: &Photo{}}})
|
|
|
|
b.Handle("/start", func(c Context) error {
|
|
assert.Equal(t, "/start", c.Text())
|
|
return nil
|
|
})
|
|
b.Handle("hello", func(c Context) error {
|
|
assert.Equal(t, "hello", c.Text())
|
|
return nil
|
|
})
|
|
b.Handle(OnText, func(c Context) error {
|
|
assert.Equal(t, "text", c.Text())
|
|
return nil
|
|
})
|
|
b.Handle(OnPinned, func(c Context) error {
|
|
assert.NotNil(t, c.Message())
|
|
return nil
|
|
})
|
|
b.Handle(OnPhoto, func(c Context) error {
|
|
assert.NotNil(t, c.Message().Photo)
|
|
return nil
|
|
})
|
|
b.Handle(OnVoice, func(c Context) error {
|
|
assert.NotNil(t, c.Message().Voice)
|
|
return nil
|
|
})
|
|
b.Handle(OnAudio, func(c Context) error {
|
|
assert.NotNil(t, c.Message().Audio)
|
|
return nil
|
|
})
|
|
b.Handle(OnAnimation, func(c Context) error {
|
|
assert.NotNil(t, c.Message().Animation)
|
|
return nil
|
|
})
|
|
b.Handle(OnDocument, func(c Context) error {
|
|
assert.NotNil(t, c.Message().Document)
|
|
return nil
|
|
})
|
|
b.Handle(OnSticker, func(c Context) error {
|
|
assert.NotNil(t, c.Message().Sticker)
|
|
return nil
|
|
})
|
|
b.Handle(OnVideo, func(c Context) error {
|
|
assert.NotNil(t, c.Message().Video)
|
|
return nil
|
|
})
|
|
b.Handle(OnVideoNote, func(c Context) error {
|
|
assert.NotNil(t, c.Message().VideoNote)
|
|
return nil
|
|
})
|
|
b.Handle(OnContact, func(c Context) error {
|
|
assert.NotNil(t, c.Message().Contact)
|
|
return nil
|
|
})
|
|
b.Handle(OnLocation, func(c Context) error {
|
|
assert.NotNil(t, c.Message().Location)
|
|
return nil
|
|
})
|
|
b.Handle(OnVenue, func(c Context) error {
|
|
assert.NotNil(t, c.Message().Venue)
|
|
return nil
|
|
})
|
|
b.Handle(OnDice, func(c Context) error {
|
|
assert.NotNil(t, c.Message().Dice)
|
|
return nil
|
|
})
|
|
b.Handle(OnInvoice, func(c Context) error {
|
|
assert.NotNil(t, c.Message().Invoice)
|
|
return nil
|
|
})
|
|
b.Handle(OnPayment, func(c Context) error {
|
|
assert.NotNil(t, c.Message().Payment)
|
|
return nil
|
|
})
|
|
b.Handle(OnAddedToGroup, func(c Context) error {
|
|
assert.NotNil(t, c.Message().GroupCreated)
|
|
return nil
|
|
})
|
|
b.Handle(OnUserJoined, func(c Context) error {
|
|
assert.NotNil(t, c.Message().UserJoined)
|
|
return nil
|
|
})
|
|
b.Handle(OnUserLeft, func(c Context) error {
|
|
assert.NotNil(t, c.Message().UserLeft)
|
|
return nil
|
|
})
|
|
b.Handle(OnNewGroupTitle, func(c Context) error {
|
|
assert.Equal(t, "title", c.Message().NewGroupTitle)
|
|
return nil
|
|
})
|
|
b.Handle(OnNewGroupPhoto, func(c Context) error {
|
|
assert.NotNil(t, c.Message().NewGroupPhoto)
|
|
return nil
|
|
})
|
|
b.Handle(OnGroupPhotoDeleted, func(c Context) error {
|
|
assert.True(t, c.Message().GroupPhotoDeleted)
|
|
return nil
|
|
})
|
|
b.Handle(OnMigration, func(c Context) error {
|
|
from, to := c.Migration()
|
|
assert.Equal(t, int64(1), from)
|
|
assert.Equal(t, int64(2), to)
|
|
return nil
|
|
})
|
|
b.Handle(OnEdited, func(c Context) error {
|
|
assert.Equal(t, "edited", c.Message().Text)
|
|
return nil
|
|
})
|
|
b.Handle(OnChannelPost, func(c Context) error {
|
|
assert.Equal(t, "post", c.Message().Text)
|
|
return nil
|
|
})
|
|
b.Handle(OnEditedChannelPost, func(c Context) error {
|
|
assert.Equal(t, "edited post", c.Message().Text)
|
|
return nil
|
|
})
|
|
b.Handle(OnCallback, func(c Context) error {
|
|
if data := c.Callback().Data; data[0] != '\f' {
|
|
assert.Equal(t, "callback", data)
|
|
}
|
|
return nil
|
|
})
|
|
b.Handle("\funique", func(c Context) error {
|
|
assert.Equal(t, "callback", c.Callback().Data)
|
|
return nil
|
|
})
|
|
b.Handle(OnQuery, func(c Context) error {
|
|
assert.Equal(t, "query", c.Data())
|
|
return nil
|
|
})
|
|
b.Handle(OnInlineResult, func(c Context) error {
|
|
assert.Equal(t, "result", c.InlineResult().ResultID)
|
|
return nil
|
|
})
|
|
b.Handle(OnShipping, func(c Context) error {
|
|
assert.Equal(t, "shipping", c.ShippingQuery().ID)
|
|
return nil
|
|
})
|
|
b.Handle(OnCheckout, func(c Context) error {
|
|
assert.Equal(t, "checkout", c.PreCheckoutQuery().ID)
|
|
return nil
|
|
})
|
|
b.Handle(OnPoll, func(c Context) error {
|
|
assert.Equal(t, "poll", c.Poll().ID)
|
|
return nil
|
|
})
|
|
b.Handle(OnPollAnswer, func(c Context) error {
|
|
assert.Equal(t, "poll", c.PollAnswer().PollID)
|
|
return nil
|
|
})
|
|
|
|
b.Handle(OnWebApp, func(c Context) error {
|
|
assert.Equal(t, "webapp", c.Message().WebAppData.Data)
|
|
return nil
|
|
})
|
|
|
|
b.ProcessUpdate(Update{Message: &Message{Text: "/start"}})
|
|
b.ProcessUpdate(Update{Message: &Message{Text: "/start@other_bot"}})
|
|
b.ProcessUpdate(Update{Message: &Message{Text: "hello"}})
|
|
b.ProcessUpdate(Update{Message: &Message{Text: "text"}})
|
|
b.ProcessUpdate(Update{Message: &Message{PinnedMessage: &Message{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{Photo: &Photo{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{Voice: &Voice{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{Audio: &Audio{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{Animation: &Animation{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{Document: &Document{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{Sticker: &Sticker{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{Video: &Video{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{VideoNote: &VideoNote{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{Contact: &Contact{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{Location: &Location{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{Venue: &Venue{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{Invoice: &Invoice{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{Payment: &Payment{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{Dice: &Dice{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{GroupCreated: true}})
|
|
b.ProcessUpdate(Update{Message: &Message{UserJoined: &User{ID: 1}}})
|
|
b.ProcessUpdate(Update{Message: &Message{UsersJoined: []User{{ID: 1}}}})
|
|
b.ProcessUpdate(Update{Message: &Message{UserLeft: &User{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{NewGroupTitle: "title"}})
|
|
b.ProcessUpdate(Update{Message: &Message{NewGroupPhoto: &Photo{}}})
|
|
b.ProcessUpdate(Update{Message: &Message{GroupPhotoDeleted: true}})
|
|
b.ProcessUpdate(Update{Message: &Message{Chat: &Chat{ID: 1}, MigrateTo: 2}})
|
|
b.ProcessUpdate(Update{EditedMessage: &Message{Text: "edited"}})
|
|
b.ProcessUpdate(Update{ChannelPost: &Message{Text: "post"}})
|
|
b.ProcessUpdate(Update{ChannelPost: &Message{PinnedMessage: &Message{}}})
|
|
b.ProcessUpdate(Update{EditedChannelPost: &Message{Text: "edited post"}})
|
|
b.ProcessUpdate(Update{Callback: &Callback{MessageID: "inline", Data: "callback"}})
|
|
b.ProcessUpdate(Update{Callback: &Callback{Data: "callback"}})
|
|
b.ProcessUpdate(Update{Callback: &Callback{Data: "\funique|callback"}})
|
|
b.ProcessUpdate(Update{Query: &Query{Text: "query"}})
|
|
b.ProcessUpdate(Update{InlineResult: &InlineResult{ResultID: "result"}})
|
|
b.ProcessUpdate(Update{ShippingQuery: &ShippingQuery{ID: "shipping"}})
|
|
b.ProcessUpdate(Update{PreCheckoutQuery: &PreCheckoutQuery{ID: "checkout"}})
|
|
b.ProcessUpdate(Update{Poll: &Poll{ID: "poll"}})
|
|
b.ProcessUpdate(Update{PollAnswer: &PollAnswer{PollID: "poll"}})
|
|
b.ProcessUpdate(Update{Message: &Message{WebAppData: &WebAppData{Data: "webapp"}}})
|
|
}
|
|
|
|
func TestBotOnError(t *testing.T) {
|
|
b, err := NewBot(Settings{Synchronous: true, Offline: true})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
var ok bool
|
|
b.onError = func(err error, c Context) {
|
|
assert.Equal(t, b, c.(*nativeContext).b)
|
|
assert.NotNil(t, err)
|
|
ok = true
|
|
}
|
|
|
|
b.runHandler(func(c Context) error {
|
|
return errors.New("not nil")
|
|
}, &nativeContext{b: b})
|
|
|
|
assert.True(t, ok)
|
|
}
|
|
|
|
func TestBotMiddleware(t *testing.T) {
|
|
t.Run("calling order", func(t *testing.T) {
|
|
var trace []string
|
|
|
|
handler := func(name string) HandlerFunc {
|
|
return func(c Context) error {
|
|
trace = append(trace, name)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
middleware := func(name string) MiddlewareFunc {
|
|
return func(next HandlerFunc) HandlerFunc {
|
|
return func(c Context) error {
|
|
trace = append(trace, name+":in")
|
|
err := next(c)
|
|
trace = append(trace, name+":out")
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
b, err := NewBot(Settings{Synchronous: true, Offline: true})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
b.Use(middleware("global1"), middleware("global2"))
|
|
b.Handle("/a", handler("/a"), middleware("handler1a"), middleware("handler2a"))
|
|
|
|
group := b.Group()
|
|
group.Use(middleware("group1"), middleware("group2"))
|
|
group.Handle("/b", handler("/b"), middleware("handler1b"))
|
|
|
|
b.ProcessUpdate(Update{
|
|
Message: &Message{Text: "/a"},
|
|
})
|
|
assert.Equal(t, []string{
|
|
"global1:in", "global2:in",
|
|
"handler1a:in", "handler2a:in",
|
|
"/a",
|
|
"handler2a:out", "handler1a:out",
|
|
"global2:out", "global1:out",
|
|
}, trace)
|
|
|
|
trace = trace[:0]
|
|
|
|
b.ProcessUpdate(Update{
|
|
Message: &Message{Text: "/b"},
|
|
})
|
|
assert.Equal(t, []string{
|
|
"global1:in", "global2:in",
|
|
"group1:in", "group2:in",
|
|
"handler1b:in",
|
|
"/b",
|
|
"handler1b:out",
|
|
"group2:out", "group1:out",
|
|
"global2:out", "global1:out",
|
|
}, trace)
|
|
})
|
|
|
|
fatal := func(next HandlerFunc) HandlerFunc {
|
|
return func(c Context) error {
|
|
t.Fatal("fatal middleware should not be called")
|
|
return nil
|
|
}
|
|
}
|
|
|
|
nop := func(next HandlerFunc) HandlerFunc {
|
|
return func(c Context) error {
|
|
return next(c)
|
|
}
|
|
}
|
|
|
|
t.Run("combining with global middleware", func(t *testing.T) {
|
|
b, err := NewBot(Settings{Synchronous: true, Offline: true})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Pre-allocate middleware slice to make sure
|
|
// it has extra capacity after group-level middleware is added.
|
|
b.group.middleware = make([]MiddlewareFunc, 0, 2)
|
|
b.Use(nop)
|
|
|
|
b.Handle("/a", func(c Context) error { return nil }, nop)
|
|
b.Handle("/b", func(c Context) error { return nil }, fatal)
|
|
|
|
b.ProcessUpdate(Update{Message: &Message{Text: "/a"}})
|
|
})
|
|
|
|
t.Run("combining with group middleware", func(t *testing.T) {
|
|
b, err := NewBot(Settings{Synchronous: true, Offline: true})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
g := b.Group()
|
|
// Pre-allocate middleware slice to make sure
|
|
// it has extra capacity after group-level middleware is added.
|
|
g.middleware = make([]MiddlewareFunc, 0, 2)
|
|
g.Use(nop)
|
|
|
|
g.Handle("/a", func(c Context) error { return nil }, nop)
|
|
g.Handle("/b", func(c Context) error { return nil }, fatal)
|
|
|
|
b.ProcessUpdate(Update{Message: &Message{Text: "/a"}})
|
|
})
|
|
}
|
|
|
|
func TestBot(t *testing.T) {
|
|
if b == nil {
|
|
t.Skip("Cached bot instance is bad (probably wrong or empty TELEBOT_SECRET)")
|
|
}
|
|
if chatID == 0 {
|
|
t.Skip("CHAT_ID is required for Bot methods test")
|
|
}
|
|
|
|
_, err := b.Send(to, nil)
|
|
assert.Equal(t, ErrUnsupportedWhat, err)
|
|
_, err = b.Edit(&Message{Chat: &Chat{}}, nil)
|
|
assert.Equal(t, ErrUnsupportedWhat, err)
|
|
|
|
_, err = b.Send(nil, "")
|
|
assert.Equal(t, ErrBadRecipient, err)
|
|
_, err = b.Forward(nil, nil)
|
|
assert.Equal(t, ErrBadRecipient, err)
|
|
|
|
photo := &Photo{
|
|
File: logo,
|
|
Caption: t.Name(),
|
|
}
|
|
var msg *Message
|
|
|
|
t.Run("Send(what=Sendable)", func(t *testing.T) {
|
|
msg, err = b.Send(to, photo)
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, msg.Photo)
|
|
assert.Equal(t, photo.Caption, msg.Caption)
|
|
})
|
|
|
|
t.Run("SendAlbum()", func(t *testing.T) {
|
|
_, err = b.SendAlbum(nil, nil)
|
|
assert.Equal(t, ErrBadRecipient, err)
|
|
|
|
_, err = b.SendAlbum(to, nil)
|
|
assert.Error(t, err)
|
|
|
|
photo2 := *photo
|
|
photo2.Caption = ""
|
|
|
|
msgs, err := b.SendAlbum(to, Album{photo, &photo2}, ModeHTML)
|
|
require.NoError(t, err)
|
|
assert.Len(t, msgs, 2)
|
|
assert.NotEmpty(t, msgs[0].AlbumID)
|
|
})
|
|
|
|
t.Run("EditCaption()+ParseMode", func(t *testing.T) {
|
|
b.parseMode = ModeHTML
|
|
|
|
edited, err := b.EditCaption(msg, "<b>new caption with html</b>")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "new caption with html", edited.Caption)
|
|
assert.Equal(t, EntityBold, edited.CaptionEntities[0].Type)
|
|
|
|
sleep()
|
|
|
|
edited, err = b.EditCaption(msg, "*new caption with markdown*", ModeMarkdown)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "new caption with markdown", edited.Caption)
|
|
assert.Equal(t, EntityBold, edited.CaptionEntities[0].Type)
|
|
|
|
sleep()
|
|
|
|
edited, err = b.EditCaption(msg, "_new caption with markdown \\(V2\\)_", ModeMarkdownV2)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "new caption with markdown (V2)", edited.Caption)
|
|
assert.Equal(t, EntityItalic, edited.CaptionEntities[0].Type)
|
|
|
|
b.parseMode = ModeDefault
|
|
})
|
|
|
|
t.Run("Edit(what=Media)", func(t *testing.T) {
|
|
edited, err := b.Edit(msg, photo)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, edited.Photo.UniqueID, photo.UniqueID)
|
|
|
|
resp, err := http.Get("https://telegra.ph/file/274e5eb26f348b10bd8ee.mp4")
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
file, err := ioutil.TempFile("", "")
|
|
require.NoError(t, err)
|
|
|
|
_, err = io.Copy(file, resp.Body)
|
|
require.NoError(t, err)
|
|
|
|
animation := &Animation{
|
|
File: FromDisk(file.Name()),
|
|
Caption: t.Name(),
|
|
FileName: "animation.gif",
|
|
}
|
|
|
|
msg, err := b.Send(msg.Chat, animation)
|
|
require.NoError(t, err)
|
|
|
|
if msg.Animation != nil {
|
|
assert.Equal(t, msg.Animation.FileID, animation.FileID)
|
|
} else {
|
|
assert.Equal(t, msg.Document.FileID, animation.FileID)
|
|
}
|
|
|
|
_, err = b.Edit(edited, animation)
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("Edit(what=Animation)", func(t *testing.T) {})
|
|
|
|
t.Run("Send(what=string)", func(t *testing.T) {
|
|
msg, err = b.Send(to, t.Name())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, t.Name(), msg.Text)
|
|
|
|
rpl, err := b.Reply(msg, t.Name())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, rpl.Text, msg.Text)
|
|
assert.NotNil(t, rpl.ReplyTo)
|
|
assert.Equal(t, rpl.ReplyTo, msg)
|
|
assert.True(t, rpl.IsReply())
|
|
|
|
fwd, err := b.Forward(to, msg)
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, msg, fwd)
|
|
assert.True(t, fwd.IsForwarded())
|
|
|
|
fwd.ID += 1 // nonexistent message
|
|
_, err = b.Forward(to, fwd)
|
|
assert.Equal(t, ErrNotFoundToForward, err)
|
|
})
|
|
|
|
t.Run("Edit(what=string)", func(t *testing.T) {
|
|
msg, err = b.Edit(msg, t.Name())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, t.Name(), msg.Text)
|
|
|
|
_, err = b.Edit(msg, msg.Text)
|
|
assert.Error(t, err) // message is not modified
|
|
})
|
|
|
|
t.Run("Edit(what=ReplyMarkup)", func(t *testing.T) {
|
|
good := &ReplyMarkup{
|
|
InlineKeyboard: [][]InlineButton{
|
|
{{
|
|
Data: "btn",
|
|
Text: "Hi Telebot!",
|
|
}},
|
|
},
|
|
}
|
|
bad := &ReplyMarkup{
|
|
InlineKeyboard: [][]InlineButton{
|
|
{{
|
|
Data: strings.Repeat("*", 65),
|
|
Text: "Bad Button",
|
|
}},
|
|
},
|
|
}
|
|
|
|
edited, err := b.Edit(msg, good)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, edited.ReplyMarkup.InlineKeyboard, good.InlineKeyboard)
|
|
|
|
edited, err = b.EditReplyMarkup(edited, nil)
|
|
require.NoError(t, err)
|
|
assert.Nil(t, edited.ReplyMarkup)
|
|
|
|
_, err = b.Edit(edited, bad)
|
|
assert.Equal(t, ErrBadButtonData, err)
|
|
})
|
|
|
|
t.Run("Edit(what=Location)", func(t *testing.T) {
|
|
loc := &Location{Lat: 42, Lng: 69, LivePeriod: 60}
|
|
edited, err := b.Send(to, loc)
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, edited.Location)
|
|
|
|
loc = &Location{Lat: loc.Lng, Lng: loc.Lat}
|
|
edited, err = b.Edit(edited, *loc)
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, edited.Location)
|
|
})
|
|
|
|
// Should be after the Edit tests.
|
|
t.Run("Delete()", func(t *testing.T) {
|
|
require.NoError(t, b.Delete(msg))
|
|
})
|
|
|
|
t.Run("Notify()", func(t *testing.T) {
|
|
assert.Equal(t, ErrBadRecipient, b.Notify(nil, Typing))
|
|
require.NoError(t, b.Notify(to, Typing))
|
|
})
|
|
|
|
t.Run("Answer()", func(t *testing.T) {
|
|
assert.Error(t, b.Answer(&Query{}, &QueryResponse{
|
|
Results: Results{&ArticleResult{}},
|
|
}))
|
|
})
|
|
|
|
t.Run("Respond()", func(t *testing.T) {
|
|
assert.Error(t, b.Respond(&Callback{}, &CallbackResponse{}))
|
|
})
|
|
|
|
t.Run("Payments", func(t *testing.T) {
|
|
assert.NotPanics(t, func() {
|
|
b.Accept(&PreCheckoutQuery{})
|
|
b.Accept(&PreCheckoutQuery{}, "error")
|
|
})
|
|
assert.NotPanics(t, func() {
|
|
b.Ship(&ShippingQuery{})
|
|
b.Ship(&ShippingQuery{}, "error")
|
|
b.Ship(&ShippingQuery{}, ShippingOption{}, ShippingOption{})
|
|
assert.Equal(t, ErrUnsupportedWhat, b.Ship(&ShippingQuery{}, 0))
|
|
})
|
|
})
|
|
|
|
t.Run("Commands", func(t *testing.T) {
|
|
var (
|
|
set1 = []Command{{
|
|
Text: "test1",
|
|
Description: "test command 1",
|
|
}}
|
|
set2 = []Command{{
|
|
Text: "test2",
|
|
Description: "test command 2",
|
|
}}
|
|
scope = CommandScope{
|
|
Type: CommandScopeChat,
|
|
ChatID: chatID,
|
|
}
|
|
)
|
|
|
|
err := b.SetCommands(set1)
|
|
require.NoError(t, err)
|
|
|
|
cmds, err := b.Commands()
|
|
require.NoError(t, err)
|
|
assert.Equal(t, set1, cmds)
|
|
|
|
err = b.SetCommands(set2, "en", scope)
|
|
require.NoError(t, err)
|
|
|
|
cmds, err = b.Commands()
|
|
require.NoError(t, err)
|
|
assert.Equal(t, set1, cmds)
|
|
|
|
cmds, err = b.Commands("en", scope)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, set2, cmds)
|
|
|
|
require.NoError(t, b.DeleteCommands("en", scope))
|
|
require.NoError(t, b.DeleteCommands())
|
|
})
|
|
|
|
t.Run("InviteLink", func(t *testing.T) {
|
|
inviteLink, err := b.CreateInviteLink(&Chat{ID: chatID}, nil)
|
|
require.NoError(t, err)
|
|
assert.True(t, len(inviteLink.InviteLink) > 0)
|
|
|
|
sleep()
|
|
|
|
response, err := b.EditInviteLink(&Chat{ID: chatID}, &ChatInviteLink{InviteLink: inviteLink.InviteLink})
|
|
require.NoError(t, err)
|
|
assert.True(t, len(response.InviteLink) > 0)
|
|
|
|
sleep()
|
|
|
|
response, err = b.RevokeInviteLink(&Chat{ID: chatID}, inviteLink.InviteLink)
|
|
require.Nil(t, err)
|
|
assert.True(t, len(response.InviteLink) > 0)
|
|
})
|
|
}
|
|
|
|
func sleep() {
|
|
time.Sleep(time.Second)
|
|
}
|