2020-01-09 15:27:00 +00:00
|
|
|
|
package telegram
|
|
|
|
|
|
|
|
|
|
import (
|
|
|
|
|
"io/ioutil"
|
|
|
|
|
"os"
|
|
|
|
|
"path/filepath"
|
2020-11-05 08:28:32 +00:00
|
|
|
|
"strconv"
|
2020-01-09 15:27:00 +00:00
|
|
|
|
"testing"
|
|
|
|
|
"time"
|
|
|
|
|
|
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
|
http "github.com/valyala/fasthttp"
|
|
|
|
|
"golang.org/x/text/language"
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
func TestUserLanguage(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
user User
|
|
|
|
|
expResult language.Tag
|
|
|
|
|
}{{
|
|
|
|
|
name: "russian",
|
|
|
|
|
user: User{LanguageCode: "ru"},
|
|
|
|
|
expResult: language.Russian,
|
|
|
|
|
}, {
|
|
|
|
|
name: "english",
|
|
|
|
|
user: User{LanguageCode: "en"},
|
|
|
|
|
expResult: language.English,
|
|
|
|
|
}, {
|
|
|
|
|
name: "other",
|
|
|
|
|
user: User{LanguageCode: "w-t-f"},
|
|
|
|
|
expResult: language.Und,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: language.Und,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.user.Language(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestUserFullName(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
user User
|
|
|
|
|
expResult string
|
|
|
|
|
}{{
|
|
|
|
|
name: "full",
|
|
|
|
|
user: User{FirstName: "Maxim", LastName: "Lebedev"},
|
|
|
|
|
expResult: "Maxim Lebedev",
|
|
|
|
|
}, {
|
|
|
|
|
name: "first",
|
|
|
|
|
user: User{FirstName: "Maxim"},
|
|
|
|
|
expResult: "Maxim",
|
|
|
|
|
}, {
|
|
|
|
|
name: "last",
|
|
|
|
|
user: User{LastName: "Lebedev"},
|
|
|
|
|
expResult: "",
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: "",
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.user.FullName(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestUserHasLastName(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
u := User{LastName: "Lebedev"}
|
|
|
|
|
assert.True(t, u.HasLastName())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
u := User{FirstName: "Maxim"}
|
|
|
|
|
assert.False(t, u.HasLastName())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestUserHasUsername(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
u := User{Username: "toby3d", FirstName: "Maxim", LastName: "Lebedev"}
|
|
|
|
|
assert.True(t, u.HasUsername())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
u := User{FirstName: "Maxim", LastName: "Lebedev"}
|
|
|
|
|
assert.False(t, u.HasUsername())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestChatIsPrivate(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
c := Chat{Type: ChatPrivate, FirstName: "Maxim", LastName: "Lebedev"}
|
|
|
|
|
assert.True(t, c.IsPrivate())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
c := Chat{Type: ChatSuperGroup, FirstName: "Меня заставили создать эту группу"}
|
|
|
|
|
assert.False(t, c.IsPrivate())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestChatIsGroup(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
c := Chat{Type: ChatGroup, FirstName: "Меня заставили создать эту группу"}
|
|
|
|
|
assert.True(t, c.IsGroup())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
c := Chat{Type: ChatPrivate, FirstName: "Maxim", LastName: "Lebedev"}
|
|
|
|
|
assert.False(t, c.IsGroup())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestChatIsSuperGroup(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
c := Chat{Type: ChatSuperGroup, FirstName: "Меня заставили создать эту группу"}
|
|
|
|
|
assert.True(t, c.IsSuperGroup())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
c := Chat{Type: ChatPrivate, FirstName: "Maxim", LastName: "Lebedev"}
|
|
|
|
|
assert.False(t, c.IsSuperGroup())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestChatIsChannel(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
c := Chat{Type: ChatChannel, FirstName: "toby3d"}
|
|
|
|
|
assert.True(t, c.IsChannel())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
c := Chat{Type: ChatPrivate, FirstName: "Меня заставили создать эту группу"}
|
|
|
|
|
assert.False(t, c.IsChannel())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestChatHasPinnedMessage(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
c := Chat{PinnedMessage: &Message{Text: "hello, world!"}}
|
|
|
|
|
assert.True(t, c.HasPinnedMessage())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
c := Chat{}
|
|
|
|
|
assert.False(t, c.HasPinnedMessage())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestChatHasStickerSet(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
c := Chat{StickerSetName: "HotCherry"}
|
|
|
|
|
assert.True(t, c.HasStickerSet())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
c := Chat{}
|
|
|
|
|
assert.False(t, c.HasStickerSet())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestChatFullName(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
chat Chat
|
|
|
|
|
expResult string
|
|
|
|
|
}{{
|
|
|
|
|
name: "full",
|
|
|
|
|
chat: Chat{FirstName: "Maxim", LastName: "Lebedev"},
|
|
|
|
|
expResult: "Maxim Lebedev",
|
|
|
|
|
}, {
|
|
|
|
|
name: "first",
|
|
|
|
|
chat: Chat{FirstName: "Меня заставили создать эту группу"},
|
|
|
|
|
expResult: "Меня заставили создать эту группу",
|
|
|
|
|
}, {
|
|
|
|
|
name: "last",
|
|
|
|
|
chat: Chat{LastName: "WTF"},
|
|
|
|
|
expResult: "",
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: "",
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.chat.FullName(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestChatHasLastName(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
c := Chat{FirstName: "Maxim", LastName: "Lebedev"}
|
|
|
|
|
assert.True(t, c.HasLastName())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
c := Chat{FirstName: "Меня заставили создать эту группу", LastName: ""}
|
|
|
|
|
assert.False(t, c.HasLastName())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestChatHasUsername(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
c := Chat{Username: "toby3dRu"}
|
|
|
|
|
assert.True(t, c.HasUsername())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
c := Chat{}
|
|
|
|
|
assert.False(t, c.HasUsername())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestChatHasDescription(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
c := Chat{Description: "hello, world!"}
|
|
|
|
|
assert.True(t, c.HasDescription())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
c := Chat{}
|
|
|
|
|
assert.False(t, c.HasDescription())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestChatHasInviteLink(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
c := Chat{InviteLink: "https://t.me/joinchat/AAAAAD84EWpWTRTMh4aahQ"}
|
|
|
|
|
assert.True(t, c.HasInviteLink())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
c := Chat{}
|
|
|
|
|
assert.False(t, c.HasInviteLink())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsCommand(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "/" + CommandStart, Entities: []*MessageEntity{{Type: EntityBotCommand}}}
|
|
|
|
|
assert.True(t, m.IsCommand())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, @toby3d", Entities: []*MessageEntity{{Type: EntityMention}}}
|
|
|
|
|
assert.False(t, m.IsCommand())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsCommandEqual(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
message Message
|
|
|
|
|
command string
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "exact",
|
|
|
|
|
message: Message{
|
|
|
|
|
Text: "/" + CommandStart,
|
|
|
|
|
Entities: []*MessageEntity{{Type: EntityBotCommand, Length: len(CommandStart) + 1}},
|
|
|
|
|
},
|
|
|
|
|
command: CommandStart,
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "other",
|
|
|
|
|
message: Message{
|
|
|
|
|
Text: "/" + CommandStart,
|
|
|
|
|
Entities: []*MessageEntity{{Type: EntityBotCommand, Length: len(CommandStart) + 1}},
|
|
|
|
|
},
|
|
|
|
|
command: CommandHelp,
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
command: CommandHelp,
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.message.IsCommandEqual(tc.command), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageCommand(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
message Message
|
|
|
|
|
expResult string
|
|
|
|
|
}{{
|
|
|
|
|
name: "command",
|
|
|
|
|
message: Message{
|
|
|
|
|
Text: "/" + CommandStart,
|
|
|
|
|
Entities: []*MessageEntity{{Type: EntityBotCommand, Length: len(CommandStart) + 1}},
|
|
|
|
|
},
|
|
|
|
|
expResult: CommandStart,
|
|
|
|
|
}, {
|
|
|
|
|
name: "other",
|
|
|
|
|
message: Message{
|
|
|
|
|
Text: "hello world",
|
|
|
|
|
Entities: []*MessageEntity{{Type: EntityBold, Offset: 6, Length: 5}},
|
|
|
|
|
},
|
|
|
|
|
expResult: "",
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: "",
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.message.Command(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageRawCommand(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
message Message
|
|
|
|
|
expResult string
|
|
|
|
|
}{{
|
|
|
|
|
name: "command",
|
|
|
|
|
message: Message{
|
|
|
|
|
Text: "/" + CommandStart,
|
|
|
|
|
Entities: []*MessageEntity{{Type: EntityBotCommand, Length: len(CommandStart) + 1}},
|
|
|
|
|
},
|
|
|
|
|
expResult: CommandStart,
|
|
|
|
|
}, {
|
|
|
|
|
name: "other",
|
|
|
|
|
message: Message{
|
|
|
|
|
Text: "hello world",
|
|
|
|
|
Entities: []*MessageEntity{{Type: EntityBold, Offset: 6, Length: 5}},
|
|
|
|
|
},
|
|
|
|
|
expResult: "",
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: "",
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.message.RawCommand(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageHasCommandArgument(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
message Message
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
message: Message{
|
|
|
|
|
Text: "/start example",
|
|
|
|
|
Entities: []*MessageEntity{{Type: EntityBotCommand, Length: len(CommandStart) + 1}},
|
|
|
|
|
},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "other",
|
|
|
|
|
message: Message{
|
|
|
|
|
Text: "/start",
|
|
|
|
|
Entities: []*MessageEntity{{Type: EntityBold, Offset: 1, Length: len(CommandStart)}},
|
|
|
|
|
},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
message: Message{
|
|
|
|
|
Text: "/start",
|
|
|
|
|
Entities: []*MessageEntity{{Type: EntityBotCommand, Length: len(CommandStart) + 1}},
|
|
|
|
|
},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.message.HasCommandArgument(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageCommandArgument(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
message Message
|
|
|
|
|
expResult string
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
message: Message{
|
|
|
|
|
Text: "/start example",
|
|
|
|
|
Entities: []*MessageEntity{{Type: EntityBotCommand, Length: len(CommandStart) + 1}},
|
|
|
|
|
},
|
|
|
|
|
expResult: "example",
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
message: Message{
|
|
|
|
|
Text: "/start",
|
|
|
|
|
Entities: []*MessageEntity{{Type: EntityBotCommand, Length: len(CommandStart) + 1}},
|
|
|
|
|
},
|
|
|
|
|
expResult: "",
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: "",
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.message.CommandArgument(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsReply(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
message Message
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
message: Message{Text: "hello!", ReplyToMessage: &Message{Text: "hello, world!"}},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
message: Message{Text: "hello!"},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.message.IsReply(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsForward(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!", ForwardDate: time.Now().Unix()}
|
|
|
|
|
assert.True(t, m.IsForward())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsForward())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageTime(t *testing.T) {
|
|
|
|
|
now := time.Now().Round(time.Second)
|
|
|
|
|
zero := time.Time{}
|
|
|
|
|
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
message Message
|
|
|
|
|
expResult time.Time
|
|
|
|
|
}{{
|
|
|
|
|
name: "specific date",
|
|
|
|
|
message: Message{Date: now.Unix()},
|
|
|
|
|
expResult: now,
|
|
|
|
|
}, {
|
|
|
|
|
name: "zero",
|
|
|
|
|
message: Message{Date: 0},
|
|
|
|
|
expResult: zero,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: zero,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.True(t, tc.message.Time().Equal(tc.expResult))
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageForwardTime(t *testing.T) {
|
|
|
|
|
now := time.Now().Round(time.Second)
|
|
|
|
|
zero := time.Time{}
|
|
|
|
|
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
message Message
|
|
|
|
|
expResult time.Time
|
|
|
|
|
}{{
|
|
|
|
|
name: "specific date",
|
|
|
|
|
message: Message{ForwardDate: now.Unix()},
|
|
|
|
|
expResult: now,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
message: Message{ForwardDate: 0},
|
|
|
|
|
expResult: zero,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: zero,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.True(t, tc.message.ForwardTime().Equal(tc.expResult))
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEditTime(t *testing.T) {
|
|
|
|
|
now := time.Now().Round(time.Second)
|
|
|
|
|
zero := time.Time{}
|
|
|
|
|
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
message Message
|
|
|
|
|
expResult time.Time
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
message: Message{EditDate: now.Unix()},
|
|
|
|
|
expResult: now,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
message: Message{EditDate: 0},
|
|
|
|
|
expResult: zero,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: zero,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.True(t, tc.message.EditTime().Equal(tc.expResult))
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageHasBeenEdited(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "sorry, fixed", EditDate: time.Now().UTC().Unix()}
|
|
|
|
|
assert.True(t, m.HasBeenEdited())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "sorry, fixed", EditDate: 0}
|
|
|
|
|
assert.False(t, m.HasBeenEdited())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsText(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.True(t, m.IsText())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{}
|
|
|
|
|
assert.False(t, m.IsText())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsAudio(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Audio: &Audio{Performer: "One-Aloner", Title: "Monitor"}}
|
|
|
|
|
assert.True(t, m.IsAudio())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{}
|
|
|
|
|
assert.False(t, m.IsAudio())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsDocument(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Document: &Document{FileName: "readme.txt"}}
|
|
|
|
|
assert.True(t, m.IsDocument())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsDocument())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsGame(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Game: &Game{Title: "MuSquare"}}
|
|
|
|
|
assert.True(t, m.IsGame())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsGame())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsPhoto(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
2020-01-28 08:30:47 +00:00
|
|
|
|
m := Message{Photo: Photo{{FileID: "abc"}}}
|
2020-01-09 15:27:00 +00:00
|
|
|
|
assert.True(t, m.IsPhoto())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsPhoto())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsSticker(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Sticker: &Sticker{FileID: "abc"}}
|
|
|
|
|
assert.True(t, m.IsSticker())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsSticker())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsVideo(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Video: &Video{FileID: "abc"}}
|
|
|
|
|
assert.True(t, m.IsVideo())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsVideo())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsVoice(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Voice: &Voice{FileID: "abc"}}
|
|
|
|
|
assert.True(t, m.IsVoice())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsVoice())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsVideoNote(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{VideoNote: &VideoNote{FileID: "abc"}}
|
|
|
|
|
assert.True(t, m.IsVideoNote())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsVideoNote())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsContact(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Contact: &Contact{FirstName: "Maxim", PhoneNumber: "1234567890"}}
|
|
|
|
|
assert.True(t, m.IsContact())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsContact())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsLocation(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Location: &Location{Latitude: 56.085180, Longitude: 60.735150}}
|
|
|
|
|
assert.True(t, m.IsLocation())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsLocation())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsVenue(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Venue: &Venue{
|
|
|
|
|
Title: "Памятник В. И. Ленину",
|
|
|
|
|
Address: "Россия, Челябинская область, Снежинск, улица Свердлова",
|
|
|
|
|
Location: &Location{Latitude: 56.085180, Longitude: 60.735150},
|
|
|
|
|
}}
|
|
|
|
|
assert.True(t, m.IsVenue())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsVenue())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsAnimation(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Animation: &Animation{FileID: "abc"}}
|
|
|
|
|
assert.True(t, m.IsAnimation())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsAnimation())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsNewChatMembersEvent(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{NewChatMembers: []*User{{ID: 42, FirstName: "Maxim", LastName: "Lebedev"}}}
|
|
|
|
|
assert.True(t, m.IsNewChatMembersEvent())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsNewChatMembersEvent())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsLeftChatMemberEvent(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{LeftChatMember: &User{ID: 42, FirstName: "Maxim", LastName: "Lebedev"}}
|
|
|
|
|
assert.True(t, m.IsLeftChatMemberEvent())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsLeftChatMemberEvent())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsNewChatTitleEvent(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{NewChatTitle: "Меня заставили создать эту группу"}
|
|
|
|
|
assert.True(t, m.IsNewChatTitleEvent())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsNewChatTitleEvent())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsNewChatPhotoEvent(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
2020-01-28 08:30:47 +00:00
|
|
|
|
m := Message{NewChatPhoto: Photo{{FileID: "abc"}}}
|
2020-01-09 15:27:00 +00:00
|
|
|
|
assert.True(t, m.IsNewChatPhotoEvent())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsNewChatPhotoEvent())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsDeleteChatPhotoEvent(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{DeleteChatPhoto: true}
|
|
|
|
|
assert.True(t, m.IsDeleteChatPhotoEvent())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsDeleteChatPhotoEvent())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsGroupChatCreatedEvent(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{GroupChatCreated: true}
|
|
|
|
|
assert.True(t, m.IsGroupChatCreatedEvent())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsGroupChatCreatedEvent())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsSupergroupChatCreatedEvent(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{SupergroupChatCreated: true}
|
|
|
|
|
assert.True(t, m.IsSupergroupChatCreatedEvent())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsSupergroupChatCreatedEvent())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsChannelChatCreatedEvent(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{ChannelChatCreated: true}
|
|
|
|
|
assert.True(t, m.IsChannelChatCreatedEvent())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsChannelChatCreatedEvent())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsPinnedMessage(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{PinnedMessage: &Message{Text: "hello, world!"}}
|
|
|
|
|
assert.True(t, m.IsPinnedMessage())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsPinnedMessage())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsInvoice(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Invoice: &Invoice{Title: "Time Machine", TotalAmount: 1}}
|
|
|
|
|
assert.True(t, m.IsInvoice())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsInvoice())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsSuccessfulPayment(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{SuccessfulPayment: &SuccessfulPayment{
|
|
|
|
|
OrderInfo: &OrderInfo{Name: "Maxim Lebedev"}, TotalAmount: 1,
|
|
|
|
|
}}
|
|
|
|
|
assert.True(t, m.IsSuccessfulPayment())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsSuccessfulPayment())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsPoll(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Poll: &Poll{
|
|
|
|
|
Question: "What is the answer to life, the universe, and everything?",
|
|
|
|
|
Options: []*PollOption{
|
|
|
|
|
{Text: "42", VoterCount: 420},
|
|
|
|
|
{Text: "24", VoterCount: 140},
|
|
|
|
|
},
|
|
|
|
|
}}
|
|
|
|
|
assert.True(t, m.IsPoll())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.IsPoll())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageHasEntities(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!", Entities: []*MessageEntity{
|
|
|
|
|
{Type: EntityBold, Offset: 7, Length: 5},
|
|
|
|
|
}}
|
|
|
|
|
assert.True(t, m.HasEntities())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
m := Message{Text: "hello, world!"}
|
|
|
|
|
assert.False(t, m.HasEntities())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageHasCaptionEntities(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
message Message
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
message: Message{
|
|
|
|
|
Caption: "hello, world!", CaptionEntities: []*MessageEntity{
|
|
|
|
|
{Type: EntityBold, Offset: 7, Length: 5},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
message: Message{Text: "hello, world!"},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.message.HasCaptionEntities(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageHasMentions(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
message Message
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
message: Message{Text: "hello, @toby3d!", Entities: []*MessageEntity{
|
|
|
|
|
{Type: EntityMention, Offset: 7, Length: 7},
|
|
|
|
|
}},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "other",
|
|
|
|
|
message: Message{Text: "hello, world!", Entities: []*MessageEntity{
|
|
|
|
|
{Type: EntityBold, Offset: 7, Length: 5},
|
|
|
|
|
}},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
message: Message{Text: "hello, world!"},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.message.HasMentions(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageHasCaptionMentions(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
message Message
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
message: Message{Caption: "hello, @toby3d!", CaptionEntities: []*MessageEntity{
|
|
|
|
|
{Type: EntityMention, Offset: 7, Length: 7},
|
|
|
|
|
}},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "other",
|
|
|
|
|
message: Message{Text: "hello, world!", CaptionEntities: []*MessageEntity{
|
|
|
|
|
{Type: EntityBold, Offset: 7, Length: 5},
|
|
|
|
|
}},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
message: Message{Text: "hello, world!"},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.message.HasCaptionMentions(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageHasCaption(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
message Message
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
message: Message{Caption: "hello, world!"},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
message: Message{Text: "hello, world!"},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.message.HasCaption(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageHasAuthorSignature(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
message Message
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
message: Message{AuthorSignature: "Editor"},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
message: Message{Text: "hello, world!"},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.message.HasAuthorSignature(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageIsEvent(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
message Message
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "ChannelChatCreated",
|
|
|
|
|
message: Message{ChannelChatCreated: true},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "DeleteChatPhoto",
|
|
|
|
|
message: Message{DeleteChatPhoto: true},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "GroupChatCreated",
|
|
|
|
|
message: Message{GroupChatCreated: true},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "LeftChatMember",
|
|
|
|
|
message: Message{LeftChatMember: &User{ID: 42}},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "NewChatMembers",
|
|
|
|
|
message: Message{NewChatMembers: []*User{{ID: 42}}},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "NewChatTitle",
|
|
|
|
|
message: Message{NewChatTitle: "Меня заставили создать эту группу"},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "SupergroupChatCreated",
|
|
|
|
|
message: Message{SupergroupChatCreated: true},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "NewChatPhoto",
|
2020-01-28 08:30:47 +00:00
|
|
|
|
message: Message{NewChatPhoto: Photo{{FileID: "abc"}}},
|
2020-01-09 15:27:00 +00:00
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
message: Message{Text: "hello, world!"},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.message.IsEvent(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityIsBold(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
entity: MessageEntity{Type: EntityBold},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
entity: MessageEntity{Type: EntityMention},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.entity.IsBold(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityIsBotCommand(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
entity: MessageEntity{Type: EntityBotCommand},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
entity: MessageEntity{Type: EntityMention},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.entity.IsBotCommand(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityIsCashtag(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
entity: MessageEntity{Type: EntityCashtag},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
entity: MessageEntity{Type: EntityMention},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.entity.IsCashtag(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityIsCode(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
entity: MessageEntity{Type: EntityCode},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
entity: MessageEntity{Type: EntityMention},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.entity.IsCode(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityIsEmail(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
entity: MessageEntity{Type: EntityEmail},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
entity: MessageEntity{Type: EntityMention},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.entity.IsEmail(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityIsHashtag(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
entity: MessageEntity{Type: EntityHashtag},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
entity: MessageEntity{Type: EntityMention},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.entity.IsHashtag(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityIsItalic(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
entity: MessageEntity{Type: EntityItalic},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
entity: MessageEntity{Type: EntityMention},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.entity.IsItalic(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityIsMention(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
entity: MessageEntity{Type: EntityMention},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
entity: MessageEntity{Type: EntityURL},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.entity.IsMention(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityIsPhoneNumber(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
entity: MessageEntity{Type: EntityPhoneNumber},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
entity: MessageEntity{Type: EntityMention},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.entity.IsPhoneNumber(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityIsPre(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
entity: MessageEntity{Type: EntityPre},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
entity: MessageEntity{Type: EntityMention},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.entity.IsPre(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityIsStrikethrough(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
entity: MessageEntity{Type: EntityStrikethrough},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
entity: MessageEntity{Type: EntityMention},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.entity.IsStrikethrough(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityIsTextLink(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
entity: MessageEntity{Type: EntityTextLink},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
entity: MessageEntity{Type: EntityMention},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.entity.IsTextLink(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityIsTextMention(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
entity: MessageEntity{Type: EntityTextMention},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
entity: MessageEntity{Type: EntityMention},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.entity.IsTextMention(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityIsUnderline(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
entity: MessageEntity{Type: EntityUnderline},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
entity: MessageEntity{Type: EntityMention},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.entity.IsUnderline(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityIsURL(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
entity: MessageEntity{Type: EntityURL},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
entity: MessageEntity{Type: EntityMention},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.entity.IsURL(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityParseURL(t *testing.T) {
|
|
|
|
|
link := http.AcquireURI()
|
|
|
|
|
defer http.ReleaseURI(link)
|
|
|
|
|
|
|
|
|
|
link.Update("https://toby3d.me")
|
|
|
|
|
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
text string
|
|
|
|
|
expResult *http.URI
|
|
|
|
|
}{{
|
|
|
|
|
name: "valid",
|
|
|
|
|
entity: MessageEntity{Type: EntityURL, Length: len(link.String())},
|
|
|
|
|
text: link.String(),
|
|
|
|
|
expResult: link,
|
|
|
|
|
}, {
|
|
|
|
|
name: "other",
|
|
|
|
|
entity: MessageEntity{Type: EntityTextLink},
|
|
|
|
|
text: link.String(),
|
|
|
|
|
expResult: nil,
|
|
|
|
|
}, {
|
|
|
|
|
name: "wrong text",
|
|
|
|
|
entity: MessageEntity{Type: EntityURL, Length: len(link.String())},
|
|
|
|
|
text: "wtf",
|
|
|
|
|
expResult: nil,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
text: "",
|
|
|
|
|
expResult: nil,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
if tc.expResult == nil {
|
|
|
|
|
assert.Nil(t, tc.entity.ParseURL(tc.text))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
assert.Equal(t, tc.entity.ParseURL(tc.text).String(), tc.expResult.String())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestMessageEntityTextLink(t *testing.T) {
|
|
|
|
|
link := http.AcquireURI()
|
|
|
|
|
defer http.ReleaseURI(link)
|
|
|
|
|
|
|
|
|
|
link.Update("https://toby3d.me")
|
|
|
|
|
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
entity MessageEntity
|
|
|
|
|
expResult *http.URI
|
|
|
|
|
}{{
|
|
|
|
|
name: "valid",
|
|
|
|
|
entity: MessageEntity{Type: EntityTextLink, URL: link.String()},
|
|
|
|
|
expResult: link,
|
|
|
|
|
}, {
|
|
|
|
|
name: "other",
|
|
|
|
|
entity: MessageEntity{Type: EntityURL},
|
|
|
|
|
expResult: nil,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: nil,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
if tc.expResult == nil {
|
|
|
|
|
assert.Nil(t, tc.entity.TextLink())
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
assert.Equal(t, tc.entity.TextLink().String(), tc.expResult.String())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestAudioFullName(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
audio Audio
|
|
|
|
|
separator string
|
|
|
|
|
expResult string
|
|
|
|
|
}{{
|
|
|
|
|
name: "full",
|
|
|
|
|
audio: Audio{Performer: "One-Aloner", Title: "Monitor"},
|
|
|
|
|
separator: " | ",
|
|
|
|
|
expResult: "One-Aloner | Monitor",
|
|
|
|
|
}, {
|
|
|
|
|
name: "performer",
|
|
|
|
|
audio: Audio{Performer: "One-Aloner"},
|
|
|
|
|
separator: " | ",
|
|
|
|
|
expResult: "One-Aloner | " + DefaultAudioTitle,
|
|
|
|
|
}, {
|
|
|
|
|
name: "title",
|
|
|
|
|
audio: Audio{Title: "Monitor"},
|
|
|
|
|
separator: " | ",
|
|
|
|
|
expResult: "Monitor",
|
|
|
|
|
}, {
|
|
|
|
|
name: "without separator",
|
|
|
|
|
audio: Audio{Performer: "One-Aloner", Title: "Monitor"},
|
|
|
|
|
expResult: "One-Aloner" + DefaultAudioSeparator + "Monitor",
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: DefaultAudioTitle,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.audio.FullName(tc.separator), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestAudioHasPerformer(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
audio Audio
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
audio: Audio{Performer: "One-Aloner", Title: "Monitor"},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
audio: Audio{Title: "Monitor"},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.audio.HasPerformer(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestAudioHasTitle(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
audio Audio
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
audio: Audio{Performer: "One-Aloner", Title: "Monitor"},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
audio: Audio{Performer: "One-Aloner"},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.audio.HasTitle(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestAudioHasThumb(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
audio Audio
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
audio: Audio{Thumb: &PhotoSize{FileID: "abc"}},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.audio.HasThumb(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestAudioFile(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
audio Audio
|
|
|
|
|
expResult File
|
|
|
|
|
}{{
|
|
|
|
|
name: "valid",
|
|
|
|
|
audio: Audio{FileID: "abc", FileUniqueID: "really_abc", FileSize: 42},
|
|
|
|
|
expResult: File{FileID: "abc", FileUniqueID: "really_abc", FileSize: 42},
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: File{},
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.audio.File(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestDocumentHasThumb(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
document Document
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
document: Document{Thumb: &PhotoSize{FileID: "abc"}},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.document.HasThumb(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestDocumentFile(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
document Document
|
|
|
|
|
expResult File
|
|
|
|
|
}{{
|
|
|
|
|
name: "valid",
|
|
|
|
|
document: Document{FileID: "abc", FileUniqueID: "really_abc", FileSize: 42},
|
|
|
|
|
expResult: File{FileID: "abc", FileUniqueID: "really_abc", FileSize: 42},
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: File{},
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.document.File(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestVideoHasThumb(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
video Video
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
video: Video{Thumb: &PhotoSize{FileID: "abc"}},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.video.HasThumb(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestVideoFile(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
video Video
|
|
|
|
|
expResult File
|
|
|
|
|
}{{
|
|
|
|
|
name: "valid",
|
|
|
|
|
video: Video{FileID: "abc", FileUniqueID: "really_abc", FileSize: 42},
|
|
|
|
|
expResult: File{FileID: "abc", FileUniqueID: "really_abc", FileSize: 42},
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: File{},
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.video.File(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestAnimationHasThumb(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
animation Animation
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
animation: Animation{Thumb: &PhotoSize{FileID: "abc"}},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.animation.HasThumb(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestAnimationFile(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
animation Animation
|
|
|
|
|
expResult File
|
|
|
|
|
}{{
|
|
|
|
|
name: "valid",
|
|
|
|
|
animation: Animation{FileID: "abc", FileUniqueID: "really_abc", FileSize: 42},
|
|
|
|
|
expResult: File{FileID: "abc", FileUniqueID: "really_abc", FileSize: 42},
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: File{},
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.animation.File(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestVoiceFile(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
voice Voice
|
|
|
|
|
expResult File
|
|
|
|
|
}{{
|
|
|
|
|
name: "valid",
|
|
|
|
|
voice: Voice{FileID: "abc", FileUniqueID: "really_abc", FileSize: 42},
|
|
|
|
|
expResult: File{FileID: "abc", FileUniqueID: "really_abc", FileSize: 42},
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: File{},
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.voice.File(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestVideoNoteHasThumb(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
videoNote VideoNote
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
videoNote: VideoNote{Thumb: &PhotoSize{FileID: "abc"}},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.videoNote.HasThumb(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestVideoNoteFile(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
videoNote VideoNote
|
|
|
|
|
expResult File
|
|
|
|
|
}{{
|
|
|
|
|
name: "valid",
|
|
|
|
|
videoNote: VideoNote{FileID: "abc", FileUniqueID: "really_abc", FileSize: 42},
|
|
|
|
|
expResult: File{FileID: "abc", FileUniqueID: "really_abc", FileSize: 42},
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: File{},
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.videoNote.File(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestContactFullName(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
contact Contact
|
|
|
|
|
expResult string
|
|
|
|
|
}{{
|
|
|
|
|
name: "full",
|
|
|
|
|
contact: Contact{FirstName: "Maxim", LastName: "Lebedev"},
|
|
|
|
|
expResult: "Maxim Lebedev",
|
|
|
|
|
}, {
|
|
|
|
|
name: "first",
|
|
|
|
|
contact: Contact{FirstName: "Maxim"},
|
|
|
|
|
expResult: "Maxim",
|
|
|
|
|
}, {
|
|
|
|
|
name: "last",
|
|
|
|
|
contact: Contact{LastName: "Lebedev"},
|
|
|
|
|
expResult: "",
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
expResult: "",
|
|
|
|
|
}} {
|
2020-01-09 16:05:53 +00:00
|
|
|
|
tc := tc
|
2020-01-09 15:27:00 +00:00
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.contact.FullName(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestContactHasLastName(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
contact Contact
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
contact: Contact{FirstName: "Maxim", LastName: "Lebedev"},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
contact: Contact{FirstName: "Maxim"},
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
2020-01-09 16:05:53 +00:00
|
|
|
|
tc := tc
|
2020-01-09 15:27:00 +00:00
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.contact.HasLastName(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestContactInTelegram(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
contact Contact
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
contact: Contact{UserID: 42},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
2020-01-09 16:05:53 +00:00
|
|
|
|
tc := tc
|
2020-01-09 15:27:00 +00:00
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.contact.InTelegram(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestContactHasVCard(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
contact Contact
|
|
|
|
|
expResult bool
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
contact: Contact{
|
|
|
|
|
VCard: "BEGIN:VCARD\nVERSION:3.0\nFN;CHARSET=UTF-8:Maxim Maksimovich Lebedev\n" +
|
|
|
|
|
"N;CHARSET=UTF-8:Lebedev;Maxim;Maksimovich;;\nNICKNAME;CHARSET=UTF-8:toby3d\n" +
|
|
|
|
|
"GENDER:M\nURL;CHARSET=UTF-8:https://toby3d.me\nREV:2020-01-08T01:31:36.277Z\n" +
|
|
|
|
|
"END:VCARD",
|
|
|
|
|
},
|
|
|
|
|
expResult: true,
|
|
|
|
|
}, {
|
|
|
|
|
name: "false",
|
|
|
|
|
expResult: false,
|
|
|
|
|
}} {
|
2020-01-09 16:05:53 +00:00
|
|
|
|
tc := tc
|
2020-01-09 15:27:00 +00:00
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.contact.HasVCard(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestPollVotesCount(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
poll Poll
|
|
|
|
|
expResult int
|
|
|
|
|
}{{
|
|
|
|
|
name: "true",
|
|
|
|
|
poll: Poll{Options: []*PollOption{
|
2020-01-09 16:05:53 +00:00
|
|
|
|
{Text: "a", VoterCount: 24},
|
|
|
|
|
{Text: "b", VoterCount: 42},
|
2020-01-09 15:27:00 +00:00
|
|
|
|
}},
|
|
|
|
|
expResult: 66,
|
|
|
|
|
}, {
|
|
|
|
|
name: "true",
|
|
|
|
|
poll: Poll{Options: []*PollOption{
|
2020-01-09 16:05:53 +00:00
|
|
|
|
{Text: "a", VoterCount: 10},
|
|
|
|
|
{Text: "b", VoterCount: 0},
|
|
|
|
|
{Text: "c", VoterCount: 120},
|
2020-01-09 15:27:00 +00:00
|
|
|
|
}},
|
|
|
|
|
expResult: 130,
|
|
|
|
|
}} {
|
2020-01-09 16:05:53 +00:00
|
|
|
|
tc := tc
|
2020-01-09 15:27:00 +00:00
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.poll.VotesCount(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestChatPhotoSmallFile(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
chatPhoto ChatPhoto
|
|
|
|
|
expResult File
|
|
|
|
|
}{{
|
|
|
|
|
name: "valid",
|
|
|
|
|
chatPhoto: ChatPhoto{SmallFileID: "abc", SmallFileUniqueID: "really_abc"},
|
|
|
|
|
expResult: File{FileID: "abc", FileUniqueID: "really_abc"},
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: File{},
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.chatPhoto.SmallFile(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestChatPhotoBigFile(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
chatPhoto ChatPhoto
|
|
|
|
|
expResult File
|
|
|
|
|
}{{
|
|
|
|
|
name: "valid",
|
|
|
|
|
chatPhoto: ChatPhoto{BigFileID: "abc", BigFileUniqueID: "really_abc"},
|
|
|
|
|
expResult: File{FileID: "abc", FileUniqueID: "really_abc"},
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
expResult: File{},
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
assert.Equal(t, tc.chatPhoto.BigFile(), tc.expResult)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestInputFileIsFileID(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
f := InputFile{ID: "abc"}
|
|
|
|
|
assert.True(t, f.IsFileID())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
f := InputFile{}
|
|
|
|
|
assert.False(t, f.IsFileID())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestInputFileIsURI(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
u := http.AcquireURI()
|
|
|
|
|
defer http.ReleaseURI(u)
|
|
|
|
|
u.Update("https://toby3d.me/image.jpeg")
|
|
|
|
|
f := InputFile{URI: u}
|
|
|
|
|
assert.True(t, f.IsURI())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
f := InputFile{}
|
|
|
|
|
assert.False(t, f.IsURI())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestInputFileIsAttachment(t *testing.T) {
|
|
|
|
|
file, err := ioutil.TempFile(os.TempDir(), "photo_*.jpeg")
|
|
|
|
|
assert.NoError(t, err)
|
2020-01-09 16:05:53 +00:00
|
|
|
|
|
2020-01-09 15:27:00 +00:00
|
|
|
|
defer os.RemoveAll(file.Name())
|
|
|
|
|
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
f := InputFile{Attachment: file}
|
|
|
|
|
assert.True(t, f.IsAttachment())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
f := InputFile{}
|
|
|
|
|
assert.False(t, f.IsAttachment())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestInputFileMarshalJSON(t *testing.T) {
|
|
|
|
|
u := http.AcquireURI()
|
|
|
|
|
defer http.ReleaseURI(u)
|
|
|
|
|
u.Update("https://toby3d.me/image.jpeg")
|
|
|
|
|
|
|
|
|
|
file, err := ioutil.TempFile(os.TempDir(), "photo_*.jpeg")
|
|
|
|
|
assert.NoError(t, err)
|
2020-01-09 16:05:53 +00:00
|
|
|
|
|
2020-01-09 15:27:00 +00:00
|
|
|
|
defer os.RemoveAll(file.Name())
|
|
|
|
|
|
|
|
|
|
_, fileName := filepath.Split(file.Name())
|
|
|
|
|
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
inputFile InputFile
|
|
|
|
|
expResult string
|
|
|
|
|
}{{
|
|
|
|
|
name: "id",
|
|
|
|
|
inputFile: InputFile{ID: "abc"},
|
|
|
|
|
expResult: "abc",
|
|
|
|
|
}, {
|
|
|
|
|
name: "uri",
|
|
|
|
|
inputFile: InputFile{URI: u},
|
|
|
|
|
expResult: u.String(),
|
|
|
|
|
}, {
|
|
|
|
|
name: "attach",
|
|
|
|
|
inputFile: InputFile{Attachment: file},
|
|
|
|
|
expResult: SchemeAttach + "://" + fileName,
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
inputFile: InputFile{},
|
|
|
|
|
expResult: "",
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
src, err := tc.inputFile.MarshalJSON()
|
|
|
|
|
assert.NoError(t, err)
|
|
|
|
|
assert.Equal(t, tc.expResult, string(src))
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-05-08 15:45:09 +00:00
|
|
|
|
|
|
|
|
|
func TestMessageIsDice(t *testing.T) {
|
|
|
|
|
t.Run("true", func(t *testing.T) {
|
|
|
|
|
f := Message{Dice: &Dice{Value: 3}}
|
|
|
|
|
assert.True(t, f.IsDice())
|
|
|
|
|
})
|
|
|
|
|
t.Run("false", func(t *testing.T) {
|
|
|
|
|
f := new(Message)
|
|
|
|
|
assert.False(t, f.IsDice())
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestPollCloseTime(t *testing.T) {
|
|
|
|
|
now := time.Now().Round(time.Second)
|
|
|
|
|
p := Poll{CloseDate: now.Unix()}
|
|
|
|
|
|
|
|
|
|
assert.Equal(t, now, p.CloseTime())
|
|
|
|
|
}
|
2020-11-05 08:28:32 +00:00
|
|
|
|
|
|
|
|
|
func TestChatIDMarshalJSON(t *testing.T) {
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
input ChatID
|
|
|
|
|
expResult []byte
|
|
|
|
|
}{{
|
|
|
|
|
name: "chat id",
|
|
|
|
|
input: ChatID{ID: 123456},
|
|
|
|
|
expResult: strconv.AppendInt(nil, 123456, 10),
|
|
|
|
|
}, {
|
|
|
|
|
name: "channel username",
|
|
|
|
|
input: ChatID{Username: "@toby3dMe"},
|
|
|
|
|
expResult: []byte("@toby3dMe"),
|
|
|
|
|
}, {
|
|
|
|
|
name: "prefer id",
|
|
|
|
|
input: ChatID{ID: 123456, Username: "@toby3dMe"},
|
|
|
|
|
expResult: strconv.AppendInt(nil, 123456, 10),
|
|
|
|
|
}, {
|
|
|
|
|
name: "empty",
|
|
|
|
|
input: ChatID{},
|
|
|
|
|
expResult: nil,
|
|
|
|
|
}} {
|
|
|
|
|
tc := tc
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
result, err := tc.input.MarshalJSON()
|
|
|
|
|
assert.NoError(t, err)
|
|
|
|
|
assert.Equal(t, tc.expResult, result)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|