1package tgbotapi_test
  2
  3import (
  4	"io/ioutil"
  5	"log"
  6	"net/http"
  7	"os"
  8	"testing"
  9	"time"
 10
 11	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api"
 12)
 13
 14const (
 15	TestToken               = "153667468:AAHlSHlMqSt1f_uFmVRJbm5gntu2HI4WW8I"
 16	ChatID                  = 76918703
 17	SupergroupChatID        = -1001120141283
 18	ReplyToMessageID        = 35
 19	ExistingPhotoFileID     = "AgADAgADw6cxG4zHKAkr42N7RwEN3IFShCoABHQwXEtVks4EH2wBAAEC"
 20	ExistingDocumentFileID  = "BQADAgADOQADjMcoCcioX1GrDvp3Ag"
 21	ExistingAudioFileID     = "BQADAgADRgADjMcoCdXg3lSIN49lAg"
 22	ExistingVoiceFileID     = "AwADAgADWQADjMcoCeul6r_q52IyAg"
 23	ExistingVideoFileID     = "BAADAgADZgADjMcoCav432kYe0FRAg"
 24	ExistingVideoNoteFileID = "DQADAgADdQAD70cQSUK41dLsRMqfAg"
 25	ExistingStickerFileID   = "BQADAgADcwADjMcoCbdl-6eB--YPAg"
 26)
 27
 28func getBot(t *testing.T) (*tgbotapi.BotAPI, error) {
 29	bot, err := tgbotapi.NewBotAPI(TestToken)
 30	bot.Debug = true
 31
 32	if err != nil {
 33		t.Error(err)
 34		t.Fail()
 35	}
 36
 37	return bot, err
 38}
 39
 40func TestNewBotAPI_notoken(t *testing.T) {
 41	_, err := tgbotapi.NewBotAPI("")
 42
 43	if err == nil {
 44		t.Error(err)
 45		t.Fail()
 46	}
 47}
 48
 49func TestGetUpdates(t *testing.T) {
 50	bot, _ := getBot(t)
 51
 52	u := tgbotapi.NewUpdate(0)
 53
 54	_, err := bot.GetUpdates(u)
 55
 56	if err != nil {
 57		t.Error(err)
 58		t.Fail()
 59	}
 60}
 61
 62func TestSendWithMessage(t *testing.T) {
 63	bot, _ := getBot(t)
 64
 65	msg := tgbotapi.NewMessage(ChatID, "A test message from the test library in telegram-bot-api")
 66	msg.ParseMode = "markdown"
 67	_, err := bot.Send(msg)
 68
 69	if err != nil {
 70		t.Error(err)
 71		t.Fail()
 72	}
 73}
 74
 75func TestSendWithMessageReply(t *testing.T) {
 76	bot, _ := getBot(t)
 77
 78	msg := tgbotapi.NewMessage(ChatID, "A test message from the test library in telegram-bot-api")
 79	msg.ReplyToMessageID = ReplyToMessageID
 80	_, err := bot.Send(msg)
 81
 82	if err != nil {
 83		t.Error(err)
 84		t.Fail()
 85	}
 86}
 87
 88func TestSendWithMessageForward(t *testing.T) {
 89	bot, _ := getBot(t)
 90
 91	msg := tgbotapi.NewForward(ChatID, ChatID, ReplyToMessageID)
 92	_, err := bot.Send(msg)
 93
 94	if err != nil {
 95		t.Error(err)
 96		t.Fail()
 97	}
 98}
 99
100func TestSendWithNewPhoto(t *testing.T) {
101	bot, _ := getBot(t)
102
103	msg := tgbotapi.NewPhotoUpload(ChatID, "tests/image.jpg")
104	msg.Caption = "Test"
105	_, err := bot.Send(msg)
106
107	if err != nil {
108		t.Error(err)
109		t.Fail()
110	}
111}
112
113func TestSendWithNewPhotoWithFileBytes(t *testing.T) {
114	bot, _ := getBot(t)
115
116	data, _ := ioutil.ReadFile("tests/image.jpg")
117	b := tgbotapi.FileBytes{Name: "image.jpg", Bytes: data}
118
119	msg := tgbotapi.NewPhotoUpload(ChatID, b)
120	msg.Caption = "Test"
121	_, err := bot.Send(msg)
122
123	if err != nil {
124		t.Error(err)
125		t.Fail()
126	}
127}
128
129func TestSendWithNewPhotoWithFileReader(t *testing.T) {
130	bot, _ := getBot(t)
131
132	f, _ := os.Open("tests/image.jpg")
133	reader := tgbotapi.FileReader{Name: "image.jpg", Reader: f, Size: -1}
134
135	msg := tgbotapi.NewPhotoUpload(ChatID, reader)
136	msg.Caption = "Test"
137	_, err := bot.Send(msg)
138
139	if err != nil {
140		t.Error(err)
141		t.Fail()
142	}
143}
144
145func TestSendWithNewPhotoReply(t *testing.T) {
146	bot, _ := getBot(t)
147
148	msg := tgbotapi.NewPhotoUpload(ChatID, "tests/image.jpg")
149	msg.ReplyToMessageID = ReplyToMessageID
150
151	_, err := bot.Send(msg)
152
153	if err != nil {
154		t.Error(err)
155		t.Fail()
156	}
157}
158
159func TestSendWithExistingPhoto(t *testing.T) {
160	bot, _ := getBot(t)
161
162	msg := tgbotapi.NewPhotoShare(ChatID, ExistingPhotoFileID)
163	msg.Caption = "Test"
164	_, err := bot.Send(msg)
165
166	if err != nil {
167		t.Error(err)
168		t.Fail()
169	}
170}
171
172func TestSendWithNewDocument(t *testing.T) {
173	bot, _ := getBot(t)
174
175	msg := tgbotapi.NewDocumentUpload(ChatID, "tests/image.jpg")
176	_, err := bot.Send(msg)
177
178	if err != nil {
179		t.Error(err)
180		t.Fail()
181	}
182}
183
184func TestSendWithExistingDocument(t *testing.T) {
185	bot, _ := getBot(t)
186
187	msg := tgbotapi.NewDocumentShare(ChatID, ExistingDocumentFileID)
188	_, err := bot.Send(msg)
189
190	if err != nil {
191		t.Error(err)
192		t.Fail()
193	}
194}
195
196func TestSendWithNewAudio(t *testing.T) {
197	bot, _ := getBot(t)
198
199	msg := tgbotapi.NewAudioUpload(ChatID, "tests/audio.mp3")
200	msg.Title = "TEST"
201	msg.Duration = 10
202	msg.Performer = "TEST"
203	msg.MimeType = "audio/mpeg"
204	msg.FileSize = 688
205	_, err := bot.Send(msg)
206
207	if err != nil {
208		t.Error(err)
209		t.Fail()
210	}
211}
212
213func TestSendWithExistingAudio(t *testing.T) {
214	bot, _ := getBot(t)
215
216	msg := tgbotapi.NewAudioShare(ChatID, ExistingAudioFileID)
217	msg.Title = "TEST"
218	msg.Duration = 10
219	msg.Performer = "TEST"
220
221	_, err := bot.Send(msg)
222
223	if err != nil {
224		t.Error(err)
225		t.Fail()
226	}
227}
228
229func TestSendWithNewVoice(t *testing.T) {
230	bot, _ := getBot(t)
231
232	msg := tgbotapi.NewVoiceUpload(ChatID, "tests/voice.ogg")
233	msg.Duration = 10
234	_, err := bot.Send(msg)
235
236	if err != nil {
237		t.Error(err)
238		t.Fail()
239	}
240}
241
242func TestSendWithExistingVoice(t *testing.T) {
243	bot, _ := getBot(t)
244
245	msg := tgbotapi.NewVoiceShare(ChatID, ExistingVoiceFileID)
246	msg.Duration = 10
247	_, err := bot.Send(msg)
248
249	if err != nil {
250		t.Error(err)
251		t.Fail()
252	}
253}
254
255func TestSendWithContact(t *testing.T) {
256	bot, _ := getBot(t)
257
258	contact := tgbotapi.NewContact(ChatID, "5551234567", "Test")
259
260	if _, err := bot.Send(contact); err != nil {
261		t.Error(err)
262		t.Fail()
263	}
264}
265
266func TestSendWithLocation(t *testing.T) {
267	bot, _ := getBot(t)
268
269	_, err := bot.Send(tgbotapi.NewLocation(ChatID, 40, 40))
270
271	if err != nil {
272		t.Error(err)
273		t.Fail()
274	}
275}
276
277func TestSendWithVenue(t *testing.T) {
278	bot, _ := getBot(t)
279
280	venue := tgbotapi.NewVenue(ChatID, "A Test Location", "123 Test Street", 40, 40)
281
282	if _, err := bot.Send(venue); err != nil {
283		t.Error(err)
284		t.Fail()
285	}
286}
287
288func TestSendWithNewVideo(t *testing.T) {
289	bot, _ := getBot(t)
290
291	msg := tgbotapi.NewVideoUpload(ChatID, "tests/video.mp4")
292	msg.Duration = 10
293	msg.Caption = "TEST"
294
295	_, err := bot.Send(msg)
296
297	if err != nil {
298		t.Error(err)
299		t.Fail()
300	}
301}
302
303func TestSendWithExistingVideo(t *testing.T) {
304	bot, _ := getBot(t)
305
306	msg := tgbotapi.NewVideoShare(ChatID, ExistingVideoFileID)
307	msg.Duration = 10
308	msg.Caption = "TEST"
309
310	_, err := bot.Send(msg)
311
312	if err != nil {
313		t.Error(err)
314		t.Fail()
315	}
316}
317
318func TestSendWithNewVideoNote(t *testing.T) {
319	bot, _ := getBot(t)
320
321	msg := tgbotapi.NewVideoNoteUpload(ChatID, 240, "tests/videonote.mp4")
322	msg.Duration = 10
323
324	_, err := bot.Send(msg)
325
326	if err != nil {
327		t.Error(err)
328		t.Fail()
329	}
330}
331
332func TestSendWithExistingVideoNote(t *testing.T) {
333	bot, _ := getBot(t)
334
335	msg := tgbotapi.NewVideoNoteShare(ChatID, 240, ExistingVideoNoteFileID)
336	msg.Duration = 10
337
338	_, err := bot.Send(msg)
339
340	if err != nil {
341		t.Error(err)
342		t.Fail()
343	}
344}
345
346func TestSendWithNewSticker(t *testing.T) {
347	bot, _ := getBot(t)
348
349	msg := tgbotapi.NewStickerUpload(ChatID, "tests/image.jpg")
350
351	_, err := bot.Send(msg)
352
353	if err != nil {
354		t.Error(err)
355		t.Fail()
356	}
357}
358
359func TestSendWithExistingSticker(t *testing.T) {
360	bot, _ := getBot(t)
361
362	msg := tgbotapi.NewStickerShare(ChatID, ExistingStickerFileID)
363
364	_, err := bot.Send(msg)
365
366	if err != nil {
367		t.Error(err)
368		t.Fail()
369	}
370}
371
372func TestSendWithNewStickerAndKeyboardHide(t *testing.T) {
373	bot, _ := getBot(t)
374
375	msg := tgbotapi.NewStickerUpload(ChatID, "tests/image.jpg")
376	msg.ReplyMarkup = tgbotapi.ReplyKeyboardRemove{
377		RemoveKeyboard: true,
378		Selective:      false,
379	}
380	_, err := bot.Send(msg)
381
382	if err != nil {
383		t.Error(err)
384		t.Fail()
385	}
386}
387
388func TestSendWithExistingStickerAndKeyboardHide(t *testing.T) {
389	bot, _ := getBot(t)
390
391	msg := tgbotapi.NewStickerShare(ChatID, ExistingStickerFileID)
392	msg.ReplyMarkup = tgbotapi.ReplyKeyboardRemove{
393		RemoveKeyboard: true,
394		Selective:      false,
395	}
396
397	_, err := bot.Send(msg)
398
399	if err != nil {
400		t.Error(err)
401		t.Fail()
402	}
403}
404
405func TestSendWithDice(t *testing.T) {
406	bot, _ := getBot(t)
407
408	msg := tgbotapi.NewDice(ChatID)
409	_, err := bot.Send(msg)
410
411	if err != nil {
412		t.Error(err)
413		t.Fail()
414	}
415
416}
417
418func TestSendWithDiceWithEmoji(t *testing.T) {
419	bot, _ := getBot(t)
420
421	msg := tgbotapi.NewDiceWithEmoji(ChatID, "🏀")
422	_, err := bot.Send(msg)
423
424	if err != nil {
425		t.Error(err)
426		t.Fail()
427	}
428
429}
430
431func TestGetFile(t *testing.T) {
432	bot, _ := getBot(t)
433
434	file := tgbotapi.FileConfig{FileID: ExistingPhotoFileID}
435
436	_, err := bot.GetFile(file)
437
438	if err != nil {
439		t.Error(err)
440		t.Fail()
441	}
442}
443
444func TestSendChatConfig(t *testing.T) {
445	bot, _ := getBot(t)
446
447	_, err := bot.Send(tgbotapi.NewChatAction(ChatID, tgbotapi.ChatTyping))
448
449	if err != nil {
450		t.Error(err)
451		t.Fail()
452	}
453}
454
455func TestSendEditMessage(t *testing.T) {
456	bot, _ := getBot(t)
457
458	msg, err := bot.Send(tgbotapi.NewMessage(ChatID, "Testing editing."))
459	if err != nil {
460		t.Error(err)
461		t.Fail()
462	}
463
464	edit := tgbotapi.EditMessageTextConfig{
465		BaseEdit: tgbotapi.BaseEdit{
466			ChatID:    ChatID,
467			MessageID: msg.MessageID,
468		},
469		Text: "Updated text.",
470	}
471
472	_, err = bot.Send(edit)
473	if err != nil {
474		t.Error(err)
475		t.Fail()
476	}
477}
478
479func TestGetUserProfilePhotos(t *testing.T) {
480	bot, _ := getBot(t)
481
482	_, err := bot.GetUserProfilePhotos(tgbotapi.NewUserProfilePhotos(ChatID))
483	if err != nil {
484		t.Error(err)
485		t.Fail()
486	}
487}
488
489func TestSetWebhookWithCert(t *testing.T) {
490	bot, _ := getBot(t)
491
492	time.Sleep(time.Second * 2)
493
494	bot.RemoveWebhook()
495
496	wh := tgbotapi.NewWebhookWithCert("https://example.com/tgbotapi-test/"+bot.Token, "tests/cert.pem")
497	_, err := bot.SetWebhook(wh)
498	if err != nil {
499		t.Error(err)
500		t.Fail()
501	}
502	_, err = bot.GetWebhookInfo()
503	if err != nil {
504		t.Error(err)
505	}
506	bot.RemoveWebhook()
507}
508
509func TestSetWebhookWithoutCert(t *testing.T) {
510	bot, _ := getBot(t)
511
512	time.Sleep(time.Second * 2)
513
514	bot.RemoveWebhook()
515
516	wh := tgbotapi.NewWebhook("https://example.com/tgbotapi-test/" + bot.Token)
517	_, err := bot.SetWebhook(wh)
518	if err != nil {
519		t.Error(err)
520		t.Fail()
521	}
522	info, err := bot.GetWebhookInfo()
523	if err != nil {
524		t.Error(err)
525	}
526	if info.MaxConnections == 0 {
527		t.Errorf("Expected maximum connections to be greater than 0")
528	}
529	if info.LastErrorDate != 0 {
530		t.Errorf("[Telegram callback failed]%s", info.LastErrorMessage)
531	}
532	bot.RemoveWebhook()
533}
534
535func TestUpdatesChan(t *testing.T) {
536	bot, _ := getBot(t)
537
538	var ucfg tgbotapi.UpdateConfig = tgbotapi.NewUpdate(0)
539	ucfg.Timeout = 60
540	_, err := bot.GetUpdatesChan(ucfg)
541
542	if err != nil {
543		t.Error(err)
544		t.Fail()
545	}
546}
547
548func TestSendWithMediaGroup(t *testing.T) {
549	bot, _ := getBot(t)
550
551	cfg := tgbotapi.NewMediaGroup(ChatID, []interface{}{
552		tgbotapi.NewInputMediaPhoto("https://github.com/go-telegram-bot-api/telegram-bot-api/raw/0a3a1c8716c4cd8d26a262af9f12dcbab7f3f28c/tests/image.jpg"),
553		tgbotapi.NewInputMediaVideo("https://github.com/go-telegram-bot-api/telegram-bot-api/raw/0a3a1c8716c4cd8d26a262af9f12dcbab7f3f28c/tests/video.mp4"),
554	})
555	_, err := bot.Send(cfg)
556	if err != nil {
557		t.Error(err)
558	}
559}
560
561func ExampleNewBotAPI() {
562	bot, err := tgbotapi.NewBotAPI("MyAwesomeBotToken")
563	if err != nil {
564		log.Panic(err)
565	}
566
567	bot.Debug = true
568
569	log.Printf("Authorized on account %s", bot.Self.UserName)
570
571	u := tgbotapi.NewUpdate(0)
572	u.Timeout = 60
573
574	updates, err := bot.GetUpdatesChan(u)
575
576	// Optional: wait for updates and clear them if you don't want to handle
577	// a large backlog of old messages
578	time.Sleep(time.Millisecond * 500)
579	updates.Clear()
580
581	for update := range updates {
582		if update.Message == nil {
583			continue
584		}
585
586		log.Printf("[%s] %s", update.Message.From.UserName, update.Message.Text)
587
588		msg := tgbotapi.NewMessage(update.Message.Chat.ID, update.Message.Text)
589		msg.ReplyToMessageID = update.Message.MessageID
590
591		bot.Send(msg)
592	}
593}
594
595func ExampleNewWebhook() {
596	bot, err := tgbotapi.NewBotAPI("MyAwesomeBotToken")
597	if err != nil {
598		log.Fatal(err)
599	}
600
601	bot.Debug = true
602
603	log.Printf("Authorized on account %s", bot.Self.UserName)
604
605	_, err = bot.SetWebhook(tgbotapi.NewWebhookWithCert("https://www.google.com:8443/"+bot.Token, "cert.pem"))
606	if err != nil {
607		log.Fatal(err)
608	}
609	info, err := bot.GetWebhookInfo()
610	if err != nil {
611		log.Fatal(err)
612	}
613	if info.LastErrorDate != 0 {
614		log.Printf("[Telegram callback failed]%s", info.LastErrorMessage)
615	}
616	updates := bot.ListenForWebhook("/" + bot.Token)
617	go http.ListenAndServeTLS("0.0.0.0:8443", "cert.pem", "key.pem", nil)
618
619	for update := range updates {
620		log.Printf("%+v\n", update)
621	}
622}
623
624func ExampleWebhookHandler() {
625	bot, err := tgbotapi.NewBotAPI("MyAwesomeBotToken")
626	if err != nil {
627		log.Fatal(err)
628	}
629
630	bot.Debug = true
631
632	log.Printf("Authorized on account %s", bot.Self.UserName)
633
634	_, err = bot.SetWebhook(tgbotapi.NewWebhookWithCert("https://www.google.com:8443/"+bot.Token, "cert.pem"))
635	if err != nil {
636		log.Fatal(err)
637	}
638	info, err := bot.GetWebhookInfo()
639	if err != nil {
640		log.Fatal(err)
641	}
642	if info.LastErrorDate != 0 {
643		log.Printf("[Telegram callback failed]%s", info.LastErrorMessage)
644	}
645
646	http.HandleFunc("/"+bot.Token, func(w http.ResponseWriter, r *http.Request) {
647		update, err := bot.HandleUpdate(r)
648		if err != nil {
649			log.Printf("%+v\n", err.Error())
650		} else {
651			log.Printf("%+v\n", *update)
652		}
653	})
654
655	go http.ListenAndServeTLS("0.0.0.0:8443", "cert.pem", "key.pem", nil)
656}
657
658func ExampleAnswerInlineQuery() {
659	bot, err := tgbotapi.NewBotAPI("MyAwesomeBotToken") // create new bot
660	if err != nil {
661		log.Panic(err)
662	}
663
664	log.Printf("Authorized on account %s", bot.Self.UserName)
665
666	u := tgbotapi.NewUpdate(0)
667	u.Timeout = 60
668
669	updates, err := bot.GetUpdatesChan(u)
670
671	for update := range updates {
672		if update.InlineQuery == nil { // if no inline query, ignore it
673			continue
674		}
675
676		article := tgbotapi.NewInlineQueryResultArticle(update.InlineQuery.ID, "Echo", update.InlineQuery.Query)
677		article.Description = update.InlineQuery.Query
678
679		inlineConf := tgbotapi.InlineConfig{
680			InlineQueryID: update.InlineQuery.ID,
681			IsPersonal:    true,
682			CacheTime:     0,
683			Results:       []interface{}{article},
684		}
685
686		if _, err := bot.AnswerInlineQuery(inlineConf); err != nil {
687			log.Println(err)
688		}
689	}
690}
691
692func TestDeleteMessage(t *testing.T) {
693	bot, _ := getBot(t)
694
695	msg := tgbotapi.NewMessage(ChatID, "A test message from the test library in telegram-bot-api")
696	msg.ParseMode = "markdown"
697	message, _ := bot.Send(msg)
698
699	deleteMessageConfig := tgbotapi.DeleteMessageConfig{
700		ChatID:    message.Chat.ID,
701		MessageID: message.MessageID,
702	}
703	_, err := bot.DeleteMessage(deleteMessageConfig)
704
705	if err != nil {
706		t.Error(err)
707		t.Fail()
708	}
709}
710
711func TestPinChatMessage(t *testing.T) {
712	bot, _ := getBot(t)
713
714	msg := tgbotapi.NewMessage(SupergroupChatID, "A test message from the test library in telegram-bot-api")
715	msg.ParseMode = "markdown"
716	message, _ := bot.Send(msg)
717
718	pinChatMessageConfig := tgbotapi.PinChatMessageConfig{
719		ChatID:              message.Chat.ID,
720		MessageID:           message.MessageID,
721		DisableNotification: false,
722	}
723	_, err := bot.PinChatMessage(pinChatMessageConfig)
724
725	if err != nil {
726		t.Error(err)
727		t.Fail()
728	}
729}
730
731func TestUnpinChatMessage(t *testing.T) {
732	bot, _ := getBot(t)
733
734	msg := tgbotapi.NewMessage(SupergroupChatID, "A test message from the test library in telegram-bot-api")
735	msg.ParseMode = "markdown"
736	message, _ := bot.Send(msg)
737
738	// We need pin message to unpin something
739	pinChatMessageConfig := tgbotapi.PinChatMessageConfig{
740		ChatID:              message.Chat.ID,
741		MessageID:           message.MessageID,
742		DisableNotification: false,
743	}
744	_, err := bot.PinChatMessage(pinChatMessageConfig)
745
746	unpinChatMessageConfig := tgbotapi.UnpinChatMessageConfig{
747		ChatID: message.Chat.ID,
748	}
749	_, err = bot.UnpinChatMessage(unpinChatMessageConfig)
750
751	if err != nil {
752		t.Error(err)
753		t.Fail()
754	}
755}