test<\/pre><\/div>\n<\/pre><\/div>\n<\/div>",
"lines": 2,
"lines_more": 0,
"channels": [
"C2147483705"
],
"groups": [],
"ims": [],
"comments_count": 1,
"initial_comment": {
"id": "Fc066YLGKH",
"created": 1433314757,
"timestamp": 1433314757,
"user": "U2147483697",
"comment": "test comment here"
}
}],
"user": "U2147483697",
"upload": true,
"ts": "1433314757.000006"
}`
func TestUploadedFile(t *testing.T) {
message, err := unmarshalMessage(uploadedFile)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeFileShare, message.SubType)
assert.Equal(t, "<@U2147483697|tester> uploaded a file: and commented: test comment here", message.Text)
// TODO: Assert File
assert.Equal(t, "U2147483697", message.User)
assert.True(t, message.Upload)
assert.Equal(t, "1433314757.000006", message.Timestamp)
}
var testPost = `{
"type": "message",
"subtype": "file_share",
"text": "<@U2147483697|tester> shared a file: ",
"files": [{
"id": "abc",
"created": 1433315398,
"timestamp": 1433315398,
"name": "test_post",
"title": "test post",
"mimetype": "text\/plain",
"filetype": "post",
"pretty_type": "Post",
"user": "U2147483697",
"editable": true,
"size": 14,
"mode": "post",
"is_external": false,
"external_type": "",
"is_public": true,
"public_url_shared": false,
"url": "https:\/\/slack-files.com\/files-pub\/abc-def-ghi\/test_post",
"url_download": "https:\/\/slack-files.com\/files-pub\/abc-def-ghi\/download\/test_post",
"url_private": "https:\/\/files.slack.com\/files-pri\/abc-def\/test_post",
"url_private_download": "https:\/\/files.slack.com\/files-pri\/abc-def\/download\/test_post",
"permalink": "https:\/\/test.slack.com\/files\/tester\/abc\/test_post",
"permalink_public": "https:\/\/slack-files.com\/abc-def-ghi",
"edit_link": "https:\/\/test.slack.com\/files\/tester\/abc\/test_post\/edit",
"preview": "test post body",
"channels": [
"C2147483705"
],
"groups": [],
"ims": [],
"comments_count": 1
}],
"user": "U2147483697",
"upload": false,
"ts": "1433315416.000008"
}`
func TestPost(t *testing.T) {
message, err := unmarshalMessage(testPost)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeFileShare, message.SubType)
assert.Equal(t, "<@U2147483697|tester> shared a file: ", message.Text)
// TODO: Assert File
assert.Equal(t, "U2147483697", message.User)
assert.False(t, message.Upload)
assert.Equal(t, "1433315416.000008", message.Timestamp)
}
var testComment = `{
"type": "message",
"subtype": "file_comment",
"text": "<@U2147483697|tester> commented on <@U2147483697|tester>'s file : another comment",
"files": [{
"id": "abc",
"created": 1433315398,
"timestamp": 1433315398,
"name": "test_post",
"title": "test post",
"mimetype": "text\/plain",
"filetype": "post",
"pretty_type": "Post",
"user": "U2147483697",
"editable": true,
"size": 14,
"mode": "post",
"is_external": false,
"external_type": "",
"is_public": true,
"public_url_shared": false,
"url": "https:\/\/slack-files.com\/files-pub\/abc-def-ghi\/test_post",
"url_download": "https:\/\/slack-files.com\/files-pub\/abc-def-ghi\/download\/test_post",
"url_private": "https:\/\/files.slack.com\/files-pri\/abc-def\/test_post",
"url_private_download": "https:\/\/files.slack.com\/files-pri\/abc-def\/download\/test_post",
"permalink": "https:\/\/test.slack.com\/files\/tester\/abc\/test_post",
"permalink_public": "https:\/\/slack-files.com\/abc-def-ghi",
"edit_link": "https:\/\/test.slack.com\/files\/tester\/abc\/test_post\/edit",
"preview": "test post body",
"channels": [
"C2147483705"
],
"groups": [],
"ims": [],
"comments_count": 2
}],
"comment": {
"id": "xyz",
"created": 1433316360,
"timestamp": 1433316360,
"user": "U2147483697",
"comment": "another comment"
},
"ts": "1433316360.000009"
}`
func TestComment(t *testing.T) {
message, err := unmarshalMessage(testComment)
fmt.Println(err)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeFileComment, message.SubType)
assert.Equal(t, "<@U2147483697|tester> commented on <@U2147483697|tester>'s file : another comment", message.Text)
// TODO: Assert File
// TODO: Assert Comment
assert.Equal(t, "1433316360.000009", message.Timestamp)
}
var botMessage = `{
"type": "message",
"subtype": "bot_message",
"text": "Pushing is the answer",
"suppress_notification": false,
"bot_id": "BB12033",
"username": "github",
"icons": {},
"team": "T01A9CUMPQA",
"bot_profile": {
"id": "BB12033",
"deleted": false,
"name": "github",
"updated": 1599574335,
"app_id": "A6DB2SWUW",
"icons": {
"image_36": "https://slack-files2.s3-us-west-2.amazonaws.com/avatars/2017-10-24/261138718469_ada58732a18da119678d_36.png",
"image_48": "https://slack-files2.s3-us-west-2.amazonaws.com/avatars/2017-10-24/261138718469_ada58732a18da119678d_48.png",
"image_72": "https://slack-files2.s3-us-west-2.amazonaws.com/avatars/2017-10-24/261138718469_ada58732a18da119678d_72.png"
},
"team_id": "T01A9CUMPQA"
},
"blocks": [],
"channel": "C01AZ844Z32",
"event_ts": "1358877455.000010",
"ts": "1358877455.000010"
}`
func TestBotMessage(t *testing.T) {
message, err := unmarshalMessage(botMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeBotMessage, message.SubType)
assert.Equal(t, "1358877455.000010", message.Timestamp)
assert.Equal(t, "Pushing is the answer", message.Text)
assert.Equal(t, "BB12033", message.BotID)
assert.Equal(t, "github", message.Username)
assert.NotNil(t, message.Icons)
assert.Empty(t, message.Icons.IconURL)
assert.Empty(t, message.Icons.IconEmoji)
assert.Equal(t, "github", message.BotProfile.Name)
assert.Equal(t, "BB12033", message.BotProfile.ID)
assert.Equal(t, false, message.BotProfile.Deleted)
assert.Equal(t, int64(1599574335), message.BotProfile.Updated)
assert.Equal(t, "A6DB2SWUW", message.BotProfile.AppID)
assert.Equal(t, "https://slack-files2.s3-us-west-2.amazonaws.com/avatars/2017-10-24/261138718469_ada58732a18da119678d_36.png", message.BotProfile.Icons.Image36)
assert.Equal(t, "https://slack-files2.s3-us-west-2.amazonaws.com/avatars/2017-10-24/261138718469_ada58732a18da119678d_48.png", message.BotProfile.Icons.Image48)
assert.Equal(t, "https://slack-files2.s3-us-west-2.amazonaws.com/avatars/2017-10-24/261138718469_ada58732a18da119678d_72.png", message.BotProfile.Icons.Image72)
assert.Equal(t, "T01A9CUMPQA", message.BotProfile.TeamID)
assert.Equal(t, "C01AZ844Z32", message.Channel)
assert.Equal(t, "1358877455.000010", message.EventTimestamp)
}
var meMessage = `{
"type": "message",
"subtype": "me_message",
"channel": "C2147483705",
"user": "U2147483697",
"text": "is doing that thing",
"ts": "1355517523.000005"
}`
func TestMeMessage(t *testing.T) {
message, err := unmarshalMessage(meMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeMeMessage, message.SubType)
assert.Equal(t, "C2147483705", message.Channel)
assert.Equal(t, "U2147483697", message.User)
assert.Equal(t, "is doing that thing", message.Text)
assert.Equal(t, "1355517523.000005", message.Timestamp)
}
var messageChangedMessage = `{
"type": "message",
"subtype": "message_changed",
"hidden": true,
"channel": "C2147483705",
"ts": "1358878755.000001",
"message": {
"type": "message",
"user": "U2147483697",
"text": "Hello, world!",
"ts": "1355517523.000005",
"edited": {
"user": "U2147483697",
"ts": "1358878755.000001"
}
}
}`
func TestMessageChangedMessage(t *testing.T) {
message, err := unmarshalMessage(messageChangedMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeMessageChanged, message.SubType)
assert.True(t, message.Hidden)
assert.Equal(t, "C2147483705", message.Channel)
assert.NotNil(t, message.SubMessage)
assert.Equal(t, "message", message.SubMessage.Type)
assert.Equal(t, "U2147483697", message.SubMessage.User)
assert.Equal(t, "Hello, world!", message.SubMessage.Text)
assert.Equal(t, "1355517523.000005", message.SubMessage.Timestamp)
assert.NotNil(t, message.SubMessage.Edited)
assert.Equal(t, "U2147483697", message.SubMessage.Edited.User)
assert.Equal(t, "1358878755.000001", message.SubMessage.Edited.Timestamp)
assert.Equal(t, "1358878755.000001", message.Timestamp)
}
var messageDeletedMessage = `{
"type": "message",
"subtype": "message_deleted",
"hidden": true,
"channel": "C2147483705",
"ts": "1358878755.000001",
"deleted_ts": "1358878749.000002"
}`
func TestMessageDeletedMessage(t *testing.T) {
message, err := unmarshalMessage(messageDeletedMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeMessageDeleted, message.SubType)
assert.True(t, message.Hidden)
assert.Equal(t, "C2147483705", message.Channel)
assert.Equal(t, "1358878755.000001", message.Timestamp)
assert.Equal(t, "1358878749.000002", message.DeletedTimestamp)
}
var channelJoinMessage = `{
"type": "message",
"subtype": "channel_join",
"ts": "1358877458.000011",
"user": "U2147483828",
"text": "<@U2147483828|cal> has joined the channel"
}`
func TestChannelJoinMessage(t *testing.T) {
message, err := unmarshalMessage(channelJoinMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeChannelJoin, message.SubType)
assert.Equal(t, "1358877458.000011", message.Timestamp)
assert.Equal(t, "U2147483828", message.User)
assert.Equal(t, "<@U2147483828|cal> has joined the channel", message.Text)
}
var channelJoinInvitedMessage = `{
"type": "message",
"subtype": "channel_join",
"ts": "1358877458.000011",
"user": "U2147483828",
"text": "<@U2147483828|cal> has joined the channel",
"inviter": "U2147483829"
}`
func TestChannelJoinInvitedMessage(t *testing.T) {
message, err := unmarshalMessage(channelJoinInvitedMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeChannelJoin, message.SubType)
assert.Equal(t, "1358877458.000011", message.Timestamp)
assert.Equal(t, "U2147483828", message.User)
assert.Equal(t, "<@U2147483828|cal> has joined the channel", message.Text)
assert.Equal(t, "U2147483829", message.Inviter)
}
var channelLeaveMessage = `{
"type": "message",
"subtype": "channel_leave",
"ts": "1358877455.000010",
"user": "U2147483828",
"text": "<@U2147483828|cal> has left the channel"
}`
func TestChannelLeaveMessage(t *testing.T) {
message, err := unmarshalMessage(channelLeaveMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeChannelLeave, message.SubType)
assert.Equal(t, "1358877455.000010", message.Timestamp)
assert.Equal(t, "U2147483828", message.User)
assert.Equal(t, "<@U2147483828|cal> has left the channel", message.Text)
}
var channelTopicMessage = `{
"type": "message",
"subtype": "channel_topic",
"ts": "1358877455.000010",
"user": "U2147483828",
"topic": "hello world",
"text": "<@U2147483828|cal> set the channel topic: hello world"
}`
func TestChannelTopicMessage(t *testing.T) {
message, err := unmarshalMessage(channelTopicMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeChannelTopic, message.SubType)
assert.Equal(t, "1358877455.000010", message.Timestamp)
assert.Equal(t, "U2147483828", message.User)
assert.Equal(t, "hello world", message.Topic)
assert.Equal(t, "<@U2147483828|cal> set the channel topic: hello world", message.Text)
}
var channelPurposeMessage = `{
"type": "message",
"subtype": "channel_purpose",
"ts": "1358877455.000010",
"user": "U2147483828",
"purpose": "whatever",
"text": "<@U2147483828|cal> set the channel purpose: whatever"
}`
func TestChannelPurposeMessage(t *testing.T) {
message, err := unmarshalMessage(channelPurposeMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeChannelPurpose, message.SubType)
assert.Equal(t, "1358877455.000010", message.Timestamp)
assert.Equal(t, "U2147483828", message.User)
assert.Equal(t, "whatever", message.Purpose)
assert.Equal(t, "<@U2147483828|cal> set the channel purpose: whatever", message.Text)
}
var channelNameMessage = `{
"type": "message",
"subtype": "channel_name",
"ts": "1358877455.000010",
"user": "U2147483828",
"old_name": "random",
"name": "watercooler",
"text": "<@U2147483828|cal> has renamed the channel from \"random\" to \"watercooler\""
}`
func TestChannelNameMessage(t *testing.T) {
message, err := unmarshalMessage(channelNameMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeChannelName, message.SubType)
assert.Equal(t, "1358877455.000010", message.Timestamp)
assert.Equal(t, "U2147483828", message.User)
assert.Equal(t, "random", message.OldName)
assert.Equal(t, "watercooler", message.Name)
assert.Equal(t, "<@U2147483828|cal> has renamed the channel from \"random\" to \"watercooler\"", message.Text)
}
var channelArchiveMessage = `{
"type": "message",
"subtype": "channel_archive",
"ts": "1361482916.000003",
"text": " archived the channel",
"user": "U1234",
"members": ["U1234", "U5678"]
}`
func TestChannelArchiveMessage(t *testing.T) {
message, err := unmarshalMessage(channelArchiveMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeChannelArchive, message.SubType)
assert.Equal(t, "1361482916.000003", message.Timestamp)
assert.Equal(t, " archived the channel", message.Text)
assert.Equal(t, "U1234", message.User)
assert.NotNil(t, message.Members)
assert.Equal(t, 2, len(message.Members))
}
var channelUnarchiveMessage = `{
"type": "message",
"subtype": "channel_unarchive",
"ts": "1361482916.000003",
"text": " un-archived the channel",
"user": "U1234"
}`
func TestChannelUnarchiveMessage(t *testing.T) {
message, err := unmarshalMessage(channelUnarchiveMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeChannelUnarchive, message.SubType)
assert.Equal(t, "1361482916.000003", message.Timestamp)
assert.Equal(t, " un-archived the channel", message.Text)
assert.Equal(t, "U1234", message.User)
}
var channelRepliesParentMessage = `{
"type": "message",
"user": "U1234",
"text": "test",
"thread_ts": "1493305433.915644",
"reply_count": 2,
"replies": [
{
"user": "U5678",
"ts": "1493305444.920992"
},
{
"user": "U9012",
"ts": "1493305894.133936"
}
],
"subscribed": true,
"last_read": "1493305894.133936",
"unread_count": 0,
"ts": "1493305433.915644"
}`
func TestChannelRepliesParentMessage(t *testing.T) {
message, err := unmarshalMessage(channelRepliesParentMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, "U1234", message.User)
assert.Equal(t, "test", message.Text)
assert.Equal(t, "1493305433.915644", message.ThreadTimestamp)
assert.Equal(t, 2, message.ReplyCount)
assert.Equal(t, "U5678", message.Replies[0].User)
assert.Equal(t, "1493305444.920992", message.Replies[0].Timestamp)
assert.Equal(t, "U9012", message.Replies[1].User)
assert.Equal(t, "1493305894.133936", message.Replies[1].Timestamp)
assert.Equal(t, "1493305433.915644", message.Timestamp)
}
var channelRepliesChildMessage = `{
"type": "message",
"user": "U5678",
"text": "foo",
"thread_ts": "1493305433.915644",
"parent_user_id": "U1234",
"ts": "1493305444.920992"
}`
func TestChannelRepliesChildMessage(t *testing.T) {
message, err := unmarshalMessage(channelRepliesChildMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, "U5678", message.User)
assert.Equal(t, "foo", message.Text)
assert.Equal(t, "1493305433.915644", message.ThreadTimestamp)
assert.Equal(t, "U1234", message.ParentUserId)
assert.Equal(t, "1493305444.920992", message.Timestamp)
}
var groupJoinMessage = `{
"type": "message",
"subtype": "group_join",
"ts": "1358877458.000011",
"user": "U2147483828",
"text": "<@U2147483828|cal> has joined the group"
}`
func TestGroupJoinMessage(t *testing.T) {
message, err := unmarshalMessage(groupJoinMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeGroupJoin, message.SubType)
assert.Equal(t, "1358877458.000011", message.Timestamp)
assert.Equal(t, "U2147483828", message.User)
assert.Equal(t, "<@U2147483828|cal> has joined the group", message.Text)
}
var groupJoinInvitedMessage = `{
"type": "message",
"subtype": "group_join",
"ts": "1358877458.000011",
"user": "U2147483828",
"text": "<@U2147483828|cal> has joined the group",
"inviter": "U2147483829"
}`
func TestGroupJoinInvitedMessage(t *testing.T) {
message, err := unmarshalMessage(groupJoinInvitedMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeGroupJoin, message.SubType)
assert.Equal(t, "1358877458.000011", message.Timestamp)
assert.Equal(t, "U2147483828", message.User)
assert.Equal(t, "<@U2147483828|cal> has joined the group", message.Text)
assert.Equal(t, "U2147483829", message.Inviter)
}
var groupLeaveMessage = `{
"type": "message",
"subtype": "group_leave",
"ts": "1358877455.000010",
"user": "U2147483828",
"text": "<@U2147483828|cal> has left the group"
}`
func TestGroupLeaveMessage(t *testing.T) {
message, err := unmarshalMessage(groupLeaveMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeGroupLeave, message.SubType)
assert.Equal(t, "1358877455.000010", message.Timestamp)
assert.Equal(t, "U2147483828", message.User)
assert.Equal(t, "<@U2147483828|cal> has left the group", message.Text)
}
var groupTopicMessage = `{
"type": "message",
"subtype": "group_topic",
"ts": "1358877455.000010",
"user": "U2147483828",
"topic": "hello world",
"text": "<@U2147483828|cal> set the group topic: hello world"
}`
func TestGroupTopicMessage(t *testing.T) {
message, err := unmarshalMessage(groupTopicMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeGroupTopic, message.SubType)
assert.Equal(t, "1358877455.000010", message.Timestamp)
assert.Equal(t, "U2147483828", message.User)
assert.Equal(t, "hello world", message.Topic)
assert.Equal(t, "<@U2147483828|cal> set the group topic: hello world", message.Text)
}
var groupPurposeMessage = `{
"type": "message",
"subtype": "group_purpose",
"ts": "1358877455.000010",
"user": "U2147483828",
"purpose": "whatever",
"text": "<@U2147483828|cal> set the group purpose: whatever"
}`
func TestGroupPurposeMessage(t *testing.T) {
message, err := unmarshalMessage(groupPurposeMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeGroupPurpose, message.SubType)
assert.Equal(t, "1358877455.000010", message.Timestamp)
assert.Equal(t, "U2147483828", message.User)
assert.Equal(t, "whatever", message.Purpose)
assert.Equal(t, "<@U2147483828|cal> set the group purpose: whatever", message.Text)
}
var groupNameMessage = `{
"type": "message",
"subtype": "group_name",
"ts": "1358877455.000010",
"user": "U2147483828",
"old_name": "random",
"name": "watercooler",
"text": "<@U2147483828|cal> has renamed the group from \"random\" to \"watercooler\""
}`
func TestGroupNameMessage(t *testing.T) {
message, err := unmarshalMessage(groupNameMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeGroupName, message.SubType)
assert.Equal(t, "1358877455.000010", message.Timestamp)
assert.Equal(t, "U2147483828", message.User)
assert.Equal(t, "random", message.OldName)
assert.Equal(t, "watercooler", message.Name)
assert.Equal(t, "<@U2147483828|cal> has renamed the group from \"random\" to \"watercooler\"", message.Text)
}
var groupArchiveMessage = `{
"type": "message",
"subtype": "group_archive",
"ts": "1361482916.000003",
"text": " archived the group",
"user": "U1234",
"members": ["U1234", "U5678"]
}`
func TestGroupArchiveMessage(t *testing.T) {
message, err := unmarshalMessage(groupArchiveMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeGroupArchive, message.SubType)
assert.Equal(t, "1361482916.000003", message.Timestamp)
assert.Equal(t, " archived the group", message.Text)
assert.Equal(t, "U1234", message.User)
assert.NotNil(t, message.Members)
assert.Equal(t, 2, len(message.Members))
}
var groupUnarchiveMessage = `{
"type": "message",
"subtype": "group_unarchive",
"ts": "1361482916.000003",
"text": " un-archived the group",
"user": "U1234"
}`
func TestGroupUnarchiveMessage(t *testing.T) {
message, err := unmarshalMessage(groupUnarchiveMessage)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeGroupUnarchive, message.SubType)
assert.Equal(t, "1361482916.000003", message.Timestamp)
assert.Equal(t, " un-archived the group", message.Text)
assert.Equal(t, "U1234", message.User)
}
var fileShareMessage = `{
"type": "message",
"subtype": "file_share",
"ts": "1358877455.000010",
"text": "<@cal> uploaded a file: ",
"files": [{
"id" : "F2147483862",
"created" : 1356032811,
"timestamp" : 1356032811,
"name" : "file.htm",
"title" : "My HTML file",
"mimetype" : "text\/plain",
"filetype" : "text",
"pretty_type": "Text",
"user" : "U2147483697",
"mode" : "hosted",
"editable" : true,
"is_external": false,
"external_type": "",
"size" : 12345,
"url": "https:\/\/slack-files.com\/files-pub\/T024BE7LD-F024BERPE-09acb6\/1.png",
"url_download": "https:\/\/slack-files.com\/files-pub\/T024BE7LD-F024BERPE-09acb6\/download\/1.png",
"url_private": "https:\/\/slack.com\/files-pri\/T024BE7LD-F024BERPE\/1.png",
"url_private_download": "https:\/\/slack.com\/files-pri\/T024BE7LD-F024BERPE\/download\/1.png",
"thumb_64": "https:\/\/slack-files.com\/files-tmb\/T024BE7LD-F024BERPE-c66246\/1_64.png",
"thumb_80": "https:\/\/slack-files.com\/files-tmb\/T024BE7LD-F024BERPE-c66246\/1_80.png",
"thumb_360": "https:\/\/slack-files.com\/files-tmb\/T024BE7LD-F024BERPE-c66246\/1_360.png",
"thumb_360_gif": "https:\/\/slack-files.com\/files-tmb\/T024BE7LD-F024BERPE-c66246\/1_360.gif",
"thumb_360_w": 100,
"thumb_360_h": 100,
"permalink" : "https:\/\/tinyspeck.slack.com\/files\/cal\/F024BERPE\/1.png",
"edit_link" : "https:\/\/tinyspeck.slack.com\/files\/cal\/F024BERPE\/1.png/edit",
"preview" : "<!DOCTYPE html>\n<html>\n<meta charset='utf-8'>",
"preview_highlight" : "<div class=\"sssh-code\"><div class=\"sssh-line\"><pre><!DOCTYPE html...",
"lines" : 123,
"lines_more": 118,
"is_public": true,
"public_url_shared": false,
"channels": ["C024BE7LT"],
"groups": ["G12345"],
"ims": ["D12345"],
"initial_comment": {},
"num_stars": 7,
"is_starred": true
}],
"user": "U2147483697",
"upload": true
}`
func TestFileShareMessage(t *testing.T) {
message, err := unmarshalMessage(fileShareMessage)
fmt.Println(err)
assert.Nil(t, err)
assert.NotNil(t, message)
assert.Equal(t, "message", message.Type)
assert.Equal(t, MsgSubTypeFileShare, message.SubType)
assert.Equal(t, "1358877455.000010", message.Timestamp)
assert.Equal(t, "<@cal> uploaded a file: ", message.Text)
assert.Equal(t, "U2147483697", message.User)
assert.True(t, message.Upload)
assert.NotNil(t, message.Files[0])
}
slack-0.11.3/metadata.go 0000664 0000000 0000000 00000000334 14307410331 0014774 0 ustar 00root root 0000000 0000000 package slack
// SlackMetadata https://api.slack.com/reference/metadata
type SlackMetadata struct {
EventType string `json:"event_type"`
EventPayload map[string]interface{} `json:"event_payload"`
}
slack-0.11.3/misc.go 0000664 0000000 0000000 00000020744 14307410331 0014156 0 ustar 00root root 0000000 0000000 package slack
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"io/ioutil"
"mime"
"mime/multipart"
"net/http"
"net/http/httputil"
"net/url"
"os"
"path/filepath"
"strconv"
"strings"
"time"
)
// SlackResponse handles parsing out errors from the web api.
type SlackResponse struct {
Ok bool `json:"ok"`
Error string `json:"error"`
ResponseMetadata ResponseMetadata `json:"response_metadata"`
}
func (t SlackResponse) Err() error {
if t.Ok {
return nil
}
// handle pure text based responses like chat.post
// which while they have a slack response in their data structure
// it doesn't actually get set during parsing.
if strings.TrimSpace(t.Error) == "" {
return nil
}
return SlackErrorResponse{Err: t.Error, ResponseMetadata: t.ResponseMetadata}
}
// SlackErrorResponse brings along the metadata of errors returned by the Slack API.
type SlackErrorResponse struct {
Err string
ResponseMetadata ResponseMetadata
}
func (r SlackErrorResponse) Error() string { return r.Err }
// RateLimitedError represents the rate limit response from slack
type RateLimitedError struct {
RetryAfter time.Duration
}
func (e *RateLimitedError) Error() string {
return fmt.Sprintf("slack rate limit exceeded, retry after %s", e.RetryAfter)
}
func (e *RateLimitedError) Retryable() bool {
return true
}
func fileUploadReq(ctx context.Context, path string, values url.Values, r io.Reader) (*http.Request, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodPost, path, r)
if err != nil {
return nil, err
}
req.URL.RawQuery = values.Encode()
return req, nil
}
func downloadFile(ctx context.Context, client httpClient, token string, downloadURL string, writer io.Writer, d Debug) error {
if downloadURL == "" {
return fmt.Errorf("received empty download URL")
}
req, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL, &bytes.Buffer{})
if err != nil {
return err
}
var bearer = "Bearer " + token
req.Header.Add("Authorization", bearer)
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
err = checkStatusCode(resp, d)
if err != nil {
return err
}
_, err = io.Copy(writer, resp.Body)
return err
}
func formReq(ctx context.Context, endpoint string, values url.Values) (req *http.Request, err error) {
if req, err = http.NewRequestWithContext(ctx, http.MethodPost, endpoint, strings.NewReader(values.Encode())); err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
return req, nil
}
func jsonReq(ctx context.Context, endpoint string, body interface{}) (req *http.Request, err error) {
buffer := bytes.NewBuffer([]byte{})
if err = json.NewEncoder(buffer).Encode(body); err != nil {
return nil, err
}
if req, err = http.NewRequestWithContext(ctx, http.MethodPost, endpoint, buffer); err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
return req, nil
}
func parseResponseBody(body io.ReadCloser, intf interface{}, d Debug) error {
response, err := ioutil.ReadAll(body)
if err != nil {
return err
}
if d.Debug() {
d.Debugln("parseResponseBody", string(response))
}
return json.Unmarshal(response, intf)
}
func postLocalWithMultipartResponse(ctx context.Context, client httpClient, method, fpath, fieldname, token string, values url.Values, intf interface{}, d Debug) error {
fullpath, err := filepath.Abs(fpath)
if err != nil {
return err
}
file, err := os.Open(fullpath)
if err != nil {
return err
}
defer file.Close()
return postWithMultipartResponse(ctx, client, method, filepath.Base(fpath), fieldname, token, values, file, intf, d)
}
func postWithMultipartResponse(ctx context.Context, client httpClient, path, name, fieldname, token string, values url.Values, r io.Reader, intf interface{}, d Debug) error {
pipeReader, pipeWriter := io.Pipe()
wr := multipart.NewWriter(pipeWriter)
errc := make(chan error)
go func() {
defer pipeWriter.Close()
ioWriter, err := wr.CreateFormFile(fieldname, name)
if err != nil {
errc <- err
return
}
_, err = io.Copy(ioWriter, r)
if err != nil {
errc <- err
return
}
if err = wr.Close(); err != nil {
errc <- err
return
}
}()
req, err := fileUploadReq(ctx, path, values, pipeReader)
if err != nil {
return err
}
req.Header.Add("Content-Type", wr.FormDataContentType())
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
err = checkStatusCode(resp, d)
if err != nil {
return err
}
select {
case err = <-errc:
return err
default:
return newJSONParser(intf)(resp)
}
}
func doPost(ctx context.Context, client httpClient, req *http.Request, parser responseParser, d Debug) error {
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
err = checkStatusCode(resp, d)
if err != nil {
return err
}
return parser(resp)
}
// post JSON.
func postJSON(ctx context.Context, client httpClient, endpoint, token string, json []byte, intf interface{}, d Debug) error {
reqBody := bytes.NewBuffer(json)
req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, reqBody)
if err != nil {
return err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
return doPost(ctx, client, req, newJSONParser(intf), d)
}
// post a url encoded form.
func postForm(ctx context.Context, client httpClient, endpoint string, values url.Values, intf interface{}, d Debug) error {
reqBody := strings.NewReader(values.Encode())
req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, reqBody)
if err != nil {
return err
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
return doPost(ctx, client, req, newJSONParser(intf), d)
}
func getResource(ctx context.Context, client httpClient, endpoint, token string, values url.Values, intf interface{}, d Debug) error {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
if err != nil {
return err
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
req.URL.RawQuery = values.Encode()
return doPost(ctx, client, req, newJSONParser(intf), d)
}
func parseAdminResponse(ctx context.Context, client httpClient, method string, teamName string, values url.Values, intf interface{}, d Debug) error {
endpoint := fmt.Sprintf(WEBAPIURLFormat, teamName, method, time.Now().Unix())
return postForm(ctx, client, endpoint, values, intf, d)
}
func logResponse(resp *http.Response, d Debug) error {
if d.Debug() {
text, err := httputil.DumpResponse(resp, true)
if err != nil {
return err
}
d.Debugln(string(text))
}
return nil
}
func okJSONHandler(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
response, _ := json.Marshal(SlackResponse{
Ok: true,
})
rw.Write(response)
}
// timerReset safely reset a timer, see time.Timer.Reset for details.
func timerReset(t *time.Timer, d time.Duration) {
if !t.Stop() {
<-t.C
}
t.Reset(d)
}
func checkStatusCode(resp *http.Response, d Debug) error {
if resp.StatusCode == http.StatusTooManyRequests {
retry, err := strconv.ParseInt(resp.Header.Get("Retry-After"), 10, 64)
if err != nil {
return err
}
return &RateLimitedError{time.Duration(retry) * time.Second}
}
// Slack seems to send an HTML body along with 5xx error codes. Don't parse it.
if resp.StatusCode != http.StatusOK {
logResponse(resp, d)
return StatusCodeError{Code: resp.StatusCode, Status: resp.Status}
}
return nil
}
type responseParser func(*http.Response) error
func newJSONParser(dst interface{}) responseParser {
return func(resp *http.Response) error {
return json.NewDecoder(resp.Body).Decode(dst)
}
}
func newTextParser(dst interface{}) responseParser {
return func(resp *http.Response) error {
b, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
if !bytes.Equal(b, []byte("ok")) {
return errors.New(string(b))
}
return nil
}
}
func newContentTypeParser(dst interface{}) responseParser {
return func(req *http.Response) (err error) {
var (
ctype string
)
if ctype, _, err = mime.ParseMediaType(req.Header.Get("Content-Type")); err != nil {
return err
}
switch ctype {
case "application/json":
return newJSONParser(dst)(req)
default:
return newTextParser(dst)(req)
}
}
}
slack-0.11.3/misc_test.go 0000664 0000000 0000000 00000005215 14307410331 0015211 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"log"
"net/http"
"net/url"
"sync"
"testing"
"github.com/slack-go/slack/slackutilsx"
)
var (
parseResponseOnce sync.Once
)
func parseResponseHandler(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
token := r.FormValue("token")
log.Println(token)
if token == "" {
rw.Write([]byte(`{"ok":false,"error":"not_authed"}`))
return
}
if token != validToken {
rw.Write([]byte(`{"ok":false,"error":"invalid_auth"}`))
return
}
response := []byte(`{"ok": true}`)
rw.Write(response)
}
func setParseResponseHandler() {
http.HandleFunc("/parseResponse", parseResponseHandler)
}
func TestParseResponse(t *testing.T) {
parseResponseOnce.Do(setParseResponseHandler)
once.Do(startServer)
APIURL := "http://" + serverAddr + "/"
values := url.Values{
"token": {validToken},
}
responsePartial := &SlackResponse{}
err := postForm(context.Background(), http.DefaultClient, APIURL+"parseResponse", values, responsePartial, discard{})
if err != nil {
t.Errorf("Unexpected error: %s", err)
}
}
func TestParseResponseNoToken(t *testing.T) {
parseResponseOnce.Do(setParseResponseHandler)
once.Do(startServer)
APIURL := "http://" + serverAddr + "/"
values := url.Values{}
responsePartial := &SlackResponse{}
err := postForm(context.Background(), http.DefaultClient, APIURL+"parseResponse", values, responsePartial, discard{})
if err != nil {
t.Errorf("Unexpected error: %s", err)
return
}
if responsePartial.Ok {
t.Errorf("Unexpected error: %s", err)
} else if responsePartial.Error != "not_authed" {
t.Errorf("got %v; want %v", responsePartial.Error, "not_authed")
}
}
func TestParseResponseInvalidToken(t *testing.T) {
parseResponseOnce.Do(setParseResponseHandler)
once.Do(startServer)
APIURL := "http://" + serverAddr + "/"
values := url.Values{
"token": {"whatever"},
}
responsePartial := &SlackResponse{}
err := postForm(context.Background(), http.DefaultClient, APIURL+"parseResponse", values, responsePartial, discard{})
if err != nil {
t.Errorf("Unexpected error: %s", err)
return
}
if responsePartial.Ok {
t.Errorf("Unexpected error: %s", err)
} else if responsePartial.Error != "invalid_auth" {
t.Errorf("got %v; want %v", responsePartial.Error, "invalid_auth")
}
}
func TestRetryable(t *testing.T) {
for _, e := range []error{
&RateLimitedError{},
StatusCodeError{Code: http.StatusInternalServerError},
StatusCodeError{Code: http.StatusTooManyRequests},
} {
r, ok := e.(slackutilsx.Retryable)
if !ok {
t.Errorf("expected %#v to implement Retryable", e)
}
if !r.Retryable() {
t.Errorf("expected %#v to be Retryable", e)
}
}
}
slack-0.11.3/oauth.go 0000664 0000000 0000000 00000014756 14307410331 0014351 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"net/url"
)
// OAuthResponseIncomingWebhook ...
type OAuthResponseIncomingWebhook struct {
URL string `json:"url"`
Channel string `json:"channel"`
ChannelID string `json:"channel_id,omitempty"`
ConfigurationURL string `json:"configuration_url"`
}
// OAuthResponseBot ...
type OAuthResponseBot struct {
BotUserID string `json:"bot_user_id"`
BotAccessToken string `json:"bot_access_token"`
}
// OAuthResponse ...
type OAuthResponse struct {
AccessToken string `json:"access_token"`
Scope string `json:"scope"`
TeamName string `json:"team_name"`
TeamID string `json:"team_id"`
IncomingWebhook OAuthResponseIncomingWebhook `json:"incoming_webhook"`
Bot OAuthResponseBot `json:"bot"`
UserID string `json:"user_id,omitempty"`
SlackResponse
}
// OAuthV2Response ...
type OAuthV2Response struct {
AccessToken string `json:"access_token"`
TokenType string `json:"token_type"`
Scope string `json:"scope"`
BotUserID string `json:"bot_user_id"`
AppID string `json:"app_id"`
Team OAuthV2ResponseTeam `json:"team"`
IncomingWebhook OAuthResponseIncomingWebhook `json:"incoming_webhook"`
Enterprise OAuthV2ResponseEnterprise `json:"enterprise"`
AuthedUser OAuthV2ResponseAuthedUser `json:"authed_user"`
RefreshToken string `json:"refresh_token"`
ExpiresIn int `json:"expires_in"`
SlackResponse
}
// OAuthV2ResponseTeam ...
type OAuthV2ResponseTeam struct {
ID string `json:"id"`
Name string `json:"name"`
}
// OAuthV2ResponseEnterprise ...
type OAuthV2ResponseEnterprise struct {
ID string `json:"id"`
Name string `json:"name"`
}
// OAuthV2ResponseAuthedUser ...
type OAuthV2ResponseAuthedUser struct {
ID string `json:"id"`
Scope string `json:"scope"`
AccessToken string `json:"access_token"`
ExpiresIn int `json:"expires_in"`
RefreshToken string `json:"refresh_token"`
TokenType string `json:"token_type"`
}
// GetOAuthToken retrieves an AccessToken
func GetOAuthToken(client httpClient, clientID, clientSecret, code, redirectURI string) (accessToken string, scope string, err error) {
return GetOAuthTokenContext(context.Background(), client, clientID, clientSecret, code, redirectURI)
}
// GetOAuthTokenContext retrieves an AccessToken with a custom context
func GetOAuthTokenContext(ctx context.Context, client httpClient, clientID, clientSecret, code, redirectURI string) (accessToken string, scope string, err error) {
response, err := GetOAuthResponseContext(ctx, client, clientID, clientSecret, code, redirectURI)
if err != nil {
return "", "", err
}
return response.AccessToken, response.Scope, nil
}
// GetBotOAuthToken retrieves top-level and bot AccessToken - https://api.slack.com/legacy/oauth#bot_user_access_tokens
func GetBotOAuthToken(client httpClient, clientID, clientSecret, code, redirectURI string) (accessToken string, scope string, bot OAuthResponseBot, err error) {
return GetBotOAuthTokenContext(context.Background(), client, clientID, clientSecret, code, redirectURI)
}
// GetBotOAuthTokenContext retrieves top-level and bot AccessToken with a custom context
func GetBotOAuthTokenContext(ctx context.Context, client httpClient, clientID, clientSecret, code, redirectURI string) (accessToken string, scope string, bot OAuthResponseBot, err error) {
response, err := GetOAuthResponseContext(ctx, client, clientID, clientSecret, code, redirectURI)
if err != nil {
return "", "", OAuthResponseBot{}, err
}
return response.AccessToken, response.Scope, response.Bot, nil
}
// GetOAuthResponse retrieves OAuth response
func GetOAuthResponse(client httpClient, clientID, clientSecret, code, redirectURI string) (resp *OAuthResponse, err error) {
return GetOAuthResponseContext(context.Background(), client, clientID, clientSecret, code, redirectURI)
}
// GetOAuthResponseContext retrieves OAuth response with custom context
func GetOAuthResponseContext(ctx context.Context, client httpClient, clientID, clientSecret, code, redirectURI string) (resp *OAuthResponse, err error) {
values := url.Values{
"client_id": {clientID},
"client_secret": {clientSecret},
"code": {code},
"redirect_uri": {redirectURI},
}
response := &OAuthResponse{}
if err = postForm(ctx, client, APIURL+"oauth.access", values, response, discard{}); err != nil {
return nil, err
}
return response, response.Err()
}
// GetOAuthV2Response gets a V2 OAuth access token response - https://api.slack.com/methods/oauth.v2.access
func GetOAuthV2Response(client httpClient, clientID, clientSecret, code, redirectURI string) (resp *OAuthV2Response, err error) {
return GetOAuthV2ResponseContext(context.Background(), client, clientID, clientSecret, code, redirectURI)
}
// GetOAuthV2ResponseContext with a context, gets a V2 OAuth access token response
func GetOAuthV2ResponseContext(ctx context.Context, client httpClient, clientID, clientSecret, code, redirectURI string) (resp *OAuthV2Response, err error) {
values := url.Values{
"client_id": {clientID},
"client_secret": {clientSecret},
"code": {code},
"redirect_uri": {redirectURI},
}
response := &OAuthV2Response{}
if err = postForm(ctx, client, APIURL+"oauth.v2.access", values, response, discard{}); err != nil {
return nil, err
}
return response, response.Err()
}
// RefreshOAuthV2AccessContext with a context, gets a V2 OAuth access token response
func RefreshOAuthV2Token(client httpClient, clientID, clientSecret, refreshToken string) (resp *OAuthV2Response, err error) {
return RefreshOAuthV2TokenContext(context.Background(), client, clientID, clientSecret, refreshToken)
}
// RefreshOAuthV2AccessContext with a context, gets a V2 OAuth access token response
func RefreshOAuthV2TokenContext(ctx context.Context, client httpClient, clientID, clientSecret, refreshToken string) (resp *OAuthV2Response, err error) {
values := url.Values{
"client_id": {clientID},
"client_secret": {clientSecret},
"refresh_token": {refreshToken},
"grant_type": {"refresh_token"},
}
response := &OAuthV2Response{}
if err = postForm(ctx, client, APIURL+"oauth.v2.access", values, response, discard{}); err != nil {
return nil, err
}
return response, response.Err()
}
slack-0.11.3/pagination.go 0000664 0000000 0000000 00000001013 14307410331 0015340 0 ustar 00root root 0000000 0000000 package slack
// Paging contains paging information
type Paging struct {
Count int `json:"count"`
Total int `json:"total"`
Page int `json:"page"`
Pages int `json:"pages"`
}
// Pagination contains pagination information
// This is different from Paging in that it contains additional details
type Pagination struct {
TotalCount int `json:"total_count"`
Page int `json:"page"`
PerPage int `json:"per_page"`
PageCount int `json:"page_count"`
First int `json:"first"`
Last int `json:"last"`
}
slack-0.11.3/pins.go 0000664 0000000 0000000 00000004542 14307410331 0014172 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"errors"
"net/url"
)
type listPinsResponseFull struct {
Items []Item
Paging `json:"paging"`
SlackResponse
}
// AddPin pins an item in a channel
func (api *Client) AddPin(channel string, item ItemRef) error {
return api.AddPinContext(context.Background(), channel, item)
}
// AddPinContext pins an item in a channel with a custom context
func (api *Client) AddPinContext(ctx context.Context, channel string, item ItemRef) error {
values := url.Values{
"channel": {channel},
"token": {api.token},
}
if item.Timestamp != "" {
values.Set("timestamp", item.Timestamp)
}
if item.File != "" {
values.Set("file", item.File)
}
if item.Comment != "" {
values.Set("file_comment", item.Comment)
}
response := &SlackResponse{}
if err := api.postMethod(ctx, "pins.add", values, response); err != nil {
return err
}
return response.Err()
}
// RemovePin un-pins an item from a channel
func (api *Client) RemovePin(channel string, item ItemRef) error {
return api.RemovePinContext(context.Background(), channel, item)
}
// RemovePinContext un-pins an item from a channel with a custom context
func (api *Client) RemovePinContext(ctx context.Context, channel string, item ItemRef) error {
values := url.Values{
"channel": {channel},
"token": {api.token},
}
if item.Timestamp != "" {
values.Set("timestamp", item.Timestamp)
}
if item.File != "" {
values.Set("file", item.File)
}
if item.Comment != "" {
values.Set("file_comment", item.Comment)
}
response := &SlackResponse{}
if err := api.postMethod(ctx, "pins.remove", values, response); err != nil {
return err
}
return response.Err()
}
// ListPins returns information about the items a user reacted to.
func (api *Client) ListPins(channel string) ([]Item, *Paging, error) {
return api.ListPinsContext(context.Background(), channel)
}
// ListPinsContext returns information about the items a user reacted to with a custom context.
func (api *Client) ListPinsContext(ctx context.Context, channel string) ([]Item, *Paging, error) {
values := url.Values{
"channel": {channel},
"token": {api.token},
}
response := &listPinsResponseFull{}
err := api.postMethod(ctx, "pins.list", values, response)
if err != nil {
return nil, nil, err
}
if !response.Ok {
return nil, nil, errors.New(response.Error)
}
return response.Items, &response.Paging, nil
}
slack-0.11.3/pins_test.go 0000664 0000000 0000000 00000013233 14307410331 0015226 0 ustar 00root root 0000000 0000000 package slack
import (
"fmt"
"net/http"
"reflect"
"testing"
)
type pinsHandler struct {
gotParams map[string]string
response string
}
func newPinsHandler() *pinsHandler {
return &pinsHandler{
gotParams: make(map[string]string),
response: `{ "ok": true }`,
}
}
func (rh *pinsHandler) accumulateFormValue(k string, r *http.Request) {
if v := r.FormValue(k); v != "" {
rh.gotParams[k] = v
}
}
func (rh *pinsHandler) handler(w http.ResponseWriter, r *http.Request) {
rh.accumulateFormValue("channel", r)
rh.accumulateFormValue("count", r)
rh.accumulateFormValue("file", r)
rh.accumulateFormValue("file_comment", r)
rh.accumulateFormValue("page", r)
rh.accumulateFormValue("timestamp", r)
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(rh.response))
}
func TestSlack_AddPin(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
tests := []struct {
channel string
ref ItemRef
wantParams map[string]string
}{
{
"ChannelID",
NewRefToMessage("ChannelID", "123"),
map[string]string{
"channel": "ChannelID",
"timestamp": "123",
},
},
{
"ChannelID",
NewRefToFile("FileID"),
map[string]string{
"channel": "ChannelID",
"file": "FileID",
},
},
{
"ChannelID",
NewRefToComment("FileCommentID"),
map[string]string{
"channel": "ChannelID",
"file_comment": "FileCommentID",
},
},
}
var rh *pinsHandler
http.HandleFunc("/pins.add", func(w http.ResponseWriter, r *http.Request) { rh.handler(w, r) })
for i, test := range tests {
rh = newPinsHandler()
err := api.AddPin(test.channel, test.ref)
if err != nil {
t.Fatalf("%d: Unexpected error: %s", i, err)
}
if !reflect.DeepEqual(rh.gotParams, test.wantParams) {
t.Errorf("%d: Got params %#v, want %#v", i, rh.gotParams, test.wantParams)
}
}
}
func TestSlack_RemovePin(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
tests := []struct {
channel string
ref ItemRef
wantParams map[string]string
}{
{
"ChannelID",
NewRefToMessage("ChannelID", "123"),
map[string]string{
"channel": "ChannelID",
"timestamp": "123",
},
},
{
"ChannelID",
NewRefToFile("FileID"),
map[string]string{
"channel": "ChannelID",
"file": "FileID",
},
},
{
"ChannelID",
NewRefToComment("FileCommentID"),
map[string]string{
"channel": "ChannelID",
"file_comment": "FileCommentID",
},
},
}
var rh *pinsHandler
http.HandleFunc("/pins.remove", func(w http.ResponseWriter, r *http.Request) { rh.handler(w, r) })
for i, test := range tests {
rh = newPinsHandler()
err := api.RemovePin(test.channel, test.ref)
if err != nil {
t.Fatalf("%d: Unexpected error: %s", i, err)
}
if !reflect.DeepEqual(rh.gotParams, test.wantParams) {
t.Errorf("%d: Got params %#v, want %#v", i, rh.gotParams, test.wantParams)
}
}
}
func TestSlack_ListPins(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
rh := newPinsHandler()
http.HandleFunc("/pins.list", func(w http.ResponseWriter, r *http.Request) { rh.handler(w, r) })
rh.response = `{"ok": true,
"items": [
{
"type": "message",
"channel": "C1",
"message": {
"text": "hello",
"reactions": [
{
"name": "astonished",
"count": 3,
"users": [ "U1", "U2", "U3" ]
},
{
"name": "clock1",
"count": 3,
"users": [ "U1", "U2" ]
}
]
}
},
{
"type": "file",
"file": {
"name": "toy",
"reactions": [
{
"name": "clock1",
"count": 3,
"users": [ "U1", "U2" ]
}
]
}
},
{
"type": "file_comment",
"file": {
"name": "toy"
},
"comment": {
"comment": "cool toy",
"reactions": [
{
"name": "astonished",
"count": 3,
"users": [ "U1", "U2", "U3" ]
}
]
}
}
],
"paging": {
"count": 100,
"total": 4,
"page": 1,
"pages": 1
}}`
want := []Item{
NewMessageItem("C1", &Message{Msg: Msg{
Text: "hello",
Reactions: []ItemReaction{
{Name: "astonished", Count: 3, Users: []string{"U1", "U2", "U3"}},
{Name: "clock1", Count: 3, Users: []string{"U1", "U2"}},
},
}}),
NewFileItem(&File{Name: "toy"}),
NewFileCommentItem(&File{Name: "toy"}, &Comment{Comment: "cool toy"}),
}
wantParams := map[string]string{
"channel": "ChannelID",
}
got, paging, err := api.ListPins("ChannelID")
if err != nil {
t.Fatalf("Unexpected error: %s", err)
}
if !reflect.DeepEqual(got, want) {
t.Errorf("Got Pins %#v, want %#v", got, want)
for i, item := range got {
fmt.Printf("Item %d, Type: %s\n", i, item.Type)
fmt.Printf("Message %#v\n", item.Message)
fmt.Printf("File %#v\n", item.File)
fmt.Printf("Comment %#v\n", item.Comment)
}
}
if !reflect.DeepEqual(rh.gotParams, wantParams) {
t.Errorf("Got params %#v, want %#v", rh.gotParams, wantParams)
}
if reflect.DeepEqual(paging, Paging{}) {
t.Errorf("Want paging data, got empty struct")
}
}
slack-0.11.3/reactions.go 0000664 0000000 0000000 00000015420 14307410331 0015205 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"net/url"
"strconv"
)
// ItemReaction is the reactions that have happened on an item.
type ItemReaction struct {
Name string `json:"name"`
Count int `json:"count"`
Users []string `json:"users"`
}
// ReactedItem is an item that was reacted to, and the details of the
// reactions.
type ReactedItem struct {
Item
Reactions []ItemReaction
}
// GetReactionsParameters is the inputs to get reactions to an item.
type GetReactionsParameters struct {
Full bool
}
// NewGetReactionsParameters initializes the inputs to get reactions to an item.
func NewGetReactionsParameters() GetReactionsParameters {
return GetReactionsParameters{
Full: false,
}
}
type getReactionsResponseFull struct {
Type string
M struct {
Reactions []ItemReaction
} `json:"message"`
F struct {
Reactions []ItemReaction
} `json:"file"`
FC struct {
Reactions []ItemReaction
} `json:"comment"`
SlackResponse
}
func (res getReactionsResponseFull) extractReactions() []ItemReaction {
switch res.Type {
case "message":
return res.M.Reactions
case "file":
return res.F.Reactions
case "file_comment":
return res.FC.Reactions
}
return []ItemReaction{}
}
const (
DEFAULT_REACTIONS_USER = ""
DEFAULT_REACTIONS_COUNT = 100
DEFAULT_REACTIONS_PAGE = 1
DEFAULT_REACTIONS_FULL = false
)
// ListReactionsParameters is the inputs to find all reactions by a user.
type ListReactionsParameters struct {
User string
Count int
Page int
Full bool
}
// NewListReactionsParameters initializes the inputs to find all reactions
// performed by a user.
func NewListReactionsParameters() ListReactionsParameters {
return ListReactionsParameters{
User: DEFAULT_REACTIONS_USER,
Count: DEFAULT_REACTIONS_COUNT,
Page: DEFAULT_REACTIONS_PAGE,
Full: DEFAULT_REACTIONS_FULL,
}
}
type listReactionsResponseFull struct {
Items []struct {
Type string
Channel string
M struct {
*Message
} `json:"message"`
F struct {
*File
Reactions []ItemReaction
} `json:"file"`
FC struct {
*Comment
Reactions []ItemReaction
} `json:"comment"`
}
Paging `json:"paging"`
SlackResponse
}
func (res listReactionsResponseFull) extractReactedItems() []ReactedItem {
items := make([]ReactedItem, len(res.Items))
for i, input := range res.Items {
item := ReactedItem{}
item.Type = input.Type
switch input.Type {
case "message":
item.Channel = input.Channel
item.Message = input.M.Message
item.Reactions = input.M.Reactions
case "file":
item.File = input.F.File
item.Reactions = input.F.Reactions
case "file_comment":
item.File = input.F.File
item.Comment = input.FC.Comment
item.Reactions = input.FC.Reactions
}
items[i] = item
}
return items
}
// AddReaction adds a reaction emoji to a message, file or file comment.
func (api *Client) AddReaction(name string, item ItemRef) error {
return api.AddReactionContext(context.Background(), name, item)
}
// AddReactionContext adds a reaction emoji to a message, file or file comment with a custom context.
func (api *Client) AddReactionContext(ctx context.Context, name string, item ItemRef) error {
values := url.Values{
"token": {api.token},
}
if name != "" {
values.Set("name", name)
}
if item.Channel != "" {
values.Set("channel", item.Channel)
}
if item.Timestamp != "" {
values.Set("timestamp", item.Timestamp)
}
if item.File != "" {
values.Set("file", item.File)
}
if item.Comment != "" {
values.Set("file_comment", item.Comment)
}
response := &SlackResponse{}
if err := api.postMethod(ctx, "reactions.add", values, response); err != nil {
return err
}
return response.Err()
}
// RemoveReaction removes a reaction emoji from a message, file or file comment.
func (api *Client) RemoveReaction(name string, item ItemRef) error {
return api.RemoveReactionContext(context.Background(), name, item)
}
// RemoveReactionContext removes a reaction emoji from a message, file or file comment with a custom context.
func (api *Client) RemoveReactionContext(ctx context.Context, name string, item ItemRef) error {
values := url.Values{
"token": {api.token},
}
if name != "" {
values.Set("name", name)
}
if item.Channel != "" {
values.Set("channel", item.Channel)
}
if item.Timestamp != "" {
values.Set("timestamp", item.Timestamp)
}
if item.File != "" {
values.Set("file", item.File)
}
if item.Comment != "" {
values.Set("file_comment", item.Comment)
}
response := &SlackResponse{}
if err := api.postMethod(ctx, "reactions.remove", values, response); err != nil {
return err
}
return response.Err()
}
// GetReactions returns details about the reactions on an item.
func (api *Client) GetReactions(item ItemRef, params GetReactionsParameters) ([]ItemReaction, error) {
return api.GetReactionsContext(context.Background(), item, params)
}
// GetReactionsContext returns details about the reactions on an item with a custom context
func (api *Client) GetReactionsContext(ctx context.Context, item ItemRef, params GetReactionsParameters) ([]ItemReaction, error) {
values := url.Values{
"token": {api.token},
}
if item.Channel != "" {
values.Set("channel", item.Channel)
}
if item.Timestamp != "" {
values.Set("timestamp", item.Timestamp)
}
if item.File != "" {
values.Set("file", item.File)
}
if item.Comment != "" {
values.Set("file_comment", item.Comment)
}
if params.Full != DEFAULT_REACTIONS_FULL {
values.Set("full", strconv.FormatBool(params.Full))
}
response := &getReactionsResponseFull{}
if err := api.postMethod(ctx, "reactions.get", values, response); err != nil {
return nil, err
}
if err := response.Err(); err != nil {
return nil, err
}
return response.extractReactions(), nil
}
// ListReactions returns information about the items a user reacted to.
func (api *Client) ListReactions(params ListReactionsParameters) ([]ReactedItem, *Paging, error) {
return api.ListReactionsContext(context.Background(), params)
}
// ListReactionsContext returns information about the items a user reacted to with a custom context.
func (api *Client) ListReactionsContext(ctx context.Context, params ListReactionsParameters) ([]ReactedItem, *Paging, error) {
values := url.Values{
"token": {api.token},
}
if params.User != DEFAULT_REACTIONS_USER {
values.Add("user", params.User)
}
if params.Count != DEFAULT_REACTIONS_COUNT {
values.Add("count", strconv.Itoa(params.Count))
}
if params.Page != DEFAULT_REACTIONS_PAGE {
values.Add("page", strconv.Itoa(params.Page))
}
if params.Full != DEFAULT_REACTIONS_FULL {
values.Add("full", strconv.FormatBool(params.Full))
}
response := &listReactionsResponseFull{}
err := api.postMethod(ctx, "reactions.list", values, response)
if err != nil {
return nil, nil, err
}
if err := response.Err(); err != nil {
return nil, nil, err
}
return response.extractReactedItems(), &response.Paging, nil
}
slack-0.11.3/reactions_test.go 0000664 0000000 0000000 00000022643 14307410331 0016251 0 ustar 00root root 0000000 0000000 package slack
import (
"fmt"
"net/http"
"reflect"
"testing"
)
type reactionsHandler struct {
gotParams map[string]string
response string
}
func newReactionsHandler() *reactionsHandler {
return &reactionsHandler{
gotParams: make(map[string]string),
response: `{ "ok": true }`,
}
}
func (rh *reactionsHandler) accumulateFormValue(k string, r *http.Request) {
if v := r.FormValue(k); v != "" {
rh.gotParams[k] = v
}
}
func (rh *reactionsHandler) handler(w http.ResponseWriter, r *http.Request) {
rh.accumulateFormValue("channel", r)
rh.accumulateFormValue("count", r)
rh.accumulateFormValue("file", r)
rh.accumulateFormValue("file_comment", r)
rh.accumulateFormValue("full", r)
rh.accumulateFormValue("name", r)
rh.accumulateFormValue("page", r)
rh.accumulateFormValue("timestamp", r)
rh.accumulateFormValue("user", r)
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(rh.response))
}
func TestSlack_AddReaction(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
tests := []struct {
name string
ref ItemRef
wantParams map[string]string
}{
{
"thumbsup",
NewRefToMessage("ChannelID", "123"),
map[string]string{
"name": "thumbsup",
"channel": "ChannelID",
"timestamp": "123",
},
},
{
"thumbsup",
NewRefToFile("FileID"),
map[string]string{
"name": "thumbsup",
"file": "FileID",
},
},
{
"thumbsup",
NewRefToComment("FileCommentID"),
map[string]string{
"name": "thumbsup",
"file_comment": "FileCommentID",
},
},
}
var rh *reactionsHandler
http.HandleFunc("/reactions.add", func(w http.ResponseWriter, r *http.Request) { rh.handler(w, r) })
for i, test := range tests {
rh = newReactionsHandler()
err := api.AddReaction(test.name, test.ref)
if err != nil {
t.Fatalf("%d: Unexpected error: %s", i, err)
}
if !reflect.DeepEqual(rh.gotParams, test.wantParams) {
t.Errorf("%d: Got params %#v, want %#v", i, rh.gotParams, test.wantParams)
}
}
}
func TestSlack_RemoveReaction(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
tests := []struct {
name string
ref ItemRef
wantParams map[string]string
}{
{
"thumbsup",
NewRefToMessage("ChannelID", "123"),
map[string]string{
"name": "thumbsup",
"channel": "ChannelID",
"timestamp": "123",
},
},
{
"thumbsup",
NewRefToFile("FileID"),
map[string]string{
"name": "thumbsup",
"file": "FileID",
},
},
{
"thumbsup",
NewRefToComment("FileCommentID"),
map[string]string{
"name": "thumbsup",
"file_comment": "FileCommentID",
},
},
}
var rh *reactionsHandler
http.HandleFunc("/reactions.remove", func(w http.ResponseWriter, r *http.Request) { rh.handler(w, r) })
for i, test := range tests {
rh = newReactionsHandler()
err := api.RemoveReaction(test.name, test.ref)
if err != nil {
t.Fatalf("%d: Unexpected error: %s", i, err)
}
if !reflect.DeepEqual(rh.gotParams, test.wantParams) {
t.Errorf("%d: Got params %#v, want %#v", i, rh.gotParams, test.wantParams)
}
}
}
func TestSlack_GetReactions(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
tests := []struct {
ref ItemRef
params GetReactionsParameters
wantParams map[string]string
json string
wantReactions []ItemReaction
}{
{
NewRefToMessage("ChannelID", "123"),
GetReactionsParameters{},
map[string]string{
"channel": "ChannelID",
"timestamp": "123",
},
`{"ok": true,
"type": "message",
"message": {
"reactions": [
{
"name": "astonished",
"count": 3,
"users": [ "U1", "U2", "U3" ]
},
{
"name": "clock1",
"count": 3,
"users": [ "U1", "U2" ]
}
]
}}`,
[]ItemReaction{
{Name: "astonished", Count: 3, Users: []string{"U1", "U2", "U3"}},
{Name: "clock1", Count: 3, Users: []string{"U1", "U2"}},
},
},
{
NewRefToFile("FileID"),
GetReactionsParameters{Full: true},
map[string]string{
"file": "FileID",
"full": "true",
},
`{"ok": true,
"type": "file",
"file": {
"reactions": [
{
"name": "astonished",
"count": 3,
"users": [ "U1", "U2", "U3" ]
},
{
"name": "clock1",
"count": 3,
"users": [ "U1", "U2" ]
}
]
}}`,
[]ItemReaction{
{Name: "astonished", Count: 3, Users: []string{"U1", "U2", "U3"}},
{Name: "clock1", Count: 3, Users: []string{"U1", "U2"}},
},
},
{
NewRefToComment("FileCommentID"),
GetReactionsParameters{},
map[string]string{
"file_comment": "FileCommentID",
},
`{"ok": true,
"type": "file_comment",
"file": {},
"comment": {
"reactions": [
{
"name": "astonished",
"count": 3,
"users": [ "U1", "U2", "U3" ]
},
{
"name": "clock1",
"count": 3,
"users": [ "U1", "U2" ]
}
]
}}`,
[]ItemReaction{
{Name: "astonished", Count: 3, Users: []string{"U1", "U2", "U3"}},
{Name: "clock1", Count: 3, Users: []string{"U1", "U2"}},
},
},
}
var rh *reactionsHandler
http.HandleFunc("/reactions.get", func(w http.ResponseWriter, r *http.Request) { rh.handler(w, r) })
for i, test := range tests {
rh = newReactionsHandler()
rh.response = test.json
got, err := api.GetReactions(test.ref, test.params)
if err != nil {
t.Fatalf("%d: Unexpected error: %s", i, err)
}
if !reflect.DeepEqual(got, test.wantReactions) {
t.Errorf("%d: Got reaction %#v, want %#v", i, got, test.wantReactions)
}
if !reflect.DeepEqual(rh.gotParams, test.wantParams) {
t.Errorf("%d: Got params %#v, want %#v", i, rh.gotParams, test.wantParams)
}
}
}
func TestSlack_ListReactions(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
rh := newReactionsHandler()
http.HandleFunc("/reactions.list", func(w http.ResponseWriter, r *http.Request) { rh.handler(w, r) })
rh.response = `{"ok": true,
"items": [
{
"type": "message",
"channel": "C1",
"message": {
"text": "hello",
"reactions": [
{
"name": "astonished",
"count": 3,
"users": [ "U1", "U2", "U3" ]
},
{
"name": "clock1",
"count": 3,
"users": [ "U1", "U2" ]
}
]
}
},
{
"type": "file",
"file": {
"name": "toy",
"reactions": [
{
"name": "clock1",
"count": 3,
"users": [ "U1", "U2" ]
}
]
}
},
{
"type": "file_comment",
"file": {
"name": "toy"
},
"comment": {
"comment": "cool toy",
"reactions": [
{
"name": "astonished",
"count": 3,
"users": [ "U1", "U2", "U3" ]
}
]
}
}
],
"paging": {
"count": 100,
"total": 4,
"page": 1,
"pages": 1
}}`
want := []ReactedItem{
{
Item: NewMessageItem("C1", &Message{Msg: Msg{
Text: "hello",
Reactions: []ItemReaction{
{Name: "astonished", Count: 3, Users: []string{"U1", "U2", "U3"}},
{Name: "clock1", Count: 3, Users: []string{"U1", "U2"}},
},
}}),
Reactions: []ItemReaction{
{Name: "astonished", Count: 3, Users: []string{"U1", "U2", "U3"}},
{Name: "clock1", Count: 3, Users: []string{"U1", "U2"}},
},
},
{
Item: NewFileItem(&File{Name: "toy"}),
Reactions: []ItemReaction{
{Name: "clock1", Count: 3, Users: []string{"U1", "U2"}},
},
},
{
Item: NewFileCommentItem(&File{Name: "toy"}, &Comment{Comment: "cool toy"}),
Reactions: []ItemReaction{
{Name: "astonished", Count: 3, Users: []string{"U1", "U2", "U3"}},
},
},
}
wantParams := map[string]string{
"user": "User",
"count": "200",
"page": "2",
"full": "true",
}
params := NewListReactionsParameters()
params.User = "User"
params.Count = 200
params.Page = 2
params.Full = true
got, paging, err := api.ListReactions(params)
if err != nil {
t.Fatalf("Unexpected error: %s", err)
}
if !reflect.DeepEqual(got, want) {
t.Errorf("Got reaction %#v, want %#v", got, want)
for i, item := range got {
fmt.Printf("Item %d, Type: %s\n", i, item.Type)
fmt.Printf("Message %#v\n", item.Message)
fmt.Printf("File %#v\n", item.File)
fmt.Printf("Comment %#v\n", item.Comment)
fmt.Printf("Reactions %#v\n", item.Reactions)
}
}
if !reflect.DeepEqual(rh.gotParams, wantParams) {
t.Errorf("Got params %#v, want %#v", rh.gotParams, wantParams)
}
if reflect.DeepEqual(paging, Paging{}) {
t.Errorf("Want paging data, got empty struct")
}
}
slack-0.11.3/reminders.go 0000664 0000000 0000000 00000010020 14307410331 0015175 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"net/url"
)
type Reminder struct {
ID string `json:"id"`
Creator string `json:"creator"`
User string `json:"user"`
Text string `json:"text"`
Recurring bool `json:"recurring"`
Time int `json:"time"`
CompleteTS int `json:"complete_ts"`
}
type reminderResp struct {
SlackResponse
Reminder Reminder `json:"reminder"`
}
type remindersResp struct {
SlackResponse
Reminders []*Reminder `json:"reminders"`
}
func (api *Client) doReminder(ctx context.Context, path string, values url.Values) (*Reminder, error) {
response := &reminderResp{}
if err := api.postMethod(ctx, path, values, response); err != nil {
return nil, err
}
return &response.Reminder, response.Err()
}
func (api *Client) doReminders(ctx context.Context, path string, values url.Values) ([]*Reminder, error) {
response := &remindersResp{}
if err := api.postMethod(ctx, path, values, response); err != nil {
return nil, err
}
// create an array of pointers to reminders
var reminders = make([]*Reminder, 0, len(response.Reminders))
for _, reminder := range response.Reminders {
reminders = append(reminders, reminder)
}
return reminders, response.Err()
}
// ListReminders lists all the reminders created by or for the authenticated user
//
// See https://api.slack.com/methods/reminders.list
func (api *Client) ListReminders() ([]*Reminder, error) {
return api.ListRemindersContext(context.Background())
}
// ListRemindersContext lists all the reminders created by or for the authenticated user with a custom context
//
// For more details, see ListReminders documentation.
func (api *Client) ListRemindersContext(ctx context.Context) ([]*Reminder, error) {
values := url.Values{
"token": {api.token},
}
return api.doReminders(ctx, "reminders.list", values)
}
// AddChannelReminder adds a reminder for a channel.
//
// See https://api.slack.com/methods/reminders.add (NOTE: the ability to set
// reminders on a channel is currently undocumented but has been tested to
// work)
func (api *Client) AddChannelReminder(channelID, text, time string) (*Reminder, error) {
return api.AddChannelReminderContext(context.Background(), channelID, text, time)
}
// AddChannelReminderContext adds a reminder for a channel with a custom context
//
// For more details, see AddChannelReminder documentation.
func (api *Client) AddChannelReminderContext(ctx context.Context, channelID, text, time string) (*Reminder, error) {
values := url.Values{
"token": {api.token},
"text": {text},
"time": {time},
"channel": {channelID},
}
return api.doReminder(ctx, "reminders.add", values)
}
// AddUserReminder adds a reminder for a user.
//
// See https://api.slack.com/methods/reminders.add (NOTE: the ability to set
// reminders on a channel is currently undocumented but has been tested to
// work)
func (api *Client) AddUserReminder(userID, text, time string) (*Reminder, error) {
return api.AddUserReminderContext(context.Background(), userID, text, time)
}
// AddUserReminderContext adds a reminder for a user with a custom context
//
// For more details, see AddUserReminder documentation.
func (api *Client) AddUserReminderContext(ctx context.Context, userID, text, time string) (*Reminder, error) {
values := url.Values{
"token": {api.token},
"text": {text},
"time": {time},
"user": {userID},
}
return api.doReminder(ctx, "reminders.add", values)
}
// DeleteReminder deletes an existing reminder.
//
// See https://api.slack.com/methods/reminders.delete
func (api *Client) DeleteReminder(id string) error {
return api.DeleteReminderContext(context.Background(), id)
}
// DeleteReminderContext deletes an existing reminder with a custom context
//
// For more details, see DeleteReminder documentation.
func (api *Client) DeleteReminderContext(ctx context.Context, id string) error {
values := url.Values{
"token": {api.token},
"reminder": {id},
}
response := &SlackResponse{}
if err := api.postMethod(ctx, "reminders.delete", values, response); err != nil {
return err
}
return response.Err()
}
slack-0.11.3/reminders_test.go 0000664 0000000 0000000 00000011551 14307410331 0016246 0 ustar 00root root 0000000 0000000 package slack
import (
"bytes"
"io/ioutil"
"net/http"
"reflect"
"testing"
)
type remindersHandler struct {
gotParams map[string]string
}
func newRemindersHandler() *remindersHandler {
return &remindersHandler{
gotParams: make(map[string]string),
}
}
func (rh *remindersHandler) accumulateFormValue(k string, r *http.Request) {
if v := r.FormValue(k); v != "" {
rh.gotParams[k] = v
}
}
func (rh *remindersHandler) handler(w http.ResponseWriter, r *http.Request) {
rh.accumulateFormValue("channel", r)
rh.accumulateFormValue("user", r)
rh.accumulateFormValue("text", r)
rh.accumulateFormValue("time", r)
rh.accumulateFormValue("reminder", r)
w.Header().Set("Content-Type", "application/json")
if rh.gotParams["text"] == "trigger-error" || rh.gotParams["reminder"] == "trigger-error" {
w.Write([]byte(`{ "ok": false, "error": "oh no" }`))
} else {
w.Write([]byte(`{ "ok": true }`))
}
}
func TestSlack_AddReminder(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
tests := []struct {
chanID string
userID string
text string
time string
wantParams map[string]string
expectErr bool
}{
{
"someChannelID",
"",
"hello world",
"tomorrow at 9am",
map[string]string{
"text": "hello world",
"time": "tomorrow at 9am",
"channel": "someChannelID",
},
false,
},
{
"someChannelID",
"",
"trigger-error",
"tomorrow at 9am",
map[string]string{
"text": "trigger-error",
"time": "tomorrow at 9am",
"channel": "someChannelID",
},
true,
},
{
"",
"someUserID",
"hello world",
"tomorrow at 9am",
map[string]string{
"text": "hello world",
"time": "tomorrow at 9am",
"user": "someUserID",
},
false,
},
{
"",
"someUserID",
"trigger-error",
"tomorrow at 9am",
map[string]string{
"text": "trigger-error",
"time": "tomorrow at 9am",
"user": "someUserID",
},
true,
},
}
var rh *remindersHandler
http.HandleFunc("/reminders.add", func(w http.ResponseWriter, r *http.Request) { rh.handler(w, r) })
for i, test := range tests {
rh = newRemindersHandler()
var err error
if test.chanID != "" {
_, err = api.AddChannelReminder(test.chanID, test.text, test.time)
} else {
_, err = api.AddUserReminder(test.userID, test.text, test.time)
}
if test.expectErr == false && err != nil {
t.Fatalf("%d: Unexpected error: %s", i, err)
} else if test.expectErr == true && err == nil {
t.Fatalf("%d: Expected error but got none!", i)
}
if !reflect.DeepEqual(rh.gotParams, test.wantParams) {
t.Errorf("%d: Got params %#v, want %#v", i, rh.gotParams, test.wantParams)
}
}
}
func TestSlack_DeleteReminder(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
tests := []struct {
reminder string
wantParams map[string]string
expectErr bool
}{
{
"foo",
map[string]string{
"reminder": "foo",
},
false,
},
{
"trigger-error",
map[string]string{
"reminder": "trigger-error",
},
true,
},
}
var rh *remindersHandler
http.HandleFunc("/reminders.delete", func(w http.ResponseWriter, r *http.Request) { rh.handler(w, r) })
for i, test := range tests {
rh = newRemindersHandler()
err := api.DeleteReminder(test.reminder)
if test.expectErr == false && err != nil {
t.Fatalf("%d: Unexpected error: %s", i, err)
} else if test.expectErr == true && err == nil {
t.Fatalf("%d: Expected error but got none!", i)
}
if !reflect.DeepEqual(rh.gotParams, test.wantParams) {
t.Errorf("%d: Got params %#v, want %#v", i, rh.gotParams, test.wantParams)
}
}
}
type mockRemindersListHTTPClient struct{}
func (m *mockRemindersListHTTPClient) Do(*http.Request) (*http.Response, error) {
responseString := `{
"ok": true,
"reminders": [
{
"id": "Rm12345678",
"creator": "U18888888",
"user": "U18888888",
"text": "eat a banana",
"recurring": false,
"time": 1458678068,
"complete_ts": 0
},
{
"id": "Gm12345678",
"creator": "U18888888",
"user": "U18888888",
"text": "drink some water",
"recurring": false,
"time": 1458678090,
"complete_ts": 0
}
]
}`
return &http.Response{StatusCode: 200, Body: ioutil.NopCloser(bytes.NewBufferString(responseString))}, nil
}
func TestSlack_ListReminders(t *testing.T) {
expectedIDs := []string{"Rm12345678", "Gm12345678"}
once.Do(startServer)
api := &Client{
endpoint: "http://" + serverAddr + "/",
token: "testing-token",
httpclient: &mockRemindersListHTTPClient{},
}
reminders, err := api.ListReminders()
if err != nil {
t.Fatalf("Unexpected error: %s", err)
}
for i := range reminders {
if reminders[i].ID != expectedIDs[i] {
t.Fatalf("List Reminders data wasn't correctly populated: wanted %v, got %v", expectedIDs[i], reminders[i].ID)
}
}
}
slack-0.11.3/remotefiles.go 0000664 0000000 0000000 00000025373 14307410331 0015544 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"fmt"
"io"
"net/url"
"strconv"
"strings"
)
const (
DEFAULT_REMOTE_FILES_CHANNEL = ""
DEFAULT_REMOTE_FILES_TS_FROM = 0
DEFAULT_REMOTE_FILES_TS_TO = -1
DEFAULT_REMOTE_FILES_COUNT = 100
)
// RemoteFile contains all the information for a remote file
// For more details:
// https://api.slack.com/messaging/files/remote
type RemoteFile struct {
ID string `json:"id"`
Created JSONTime `json:"created"`
Timestamp JSONTime `json:"timestamp"`
Name string `json:"name"`
Title string `json:"title"`
Mimetype string `json:"mimetype"`
Filetype string `json:"filetype"`
PrettyType string `json:"pretty_type"`
User string `json:"user"`
Editable bool `json:"editable"`
Size int `json:"size"`
Mode string `json:"mode"`
IsExternal bool `json:"is_external"`
ExternalType string `json:"external_type"`
IsPublic bool `json:"is_public"`
PublicURLShared bool `json:"public_url_shared"`
DisplayAsBot bool `json:"display_as_bot"`
Username string `json:"username"`
URLPrivate string `json:"url_private"`
Permalink string `json:"permalink"`
CommentsCount int `json:"comments_count"`
IsStarred bool `json:"is_starred"`
Shares Share `json:"shares"`
Channels []string `json:"channels"`
Groups []string `json:"groups"`
IMs []string `json:"ims"`
ExternalID string `json:"external_id"`
ExternalURL string `json:"external_url"`
HasRichPreview bool `json:"has_rich_preview"`
}
// RemoteFileParameters contains required and optional parameters for a remote file.
//
// ExternalID is a user defined GUID, ExternalURL is where the remote file can be accessed,
// and Title is the name of the file.
//
// For more details:
// https://api.slack.com/methods/files.remote.add
type RemoteFileParameters struct {
ExternalID string // required
ExternalURL string // required
Title string // required
Filetype string
IndexableFileContents string
PreviewImage string
PreviewImageReader io.Reader
}
// ListRemoteFilesParameters contains arguments for the ListRemoteFiles method.
// For more details:
// https://api.slack.com/methods/files.remote.list
type ListRemoteFilesParameters struct {
Channel string
Cursor string
Limit int
TimestampFrom JSONTime
TimestampTo JSONTime
}
type remoteFileResponseFull struct {
RemoteFile `json:"file"`
Paging `json:"paging"`
Files []RemoteFile `json:"files"`
SlackResponse
}
func (api *Client) remoteFileRequest(ctx context.Context, path string, values url.Values) (*remoteFileResponseFull, error) {
response := &remoteFileResponseFull{}
err := api.postMethod(ctx, path, values, response)
if err != nil {
return nil, err
}
return response, response.Err()
}
// AddRemoteFile adds a remote file. Unlike regular files, remote files must be explicitly shared.
// For more details:
// https://api.slack.com/methods/files.remote.add
func (api *Client) AddRemoteFile(params RemoteFileParameters) (*RemoteFile, error) {
return api.AddRemoteFileContext(context.Background(), params)
}
// AddRemoteFileContext adds a remote file and setting a custom context
// For more details see the AddRemoteFile documentation.
func (api *Client) AddRemoteFileContext(ctx context.Context, params RemoteFileParameters) (remotefile *RemoteFile, err error) {
if params.ExternalID == "" || params.ExternalURL == "" || params.Title == "" {
return nil, ErrParametersMissing
}
response := &remoteFileResponseFull{}
values := url.Values{
"token": {api.token},
"external_id": {params.ExternalID},
"external_url": {params.ExternalURL},
"title": {params.Title},
}
if params.Filetype != "" {
values.Add("filetype", params.Filetype)
}
if params.IndexableFileContents != "" {
values.Add("indexable_file_contents", params.IndexableFileContents)
}
if params.PreviewImage != "" {
err = postLocalWithMultipartResponse(ctx, api.httpclient, api.endpoint+"files.remote.add", params.PreviewImage, "preview_image", api.token, values, response, api)
} else if params.PreviewImageReader != nil {
err = postWithMultipartResponse(ctx, api.httpclient, api.endpoint+"files.remote.add", "preview.png", "preview_image", api.token, values, params.PreviewImageReader, response, api)
} else {
response, err = api.remoteFileRequest(ctx, "files.remote.add", values)
}
if err != nil {
return nil, err
}
return &response.RemoteFile, response.Err()
}
// ListRemoteFiles retrieves all remote files according to the parameters given. Uses cursor based pagination.
// For more details:
// https://api.slack.com/methods/files.remote.list
func (api *Client) ListRemoteFiles(params ListRemoteFilesParameters) ([]RemoteFile, error) {
return api.ListRemoteFilesContext(context.Background(), params)
}
// ListRemoteFilesContext retrieves all remote files according to the parameters given with a custom context. Uses cursor based pagination.
// For more details see the ListRemoteFiles documentation.
func (api *Client) ListRemoteFilesContext(ctx context.Context, params ListRemoteFilesParameters) ([]RemoteFile, error) {
values := url.Values{
"token": {api.token},
}
if params.Channel != DEFAULT_REMOTE_FILES_CHANNEL {
values.Add("channel", params.Channel)
}
if params.TimestampFrom != DEFAULT_REMOTE_FILES_TS_FROM {
values.Add("ts_from", strconv.FormatInt(int64(params.TimestampFrom), 10))
}
if params.TimestampTo != DEFAULT_REMOTE_FILES_TS_TO {
values.Add("ts_to", strconv.FormatInt(int64(params.TimestampTo), 10))
}
if params.Limit != DEFAULT_REMOTE_FILES_COUNT {
values.Add("limit", strconv.Itoa(params.Limit))
}
if params.Cursor != "" {
values.Add("cursor", params.Cursor)
}
response, err := api.remoteFileRequest(ctx, "files.remote.list", values)
if err != nil {
return nil, err
}
params.Cursor = response.SlackResponse.ResponseMetadata.Cursor
return response.Files, nil
}
// GetRemoteFileInfo retrieves the complete remote file information.
// For more details:
// https://api.slack.com/methods/files.remote.info
func (api *Client) GetRemoteFileInfo(externalID, fileID string) (remotefile *RemoteFile, err error) {
return api.GetRemoteFileInfoContext(context.Background(), externalID, fileID)
}
// GetRemoteFileInfoContext retrieves the complete remote file information given with a custom context.
// For more details see the GetRemoteFileInfo documentation.
func (api *Client) GetRemoteFileInfoContext(ctx context.Context, externalID, fileID string) (remotefile *RemoteFile, err error) {
if fileID == "" && externalID == "" {
return nil, fmt.Errorf("either externalID or fileID is required")
}
if fileID != "" && externalID != "" {
return nil, fmt.Errorf("don't provide both externalID and fileID")
}
values := url.Values{
"token": {api.token},
}
if fileID != "" {
values.Add("file", fileID)
}
if externalID != "" {
values.Add("external_id", externalID)
}
response, err := api.remoteFileRequest(ctx, "files.remote.info", values)
if err != nil {
return nil, err
}
return &response.RemoteFile, err
}
// ShareRemoteFile shares a remote file to channels
// For more details:
// https://api.slack.com/methods/files.remote.share
func (api *Client) ShareRemoteFile(channels []string, externalID, fileID string) (file *RemoteFile, err error) {
return api.ShareRemoteFileContext(context.Background(), channels, externalID, fileID)
}
// ShareRemoteFileContext shares a remote file to channels with a custom context.
// For more details see the ShareRemoteFile documentation.
func (api *Client) ShareRemoteFileContext(ctx context.Context, channels []string, externalID, fileID string) (file *RemoteFile, err error) {
if channels == nil || len(channels) == 0 {
return nil, ErrParametersMissing
}
if fileID == "" && externalID == "" {
return nil, fmt.Errorf("either externalID or fileID is required")
}
values := url.Values{
"token": {api.token},
"channels": {strings.Join(channels, ",")},
}
if fileID != "" {
values.Add("file", fileID)
}
if externalID != "" {
values.Add("external_id", externalID)
}
response, err := api.remoteFileRequest(ctx, "files.remote.share", values)
if err != nil {
return nil, err
}
return &response.RemoteFile, err
}
// UpdateRemoteFile updates a remote file
// For more details:
// https://api.slack.com/methods/files.remote.update
func (api *Client) UpdateRemoteFile(fileID string, params RemoteFileParameters) (remotefile *RemoteFile, err error) {
return api.UpdateRemoteFileContext(context.Background(), fileID, params)
}
// UpdateRemoteFileContext updates a remote file with a custom context
// For more details see the UpdateRemoteFile documentation.
func (api *Client) UpdateRemoteFileContext(ctx context.Context, fileID string, params RemoteFileParameters) (remotefile *RemoteFile, err error) {
response := &remoteFileResponseFull{}
values := url.Values{
"token": {api.token},
}
if fileID != "" {
values.Add("file", fileID)
}
if params.ExternalID != "" {
values.Add("external_id", params.ExternalID)
}
if params.ExternalURL != "" {
values.Add("external_url", params.ExternalURL)
}
if params.Title != "" {
values.Add("title", params.Title)
}
if params.Filetype != "" {
values.Add("filetype", params.Filetype)
}
if params.IndexableFileContents != "" {
values.Add("indexable_file_contents", params.IndexableFileContents)
}
if params.PreviewImageReader != nil {
err = postWithMultipartResponse(ctx, api.httpclient, api.endpoint+"files.remote.update", "preview.png", "preview_image", api.token, values, params.PreviewImageReader, response, api)
} else {
response, err = api.remoteFileRequest(ctx, "files.remote.update", values)
}
if err != nil {
return nil, err
}
return &response.RemoteFile, response.Err()
}
// RemoveRemoteFile removes a remote file.
// For more details:
// https://api.slack.com/methods/files.remote.remove
func (api *Client) RemoveRemoteFile(externalID, fileID string) (err error) {
return api.RemoveRemoteFileContext(context.Background(), externalID, fileID)
}
// RemoveRemoteFileContext removes a remote file with a custom context
// For more information see the RemoveRemoteFiles documentation.
func (api *Client) RemoveRemoteFileContext(ctx context.Context, externalID, fileID string) (err error) {
if fileID == "" && externalID == "" {
return fmt.Errorf("either externalID or fileID is required")
}
if fileID != "" && externalID != "" {
return fmt.Errorf("don't provide both externalID and fileID")
}
values := url.Values{
"token": {api.token},
}
if fileID != "" {
values.Add("file", fileID)
}
if externalID != "" {
values.Add("external_id", externalID)
}
_, err = api.remoteFileRequest(ctx, "files.remote.remove", values)
return err
}
slack-0.11.3/remotefiles_test.go 0000664 0000000 0000000 00000015024 14307410331 0016573 0 ustar 00root root 0000000 0000000 package slack
import (
"encoding/json"
"net/http"
"strings"
"testing"
)
func addRemoteFileHandler(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
response, _ := json.Marshal(remoteFileResponseFull{
SlackResponse: SlackResponse{Ok: true}})
rw.Write(response)
}
func TestAddRemoteFile(t *testing.T) {
http.HandleFunc("/files.remote.add", addRemoteFileHandler)
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
params := RemoteFileParameters{
ExternalID: "externalID",
ExternalURL: "http://example.com/",
Title: "example",
}
if _, err := api.AddRemoteFile(params); err != nil {
t.Errorf("Unexpected error: %s", err)
}
}
func TestAddRemoteFileWithoutTitle(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
params := RemoteFileParameters{
ExternalID: "externalID",
ExternalURL: "http://example.com/",
}
if _, err := api.AddRemoteFile(params); err != ErrParametersMissing {
t.Errorf("Expected ErrParametersMissing. got %s", err)
}
}
func listRemoteFileHandler(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
response, _ := json.Marshal(remoteFileResponseFull{
SlackResponse: SlackResponse{Ok: true}})
rw.Write(response)
}
func TestListRemoteFile(t *testing.T) {
http.HandleFunc("/files.remote.list", listRemoteFileHandler)
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
params := ListRemoteFilesParameters{}
if _, err := api.ListRemoteFiles(params); err != nil {
t.Errorf("Unexpected error: %s", err)
}
}
func getRemoteFileInfoHandler(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
response, _ := json.Marshal(remoteFileResponseFull{
SlackResponse: SlackResponse{Ok: true}})
rw.Write(response)
}
func TestGetRemoteFileInfo(t *testing.T) {
http.HandleFunc("/files.remote.info", getRemoteFileInfoHandler)
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
if _, err := api.GetRemoteFileInfo("ExternalID", ""); err != nil {
t.Errorf("Unexpected error: %s", err)
}
}
func TestGetRemoteFileInfoWithoutID(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
_, err := api.GetRemoteFileInfo("", "")
if err == nil {
t.Fatal("Expected error when both externalID and fileID is not provided, instead got nil")
}
if !strings.Contains(err.Error(), "either externalID or fileID is required") {
t.Errorf("Error message should mention a required field")
}
}
func TestGetRemoteFileInfoWithFileIDAndExternalID(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
_, err := api.GetRemoteFileInfo("ExternalID", "FileID")
if err == nil {
t.Fatal("Expected error when both externalID and fileID are both provided, instead got nil")
}
if !strings.Contains(err.Error(), "don't provide both externalID and fileID") {
t.Errorf("Error message should mention don't providing both externalID and fileID")
}
}
func shareRemoteFileHandler(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
response, _ := json.Marshal(remoteFileResponseFull{
SlackResponse: SlackResponse{Ok: true}})
rw.Write(response)
}
func TestShareRemoteFile(t *testing.T) {
http.HandleFunc("/files.remote.share", shareRemoteFileHandler)
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
if _, err := api.ShareRemoteFile([]string{"channel"}, "ExternalID", ""); err != nil {
t.Errorf("Unexpected error: %s", err)
}
}
func TestShareRemoteFileWithoutChannels(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
if _, err := api.ShareRemoteFile([]string{}, "ExternalID", ""); err != ErrParametersMissing {
t.Errorf("Expected ErrParametersMissing. got %s", err)
}
}
func TestShareRemoteFileWithoutID(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
_, err := api.ShareRemoteFile([]string{"channel"}, "", "")
if err == nil {
t.Fatal("Expected error when both externalID and fileID is not provided, instead got nil")
}
if !strings.Contains(err.Error(), "either externalID or fileID is required") {
t.Errorf("Error message should mention a required field")
}
}
func updateRemoteFileHandler(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
response, _ := json.Marshal(remoteFileResponseFull{
SlackResponse: SlackResponse{Ok: true}})
rw.Write(response)
}
func TestUpdateRemoteFile(t *testing.T) {
http.HandleFunc("/files.remote.update", updateRemoteFileHandler)
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
params := RemoteFileParameters{
ExternalURL: "http://example.com/",
Title: "example",
}
if _, err := api.UpdateRemoteFile("fileID", params); err != nil {
t.Errorf("Unexpected error: %s", err)
}
}
func removeRemoteFileHandler(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
response, _ := json.Marshal(remoteFileResponseFull{
SlackResponse: SlackResponse{Ok: true}})
rw.Write(response)
}
func TestRemoveRemoteFile(t *testing.T) {
http.HandleFunc("/files.remote.remove", removeRemoteFileHandler)
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
if err := api.RemoveRemoteFile("ExternalID", ""); err != nil {
t.Errorf("Unexpected error: %s", err)
}
}
func TestRemoveRemoteFileWithoutID(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
err := api.RemoveRemoteFile("", "")
if err == nil {
t.Fatal("Expected error when both externalID and fileID is not provided, instead got nil")
}
if !strings.Contains(err.Error(), "either externalID or fileID is required") {
t.Errorf("Error message should mention a required field")
}
}
func TestRemoveRemoteFileWithFileIDAndExternalID(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
err := api.RemoveRemoteFile("ExternalID", "FileID")
if err == nil {
t.Fatal("Expected error when both externalID and fileID are both provided, instead got nil")
}
if !strings.Contains(err.Error(), "don't provide both externalID and fileID") {
t.Errorf("Error message should mention don't providing both externalID and fileID")
}
}
slack-0.11.3/rtm.go 0000664 0000000 0000000 00000010227 14307410331 0014020 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"net/url"
"sync"
"time"
"github.com/gorilla/websocket"
)
const (
websocketDefaultTimeout = 10 * time.Second
defaultPingInterval = 30 * time.Second
)
const (
rtmEventTypeAck = ""
rtmEventTypeHello = "hello"
rtmEventTypeGoodbye = "goodbye"
rtmEventTypePong = "pong"
rtmEventTypeDesktopNotification = "desktop_notification"
)
// StartRTM calls the "rtm.start" endpoint and returns the provided URL and the full Info block.
//
// To have a fully managed Websocket connection, use `NewRTM`, and call `ManageConnection()` on it.
func (api *Client) StartRTM() (info *Info, websocketURL string, err error) {
ctx, cancel := context.WithTimeout(context.Background(), websocketDefaultTimeout)
defer cancel()
return api.StartRTMContext(ctx)
}
// StartRTMContext calls the "rtm.start" endpoint and returns the provided URL and the full Info block with a custom context.
//
// To have a fully managed Websocket connection, use `NewRTM`, and call `ManageConnection()` on it.
func (api *Client) StartRTMContext(ctx context.Context) (info *Info, websocketURL string, err error) {
response := &infoResponseFull{}
err = api.postMethod(ctx, "rtm.start", url.Values{"token": {api.token}}, response)
if err != nil {
return nil, "", err
}
api.Debugln("Using URL:", response.Info.URL)
return &response.Info, response.Info.URL, response.Err()
}
// ConnectRTM calls the "rtm.connect" endpoint and returns the provided URL and the compact Info block.
//
// To have a fully managed Websocket connection, use `NewRTM`, and call `ManageConnection()` on it.
func (api *Client) ConnectRTM() (info *Info, websocketURL string, err error) {
ctx, cancel := context.WithTimeout(context.Background(), websocketDefaultTimeout)
defer cancel()
return api.ConnectRTMContext(ctx)
}
// ConnectRTMContext calls the "rtm.connect" endpoint and returns the
// provided URL and the compact Info block with a custom context.
//
// To have a fully managed Websocket connection, use `NewRTM`, and call `ManageConnection()` on it.
func (api *Client) ConnectRTMContext(ctx context.Context) (info *Info, websocketURL string, err error) {
response := &infoResponseFull{}
err = api.postMethod(ctx, "rtm.connect", url.Values{"token": {api.token}}, response)
if err != nil {
api.Debugf("Failed to connect to RTM: %s", err)
return nil, "", err
}
api.Debugln("Using URL:", response.Info.URL)
return &response.Info, response.Info.URL, response.Err()
}
// RTMOption options for the managed RTM.
type RTMOption func(*RTM)
// RTMOptionUseStart as of 11th July 2017 you should prefer setting this to false, see:
// https://api.slack.com/changelog/2017-04-start-using-rtm-connect-and-stop-using-rtm-start
func RTMOptionUseStart(b bool) RTMOption {
return func(rtm *RTM) {
rtm.useRTMStart = b
}
}
// RTMOptionDialer takes a gorilla websocket Dialer and uses it as the
// Dialer when opening the websocket for the RTM connection.
func RTMOptionDialer(d *websocket.Dialer) RTMOption {
return func(rtm *RTM) {
rtm.dialer = d
}
}
// RTMOptionPingInterval determines how often to deliver a ping message to slack.
func RTMOptionPingInterval(d time.Duration) RTMOption {
return func(rtm *RTM) {
rtm.pingInterval = d
rtm.resetDeadman()
}
}
// RTMOptionConnParams installs parameters to embed into the connection URL.
func RTMOptionConnParams(connParams url.Values) RTMOption {
return func(rtm *RTM) {
rtm.connParams = connParams
}
}
// NewRTM returns a RTM, which provides a fully managed connection to
// Slack's websocket-based Real-Time Messaging protocol.
func (api *Client) NewRTM(options ...RTMOption) *RTM {
result := &RTM{
Client: *api,
IncomingEvents: make(chan RTMEvent, 50),
outgoingMessages: make(chan OutgoingMessage, 20),
pingInterval: defaultPingInterval,
pingDeadman: time.NewTimer(deadmanDuration(defaultPingInterval)),
killChannel: make(chan bool),
disconnected: make(chan struct{}),
disconnectedm: &sync.Once{},
forcePing: make(chan bool),
idGen: NewSafeID(1),
mu: &sync.Mutex{},
}
for _, opt := range options {
opt(result)
}
return result
}
slack-0.11.3/search.go 0000664 0000000 0000000 00000010730 14307410331 0014462 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"net/url"
"strconv"
)
const (
DEFAULT_SEARCH_SORT = "score"
DEFAULT_SEARCH_SORT_DIR = "desc"
DEFAULT_SEARCH_HIGHLIGHT = false
DEFAULT_SEARCH_COUNT = 20
DEFAULT_SEARCH_PAGE = 1
)
type SearchParameters struct {
Sort string
SortDirection string
Highlight bool
Count int
Page int
}
type CtxChannel struct {
ID string `json:"id"`
Name string `json:"name"`
IsExtShared bool `json:"is_ext_shared"`
IsMPIM bool `json:"is_mpim"`
ISOrgShared bool `json:"is_org_shared"`
IsPendingExtShared bool `json:"is_pending_ext_shared"`
IsPrivate bool `json:"is_private"`
IsShared bool `json:"is_shared"`
}
type CtxMessage struct {
User string `json:"user"`
Username string `json:"username"`
Text string `json:"text"`
Timestamp string `json:"ts"`
Type string `json:"type"`
}
type SearchMessage struct {
Type string `json:"type"`
Channel CtxChannel `json:"channel"`
User string `json:"user"`
Username string `json:"username"`
Timestamp string `json:"ts"`
Blocks Blocks `json:"blocks,omitempty"`
Text string `json:"text"`
Permalink string `json:"permalink"`
Attachments []Attachment `json:"attachments"`
Previous CtxMessage `json:"previous"`
Previous2 CtxMessage `json:"previous_2"`
Next CtxMessage `json:"next"`
Next2 CtxMessage `json:"next_2"`
}
type SearchMessages struct {
Matches []SearchMessage `json:"matches"`
Paging `json:"paging"`
Pagination `json:"pagination"`
Total int `json:"total"`
}
type SearchFiles struct {
Matches []File `json:"matches"`
Paging `json:"paging"`
Pagination `json:"pagination"`
Total int `json:"total"`
}
type searchResponseFull struct {
Query string `json:"query"`
SearchMessages `json:"messages"`
SearchFiles `json:"files"`
SlackResponse
}
func NewSearchParameters() SearchParameters {
return SearchParameters{
Sort: DEFAULT_SEARCH_SORT,
SortDirection: DEFAULT_SEARCH_SORT_DIR,
Highlight: DEFAULT_SEARCH_HIGHLIGHT,
Count: DEFAULT_SEARCH_COUNT,
Page: DEFAULT_SEARCH_PAGE,
}
}
func (api *Client) _search(ctx context.Context, path, query string, params SearchParameters, files, messages bool) (response *searchResponseFull, error error) {
values := url.Values{
"token": {api.token},
"query": {query},
}
if params.Sort != DEFAULT_SEARCH_SORT {
values.Add("sort", params.Sort)
}
if params.SortDirection != DEFAULT_SEARCH_SORT_DIR {
values.Add("sort_dir", params.SortDirection)
}
if params.Highlight != DEFAULT_SEARCH_HIGHLIGHT {
values.Add("highlight", strconv.Itoa(1))
}
if params.Count != DEFAULT_SEARCH_COUNT {
values.Add("count", strconv.Itoa(params.Count))
}
if params.Page != DEFAULT_SEARCH_PAGE {
values.Add("page", strconv.Itoa(params.Page))
}
response = &searchResponseFull{}
err := api.postMethod(ctx, path, values, response)
if err != nil {
return nil, err
}
return response, response.Err()
}
func (api *Client) Search(query string, params SearchParameters) (*SearchMessages, *SearchFiles, error) {
return api.SearchContext(context.Background(), query, params)
}
func (api *Client) SearchContext(ctx context.Context, query string, params SearchParameters) (*SearchMessages, *SearchFiles, error) {
response, err := api._search(ctx, "search.all", query, params, true, true)
if err != nil {
return nil, nil, err
}
return &response.SearchMessages, &response.SearchFiles, nil
}
func (api *Client) SearchFiles(query string, params SearchParameters) (*SearchFiles, error) {
return api.SearchFilesContext(context.Background(), query, params)
}
func (api *Client) SearchFilesContext(ctx context.Context, query string, params SearchParameters) (*SearchFiles, error) {
response, err := api._search(ctx, "search.files", query, params, true, false)
if err != nil {
return nil, err
}
return &response.SearchFiles, nil
}
func (api *Client) SearchMessages(query string, params SearchParameters) (*SearchMessages, error) {
return api.SearchMessagesContext(context.Background(), query, params)
}
func (api *Client) SearchMessagesContext(ctx context.Context, query string, params SearchParameters) (*SearchMessages, error) {
response, err := api._search(ctx, "search.messages", query, params, false, true)
if err != nil {
return nil, err
}
return &response.SearchMessages, nil
}
slack-0.11.3/security.go 0000664 0000000 0000000 00000005071 14307410331 0015066 0 ustar 00root root 0000000 0000000 package slack
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"hash"
"net/http"
"strconv"
"strings"
"time"
)
// Signature headers
const (
hSignature = "X-Slack-Signature"
hTimestamp = "X-Slack-Request-Timestamp"
)
// SecretsVerifier contains the information needed to verify that the request comes from Slack
type SecretsVerifier struct {
d Debug
signature []byte
hmac hash.Hash
}
func unsafeSignatureVerifier(header http.Header, secret string) (_ SecretsVerifier, err error) {
var (
bsignature []byte
)
signature := header.Get(hSignature)
stimestamp := header.Get(hTimestamp)
if signature == "" || stimestamp == "" {
return SecretsVerifier{}, ErrMissingHeaders
}
if bsignature, err = hex.DecodeString(strings.TrimPrefix(signature, "v0=")); err != nil {
return SecretsVerifier{}, err
}
hash := hmac.New(sha256.New, []byte(secret))
if _, err = hash.Write([]byte(fmt.Sprintf("v0:%s:", stimestamp))); err != nil {
return SecretsVerifier{}, err
}
return SecretsVerifier{
signature: bsignature,
hmac: hash,
}, nil
}
// NewSecretsVerifier returns a SecretsVerifier object in exchange for an http.Header object and signing secret
func NewSecretsVerifier(header http.Header, secret string) (sv SecretsVerifier, err error) {
var (
timestamp int64
)
stimestamp := header.Get(hTimestamp)
if sv, err = unsafeSignatureVerifier(header, secret); err != nil {
return SecretsVerifier{}, err
}
if timestamp, err = strconv.ParseInt(stimestamp, 10, 64); err != nil {
return SecretsVerifier{}, err
}
diff := absDuration(time.Since(time.Unix(timestamp, 0)))
if diff > 5*time.Minute {
return SecretsVerifier{}, ErrExpiredTimestamp
}
return sv, err
}
func (v *SecretsVerifier) WithDebug(d Debug) *SecretsVerifier {
v.d = d
return v
}
func (v *SecretsVerifier) Write(body []byte) (n int, err error) {
return v.hmac.Write(body)
}
// Ensure compares the signature sent from Slack with the actual computed hash to judge validity
func (v SecretsVerifier) Ensure() error {
computed := v.hmac.Sum(nil)
// use hmac.Equal prevent leaking timing information.
if hmac.Equal(computed, v.signature) {
return nil
}
if v.d != nil && v.d.Debug() {
v.d.Debugln(fmt.Sprintf("Expected signing signature: %s, but computed: %s", hex.EncodeToString(v.signature), hex.EncodeToString(computed)))
}
return fmt.Errorf("Computed unexpected signature of: %s", hex.EncodeToString(computed))
}
func abs64(n int64) int64 {
y := n >> 63
return (n ^ y) - y
}
func absDuration(n time.Duration) time.Duration {
return time.Duration(abs64(int64(n)))
}
slack-0.11.3/security_test.go 0000664 0000000 0000000 00000006740 14307410331 0016131 0 ustar 00root root 0000000 0000000 package slack
import (
"io"
"log"
"net/http"
"testing"
)
const (
validSigningSecret = "e6b19c573432dcc6b075501d51b51bb8"
invalidSigningSecret = "e6b19c573432dcc6b075501d51b51boo"
validBody = `{"token":"aF5ynEYQH0dFN9imlgcADxDB","team_id":"XXXXXXXXX","api_app_id":"YYYYYYYYY","event":{"type":"app_mention","user":"AAAAAAAAA","text":"<@EEEEEEEEE> hello world","client_msg_id":"477cc591-ch73-a14z-4db8-g0cd76321bec","ts":"1531431954.000073","channel":"TTTTTTTTT","event_ts":"1531431954.000073"},"type":"event_callback","event_id":"TvBP7LRED7","event_time":1531431954,"authed_users":["EEEEEEEEE"]}`
invalidBody = `{"token":"12345678abcdefghlmnopqrs","team_id":"XXXXXXXXX","api_app_id":"YYYYYYYYY","event":{"type":"app_mention","user":"AAAAAAAAA","text":"<@EEEEEEEEE> hello world","client_msg_id":"477cc591-ch73-a14z-4db8-g0cd76321bec","ts":"1531431954.000073","channel":"TTTTTTTTT","event_ts":"1531431954.000073"},"type":"event_callback","event_id":"TvBP7LRED7","event_time":1531431954,"authed_users":["EEEEEEEEE"]}`
)
func newHeader(valid bool) http.Header {
h := http.Header{}
if valid {
h.Set("X-Slack-Signature", "v0=adada4ed31709aef585c2580ca3267678c6a8eaeb7e0c1aca3ee57b656886b2c")
h.Set("X-Slack-Request-Timestamp", "1531431954")
} else {
h.Set("X-Slack-Signature", "")
}
return h
}
func TestExpiredTimestamp(t *testing.T) {
_, err := NewSecretsVerifier(newHeader(true), "abcdefg12345")
if err == nil {
t.Fatal("expected an error but got none")
}
}
func TestUnsafeSignatureVerifier(t *testing.T) {
tests := []struct {
title string
header http.Header
signingSecret string
expectError bool
}{
{
title: "Testing with acceptable params",
header: newHeader(true),
signingSecret: "abcdefg12345",
expectError: false,
},
{
title: "Testing with unacceptable params",
header: newHeader(false),
signingSecret: "abcdefg12345",
expectError: true,
},
}
for _, test := range tests {
_, err := unsafeSignatureVerifier(test.header, test.signingSecret)
if !test.expectError && err != nil {
log.Fatalf("%s: Unexpected error: %s in test", test.title, err)
} else if test.expectError == true && err == nil {
log.Fatalf("Expected error but got none")
}
}
}
func TestEnsure(t *testing.T) {
tests := []struct {
title string
header http.Header
signingSecret string
body string
expectError bool
}{
{
title: "Testing with acceptable signing secret and valid body",
header: newHeader(true),
signingSecret: validSigningSecret,
body: validBody,
expectError: false,
},
{
title: "Testing with unacceptable signing secret and valid body",
header: newHeader(true),
signingSecret: invalidSigningSecret,
body: validBody,
expectError: true,
},
{
title: "Testing with acceptable signing secret and invalid body",
header: newHeader(true),
signingSecret: validSigningSecret,
body: invalidBody,
expectError: true,
},
}
for _, test := range tests {
sv, err := unsafeSignatureVerifier(test.header, test.signingSecret)
if err != nil {
t.Fatalf("unexpected error: %s", err)
}
io.WriteString(&sv, test.body)
err = sv.Ensure()
if !test.expectError && err != nil {
log.Fatalf("%s: Unexpected error: %s in test", test.title, err)
} else if test.expectError == true && err == nil {
log.Fatalf("Expected error but got none")
}
}
}
slack-0.11.3/slack.go 0000664 0000000 0000000 00000010027 14307410331 0014311 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"fmt"
"log"
"net/http"
"net/url"
"os"
)
const (
// APIURL of the slack api.
APIURL = "https://slack.com/api/"
// WEBAPIURLFormat ...
WEBAPIURLFormat = "https://%s.slack.com/api/users.admin.%s?t=%d"
)
// httpClient defines the minimal interface needed for an http.Client to be implemented.
type httpClient interface {
Do(*http.Request) (*http.Response, error)
}
// ResponseMetadata holds pagination metadata
type ResponseMetadata struct {
Cursor string `json:"next_cursor"`
Messages []string `json:"messages"`
Warnings []string `json:"warnings"`
}
func (t *ResponseMetadata) initialize() *ResponseMetadata {
if t != nil {
return t
}
return &ResponseMetadata{}
}
// AuthTestResponse ...
type AuthTestResponse struct {
URL string `json:"url"`
Team string `json:"team"`
User string `json:"user"`
TeamID string `json:"team_id"`
UserID string `json:"user_id"`
// EnterpriseID is only returned when an enterprise id present
EnterpriseID string `json:"enterprise_id,omitempty"`
BotID string `json:"bot_id"`
}
type authTestResponseFull struct {
SlackResponse
AuthTestResponse
}
// Client for the slack api.
type ParamOption func(*url.Values)
type Client struct {
token string
appLevelToken string
endpoint string
debug bool
log ilogger
httpclient httpClient
}
// Option defines an option for a Client
type Option func(*Client)
// OptionHTTPClient - provide a custom http client to the slack client.
func OptionHTTPClient(client httpClient) func(*Client) {
return func(c *Client) {
c.httpclient = client
}
}
// OptionDebug enable debugging for the client
func OptionDebug(b bool) func(*Client) {
return func(c *Client) {
c.debug = b
}
}
// OptionLog set logging for client.
func OptionLog(l logger) func(*Client) {
return func(c *Client) {
c.log = internalLog{logger: l}
}
}
// OptionAPIURL set the url for the client. only useful for testing.
func OptionAPIURL(u string) func(*Client) {
return func(c *Client) { c.endpoint = u }
}
// OptionAppLevelToken sets an app-level token for the client.
func OptionAppLevelToken(token string) func(*Client) {
return func(c *Client) { c.appLevelToken = token }
}
// New builds a slack client from the provided token and options.
func New(token string, options ...Option) *Client {
s := &Client{
token: token,
endpoint: APIURL,
httpclient: &http.Client{},
log: log.New(os.Stderr, "slack-go/slack", log.LstdFlags|log.Lshortfile),
}
for _, opt := range options {
opt(s)
}
return s
}
// AuthTest tests if the user is able to do authenticated requests or not
func (api *Client) AuthTest() (response *AuthTestResponse, error error) {
return api.AuthTestContext(context.Background())
}
// AuthTestContext tests if the user is able to do authenticated requests or not with a custom context
func (api *Client) AuthTestContext(ctx context.Context) (response *AuthTestResponse, err error) {
api.Debugf("Challenging auth...")
responseFull := &authTestResponseFull{}
err = api.postMethod(ctx, "auth.test", url.Values{"token": {api.token}}, responseFull)
if err != nil {
return nil, err
}
return &responseFull.AuthTestResponse, responseFull.Err()
}
// Debugf print a formatted debug line.
func (api *Client) Debugf(format string, v ...interface{}) {
if api.debug {
api.log.Output(2, fmt.Sprintf(format, v...))
}
}
// Debugln print a debug line.
func (api *Client) Debugln(v ...interface{}) {
if api.debug {
api.log.Output(2, fmt.Sprintln(v...))
}
}
// Debug returns if debug is enabled.
func (api *Client) Debug() bool {
return api.debug
}
// post to a slack web method.
func (api *Client) postMethod(ctx context.Context, path string, values url.Values, intf interface{}) error {
return postForm(ctx, api.httpclient, api.endpoint+path, values, intf, api)
}
// get a slack web method.
func (api *Client) getMethod(ctx context.Context, path string, token string, values url.Values, intf interface{}) error {
return getResource(ctx, api.httpclient, api.endpoint+path, token, values, intf, api)
}
slack-0.11.3/slack_test.go 0000664 0000000 0000000 00000000500 14307410331 0015343 0 ustar 00root root 0000000 0000000 package slack
import (
"log"
"net/http/httptest"
"sync"
)
const (
validToken = "testing-token"
)
var (
serverAddr string
once sync.Once
)
func startServer() {
server := httptest.NewServer(nil)
serverAddr = server.Listener.Addr().String()
log.Print("Test WebSocket server listening on ", serverAddr)
}
slack-0.11.3/slackevents/ 0000775 0000000 0000000 00000000000 14307410331 0015207 5 ustar 00root root 0000000 0000000 slack-0.11.3/slackevents/action_events.go 0000664 0000000 0000000 00000002365 14307410331 0020405 0 ustar 00root root 0000000 0000000 package slackevents
import (
"encoding/json"
"github.com/slack-go/slack"
)
type MessageActionResponse struct {
ResponseType string `json:"response_type"`
ReplaceOriginal bool `json:"replace_original"`
Text string `json:"text"`
}
type MessageActionEntity struct {
ID string `json:"id"`
Domain string `json:"domain"`
Name string `json:"name"`
}
type MessageAction struct {
Type string `json:"type"`
Actions []slack.AttachmentAction `json:"actions"`
CallbackID string `json:"callback_id"`
Team MessageActionEntity `json:"team"`
Channel MessageActionEntity `json:"channel"`
User MessageActionEntity `json:"user"`
ActionTimestamp json.Number `json:"action_ts"`
MessageTimestamp json.Number `json:"message_ts"`
AttachmentID json.Number `json:"attachment_id"`
Token string `json:"token"`
Message slack.Message `json:"message"`
OriginalMessage slack.Message `json:"original_message"`
ResponseURL string `json:"response_url"`
TriggerID string `json:"trigger_id"`
}
slack-0.11.3/slackevents/inner_events.go 0000664 0000000 0000000 00000054623 14307410331 0020247 0 ustar 00root root 0000000 0000000 // inner_events.go provides EventsAPI particular inner events
package slackevents
import (
"github.com/slack-go/slack"
)
// EventsAPIInnerEvent the inner event of a EventsAPI event_callback Event.
type EventsAPIInnerEvent struct {
Type string `json:"type"`
Data interface{}
}
// AppMentionEvent is an (inner) EventsAPI subscribable event.
type AppMentionEvent struct {
Type string `json:"type"`
User string `json:"user"`
Text string `json:"text"`
TimeStamp string `json:"ts"`
ThreadTimeStamp string `json:"thread_ts"`
Channel string `json:"channel"`
EventTimeStamp string `json:"event_ts"`
// When Message comes from a channel that is shared between workspaces
UserTeam string `json:"user_team,omitempty"`
SourceTeam string `json:"source_team,omitempty"`
// BotID is filled out when a bot triggers the app_mention event
BotID string `json:"bot_id,omitempty"`
}
// AppHomeOpenedEvent Your Slack app home was opened.
type AppHomeOpenedEvent struct {
Type string `json:"type"`
User string `json:"user"`
Channel string `json:"channel"`
EventTimeStamp string `json:"event_ts"`
Tab string `json:"tab"`
View slack.View `json:"view"`
}
// AppUninstalledEvent Your Slack app was uninstalled.
type AppUninstalledEvent struct {
Type string `json:"type"`
}
// ChannelCreatedEvent represents the Channel created event
type ChannelCreatedEvent struct {
Type string `json:"type"`
Channel ChannelCreatedInfo `json:"channel"`
EventTimestamp string `json:"event_ts"`
}
// ChannelDeletedEvent represents the Channel deleted event
type ChannelDeletedEvent struct {
Type string `json:"type"`
Channel string `json:"channel"`
EventTimestamp string `json:"event_ts"`
}
// ChannelArchiveEvent represents the Channel archive event
type ChannelArchiveEvent struct {
Type string `json:"type"`
Channel string `json:"channel"`
User string `json:"user"`
EventTimestamp string `json:"event_ts"`
}
// ChannelUnarchiveEvent represents the Channel unarchive event
type ChannelUnarchiveEvent struct {
Type string `json:"type"`
Channel string `json:"channel"`
User string `json:"user"`
EventTimestamp string `json:"event_ts"`
}
// ChannelLeftEvent represents the Channel left event
type ChannelLeftEvent struct {
Type string `json:"type"`
Channel string `json:"channel"`
EventTimestamp string `json:"event_ts"`
}
// ChannelRenameEvent represents the Channel rename event
type ChannelRenameEvent struct {
Type string `json:"type"`
Channel ChannelRenameInfo `json:"channel"`
EventTimestamp string `json:"event_ts"`
}
// ChannelIDChangedEvent represents the Channel identifier changed event
type ChannelIDChangedEvent struct {
Type string `json:"type"`
OldChannelID string `json:"old_channel_id"`
NewChannelID string `json:"new_channel_id"`
EventTimestamp string `json:"event_ts"`
}
// ChannelCreatedInfo represents the information associated with the Channel created event
type ChannelCreatedInfo struct {
ID string `json:"id"`
IsChannel bool `json:"is_channel"`
Name string `json:"name"`
Created int `json:"created"`
Creator string `json:"creator"`
}
// ChannelRenameInfo represents the information associated with the Channel rename event
type ChannelRenameInfo struct {
ID string `json:"id"`
Name string `json:"name"`
Created int `json:"created"`
}
// GroupDeletedEvent represents the Group deleted event
type GroupDeletedEvent struct {
Type string `json:"type"`
Channel string `json:"channel"`
EventTimestamp string `json:"event_ts"`
}
// GroupArchiveEvent represents the Group archive event
type GroupArchiveEvent struct {
Type string `json:"type"`
Channel string `json:"channel"`
EventTimestamp string `json:"event_ts"`
}
// GroupUnarchiveEvent represents the Group unarchive event
type GroupUnarchiveEvent struct {
Type string `json:"type"`
Channel string `json:"channel"`
EventTimestamp string `json:"event_ts"`
}
// GroupLeftEvent represents the Group left event
type GroupLeftEvent struct {
Type string `json:"type"`
Channel string `json:"channel"`
EventTimestamp string `json:"event_ts"`
}
// GroupRenameEvent represents the Group rename event
type GroupRenameEvent struct {
Type string `json:"type"`
Channel GroupRenameInfo `json:"channel"`
EventTimestamp string `json:"event_ts"`
}
// GroupRenameInfo represents the information associated with the Group rename event
type GroupRenameInfo struct {
ID string `json:"id"`
Name string `json:"name"`
Created int `json:"created"`
}
// GridMigrationFinishedEvent An enterprise grid migration has finished on this workspace.
type GridMigrationFinishedEvent struct {
Type string `json:"type"`
EnterpriseID string `json:"enterprise_id"`
}
// GridMigrationStartedEvent An enterprise grid migration has started on this workspace.
type GridMigrationStartedEvent struct {
Type string `json:"type"`
EnterpriseID string `json:"enterprise_id"`
}
// LinkSharedEvent A message was posted containing one or more links relevant to your application
type LinkSharedEvent struct {
Type string `json:"type"`
User string `json:"user"`
TimeStamp string `json:"ts"`
Channel string `json:"channel"`
// MessageTimeStamp can be both a numeric timestamp if the LinkSharedEvent corresponds to a sent
// message and (contrary to the field name) a uuid if the LinkSharedEvent is generated in the
// compose text area.
MessageTimeStamp string `json:"message_ts"`
ThreadTimeStamp string `json:"thread_ts"`
Links []sharedLinks `json:"links"`
EventTimestamp string `json:"event_ts"`
}
type sharedLinks struct {
Domain string `json:"domain"`
URL string `json:"url"`
}
// MessageEvent occurs when a variety of types of messages has been posted.
// Parse ChannelType to see which
// if ChannelType = "group", this is a private channel message
// if ChannelType = "channel", this message was sent to a channel
// if ChannelType = "im", this is a private message
// if ChannelType = "mim", A message was posted in a multiparty direct message channel
// TODO: Improve this so that it is not required to manually parse ChannelType
type MessageEvent struct {
// Basic Message Event - https://api.slack.com/events/message
ClientMsgID string `json:"client_msg_id"`
Type string `json:"type"`
User string `json:"user"`
Text string `json:"text"`
ThreadTimeStamp string `json:"thread_ts"`
TimeStamp string `json:"ts"`
Channel string `json:"channel"`
ChannelType string `json:"channel_type"`
EventTimeStamp string `json:"event_ts"`
// When Message comes from a channel that is shared between workspaces
UserTeam string `json:"user_team,omitempty"`
SourceTeam string `json:"source_team,omitempty"`
// Edited Message
Message *MessageEvent `json:"message,omitempty"`
PreviousMessage *MessageEvent `json:"previous_message,omitempty"`
Edited *Edited `json:"edited,omitempty"`
// Message Subtypes
SubType string `json:"subtype,omitempty"`
// bot_message (https://api.slack.com/events/message/bot_message)
BotID string `json:"bot_id,omitempty"`
Username string `json:"username,omitempty"`
Icons *Icon `json:"icons,omitempty"`
Upload bool `json:"upload"`
Files []File `json:"files"`
Attachments []slack.Attachment `json:"attachments,omitempty"`
// Root is the message that was broadcast to the channel when the SubType is
// thread_broadcast. If this is not a thread_broadcast message event, this
// value is nil.
Root *MessageEvent `json:"root"`
}
// MemberJoinedChannelEvent A member joined a public or private channel
type MemberJoinedChannelEvent struct {
Type string `json:"type"`
User string `json:"user"`
Channel string `json:"channel"`
ChannelType string `json:"channel_type"`
Team string `json:"team"`
Inviter string `json:"inviter"`
EventTimestamp string `json:"event_ts"`
}
// MemberLeftChannelEvent A member left a public or private channel
type MemberLeftChannelEvent struct {
Type string `json:"type"`
User string `json:"user"`
Channel string `json:"channel"`
ChannelType string `json:"channel_type"`
Team string `json:"team"`
EventTimestamp string `json:"event_ts"`
}
type pinEvent struct {
Type string `json:"type"`
User string `json:"user"`
Item Item `json:"item"`
Channel string `json:"channel_id"`
EventTimestamp string `json:"event_ts"`
HasPins bool `json:"has_pins,omitempty"`
}
type reactionEvent struct {
Type string `json:"type"`
User string `json:"user"`
Reaction string `json:"reaction"`
ItemUser string `json:"item_user"`
Item Item `json:"item"`
EventTimestamp string `json:"event_ts"`
}
// ReactionAddedEvent An reaction was added to a message - https://api.slack.com/events/reaction_added
type ReactionAddedEvent reactionEvent
// ReactionRemovedEvent An reaction was removed from a message - https://api.slack.com/events/reaction_removed
type ReactionRemovedEvent reactionEvent
// PinAddedEvent An item was pinned to a channel - https://api.slack.com/events/pin_added
type PinAddedEvent pinEvent
// PinRemovedEvent An item was unpinned from a channel - https://api.slack.com/events/pin_removed
type PinRemovedEvent pinEvent
type tokens struct {
Oauth []string `json:"oauth"`
Bot []string `json:"bot"`
}
// TeamJoinEvent A new member joined a workspace - https://api.slack.com/events/team_join
type TeamJoinEvent struct {
Type string `json:"type"`
User *slack.User `json:"user"`
EventTimestamp string `json:"event_ts"`
}
// TokensRevokedEvent APP's API tokens are revoked - https://api.slack.com/events/tokens_revoked
type TokensRevokedEvent struct {
Type string `json:"type"`
Tokens tokens `json:"tokens"`
EventTimestamp string `json:"event_ts"`
}
// EmojiChangedEvent is the event of custom emoji has been added or changed
type EmojiChangedEvent struct {
Type string `json:"type"`
Subtype string `json:"subtype"`
EventTimeStamp string `json:"event_ts"`
// filled out when custom emoji added
Name string `json:"name,omitempty"`
// filled out when custom emoji removed
Names []string `json:"names,omitempty"`
// filled out when custom emoji renamed
OldName string `json:"old_name,omitempty"`
NewName string `json:"new_name,omitempty"`
// filled out when custom emoji added or renamed
Value string `json:"value,omitempty"`
}
// WorkflowStepExecuteEvent is fired, if a workflow step of your app is invoked
type WorkflowStepExecuteEvent struct {
Type string `json:"type"`
CallbackID string `json:"callback_id"`
WorkflowStep EventWorkflowStep `json:"workflow_step"`
EventTimestamp string `json:"event_ts"`
}
// MessageMetadataPostedEvent is sent, if a message with metadata is posted
type MessageMetadataPostedEvent struct {
Type string `json:"type"`
AppId string `json:"app_id"`
BotId string `json:"bot_id"`
UserId string `json:"user_id"`
TeamId string `json:"team_id"`
ChannelId string `json:"channel_id"`
Metadata *slack.SlackMetadata `json:"metadata"`
MessageTimestamp string `json:"message_ts"`
EventTimestamp string `json:"event_ts"`
}
// MessageMetadataUpdatedEvent is sent, if a message with metadata is deleted
type MessageMetadataUpdatedEvent struct {
Type string `json:"type"`
ChannelId string `json:"channel_id"`
EventTimestamp string `json:"event_ts"`
PreviousMetadata *slack.SlackMetadata `json:"previous_metadata"`
AppId string `json:"app_id"`
BotId string `json:"bot_id"`
UserId string `json:"user_id"`
TeamId string `json:"team_id"`
MessageTimestamp string `json:"message_ts"`
Metadata *slack.SlackMetadata `json:"metadata"`
}
// MessageMetadataDeletedEvent is sent, if a message with metadata is deleted
type MessageMetadataDeletedEvent struct {
Type string `json:"type"`
ChannelId string `json:"channel_id"`
EventTimestamp string `json:"event_ts"`
PreviousMetadata *slack.SlackMetadata `json:"previous_metadata"`
AppId string `json:"app_id"`
BotId string `json:"bot_id"`
UserId string `json:"user_id"`
TeamId string `json:"team_id"`
MessageTimestamp string `json:"message_ts"`
DeletedTimestamp string `json:"deleted_ts"`
}
type EventWorkflowStep struct {
WorkflowStepExecuteID string `json:"workflow_step_execute_id"`
WorkflowID string `json:"workflow_id"`
WorkflowInstanceID string `json:"workflow_instance_id"`
StepID string `json:"step_id"`
Inputs *slack.WorkflowStepInputs `json:"inputs,omitempty"`
Outputs *[]slack.WorkflowStepOutput `json:"outputs,omitempty"`
}
// JSONTime exists so that we can have a String method converting the date
type JSONTime int64
// Comment contains all the information relative to a comment
type Comment struct {
ID string `json:"id,omitempty"`
Created JSONTime `json:"created,omitempty"`
Timestamp JSONTime `json:"timestamp,omitempty"`
User string `json:"user,omitempty"`
Comment string `json:"comment,omitempty"`
}
// File is a file upload
type File struct {
ID string `json:"id"`
Created int `json:"created"`
Timestamp int `json:"timestamp"`
Name string `json:"name"`
Title string `json:"title"`
Mimetype string `json:"mimetype"`
Filetype string `json:"filetype"`
PrettyType string `json:"pretty_type"`
User string `json:"user"`
Editable bool `json:"editable"`
Size int `json:"size"`
Mode string `json:"mode"`
IsExternal bool `json:"is_external"`
ExternalType string `json:"external_type"`
IsPublic bool `json:"is_public"`
PublicURLShared bool `json:"public_url_shared"`
DisplayAsBot bool `json:"display_as_bot"`
Username string `json:"username"`
URLPrivate string `json:"url_private"`
URLPrivateDownload string `json:"url_private_download"`
Thumb64 string `json:"thumb_64"`
Thumb80 string `json:"thumb_80"`
Thumb360 string `json:"thumb_360"`
Thumb360W int `json:"thumb_360_w"`
Thumb360H int `json:"thumb_360_h"`
Thumb480 string `json:"thumb_480"`
Thumb480W int `json:"thumb_480_w"`
Thumb480H int `json:"thumb_480_h"`
Thumb160 string `json:"thumb_160"`
Thumb720 string `json:"thumb_720"`
Thumb720W int `json:"thumb_720_w"`
Thumb720H int `json:"thumb_720_h"`
Thumb800 string `json:"thumb_800"`
Thumb800W int `json:"thumb_800_w"`
Thumb800H int `json:"thumb_800_h"`
Thumb960 string `json:"thumb_960"`
Thumb960W int `json:"thumb_960_w"`
Thumb960H int `json:"thumb_960_h"`
Thumb1024 string `json:"thumb_1024"`
Thumb1024W int `json:"thumb_1024_w"`
Thumb1024H int `json:"thumb_1024_h"`
ImageExifRotation int `json:"image_exif_rotation"`
OriginalW int `json:"original_w"`
OriginalH int `json:"original_h"`
Permalink string `json:"permalink"`
PermalinkPublic string `json:"permalink_public"`
}
// Edited is included when a Message is edited
type Edited struct {
User string `json:"user"`
TimeStamp string `json:"ts"`
}
// Icon is used for bot messages
type Icon struct {
IconURL string `json:"icon_url,omitempty"`
IconEmoji string `json:"icon_emoji,omitempty"`
}
// Item is any type of slack message - message, file, or file comment.
type Item struct {
Type string `json:"type"`
Channel string `json:"channel,omitempty"`
Message *ItemMessage `json:"message,omitempty"`
File *File `json:"file,omitempty"`
Comment *Comment `json:"comment,omitempty"`
Timestamp string `json:"ts,omitempty"`
}
// ItemMessage is the event message
type ItemMessage struct {
Type string `json:"type"`
User string `json:"user"`
Text string `json:"text"`
Timestamp string `json:"ts"`
PinnedTo []string `json:"pinned_to"`
ReplaceOriginal bool `json:"replace_original"`
DeleteOriginal bool `json:"delete_original"`
}
// IsEdited checks if the MessageEvent is caused by an edit
func (e MessageEvent) IsEdited() bool {
return e.Message != nil &&
e.Message.Edited != nil
}
type EventsAPIType string
const (
// AppMention is an Events API subscribable event
AppMention = EventsAPIType("app_mention")
// AppHomeOpened Your Slack app home was opened
AppHomeOpened = EventsAPIType("app_home_opened")
// AppUninstalled Your Slack app was uninstalled.
AppUninstalled = EventsAPIType("app_uninstalled")
// ChannelCreated is sent when a new channel is created.
ChannelCreated = EventsAPIType("channel_created")
// ChannelDeleted is sent when a channel is deleted.
ChannelDeleted = EventsAPIType("channel_deleted")
// ChannelArchive is sent when a channel is archived.
ChannelArchive = EventsAPIType("channel_archive")
// ChannelUnarchive is sent when a channel is unarchived.
ChannelUnarchive = EventsAPIType("channel_unarchive")
// ChannelLeft is sent when a channel is left.
ChannelLeft = EventsAPIType("channel_left")
// ChannelRename is sent when a channel is rename.
ChannelRename = EventsAPIType("channel_rename")
// ChannelIDChanged is sent when a channel identifier is changed.
ChannelIDChanged = EventsAPIType("channel_id_changed")
// GroupDeleted is sent when a group is deleted.
GroupDeleted = EventsAPIType("group_deleted")
// GroupArchive is sent when a group is archived.
GroupArchive = EventsAPIType("group_archive")
// GroupUnarchive is sent when a group is unarchived.
GroupUnarchive = EventsAPIType("group_unarchive")
// GroupLeft is sent when a group is left.
GroupLeft = EventsAPIType("group_left")
// GroupRename is sent when a group is renamed.
GroupRename = EventsAPIType("group_rename")
// GridMigrationFinished An enterprise grid migration has finished on this workspace.
GridMigrationFinished = EventsAPIType("grid_migration_finished")
// GridMigrationStarted An enterprise grid migration has started on this workspace.
GridMigrationStarted = EventsAPIType("grid_migration_started")
// LinkShared A message was posted containing one or more links relevant to your application
LinkShared = EventsAPIType("link_shared")
// Message A message was posted to a channel, private channel (group), im, or mim
Message = EventsAPIType("message")
// Member Joined Channel
MemberJoinedChannel = EventsAPIType("member_joined_channel")
// Member Left Channel
MemberLeftChannel = EventsAPIType("member_left_channel")
// PinAdded An item was pinned to a channel
PinAdded = EventsAPIType("pin_added")
// PinRemoved An item was unpinned from a channel
PinRemoved = EventsAPIType("pin_removed")
// ReactionAdded An reaction was added to a message
ReactionAdded = EventsAPIType("reaction_added")
// ReactionRemoved An reaction was removed from a message
ReactionRemoved = EventsAPIType("reaction_removed")
// TeamJoin A new user joined the workspace
TeamJoin = EventsAPIType("team_join")
// TokensRevoked APP's API tokes are revoked
TokensRevoked = EventsAPIType("tokens_revoked")
// EmojiChanged A custom emoji has been added or changed
EmojiChanged = EventsAPIType("emoji_changed")
// WorkflowStepExecute Happens, if a workflow step of your app is invoked
WorkflowStepExecute = EventsAPIType("workflow_step_execute")
// MessageMetadataPosted A message with metadata was posted
MessageMetadataPosted = EventsAPIType("message_metadata_posted")
// MessageMetadataPosted A message with metadata was updated
MessageMetadataUpdated = EventsAPIType("message_metadata_updated")
// MessageMetadataPosted A message with metadata was deleted
MessageMetadataDeleted = EventsAPIType("message_metadata_deleted")
)
// EventsAPIInnerEventMapping maps INNER Event API events to their corresponding struct
// implementations. The structs should be instances of the unmarshalling
// target for the matching event type.
var EventsAPIInnerEventMapping = map[EventsAPIType]interface{}{
AppMention: AppMentionEvent{},
AppHomeOpened: AppHomeOpenedEvent{},
AppUninstalled: AppUninstalledEvent{},
ChannelCreated: ChannelCreatedEvent{},
ChannelDeleted: ChannelDeletedEvent{},
ChannelArchive: ChannelArchiveEvent{},
ChannelUnarchive: ChannelUnarchiveEvent{},
ChannelLeft: ChannelLeftEvent{},
ChannelRename: ChannelRenameEvent{},
ChannelIDChanged: ChannelIDChangedEvent{},
GroupDeleted: GroupDeletedEvent{},
GroupArchive: GroupArchiveEvent{},
GroupUnarchive: GroupUnarchiveEvent{},
GroupLeft: GroupLeftEvent{},
GroupRename: GroupRenameEvent{},
GridMigrationFinished: GridMigrationFinishedEvent{},
GridMigrationStarted: GridMigrationStartedEvent{},
LinkShared: LinkSharedEvent{},
Message: MessageEvent{},
MemberJoinedChannel: MemberJoinedChannelEvent{},
MemberLeftChannel: MemberLeftChannelEvent{},
PinAdded: PinAddedEvent{},
PinRemoved: PinRemovedEvent{},
ReactionAdded: ReactionAddedEvent{},
ReactionRemoved: ReactionRemovedEvent{},
TeamJoin: TeamJoinEvent{},
TokensRevoked: TokensRevokedEvent{},
EmojiChanged: EmojiChangedEvent{},
WorkflowStepExecute: WorkflowStepExecuteEvent{},
MessageMetadataPosted: MessageMetadataPostedEvent{},
MessageMetadataUpdated: MessageMetadataUpdatedEvent{},
MessageMetadataDeleted: MessageMetadataDeletedEvent{},
}
slack-0.11.3/slackevents/inner_events_test.go 0000664 0000000 0000000 00000032764 14307410331 0021310 0 ustar 00root root 0000000 0000000 package slackevents
import (
"encoding/json"
"testing"
)
func TestAppMention(t *testing.T) {
rawE := []byte(`
{
"type": "app_mention",
"user": "U061F7AUR",
"text": "<@U0LAN0Z89> is it everything a river should be?",
"ts": "1515449522.000016",
"thread_ts": "1515449522.000016",
"channel": "C0LAN2Q65",
"event_ts": "1515449522000016",
"source_team": "T3MQV36V7",
"user_team": "T3MQV36V7",
"blah": "test"
}
`)
err := json.Unmarshal(rawE, &AppMentionEvent{})
if err != nil {
t.Error(err)
}
}
func TestAppUninstalled(t *testing.T) {
rawE := []byte(`
{
"type": "app_uninstalled"
}
`)
err := json.Unmarshal(rawE, &AppUninstalledEvent{})
if err != nil {
t.Error(err)
}
}
func TestGridMigrationFinishedEvent(t *testing.T) {
rawE := []byte(`
{
"type": "grid_migration_finished",
"enterprise_id": "EXXXXXXXX"
}
`)
err := json.Unmarshal(rawE, &GridMigrationFinishedEvent{})
if err != nil {
t.Error(err)
}
}
func TestGridMigrationStartedEvent(t *testing.T) {
rawE := []byte(`
{
"token": "XXYYZZ",
"team_id": "TXXXXXXXX",
"api_app_id": "AXXXXXXXXX",
"event": {
"type": "grid_migration_started",
"enterprise_id": "EXXXXXXXX"
},
"type": "event_callback",
"event_id": "EvXXXXXXXX",
"event_time": 1234567890
}
`)
err := json.Unmarshal(rawE, &GridMigrationStartedEvent{})
if err != nil {
t.Error(err)
}
}
func TestLinkSharedEvent(t *testing.T) {
rawE := []byte(`
{
"type": "link_shared",
"channel": "Cxxxxxx",
"user": "Uxxxxxxx",
"message_ts": "123456789.9875",
"thread_ts": "123456789.9876",
"links":
[
{
"domain": "example.com",
"url": "https://example.com/12345"
},
{
"domain": "example.com",
"url": "https://example.com/67890"
},
{
"domain": "another-example.com",
"url": "https://yet.another-example.com/v/abcde"
}
]
}
`)
err := json.Unmarshal(rawE, &LinkSharedEvent{})
if err != nil {
t.Error(err)
}
}
func TestLinkSharedComposerEvent(t *testing.T) {
rawE := []byte(`
{
"type": "link_shared",
"channel": "COMPOSER",
"is_bot_user_member": true,
"user": "Uxxxxxxx",
"message_ts": "Uxxxxxxx-909b5454-75f8-4ac4-b325-1b40e230bbd8-gryl3kb80b3wm49ihzoo35fyqoq08n2y",
"unfurl_id": "Uxxxxxxx-909b5454-75f8-4ac4-b325-1b40e230bbd8-gryl3kb80b3wm49ihzoo35fyqoq08n2y",
"source": "composer",
"links": [
{
"domain": "example.com",
"url": "https://example.com/12345"
},
{
"domain": "example.com",
"url": "https://example.com/67890"
},
{
"domain": "another-example.com",
"url": "https://yet.another-example.com/v/abcde"
}
]
}
`)
err := json.Unmarshal(rawE, &LinkSharedEvent{})
if err != nil {
t.Error(err)
}
}
func TestMessageEvent(t *testing.T) {
rawE := []byte(`
{
"client_msg_id": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
"type": "message",
"channel": "G024BE91L",
"user": "U2147483697",
"text": "Live long and prospect.",
"ts": "1355517523.000005",
"event_ts": "1355517523.000005",
"channel_type": "channel",
"source_team": "T3MQV36V7",
"user_team": "T3MQV36V7",
"message": {
"text": "To infinity and beyond.",
"edited": {
"user": "U2147483697",
"ts": "1355517524.000000"
}
},
"previous_message": {
"text": "Live long and prospect."
}
}
`)
err := json.Unmarshal(rawE, &MessageEvent{})
if err != nil {
t.Error(err)
}
}
func TestBotMessageEvent(t *testing.T) {
rawE := []byte(`
{
"type": "message",
"subtype": "bot_message",
"ts": "1358877455.000010",
"text": "Pushing is the answer",
"bot_id": "BB12033",
"username": "github",
"icons": {}
}
`)
err := json.Unmarshal(rawE, &MessageEvent{})
if err != nil {
t.Error(err)
}
}
func TestThreadBroadcastEvent(t *testing.T) {
rawE := []byte(`
{
"type": "message",
"subtype": "thread_broadcast",
"channel": "G024BE91L",
"user": "U2147483697",
"text": "Live long and prospect.",
"ts": "1355517523.000005",
"event_ts": "1355517523.000005",
"channel_type": "channel",
"source_team": "T3MQV36V7",
"user_team": "T3MQV36V7",
"message": {
"text": "To infinity and beyond.",
"root": {
"text": "To infinity and beyond.",
"ts": "1355517523.000005"
},
"edited": {
"user": "U2147483697",
"ts": "1355517524.000000"
}
},
"previous_message": {
"text": "Live long and prospect."
}
}
`)
var me MessageEvent
if err := json.Unmarshal(rawE, &me); err != nil {
t.Error(err)
}
if me.Root != nil {
t.Error("me.Root should be nil")
}
if me.Message.Root == nil {
t.Fatal("me.Message.Root is nil")
}
if me.Message.Root.TimeStamp != "1355517523.000005" {
t.Errorf("me.Message.Root.TimeStamp = %q, want %q", me.Root.TimeStamp, "1355517523.000005")
}
}
func TestMemberJoinedChannelEvent(t *testing.T) {
rawE := []byte(`
{
"type": "member_joined_channel",
"user": "W06GH7XHN",
"channel": "C0698JE0H",
"channel_type": "C",
"team": "T024BE7LD",
"inviter": "U123456789"
}
`)
err := json.Unmarshal(rawE, &MemberJoinedChannelEvent{})
if err != nil {
t.Error(err)
}
}
func TestMemberLeftChannelEvent(t *testing.T) {
rawE := []byte(`
{
"type": "member_left_channel",
"user": "W06GH7XHN",
"channel": "C0698JE0H",
"channel_type": "C",
"team": "T024BE7LD"
}
`)
err := json.Unmarshal(rawE, &MemberLeftChannelEvent{})
if err != nil {
t.Error(err)
}
}
func TestPinAdded(t *testing.T) {
rawE := []byte(`
{
"type": "pin_added",
"user": "U061F7AUR",
"item": {
"type": "message",
"channel":"C0LAN2Q65",
"message":{
"type":"message",
"user":"U061F7AUR",
"text": "<@U0LAN0Z89> is it everything a river should be?",
"ts":"1539904112.000100",
"pinned_to":["C0LAN2Q65"],
"replace_original":false,
"delete_original":false
}
},
"channel_id":"C0LAN2Q65",
"event_ts": "1515449522000016"
}
`)
err := json.Unmarshal(rawE, &PinAddedEvent{})
if err != nil {
t.Error(err)
}
}
func TestPinRemoved(t *testing.T) {
rawE := []byte(`
{
"type": "pin_removed",
"user": "U061F7AUR",
"item": {
"type": "message",
"channel":"C0LAN2Q65",
"message":{
"type":"message",
"user":"U061F7AUR",
"text": "<@U0LAN0Z89> is it everything a river should be?",
"ts":"1539904112.000100",
"pinned_to":["C0LAN2Q65"],
"replace_original":false,
"delete_original":false
}
},
"channel_id":"C0LAN2Q65",
"event_ts": "1515449522000016"
}
`)
err := json.Unmarshal(rawE, &PinRemovedEvent{})
if err != nil {
t.Error(err)
}
}
func TestTokensRevoked(t *testing.T) {
rawE := []byte(`
{
"type": "tokens_revoked",
"tokens": {
"oauth": [
"OUXXXXXXXX"
],
"bot": [
"BUXXXXXXXX"
]
}
}
`)
tre := TokensRevokedEvent{}
err := json.Unmarshal(rawE, &tre)
if err != nil {
t.Error(err)
}
if tre.Type != "tokens_revoked" {
t.Fail()
}
if len(tre.Tokens.Bot) != 1 || tre.Tokens.Bot[0] != "BUXXXXXXXX" {
t.Fail()
}
if len(tre.Tokens.Oauth) != 1 || tre.Tokens.Oauth[0] != "OUXXXXXXXX" {
t.Fail()
}
}
func TestEmojiChanged(t *testing.T) {
var (
ece EmojiChangedEvent
err error
)
// custom emoji added event
rawAddE := []byte(`
{
"type": "emoji_changed",
"subtype": "add",
"name": "picard_facepalm",
"value": "https://my.slack.com/emoji/picard_facepalm/db8e287430eaa459.gif",
"event_ts" : "1361482916.000004"
}
`)
ece = EmojiChangedEvent{}
err = json.Unmarshal(rawAddE, &ece)
if err != nil {
t.Error(err)
}
if ece.Subtype != "add" {
t.Fail()
}
if ece.Name != "picard_facepalm" {
t.Fail()
}
// emoji removed event
rawRemoveE := []byte(`
{
"type": "emoji_changed",
"subtype": "remove",
"names": ["picard_facepalm"],
"event_ts" : "1361482916.000004"
}
`)
ece = EmojiChangedEvent{}
err = json.Unmarshal(rawRemoveE, &ece)
if err != nil {
t.Error(err)
}
if ece.Subtype != "remove" {
t.Fail()
}
if len(ece.Names) != 1 {
t.Fail()
}
if ece.Names[0] != "picard_facepalm" {
t.Fail()
}
// custom emoji rename event
rawRenameE := []byte(`
{
"type": "emoji_changed",
"subtype": "rename",
"old_name": "grin",
"new_name": "cheese-grin",
"value": "https://my.slack.com/emoji/picard_facepalm/db8e287430eaa459.gif",
"event_ts" : "1361482916.000004"
}
`)
ece = EmojiChangedEvent{}
err = json.Unmarshal(rawRenameE, &ece)
if err != nil {
t.Error(err)
}
if ece.Subtype != "rename" {
t.Fail()
}
if ece.OldName != "grin" {
t.Fail()
}
if ece.NewName != "cheese-grin" {
t.Fail()
}
}
func TestWorkflowStepExecute(t *testing.T) {
// see: https://api.slack.com/events/workflow_step_execute
rawE := []byte(`
{
"type":"workflow_step_execute",
"callback_id":"open_ticket",
"workflow_step":{
"workflow_step_execute_id":"1036669284371.19077474947.c94bcf942e047298d21f89faf24f1326",
"workflow_id":"123456789012345678",
"workflow_instance_id":"987654321098765432",
"step_id":"12a345bc-1a23-4567-8b90-1234a567b8c9",
"inputs":{
"example-select-input":{
"value": "value-two",
"skip_variable_replacement": false
}
},
"outputs":[
]
},
"event_ts":"1643290847.766536"
}
`)
wse := WorkflowStepExecuteEvent{}
err := json.Unmarshal(rawE, &wse)
if err != nil {
t.Error(err)
}
if wse.Type != "workflow_step_execute" {
t.Fail()
}
if wse.CallbackID != "open_ticket" {
t.Fail()
}
if wse.WorkflowStep.WorkflowStepExecuteID != "1036669284371.19077474947.c94bcf942e047298d21f89faf24f1326" {
t.Fail()
}
if wse.WorkflowStep.WorkflowID != "123456789012345678" {
t.Fail()
}
if wse.WorkflowStep.WorkflowInstanceID != "987654321098765432" {
t.Fail()
}
if wse.WorkflowStep.StepID != "12a345bc-1a23-4567-8b90-1234a567b8c9" {
t.Fail()
}
if len(*wse.WorkflowStep.Inputs) == 0 {
t.Fail()
}
if inputElement, ok := (*wse.WorkflowStep.Inputs)["example-select-input"]; ok {
if inputElement.Value != "value-two" {
t.Fail()
}
if inputElement.SkipVariableReplacement != false {
t.Fail()
}
}
}
func TestMessageMetadataPosted(t *testing.T) {
rawE := []byte(`
{
"type":"message_metadata_posted",
"app_id":"APPXXX",
"bot_id":"BOTXXX",
"user_id":"USERXXX",
"team_id":"TEAMXXX",
"channel_id":"CHANNELXXX",
"metadata":{
"event_type":"type",
"event_payload":{"key": "value"}
},
"message_ts":"1660398079.756349",
"event_ts":"1660398079.756349"
}
`)
mmp := MessageMetadataPostedEvent{}
err := json.Unmarshal(rawE, &mmp)
if err != nil {
t.Error(err)
}
if mmp.Type != "message_metadata_posted" {
t.Fail()
}
if mmp.AppId != "APPXXX" {
t.Fail()
}
if mmp.BotId != "BOTXXX" {
t.Fail()
}
if mmp.UserId != "USERXXX" {
t.Fail()
}
if mmp.TeamId != "TEAMXXX" {
t.Fail()
}
if mmp.ChannelId != "CHANNELXXX" {
t.Fail()
}
if mmp.Metadata.EventType != "type" {
t.Fail()
}
payload := mmp.Metadata.EventPayload
if len(payload) <= 0 {
t.Fail()
}
if mmp.EventTimestamp != "1660398079.756349" {
t.Fail()
}
if mmp.MessageTimestamp != "1660398079.756349" {
t.Fail()
}
}
func TestMessageMetadataUpdated(t *testing.T) {
rawE := []byte(`
{
"type":"message_metadata_updated",
"channel_id":"CHANNELXXX",
"event_ts":"1660398079.756349",
"previous_metadata":{
"event_type":"type1",
"event_payload":{"key1": "value1"}
},
"app_id":"APPXXX",
"bot_id":"BOTXXX",
"user_id":"USERXXX",
"team_id":"TEAMXXX",
"message_ts":"1660398079.756349",
"metadata":{
"event_type":"type2",
"event_payload":{"key2": "value2"}
}
}
`)
mmp := MessageMetadataUpdatedEvent{}
err := json.Unmarshal(rawE, &mmp)
if err != nil {
t.Error(err)
}
if mmp.Type != "message_metadata_updated" {
t.Fail()
}
if mmp.ChannelId != "CHANNELXXX" {
t.Fail()
}
if mmp.EventTimestamp != "1660398079.756349" {
t.Fail()
}
if mmp.PreviousMetadata.EventType != "type1" {
t.Fail()
}
payload := mmp.PreviousMetadata.EventPayload
if len(payload) <= 0 {
t.Fail()
}
if mmp.AppId != "APPXXX" {
t.Fail()
}
if mmp.BotId != "BOTXXX" {
t.Fail()
}
if mmp.UserId != "USERXXX" {
t.Fail()
}
if mmp.TeamId != "TEAMXXX" {
t.Fail()
}
if mmp.MessageTimestamp != "1660398079.756349" {
t.Fail()
}
if mmp.Metadata.EventType != "type2" {
t.Fail()
}
payload = mmp.Metadata.EventPayload
if len(payload) <= 0 {
t.Fail()
}
}
func TestMessageMetadataDeleted(t *testing.T) {
rawE := []byte(`
{
"type":"message_metadata_deleted",
"channel_id":"CHANNELXXX",
"event_ts":"1660398079.756349",
"previous_metadata":{
"event_type":"type",
"event_payload":{"key": "value"}
},
"app_id":"APPXXX",
"bot_id":"BOTXXX",
"user_id":"USERXXX",
"team_id":"TEAMXXX",
"message_ts":"1660398079.756349",
"deleted_ts":"1660398079.756349"
}
`)
mmp := MessageMetadataDeletedEvent{}
err := json.Unmarshal(rawE, &mmp)
if err != nil {
t.Error(err)
}
if mmp.Type != "message_metadata_deleted" {
t.Fail()
}
if mmp.ChannelId != "CHANNELXXX" {
t.Fail()
}
if mmp.EventTimestamp != "1660398079.756349" {
t.Fail()
}
if mmp.PreviousMetadata.EventType != "type" {
t.Fail()
}
payload := mmp.PreviousMetadata.EventPayload
if len(payload) <= 0 {
t.Fail()
}
if mmp.AppId != "APPXXX" {
t.Fail()
}
if mmp.BotId != "BOTXXX" {
t.Fail()
}
if mmp.UserId != "USERXXX" {
t.Fail()
}
if mmp.TeamId != "TEAMXXX" {
t.Fail()
}
if mmp.MessageTimestamp != "1660398079.756349" {
t.Fail()
}
if mmp.DeletedTimestamp != "1660398079.756349" {
t.Fail()
}
}
slack-0.11.3/slackevents/outer_events.go 0000664 0000000 0000000 00000004664 14307410331 0020272 0 ustar 00root root 0000000 0000000 // outer_events.go provides EventsAPI particular outer events
package slackevents
import (
"encoding/json"
)
// EventsAPIEvent is the base EventsAPIEvent
type EventsAPIEvent struct {
Token string `json:"token"`
TeamID string `json:"team_id"`
Type string `json:"type"`
APIAppID string `json:"api_app_id"`
EnterpriseID string `json:"enterprise_id"`
Data interface{}
InnerEvent EventsAPIInnerEvent
}
// EventsAPIURLVerificationEvent received when configuring a EventsAPI driven app
type EventsAPIURLVerificationEvent struct {
Token string `json:"token"`
Challenge string `json:"challenge"`
Type string `json:"type"`
}
// ChallengeResponse is a response to a EventsAPIEvent URLVerification challenge
type ChallengeResponse struct {
Challenge string
}
// EventsAPICallbackEvent is the main (outer) EventsAPI event.
type EventsAPICallbackEvent struct {
Type string `json:"type"`
Token string `json:"token"`
TeamID string `json:"team_id"`
APIAppID string `json:"api_app_id"`
InnerEvent *json.RawMessage `json:"event"`
AuthedUsers []string `json:"authed_users"`
AuthedTeams []string `json:"authed_teams"`
EventID string `json:"event_id"`
EventTime int `json:"event_time"`
EventContext string `json:"event_context"`
}
// EventsAPIAppRateLimited indicates your app's event subscriptions are being rate limited
type EventsAPIAppRateLimited struct {
Type string `json:"type"`
Token string `json:"token"`
TeamID string `json:"team_id"`
MinuteRateLimited int `json:"minute_rate_limited"`
APIAppID string `json:"api_app_id"`
}
const (
// CallbackEvent is the "outer" event of an EventsAPI event.
CallbackEvent = "event_callback"
// URLVerification is an event used when configuring your EventsAPI app
URLVerification = "url_verification"
// AppRateLimited indicates your app's event subscriptions are being rate limited
AppRateLimited = "app_rate_limited"
)
// EventsAPIEventMap maps OUTER Event API events to their corresponding struct
// implementations. The structs should be instances of the unmarshalling
// target for the matching event type.
var EventsAPIEventMap = map[string]interface{}{
CallbackEvent: EventsAPICallbackEvent{},
URLVerification: EventsAPIURLVerificationEvent{},
AppRateLimited: EventsAPIAppRateLimited{},
}
slack-0.11.3/slackevents/outer_events_test.go 0000664 0000000 0000000 00000002277 14307410331 0021327 0 ustar 00root root 0000000 0000000 package slackevents
import (
"encoding/json"
"testing"
)
func TestURLVerificationEvent(t *testing.T) {
rawE := []byte(`
{
"token": "Jhj5dZrVaK7ZwHHjRyZWjbDl",
"challenge": "3eZbrw1aBm2rZgRNFdxV2595E9CY3gmdALWMmHkvFXO7tYXAYM8P",
"type": "url_verification"
}
`)
err := json.Unmarshal(rawE, &EventsAPIURLVerificationEvent{})
if err != nil {
t.Error(err)
}
}
func TestCallBackEvent(t *testing.T) {
rawE := []byte(`
{
"token": "XXYYZZ",
"team_id": "TXXXXXXXX",
"api_app_id": "AXXXXXXXXX",
"event": {
"type": "app_mention",
"event_ts": "1234567890.123456",
"user": "UXXXXXXX1"
},
"type": "event_callback",
"authed_users": [ "UXXXXXXX1" ],
"event_id": "Ev08MFMKH6",
"event_time": 1234567890
}
`)
err := json.Unmarshal(rawE, &EventsAPICallbackEvent{})
if err != nil {
t.Error(err)
}
}
func TestAppRateLimitedEvent(t *testing.T) {
rawE := []byte(`
{
"token": "Jhj5dZrVaK7ZwHHjRyZWjbDl",
"type": "app_rate_limited",
"team_id": "T123456",
"minute_rate_limited": 1518467820,
"api_app_id": "A123456"
}
`)
err := json.Unmarshal(rawE, &EventsAPIAppRateLimited{})
if err != nil {
t.Error(err)
}
}
slack-0.11.3/slackevents/parsers.go 0000664 0000000 0000000 00000012673 14307410331 0017226 0 ustar 00root root 0000000 0000000 package slackevents
import (
"crypto/subtle"
"encoding/json"
"errors"
"fmt"
"reflect"
"github.com/slack-go/slack"
)
// eventsMap checks both slack.EventsMapping and
// and slackevents.EventsAPIInnerEventMapping. If the event
// exists, returns the unmarshalled struct instance of
// target for the matching event type.
// TODO: Consider moving all events into its own package?
func eventsMap(t string) (interface{}, bool) {
// Must parse EventsAPI FIRST as both RTM and EventsAPI
// have a type: "Message" event.
// TODO: Handle these cases more explicitly.
v, exists := EventsAPIInnerEventMapping[EventsAPIType(t)]
if exists {
return v, exists
}
v, exists = slack.EventMapping[t]
if exists {
return v, exists
}
return v, exists
}
func parseOuterEvent(rawE json.RawMessage) (EventsAPIEvent, error) {
e := &EventsAPIEvent{}
err := json.Unmarshal(rawE, e)
if err != nil {
return EventsAPIEvent{
"",
"",
"unmarshalling_error",
"",
"",
&slack.UnmarshallingErrorEvent{ErrorObj: err},
EventsAPIInnerEvent{},
}, err
}
if e.Type == CallbackEvent {
cbEvent := &EventsAPICallbackEvent{}
err = json.Unmarshal(rawE, cbEvent)
if err != nil {
return EventsAPIEvent{
"",
"",
"unmarshalling_error",
"",
"",
&slack.UnmarshallingErrorEvent{ErrorObj: err},
EventsAPIInnerEvent{},
}, err
}
return EventsAPIEvent{
e.Token,
e.TeamID,
e.Type,
e.APIAppID,
e.EnterpriseID,
cbEvent,
EventsAPIInnerEvent{},
}, nil
}
urlVE := &EventsAPIURLVerificationEvent{}
err = json.Unmarshal(rawE, urlVE)
if err != nil {
return EventsAPIEvent{
"",
"",
"unmarshalling_error",
"",
"",
&slack.UnmarshallingErrorEvent{ErrorObj: err},
EventsAPIInnerEvent{},
}, err
}
return EventsAPIEvent{
e.Token,
e.TeamID,
e.Type,
e.APIAppID,
e.EnterpriseID,
urlVE,
EventsAPIInnerEvent{},
}, nil
}
func parseInnerEvent(e *EventsAPICallbackEvent) (EventsAPIEvent, error) {
iE := &slack.Event{}
rawInnerJSON := e.InnerEvent
err := json.Unmarshal(*rawInnerJSON, iE)
if err != nil {
return EventsAPIEvent{
e.Token,
e.TeamID,
"unmarshalling_error",
e.APIAppID,
"",
&slack.UnmarshallingErrorEvent{ErrorObj: err},
EventsAPIInnerEvent{},
}, err
}
v, exists := eventsMap(iE.Type)
if !exists {
return EventsAPIEvent{
e.Token,
e.TeamID,
iE.Type,
e.APIAppID,
"",
nil,
EventsAPIInnerEvent{},
}, fmt.Errorf("Inner Event does not exist! %s", iE.Type)
}
t := reflect.TypeOf(v)
recvEvent := reflect.New(t).Interface()
err = json.Unmarshal(*rawInnerJSON, recvEvent)
if err != nil {
return EventsAPIEvent{
e.Token,
e.TeamID,
"unmarshalling_error",
e.APIAppID,
"",
&slack.UnmarshallingErrorEvent{ErrorObj: err},
EventsAPIInnerEvent{},
}, err
}
return EventsAPIEvent{
e.Token,
e.TeamID,
e.Type,
e.APIAppID,
"",
e,
EventsAPIInnerEvent{iE.Type, recvEvent},
}, nil
}
type Config struct {
VerificationToken string
TokenVerified bool
}
type Option func(cfg *Config)
type verifier interface {
Verify(token string) bool
}
func OptionVerifyToken(v verifier) Option {
return func(cfg *Config) {
cfg.TokenVerified = v.Verify(cfg.VerificationToken)
}
}
// OptionNoVerifyToken skips the check of the Slack verification token
func OptionNoVerifyToken() Option {
return func(cfg *Config) {
cfg.TokenVerified = true
}
}
type TokenComparator struct {
VerificationToken string
}
func (c TokenComparator) Verify(t string) bool {
return subtle.ConstantTimeCompare([]byte(c.VerificationToken), []byte(t)) == 1
}
// ParseEvent parses the outer and inner events (if applicable) of an events
// api event returning a EventsAPIEvent type. If the event is a url_verification event,
// the inner event is empty.
func ParseEvent(rawEvent json.RawMessage, opts ...Option) (EventsAPIEvent, error) {
e, err := parseOuterEvent(rawEvent)
if err != nil {
return EventsAPIEvent{}, err
}
cfg := &Config{}
cfg.VerificationToken = e.Token
for _, opt := range opts {
opt(cfg)
}
if !cfg.TokenVerified {
return EventsAPIEvent{}, errors.New("Invalid verification token")
}
if e.Type == CallbackEvent {
cbEvent := e.Data.(*EventsAPICallbackEvent)
innerEvent, err := parseInnerEvent(cbEvent)
if err != nil {
err := fmt.Errorf("EventsAPI Error parsing inner event: %s, %s", innerEvent.Type, err)
return EventsAPIEvent{
"",
"",
"unmarshalling_error",
"",
"",
&slack.UnmarshallingErrorEvent{ErrorObj: err},
EventsAPIInnerEvent{},
}, err
}
return innerEvent, nil
}
urlVerificationEvent := &EventsAPIURLVerificationEvent{}
err = json.Unmarshal(rawEvent, urlVerificationEvent)
if err != nil {
return EventsAPIEvent{
"",
"",
"unmarshalling_error",
"",
"",
&slack.UnmarshallingErrorEvent{ErrorObj: err},
EventsAPIInnerEvent{},
}, err
}
return EventsAPIEvent{
e.Token,
e.TeamID,
e.Type,
e.APIAppID,
e.EnterpriseID,
urlVerificationEvent,
EventsAPIInnerEvent{},
}, nil
}
func ParseActionEvent(payloadString string, opts ...Option) (MessageAction, error) {
byteString := []byte(payloadString)
action := MessageAction{}
err := json.Unmarshal(byteString, &action)
if err != nil {
return MessageAction{}, errors.New("MessageAction unmarshalling failed")
}
cfg := &Config{}
cfg.VerificationToken = action.Token
for _, opt := range opts {
opt(cfg)
}
if !cfg.TokenVerified {
return MessageAction{}, errors.New("invalid verification token")
} else {
return action, nil
}
}
slack-0.11.3/slackevents/parsers_test.go 0000664 0000000 0000000 00000005517 14307410331 0020264 0 ustar 00root root 0000000 0000000 package slackevents
import (
"encoding/json"
"fmt"
"testing"
"github.com/slack-go/slack"
)
func TestParserOuterCallBackEvent(t *testing.T) {
eventsAPIRawCallbackEvent := `
{
"token": "XXYYZZ",
"team_id": "TXXXXXXXX",
"api_app_id": "AXXXXXXXXX",
"event": {
"type": "app_mention",
"event_ts": "1234567890.123456",
"user": "UXXXXXXX1"
},
"type": "event_callback",
"authed_users": [ "UXXXXXXX1" ],
"event_id": "Ev08MFMKH6",
"event_time": 1234567890
}
`
msg, e := ParseEvent(json.RawMessage(eventsAPIRawCallbackEvent), OptionVerifyToken(&TokenComparator{"XXYYZZ"}))
if e != nil {
fmt.Println(e)
t.Fail()
}
switch ev := msg.Data.(type) {
case *EventsAPICallbackEvent:
{
}
case *slack.UnmarshallingErrorEvent:
{
fmt.Println("Unmarshalling Error!")
fmt.Println(ev)
t.Fail()
}
default:
{
fmt.Println(ev)
t.Fail()
}
}
}
func TestParseURLVerificationEvent(t *testing.T) {
urlVerificationEvent := `
{
"token": "fake-token",
"challenge": "aljdsflaji3jj",
"type": "url_verification"
}
`
msg, e := ParseEvent(json.RawMessage(urlVerificationEvent), OptionVerifyToken(&TokenComparator{"fake-token"}))
if e != nil {
fmt.Println(e)
t.Fail()
}
switch ev := msg.Data.(type) {
case *EventsAPIURLVerificationEvent:
{
}
default:
{
fmt.Println(ev)
t.Fail()
}
}
}
func TestThatOuterCallbackEventHasInnerEvent(t *testing.T) {
eventsAPIRawCallbackEvent := `
{
"token": "XXYYZZ",
"team_id": "TXXXXXXXX",
"api_app_id": "AXXXXXXXXX",
"event": {
"type": "app_mention",
"event_ts": "1234567890.123456",
"user": "UXXXXXXX1"
},
"type": "event_callback",
"authed_users": [ "UXXXXXXX1" ],
"event_id": "Ev08MFMKH6",
"event_time": 1234567890
}
`
msg, e := ParseEvent(json.RawMessage(eventsAPIRawCallbackEvent), OptionVerifyToken(&TokenComparator{"XXYYZZ"}))
if e != nil {
fmt.Println(e)
t.Fail()
}
switch outerEvent := msg.Data.(type) {
case *EventsAPICallbackEvent:
{
switch innerEvent := msg.InnerEvent.Data.(type) {
case *AppMentionEvent:
{
}
default:
fmt.Println(innerEvent)
t.Fail()
}
}
default:
{
fmt.Println(outerEvent)
t.Fail()
}
}
}
func TestBadTokenVerification(t *testing.T) {
urlVerificationEvent := `
{
"token": "fake-token",
"challenge": "aljdsflaji3jj",
"type": "url_verification"
}
`
_, e := ParseEvent(json.RawMessage(urlVerificationEvent), OptionVerifyToken(TokenComparator{"real-token"}))
if e == nil {
t.Fail()
}
}
func TestNoTokenVerification(t *testing.T) {
urlVerificationEvent := `
{
"token": "fake-token",
"challenge": "aljdsflaji3jj",
"type": "url_verification"
}
`
_, e := ParseEvent(json.RawMessage(urlVerificationEvent), OptionNoVerifyToken())
if e != nil {
fmt.Println(e)
t.Fail()
}
}
slack-0.11.3/slacktest/ 0000775 0000000 0000000 00000000000 14307410331 0014662 5 ustar 00root root 0000000 0000000 slack-0.11.3/slacktest/Makefile 0000664 0000000 0000000 00000001163 14307410331 0016323 0 ustar 00root root 0000000 0000000 EXAMPLES := $(shell find examples/ -maxdepth 1 -type d -exec sh -c 'echo $(basename {})' \;)
EXLIST := $(subst examples/,,$(EXAMPLES))
ifeq ($(TRAVIS_BUILD_DIR),)
GOPATH := $(GOPATH)
else
GOPATH := $(GOPATH):$(TRAVIS_BUILD_DIR)
endif
all: chmod clean lint test coverage $(EXLIST)
# this chmod is a side effect of some windows-development related issues
chmod:
chmod +x script/*
lint:
@script/lint
test:
@script/test
coverage:
@script/coverage
$(EXLIST):
@echo $@
@go test -v ./examples/$@
@gocov test ./examples/$@ | gocov report
clean:
@rm -rf bin/ pkg/
.PHONY: all chmod clean lint test coverage $(EXLIST)
slack-0.11.3/slacktest/README.md 0000664 0000000 0000000 00000002255 14307410331 0016145 0 ustar 00root root 0000000 0000000 # slacktest
This package was copied from https://github.com/lusis/slack-test for historical reasons.
This package's license is the following.
---
Copyright 2018 @lusis
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
slack-0.11.3/slacktest/data.go 0000664 0000000 0000000 00000014715 14307410331 0016132 0 ustar 00root root 0000000 0000000 package slacktest
import (
"fmt"
slack "github.com/slack-go/slack"
)
const defaultBotName = "TestSlackBot"
const defaultBotID = "U023BECGF"
const defaultTeamID = "T024BE7LD"
const defaultNonBotUserID = "W012A3CDE"
const defaultNonBotUserName = "Egon Spengler"
const defaultTeamName = "SlackTest Team"
const defaultTeamDomain = "testdomain"
const defaultConversationName = "endeavor"
var defaultCreatedTs = nowAsJSONTime()
var defaultTeam = &slack.Team{
ID: defaultTeamID,
Name: defaultTeamName,
Domain: defaultTeamDomain,
}
var defaultBotInfo = &slack.UserDetails{
ID: defaultBotID,
Name: defaultBotName,
Created: defaultCreatedTs,
ManualPresence: "true",
Prefs: slack.UserPrefs{},
}
var okWebResponse = slack.SlackResponse{
Ok: true,
}
var defaultOkJSON = fmt.Sprintf(`
{
"ok": true
}
`)
var defaultChannelsListJSON = fmt.Sprintf(`
{
"ok": true,
"channels": [%s, %s]
}
`, defaultGeneralChannelJSON, defaultExtraChannelJSON)
var defaultGroupsListJSON = fmt.Sprintf(`
{
"ok": true,
"groups": [%s]
}
`, defaultGroupJSON)
var defaultAuthTestJSON = fmt.Sprintf(`
{
"ok": true,
"url": "https://localhost.localdomain/",
"team": "%s",
"user": "%s",
"team_id": "%s",
"user_id": "%s"
}
`, defaultTeamName, defaultNonBotUserName, defaultTeamID, defaultNonBotUserID)
var defaultUsersInfoJSON = fmt.Sprintf(`
{
"ok":true,
%s
}
`, defaultNonBotUser)
var defaultGeneralChannelJSON = fmt.Sprintf(`
{
"id": "C024BE91L",
"name": "general",
"is_channel": true,
"created": %d,
"creator": "%s",
"is_archived": false,
"is_general": true,
"members": [
"W012A3CDE"
],
"topic": {
"value": "Fun times",
"creator": "%s",
"last_set": %d
},
"purpose": {
"value": "This channel is for fun",
"creator": "%s",
"last_set": %d
},
"is_member": true
}
`, nowAsJSONTime(), defaultNonBotUserID, defaultNonBotUserID, nowAsJSONTime(), defaultNonBotUserID, nowAsJSONTime())
var defaultExtraChannelJSON = fmt.Sprintf(`
{
"id": "C024BE92L",
"name": "bot-playground",
"is_channel": true,
"created": %d,
"creator": "%s",
"is_archived": false,
"is_general": true,
"members": [
"W012A3CDE"
],
"topic": {
"value": "Fun times",
"creator": "%s",
"last_set": %d
},
"purpose": {
"value": "This channel is for fun",
"creator": "%s",
"last_set": %d
},
"is_member": true
}
`, nowAsJSONTime(), defaultNonBotUserID, defaultNonBotUserID, nowAsJSONTime(), defaultNonBotUserID, nowAsJSONTime())
var defaultGroupJSON = fmt.Sprintf(`{
"id": "G024BE91L",
"name": "secretplans",
"is_group": true,
"created": %d,
"creator": "%s",
"is_archived": false,
"members": [
"W012A3CDE"
],
"topic": {
"value": "Secret plans on hold",
"creator": "%s",
"last_set": %d
},
"purpose": {
"value": "Discuss secret plans that no-one else should know",
"creator": "%s",
"last_set": %d
}
}`, nowAsJSONTime(), defaultNonBotUserID, defaultNonBotUserID, nowAsJSONTime(), defaultNonBotUserID, nowAsJSONTime())
var defaultNonBotUser = fmt.Sprintf(`
"user": {
"id": "%s",
"team_id": "%s",
"name": "spengler",
"deleted": false,
"color": "9f69e7",
"real_name": "%s",
"tz": "America/Los_Angeles",
"tz_label": "Pacific Daylight Time",
"tz_offset": -25200,
"profile": {
"avatar_hash": "ge3b51ca72de",
"status_text": "Print is dead",
"status_emoji": ":books:",
"real_name": "%s",
"display_name": "spengler",
"real_name_normalized": "%s",
"display_name_normalized": "spengler",
"email": "spengler@ghostbusters.example.com",
"image_24": "https://localhost.localdomain/avatar/e3b51ca72dee4ef87916ae2b9240df50.jpg",
"image_32": "https://localhost.localdomain/avatar/e3b51ca72dee4ef87916ae2b9240df50.jpg",
"image_48": "https://localhost.localdomain/avatar/e3b51ca72dee4ef87916ae2b9240df50.jpg",
"image_72": "https://localhost.localdomain/avatar/e3b51ca72dee4ef87916ae2b9240df50.jpg",
"image_192": "https://localhost.localdomain/avatar/e3b51ca72dee4ef87916ae2b9240df50.jpg",
"image_512": "https://localhost.localdomain/avatar/e3b51ca72dee4ef87916ae2b9240df50.jpg",
"team": "%s"
},
"is_admin": true,
"is_owner": false,
"is_primary_owner": false,
"is_restricted": false,
"is_ultra_restricted": false,
"is_bot": false,
"is_stranger": false,
"updated": 1502138686,
"is_app_user": false,
"has_2fa": false,
"locale": "en-US"
}
`, defaultNonBotUserID, defaultTeamID, defaultNonBotUserName, defaultNonBotUserName, defaultNonBotUserName, defaultTeamID)
var templateConversationJSON = `
{
"ok": true,
"channel": {
"id": "C0EAQDV4Z",
"name": "%s",
"is_channel": true,
"is_group": false,
"is_im": false,
"created": %d,
"creator": "%s",
"is_archived": false,
"is_general": false,
"unlinked": 0,
"name_normalized": "%s",
"is_shared": false,
"is_ext_shared": false,
"is_org_shared": false,
"pending_shared": [],
"is_pending_ext_shared": false,
"is_member": true,
"is_private": false,
"is_mpim": false,
"last_read": "0000000000.000000",
"latest": null,
"unread_count": 0,
"unread_count_display": 0,
"topic": {
"value": "%s",
"creator": "%s",
"last_set": %d
},
"purpose": {
"value": "%s",
"creator": "%s",
"last_set": %d
},
"num_members": %d,
"previous_names": [],
"priority": 0
}
}`
var defaultConversationJSON = fmt.Sprintf(templateConversationJSON, defaultConversationName,
nowAsJSONTime(), defaultBotID, defaultConversationName, "", "", 0, "", "", 0, 0)
var conversionPurposeTopicJSON = fmt.Sprintf(templateConversationJSON, defaultConversationName,
nowAsJSONTime(), defaultBotID, defaultConversationName, "Apply topically for best effects", defaultBotID,
nowAsJSONTime(), "I didn't set this purpose on purpose!", defaultBotID, nowAsJSONTime(), 0)
var renameConversationJSON = fmt.Sprintf(templateConversationJSON, "newName",
nowAsJSONTime, defaultBotID, "newName", "", "", 0, "", "", 0, 0)
var inviteConversationJSON = fmt.Sprintf(templateConversationJSON, defaultConversationName,
nowAsJSONTime(), defaultBotID, defaultConversationName, "", "", 0, "", "", 0, 1)
slack-0.11.3/slacktest/errors.go 0000664 0000000 0000000 00000001133 14307410331 0016523 0 ustar 00root root 0000000 0000000 package slacktest
import (
"github.com/slack-go/slack/internal/errorsx"
)
const (
// ErrEmptyServerToHub is the error when attempting an empty server address to the hub
ErrEmptyServerToHub = errorsx.String("Unable to add an empty server address to hub")
// ErrPassedEmptyServerAddr is the error when being passed an empty server address
ErrPassedEmptyServerAddr = errorsx.String("Passed an empty server address")
// ErrNoQueuesRegisteredForServer is the error when there are no queues for a server in the hub
ErrNoQueuesRegisteredForServer = errorsx.String("No queues registered for server")
)
slack-0.11.3/slacktest/funcs.go 0000664 0000000 0000000 00000006504 14307410331 0016334 0 ustar 00root root 0000000 0000000 package slacktest
import (
"context"
"fmt"
"log"
"time"
websocket "github.com/gorilla/websocket"
slack "github.com/slack-go/slack"
)
func (sts *Server) queueForWebsocket(s, hubname string) {
channel, err := getHubForServer(hubname)
if err != nil {
log.Printf("Unable to get server's channels: %s", err.Error())
}
sts.seenOutboundMessages.Lock()
sts.seenOutboundMessages.messages = append(sts.seenOutboundMessages.messages, s)
sts.seenOutboundMessages.Unlock()
channel.sent <- s
}
func handlePendingMessages(c *websocket.Conn, hubname string) {
channel, err := getHubForServer(hubname)
if err != nil {
log.Printf("Unable to get server's channels: %s", err.Error())
return
}
for m := range channel.sent {
err := c.WriteMessage(websocket.TextMessage, []byte(m))
if err != nil {
log.Printf("error writing message to websocket: %s", err.Error())
continue
}
}
}
func (sts *Server) postProcessMessage(m, hubname string) {
channel, err := getHubForServer(hubname)
if err != nil {
log.Printf("Unable to get server's channels: %s", err.Error())
return
}
sts.seenInboundMessages.Lock()
sts.seenInboundMessages.messages = append(sts.seenInboundMessages.messages, m)
sts.seenInboundMessages.Unlock()
// send to firehose
channel.seen <- m
}
func newHub() *hub {
h := &hub{}
c := make(map[string]*messageChannels)
h.serverChannels = c
return h
}
func addServerToHub(s *Server, channels *messageChannels) error {
if s.ServerAddr == "" {
return ErrEmptyServerToHub
}
masterHub.Lock()
masterHub.serverChannels[s.ServerAddr] = channels
masterHub.Unlock()
return nil
}
func getHubForServer(serverAddr string) (*messageChannels, error) {
if serverAddr == "" {
return &messageChannels{}, ErrPassedEmptyServerAddr
}
masterHub.RLock()
defer masterHub.RUnlock()
channels, ok := masterHub.serverChannels[serverAddr]
if !ok {
return &messageChannels{}, ErrNoQueuesRegisteredForServer
}
return channels, nil
}
// BotNameFromContext returns the botname from a provided context
func BotNameFromContext(ctx context.Context) string {
botname, ok := ctx.Value(ServerBotNameContextKey).(string)
if !ok {
return defaultBotName
}
return botname
}
// BotIDFromContext returns the bot userid from a provided context
func BotIDFromContext(ctx context.Context) string {
botname, ok := ctx.Value(ServerBotIDContextKey).(string)
if !ok {
return defaultBotID
}
return botname
}
// generate a full rtminfo response for initial rtm connections
func generateRTMInfo(ctx context.Context, wsurl string) *fullInfoSlackResponse {
rtmInfo := slack.Info{
URL: wsurl,
Team: defaultTeam,
User: defaultBotInfo,
}
rtmInfo.User.ID = BotIDFromContext(ctx)
rtmInfo.User.Name = BotNameFromContext(ctx)
return &fullInfoSlackResponse{
rtmInfo,
okWebResponse,
}
}
func nowAsJSONTime() slack.JSONTime {
return slack.JSONTime(time.Now().Unix())
}
func defaultBotInfoJSON(ctx context.Context) string {
botid := BotIDFromContext(ctx)
botname := BotNameFromContext(ctx)
return fmt.Sprintf(`
{
"ok":true,
"bot":{
"id": "%s",
"app_id": "A4H1JB4AZ",
"deleted": false,
"name": "%s",
"icons": {
"image_36": "https://localhost.localdomain/img36.png",
"image_48": "https://localhost.localdomain/img48.png",
"image_72": "https://localhost.localdomain/img72.png"
}
}
}
`, botid, botname)
}
slack-0.11.3/slacktest/funcs_test.go 0000664 0000000 0000000 00000003742 14307410331 0017374 0 ustar 00root root 0000000 0000000 package slacktest
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
)
func TestGenerateDefaultRTMInfo(t *testing.T) {
wsurl := "ws://127.0.0.1:5555/ws"
ctx := context.TODO()
info := generateRTMInfo(ctx, wsurl)
assert.Equal(t, wsurl, info.URL)
assert.True(t, info.Ok)
assert.Equal(t, defaultBotID, info.User.ID)
assert.Equal(t, defaultBotName, info.User.Name)
assert.Equal(t, defaultTeamID, info.Team.ID)
assert.Equal(t, defaultTeamName, info.Team.Name)
assert.Equal(t, defaultTeamDomain, info.Team.Domain)
}
func TestCustomDefaultRTMInfo(t *testing.T) {
wsurl := "ws://127.0.0.1:5555/ws"
ctx := context.TODO()
ctx = context.WithValue(ctx, ServerBotIDContextKey, "U1234567890")
ctx = context.WithValue(ctx, ServerBotNameContextKey, "SomeTestBotThing")
info := generateRTMInfo(ctx, wsurl)
assert.Equal(t, wsurl, info.URL)
assert.True(t, info.Ok)
assert.Equal(t, "U1234567890", info.User.ID)
assert.Equal(t, "SomeTestBotThing", info.User.Name)
assert.Equal(t, defaultTeamID, info.Team.ID)
assert.Equal(t, defaultTeamName, info.Team.Name)
assert.Equal(t, defaultTeamDomain, info.Team.Domain)
}
func TestGetHubMissingServerAddr(t *testing.T) {
mc, err := getHubForServer("")
assert.Nil(t, mc.seen, "seen should be nil")
assert.Nil(t, mc.sent, "sent should be nil")
assert.Nil(t, mc.posted, "posted should be nil")
assert.Error(t, err, "should return an error")
assert.EqualError(t, err, ErrPassedEmptyServerAddr.Error())
}
func TestGetHubNoQueuesForServer(t *testing.T) {
mc, err := getHubForServer("foo")
assert.Nil(t, mc.seen, "seen should be nil")
assert.Nil(t, mc.sent, "sent should be nil")
assert.Nil(t, mc.posted, "posted should be nil")
assert.Error(t, err, "should return an error")
assert.EqualError(t, err, ErrNoQueuesRegisteredForServer.Error())
}
func TestUnableToAddToHub(t *testing.T) {
err := addServerToHub(&Server{}, &messageChannels{})
assert.Error(t, err, "should return and error")
assert.EqualError(t, err, ErrEmptyServerToHub.Error())
}
slack-0.11.3/slacktest/handlers.go 0000664 0000000 0000000 00000023644 14307410331 0017022 0 ustar 00root root 0000000 0000000 package slacktest
import (
"context"
"encoding/json"
"fmt"
"io/ioutil"
"log"
"net/http"
"net/url"
"time"
websocket "github.com/gorilla/websocket"
slack "github.com/slack-go/slack"
)
func contextHandler(server *Server, next http.HandlerFunc) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx := context.WithValue(r.Context(), ServerURLContextKey, server.GetAPIURL())
ctx = context.WithValue(ctx, ServerWSContextKey, server.GetWSURL())
ctx = context.WithValue(ctx, ServerBotNameContextKey, server.BotName)
ctx = context.WithValue(ctx, ServerBotChannelsContextKey, server.GetChannels())
ctx = context.WithValue(ctx, ServerBotGroupsContextKey, server.GetGroups())
ctx = context.WithValue(ctx, ServerBotHubNameContextKey, server.ServerAddr)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
// handle auth.test
func authTestHandler(w http.ResponseWriter, _ *http.Request) {
_, _ = w.Write([]byte(defaultAuthTestJSON))
}
func usersInfoHandler(w http.ResponseWriter, _ *http.Request) {
_, _ = w.Write([]byte(defaultUsersInfoJSON))
}
func botsInfoHandler(w http.ResponseWriter, r *http.Request) {
_, _ = w.Write([]byte(defaultBotInfoJSON(r.Context())))
}
type GroupConversationResponse struct {
Ok bool `json:"ok"`
Channel slack.GroupConversation `json:"channel"`
}
func (sts *Server) conversationsInfoHandler(w http.ResponseWriter, r *http.Request) {
data, err := ioutil.ReadAll(r.Body)
if err != nil {
msg := fmt.Sprintf("error reading body: %s", err.Error())
log.Printf(msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
values, vErr := url.ParseQuery(string(data))
if vErr != nil {
msg := fmt.Sprintf("Unable to decode query params: %s", vErr.Error())
log.Printf(msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
ch := values.Get("channel")
response := GroupConversationResponse{
Ok: true,
Channel: slack.GroupConversation{
Conversation: slack.Conversation{
ID: ch,
},
// Since we don't join channels by name, only ID, let's strip the C prefix and use that as the name.
Name: ch[1:],
},
}
encoded, err := json.Marshal(&response)
if err != nil {
msg := fmt.Sprintf("Unable to encode response: %s", err.Error())
log.Printf(msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
_, _ = w.Write(encoded)
}
// handle conversations.create
func createConversationHandler(w http.ResponseWriter, r *http.Request) {
_, _ = w.Write([]byte(defaultConversationJSON))
}
// handle conversations.setTopic
func setConversationTopicHandler(w http.ResponseWriter, r *http.Request) {
_, _ = w.Write([]byte(conversionPurposeTopicJSON))
}
// handle conversations.setPurpose
func setConversationPurposeHandler(w http.ResponseWriter, r *http.Request) {
_, _ = w.Write([]byte(conversionPurposeTopicJSON))
}
// handle conversations.rename
func renameConversationHandler(w http.ResponseWriter, r *http.Request) {
_, _ = w.Write([]byte(renameConversationJSON))
}
// handle conversations.invite
func inviteConversationHandler(w http.ResponseWriter, r *http.Request) {
_, _ = w.Write([]byte(inviteConversationJSON))
}
// handle groups.list
func listGroupsHandler(w http.ResponseWriter, _ *http.Request) {
_, _ = w.Write([]byte(defaultGroupsListJSON))
}
// handle reaction.Add
func reactionAddHandler(w http.ResponseWriter, _ *http.Request) {
_, _ = w.Write([]byte(defaultOkJSON))
}
// handle chat.postMessage
func (sts *Server) postMessageHandler(w http.ResponseWriter, r *http.Request) {
serverAddr := r.Context().Value(ServerBotHubNameContextKey).(string)
data, err := ioutil.ReadAll(r.Body)
if err != nil {
msg := fmt.Sprintf("error reading body: %s", err.Error())
log.Printf(msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
values, vErr := url.ParseQuery(string(data))
if vErr != nil {
msg := fmt.Sprintf("Unable to decode query params: %s", vErr.Error())
log.Printf(msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
ts := time.Now().Unix()
resp := &struct {
Ok bool `json:"ok"`
Channel string `json:"channel"`
Ts string `json:"ts"`
Text string `json:"text"`
}{
Ok: true,
Channel: values.Get("channel"),
Ts: fmt.Sprintf("%d", ts),
Text: values.Get("text"),
}
m := slack.Message{}
m.Type = "message"
m.Channel = values.Get("channel")
m.Timestamp = fmt.Sprintf("%d", ts)
m.Text = values.Get("text")
m.ThreadTimestamp = values.Get("thread_ts")
if values.Get("as_user") != "true" {
m.User = defaultNonBotUserID
m.Username = defaultNonBotUserName
} else {
m.User = BotIDFromContext(r.Context())
m.Username = BotNameFromContext(r.Context())
}
attachments := values.Get("attachments")
if attachments != "" {
decoded, err := url.QueryUnescape(attachments)
if err != nil {
msg := fmt.Sprintf("Unable to decode attachments: %s", err.Error())
log.Printf(msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
var attaches []slack.Attachment
aJErr := json.Unmarshal([]byte(decoded), &attaches)
if aJErr != nil {
msg := fmt.Sprintf("Unable to decode attachments string to json: %s", aJErr.Error())
log.Printf(msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
m.Attachments = attaches
}
blocks := values.Get("blocks")
if blocks != "" {
decoded, err := url.QueryUnescape(blocks)
if err != nil {
msg := fmt.Sprintf("Unable to decode blocks: %s", err.Error())
log.Printf(msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
var decodedBlocks slack.Blocks
dbJErr := json.Unmarshal([]byte(decoded), &decodedBlocks)
if dbJErr != nil {
msg := fmt.Sprintf("Unable to decode blocks string to json: %s", dbJErr.Error())
log.Printf(msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
m.Blocks = decodedBlocks
}
jsonMessage, jsonErr := json.Marshal(m)
if jsonErr != nil {
msg := fmt.Sprintf("Unable to marshal message: %s", jsonErr.Error())
log.Printf(msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
go sts.queueForWebsocket(string(jsonMessage), serverAddr)
_ = json.NewEncoder(w).Encode(resp)
}
// RTMConnectHandler generates a valid connection
func RTMConnectHandler(w http.ResponseWriter, r *http.Request) {
_, err := ioutil.ReadAll(r.Body)
if err != nil {
msg := fmt.Sprintf("Error reading body: %s", err.Error())
log.Printf(msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
wsurl := r.Context().Value(ServerWSContextKey).(string)
if wsurl == "" {
msg := "missing webservice url from context"
log.Printf(msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
fullresponse := generateRTMInfo(r.Context(), wsurl)
j, jErr := json.Marshal(fullresponse)
if jErr != nil {
msg := fmt.Sprintf("Unable to marshal response: %s", jErr.Error())
log.Printf("Error: %s", msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
_, wErr := w.Write(j)
if wErr != nil {
log.Printf("Error writing response: %s", wErr.Error())
}
}
func rtmStartHandler(w http.ResponseWriter, r *http.Request) {
_, err := ioutil.ReadAll(r.Body)
if err != nil {
msg := fmt.Sprintf("Error reading body: %s", err.Error())
log.Printf(msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
wsurl := r.Context().Value(ServerWSContextKey).(string)
if wsurl == "" {
msg := "missing webservice url from context"
log.Printf(msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
fullresponse := generateRTMInfo(r.Context(), wsurl)
j, jErr := json.Marshal(fullresponse)
if jErr != nil {
msg := fmt.Sprintf("Unable to marshal response: %s", jErr.Error())
log.Printf("Error: %s", msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
_, wErr := w.Write(j)
if wErr != nil {
log.Printf("Error writing response: %s", wErr.Error())
}
}
func (sts *Server) wsHandler(w http.ResponseWriter, r *http.Request) {
Websocket(func(c *websocket.Conn) {
serverAddr := r.Context().Value(ServerBotHubNameContextKey).(string)
go handlePendingMessages(c, serverAddr)
for {
var (
err error
m json.RawMessage
mtype string
)
if mtype, m, err = RTMRespEventType(c); err != nil {
if websocket.IsUnexpectedCloseError(err) {
return
}
log.Printf("read error: %s", err.Error())
continue
}
switch mtype {
case "ping":
if err = RTMRespPong(c, m); err != nil {
log.Println("ping error:", err)
}
default:
sts.postProcessMessage(string(m), serverAddr)
}
}
})(w, r)
}
// Websocket handler
func Websocket(delegate func(c *websocket.Conn)) func(w http.ResponseWriter, r *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
upgrader := websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
CheckOrigin: func(r *http.Request) bool {
return true
},
}
c, err := upgrader.Upgrade(w, r, nil)
if err != nil {
msg := fmt.Sprintf("Unable to upgrade to ws connection: %s", err.Error())
log.Print(msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
defer func() { _ = c.Close() }()
delegate(c)
}
}
// RTMServerSendGoodbye send a goodbye event
func RTMServerSendGoodbye(c *websocket.Conn) error {
return c.WriteJSON(slack.Event{Type: "goodbye"})
}
// RTMRespEventType retrieve the event type from the next message
func RTMRespEventType(c *websocket.Conn) (t string, m json.RawMessage, err error) {
var (
evt slack.Event
)
if err = c.ReadJSON(&m); err != nil {
return "", m, err
}
if err = json.Unmarshal(m, &evt); err != nil {
return "", m, err
}
return evt.Type, m, nil
}
// RTMRespPong decode a ping and respond with a pong event.
func RTMRespPong(c *websocket.Conn, m json.RawMessage) (err error) {
var (
ping slack.Ping
pong slack.Pong
)
if err = json.Unmarshal(m, &ping); err != nil {
return err
}
pong = slack.Pong{
Type: "pong",
ReplyTo: ping.ID,
}
if err = c.WriteJSON(pong); err != nil {
return err
}
return nil
}
slack-0.11.3/slacktest/handlers_test.go 0000664 0000000 0000000 00000007716 14307410331 0020063 0 ustar 00root root 0000000 0000000 package slacktest
import (
"testing"
"github.com/stretchr/testify/assert"
slack "github.com/slack-go/slack"
)
func TestAuthTestHandler(t *testing.T) {
s := NewTestServer()
go s.Start()
client := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
user, err := client.AuthTest()
assert.NoError(t, err, "should not error out")
assert.Equal(t, defaultTeamName, user.Team, "user ID should be correct")
assert.Equal(t, defaultTeamID, user.TeamID, "user ID should be correct")
assert.Equal(t, defaultNonBotUserID, user.UserID, "user ID should be correct")
assert.Equal(t, defaultNonBotUserName, user.User, "user ID should be correct")
}
func TestPostMessageHandler(t *testing.T) {
s := NewTestServer()
go s.Start()
client := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
channel, tstamp, err := client.PostMessage("foo", slack.MsgOptionText("some text", false), slack.MsgOptionPostMessageParameters(slack.PostMessageParameters{}))
assert.NoError(t, err, "should not error out")
assert.Equal(t, "foo", channel, "channel should be correct")
assert.NotEmpty(t, tstamp, "timestamp should not be empty")
}
func TestServerCreateConversationHandler(t *testing.T) {
s := NewTestServer()
go s.Start()
client := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
conversation, err := client.CreateConversation("test", false)
assert.NoError(t, err)
assert.Equal(t, "C0EAQDV4Z", conversation.ID)
assert.Equal(t, "U023BECGF", conversation.Creator)
assert.Equal(t, "endeavor", conversation.Name)
}
func TestServerSetConversationTopicHandler(t *testing.T) {
s := NewTestServer()
go s.Start()
client := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
response, err := client.SetTopicOfConversation("test", "Apply topically for best effects")
assert.NoError(t, err)
assert.Equal(t, "Apply topically for best effects", response.Topic.Value)
assert.Equal(t, "U023BECGF", response.Topic.Creator)
assert.NotEmpty(t, response.Topic.LastSet)
}
func TestServerSetConversationPurposeHandler(t *testing.T) {
s := NewTestServer()
go s.Start()
client := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
response, err := client.SetPurposeOfConversation("test", "I didn't set this purpose on purpose!")
assert.NoError(t, err)
assert.Equal(t, "I didn't set this purpose on purpose!", response.Purpose.Value)
assert.Equal(t, "U023BECGF", response.Purpose.Creator)
assert.NotEmpty(t, response.Purpose.LastSet)
}
func TestServerRenameConversationHandler(t *testing.T) {
s := NewTestServer()
go s.Start()
client := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
response, err := client.RenameConversation("ID", "newName")
assert.NoError(t, err)
assert.Equal(t, "newName", response.Name)
}
func TestServerInviteConversationHandler(t *testing.T) {
s := NewTestServer()
go s.Start()
client := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
response, err := client.InviteUsersToConversation("conversationID", "username")
assert.NoError(t, err)
assert.Equal(t, 1, response.NumMembers)
}
func TestUserInfoHandler(t *testing.T) {
s := NewTestServer()
go s.Start()
client := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
user, err := client.GetUserInfo("123456")
assert.NoError(t, err)
assert.Equal(t, "W012A3CDE", user.ID)
assert.Equal(t, "spengler", user.Name)
assert.True(t, user.IsAdmin)
}
func TestUserLookUpByEmailHandler(t *testing.T) {
s := NewTestServer()
go s.Start()
client := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
user, err := client.GetUserByEmail("user@email.com")
assert.NoError(t, err)
assert.Equal(t, "W012A3CDE", user.ID)
assert.Equal(t, "spengler", user.Name)
assert.True(t, user.IsAdmin)
}
func TestBotInfoHandler(t *testing.T) {
s := NewTestServer()
go s.Start()
client := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
bot, err := client.GetBotInfo(s.BotID)
assert.NoError(t, err)
assert.Equal(t, s.BotID, bot.ID)
assert.Equal(t, s.BotName, bot.Name)
assert.False(t, bot.Deleted)
}
slack-0.11.3/slacktest/rtm_test.go 0000664 0000000 0000000 00000005664 14307410331 0017065 0 ustar 00root root 0000000 0000000 package slacktest
import (
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/slack-go/slack"
)
func TestRTMInfo(t *testing.T) {
maxWait := 10 * time.Millisecond
s := NewTestServer()
go s.Start()
api := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
rtm := api.NewRTM()
go rtm.ManageConnection()
messageChan := make(chan (*slack.ConnectedEvent), 1)
go func() {
for msg := range rtm.IncomingEvents {
switch ev := msg.Data.(type) {
case *slack.ConnectedEvent:
messageChan <- ev
}
}
}()
select {
case m := <-messageChan:
assert.Equal(t, s.BotID, m.Info.User.ID, "bot id did not match")
assert.Equal(t, s.BotName, m.Info.User.Name, "bot name did not match")
break
case <-time.After(maxWait):
assert.FailNow(t, "did not get connected event in time")
}
}
func TestRTMPing(t *testing.T) {
if testing.Short() {
t.Skip("skipping timered test")
}
maxWait := 45 * time.Second
s := NewTestServer()
go s.Start()
api := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
rtm := api.NewRTM()
go rtm.ManageConnection()
messageChan := make(chan (*slack.LatencyReport), 1)
go func() {
for msg := range rtm.IncomingEvents {
switch ev := msg.Data.(type) {
case *slack.LatencyReport:
messageChan <- ev
}
}
}()
select {
case m := <-messageChan:
assert.NotEmpty(t, m.Value, "latency report should value a value")
assert.True(t, m.Value > 0, "latency report should be greater than 0")
break
case <-time.After(maxWait):
assert.FailNow(t, "did not get latency report in time")
}
}
func TestRTMDirectMessage(t *testing.T) {
maxWait := 5 * time.Second
s := NewTestServer()
go s.Start()
api := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
rtm := api.NewRTM()
go rtm.ManageConnection()
messageChan := make(chan (*slack.MessageEvent), 1)
go func() {
for msg := range rtm.IncomingEvents {
switch ev := msg.Data.(type) {
case *slack.MessageEvent:
messageChan <- ev
}
}
}()
s.SendDirectMessageToBot("some text")
select {
case m := <-messageChan:
assert.Equal(t, defaultNonBotUserID, m.User)
assert.Equal(t, "D024BE91L", m.Channel)
assert.Equal(t, "some text", m.Text)
break
case <-time.After(maxWait):
assert.FailNow(t, "did not get direct message in time")
}
}
func TestRTMChannelMessage(t *testing.T) {
maxWait := 5 * time.Second
s := NewTestServer()
go s.Start()
api := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
rtm := api.NewRTM()
go rtm.ManageConnection()
messageChan := make(chan (*slack.MessageEvent), 1)
go func() {
for msg := range rtm.IncomingEvents {
switch ev := msg.Data.(type) {
case *slack.MessageEvent:
messageChan <- ev
}
}
}()
s.SendMessageToChannel("#foochan", "some text")
select {
case m := <-messageChan:
assert.Equal(t, "#foochan", m.Channel)
assert.Equal(t, "some text", m.Text)
break
case <-time.After(maxWait):
assert.FailNow(t, "did not get channel message in time")
}
}
slack-0.11.3/slacktest/server.go 0000664 0000000 0000000 00000017536 14307410331 0016533 0 ustar 00root root 0000000 0000000 package slacktest
import (
"encoding/json"
"fmt"
"log"
"net/http"
"net/http/httptest"
"time"
"github.com/slack-go/slack"
)
func newMessageChannels() *messageChannels {
sent := make(chan (string))
seen := make(chan (string))
mc := messageChannels{
seen: seen,
sent: sent,
}
return &mc
}
// Customize the server's responses.
type Customize interface {
Handle(pattern string, handler http.HandlerFunc)
}
type binder func(Customize)
// NewTestServer returns a slacktest.Server ready to be started
func NewTestServer(custom ...binder) *Server {
serverChans := newMessageChannels()
channels := &serverChannels{}
groups := &serverGroups{}
s := &Server{
registered: map[string]struct{}{},
mux: http.NewServeMux(),
seenInboundMessages: &messageCollection{},
seenOutboundMessages: &messageCollection{},
}
for _, c := range custom {
c(s)
}
s.Handle("/conversations.info", s.conversationsInfoHandler)
s.Handle("/ws", s.wsHandler)
s.Handle("/rtm.start", rtmStartHandler)
s.Handle("/rtm.connect", RTMConnectHandler)
s.Handle("/chat.postMessage", s.postMessageHandler)
s.Handle("/conversations.create", createConversationHandler)
s.Handle("/conversations.setTopic", setConversationTopicHandler)
s.Handle("/conversations.setPurpose", setConversationPurposeHandler)
s.Handle("/conversations.rename", renameConversationHandler)
s.Handle("/conversations.invite", inviteConversationHandler)
s.Handle("/users.info", usersInfoHandler)
s.Handle("/users.lookupByEmail", usersInfoHandler)
s.Handle("/bots.info", botsInfoHandler)
s.Handle("/auth.test", authTestHandler)
s.Handle("/reactions.add", reactionAddHandler)
httpserver := httptest.NewUnstartedServer(s.mux)
addr := httpserver.Listener.Addr().String()
s.ServerAddr = addr
s.server = httpserver
s.BotName = defaultBotName
s.BotID = defaultBotID
s.SeenFeed = serverChans.seen
s.channels = channels
s.groups = groups
addErr := addServerToHub(s, serverChans)
if addErr != nil {
log.Printf("Unable to add server to hub: %s", addErr.Error())
}
return s
}
// Handle allow for customizing endpoints
func (sts *Server) Handle(pattern string, handler http.HandlerFunc) {
if _, found := sts.registered[pattern]; found {
// log.Printf("route already registered: %s\n", pattern)
return
}
sts.registered[pattern] = struct{}{}
sts.mux.Handle(pattern, contextHandler(sts, handler))
}
// GetChannels returns all the fake channels registered
func (sts *Server) GetChannels() []slack.Channel {
sts.channels.RLock()
defer sts.channels.RUnlock()
return sts.channels.channels
}
// GetGroups returns all the fake groups registered
func (sts *Server) GetGroups() []slack.Group {
return sts.groups.channels
}
// GetSeenInboundMessages returns all messages seen via websocket excluding pings
func (sts *Server) GetSeenInboundMessages() []string {
sts.seenInboundMessages.RLock()
m := sts.seenInboundMessages.messages
sts.seenInboundMessages.RUnlock()
return m
}
// GetSeenOutboundMessages returns all messages seen via websocket excluding pings
func (sts *Server) GetSeenOutboundMessages() []string {
sts.seenOutboundMessages.RLock()
m := sts.seenOutboundMessages.messages
sts.seenOutboundMessages.RUnlock()
return m
}
// SawOutgoingMessage checks if a message was sent to connected websocket clients
func (sts *Server) SawOutgoingMessage(msg string) bool {
sts.seenOutboundMessages.RLock()
defer sts.seenOutboundMessages.RUnlock()
for _, m := range sts.seenOutboundMessages.messages {
evt := &slack.MessageEvent{}
jErr := json.Unmarshal([]byte(m), evt)
if jErr != nil {
continue
}
if evt.Text == msg {
return true
}
}
return false
}
// SawMessage checks if an incoming message was seen
func (sts *Server) SawMessage(msg string) bool {
sts.seenInboundMessages.RLock()
defer sts.seenInboundMessages.RUnlock()
for _, m := range sts.seenInboundMessages.messages {
evt := &slack.MessageEvent{}
jErr := json.Unmarshal([]byte(m), evt)
if jErr != nil {
// This event isn't a message event so we'll skip it
continue
}
if evt.Text == msg {
return true
}
}
return false
}
// GetAPIURL returns the api url you can pass to slack.SLACK_API
func (sts *Server) GetAPIURL() string {
return "http://" + sts.ServerAddr + "/"
}
// GetWSURL returns the websocket url
func (sts *Server) GetWSURL() string {
return "ws://" + sts.ServerAddr + "/ws"
}
// Stop stops the test server
func (sts *Server) Stop() {
sts.server.Close()
}
// Start starts the test server
func (sts *Server) Start() {
sts.server.Start()
}
// SendMessageToBot sends a message addressed to the Bot
func (sts *Server) SendMessageToBot(channel, msg string) {
m := slack.Message{}
m.Type = slack.TYPE_MESSAGE
m.Channel = channel
m.User = defaultNonBotUserID
m.Text = fmt.Sprintf("<@%s> %s", sts.BotID, msg)
m.Timestamp = fmt.Sprintf("%d", time.Now().Unix())
j, jErr := json.Marshal(m)
if jErr != nil {
log.Printf("Unable to marshal message for bot: %s", jErr.Error())
return
}
go sts.queueForWebsocket(string(j), sts.ServerAddr)
}
// SendDirectMessageToBot sends a direct message to the bot
func (sts *Server) SendDirectMessageToBot(msg string) {
m := slack.Message{}
m.Type = slack.TYPE_MESSAGE
m.Channel = "D024BE91L"
m.User = defaultNonBotUserID
m.Text = msg
m.Timestamp = fmt.Sprintf("%d", time.Now().Unix())
j, jErr := json.Marshal(m)
if jErr != nil {
log.Printf("Unable to marshal private message for bot: %s", jErr.Error())
return
}
go sts.queueForWebsocket(string(j), sts.ServerAddr)
}
// SendMessageToChannel sends a message to a channel
func (sts *Server) SendMessageToChannel(channel, msg string) {
m := slack.Message{}
m.Type = slack.TYPE_MESSAGE
m.Channel = channel
m.Text = msg
m.User = defaultNonBotUserID
m.Timestamp = fmt.Sprintf("%d", time.Now().Unix())
j, jErr := json.Marshal(m)
if jErr != nil {
log.Printf("Unable to marshal message for channel: %s", jErr.Error())
return
}
stringMsg := string(j)
go sts.queueForWebsocket(stringMsg, sts.ServerAddr)
}
// SendToWebsocket send `s` as is to connected clients.
// This is useful for sending your own custom json to the websocket
func (sts *Server) SendToWebsocket(s string) {
go sts.queueForWebsocket(s, sts.ServerAddr)
}
// SetBotName sets a custom botname
func (sts *Server) SetBotName(b string) {
sts.BotName = b
}
// SendBotChannelInvite invites the bot to a channel
func (sts *Server) SendBotChannelInvite() {
joinMsg := `
{
"type":"channel_joined",
"channel":
{
"id": "C024BE92L",
"name": "bot-playground",
"is_channel": true,
"created": 1360782804,
"creator": "W012A3CDE",
"is_archived": false,
"is_general": true,
"members": [
"W012A3CDE"
],
"topic": {
"value": "Fun times",
"creator": "W012A3CDE",
"last_set": 1360782804
},
"purpose": {
"value": "This channel is for fun",
"creator": "W012A3CDE",
"last_set": 1360782804
},
"is_member": true
}
}`
sts.SendToWebsocket(joinMsg)
}
// SendBotGroupInvite invites the bot to a channel
func (sts *Server) SendBotGroupInvite() {
joinMsg := `
{
"type":"group_joined",
"channel":
{
"id": "G024BE91L",
"name": "secretplans",
"is_group": true,
"created": 1360782804,
"creator": "W012A3CDE",
"is_archived": false,
"members": [
"W012A3CDE"
],
"topic": {
"value": "Secret plans on hold",
"creator": "W012A3CDE",
"last_set": 1360782804
},
"purpose": {
"value": "Discuss secret plans that no-one else should know",
"creator": "W012A3CDE",
"last_set": 1360782804
}
}
}`
sts.SendToWebsocket(joinMsg)
}
// GetTestRTMInstance will give you an RTM instance in the context of the current fake server
func (sts *Server) GetTestRTMInstance() *slack.RTM {
api := slack.New("ABCEFG", slack.OptionAPIURL(sts.GetAPIURL()))
rtm := api.NewRTM()
return rtm
}
slack-0.11.3/slacktest/server_test.go 0000664 0000000 0000000 00000010510 14307410331 0017553 0 ustar 00root root 0000000 0000000 package slacktest
import (
"encoding/json"
"fmt"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/slack-go/slack"
)
func TestDefaultNewServer(t *testing.T) {
s := NewTestServer()
assert.Equal(t, defaultBotID, s.BotID)
assert.Equal(t, defaultBotName, s.BotName)
assert.NotEmpty(t, s.ServerAddr)
s.Stop()
}
func TestCustomNewServer(t *testing.T) {
s := NewTestServer()
s.SetBotName("BobsBot")
assert.Equal(t, "BobsBot", s.BotName)
}
func TestServerSendMessageToChannel(t *testing.T) {
s := NewTestServer()
go s.Start()
s.SendMessageToChannel("C123456789", "some text")
time.Sleep(2 * time.Second)
assert.True(t, s.SawOutgoingMessage("some text"))
s.Stop()
}
func TestServerSendMessageToBot(t *testing.T) {
s := NewTestServer()
go s.Start()
s.SendMessageToBot("C123456789", "some text")
expectedMsg := fmt.Sprintf("<@%s> %s", s.BotID, "some text")
time.Sleep(2 * time.Second)
assert.True(t, s.SawOutgoingMessage(expectedMsg))
s.Stop()
}
func TestBotDirectMessageBotHandler(t *testing.T) {
s := NewTestServer()
go s.Start()
s.SendDirectMessageToBot("some text")
expectedMsg := fmt.Sprintf("some text")
time.Sleep(2 * time.Second)
assert.True(t, s.SawOutgoingMessage(expectedMsg))
s.Stop()
}
func TestGetSeenOutboundMessages(t *testing.T) {
maxWait := 5 * time.Second
s := NewTestServer()
go s.Start()
s.SendMessageToChannel("foo", "should see this message")
time.Sleep(maxWait)
seenOutbound := s.GetSeenOutboundMessages()
assert.True(t, len(seenOutbound) > 0)
hadMessage := false
for _, msg := range seenOutbound {
var m = slack.Message{}
jerr := json.Unmarshal([]byte(msg), &m)
assert.NoError(t, jerr, "messages should decode as slack.Message")
if m.Text == "should see this message" {
hadMessage = true
break
}
}
assert.True(t, hadMessage, "did not see my sent message")
}
func TestGetSeenInboundMessages(t *testing.T) {
maxWait := 5 * time.Second
s := NewTestServer()
go s.Start()
api := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
rtm := api.NewRTM()
go rtm.ManageConnection()
rtm.SendMessage(&slack.OutgoingMessage{
Channel: "foo",
Text: "should see this inbound message",
})
time.Sleep(maxWait)
seenInbound := s.GetSeenInboundMessages()
assert.True(t, len(seenInbound) > 0)
hadMessage := false
for _, msg := range seenInbound {
var m = slack.Message{}
jerr := json.Unmarshal([]byte(msg), &m)
assert.NoError(t, jerr, "messages should decode as slack.Message")
if m.Text == "should see this inbound message" {
hadMessage = true
break
}
}
assert.True(t, hadMessage, "did not see my sent message")
assert.True(t, s.SawMessage("should see this inbound message"))
}
func TestSendChannelInvite(t *testing.T) {
maxWait := 5 * time.Second
s := NewTestServer()
go s.Start()
rtm := s.GetTestRTMInstance()
go rtm.ManageConnection()
evChan := make(chan (slack.Channel), 1)
go func() {
for msg := range rtm.IncomingEvents {
switch ev := msg.Data.(type) {
case *slack.ChannelJoinedEvent:
evChan <- ev.Channel
}
}
}()
s.SendBotChannelInvite()
time.Sleep(maxWait)
select {
case m := <-evChan:
assert.Equal(t, "C024BE92L", m.ID, "channel id should match")
assert.Equal(t, "Fun times", m.Topic.Value, "topic should match")
s.Stop()
break
case <-time.After(maxWait):
assert.FailNow(t, "did not get channel joined event in time")
}
}
func TestSendGroupInvite(t *testing.T) {
maxWait := 5 * time.Second
s := NewTestServer()
go s.Start()
rtm := s.GetTestRTMInstance()
go rtm.ManageConnection()
evChan := make(chan (slack.Channel), 1)
go func() {
for msg := range rtm.IncomingEvents {
switch ev := msg.Data.(type) {
case *slack.GroupJoinedEvent:
evChan <- ev.Channel
}
}
}()
s.SendBotGroupInvite()
time.Sleep(maxWait)
select {
case m := <-evChan:
assert.Equal(t, "G024BE91L", m.ID, "channel id should match")
assert.Equal(t, "Secret plans on hold", m.Topic.Value, "topic should match")
s.Stop()
break
case <-time.After(maxWait):
assert.FailNow(t, "did not get group joined event in time")
}
}
func TestServerSawMessage(t *testing.T) {
s := NewTestServer()
go s.Start()
assert.False(t, s.SawMessage("foo"), "should not have seen any message")
}
func TestServerSawOutgoingMessage(t *testing.T) {
s := NewTestServer()
go s.Start()
assert.False(t, s.SawOutgoingMessage("foo"), "should not have seen any message")
}
slack-0.11.3/slacktest/types.go 0000664 0000000 0000000 00000004021 14307410331 0016352 0 ustar 00root root 0000000 0000000 package slacktest
import (
"log"
"net/http"
"net/http/httptest"
"sync"
"github.com/slack-go/slack"
)
type contextKey string
// ServerURLContextKey is the context key to store the server's url
const ServerURLContextKey contextKey = "__SERVER_URL__"
// ServerWSContextKey is the context key to store the server's ws url
const ServerWSContextKey contextKey = "__SERVER_WS_URL__"
// ServerBotNameContextKey is the bot name
const ServerBotNameContextKey contextKey = "__SERVER_BOTNAME__"
// ServerBotIDContextKey is the bot userid
const ServerBotIDContextKey contextKey = "__SERVER_BOTID__"
// ServerBotChannelsContextKey is the list of channels associated with the fake server
const ServerBotChannelsContextKey contextKey = "__SERVER_CHANNELS__"
// ServerBotGroupsContextKey is the list of channels associated with the fake server
const ServerBotGroupsContextKey contextKey = "__SERVER_GROUPS__"
// ServerBotHubNameContextKey is the context key for passing along the server name registered in the hub
const ServerBotHubNameContextKey contextKey = "__SERVER_HUBNAME__"
var masterHub = newHub()
type hub struct {
sync.RWMutex
serverChannels map[string]*messageChannels
}
type messageChannels struct {
seen chan (string)
sent chan (string)
posted chan (slack.Message)
}
type messageCollection struct {
sync.RWMutex
messages []string
}
type serverChannels struct {
sync.RWMutex
channels []slack.Channel
}
type serverGroups struct {
sync.RWMutex
channels []slack.Group
}
// Server represents a Slack Test server
type Server struct {
registered map[string]struct{}
server *httptest.Server
mux *http.ServeMux
Logger *log.Logger
BotName string
BotID string
ServerAddr string
SeenFeed chan (string)
channels *serverChannels
groups *serverGroups
seenInboundMessages *messageCollection
seenOutboundMessages *messageCollection
}
type fullInfoSlackResponse struct {
slack.Info
slack.SlackResponse
}
slack-0.11.3/slackutilsx/ 0000775 0000000 0000000 00000000000 14307410331 0015233 5 ustar 00root root 0000000 0000000 slack-0.11.3/slackutilsx/slackutilsx.go 0000664 0000000 0000000 00000002764 14307410331 0020141 0 ustar 00root root 0000000 0000000 // Package slackutilsx is a utility package that doesn't promise API stability.
// its for experimental functionality and utilities.
package slackutilsx
import (
"strings"
"unicode/utf8"
)
// ChannelType the type of channel based on the channelID
type ChannelType int
func (t ChannelType) String() string {
switch t {
case CTypeDM:
return "Direct"
case CTypeGroup:
return "Group"
case CTypeChannel:
return "Channel"
default:
return "Unknown"
}
}
const (
// CTypeUnknown represents channels we cannot properly detect.
CTypeUnknown ChannelType = iota
// CTypeDM is a private channel between two slack users.
CTypeDM
// CTypeGroup is a group channel.
CTypeGroup
// CTypeChannel is a public channel.
CTypeChannel
)
// DetectChannelType converts a channelID to a ChannelType.
// channelID must not be empty. However, if it is empty, the channel type will default to Unknown.
func DetectChannelType(channelID string) ChannelType {
// intentionally ignore the error and just default to CTypeUnknown
switch r, _ := utf8.DecodeRuneInString(channelID); r {
case 'C':
return CTypeChannel
case 'G':
return CTypeGroup
case 'D':
return CTypeDM
default:
return CTypeUnknown
}
}
// initialize replacer only once (if needed)
var escapeReplacer = strings.NewReplacer("&", "&", "<", "<", ">", ">")
// EscapeMessage text
func EscapeMessage(message string) string {
return escapeReplacer.Replace(message)
}
// Retryable errors return true.
type Retryable interface {
Retryable() bool
}
slack-0.11.3/slackutilsx/slackutilsx_test.go 0000664 0000000 0000000 00000001613 14307410331 0021170 0 ustar 00root root 0000000 0000000 package slackutilsx
import (
"testing"
)
func TestDetectChannelType(t *testing.T) {
test := func(channelID string, expected ChannelType) {
if computed := DetectChannelType(channelID); computed != expected {
t.Errorf("expected channelID %s to have type %s, got: %s", channelID, expected, computed)
}
}
test("G11111111", CTypeGroup)
test("D11111111", CTypeDM)
test("C11111111", CTypeChannel)
test("", CTypeUnknown)
test("X11111111", CTypeUnknown)
}
func TestEscapeMessage(t *testing.T) {
test := func(message string, expected string) {
if computed := EscapeMessage(message); computed != expected {
t.Errorf("expected message %s to be converted to %s, got: %s", message, expected, computed)
}
}
test("A & B", "A & B")
test("A < B", "A < B")
test("A > B", "A > B")
}
func BenchmarkEscapeMessage(b *testing.B) {
for i := 0; i < b.N; i++ {
EscapeMessage("A & B")
}
}
slack-0.11.3/slash.go 0000664 0000000 0000000 00000003402 14307410331 0014325 0 ustar 00root root 0000000 0000000 package slack
import (
"net/http"
)
// SlashCommand contains information about a request of the slash command
type SlashCommand struct {
Token string `json:"token"`
TeamID string `json:"team_id"`
TeamDomain string `json:"team_domain"`
EnterpriseID string `json:"enterprise_id,omitempty"`
EnterpriseName string `json:"enterprise_name,omitempty"`
ChannelID string `json:"channel_id"`
ChannelName string `json:"channel_name"`
UserID string `json:"user_id"`
UserName string `json:"user_name"`
Command string `json:"command"`
Text string `json:"text"`
ResponseURL string `json:"response_url"`
TriggerID string `json:"trigger_id"`
APIAppID string `json:"api_app_id"`
}
// SlashCommandParse will parse the request of the slash command
func SlashCommandParse(r *http.Request) (s SlashCommand, err error) {
if err = r.ParseForm(); err != nil {
return s, err
}
s.Token = r.PostForm.Get("token")
s.TeamID = r.PostForm.Get("team_id")
s.TeamDomain = r.PostForm.Get("team_domain")
s.EnterpriseID = r.PostForm.Get("enterprise_id")
s.EnterpriseName = r.PostForm.Get("enterprise_name")
s.ChannelID = r.PostForm.Get("channel_id")
s.ChannelName = r.PostForm.Get("channel_name")
s.UserID = r.PostForm.Get("user_id")
s.UserName = r.PostForm.Get("user_name")
s.Command = r.PostForm.Get("command")
s.Text = r.PostForm.Get("text")
s.ResponseURL = r.PostForm.Get("response_url")
s.TriggerID = r.PostForm.Get("trigger_id")
s.APIAppID = r.PostForm.Get("api_app_id")
return s, nil
}
// ValidateToken validates verificationTokens
func (s SlashCommand) ValidateToken(verificationTokens ...string) bool {
for _, token := range verificationTokens {
if s.Token == token {
return true
}
}
return false
}
slack-0.11.3/slash_test.go 0000664 0000000 0000000 00000005634 14307410331 0015375 0 ustar 00root root 0000000 0000000 package slack
import (
"fmt"
"net/http"
"net/url"
"reflect"
"strings"
"testing"
)
func TestSlash_ServeHTTP(t *testing.T) {
once.Do(startServer)
serverURL := fmt.Sprintf("http://%s/slash", serverAddr)
tests := []struct {
body url.Values
wantParams SlashCommand
wantStatusCode int
}{
{
body: url.Values{
"command": []string{"/command"},
"team_domain": []string{"team"},
"enterprise_id": []string{"E0001"},
"enterprise_name": []string{"Globular%20Construct%20Inc"},
"channel_id": []string{"C1234ABCD"},
"text": []string{"text"},
"team_id": []string{"T1234ABCD"},
"user_id": []string{"U1234ABCD"},
"user_name": []string{"username"},
"response_url": []string{"https://hooks.slack.com/commands/XXXXXXXX/00000000000/YYYYYYYYYYYYYY"},
"token": []string{"valid"},
"channel_name": []string{"channel"},
"trigger_id": []string{"0000000000.1111111111.222222222222aaaaaaaaaaaaaa"},
"api_app_id": []string{"A123456"},
},
wantParams: SlashCommand{
Command: "/command",
TeamDomain: "team",
EnterpriseID: "E0001",
EnterpriseName: "Globular%20Construct%20Inc",
ChannelID: "C1234ABCD",
Text: "text",
TeamID: "T1234ABCD",
UserID: "U1234ABCD",
UserName: "username",
ResponseURL: "https://hooks.slack.com/commands/XXXXXXXX/00000000000/YYYYYYYYYYYYYY",
Token: "valid",
ChannelName: "channel",
TriggerID: "0000000000.1111111111.222222222222aaaaaaaaaaaaaa",
APIAppID: "A123456",
},
wantStatusCode: http.StatusOK,
},
{
body: url.Values{
"token": []string{"invalid"},
},
wantParams: SlashCommand{
Token: "invalid",
},
wantStatusCode: http.StatusUnauthorized,
},
}
var slashCommand SlashCommand
client := &http.Client{}
http.HandleFunc("/slash", func(w http.ResponseWriter, r *http.Request) {
var err error
slashCommand, err = SlashCommandParse(r)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
}
acceptableTokens := []string{"valid", "valid2"}
if !slashCommand.ValidateToken(acceptableTokens...) {
w.WriteHeader(http.StatusUnauthorized)
}
})
for i, test := range tests {
req, err := http.NewRequest(http.MethodPost, serverURL, strings.NewReader(test.body.Encode()))
if err != nil {
t.Fatalf("%d: Unexpected error: %s", i, err)
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
resp, err := client.Do(req)
if err != nil {
t.Fatalf("%d: Unexpected error: %s", i, err)
}
if resp.StatusCode != test.wantStatusCode {
t.Errorf("%d: Got status code %d, want %d", i, resp.StatusCode, test.wantStatusCode)
}
if !reflect.DeepEqual(slashCommand, test.wantParams) {
t.Errorf("%d: Got params %#v, want %#v", i, slashCommand, test.wantParams)
}
resp.Body.Close()
}
}
slack-0.11.3/socket_mode.go 0000664 0000000 0000000 00000002151 14307410331 0015507 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
)
// SocketModeConnection contains various details about the SocketMode connection.
// It is returned by an "apps.connections.open" API call.
type SocketModeConnection struct {
URL string `json:"url,omitempty"`
Data map[string]interface{} `json:"-"`
}
type openResponseFull struct {
SlackResponse
SocketModeConnection
}
// StartSocketModeContext calls the "apps.connections.open" endpoint and returns the provided URL and the full Info block with a custom context.
//
// To have a fully managed Socket Mode connection, use `socketmode.New()`, and call `Run()` on it.
func (api *Client) StartSocketModeContext(ctx context.Context) (info *SocketModeConnection, websocketURL string, err error) {
response := &openResponseFull{}
err = postJSON(ctx, api.httpclient, api.endpoint+"apps.connections.open", api.appLevelToken, nil, response, api)
if err != nil {
return nil, "", err
}
if response.Err() == nil {
api.Debugln("Using URL:", response.SocketModeConnection.URL)
}
return &response.SocketModeConnection, response.SocketModeConnection.URL, response.Err()
}
slack-0.11.3/socketmode/ 0000775 0000000 0000000 00000000000 14307410331 0015022 5 ustar 00root root 0000000 0000000 slack-0.11.3/socketmode/client.go 0000664 0000000 0000000 00000003600 14307410331 0016626 0 ustar 00root root 0000000 0000000 package socketmode
import (
"encoding/json"
"time"
"github.com/slack-go/slack"
"github.com/gorilla/websocket"
)
type ConnectedEvent struct {
ConnectionCount int // 1 = first time, 2 = second time
Info *slack.SocketModeConnection
}
type DebugInfo struct {
// Host is the name of the host name on the Slack end, that can be something like `applink-7fc4fdbb64-4x5xq`
Host string `json:"host"`
// `hello` type only
BuildNumber int `json:"build_number"`
ApproximateConnectionTime int `json:"approximate_connection_time"`
}
type ConnectionInfo struct {
AppID string `json:"app_id"`
}
type SocketModeMessagePayload struct {
Event json.RawMessage `json:"event"`
}
// Client is a Socket Mode client that allows programs to use [Events API](https://api.slack.com/events-api)
// and [interactive components](https://api.slack.com/interactivity) over WebSocket.
// Please see [Intro to Socket Mode](https://api.slack.com/apis/connections/socket) for more information
// on Socket Mode.
//
// The implementation is highly inspired by https://www.npmjs.com/package/@slack/socket-mode,
// but the structure and the design has been adapted as much as possible to that of our RTM client for consistency
// within the library.
//
// You can instantiate the socket mode client with
// Client's New() and call Run() to start it. Please see examples/socketmode for the usage.
type Client struct {
// Client is the main API, embedded
slack.Client
// maxPingInterval is the maximum duration elapsed after the last WebSocket PING sent from Slack
// until Client considers the WebSocket connection is dead and needs to be reopened.
maxPingInterval time.Duration
// Connection life-cycle
Events chan Event
socketModeResponses chan *Response
// dialer is a gorilla/websocket Dialer. If nil, use the default
// Dialer.
dialer *websocket.Dialer
debug bool
log ilogger
}
slack-0.11.3/socketmode/deadman.go 0000664 0000000 0000000 00000001034 14307410331 0016740 0 ustar 00root root 0000000 0000000 package socketmode
import "time"
type deadmanTimer struct {
timeout time.Duration
timer *time.Timer
}
func newDeadmanTimer(timeout time.Duration) *deadmanTimer {
return &deadmanTimer{
timeout: timeout,
timer: time.NewTimer(timeout),
}
}
func (smc *deadmanTimer) Elapsed() <-chan time.Time {
return smc.timer.C
}
func (smc *deadmanTimer) Reset() {
// Note that this is the correct way to Reset a non-expired timer
if !smc.timer.Stop() {
select {
case <-smc.timer.C:
default:
}
}
smc.timer.Reset(smc.timeout)
}
slack-0.11.3/socketmode/event.go 0000664 0000000 0000000 00000001132 14307410331 0016467 0 ustar 00root root 0000000 0000000 package socketmode
import "encoding/json"
// Event is the event sent to the consumer of Client
type Event struct {
Type EventType
Data interface{}
// Request is the json-decoded raw WebSocket message that is received via the Slack Socket Mode
// WebSocket connection.
Request *Request
}
type ErrorBadMessage struct {
Cause error
Message json.RawMessage
}
type ErrorWriteFailed struct {
Cause error
Response *Response
}
type errorRequestedDisconnect struct {
}
func (e errorRequestedDisconnect) Error() string {
return "disconnection requested: Slack requested us to disconnect"
}
slack-0.11.3/socketmode/log.go 0000664 0000000 0000000 00000002335 14307410331 0016135 0 ustar 00root root 0000000 0000000 package socketmode
import "fmt"
// TODO merge logger, ilogger, and internalLogger with the top-level package's equivalents
// logger is a logger interface compatible with both stdlib and some
// 3rd party loggers.
type logger interface {
Output(int, string) error
}
// ilogger represents the internal logging api we use.
type ilogger interface {
logger
Print(...interface{})
Printf(string, ...interface{})
Println(...interface{})
}
// internalLog implements the additional methods used by our internal logging.
type internalLog struct {
logger
}
// Println replicates the behaviour of the standard logger.
func (t internalLog) Println(v ...interface{}) {
t.Output(2, fmt.Sprintln(v...))
}
// Printf replicates the behaviour of the standard logger.
func (t internalLog) Printf(format string, v ...interface{}) {
t.Output(2, fmt.Sprintf(format, v...))
}
// Print replicates the behaviour of the standard logger.
func (t internalLog) Print(v ...interface{}) {
t.Output(2, fmt.Sprint(v...))
}
func (smc *Client) Debugf(format string, v ...interface{}) {
if smc.debug {
smc.log.Output(2, fmt.Sprintf(format, v...))
}
}
func (smc *Client) Debugln(v ...interface{}) {
if smc.debug {
smc.log.Output(2, fmt.Sprintln(v...))
}
}
slack-0.11.3/socketmode/request.go 0000664 0000000 0000000 00000003112 14307410331 0017036 0 ustar 00root root 0000000 0000000 package socketmode
import "encoding/json"
// Request maps to the content of each WebSocket message received via a Socket Mode WebSocket connection
//
// We call this a "request" rather than e.g. a WebSocket message or an Socket Mode "event" following python-slack-sdk:
//
// https://github.com/slackapi/python-slack-sdk/blob/3f1c4c6e27bf7ee8af57699b2543e6eb7848bcf9/slack_sdk/socket_mode/request.py#L6
//
// We know that node-slack-sdk calls it an "event", that makes it hard for us to distinguish our client's own event
// that wraps both internal events and Socket Mode "events", vs node-slack-sdk's is for the latter only.
//
// https://github.com/slackapi/node-slack-sdk/blob/main/packages/socket-mode/src/SocketModeClient.ts#L537
type Request struct {
Type string `json:"type"`
// `hello` type only
NumConnections int `json:"num_connections"`
ConnectionInfo ConnectionInfo `json:"connection_info"`
// `disconnect` type only
// Reason can be "warning" or else
Reason string `json:"reason"`
// `hello` and `disconnect` types only
DebugInfo DebugInfo `json:"debug_info"`
// `events_api` type only
EnvelopeID string `json:"envelope_id"`
// TODO Can it really be a non-object type?
// See https://github.com/slackapi/python-slack-sdk/blob/3f1c4c6e27bf7ee8af57699b2543e6eb7848bcf9/slack_sdk/socket_mode/request.py#L26-L31
Payload json.RawMessage `json:"payload"`
AcceptsResponsePayload bool `json:"accepts_response_payload"`
RetryAttempt int `json:"retry_attempt"`
RetryReason string `json:"retry_reason"`
}
slack-0.11.3/socketmode/response.go 0000664 0000000 0000000 00000000215 14307410331 0017205 0 ustar 00root root 0000000 0000000 package socketmode
type Response struct {
EnvelopeID string `json:"envelope_id"`
Payload interface{} `json:"payload,omitempty"`
}
slack-0.11.3/socketmode/socket_mode_managed_conn.go 0000664 0000000 0000000 00000043551 14307410331 0022346 0 ustar 00root root 0000000 0000000 package socketmode
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"sync"
"time"
"github.com/gorilla/websocket"
"github.com/slack-go/slack"
"github.com/slack-go/slack/internal/backoff"
"github.com/slack-go/slack/internal/timex"
"github.com/slack-go/slack/slackevents"
)
// Run is a blocking function that connects the Slack Socket Mode API and handles all incoming
// requests and outgoing responses.
//
// The consumer of the Client and this function should read the Client.Events channel to receive
// `socketmode.Event`s that includes the client-specific events that may or may not wrap Socket Mode requests.
//
// Note that this function automatically reconnect on requested by Slack through a `disconnect` message.
// This function exists with an error only when a reconnection is failued due to some reason.
// If you want to retry even on reconnection failure, you'd need to write your own wrapper for this function
// to do so.
func (smc *Client) Run() error {
return smc.RunContext(context.TODO())
}
// RunContext is a blocking function that connects the Slack Socket Mode API and handles all incoming
// requests and outgoing responses.
//
// The consumer of the Client and this function should read the Client.Events channel to receive
// `socketmode.Event`s that includes the client-specific events that may or may not wrap Socket Mode requests.
//
// Note that this function automatically reconnect on requested by Slack through a `disconnect` message.
// This function exists with an error only when a reconnection is failued due to some reason.
// If you want to retry even on reconnection failure, you'd need to write your own wrapper for this function
// to do so.
func (smc *Client) RunContext(ctx context.Context) error {
for connectionCount := 0; ; connectionCount++ {
if err := smc.run(ctx, connectionCount); err != nil {
return err
}
// Continue and run the loop again to reconnect
}
}
func (smc *Client) run(ctx context.Context, connectionCount int) error {
messages := make(chan json.RawMessage)
defer close(messages)
deadmanTimer := newDeadmanTimer(smc.maxPingInterval)
pingHandler := func(_ string) error {
deadmanTimer.Reset()
return nil
}
// Start trying to connect
// the returned err is already passed onto the Events channel
//
// We also configures an additional ping handler for the deadmanTimer that triggers a timeout when
// Slack did not send us WebSocket PING for more than Client.maxPingInterval.
// We can use `<-smc.pingTimeout.C` to wait for the timeout.
info, conn, err := smc.connect(ctx, connectionCount, pingHandler)
if err != nil {
// when the connection is unsuccessful its fatal, and we need to bail out.
smc.Debugf("Failed to connect with Socket Mode on try %d: %s", connectionCount, err)
return err
}
ctx, cancel := context.WithCancel(ctx)
defer cancel()
smc.Events <- newEvent(EventTypeConnected, &ConnectedEvent{
ConnectionCount: connectionCount,
Info: info,
})
smc.Debugf("WebSocket connection succeeded on try %d", connectionCount)
// We're now connected so we can set up listeners
var (
wg sync.WaitGroup
firstErr error
firstErrOnce sync.Once
)
wg.Add(1)
go func() {
defer wg.Done()
defer cancel()
// The response sender sends Socket Mode responses over the WebSocket conn
if err := smc.runResponseSender(ctx, conn); err != nil {
firstErrOnce.Do(func() {
firstErr = err
})
}
}()
wg.Add(1)
go func() {
defer wg.Done()
defer cancel()
// The handler reads Socket Mode requests, and enqueues responses for sending by the response sender
if err := smc.runRequestHandler(ctx, messages); err != nil {
firstErrOnce.Do(func() {
firstErr = err
})
}
}()
// We don't wait on runMessageReceiver because it doesn't block on a select with the context,
// so we'd have to wait for the ReadJSON to time out, which can take a while.
go func() {
defer cancel()
// The receiver reads WebSocket messages, and enqueues parsed Socket Mode requests to be handled by
// the request handler
if err := smc.runMessageReceiver(ctx, conn, messages); err != nil {
firstErrOnce.Do(func() {
firstErr = err
})
}
}()
wg.Add(1)
go func() {
defer wg.Done()
select {
case <-ctx.Done():
// Detect when the connection is dead and try close connection.
if err = conn.Close(); err != nil {
smc.Debugf("Failed to close connection: %v", err)
}
case <-deadmanTimer.Elapsed():
firstErrOnce.Do(func() {
firstErr = errors.New("ping timeout: Slack did not send us WebSocket PING for more than Client.maxInterval")
})
cancel()
}
}()
wg.Wait()
if firstErr == context.Canceled {
return firstErr
}
// wg.Wait() finishes only after any of the above go routines finishes and cancels the
// context, allowing the other threads to shut down gracefully.
// Also, we can expect firstErr to be not nil, as goroutines can finish only on error.
smc.Debugf("Reconnecting due to %v", firstErr)
return nil
}
// connect attempts to connect to the slack websocket API. It handles any
// errors that occur while connecting and will return once a connection
// has been successfully opened.
func (smc *Client) connect(ctx context.Context, connectionCount int, additionalPingHandler func(string) error) (*slack.SocketModeConnection, *websocket.Conn, error) {
const (
errInvalidAuth = "invalid_auth"
errInactiveAccount = "account_inactive"
errMissingAuthToken = "not_authed"
errTokenRevoked = "token_revoked"
)
// used to provide exponential backoff wait time with jitter before trying
// to connect to slack again
boff := &backoff.Backoff{
Max: 5 * time.Minute,
}
for {
var (
backoff time.Duration
)
// send connecting event
smc.Events <- newEvent(EventTypeConnecting, &slack.ConnectingEvent{
Attempt: boff.Attempts() + 1,
ConnectionCount: connectionCount,
})
// attempt to start the connection
info, conn, err := smc.openAndDial(ctx, additionalPingHandler)
if err == nil {
return info, conn, nil
}
// check for fatal errors
switch err.Error() {
case errInvalidAuth, errInactiveAccount, errMissingAuthToken, errTokenRevoked:
smc.Debugf("invalid auth when connecting with SocketMode: %s", err)
return nil, nil, err
default:
}
switch actual := err.(type) {
case slack.StatusCodeError:
if actual.Code == http.StatusNotFound {
smc.Debugf("invalid auth when connecting with Socket Mode: %s", err)
smc.Events <- newEvent(EventTypeInvalidAuth, &slack.InvalidAuthEvent{})
return nil, nil, err
}
case *slack.RateLimitedError:
backoff = actual.RetryAfter
default:
}
backoff = timex.Max(backoff, boff.Duration())
// any other errors are treated as recoverable and we try again after
// sending the event along the Events channel
smc.Events <- newEvent(EventTypeConnectionError, &slack.ConnectionErrorEvent{
Attempt: boff.Attempts(),
Backoff: backoff,
ErrorObj: err,
})
// get time we should wait before attempting to connect again
smc.Debugf("reconnection %d failed: %s reconnecting in %v\n", boff.Attempts(), err, backoff)
// wait for one of the following to occur,
// backoff duration has elapsed, disconnectCh is signalled, or
// the smc finishes disconnecting.
select {
case <-time.After(backoff): // retry after the backoff.
case <-ctx.Done():
return nil, nil, ctx.Err()
}
}
}
// openAndDial attempts to open a Socket Mode connection and dial to the connection endpoint using WebSocket.
// It returns the full information returned by the "apps.connections.open" method on the
// Slack API.
func (smc *Client) openAndDial(ctx context.Context, additionalPingHandler func(string) error) (info *slack.SocketModeConnection, _ *websocket.Conn, err error) {
var (
url string
)
smc.Debugf("Starting SocketMode")
info, url, err = smc.OpenContext(ctx)
if err != nil {
smc.Debugf("Failed to start or connect with SocketMode: %s", err)
return nil, nil, err
}
smc.Debugf("Dialing to websocket on url %s", url)
// Only use HTTPS for connections to prevent MITM attacks on the connection.
upgradeHeader := http.Header{}
upgradeHeader.Add("Origin", "https://api.slack.com")
dialer := websocket.DefaultDialer
if smc.dialer != nil {
dialer = smc.dialer
}
conn, _, err := dialer.DialContext(ctx, url, upgradeHeader)
if err != nil {
smc.Debugf("Failed to dial to the websocket: %s", err)
return nil, nil, err
}
conn.SetPingHandler(func(appData string) error {
if additionalPingHandler != nil {
if err := additionalPingHandler(appData); err != nil {
return err
}
}
smc.handlePing(conn, appData)
return nil
})
// We don't need to conn.SetCloseHandler because the default handler is effective enough that
// it sends back the CLOSE message to the server and let conn.ReadJSON() fail with CloseError.
// The CloseError must be handled normally in our receiveMessagesInto function.
//conn.SetCloseHandler(func(code int, text string) error {
// ...
// })
return info, conn, err
}
// runResponseSender runs the handler that reads Socket Mode responses enqueued onto Client.socketModeResponses channel
// and sends them one by one over the WebSocket connection.
// Gorilla WebSocket is not goroutine safe hence this needs to be the single place you write to the WebSocket connection.
func (smc *Client) runResponseSender(ctx context.Context, conn *websocket.Conn) error {
for {
select {
case <-ctx.Done():
return ctx.Err()
// 3. listen for messages that need to be sent
case res := <-smc.socketModeResponses:
smc.Debugf("Sending Socket Mode response with envelope ID %q: %v", res.EnvelopeID, res)
if err := unsafeWriteSocketModeResponse(conn, res); err != nil {
smc.Events <- newEvent(EventTypeErrorWriteFailed, &ErrorWriteFailed{
Cause: err,
Response: res,
})
}
smc.Debugf("Finished sending Socket Mode response with envelope ID %q", res.EnvelopeID)
}
}
}
// runRequestHandler is a blocking function that runs the Socket Mode request receiver.
//
// It reads WebSocket messages sent from Slack's Socket Mode WebSocket connection,
// parses them as Socket Mode requests, and processes them and optionally emit our own events into Client.Events channel.
func (smc *Client) runRequestHandler(ctx context.Context, websocket chan json.RawMessage) error {
for {
select {
case <-ctx.Done():
return ctx.Err()
case message := <-websocket:
smc.Debugf("Received WebSocket message: %s", message)
// listen for incoming messages that need to be parsed
evt, err := smc.parseEvent(message)
if err != nil {
smc.Events <- newEvent(EventTypeErrorBadMessage, &ErrorBadMessage{
Cause: err,
Message: message,
})
} else if evt != nil {
if evt.Type == EventTypeDisconnect {
// We treat the `disconnect` request from Slack as an error internally,
// so that we can tell the consumer of this function to reopen the connection on it.
return errorRequestedDisconnect{}
}
smc.Events <- *evt
}
}
}
}
// runMessageReceiver monitors the Socket Mode opened WebSocket connection for any incoming
// messages. It pushes the raw events into the channel.
// The receiver runs until the context is closed.
func (smc *Client) runMessageReceiver(ctx context.Context, conn *websocket.Conn, sink chan json.RawMessage) error {
for {
if err := smc.receiveMessagesInto(ctx, conn, sink); err != nil {
return err
}
}
}
// unsafeWriteSocketModeResponse sends a WebSocket message back to Slack.
// WARNING: Call to this function must be serialized!
//
// Here's why - Gorilla WebSocket's Writes functions are not concurrency-safe.
// That is, we must serialize all the writes to it with e.g. a goroutine or mutex.
// We intentionally chose to use goroutine, which makes it harder to propagate write errors to the caller,
// but is more computationally efficient.
//
// See the below for more information on this topic:
// https://stackoverflow.com/questions/43225340/how-to-ensure-concurrency-in-golang-gorilla-websocket-package
func unsafeWriteSocketModeResponse(conn *websocket.Conn, res *Response) error {
// set a write deadline on the connection
if err := conn.SetWriteDeadline(time.Now().Add(10 * time.Second)); err != nil {
return err
}
// Remove write deadline regardless of WriteJSON succeeds or not
defer conn.SetWriteDeadline(time.Time{})
if err := conn.WriteJSON(res); err != nil {
return err
}
return nil
}
func newEvent(tpe EventType, data interface{}, req ...*Request) Event {
evt := Event{Type: tpe, Data: data}
if len(req) > 0 {
evt.Request = req[0]
}
return evt
}
// Ack acknowledges the Socket Mode request with the payload.
//
// This tells Slack that the we have received the request denoted by the envelope ID,
// by sending back the envelope ID over the WebSocket connection.
func (smc *Client) Ack(req Request, payload ...interface{}) {
res := Response{
EnvelopeID: req.EnvelopeID,
}
if len(payload) > 0 {
res.Payload = payload[0]
}
smc.Send(res)
}
// Send sends the Socket Mode response over a WebSocket connection.
// This is usually used for acknowledging requests, but if you need more control over Client.Ack().
// It's normally recommended to use Client.Ack() instead of this.
func (smc *Client) Send(res Response) {
js, err := json.Marshal(res)
if err != nil {
panic(err)
}
smc.Debugf("Scheduling Socket Mode response for envelope ID %s: %s", res.EnvelopeID, js)
smc.socketModeResponses <- &res
}
// receiveMessagesInto attempts to receive an event from the WebSocket connection for Socket Mode.
// This will block until a frame is available from the WebSocket.
// If the read from the WebSocket results in a fatal error, this function will return non-nil.
func (smc *Client) receiveMessagesInto(ctx context.Context, conn *websocket.Conn, sink chan json.RawMessage) error {
smc.Debugf("Starting to receive message")
defer smc.Debugf("Finished to receive message")
event := json.RawMessage{}
err := conn.ReadJSON(&event)
// check if the connection was closed.
if websocket.IsUnexpectedCloseError(err) {
return err
}
switch {
case err == io.ErrUnexpectedEOF:
// EOF's don't seem to signify a failed connection so instead we ignore
// them here and detect a failed connection upon attempting to send a
// 'PING' message
// Unlike RTM, we don't ping from the our end as there seem to have no client ping.
// We just continue to the next loop so that we `smc.disconnected` should be received if
// this EOF error was actually due to disconnection.
return nil
case err != nil:
// All other errors from ReadJSON come from NextReader, and should
// kill the read loop and force a reconnect.
smc.Events <- newEvent(EventTypeIncomingError, &slack.IncomingEventError{
ErrorObj: err,
})
return err
case len(event) == 0:
smc.Debugln("Received empty event")
default:
if smc.debug {
buf := &bytes.Buffer{}
d := json.NewEncoder(buf)
d.SetIndent("", " ")
if err := d.Encode(event); err != nil {
smc.Debugln("Failed encoding decoded json:", err)
}
reencoded := buf.String()
smc.Debugln("Incoming WebSocket message:", reencoded)
}
select {
case sink <- event:
case <-ctx.Done():
smc.Debugln("cancelled while attempting to send raw event")
return ctx.Err()
}
}
return nil
}
// parseEvent takes a raw JSON message received from the slack websocket
// and handles the encoded event.
// returns the our own event that wraps the socket mode request.
func (smc *Client) parseEvent(wsMsg json.RawMessage) (*Event, error) {
req := &Request{}
err := json.Unmarshal(wsMsg, req)
if err != nil {
return nil, fmt.Errorf("unmarshalling WebSocket message: %v", err)
}
var evt Event
// See below two links for all the available message types.
// - https://github.com/slackapi/node-slack-sdk/blob/c3f4d7109062a0356fb765d53794b7b5f6b3b5ae/packages/socket-mode/src/SocketModeClient.ts#L533
// - https://api.slack.com/apis/connections/socket-implement
switch req.Type {
case RequestTypeHello:
evt = newEvent(EventTypeHello, nil, req)
case RequestTypeEventsAPI:
payloadEvent := req.Payload
eventsAPIEvent, err := slackevents.ParseEvent(payloadEvent, slackevents.OptionNoVerifyToken())
if err != nil {
return nil, fmt.Errorf("parsing Events API event: %v", err)
}
evt = newEvent(EventTypeEventsAPI, eventsAPIEvent, req)
case RequestTypeDisconnect:
// See https://api.slack.com/apis/connections/socket-implement#disconnect
evt = newEvent(EventTypeDisconnect, nil, req)
case RequestTypeSlashCommands:
// See https://api.slack.com/apis/connections/socket-implement#command
var cmd slack.SlashCommand
if err := json.Unmarshal(req.Payload, &cmd); err != nil {
return nil, fmt.Errorf("parsing slash command: %v", err)
}
evt = newEvent(EventTypeSlashCommand, cmd, req)
case RequestTypeInteractive:
// See belows:
// - https://api.slack.com/apis/connections/socket-implement#button
// - https://api.slack.com/apis/connections/socket-implement#home
// - https://api.slack.com/apis/connections/socket-implement#modal
// - https://api.slack.com/apis/connections/socket-implement#menu
var callback slack.InteractionCallback
if err := json.Unmarshal(req.Payload, &callback); err != nil {
return nil, fmt.Errorf("parsing interaction callback: %v", err)
}
evt = newEvent(EventTypeInteractive, callback, req)
default:
return nil, fmt.Errorf("processing WebSocket message: encountered unsupported type %q", req.Type)
}
return &evt, nil
}
// handlePing handles an incoming 'PONG' message which should be in response to
// a previously sent 'PING' message. This is then used to compute the
// connection's latency.
func (smc *Client) handlePing(conn *websocket.Conn, event string) {
smc.Debugf("WebSocket ping message received: %s", event)
// In WebSocket, we need to respond a PING from the server with a PONG with the same payload as the PING.
if err := conn.WriteControl(websocket.PongMessage, []byte(event), time.Now().Add(10*time.Second)); err != nil {
smc.Debugf("Failed writing WebSocket PONG message: %v", err)
}
}
slack-0.11.3/socketmode/socket_mode_managed_conn_test.go 0000664 0000000 0000000 00000002030 14307410331 0023370 0 ustar 00root root 0000000 0000000 //go:build go1.13
// +build go1.13
package socketmode
import (
"context"
"errors"
"testing"
"time"
"github.com/slack-go/slack"
"github.com/slack-go/slack/slacktest"
"github.com/stretchr/testify/assert"
)
func Test_passContext(t *testing.T) {
s := slacktest.NewTestServer()
go s.Start()
api := slack.New("ABCDEFG", slack.OptionAPIURL(s.GetAPIURL()))
cli := New(api)
ctx, cancel := context.WithTimeout(context.TODO(), time.Nanosecond)
defer cancel()
t.Run("RunWithContext", func(t *testing.T) {
// should fail imidiatly.
assert.EqualError(t, cli.RunContext(ctx), context.DeadlineExceeded.Error())
})
t.Run("openAndDial", func(t *testing.T) {
_, _, err := cli.openAndDial(ctx, func(_ string) error { return nil })
// should fail imidiatly.
assert.EqualError(t, errors.Unwrap(err), context.DeadlineExceeded.Error())
})
t.Run("OpenWithContext", func(t *testing.T) {
_, _, err := cli.OpenContext(ctx)
// should fail imidiatly.
assert.EqualError(t, errors.Unwrap(err), context.DeadlineExceeded.Error())
})
}
slack-0.11.3/socketmode/socketmode.go 0000664 0000000 0000000 00000007711 14307410331 0017514 0 ustar 00root root 0000000 0000000 package socketmode
import (
"context"
"log"
"os"
"time"
"github.com/gorilla/websocket"
"github.com/slack-go/slack"
)
// EventType is the type of events that are emitted by scoketmode.Client.
// You receive and handle those events from a socketmode.Client.Events channel.
// Those event types does not necessarily match 1:1 to those of Slack Events API events.
type EventType string
const (
// The following request types are the types of requests sent from Slack via Socket Mode WebSocket connection
// and handled internally by the socketmode.Client.
// The consumer of socketmode.Client will never see it.
RequestTypeHello = "hello"
RequestTypeEventsAPI = "events_api"
RequestTypeDisconnect = "disconnect"
RequestTypeSlashCommands = "slash_commands"
RequestTypeInteractive = "interactive"
// The following event types are for events emitted by socketmode.Client itself and
// does not originate from Slack.
EventTypeConnecting = EventType("connecting")
EventTypeInvalidAuth = EventType("invalid_auth")
EventTypeConnectionError = EventType("connection_error")
EventTypeConnected = EventType("connected")
EventTypeIncomingError = EventType("incoming_error")
EventTypeErrorWriteFailed = EventType("write_error")
EventTypeErrorBadMessage = EventType("error_bad_message")
//
// The following event types are guaranteed to not change unless Slack changes
//
EventTypeHello = EventType("hello")
EventTypeDisconnect = EventType("disconnect")
EventTypeEventsAPI = EventType("events_api")
EventTypeInteractive = EventType("interactive")
EventTypeSlashCommand = EventType("slash_commands")
websocketDefaultTimeout = 10 * time.Second
defaultMaxPingInterval = 30 * time.Second
)
// Open calls the "apps.connections.open" endpoint and returns the provided URL and the full Info block.
//
// To have a fully managed Websocket connection, use `New`, and call `Run()` on it.
func (smc *Client) Open() (info *slack.SocketModeConnection, websocketURL string, err error) {
ctx, cancel := context.WithTimeout(context.Background(), websocketDefaultTimeout)
defer cancel()
return smc.StartSocketModeContext(ctx)
}
// OpenContext calls the "apps.connections.open" endpoint and returns the provided URL and the full Info block.
//
// To have a fully managed Websocket connection, use `New`, and call `Run()` on it.
func (smc *Client) OpenContext(ctx context.Context) (info *slack.SocketModeConnection, websocketURL string, err error) {
return smc.StartSocketModeContext(ctx)
}
// Option options for the managed Client.
type Option func(client *Client)
// OptionDialer takes a gorilla websocket Dialer and uses it as the
// Dialer when opening the websocket for the Socket Mode connection.
func OptionDialer(d *websocket.Dialer) Option {
return func(smc *Client) {
smc.dialer = d
}
}
// OptionPingInterval determines how often we expect Slack to deliver WebSocket ping to us.
// If no ping is delivered to us within this interval after the last ping, we assumes the WebSocket connection
// is dead and needs to be reconnected.
func OptionPingInterval(d time.Duration) Option {
return func(smc *Client) {
smc.maxPingInterval = d
}
}
// OptionDebug enable debugging for the client
func OptionDebug(b bool) func(*Client) {
return func(c *Client) {
c.debug = b
}
}
// OptionLog set logging for client.
func OptionLog(l logger) func(*Client) {
return func(c *Client) {
c.log = internalLog{logger: l}
}
}
// New returns a Socket Mode client which provides a fully managed connection to
// Slack's Websocket-based Socket Mode.
func New(api *slack.Client, options ...Option) *Client {
result := &Client{
Client: *api,
Events: make(chan Event, 50),
socketModeResponses: make(chan *Response, 20),
maxPingInterval: defaultMaxPingInterval,
log: log.New(os.Stderr, "slack-go/slack/socketmode", log.LstdFlags|log.Lshortfile),
}
for _, opt := range options {
opt(result)
}
return result
}
slack-0.11.3/socketmode/socketmode_handler.go 0000664 0000000 0000000 00000015606 14307410331 0021213 0 ustar 00root root 0000000 0000000 package socketmode
import (
"github.com/slack-go/slack"
"github.com/slack-go/slack/slackevents"
)
type SocketmodeHandler struct {
Client *Client
//lvl 1 - the most generic type of event
EventMap map[EventType][]SocketmodeHandlerFunc
//lvl 2 - Manage event by inner type
InteractionEventMap map[slack.InteractionType][]SocketmodeHandlerFunc
EventApiMap map[slackevents.EventsAPIType][]SocketmodeHandlerFunc
//lvl 3 - the most userfriendly way of managing event
InteractionBlockActionEventMap map[string]SocketmodeHandlerFunc
SlashCommandMap map[string]SocketmodeHandlerFunc
Default SocketmodeHandlerFunc
}
// Handler have access to the event and socketmode client
type SocketmodeHandlerFunc func(*Event, *Client)
// Middleware accept SocketmodeHandlerFunc, and return SocketmodeHandlerFunc
type SocketmodeMiddlewareFunc func(SocketmodeHandlerFunc) SocketmodeHandlerFunc
// Initialization constructor for SocketmodeHandler
func NewSocketmodeHandler(client *Client) *SocketmodeHandler {
eventMap := make(map[EventType][]SocketmodeHandlerFunc)
interactionEventMap := make(map[slack.InteractionType][]SocketmodeHandlerFunc)
eventApiMap := make(map[slackevents.EventsAPIType][]SocketmodeHandlerFunc)
interactionBlockActionEventMap := make(map[string]SocketmodeHandlerFunc)
slackCommandMap := make(map[string]SocketmodeHandlerFunc)
return &SocketmodeHandler{
Client: client,
EventMap: eventMap,
EventApiMap: eventApiMap,
InteractionEventMap: interactionEventMap,
InteractionBlockActionEventMap: interactionBlockActionEventMap,
SlashCommandMap: slackCommandMap,
Default: func(e *Event, c *Client) {
c.log.Printf("Unexpected event type received: %v\n", e.Type)
},
}
}
// Register a middleware or handler for an Event from socketmode
// This most general entrypoint
func (r *SocketmodeHandler) Handle(et EventType, f SocketmodeHandlerFunc) {
r.EventMap[et] = append(r.EventMap[et], f)
}
// Register a middleware or handler for an Interaction
// There is several types of interactions, decated functions lets you better handle them
// See
// * HandleInteractionBlockAction
// * (Not Implemented) HandleShortcut
// * (Not Implemented) HandleView
func (r *SocketmodeHandler) HandleInteraction(et slack.InteractionType, f SocketmodeHandlerFunc) {
r.InteractionEventMap[et] = append(r.InteractionEventMap[et], f)
}
// Register a middleware or handler for a Block Action referenced by its ActionID
func (r *SocketmodeHandler) HandleInteractionBlockAction(actionID string, f SocketmodeHandlerFunc) {
if actionID == "" {
panic("invalid command cannot be empty")
}
if f == nil {
panic("invalid handler cannot be nil")
}
if _, exist := r.InteractionBlockActionEventMap[actionID]; exist {
panic("multiple registrations for actionID" + actionID)
}
r.InteractionBlockActionEventMap[actionID] = f
}
// Register a middleware or handler for an Event (from slackevents)
func (r *SocketmodeHandler) HandleEvents(et slackevents.EventsAPIType, f SocketmodeHandlerFunc) {
r.EventApiMap[et] = append(r.EventApiMap[et], f)
}
// Register a middleware or handler for a Slash Command
func (r *SocketmodeHandler) HandleSlashCommand(command string, f SocketmodeHandlerFunc) {
if command == "" {
panic("invalid command cannot be empty")
}
if f == nil {
panic("invalid handler cannot be nil")
}
if _, exist := r.SlashCommandMap[command]; exist {
panic("multiple registrations for command" + command)
}
r.SlashCommandMap[command] = f
}
// Register a middleware or handler to use as a last resort
func (r *SocketmodeHandler) HandleDefault(f SocketmodeHandlerFunc) {
r.Default = f
}
// RunSlackEventLoop receives the event via the socket
func (r *SocketmodeHandler) RunEventLoop() error {
go r.runEventLoop()
return r.Client.Run()
}
// Call the dispatcher for each incomming event
func (r *SocketmodeHandler) runEventLoop() {
for evt := range r.Client.Events {
r.dispatcher(evt)
}
}
// Dispatch events to the specialized dispatcher
func (r *SocketmodeHandler) dispatcher(evt Event) {
var ishandled bool
// Some eventType can be further decomposed
switch evt.Type {
case EventTypeInteractive:
ishandled = r.interactionDispatcher(&evt)
case EventTypeEventsAPI:
ishandled = r.eventAPIDispatcher(&evt)
case EventTypeSlashCommand:
ishandled = r.slashCommandDispatcher(&evt)
default:
ishandled = r.socketmodeDispatcher(&evt)
}
if !ishandled {
go r.Default(&evt, r.Client)
}
}
// Dispatch socketmode events to the registered middleware
func (r *SocketmodeHandler) socketmodeDispatcher(evt *Event) bool {
if handlers, ok := r.EventMap[evt.Type]; ok {
// If we registered an event
for _, f := range handlers {
go f(evt, r.Client)
}
return true
}
return false
}
// Dispatch interactions to the registered middleware
func (r *SocketmodeHandler) interactionDispatcher(evt *Event) bool {
var ishandled bool = false
interaction, ok := evt.Data.(slack.InteractionCallback)
if !ok {
r.Client.log.Printf("Ignored %+v\n", evt)
return false
}
// Level 1 - socketmode EventType
ishandled = r.socketmodeDispatcher(evt)
// Level 2 - interaction EventType
if handlers, ok := r.InteractionEventMap[interaction.Type]; ok {
// If we registered an event
for _, f := range handlers {
go f(evt, r.Client)
}
ishandled = true
}
// Level 3 - interaction with actionID
blockActions := interaction.ActionCallback.BlockActions
// outmoded approach won`t be implemented
// attachments_actions := interaction.ActionCallback.AttachmentActions
for _, action := range blockActions {
if handler, ok := r.InteractionBlockActionEventMap[action.ActionID]; ok {
go handler(evt, r.Client)
ishandled = true
}
}
return ishandled
}
// Dispatch eventAPI events to the registered middleware
func (r *SocketmodeHandler) eventAPIDispatcher(evt *Event) bool {
var ishandled bool = false
eventsAPIEvent, ok := evt.Data.(slackevents.EventsAPIEvent)
if !ok {
r.Client.log.Printf("Ignored %+v\n", evt)
return false
}
innerEventType := slackevents.EventsAPIType(eventsAPIEvent.InnerEvent.Type)
// Level 1 - socketmode EventType
ishandled = r.socketmodeDispatcher(evt)
// Level 2 - EventAPI EventType
if handlers, ok := r.EventApiMap[innerEventType]; ok {
// If we registered an event
for _, f := range handlers {
go f(evt, r.Client)
}
ishandled = true
}
return ishandled
}
// Dispatch SlashCommands events to the registered middleware
func (r *SocketmodeHandler) slashCommandDispatcher(evt *Event) bool {
var ishandled bool = false
slashCommandEvent, ok := evt.Data.(slack.SlashCommand)
if !ok {
r.Client.log.Printf("Ignored %+v\n", evt)
return false
}
// Level 1 - socketmode EventType
ishandled = r.socketmodeDispatcher(evt)
// Level 2 - SlackCommand by name
if handler, ok := r.SlashCommandMap[slashCommandEvent.Command]; ok {
go handler(evt, r.Client)
ishandled = true
}
return ishandled
}
slack-0.11.3/socketmode/socketmode_handler_test.go 0000664 0000000 0000000 00000032566 14307410331 0022256 0 ustar 00root root 0000000 0000000 package socketmode
import (
"log"
"os"
"reflect"
"runtime"
"testing"
"github.com/slack-go/slack"
"github.com/slack-go/slack/slackevents"
)
func init_SocketmodeHandler() *SocketmodeHandler {
eventMap := make(map[EventType][]SocketmodeHandlerFunc)
interactioneventMap := make(map[slack.InteractionType][]SocketmodeHandlerFunc)
eventApiMap := make(map[slackevents.EventsAPIType][]SocketmodeHandlerFunc)
interactionBlockActionEventMap := make(map[string]SocketmodeHandlerFunc)
slashCommandMap := make(map[string]SocketmodeHandlerFunc)
return &SocketmodeHandler{
Client: &Client{
log: log.New(os.Stderr, "slack-go/slack/socketmode", log.LstdFlags|log.Lshortfile),
},
EventMap: eventMap,
EventApiMap: eventApiMap,
InteractionEventMap: interactioneventMap,
InteractionBlockActionEventMap: interactionBlockActionEventMap,
SlashCommandMap: slashCommandMap,
}
}
// The goal of this function is to catch the name of the function that is behing called
// This let us validate that the dispatcher did its job correctly
func testing_wrapper(ch chan<- string, f SocketmodeHandlerFunc) SocketmodeHandlerFunc {
return SocketmodeHandlerFunc(func(e *Event, c *Client) {
f(e, c)
var name_f string
// test with the name of the function we called
v := reflect.ValueOf(f)
if v.Kind() == reflect.Func {
if rf := runtime.FuncForPC(v.Pointer()); rf != nil {
name_f = rf.Name()
}
} else {
name_f = v.String()
}
ch <- name_f
})
}
func middleware_interaction(evt *Event, client *Client) {
//do nothing
}
func middleware_interaction_block_action(evt *Event, client *Client) {
//do nothing
}
func middleware_eventapi(evt *Event, client *Client) {
//do nothing
}
func middleware(evt *Event, client *Client) {
//do nothing
}
func defaultmiddleware(evt *Event, client *Client) {
//do nothing
}
func middleware_slach_command(evt *Event, client *Client) {
//do nothing
}
func TestSocketmodeHandler_Handle(t *testing.T) {
type args struct {
evt Event
evt_type EventType
}
tests := []struct {
name string
args args
want string //what is the name of the function we want to be called
}{
{
name: "Event Match registered function",
args: args{
evt: Event{
Type: EventTypeConnecting,
},
evt_type: EventTypeConnecting,
},
want: "github.com/slack-go/slack/socketmode.middleware",
}, {
name: "Event do not registered function",
args: args{
evt: Event{
Type: EventTypeConnected,
},
evt_type: EventTypeConnecting,
},
want: "github.com/slack-go/slack/socketmode.defaultmiddleware",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
r := init_SocketmodeHandler()
c := make(chan string)
r.Handle(tt.args.evt_type, testing_wrapper(c, middleware))
r.HandleDefault(testing_wrapper(c, defaultmiddleware))
r.dispatcher(tt.args.evt)
got := <-c
if got != tt.want {
t.Fatalf("middleware was not called for EventTy(\"%v\"), got %v", tt.args.evt_type, got)
}
})
}
}
func TestSocketmodeHandler_HandleInteraction(t *testing.T) {
type args struct {
evt Event
register func(*SocketmodeHandler, chan<- string)
}
tests := []struct {
name string
args args
want string //what is the name of the function we want to be called
}{
{
name: "Event Match registered function",
args: args{
evt: Event{
Type: EventTypeInteractive,
Data: slack.InteractionCallback{
Type: slack.InteractionTypeBlockActions,
},
},
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleInteraction(slack.InteractionTypeBlockActions, testing_wrapper(c, middleware_interaction))
},
},
want: "github.com/slack-go/slack/socketmode.middleware_interaction",
}, {
name: "Event do not Match any registered function",
args: args{
evt: Event{
Type: EventTypeInteractive,
Data: slack.InteractionCallback{
Type: slack.InteractionTypeBlockActions,
},
},
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleInteraction(slack.InteractionTypeBlockSuggestion, testing_wrapper(c, middleware_interaction))
},
},
want: "github.com/slack-go/slack/socketmode.defaultmiddleware",
}, {
name: "Event with invalid data is handled by default middleware",
args: args{
evt: Event{
Type: EventTypeInteractive,
Data: map[string]string{
"brokendata": "test",
},
},
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleInteraction(slack.InteractionTypeBlockActions, testing_wrapper(c, middleware_interaction))
},
},
want: "github.com/slack-go/slack/socketmode.defaultmiddleware",
}, {
name: "Event is handled as EventTypeInteractive",
args: args{
evt: Event{
Type: EventTypeInteractive,
Data: slack.InteractionCallback{
Type: slack.InteractionTypeBlockActions,
},
},
register: func(r *SocketmodeHandler, c chan<- string) {
r.Handle(EventTypeInteractive, testing_wrapper(c, middleware))
},
},
want: "github.com/slack-go/slack/socketmode.middleware",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
r := init_SocketmodeHandler()
c := make(chan string)
tt.args.register(r, c)
r.HandleDefault(testing_wrapper(c, defaultmiddleware))
r.dispatcher(tt.args.evt)
got := <-c
if got != tt.want {
t.Fatalf("%s was not called for EventTy(\"%v\"), got %v", tt.want, tt.args.evt.Type, got)
}
})
}
}
func TestSocketmodeHandler_HandleEvents(t *testing.T) {
type args struct {
evt Event
register func(*SocketmodeHandler, chan<- string)
}
tests := []struct {
name string
args args
want string //what is the name of the function we want to be called
}{
{
name: "Event Match registered function",
args: args{
evt: Event{
Type: EventTypeEventsAPI,
Data: slackevents.EventsAPIEvent{
Type: "event_callback",
InnerEvent: slackevents.EventsAPIInnerEvent{
Type: string(slackevents.AppMention),
},
},
},
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleEvents(slackevents.AppMention, testing_wrapper(c, middleware_eventapi))
},
},
want: "github.com/slack-go/slack/socketmode.middleware_eventapi",
}, {
name: "Event do not Match any registered function",
args: args{
evt: Event{
Type: EventTypeEventsAPI,
Data: slackevents.EventsAPIEvent{
Type: "event_callback",
InnerEvent: slackevents.EventsAPIInnerEvent{
Type: string(slackevents.MemberJoinedChannel),
},
},
},
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleEvents(slackevents.AppMention, testing_wrapper(c, middleware_eventapi))
},
},
want: "github.com/slack-go/slack/socketmode.defaultmiddleware",
}, {
name: "Event with invalid data is handled by default middleware",
args: args{
evt: Event{
Type: EventTypeEventsAPI,
Data: map[string]string{
"brokendata": "test",
},
},
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleEvents(slackevents.AppMention, testing_wrapper(c, middleware_eventapi))
},
},
want: "github.com/slack-go/slack/socketmode.defaultmiddleware",
}, {
name: "Event is handled as EventTypeInteractive",
args: args{
evt: Event{
Type: EventTypeEventsAPI,
Data: slackevents.EventsAPIEvent{
Type: "event_callback",
InnerEvent: slackevents.EventsAPIInnerEvent{
Type: string(slackevents.MemberJoinedChannel),
},
},
},
register: func(r *SocketmodeHandler, c chan<- string) {
r.Handle(EventTypeEventsAPI, testing_wrapper(c, middleware))
},
},
want: "github.com/slack-go/slack/socketmode.middleware",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
r := init_SocketmodeHandler()
c := make(chan string)
tt.args.register(r, c)
r.HandleDefault(testing_wrapper(c, defaultmiddleware))
r.dispatcher(tt.args.evt)
got := <-c
if got != tt.want {
t.Fatalf("%s was not called for EventTy(\"%v\"), got %v", tt.want, tt.args.evt.Type, got)
}
})
}
}
func TestSocketmodeHandler_HandleInteractionBlockAction(t *testing.T) {
type args struct {
evt Event
register func(*SocketmodeHandler, chan<- string)
}
tests := []struct {
name string
args args
want string //what is the name of the function we want to be called
}{
{
name: "Event Match registered function",
args: args{
evt: Event{
Type: EventTypeInteractive,
Data: slack.InteractionCallback{
Type: slack.InteractionTypeBlockActions,
ActionCallback: slack.ActionCallbacks{
BlockActions: []*slack.BlockAction{
{
ActionID: "add_note",
Text: slack.TextBlockObject{
Type: "plain_text",
Text: "Add a Stickie",
},
},
},
},
},
},
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleInteractionBlockAction("add_note", testing_wrapper(c, middleware_interaction_block_action))
},
},
want: "github.com/slack-go/slack/socketmode.middleware_interaction_block_action",
}, {
name: "Event do not Match any registered function",
args: args{
evt: Event{
Type: EventTypeInteractive,
Data: slack.InteractionCallback{
Type: slack.InteractionTypeBlockActions,
},
},
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleInteractionBlockAction("add_note", testing_wrapper(c, middleware_interaction_block_action))
},
},
want: "github.com/slack-go/slack/socketmode.defaultmiddleware",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
r := init_SocketmodeHandler()
c := make(chan string)
tt.args.register(r, c)
r.HandleDefault(testing_wrapper(c, defaultmiddleware))
r.dispatcher(tt.args.evt)
got := <-c
if got != tt.want {
t.Fatalf("%s was not called for EventTy(\"%v\"), got %v", tt.want, tt.args.evt.Type, got)
}
})
}
}
func TestSocketmodeHandler_HandleSlashCommand(t *testing.T) {
type args struct {
evt Event
register func(*SocketmodeHandler, chan<- string)
}
tests := []struct {
name string
args args
want string //what is the name of the function we want to be called
}{
{
name: "Event Match registered function",
args: args{
evt: Event{
Type: EventTypeSlashCommand,
Data: slack.SlashCommand{
Command: "/rocket",
Text: "key=value",
},
},
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleSlashCommand("/rocket", testing_wrapper(c, middleware_slach_command))
},
},
want: "github.com/slack-go/slack/socketmode.middleware_slach_command",
}, {
name: "Event do not Match any registered function",
args: args{
evt: Event{
Type: EventTypeSlashCommand,
Data: slack.SlashCommand{
Command: "/broken_rocket",
Text: "key=value",
},
},
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleSlashCommand("/rocket", testing_wrapper(c, middleware_slach_command))
},
},
want: "github.com/slack-go/slack/socketmode.defaultmiddleware",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
r := init_SocketmodeHandler()
c := make(chan string)
tt.args.register(r, c)
r.HandleDefault(testing_wrapper(c, defaultmiddleware))
r.dispatcher(tt.args.evt)
got := <-c
if got != tt.want {
t.Fatalf("%s was not called for EventTy(\"%v\"), got %v", tt.want, tt.args.evt.Type, got)
}
})
}
}
func TestSocketmodeHandler_Handle_errors(t *testing.T) {
type args struct {
register func(*SocketmodeHandler, chan<- string)
}
tests := []struct {
name string
args args
}{
{
name: "Attempt to register empty command",
args: args{
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleSlashCommand("", testing_wrapper(c, middleware_slach_command))
},
},
}, {
name: "Attempt to register nil handler",
args: args{
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleSlashCommand("/command", nil)
},
},
}, {
name: "Attempt to register duplicate command",
args: args{
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleSlashCommand("/command", testing_wrapper(c, middleware_slach_command))
r.HandleSlashCommand("/command", testing_wrapper(c, middleware_slach_command))
},
},
}, {
name: "Attempt to register empty Block ActionID",
args: args{
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleInteractionBlockAction("", testing_wrapper(c, middleware_interaction_block_action))
},
},
}, {
name: "Attempt to register nil handler",
args: args{
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleInteractionBlockAction("action_id", nil)
},
},
}, {
name: "Attempt to register duplicate Block ActionID",
args: args{
register: func(r *SocketmodeHandler, c chan<- string) {
r.HandleInteractionBlockAction("action_id", testing_wrapper(c, middleware_interaction_block_action))
r.HandleInteractionBlockAction("action_id", testing_wrapper(c, middleware_interaction_block_action))
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
r := init_SocketmodeHandler()
c := make(chan string)
defer func() { recover() }()
tt.args.register(r, c)
t.Errorf("should have panicked")
})
}
}
slack-0.11.3/socketmode/socketmode_test.go 0000664 0000000 0000000 00000015413 14307410331 0020551 0 ustar 00root root 0000000 0000000 package socketmode
import (
"bytes"
"encoding/json"
"errors"
"reflect"
"testing"
"github.com/slack-go/slack/slackevents"
)
const (
EventDisconnect = `{
"type": "disconnect",
"reason": "warning",
"debug_info": {
"host": "applink-7fc4fdbb64-4x5xq"
}
}
`
EventHello = `{
"type": "hello",
"num_connections": 4,
"debug_info": {
"host": "applink-7fc4fdbb64-4x5xq",
"build_number": 10,
"approximate_connection_time": 18060
},
"connection_info": {
"app_id": "A01K58AR4RF"
}
}
`
EventAppMention = `{
"envelope_id": "c67a03d0-4094-4744-90ca-d286e00a3ab1",
"payload": {
"token": "redacted",
"team_id": "redacted",
"api_app_id": "redacted",
"event": {
"client_msg_id": "c714568f-67df-42d7-a343-0a8e4d9c6030",
"type": "app_mention",
"text": "\u003c@U01JKSB8T7Y\u003e test",
"user": "redacted",
"ts": "1610927831.000200",
"team": "redacted",
"blocks": [
{
"type": "rich_text",
"block_id": "2Le",
"elements": [
{
"type": "rich_text_section",
"elements": [
{
"type": "user",
"user_id": "redacted"
},
{
"type": "text",
"text": " test39"
}
]
}
]
}
],
"channel": "redacted",
"event_ts": "1610927831.000200"
},
"type": "event_callback",
"event_id": "Ev01JZ2T7S3U",
"event_time": 1610927831,
"authorizations": [
{
"enterprise_id": null,
"team_id": "redacted",
"user_id": "redacted",
"is_bot": true,
"is_enterprise_install": false
}
],
"is_ext_shared_channel": false,
"event_context": "1-app_mention-redacted-redacted"
},
"type": "events_api",
"accepts_response_payload": false,
"retry_attempt": 0,
"retry_reason": ""
}`
)
func TestEventParsing(t *testing.T) {
testParsing(t,
EventHello,
&Event{
Type: EventTypeHello,
Request: &Request{
Type: RequestTypeHello,
NumConnections: 4,
DebugInfo: DebugInfo{
Host: "applink-7fc4fdbb64-4x5xq",
BuildNumber: 10,
ApproximateConnectionTime: 18060,
},
ConnectionInfo: ConnectionInfo{
AppID: "A01K58AR4RF",
},
},
})
testParsing(t,
EventDisconnect,
&Event{
Type: EventTypeDisconnect,
Request: &Request{
Type: RequestTypeDisconnect,
Reason: "warning",
DebugInfo: DebugInfo{
Host: "applink-7fc4fdbb64-4x5xq",
},
},
})
rawAppMention := json.RawMessage(`{
"client_msg_id": "c714568f-67df-42d7-a343-0a8e4d9c6030",
"type": "app_mention",
"text": "\u003c@U01JKSB8T7Y\u003e test",
"user": "redacted",
"ts": "1610927831.000200",
"team": "redacted",
"blocks": [
{
"type": "rich_text",
"block_id": "2Le",
"elements": [
{
"type": "rich_text_section",
"elements": [
{
"type": "user",
"user_id": "redacted"
},
{
"type": "text",
"text": " test39"
}
]
}
]
}
],
"channel": "redacted",
"event_ts": "1610927831.000200"
}`)
rawAppMentionReqPayload := json.RawMessage(`{
"token": "redacted",
"team_id": "redacted",
"api_app_id": "redacted",
"event": {
"client_msg_id": "c714568f-67df-42d7-a343-0a8e4d9c6030",
"type": "app_mention",
"text": "\u003c@U01JKSB8T7Y\u003e test",
"user": "redacted",
"ts": "1610927831.000200",
"team": "redacted",
"blocks": [
{
"type": "rich_text",
"block_id": "2Le",
"elements": [
{
"type": "rich_text_section",
"elements": [
{
"type": "user",
"user_id": "redacted"
},
{
"type": "text",
"text": " test39"
}
]
}
]
}
],
"channel": "redacted",
"event_ts": "1610927831.000200"
},
"type": "event_callback",
"event_id": "Ev01JZ2T7S3U",
"event_time": 1610927831,
"authorizations": [
{
"enterprise_id": null,
"team_id": "redacted",
"user_id": "redacted",
"is_bot": true,
"is_enterprise_install": false
}
],
"is_ext_shared_channel": false,
"event_context": "1-app_mention-redacted-redacted"
}`)
testParsing(t,
EventAppMention,
&Event{
Type: EventTypeEventsAPI,
Data: slackevents.EventsAPIEvent{
Token: "redacted",
TeamID: "redacted",
Type: "event_callback",
APIAppID: "redacted",
Data: &slackevents.EventsAPICallbackEvent{
Type: "event_callback",
Token: "redacted",
TeamID: "redacted",
APIAppID: "redacted",
InnerEvent: &rawAppMention,
AuthedUsers: nil,
AuthedTeams: nil,
EventID: "Ev01JZ2T7S3U",
EventTime: 1610927831,
EventContext: "1-app_mention-redacted-redacted",
},
InnerEvent: slackevents.EventsAPIInnerEvent{
Type: string(slackevents.AppMention),
Data: &slackevents.AppMentionEvent{
Type: string(slackevents.AppMention),
User: "redacted",
Text: "<@U01JKSB8T7Y> test",
TimeStamp: "1610927831.000200",
ThreadTimeStamp: "",
Channel: "redacted",
EventTimeStamp: "1610927831.000200",
},
},
},
Request: &Request{
Type: RequestTypeEventsAPI,
EnvelopeID: "c67a03d0-4094-4744-90ca-d286e00a3ab1",
Payload: rawAppMentionReqPayload,
AcceptsResponsePayload: false,
RetryAttempt: 0,
RetryReason: "",
},
})
}
func testParsing(t *testing.T, raw string, want interface{}) {
t.Helper()
got, err := parse(raw)
if err != nil {
t.Fatalf("unexpected error parsing event %q: %v", raw, err)
}
if !reflect.DeepEqual(want, got) {
t.Fatalf("unexpected parse result: want %s, got %s", dump(t, want), dump(t, got))
}
}
func dump(t *testing.T, data interface{}) string {
t.Helper()
var buf bytes.Buffer
e := json.NewEncoder(&buf)
e.SetIndent("", " ")
if err := e.Encode(data); err != nil {
t.Fatalf("encoding data to json: %v", err)
}
return buf.String()
}
func parse(raw string) (*Event, error) {
c := &Client{}
evt, err := c.parseEvent(json.RawMessage([]byte(raw)))
if evt == nil {
return nil, errors.New("failed handling raw event: event was empty")
}
return evt, err
}
slack-0.11.3/stars.go 0000664 0000000 0000000 00000015263 14307410331 0014357 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"net/url"
"strconv"
"time"
)
const (
DEFAULT_STARS_USER = ""
DEFAULT_STARS_COUNT = 100
DEFAULT_STARS_PAGE = 1
)
type StarsParameters struct {
User string
Count int
Page int
}
type StarredItem Item
type listResponseFull struct {
Items []Item `json:"items"`
Paging `json:"paging"`
SlackResponse
}
// NewStarsParameters initialises StarsParameters with default values
func NewStarsParameters() StarsParameters {
return StarsParameters{
User: DEFAULT_STARS_USER,
Count: DEFAULT_STARS_COUNT,
Page: DEFAULT_STARS_PAGE,
}
}
// AddStar stars an item in a channel
func (api *Client) AddStar(channel string, item ItemRef) error {
return api.AddStarContext(context.Background(), channel, item)
}
// AddStarContext stars an item in a channel with a custom context
func (api *Client) AddStarContext(ctx context.Context, channel string, item ItemRef) error {
values := url.Values{
"channel": {channel},
"token": {api.token},
}
if item.Timestamp != "" {
values.Set("timestamp", item.Timestamp)
}
if item.File != "" {
values.Set("file", item.File)
}
if item.Comment != "" {
values.Set("file_comment", item.Comment)
}
response := &SlackResponse{}
if err := api.postMethod(ctx, "stars.add", values, response); err != nil {
return err
}
return response.Err()
}
// RemoveStar removes a starred item from a channel
func (api *Client) RemoveStar(channel string, item ItemRef) error {
return api.RemoveStarContext(context.Background(), channel, item)
}
// RemoveStarContext removes a starred item from a channel with a custom context
func (api *Client) RemoveStarContext(ctx context.Context, channel string, item ItemRef) error {
values := url.Values{
"channel": {channel},
"token": {api.token},
}
if item.Timestamp != "" {
values.Set("timestamp", item.Timestamp)
}
if item.File != "" {
values.Set("file", item.File)
}
if item.Comment != "" {
values.Set("file_comment", item.Comment)
}
response := &SlackResponse{}
if err := api.postMethod(ctx, "stars.remove", values, response); err != nil {
return err
}
return response.Err()
}
// ListStars returns information about the stars a user added
func (api *Client) ListStars(params StarsParameters) ([]Item, *Paging, error) {
return api.ListStarsContext(context.Background(), params)
}
// ListStarsContext returns information about the stars a user added with a custom context
func (api *Client) ListStarsContext(ctx context.Context, params StarsParameters) ([]Item, *Paging, error) {
values := url.Values{
"token": {api.token},
}
if params.User != DEFAULT_STARS_USER {
values.Add("user", params.User)
}
if params.Count != DEFAULT_STARS_COUNT {
values.Add("count", strconv.Itoa(params.Count))
}
if params.Page != DEFAULT_STARS_PAGE {
values.Add("page", strconv.Itoa(params.Page))
}
response := &listResponseFull{}
err := api.postMethod(ctx, "stars.list", values, response)
if err != nil {
return nil, nil, err
}
if err := response.Err(); err != nil {
return nil, nil, err
}
return response.Items, &response.Paging, nil
}
// GetStarred returns a list of StarredItem items.
//
// The user then has to iterate over them and figure out what they should
// be looking at according to what is in the Type:
//
// for _, item := range items {
// switch c.Type {
// case "file_comment":
// log.Println(c.Comment)
// case "file":
// ...
// }
//
// This function still exists to maintain backwards compatibility.
// I exposed it as returning []StarredItem, so it shall stay as StarredItem.
func (api *Client) GetStarred(params StarsParameters) ([]StarredItem, *Paging, error) {
return api.GetStarredContext(context.Background(), params)
}
// GetStarredContext returns a list of StarredItem items with a custom context
//
// For more details see GetStarred
func (api *Client) GetStarredContext(ctx context.Context, params StarsParameters) ([]StarredItem, *Paging, error) {
items, paging, err := api.ListStarsContext(ctx, params)
if err != nil {
return nil, nil, err
}
starredItems := make([]StarredItem, len(items))
for i, item := range items {
starredItems[i] = StarredItem(item)
}
return starredItems, paging, nil
}
type listResponsePaginated struct {
Items []Item `json:"items"`
SlackResponse
Metadata ResponseMetadata `json:"response_metadata"`
}
// StarredItemPagination allows for paginating over the starred items
type StarredItemPagination struct {
Items []Item
limit int
previousResp *ResponseMetadata
c *Client
}
// ListStarsOption options for the GetUsers method call.
type ListStarsOption func(*StarredItemPagination)
// ListAllStars returns the complete list of starred items
func (api *Client) ListAllStars() ([]Item, error) {
return api.ListAllStarsContext(context.Background())
}
// ListAllStarsContext returns the list of users (with their detailed information) with a custom context
func (api *Client) ListAllStarsContext(ctx context.Context) (results []Item, err error) {
p := api.ListStarsPaginated()
for err == nil {
p, err = p.next(ctx)
if err == nil {
results = append(results, p.Items...)
} else if rateLimitedError, ok := err.(*RateLimitedError); ok {
select {
case <-ctx.Done():
err = ctx.Err()
case <-time.After(rateLimitedError.RetryAfter):
err = nil
}
}
}
return results, p.failure(err)
}
// ListStarsPaginated fetches users in a paginated fashion, see ListStarsPaginationContext for usage.
func (api *Client) ListStarsPaginated(options ...ListStarsOption) StarredItemPagination {
return newStarPagination(api, options...)
}
func newStarPagination(c *Client, options ...ListStarsOption) (sip StarredItemPagination) {
sip = StarredItemPagination{
c: c,
limit: 200, // per slack api documentation.
}
for _, opt := range options {
opt(&sip)
}
return sip
}
// done checks if the pagination has completed
func (StarredItemPagination) done(err error) bool {
return err == errPaginationComplete
}
// done checks if pagination failed.
func (t StarredItemPagination) failure(err error) error {
if t.done(err) {
return nil
}
return err
}
// next gets the next list of starred items based on the cursor value
func (t StarredItemPagination) next(ctx context.Context) (_ StarredItemPagination, err error) {
var (
resp *listResponsePaginated
)
if t.c == nil || (t.previousResp != nil && t.previousResp.Cursor == "") {
return t, errPaginationComplete
}
t.previousResp = t.previousResp.initialize()
values := url.Values{
"limit": {strconv.Itoa(t.limit)},
"token": {t.c.token},
"cursor": {t.previousResp.Cursor},
}
if err = t.c.postMethod(ctx, "stars.list", values, &resp); err != nil {
return t, err
}
t.previousResp = &resp.Metadata
t.Items = resp.Items
return t, nil
}
slack-0.11.3/stars_test.go 0000664 0000000 0000000 00000015066 14307410331 0015417 0 ustar 00root root 0000000 0000000 package slack
import (
"fmt"
"net/http"
"reflect"
"testing"
)
type starsHandler struct {
gotParams map[string]string
response string
}
func newStarsHandler() *starsHandler {
return &starsHandler{
gotParams: make(map[string]string),
response: `{ "ok": true }`,
}
}
func (sh *starsHandler) accumulateFormValue(k string, r *http.Request) {
if v := r.FormValue(k); v != "" {
sh.gotParams[k] = v
}
}
func (sh *starsHandler) handler(w http.ResponseWriter, r *http.Request) {
sh.accumulateFormValue("user", r)
sh.accumulateFormValue("count", r)
sh.accumulateFormValue("channel", r)
sh.accumulateFormValue("file", r)
sh.accumulateFormValue("file_comment", r)
sh.accumulateFormValue("page", r)
sh.accumulateFormValue("timestamp", r)
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(sh.response))
}
func TestSlack_AddStar(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
tests := []struct {
channel string
ref ItemRef
wantParams map[string]string
}{
{
"ChannelID",
NewRefToMessage("ChannelID", "123"),
map[string]string{
"channel": "ChannelID",
"timestamp": "123",
},
},
{
"ChannelID",
NewRefToFile("FileID"),
map[string]string{
"channel": "ChannelID",
"file": "FileID",
},
},
{
"ChannelID",
NewRefToComment("FileCommentID"),
map[string]string{
"channel": "ChannelID",
"file_comment": "FileCommentID",
},
},
}
var rh *starsHandler
http.HandleFunc("/stars.add", func(w http.ResponseWriter, r *http.Request) { rh.handler(w, r) })
for i, test := range tests {
rh = newStarsHandler()
err := api.AddStar(test.channel, test.ref)
if err != nil {
t.Fatalf("%d: Unexpected error: %s", i, err)
}
if !reflect.DeepEqual(rh.gotParams, test.wantParams) {
t.Errorf("%d: Got params %#v, want %#v", i, rh.gotParams, test.wantParams)
}
}
}
func TestSlack_RemoveStar(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
tests := []struct {
channel string
ref ItemRef
wantParams map[string]string
}{
{
"ChannelID",
NewRefToMessage("ChannelID", "123"),
map[string]string{
"channel": "ChannelID",
"timestamp": "123",
},
},
{
"ChannelID",
NewRefToFile("FileID"),
map[string]string{
"channel": "ChannelID",
"file": "FileID",
},
},
{
"ChannelID",
NewRefToComment("FileCommentID"),
map[string]string{
"channel": "ChannelID",
"file_comment": "FileCommentID",
},
},
}
var rh *starsHandler
http.HandleFunc("/stars.remove", func(w http.ResponseWriter, r *http.Request) { rh.handler(w, r) })
for i, test := range tests {
rh = newStarsHandler()
err := api.RemoveStar(test.channel, test.ref)
if err != nil {
t.Fatalf("%d: Unexpected error: %s", i, err)
}
if !reflect.DeepEqual(rh.gotParams, test.wantParams) {
t.Errorf("%d: Got params %#v, want %#v", i, rh.gotParams, test.wantParams)
}
}
}
func TestSlack_ListStars(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
rh := newStarsHandler()
http.HandleFunc("/stars.list", func(w http.ResponseWriter, r *http.Request) { rh.handler(w, r) })
rh.response = `{"ok": true,
"items": [
{
"type": "message",
"channel": "C1",
"message": {
"text": "hello",
"reactions": [
{
"name": "astonished",
"count": 3,
"users": [ "U1", "U2", "U3" ]
},
{
"name": "clock1",
"count": 3,
"users": [ "U1", "U2" ]
}
]
}
},
{
"type": "file",
"file": {
"name": "toy",
"reactions": [
{
"name": "clock1",
"count": 3,
"users": [ "U1", "U2" ]
}
]
}
},
{
"type": "file_comment",
"file": {
"name": "toy"
},
"comment": {
"comment": "cool toy",
"reactions": [
{
"name": "astonished",
"count": 3,
"users": [ "U1", "U2", "U3" ]
}
]
}
}
],
"paging": {
"count": 100,
"total": 4,
"page": 1,
"pages": 1
}}`
want := []Item{
NewMessageItem("C1", &Message{Msg: Msg{
Text: "hello",
Reactions: []ItemReaction{
{Name: "astonished", Count: 3, Users: []string{"U1", "U2", "U3"}},
{Name: "clock1", Count: 3, Users: []string{"U1", "U2"}},
},
}}),
NewFileItem(&File{Name: "toy"}),
NewFileCommentItem(&File{Name: "toy"}, &Comment{Comment: "cool toy"}),
}
wantStarred := make([]StarredItem, len(want))
for i, item := range want {
wantStarred[i] = StarredItem(item)
}
wantParams := map[string]string{
"count": "200",
"page": "2",
}
params := NewStarsParameters()
params.Count = 200
params.Page = 2
got, paging, err := api.ListStars(params)
if err != nil {
t.Fatalf("Unexpected error: %s", err)
}
if !reflect.DeepEqual(got, want) {
t.Errorf("Got Stars %#v, want %#v", got, want)
for i, item := range got {
fmt.Printf("Item %d, Type: %s\n", i, item.Type)
fmt.Printf("Message %#v\n", item.Message)
fmt.Printf("File %#v\n", item.File)
fmt.Printf("Comment %#v\n", item.Comment)
}
}
if !reflect.DeepEqual(rh.gotParams, wantParams) {
t.Errorf("Got params %#v, want %#v", rh.gotParams, wantParams)
}
if reflect.DeepEqual(paging, Paging{}) {
t.Errorf("Want paging data, got empty struct")
}
// Test GetStarred
gotStarred, paging, err := api.GetStarred(params)
if err != nil {
t.Fatalf("Unexpected error: %s", err)
}
if !reflect.DeepEqual(gotStarred, wantStarred) {
t.Errorf("Got Stars %#v, want %#v", gotStarred, wantStarred)
for i, item := range got {
fmt.Printf("Item %d, Type: %s\n", i, item.Type)
fmt.Printf("Message %#v\n", item.Message)
fmt.Printf("File %#v\n", item.File)
fmt.Printf("Comment %#v\n", item.Comment)
}
}
if !reflect.DeepEqual(rh.gotParams, wantParams) {
t.Errorf("Got params %#v, want %#v", rh.gotParams, wantParams)
}
if reflect.DeepEqual(paging, Paging{}) {
t.Errorf("Want paging data, got empty struct")
}
}
slack-0.11.3/status_code_error.go 0000664 0000000 0000000 00000001030 14307410331 0016734 0 ustar 00root root 0000000 0000000 package slack
import (
"fmt"
"net/http"
)
// StatusCodeError represents an http response error.
// type httpStatusCode interface { HTTPStatusCode() int } to handle it.
type StatusCodeError struct {
Code int
Status string
}
func (t StatusCodeError) Error() string {
return fmt.Sprintf("slack server error: %s", t.Status)
}
func (t StatusCodeError) HTTPStatusCode() int {
return t.Code
}
func (t StatusCodeError) Retryable() bool {
if t.Code >= 500 || t.Code == http.StatusTooManyRequests {
return true
}
return false
}
slack-0.11.3/team.go 0000664 0000000 0000000 00000011316 14307410331 0014144 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"net/url"
"strconv"
)
const (
DEFAULT_LOGINS_COUNT = 100
DEFAULT_LOGINS_PAGE = 1
)
type TeamResponse struct {
Team TeamInfo `json:"team"`
SlackResponse
}
type TeamInfo struct {
ID string `json:"id"`
Name string `json:"name"`
Domain string `json:"domain"`
EmailDomain string `json:"email_domain"`
Icon map[string]interface{} `json:"icon"`
}
type LoginResponse struct {
Logins []Login `json:"logins"`
Paging `json:"paging"`
SlackResponse
}
type Login struct {
UserID string `json:"user_id"`
Username string `json:"username"`
DateFirst int `json:"date_first"`
DateLast int `json:"date_last"`
Count int `json:"count"`
IP string `json:"ip"`
UserAgent string `json:"user_agent"`
ISP string `json:"isp"`
Country string `json:"country"`
Region string `json:"region"`
}
type BillableInfoResponse struct {
BillableInfo map[string]BillingActive `json:"billable_info"`
SlackResponse
}
type BillingActive struct {
BillingActive bool `json:"billing_active"`
}
// AccessLogParameters contains all the parameters necessary (including the optional ones) for a GetAccessLogs() request
type AccessLogParameters struct {
Count int
Page int
}
// NewAccessLogParameters provides an instance of AccessLogParameters with all the sane default values set
func NewAccessLogParameters() AccessLogParameters {
return AccessLogParameters{
Count: DEFAULT_LOGINS_COUNT,
Page: DEFAULT_LOGINS_PAGE,
}
}
func (api *Client) teamRequest(ctx context.Context, path string, values url.Values) (*TeamResponse, error) {
response := &TeamResponse{}
err := api.postMethod(ctx, path, values, response)
if err != nil {
return nil, err
}
return response, response.Err()
}
func (api *Client) billableInfoRequest(ctx context.Context, path string, values url.Values) (map[string]BillingActive, error) {
response := &BillableInfoResponse{}
err := api.postMethod(ctx, path, values, response)
if err != nil {
return nil, err
}
return response.BillableInfo, response.Err()
}
func (api *Client) accessLogsRequest(ctx context.Context, path string, values url.Values) (*LoginResponse, error) {
response := &LoginResponse{}
err := api.postMethod(ctx, path, values, response)
if err != nil {
return nil, err
}
return response, response.Err()
}
// GetTeamInfo gets the Team Information of the user
func (api *Client) GetTeamInfo() (*TeamInfo, error) {
return api.GetTeamInfoContext(context.Background())
}
// GetTeamInfoContext gets the Team Information of the user with a custom context
func (api *Client) GetTeamInfoContext(ctx context.Context) (*TeamInfo, error) {
values := url.Values{
"token": {api.token},
}
response, err := api.teamRequest(ctx, "team.info", values)
if err != nil {
return nil, err
}
return &response.Team, nil
}
// GetAccessLogs retrieves a page of logins according to the parameters given
func (api *Client) GetAccessLogs(params AccessLogParameters) ([]Login, *Paging, error) {
return api.GetAccessLogsContext(context.Background(), params)
}
// GetAccessLogsContext retrieves a page of logins according to the parameters given with a custom context
func (api *Client) GetAccessLogsContext(ctx context.Context, params AccessLogParameters) ([]Login, *Paging, error) {
values := url.Values{
"token": {api.token},
}
if params.Count != DEFAULT_LOGINS_COUNT {
values.Add("count", strconv.Itoa(params.Count))
}
if params.Page != DEFAULT_LOGINS_PAGE {
values.Add("page", strconv.Itoa(params.Page))
}
response, err := api.accessLogsRequest(ctx, "team.accessLogs", values)
if err != nil {
return nil, nil, err
}
return response.Logins, &response.Paging, nil
}
// GetBillableInfo ...
func (api *Client) GetBillableInfo(user string) (map[string]BillingActive, error) {
return api.GetBillableInfoContext(context.Background(), user)
}
// GetBillableInfoContext ...
func (api *Client) GetBillableInfoContext(ctx context.Context, user string) (map[string]BillingActive, error) {
values := url.Values{
"token": {api.token},
"user": {user},
}
return api.billableInfoRequest(ctx, "team.billableInfo", values)
}
// GetBillableInfoForTeam returns the billing_active status of all users on the team.
func (api *Client) GetBillableInfoForTeam() (map[string]BillingActive, error) {
return api.GetBillableInfoForTeamContext(context.Background())
}
// GetBillableInfoForTeamContext returns the billing_active status of all users on the team with a custom context
func (api *Client) GetBillableInfoForTeamContext(ctx context.Context) (map[string]BillingActive, error) {
values := url.Values{
"token": {api.token},
}
return api.billableInfoRequest(ctx, "team.billableInfo", values)
}
slack-0.11.3/team_test.go 0000664 0000000 0000000 00000010206 14307410331 0015200 0 ustar 00root root 0000000 0000000 package slack
import (
"errors"
"net/http"
"strings"
"testing"
)
var (
ErrIncorrectResponse = errors.New("Response is incorrect")
)
func getTeamInfo(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
response := []byte(`{"ok": true, "team": {
"id": "F0UWHUX",
"name": "notalar",
"domain": "notalar",
"icon": {
"image_34": "https://slack.global.ssl.fastly.net/66f9/img/avatars-teams/ava_0002-34.png",
"image_44": "https://slack.global.ssl.fastly.net/66f9/img/avatars-teams/ava_0002-44.png",
"image_55": "https://slack.global.ssl.fastly.net/66f9/img/avatars-teams/ava_0002-55.png",
"image_default": true
}
}}`)
rw.Write(response)
}
func TestGetTeamInfo(t *testing.T) {
http.HandleFunc("/team.info", getTeamInfo)
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
teamInfo, err := api.GetTeamInfo()
if err != nil {
t.Errorf("Unexpected error: %s", err)
return
}
// t.Fatal refers to -> t.Errorf & return
if teamInfo.ID != "F0UWHUX" {
t.Fatal(ErrIncorrectResponse)
}
if teamInfo.Domain != "notalar" {
t.Fatal(ErrIncorrectResponse)
}
if teamInfo.Name != "notalar" {
t.Fatal(ErrIncorrectResponse)
}
if teamInfo.Icon == nil {
t.Fatal(ErrIncorrectResponse)
}
}
func getTeamAccessLogs(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
response := []byte(`{"ok": true, "logins": [{
"user_id": "F0UWHUX",
"username": "notalar",
"date_first": 1475684477,
"date_last": 1475684645,
"count": 8,
"ip": "127.0.0.1",
"user_agent": "SlackWeb/3abb0ae2380d48a9ae20c58cc624ebcd Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Slack/1.2.6 Chrome/45.0.2454.85 AtomShell/0.34.3 Safari/537.36 Slack_SSB/1.2.6",
"isp": "AT&T U-verse",
"country": "US",
"region": "IN"
},
{
"user_id": "XUHWU0F",
"username": "ralaton",
"date_first": 1447395893,
"date_last": 1447395965,
"count": 5,
"ip": "192.168.0.1",
"user_agent": "com.tinyspeck.chatlyio/2.60 (iPhone; iOS 9.1; Scale/3.00)",
"isp": null,
"country": null,
"region": null
}],
"paging": {
"count": 2,
"total": 2,
"page": 1,
"pages": 1
}
}`)
rw.Write(response)
}
func TestGetAccessLogs(t *testing.T) {
http.HandleFunc("/team.accessLogs", getTeamAccessLogs)
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
logins, paging, err := api.GetAccessLogs(NewAccessLogParameters())
if err != nil {
t.Errorf("Unexpected error: %s", err)
return
}
if len(logins) != 2 {
t.Fatal("Should have been 2 logins")
}
// test the first login
login1 := logins[0]
login2 := logins[1]
if login1.UserID != "F0UWHUX" {
t.Fatal(ErrIncorrectResponse)
}
if login1.Username != "notalar" {
t.Fatal(ErrIncorrectResponse)
}
if login1.DateFirst != 1475684477 {
t.Fatal(ErrIncorrectResponse)
}
if login1.DateLast != 1475684645 {
t.Fatal(ErrIncorrectResponse)
}
if login1.Count != 8 {
t.Fatal(ErrIncorrectResponse)
}
if login1.IP != "127.0.0.1" {
t.Fatal(ErrIncorrectResponse)
}
if !strings.HasPrefix(login1.UserAgent, "SlackWeb") {
t.Fatal(ErrIncorrectResponse)
}
if login1.ISP != "AT&T U-verse" {
t.Fatal(ErrIncorrectResponse)
}
if login1.Country != "US" {
t.Fatal(ErrIncorrectResponse)
}
if login1.Region != "IN" {
t.Fatal(ErrIncorrectResponse)
}
// test that the null values from login2 are coming across correctly
if login2.ISP != "" {
t.Fatal(ErrIncorrectResponse)
}
if login2.Country != "" {
t.Fatal(ErrIncorrectResponse)
}
if login2.Region != "" {
t.Fatal(ErrIncorrectResponse)
}
// test the paging
if paging.Count != 2 {
t.Fatal(ErrIncorrectResponse)
}
if paging.Total != 2 {
t.Fatal(ErrIncorrectResponse)
}
if paging.Page != 1 {
t.Fatal(ErrIncorrectResponse)
}
if paging.Pages != 1 {
t.Fatal(ErrIncorrectResponse)
}
}
slack-0.11.3/usergroups.go 0000664 0000000 0000000 00000022565 14307410331 0015444 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"net/url"
"strings"
)
// UserGroup contains all the information of a user group
type UserGroup struct {
ID string `json:"id"`
TeamID string `json:"team_id"`
IsUserGroup bool `json:"is_usergroup"`
Name string `json:"name"`
Description string `json:"description"`
Handle string `json:"handle"`
IsExternal bool `json:"is_external"`
DateCreate JSONTime `json:"date_create"`
DateUpdate JSONTime `json:"date_update"`
DateDelete JSONTime `json:"date_delete"`
AutoType string `json:"auto_type"`
CreatedBy string `json:"created_by"`
UpdatedBy string `json:"updated_by"`
DeletedBy string `json:"deleted_by"`
Prefs UserGroupPrefs `json:"prefs"`
UserCount int `json:"user_count"`
Users []string `json:"users"`
}
// UserGroupPrefs contains default channels and groups (private channels)
type UserGroupPrefs struct {
Channels []string `json:"channels"`
Groups []string `json:"groups"`
}
type userGroupResponseFull struct {
UserGroups []UserGroup `json:"usergroups"`
UserGroup UserGroup `json:"usergroup"`
Users []string `json:"users"`
SlackResponse
}
func (api *Client) userGroupRequest(ctx context.Context, path string, values url.Values) (*userGroupResponseFull, error) {
response := &userGroupResponseFull{}
err := api.postMethod(ctx, path, values, response)
if err != nil {
return nil, err
}
return response, response.Err()
}
// CreateUserGroup creates a new user group
func (api *Client) CreateUserGroup(userGroup UserGroup) (UserGroup, error) {
return api.CreateUserGroupContext(context.Background(), userGroup)
}
// CreateUserGroupContext creates a new user group with a custom context
func (api *Client) CreateUserGroupContext(ctx context.Context, userGroup UserGroup) (UserGroup, error) {
values := url.Values{
"token": {api.token},
"name": {userGroup.Name},
}
if userGroup.Handle != "" {
values["handle"] = []string{userGroup.Handle}
}
if userGroup.Description != "" {
values["description"] = []string{userGroup.Description}
}
if len(userGroup.Prefs.Channels) > 0 {
values["channels"] = []string{strings.Join(userGroup.Prefs.Channels, ",")}
}
response, err := api.userGroupRequest(ctx, "usergroups.create", values)
if err != nil {
return UserGroup{}, err
}
return response.UserGroup, nil
}
// DisableUserGroup disables an existing user group
func (api *Client) DisableUserGroup(userGroup string) (UserGroup, error) {
return api.DisableUserGroupContext(context.Background(), userGroup)
}
// DisableUserGroupContext disables an existing user group with a custom context
func (api *Client) DisableUserGroupContext(ctx context.Context, userGroup string) (UserGroup, error) {
values := url.Values{
"token": {api.token},
"usergroup": {userGroup},
}
response, err := api.userGroupRequest(ctx, "usergroups.disable", values)
if err != nil {
return UserGroup{}, err
}
return response.UserGroup, nil
}
// EnableUserGroup enables an existing user group
func (api *Client) EnableUserGroup(userGroup string) (UserGroup, error) {
return api.EnableUserGroupContext(context.Background(), userGroup)
}
// EnableUserGroupContext enables an existing user group with a custom context
func (api *Client) EnableUserGroupContext(ctx context.Context, userGroup string) (UserGroup, error) {
values := url.Values{
"token": {api.token},
"usergroup": {userGroup},
}
response, err := api.userGroupRequest(ctx, "usergroups.enable", values)
if err != nil {
return UserGroup{}, err
}
return response.UserGroup, nil
}
// GetUserGroupsOption options for the GetUserGroups method call.
type GetUserGroupsOption func(*GetUserGroupsParams)
// GetUserGroupsOptionIncludeCount include the number of users in each User Group (default: false)
func GetUserGroupsOptionIncludeCount(b bool) GetUserGroupsOption {
return func(params *GetUserGroupsParams) {
params.IncludeCount = b
}
}
// GetUserGroupsOptionIncludeDisabled include disabled User Groups (default: false)
func GetUserGroupsOptionIncludeDisabled(b bool) GetUserGroupsOption {
return func(params *GetUserGroupsParams) {
params.IncludeDisabled = b
}
}
// GetUserGroupsOptionIncludeUsers include the list of users for each User Group (default: false)
func GetUserGroupsOptionIncludeUsers(b bool) GetUserGroupsOption {
return func(params *GetUserGroupsParams) {
params.IncludeUsers = b
}
}
// GetUserGroupsParams contains arguments for GetUserGroups method call
type GetUserGroupsParams struct {
IncludeCount bool
IncludeDisabled bool
IncludeUsers bool
}
// GetUserGroups returns a list of user groups for the team
func (api *Client) GetUserGroups(options ...GetUserGroupsOption) ([]UserGroup, error) {
return api.GetUserGroupsContext(context.Background(), options...)
}
// GetUserGroupsContext returns a list of user groups for the team with a custom context
func (api *Client) GetUserGroupsContext(ctx context.Context, options ...GetUserGroupsOption) ([]UserGroup, error) {
params := GetUserGroupsParams{}
for _, opt := range options {
opt(¶ms)
}
values := url.Values{
"token": {api.token},
}
if params.IncludeCount {
values.Add("include_count", "true")
}
if params.IncludeDisabled {
values.Add("include_disabled", "true")
}
if params.IncludeUsers {
values.Add("include_users", "true")
}
response, err := api.userGroupRequest(ctx, "usergroups.list", values)
if err != nil {
return nil, err
}
return response.UserGroups, nil
}
// UpdateUserGroupsOption options for the UpdateUserGroup method call.
type UpdateUserGroupsOption func(*UpdateUserGroupsParams)
// UpdateUserGroupsOptionName change the name of the User Group (default: empty, so it's no-op)
func UpdateUserGroupsOptionName(name string) UpdateUserGroupsOption {
return func(params *UpdateUserGroupsParams) {
params.Name = name
}
}
// UpdateUserGroupsOptionHandle change the handle of the User Group (default: empty, so it's no-op)
func UpdateUserGroupsOptionHandle(handle string) UpdateUserGroupsOption {
return func(params *UpdateUserGroupsParams) {
params.Handle = handle
}
}
// UpdateUserGroupsOptionDescription change the description of the User Group. (default: nil, so it's no-op)
func UpdateUserGroupsOptionDescription(description *string) UpdateUserGroupsOption {
return func(params *UpdateUserGroupsParams) {
params.Description = description
}
}
// UpdateUserGroupsOptionChannels change the default channels of the User Group. (default: unspecified, so it's no-op)
func UpdateUserGroupsOptionChannels(channels []string) UpdateUserGroupsOption {
return func(params *UpdateUserGroupsParams) {
params.Channels = &channels
}
}
// UpdateUserGroupsParams contains arguments for UpdateUserGroup method call
type UpdateUserGroupsParams struct {
Name string
Handle string
Description *string
Channels *[]string
}
// UpdateUserGroup will update an existing user group
func (api *Client) UpdateUserGroup(userGroupID string, options ...UpdateUserGroupsOption) (UserGroup, error) {
return api.UpdateUserGroupContext(context.Background(), userGroupID, options...)
}
// UpdateUserGroupContext will update an existing user group with a custom context
func (api *Client) UpdateUserGroupContext(ctx context.Context, userGroupID string, options ...UpdateUserGroupsOption) (UserGroup, error) {
params := UpdateUserGroupsParams{}
for _, opt := range options {
opt(¶ms)
}
values := url.Values{
"token": {api.token},
"usergroup": {userGroupID},
}
if params.Name != "" {
values["name"] = []string{params.Name}
}
if params.Handle != "" {
values["handle"] = []string{params.Handle}
}
if params.Description != nil {
values["description"] = []string{*params.Description}
}
if params.Channels != nil {
values["channels"] = []string{strings.Join(*params.Channels, ",")}
}
response, err := api.userGroupRequest(ctx, "usergroups.update", values)
if err != nil {
return UserGroup{}, err
}
return response.UserGroup, nil
}
// GetUserGroupMembers will retrieve the current list of users in a group
func (api *Client) GetUserGroupMembers(userGroup string) ([]string, error) {
return api.GetUserGroupMembersContext(context.Background(), userGroup)
}
// GetUserGroupMembersContext will retrieve the current list of users in a group with a custom context
func (api *Client) GetUserGroupMembersContext(ctx context.Context, userGroup string) ([]string, error) {
values := url.Values{
"token": {api.token},
"usergroup": {userGroup},
}
response, err := api.userGroupRequest(ctx, "usergroups.users.list", values)
if err != nil {
return []string{}, err
}
return response.Users, nil
}
// UpdateUserGroupMembers will update the members of an existing user group
func (api *Client) UpdateUserGroupMembers(userGroup string, members string) (UserGroup, error) {
return api.UpdateUserGroupMembersContext(context.Background(), userGroup, members)
}
// UpdateUserGroupMembersContext will update the members of an existing user group with a custom context
func (api *Client) UpdateUserGroupMembersContext(ctx context.Context, userGroup string, members string) (UserGroup, error) {
values := url.Values{
"token": {api.token},
"usergroup": {userGroup},
"users": {members},
}
response, err := api.userGroupRequest(ctx, "usergroups.users.update", values)
if err != nil {
return UserGroup{}, err
}
return response.UserGroup, nil
}
slack-0.11.3/usergroups_test.go 0000664 0000000 0000000 00000015764 14307410331 0016506 0 ustar 00root root 0000000 0000000 package slack
import (
"net/http"
"reflect"
"testing"
)
type userGroupsHandler struct {
gotParams map[string]string
response string
}
func newUserGroupsHandler() *userGroupsHandler {
return &userGroupsHandler{
gotParams: make(map[string]string),
response: `{
"ok": true,
"usergroup": {
"id": "S0615G0KT",
"team_id": "T060RNRCH",
"is_usergroup": true,
"name": "Marketing Team",
"description": "Marketing gurus, PR experts and product advocates.",
"handle": "marketing-team",
"is_external": false,
"date_create": 1446746793,
"date_update": 1446746793,
"date_delete": 0,
"auto_type": null,
"created_by": "U060RNRCZ",
"updated_by": "U060RNRCZ",
"deleted_by": null,
"prefs": {
"channels": [
],
"groups": [
]
},
"user_count": 0
}
}`,
}
}
func (ugh *userGroupsHandler) handler(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
for k, v := range r.Form {
ugh.gotParams[k] = v[0]
}
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(ugh.response))
}
func TestCreateUserGroup(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
tests := []struct {
userGroup UserGroup
wantParams map[string]string
}{
{
UserGroup{
Name: "Marketing Team",
Description: "Marketing gurus, PR experts and product advocates.",
Handle: "marketing-team"},
map[string]string{
"token": "testing-token",
"name": "Marketing Team",
"description": "Marketing gurus, PR experts and product advocates.",
"handle": "marketing-team",
},
},
}
var rh *userGroupsHandler
http.HandleFunc("/usergroups.create", func(w http.ResponseWriter, r *http.Request) { rh.handler(w, r) })
for i, test := range tests {
rh = newUserGroupsHandler()
_, err := api.CreateUserGroup(test.userGroup)
if err != nil {
t.Fatalf("%d: Unexpected error: %s", i, err)
}
if !reflect.DeepEqual(rh.gotParams, test.wantParams) {
t.Errorf("%d: Got params %#v, want %#v", i, rh.gotParams, test.wantParams)
}
}
}
func getUserGroups(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
response := []byte(`{
"ok": true,
"usergroups": [
{
"id": "S0614TZR7",
"team_id": "T060RNRCH",
"is_usergroup": true,
"name": "Team Admins",
"description": "A group of all Administrators on your team.",
"handle": "admins",
"is_external": false,
"date_create": 1446598059,
"date_update": 1446670362,
"date_delete": 0,
"auto_type": "admin",
"created_by": "USLACKBOT",
"updated_by": "U060RNRCZ",
"deleted_by": null,
"prefs": {
"channels": [
"channel1",
"channel2"
],
"groups": [
"group1",
"group2",
"group3"
]
},
"users": [
"user1",
"user2"
],
"user_count": 2
}
]
}`)
rw.Write(response)
}
func TestGetUserGroups(t *testing.T) {
http.HandleFunc("/usergroups.list", getUserGroups)
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
userGroups, err := api.GetUserGroups(GetUserGroupsOptionIncludeUsers(true))
if err != nil {
t.Errorf("Unexpected error: %s", err)
return
}
// t.Fatal refers to -> t.Errorf & return
if len(userGroups) != 1 {
t.Fatal(ErrIncorrectResponse)
}
S0614TZR7 := UserGroup{
ID: "S0614TZR7",
TeamID: "T060RNRCH",
IsUserGroup: true,
Name: "Team Admins",
Description: "A group of all Administrators on your team.",
Handle: "admins",
IsExternal: false,
DateCreate: 1446598059,
DateUpdate: 1446670362,
DateDelete: 0,
AutoType: "admin",
CreatedBy: "USLACKBOT",
UpdatedBy: "U060RNRCZ",
DeletedBy: "",
Prefs: UserGroupPrefs{
Channels: []string{"channel1", "channel2"},
Groups: []string{"group1", "group2", "group3"},
},
Users: []string{
"user1",
"user2",
},
UserCount: 2,
}
if !reflect.DeepEqual(userGroups[0], S0614TZR7) {
t.Errorf("Got %#v, want %#v", userGroups[0], S0614TZR7)
}
}
func updateUserGroupsHandler() *userGroupsHandler {
return &userGroupsHandler{
gotParams: make(map[string]string),
response: `{
"ok": true,
"usergroup": {
"id": "S0615G0KT",
"team_id": "T060RNRCH",
"is_usergroup": true,
"name": "Marketing Team",
"description": "Marketing gurus, PR experts and product advocates.",
"handle": "marketing-team",
"is_external": false,
"date_create": 1446746793,
"date_update": 1446746793,
"date_delete": 0,
"auto_type": null,
"created_by": "U060RNRCZ",
"updated_by": "U060RNRCZ",
"deleted_by": null,
"prefs": {
"channels": [
"channel1",
"channel2"
],
"groups": [
]
},
"user_count": 0
}
}`,
}
}
func TestUpdateUserGroup(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
emptyDescription := ""
presenceDescription := "Marketing gurus, PR experts and product advocates."
tests := []struct {
options []UpdateUserGroupsOption
wantParams map[string]string
}{
{
[]UpdateUserGroupsOption{
UpdateUserGroupsOptionName("Marketing Team"),
UpdateUserGroupsOptionHandle("marketing-team"),
},
map[string]string{
"token": "testing-token",
"usergroup": "S0615G0KT",
"name": "Marketing Team",
"handle": "marketing-team",
},
},
{
[]UpdateUserGroupsOption{
UpdateUserGroupsOptionDescription(&presenceDescription),
UpdateUserGroupsOptionChannels([]string{"channel1", "channel2"}),
},
map[string]string{
"token": "testing-token",
"usergroup": "S0615G0KT",
"description": "Marketing gurus, PR experts and product advocates.",
"channels": "channel1,channel2",
},
},
{
[]UpdateUserGroupsOption{
UpdateUserGroupsOptionDescription(&emptyDescription),
UpdateUserGroupsOptionChannels([]string{}),
},
map[string]string{
"token": "testing-token",
"usergroup": "S0615G0KT",
"description": "",
"channels": "",
},
},
}
var rh *userGroupsHandler
http.HandleFunc("/usergroups.update", func(w http.ResponseWriter, r *http.Request) { rh.handler(w, r) })
for i, test := range tests {
rh = updateUserGroupsHandler()
_, err := api.UpdateUserGroup("S0615G0KT", test.options...)
if err != nil {
t.Fatalf("%d: Unexpected error: %s", i, err)
}
if !reflect.DeepEqual(rh.gotParams, test.wantParams) {
t.Errorf("%d: Got params %#v, want %#v", i, rh.gotParams, test.wantParams)
}
}
}
slack-0.11.3/users.go 0000664 0000000 0000000 00000053424 14307410331 0014365 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"encoding/json"
"net/url"
"strconv"
"strings"
"time"
)
const (
DEFAULT_USER_PHOTO_CROP_X = -1
DEFAULT_USER_PHOTO_CROP_Y = -1
DEFAULT_USER_PHOTO_CROP_W = -1
)
// UserProfile contains all the information details of a given user
type UserProfile struct {
FirstName string `json:"first_name"`
LastName string `json:"last_name"`
RealName string `json:"real_name"`
RealNameNormalized string `json:"real_name_normalized"`
DisplayName string `json:"display_name"`
DisplayNameNormalized string `json:"display_name_normalized"`
Email string `json:"email"`
Skype string `json:"skype"`
Phone string `json:"phone"`
Image24 string `json:"image_24"`
Image32 string `json:"image_32"`
Image48 string `json:"image_48"`
Image72 string `json:"image_72"`
Image192 string `json:"image_192"`
Image512 string `json:"image_512"`
ImageOriginal string `json:"image_original"`
Title string `json:"title"`
BotID string `json:"bot_id,omitempty"`
ApiAppID string `json:"api_app_id,omitempty"`
StatusText string `json:"status_text,omitempty"`
StatusEmoji string `json:"status_emoji,omitempty"`
StatusExpiration int `json:"status_expiration"`
Team string `json:"team"`
Fields UserProfileCustomFields `json:"fields"`
}
// UserProfileCustomFields represents user profile's custom fields.
// Slack API's response data type is inconsistent so we use the struct.
// For detail, please see below.
// https://github.com/slack-go/slack/pull/298#discussion_r185159233
type UserProfileCustomFields struct {
fields map[string]UserProfileCustomField
}
// UnmarshalJSON is the implementation of the json.Unmarshaler interface.
func (fields *UserProfileCustomFields) UnmarshalJSON(b []byte) error {
// https://github.com/slack-go/slack/pull/298#discussion_r185159233
if string(b) == "[]" {
return nil
}
return json.Unmarshal(b, &fields.fields)
}
// MarshalJSON is the implementation of the json.Marshaler interface.
func (fields UserProfileCustomFields) MarshalJSON() ([]byte, error) {
if len(fields.fields) == 0 {
return []byte("[]"), nil
}
return json.Marshal(fields.fields)
}
// ToMap returns a map of custom fields.
func (fields *UserProfileCustomFields) ToMap() map[string]UserProfileCustomField {
return fields.fields
}
// Len returns the number of custom fields.
func (fields *UserProfileCustomFields) Len() int {
return len(fields.fields)
}
// SetMap sets a map of custom fields.
func (fields *UserProfileCustomFields) SetMap(m map[string]UserProfileCustomField) {
fields.fields = m
}
// FieldsMap returns a map of custom fields.
func (profile *UserProfile) FieldsMap() map[string]UserProfileCustomField {
return profile.Fields.ToMap()
}
// SetFieldsMap sets a map of custom fields.
func (profile *UserProfile) SetFieldsMap(m map[string]UserProfileCustomField) {
profile.Fields.SetMap(m)
}
// UserProfileCustomField represents a custom user profile field
type UserProfileCustomField struct {
Value string `json:"value"`
Alt string `json:"alt"`
Label string `json:"label"`
}
// User contains all the information of a user
type User struct {
ID string `json:"id"`
TeamID string `json:"team_id"`
Name string `json:"name"`
Deleted bool `json:"deleted"`
Color string `json:"color"`
RealName string `json:"real_name"`
TZ string `json:"tz,omitempty"`
TZLabel string `json:"tz_label"`
TZOffset int `json:"tz_offset"`
Profile UserProfile `json:"profile"`
IsBot bool `json:"is_bot"`
IsAdmin bool `json:"is_admin"`
IsOwner bool `json:"is_owner"`
IsPrimaryOwner bool `json:"is_primary_owner"`
IsRestricted bool `json:"is_restricted"`
IsUltraRestricted bool `json:"is_ultra_restricted"`
IsStranger bool `json:"is_stranger"`
IsAppUser bool `json:"is_app_user"`
IsInvitedUser bool `json:"is_invited_user"`
Has2FA bool `json:"has_2fa"`
HasFiles bool `json:"has_files"`
Presence string `json:"presence"`
Locale string `json:"locale"`
Updated JSONTime `json:"updated"`
Enterprise EnterpriseUser `json:"enterprise_user,omitempty"`
}
// UserPresence contains details about a user online status
type UserPresence struct {
Presence string `json:"presence,omitempty"`
Online bool `json:"online,omitempty"`
AutoAway bool `json:"auto_away,omitempty"`
ManualAway bool `json:"manual_away,omitempty"`
ConnectionCount int `json:"connection_count,omitempty"`
LastActivity JSONTime `json:"last_activity,omitempty"`
}
type UserIdentityResponse struct {
User UserIdentity `json:"user"`
Team TeamIdentity `json:"team"`
SlackResponse
}
type UserIdentity struct {
ID string `json:"id"`
Name string `json:"name"`
Email string `json:"email"`
Image24 string `json:"image_24"`
Image32 string `json:"image_32"`
Image48 string `json:"image_48"`
Image72 string `json:"image_72"`
Image192 string `json:"image_192"`
Image512 string `json:"image_512"`
}
// EnterpriseUser is present when a user is part of Slack Enterprise Grid
// https://api.slack.com/types/user#enterprise_grid_user_objects
type EnterpriseUser struct {
ID string `json:"id"`
EnterpriseID string `json:"enterprise_id"`
EnterpriseName string `json:"enterprise_name"`
IsAdmin bool `json:"is_admin"`
IsOwner bool `json:"is_owner"`
Teams []string `json:"teams"`
}
type TeamIdentity struct {
ID string `json:"id"`
Name string `json:"name"`
Domain string `json:"domain"`
Image34 string `json:"image_34"`
Image44 string `json:"image_44"`
Image68 string `json:"image_68"`
Image88 string `json:"image_88"`
Image102 string `json:"image_102"`
Image132 string `json:"image_132"`
Image230 string `json:"image_230"`
ImageDefault bool `json:"image_default"`
ImageOriginal string `json:"image_original"`
}
type userResponseFull struct {
Members []User `json:"members,omitempty"`
User `json:"user,omitempty"`
Users []User `json:"users,omitempty"`
UserPresence
SlackResponse
Metadata ResponseMetadata `json:"response_metadata"`
}
type UserSetPhotoParams struct {
CropX int
CropY int
CropW int
}
func NewUserSetPhotoParams() UserSetPhotoParams {
return UserSetPhotoParams{
CropX: DEFAULT_USER_PHOTO_CROP_X,
CropY: DEFAULT_USER_PHOTO_CROP_Y,
CropW: DEFAULT_USER_PHOTO_CROP_W,
}
}
func (api *Client) userRequest(ctx context.Context, path string, values url.Values) (*userResponseFull, error) {
response := &userResponseFull{}
err := api.postMethod(ctx, path, values, response)
if err != nil {
return nil, err
}
return response, response.Err()
}
// GetUserPresence will retrieve the current presence status of given user.
func (api *Client) GetUserPresence(user string) (*UserPresence, error) {
return api.GetUserPresenceContext(context.Background(), user)
}
// GetUserPresenceContext will retrieve the current presence status of given user with a custom context.
func (api *Client) GetUserPresenceContext(ctx context.Context, user string) (*UserPresence, error) {
values := url.Values{
"token": {api.token},
"user": {user},
}
response, err := api.userRequest(ctx, "users.getPresence", values)
if err != nil {
return nil, err
}
return &response.UserPresence, nil
}
// GetUserInfo will retrieve the complete user information
func (api *Client) GetUserInfo(user string) (*User, error) {
return api.GetUserInfoContext(context.Background(), user)
}
// GetUserInfoContext will retrieve the complete user information with a custom context
func (api *Client) GetUserInfoContext(ctx context.Context, user string) (*User, error) {
values := url.Values{
"token": {api.token},
"user": {user},
"include_locale": {strconv.FormatBool(true)},
}
response, err := api.userRequest(ctx, "users.info", values)
if err != nil {
return nil, err
}
return &response.User, nil
}
// GetUsersInfo will retrieve the complete multi-users information
func (api *Client) GetUsersInfo(users ...string) (*[]User, error) {
return api.GetUsersInfoContext(context.Background(), users...)
}
// GetUsersInfoContext will retrieve the complete multi-users information with a custom context
func (api *Client) GetUsersInfoContext(ctx context.Context, users ...string) (*[]User, error) {
values := url.Values{
"token": {api.token},
"users": {strings.Join(users, ",")},
"include_locale": {strconv.FormatBool(true)},
}
response, err := api.userRequest(ctx, "users.info", values)
if err != nil {
return nil, err
}
return &response.Users, nil
}
// GetUsersOption options for the GetUsers method call.
type GetUsersOption func(*UserPagination)
// GetUsersOptionLimit limit the number of users returned
func GetUsersOptionLimit(n int) GetUsersOption {
return func(p *UserPagination) {
p.limit = n
}
}
// GetUsersOptionPresence include user presence
func GetUsersOptionPresence(n bool) GetUsersOption {
return func(p *UserPagination) {
p.presence = n
}
}
// GetUsersOptionTeamID include team Id
func GetUsersOptionTeamID(teamId string) GetUsersOption {
return func(p *UserPagination) {
p.teamId = teamId
}
}
func newUserPagination(c *Client, options ...GetUsersOption) (up UserPagination) {
up = UserPagination{
c: c,
limit: 200, // per slack api documentation.
}
for _, opt := range options {
opt(&up)
}
return up
}
// UserPagination allows for paginating over the users
type UserPagination struct {
Users []User
limit int
presence bool
teamId string
previousResp *ResponseMetadata
c *Client
}
// Done checks if the pagination has completed
func (UserPagination) Done(err error) bool {
return err == errPaginationComplete
}
// Failure checks if pagination failed.
func (t UserPagination) Failure(err error) error {
if t.Done(err) {
return nil
}
return err
}
func (t UserPagination) Next(ctx context.Context) (_ UserPagination, err error) {
var (
resp *userResponseFull
)
if t.c == nil || (t.previousResp != nil && t.previousResp.Cursor == "") {
return t, errPaginationComplete
}
t.previousResp = t.previousResp.initialize()
values := url.Values{
"limit": {strconv.Itoa(t.limit)},
"presence": {strconv.FormatBool(t.presence)},
"token": {t.c.token},
"cursor": {t.previousResp.Cursor},
"team_id": {t.teamId},
"include_locale": {strconv.FormatBool(true)},
}
if resp, err = t.c.userRequest(ctx, "users.list", values); err != nil {
return t, err
}
t.c.Debugf("GetUsersContext: got %d users; metadata %v", len(resp.Members), resp.Metadata)
t.Users = resp.Members
t.previousResp = &resp.Metadata
return t, nil
}
// GetUsersPaginated fetches users in a paginated fashion, see GetUsersContext for usage.
func (api *Client) GetUsersPaginated(options ...GetUsersOption) UserPagination {
return newUserPagination(api, options...)
}
// GetUsers returns the list of users (with their detailed information)
func (api *Client) GetUsers(options ...GetUsersOption) ([]User, error) {
return api.GetUsersContext(context.Background(), options...)
}
// GetUsersContext returns the list of users (with their detailed information) with a custom context
func (api *Client) GetUsersContext(ctx context.Context, options ...GetUsersOption) (results []User, err error) {
p := api.GetUsersPaginated(options...)
for err == nil {
p, err = p.Next(ctx)
if err == nil {
results = append(results, p.Users...)
} else if rateLimitedError, ok := err.(*RateLimitedError); ok {
select {
case <-ctx.Done():
err = ctx.Err()
case <-time.After(rateLimitedError.RetryAfter):
err = nil
}
}
}
return results, p.Failure(err)
}
// GetUserByEmail will retrieve the complete user information by email
func (api *Client) GetUserByEmail(email string) (*User, error) {
return api.GetUserByEmailContext(context.Background(), email)
}
// GetUserByEmailContext will retrieve the complete user information by email with a custom context
func (api *Client) GetUserByEmailContext(ctx context.Context, email string) (*User, error) {
values := url.Values{
"token": {api.token},
"email": {email},
}
response, err := api.userRequest(ctx, "users.lookupByEmail", values)
if err != nil {
return nil, err
}
return &response.User, nil
}
// SetUserAsActive marks the currently authenticated user as active
func (api *Client) SetUserAsActive() error {
return api.SetUserAsActiveContext(context.Background())
}
// SetUserAsActiveContext marks the currently authenticated user as active with a custom context
func (api *Client) SetUserAsActiveContext(ctx context.Context) (err error) {
values := url.Values{
"token": {api.token},
}
_, err = api.userRequest(ctx, "users.setActive", values)
return err
}
// SetUserPresence changes the currently authenticated user presence
func (api *Client) SetUserPresence(presence string) error {
return api.SetUserPresenceContext(context.Background(), presence)
}
// SetUserPresenceContext changes the currently authenticated user presence with a custom context
func (api *Client) SetUserPresenceContext(ctx context.Context, presence string) error {
values := url.Values{
"token": {api.token},
"presence": {presence},
}
_, err := api.userRequest(ctx, "users.setPresence", values)
return err
}
// GetUserIdentity will retrieve user info available per identity scopes
func (api *Client) GetUserIdentity() (*UserIdentityResponse, error) {
return api.GetUserIdentityContext(context.Background())
}
// GetUserIdentityContext will retrieve user info available per identity scopes with a custom context
func (api *Client) GetUserIdentityContext(ctx context.Context) (response *UserIdentityResponse, err error) {
values := url.Values{
"token": {api.token},
}
response = &UserIdentityResponse{}
err = api.postMethod(ctx, "users.identity", values, response)
if err != nil {
return nil, err
}
if err := response.Err(); err != nil {
return nil, err
}
return response, nil
}
// SetUserPhoto changes the currently authenticated user's profile image
func (api *Client) SetUserPhoto(image string, params UserSetPhotoParams) error {
return api.SetUserPhotoContext(context.Background(), image, params)
}
// SetUserPhotoContext changes the currently authenticated user's profile image using a custom context
func (api *Client) SetUserPhotoContext(ctx context.Context, image string, params UserSetPhotoParams) (err error) {
response := &SlackResponse{}
values := url.Values{}
if params.CropX != DEFAULT_USER_PHOTO_CROP_X {
values.Add("crop_x", strconv.Itoa(params.CropX))
}
if params.CropY != DEFAULT_USER_PHOTO_CROP_Y {
values.Add("crop_y", strconv.Itoa(params.CropX))
}
if params.CropW != DEFAULT_USER_PHOTO_CROP_W {
values.Add("crop_w", strconv.Itoa(params.CropW))
}
err = postLocalWithMultipartResponse(ctx, api.httpclient, api.endpoint+"users.setPhoto", image, "image", api.token, values, response, api)
if err != nil {
return err
}
return response.Err()
}
// DeleteUserPhoto deletes the current authenticated user's profile image
func (api *Client) DeleteUserPhoto() error {
return api.DeleteUserPhotoContext(context.Background())
}
// DeleteUserPhotoContext deletes the current authenticated user's profile image with a custom context
func (api *Client) DeleteUserPhotoContext(ctx context.Context) (err error) {
response := &SlackResponse{}
values := url.Values{
"token": {api.token},
}
err = api.postMethod(ctx, "users.deletePhoto", values, response)
if err != nil {
return err
}
return response.Err()
}
// SetUserRealName changes the currently authenticated user's realName
//
// For more information see SetUserRealNameContextWithUser
func (api *Client) SetUserRealName(realName string) error {
return api.SetUserRealNameContextWithUser(context.Background(), "", realName)
}
// SetUserRealNameContextWithUser will set a real name for the provided user with a custom context
func (api *Client) SetUserRealNameContextWithUser(ctx context.Context, user, realName string) error {
profile, err := json.Marshal(
&struct {
RealName string `json:"real_name"`
}{
RealName: realName,
},
)
if err != nil {
return err
}
values := url.Values{
"token": {api.token},
"profile": {string(profile)},
}
// optional field. It should not be set if empty
if user != "" {
values["user"] = []string{user}
}
response := &userResponseFull{}
if err = api.postMethod(ctx, "users.profile.set", values, response); err != nil {
return err
}
return response.Err()
}
// SetUserCustomStatus will set a custom status and emoji for the currently
// authenticated user. If statusEmoji is "" and statusText is not, the Slack API
// will automatically set it to ":speech_balloon:". Otherwise, if both are ""
// the Slack API will unset the custom status/emoji. If statusExpiration is set to 0
// the status will not expire.
func (api *Client) SetUserCustomStatus(statusText, statusEmoji string, statusExpiration int64) error {
return api.SetUserCustomStatusContextWithUser(context.Background(), "", statusText, statusEmoji, statusExpiration)
}
// SetUserCustomStatusContext will set a custom status and emoji for the currently authenticated user with a custom context
//
// For more information see SetUserCustomStatus
func (api *Client) SetUserCustomStatusContext(ctx context.Context, statusText, statusEmoji string, statusExpiration int64) error {
return api.SetUserCustomStatusContextWithUser(ctx, "", statusText, statusEmoji, statusExpiration)
}
// SetUserCustomStatusWithUser will set a custom status and emoji for the provided user.
//
// For more information see SetUserCustomStatus
func (api *Client) SetUserCustomStatusWithUser(user, statusText, statusEmoji string, statusExpiration int64) error {
return api.SetUserCustomStatusContextWithUser(context.Background(), user, statusText, statusEmoji, statusExpiration)
}
// SetUserCustomStatusContextWithUser will set a custom status and emoji for the provided user with a custom context
//
// For more information see SetUserCustomStatus
func (api *Client) SetUserCustomStatusContextWithUser(ctx context.Context, user, statusText, statusEmoji string, statusExpiration int64) error {
// XXX(theckman): this anonymous struct is for making requests to the Slack
// API for setting and unsetting a User's Custom Status/Emoji. To change
// these values we must provide a JSON document as the profile POST field.
//
// We use an anonymous struct over UserProfile because to unset the values
// on the User's profile we cannot use the `json:"omitempty"` tag. This is
// because an empty string ("") is what's used to unset the values. Check
// out the API docs for more details:
//
// - https://api.slack.com/docs/presence-and-status#custom_status
profile, err := json.Marshal(
&struct {
StatusText string `json:"status_text"`
StatusEmoji string `json:"status_emoji"`
StatusExpiration int64 `json:"status_expiration"`
}{
StatusText: statusText,
StatusEmoji: statusEmoji,
StatusExpiration: statusExpiration,
},
)
if err != nil {
return err
}
values := url.Values{
"token": {api.token},
"profile": {string(profile)},
}
// optional field. It should not be set if empty
if user != "" {
values["user"] = []string{user}
}
response := &userResponseFull{}
if err = api.postMethod(ctx, "users.profile.set", values, response); err != nil {
return err
}
return response.Err()
}
// UnsetUserCustomStatus removes the custom status message for the currently
// authenticated user. This is a convenience method that wraps (*Client).SetUserCustomStatus().
func (api *Client) UnsetUserCustomStatus() error {
return api.UnsetUserCustomStatusContext(context.Background())
}
// UnsetUserCustomStatusContext removes the custom status message for the currently authenticated user
// with a custom context. This is a convenience method that wraps (*Client).SetUserCustomStatus().
func (api *Client) UnsetUserCustomStatusContext(ctx context.Context) error {
return api.SetUserCustomStatusContext(ctx, "", "", 0)
}
// GetUserProfileParameters are the parameters required to get user profile
type GetUserProfileParameters struct {
UserID string
IncludeLabels bool
}
// GetUserProfile retrieves a user's profile information.
func (api *Client) GetUserProfile(params *GetUserProfileParameters) (*UserProfile, error) {
return api.GetUserProfileContext(context.Background(), params)
}
type getUserProfileResponse struct {
SlackResponse
Profile *UserProfile `json:"profile"`
}
// GetUserProfileContext retrieves a user's profile information with a context.
func (api *Client) GetUserProfileContext(ctx context.Context, params *GetUserProfileParameters) (*UserProfile, error) {
values := url.Values{"token": {api.token}}
if params.UserID != "" {
values.Add("user", params.UserID)
}
if params.IncludeLabels {
values.Add("include_labels", "true")
}
resp := &getUserProfileResponse{}
err := api.postMethod(ctx, "users.profile.get", values, &resp)
if err != nil {
return nil, err
}
if err := resp.Err(); err != nil {
return nil, err
}
return resp.Profile, nil
}
slack-0.11.3/users_test.go 0000664 0000000 0000000 00000052370 14307410331 0015423 0 ustar 00root root 0000000 0000000 package slack
import (
"bytes"
"encoding/json"
"fmt"
"image"
"image/draw"
"image/png"
"io"
"io/ioutil"
"net/http"
"os"
"reflect"
"strconv"
"strings"
"sync/atomic"
"testing"
)
func getTestUserProfileCustomField() UserProfileCustomField {
return UserProfileCustomField{
Value: "test value",
Alt: "",
Label: "",
}
}
func getTestUserProfileCustomFields() UserProfileCustomFields {
return UserProfileCustomFields{
fields: map[string]UserProfileCustomField{
"Xxxxxx": getTestUserProfileCustomField(),
}}
}
func getTestUserProfile() UserProfile {
return UserProfile{
StatusText: "testStatus",
StatusEmoji: ":construction:",
RealName: "Test Real Name",
RealNameNormalized: "Test Real Name Normalized",
DisplayName: "Test Display Name",
DisplayNameNormalized: "Test Display Name Normalized",
Email: "test@test.com",
Image24: "https://s3-us-west-2.amazonaws.com/slack-files2/avatars/2016-10-18/92962080834_ef14c1469fc0741caea1_24.jpg",
Image32: "https://s3-us-west-2.amazonaws.com/slack-files2/avatars/2016-10-18/92962080834_ef14c1469fc0741caea1_32.jpg",
Image48: "https://s3-us-west-2.amazonaws.com/slack-files2/avatars/2016-10-18/92962080834_ef14c1469fc0741caea1_48.jpg",
Image72: "https://s3-us-west-2.amazonaws.com/slack-files2/avatars/2016-10-18/92962080834_ef14c1469fc0741caea1_72.jpg",
Image192: "https://s3-us-west-2.amazonaws.com/slack-files2/avatars/2016-10-18/92962080834_ef14c1469fc0741caea1_192.jpg",
Image512: "https://s3-us-west-2.amazonaws.com/slack-files2/avatars/2016-10-18/92962080834_ef14c1469fc0741caea1_512.jpg",
Fields: getTestUserProfileCustomFields(),
}
}
func getTestUserWithId(id string) User {
return User{
ID: id,
Name: "Test User",
Deleted: false,
Color: "9f69e7",
RealName: "testuser",
TZ: "America/Los_Angeles",
TZLabel: "Pacific Daylight Time",
TZOffset: -25200,
Profile: getTestUserProfile(),
IsBot: false,
IsAdmin: false,
IsOwner: false,
IsPrimaryOwner: false,
IsRestricted: false,
IsUltraRestricted: false,
Updated: 1555425715,
Has2FA: false,
}
}
func getTestUser() User {
return getTestUserWithId("UXXXXXXXX")
}
func getTestUsers() []User {
return []User{
getTestUserWithId("UYYYYYYYY"),
getTestUserWithId("UZZZZZZZZ"),
}
}
func getUserIdentity(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
response := []byte(`{
"ok": true,
"user": {
"id": "UXXXXXXXX",
"name": "Test User",
"email": "test@test.com",
"image_24": "https:\/\/s3-us-west-2.amazonaws.com\/slack-files2\/avatars\/2016-10-18\/92962080834_ef14c1469fc0741caea1_24.jpg",
"image_32": "https:\/\/s3-us-west-2.amazonaws.com\/slack-files2\/avatars\/2016-10-18\/92962080834_ef14c1469fc0741caea1_32.jpg",
"image_48": "https:\/\/s3-us-west-2.amazonaws.com\/slack-files2\/avatars\/2016-10-18\/92962080834_ef14c1469fc0741caea1_48.jpg",
"image_72": "https:\/\/s3-us-west-2.amazonaws.com\/slack-files2\/avatars\/2016-10-18\/92962080834_ef14c1469fc0741caea1_72.jpg",
"image_192": "https:\/\/s3-us-west-2.amazonaws.com\/slack-files2\/avatars\/2016-10-18\/92962080834_ef14c1469fc0741caea1_192.jpg",
"image_512": "https:\/\/s3-us-west-2.amazonaws.com\/slack-files2\/avatars\/2016-10-18\/92962080834_ef14c1469fc0741caea1_512.jpg"
},
"team": {
"id": "TXXXXXXXX",
"name": "team-name",
"domain": "team-domain",
"image_34": "https:\/\/s3-us-west-2.amazonaws.com\/slack-files2\/avatars\/2016-10-18\/92962080834_ef14c1469fc0741caea1_34.jpg",
"image_44": "https:\/\/s3-us-west-2.amazonaws.com\/slack-files2\/avatars\/2016-10-18\/92962080834_ef14c1469fc0741caea1_44.jpg",
"image_68": "https:\/\/s3-us-west-2.amazonaws.com\/slack-files2\/avatars\/2016-10-18\/92962080834_ef14c1469fc0741caea1_68.jpg",
"image_88": "https:\/\/s3-us-west-2.amazonaws.com\/slack-files2\/avatars\/2016-10-18\/92962080834_ef14c1469fc0741caea1_88.jpg",
"image_102": "https:\/\/s3-us-west-2.amazonaws.com\/slack-files2\/avatars\/2016-10-18\/92962080834_ef14c1469fc0741caea1_102.jpg",
"image_132": "https:\/\/s3-us-west-2.amazonaws.com\/slack-files2\/avatars\/2016-10-18\/92962080834_ef14c1469fc0741caea1_132.jpg",
"image_230": "https:\/\/s3-us-west-2.amazonaws.com\/slack-files2\/avatars\/2016-10-18\/92962080834_ef14c1469fc0741caea1_230.jpg",
"image_original": "https:\/\/s3-us-west-2.amazonaws.com\/slack-files2\/avatars\/2016-10-18\/92962080834_ef14c1469fc0741caea1_original.jpg"
}
}`)
rw.Write(response)
}
func getUserInfo(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
response, _ := json.Marshal(struct {
Ok bool `json:"ok"`
User User `json:"user"`
}{
Ok: true,
User: getTestUser(),
})
rw.Write(response)
}
func getUsersInfo(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
response, _ := json.Marshal(struct {
Ok bool `json:"ok"`
Users []User `json:"users"`
}{
Ok: true,
Users: getTestUsers(),
})
rw.Write(response)
}
func getUserByEmail(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
response, _ := json.Marshal(struct {
Ok bool `json:"ok"`
User User `json:"user"`
}{
Ok: true,
User: getTestUser(),
})
rw.Write(response)
}
func httpTestErrReply(w http.ResponseWriter, clientErr bool, msg string) {
if clientErr {
w.WriteHeader(http.StatusBadRequest)
} else {
w.WriteHeader(http.StatusInternalServerError)
}
w.Header().Set("Content-Type", "application/json")
body, _ := json.Marshal(&SlackResponse{
Ok: false, Error: msg,
})
w.Write(body)
}
func newProfileHandler(up *UserProfile) (setter func(http.ResponseWriter, *http.Request)) {
return func(w http.ResponseWriter, r *http.Request) {
if up == nil {
httpTestErrReply(w, false, "err: UserProfile is nil")
return
}
if err := r.ParseForm(); err != nil {
httpTestErrReply(w, true, fmt.Sprintf("err parsing form: %s", err.Error()))
return
}
values := r.Form
if v, ok := values["user"]; ok {
if len(v) == 0 || v[0] == "" {
httpTestErrReply(w, true, `POST data must not include an empty in a "user" field`)
return
}
}
if len(values["profile"]) == 0 {
httpTestErrReply(w, true, `POST data must include a "profile" field`)
return
}
profile := []byte(values["profile"][0])
userProfile := UserProfile{}
if err := json.Unmarshal(profile, &userProfile); err != nil {
httpTestErrReply(w, true, fmt.Sprintf("err parsing JSON: %s\n\njson: `%s`", err.Error(), profile))
return
}
*up = userProfile
// TODO(theckman): enhance this to return a full User object
fmt.Fprint(w, `{"ok":true}`)
}
}
func TestGetUserIdentity(t *testing.T) {
http.HandleFunc("/users.identity", getUserIdentity)
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
identity, err := api.GetUserIdentity()
if err != nil {
t.Errorf("Unexpected error: %s", err)
return
}
// t.Fatal refers to -> t.Errorf & return
if identity.User.ID != "UXXXXXXXX" {
t.Fatal(ErrIncorrectResponse)
}
if identity.User.Name != "Test User" {
t.Fatal(ErrIncorrectResponse)
}
if identity.User.Email != "test@test.com" {
t.Fatal(ErrIncorrectResponse)
}
if identity.Team.ID != "TXXXXXXXX" {
t.Fatal(ErrIncorrectResponse)
}
if identity.Team.Name != "team-name" {
t.Fatal(ErrIncorrectResponse)
}
if identity.Team.Domain != "team-domain" {
t.Fatal(ErrIncorrectResponse)
}
if identity.User.Image24 == "" {
t.Fatal(ErrIncorrectResponse)
}
if identity.Team.Image34 == "" {
t.Fatal(ErrIncorrectResponse)
}
}
func TestGetUserInfo(t *testing.T) {
http.HandleFunc("/users.info", getUserInfo)
expectedUser := getTestUser()
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
user, err := api.GetUserInfo("UXXXXXXXX")
if err != nil {
t.Errorf("Unexpected error: %s", err)
return
}
if !reflect.DeepEqual(expectedUser, *user) {
t.Fatal(ErrIncorrectResponse)
}
}
func TestGetUsersInfo(t *testing.T) {
http.DefaultServeMux = new(http.ServeMux)
http.HandleFunc("/users.info", getUsersInfo)
expectedUsers := getTestUsers()
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
user, err := api.GetUsersInfo("UYYYYYYYY", "UZZZZZZZZ")
if err != nil {
t.Errorf("Unexpected error: %s", err)
return
}
if !reflect.DeepEqual(expectedUsers, *user) {
t.Fatal(ErrIncorrectResponse)
}
}
func TestGetUserByEmail(t *testing.T) {
http.HandleFunc("/users.lookupByEmail", getUserByEmail)
expectedUser := getTestUser()
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
user, err := api.GetUserByEmail("test@test.com")
if err != nil {
t.Errorf("Unexpected error: %s", err)
return
}
if !reflect.DeepEqual(expectedUser, *user) {
t.Fatal(ErrIncorrectResponse)
}
}
func TestUserProfileSet(t *testing.T) {
up := &UserProfile{}
setUserProfile := newProfileHandler(up)
http.HandleFunc("/users.profile.set", setUserProfile)
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
testSetUserCustomStatus(api, up, t)
testUnsetUserCustomStatus(api, up, t)
up.RealName = "Test User"
testSetUserCustomStatusWithUser(api, "Test User", up, t)
up.RealName = "Real Name Test"
testSetUserRealName(api, up, t)
}
func testSetUserRealName(api *Client, up *UserProfile, t *testing.T) {
const (
realName = "Real Name Test"
)
if err := api.SetUserRealName(realName); err != nil {
t.Fatalf(`SetUserRealName(%q) = %#v, want `, realName, err)
}
if up.RealName != realName {
t.Fatalf(`UserProfile.RealName = %q, want %q`, up.RealName, realName)
}
}
func testSetUserCustomStatus(api *Client, up *UserProfile, t *testing.T) {
const (
statusText = "testStatus"
statusEmoji = ":construction:"
statusExpiration = 1551619082
)
if err := api.SetUserCustomStatus(statusText, statusEmoji, statusExpiration); err != nil {
t.Fatalf(`SetUserCustomStatus(%q, %q, %q) = %#v, want `, statusText, statusEmoji, statusExpiration, err)
}
if up.StatusText != statusText {
t.Fatalf(`UserProfile.StatusText = %q, want %q`, up.StatusText, statusText)
}
if up.StatusEmoji != statusEmoji {
t.Fatalf(`UserProfile.StatusEmoji = %q, want %q`, up.StatusEmoji, statusEmoji)
}
if up.StatusExpiration != statusExpiration {
t.Fatalf(`UserProfile.StatusExpiration = %q, want %q`, up.StatusExpiration, statusExpiration)
}
}
func testSetUserCustomStatusWithUser(api *Client, user string, up *UserProfile, t *testing.T) {
const (
statusText = "testStatus"
statusEmoji = ":construction:"
statusExpiration = 1551619082
)
if err := api.SetUserCustomStatusWithUser(user, statusText, statusEmoji, statusExpiration); err != nil {
t.Fatalf(`SetUserCustomStatusWithUser(%q, %q, %q, %q) = %#v, want `, user, statusText, statusEmoji, statusExpiration, err)
}
if up.StatusText != statusText {
t.Fatalf(`UserProfile.StatusText = %q, want %q`, up.StatusText, statusText)
}
if up.StatusEmoji != statusEmoji {
t.Fatalf(`UserProfile.StatusEmoji = %q, want %q`, up.StatusEmoji, statusEmoji)
}
if up.StatusExpiration != statusExpiration {
t.Fatalf(`UserProfile.StatusExpiration = %q, want %q`, up.StatusExpiration, statusExpiration)
}
}
func testUnsetUserCustomStatus(api *Client, up *UserProfile, t *testing.T) {
if err := api.UnsetUserCustomStatus(); err != nil {
t.Fatalf(`UnsetUserCustomStatus() = %#v, want `, err)
}
if up.StatusText != "" {
t.Fatalf(`UserProfile.StatusText = %q, want %q`, up.StatusText, "")
}
if up.StatusEmoji != "" {
t.Fatalf(`UserProfile.StatusEmoji = %q, want %q`, up.StatusEmoji, "")
}
}
func TestGetUsers(t *testing.T) {
http.DefaultServeMux = new(http.ServeMux)
http.HandleFunc("/users.list", getUserPage(4))
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
users, err := api.GetUsers()
if err != nil {
t.Errorf("Unexpected error: %s", err)
return
}
if !reflect.DeepEqual([]User{
getTestUserWithId("U000"),
getTestUserWithId("U001"),
getTestUserWithId("U002"),
getTestUserWithId("U003"),
}, users) {
t.Fatal(ErrIncorrectResponse)
}
}
// returns n pages users.
func getUserPage(max int64) func(rw http.ResponseWriter, r *http.Request) {
var n int64
return func(rw http.ResponseWriter, r *http.Request) {
var cpage int64
sresp := SlackResponse{
Ok: true,
}
members := []User{
getTestUserWithId(fmt.Sprintf("U%03d", n)),
}
rw.Header().Set("Content-Type", "application/json")
if cpage = atomic.AddInt64(&n, 1); cpage == max {
response, _ := json.Marshal(userResponseFull{
SlackResponse: sresp,
Members: members,
})
rw.Write(response)
return
}
response, _ := json.Marshal(userResponseFull{
SlackResponse: sresp,
Members: members,
Metadata: ResponseMetadata{Cursor: strconv.Itoa(int(cpage))},
})
rw.Write(response)
}
}
// returns n pages of users and sends rate limited errors in between successful pages.
func getUserPagesWithRateLimitErrors(max int64) func(rw http.ResponseWriter, r *http.Request) {
var n int64
doRateLimit := false
return func(rw http.ResponseWriter, r *http.Request) {
defer func() {
doRateLimit = !doRateLimit
}()
if doRateLimit {
rw.Header().Set("Retry-After", "1")
rw.WriteHeader(http.StatusTooManyRequests)
return
}
var cpage int64
sresp := SlackResponse{
Ok: true,
}
members := []User{
getTestUserWithId(fmt.Sprintf("U%03d", n)),
}
rw.Header().Set("Content-Type", "application/json")
if cpage = atomic.AddInt64(&n, 1); cpage == max {
response, _ := json.Marshal(userResponseFull{
SlackResponse: sresp,
Members: members,
})
rw.Write(response)
return
}
response, _ := json.Marshal(userResponseFull{
SlackResponse: sresp,
Members: members,
Metadata: ResponseMetadata{Cursor: strconv.Itoa(int(cpage))},
})
rw.Write(response)
}
}
func TestSetUserPhoto(t *testing.T) {
file, fileContent, teardown := createUserPhoto(t)
defer teardown()
params := UserSetPhotoParams{CropX: 0, CropY: 0, CropW: 32}
http.HandleFunc("/users.setPhoto", setUserPhotoHandler(fileContent, params))
once.Do(startServer)
api := New(validToken, OptionAPIURL("http://"+serverAddr+"/"))
err := api.SetUserPhoto(file.Name(), params)
if err != nil {
t.Fatalf("unexpected error: %+v\n", err)
}
}
func setUserPhotoHandler(wantBytes []byte, wantParams UserSetPhotoParams) http.HandlerFunc {
const maxMemory = 1 << 20 // 1 MB
return func(w http.ResponseWriter, r *http.Request) {
if err := r.ParseMultipartForm(maxMemory); err != nil {
httpTestErrReply(w, false, fmt.Sprintf("failed to parse multipart/form: %+v", err))
return
}
// Test for expected token
actualToken := strings.Split(r.Header.Get("Authorization"), "Bearer ")[1]
if actualToken != validToken {
httpTestErrReply(w, true, fmt.Sprintf("expected multipart form value token=%v", validToken))
return
}
// Test for expected crop params
if wantParams.CropX != DEFAULT_USER_PHOTO_CROP_X {
if cx, err := strconv.Atoi(r.Form.Get("crop_x")); err != nil || cx != wantParams.CropX {
httpTestErrReply(w, true, fmt.Sprintf("expected multipart form value crop_x=%d", wantParams.CropX))
return
}
}
if wantParams.CropY != DEFAULT_USER_PHOTO_CROP_Y {
if cy, err := strconv.Atoi(r.Form.Get("crop_y")); err != nil || cy != wantParams.CropY {
httpTestErrReply(w, true, fmt.Sprintf("expected multipart form value crop_y=%d", wantParams.CropY))
return
}
}
if wantParams.CropW != DEFAULT_USER_PHOTO_CROP_W {
if cw, err := strconv.Atoi(r.Form.Get("crop_w")); err != nil || cw != wantParams.CropW {
httpTestErrReply(w, true, fmt.Sprintf("expected multipart form value crop_w=%d", wantParams.CropW))
return
}
}
// Test for expected image
f, ok := r.MultipartForm.File["image"]
if !ok || len(f) == 0 {
httpTestErrReply(w, true, `expected multipart form file "image"`)
return
}
file, err := f[0].Open()
if err != nil {
httpTestErrReply(w, true, fmt.Sprintf("failed to open uploaded file: %+v", err))
return
}
gotBytes, err := ioutil.ReadAll(file)
if err != nil {
httpTestErrReply(w, true, fmt.Sprintf("failed to read uploaded file: %+v", err))
return
}
if !bytes.Equal(wantBytes, gotBytes) {
httpTestErrReply(w, true, "uploaded bytes did not match expected bytes")
return
}
w.Header().Set("Content-Type", "application/json")
fmt.Fprint(w, `{"ok":true}`)
}
}
// createUserPhoto generates a temp photo for testing. It returns the file handle, the file
// contents, and a function that can be called to remove the file.
func createUserPhoto(t *testing.T) (*os.File, []byte, func()) {
photo := image.NewRGBA(image.Rect(0, 0, 64, 64))
draw.Draw(photo, photo.Bounds(), image.Black, image.ZP, draw.Src)
f, err := ioutil.TempFile(os.TempDir(), "profile.png")
if err != nil {
t.Fatalf("failed to create test photo: %+v\n", err)
}
var buf bytes.Buffer
if err := png.Encode(io.MultiWriter(&buf, f), photo); err != nil {
t.Fatalf("failed to write test photo: %+v\n", err)
}
teardown := func() {
if err := os.Remove(f.Name()); err != nil {
t.Fatalf("failed to remove test photo: %+v\n", err)
}
}
return f, buf.Bytes(), teardown
}
func getUserProfileHandler(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
profile := getTestUserProfile()
resp, _ := json.Marshal(&getUserProfileResponse{
SlackResponse: SlackResponse{Ok: true},
Profile: &profile})
rw.Write(resp)
}
func TestGetUserProfile(t *testing.T) {
http.HandleFunc("/users.profile.get", getUserProfileHandler)
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
profile, err := api.GetUserProfile(&GetUserProfileParameters{UserID: "UXXXXXXXX"})
if err != nil {
t.Fatalf("Unexpected error: %s", err)
}
exp := getTestUserProfile()
if profile.DisplayName != exp.DisplayName {
t.Fatalf(`profile.DisplayName = "%s", wanted "%s"`, profile.DisplayName, exp.DisplayName)
}
}
func TestSetFieldsMap(t *testing.T) {
p := &UserProfile{}
exp := map[string]UserProfileCustomField{
"Xxxxxx": getTestUserProfileCustomField(),
}
p.SetFieldsMap(exp)
act := p.FieldsMap()
if !reflect.DeepEqual(act, exp) {
t.Fatalf(`p.FieldsMap() = %v, wanted %v`, act, exp)
}
}
func TestUserProfileCustomFieldsUnmarshalJSON(t *testing.T) {
fields := &UserProfileCustomFields{}
if err := json.Unmarshal([]byte(`[]`), fields); err != nil {
t.Fatal(err)
}
if err := json.Unmarshal([]byte(`{
"Xxxxxx": {
"value": "test value",
"alt": ""
}
}`), fields); err != nil {
t.Fatal(err)
}
act := fields.ToMap()["Xxxxxx"].Value
exp := "test value"
if act != exp {
t.Fatalf(`fields.ToMap()["Xxxxxx"]["value"] = "%s", wanted "%s"`, act, exp)
}
}
func TestUserProfileCustomFieldsMarshalJSON(t *testing.T) {
fields := UserProfileCustomFields{}
b, err := json.Marshal(fields)
if err != nil {
t.Fatal(err)
}
if string(b) != "[]" {
t.Fatalf(`string(b) = "%s", wanted "[]"`, string(b))
}
fields = getTestUserProfileCustomFields()
if _, err := json.Marshal(fields); err != nil {
t.Fatal(err)
}
}
func TestUserProfileCustomFieldsToMap(t *testing.T) {
m := map[string]UserProfileCustomField{
"Xxxxxx": getTestUserProfileCustomField(),
}
fields := UserProfileCustomFields{fields: m}
act := fields.ToMap()
if !reflect.DeepEqual(act, m) {
t.Fatalf(`fields.ToMap() = %v, wanted %v`, act, m)
}
}
func TestUserProfileCustomFieldsLen(t *testing.T) {
fields := UserProfileCustomFields{
fields: map[string]UserProfileCustomField{
"Xxxxxx": getTestUserProfileCustomField(),
}}
if fields.Len() != 1 {
t.Fatalf(`fields.Len() = %d, wanted 1`, fields.Len())
}
}
func TestUserProfileCustomFieldsSetMap(t *testing.T) {
fields := UserProfileCustomFields{}
m := map[string]UserProfileCustomField{
"Xxxxxx": getTestUserProfileCustomField(),
}
fields.SetMap(m)
if !reflect.DeepEqual(fields.fields, m) {
t.Fatalf(`fields.fields = %v, wanted %v`, fields.fields, m)
}
}
func TestGetUsersHandlesRateLimit(t *testing.T) {
http.DefaultServeMux = new(http.ServeMux)
http.HandleFunc("/users.list", getUserPagesWithRateLimitErrors(4))
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
users, err := api.GetUsers()
if err != nil {
t.Errorf("Unexpected error: %s", err)
return
}
if !reflect.DeepEqual([]User{
getTestUserWithId("U000"),
getTestUserWithId("U001"),
getTestUserWithId("U002"),
getTestUserWithId("U003"),
}, users) {
t.Fatal(ErrIncorrectResponse)
}
}
func TestGetUsersReturnsServerError(t *testing.T) {
http.DefaultServeMux = new(http.ServeMux)
http.HandleFunc("/users.list", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusInternalServerError)
})
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
_, err := api.GetUsers()
if err == nil {
t.Errorf("Expected error but got nil")
return
}
expectedErr := "slack server error: 500 Internal Server Error"
if err.Error() != expectedErr {
t.Errorf("Expected: %s. Got: %s", expectedErr, err.Error())
}
}
slack-0.11.3/views.go 0000664 0000000 0000000 00000020722 14307410331 0014354 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"encoding/json"
)
const (
VTModal ViewType = "modal"
VTHomeTab ViewType = "home"
)
type ViewType string
type ViewState struct {
Values map[string]map[string]BlockAction `json:"values"`
}
type View struct {
SlackResponse
ID string `json:"id"`
TeamID string `json:"team_id"`
Type ViewType `json:"type"`
Title *TextBlockObject `json:"title"`
Close *TextBlockObject `json:"close"`
Submit *TextBlockObject `json:"submit"`
Blocks Blocks `json:"blocks"`
PrivateMetadata string `json:"private_metadata"`
CallbackID string `json:"callback_id"`
State *ViewState `json:"state"`
Hash string `json:"hash"`
ClearOnClose bool `json:"clear_on_close"`
NotifyOnClose bool `json:"notify_on_close"`
RootViewID string `json:"root_view_id"`
PreviousViewID string `json:"previous_view_id"`
AppID string `json:"app_id"`
ExternalID string `json:"external_id"`
BotID string `json:"bot_id"`
AppInstalledTeamID string `json:"app_installed_team_id"`
}
type ViewSubmissionCallbackResponseURL struct {
BlockID string `json:"block_id"`
ActionID string `json:"action_id"`
ChannelID string `json:"channel_id"`
ResponseURL string `json:"response_url"`
}
type ViewSubmissionCallback struct {
Hash string `json:"hash"`
ResponseURLs []ViewSubmissionCallbackResponseURL `json:"response_urls,omitempty"`
}
type ViewClosedCallback struct {
IsCleared bool `json:"is_cleared"`
}
const (
RAClear ViewResponseAction = "clear"
RAUpdate ViewResponseAction = "update"
RAPush ViewResponseAction = "push"
RAErrors ViewResponseAction = "errors"
)
type ViewResponseAction string
type ViewSubmissionResponse struct {
ResponseAction ViewResponseAction `json:"response_action"`
View *ModalViewRequest `json:"view,omitempty"`
Errors map[string]string `json:"errors,omitempty"`
}
func NewClearViewSubmissionResponse() *ViewSubmissionResponse {
return &ViewSubmissionResponse{
ResponseAction: RAClear,
}
}
func NewUpdateViewSubmissionResponse(view *ModalViewRequest) *ViewSubmissionResponse {
return &ViewSubmissionResponse{
ResponseAction: RAUpdate,
View: view,
}
}
func NewPushViewSubmissionResponse(view *ModalViewRequest) *ViewSubmissionResponse {
return &ViewSubmissionResponse{
ResponseAction: RAPush,
View: view,
}
}
func NewErrorsViewSubmissionResponse(errors map[string]string) *ViewSubmissionResponse {
return &ViewSubmissionResponse{
ResponseAction: RAErrors,
Errors: errors,
}
}
type ModalViewRequest struct {
Type ViewType `json:"type"`
Title *TextBlockObject `json:"title,omitempty"`
Blocks Blocks `json:"blocks"`
Close *TextBlockObject `json:"close,omitempty"`
Submit *TextBlockObject `json:"submit,omitempty"`
PrivateMetadata string `json:"private_metadata,omitempty"`
CallbackID string `json:"callback_id,omitempty"`
ClearOnClose bool `json:"clear_on_close,omitempty"`
NotifyOnClose bool `json:"notify_on_close,omitempty"`
ExternalID string `json:"external_id,omitempty"`
}
func (v *ModalViewRequest) ViewType() ViewType {
return v.Type
}
type HomeTabViewRequest struct {
Type ViewType `json:"type"`
Blocks Blocks `json:"blocks"`
PrivateMetadata string `json:"private_metadata,omitempty"`
CallbackID string `json:"callback_id,omitempty"`
ExternalID string `json:"external_id,omitempty"`
}
func (v *HomeTabViewRequest) ViewType() ViewType {
return v.Type
}
type openViewRequest struct {
TriggerID string `json:"trigger_id"`
View ModalViewRequest `json:"view"`
}
type publishViewRequest struct {
UserID string `json:"user_id"`
View HomeTabViewRequest `json:"view"`
Hash string `json:"hash,omitempty"`
}
type pushViewRequest struct {
TriggerID string `json:"trigger_id"`
View ModalViewRequest `json:"view"`
}
type updateViewRequest struct {
View ModalViewRequest `json:"view"`
ExternalID string `json:"external_id,omitempty"`
Hash string `json:"hash,omitempty"`
ViewID string `json:"view_id,omitempty"`
}
type ViewResponse struct {
SlackResponse
View `json:"view"`
}
// OpenView opens a view for a user.
func (api *Client) OpenView(triggerID string, view ModalViewRequest) (*ViewResponse, error) {
return api.OpenViewContext(context.Background(), triggerID, view)
}
// ValidateUniqueBlockID will verify if each input block has a unique block ID if set
func ValidateUniqueBlockID(view ModalViewRequest) bool {
uniqueBlockID := map[string]bool{}
for _, b := range view.Blocks.BlockSet {
if inputBlock, ok := b.(*InputBlock); ok {
if _, ok := uniqueBlockID[inputBlock.BlockID]; ok {
return false
}
uniqueBlockID[inputBlock.BlockID] = true
}
}
return true
}
// OpenViewContext opens a view for a user with a custom context.
func (api *Client) OpenViewContext(
ctx context.Context,
triggerID string,
view ModalViewRequest,
) (*ViewResponse, error) {
if triggerID == "" {
return nil, ErrParametersMissing
}
if !ValidateUniqueBlockID(view) {
return nil, ErrBlockIDNotUnique
}
req := openViewRequest{
TriggerID: triggerID,
View: view,
}
encoded, err := json.Marshal(req)
if err != nil {
return nil, err
}
endpoint := api.endpoint + "views.open"
resp := &ViewResponse{}
err = postJSON(ctx, api.httpclient, endpoint, api.token, encoded, resp, api)
if err != nil {
return nil, err
}
return resp, resp.Err()
}
// PublishView publishes a static view for a user.
func (api *Client) PublishView(userID string, view HomeTabViewRequest, hash string) (*ViewResponse, error) {
return api.PublishViewContext(context.Background(), userID, view, hash)
}
// PublishViewContext publishes a static view for a user with a custom context.
func (api *Client) PublishViewContext(
ctx context.Context,
userID string,
view HomeTabViewRequest,
hash string,
) (*ViewResponse, error) {
if userID == "" {
return nil, ErrParametersMissing
}
req := publishViewRequest{
UserID: userID,
View: view,
Hash: hash,
}
encoded, err := json.Marshal(req)
if err != nil {
return nil, err
}
endpoint := api.endpoint + "views.publish"
resp := &ViewResponse{}
err = postJSON(ctx, api.httpclient, endpoint, api.token, encoded, resp, api)
if err != nil {
return nil, err
}
return resp, resp.Err()
}
// PushView pushes a view onto the stack of a root view.
func (api *Client) PushView(triggerID string, view ModalViewRequest) (*ViewResponse, error) {
return api.PushViewContext(context.Background(), triggerID, view)
}
// PublishViewContext pushes a view onto the stack of a root view with a custom context.
func (api *Client) PushViewContext(
ctx context.Context,
triggerID string,
view ModalViewRequest,
) (*ViewResponse, error) {
if triggerID == "" {
return nil, ErrParametersMissing
}
req := pushViewRequest{
TriggerID: triggerID,
View: view,
}
encoded, err := json.Marshal(req)
if err != nil {
return nil, err
}
endpoint := api.endpoint + "views.push"
resp := &ViewResponse{}
err = postJSON(ctx, api.httpclient, endpoint, api.token, encoded, resp, api)
if err != nil {
return nil, err
}
return resp, resp.Err()
}
// UpdateView updates an existing view.
func (api *Client) UpdateView(view ModalViewRequest, externalID, hash, viewID string) (*ViewResponse, error) {
return api.UpdateViewContext(context.Background(), view, externalID, hash, viewID)
}
// UpdateViewContext updates an existing view with a custom context.
func (api *Client) UpdateViewContext(
ctx context.Context,
view ModalViewRequest,
externalID, hash,
viewID string,
) (*ViewResponse, error) {
if externalID == "" && viewID == "" {
return nil, ErrParametersMissing
}
req := updateViewRequest{
View: view,
ExternalID: externalID,
Hash: hash,
ViewID: viewID,
}
encoded, err := json.Marshal(req)
if err != nil {
return nil, err
}
endpoint := api.endpoint + "views.update"
resp := &ViewResponse{}
err = postJSON(ctx, api.httpclient, endpoint, api.token, encoded, resp, api)
if err != nil {
return nil, err
}
return resp, resp.Err()
}
slack-0.11.3/views_test.go 0000664 0000000 0000000 00000053060 14307410331 0015414 0 ustar 00root root 0000000 0000000 package slack
import (
"encoding/json"
"net/http"
"reflect"
"testing"
"github.com/stretchr/testify/assert"
"github.com/slack-go/slack/internal/errorsx"
)
var dummySlackErr = errorsx.String("dummy_error_from_slack")
type viewsHandler struct {
rawResponse string
}
func (h *viewsHandler) handler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(h.rawResponse))
}
func TestSlack_OpenView(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
cases := []struct {
caseName string
triggerID string
modalViewRequest ModalViewRequest
rawResp string
expectedResp *ViewResponse
expectedErr error
}{
{
caseName: "pass empty trigger_id",
triggerID: "",
modalViewRequest: ModalViewRequest{},
rawResp: "",
expectedResp: nil,
expectedErr: ErrParametersMissing,
},
{
caseName: "raise an error for not having a unique block id",
triggerID: "dummy_trigger_id",
modalViewRequest: ModalViewRequest{
Blocks: Blocks{
BlockSet: []Block{
&InputBlock{
BlockID: "example",
},
&InputBlock{
BlockID: "example",
},
},
},
},
rawResp: "",
expectedResp: nil,
expectedErr: ErrBlockIDNotUnique,
},
{
caseName: "raise an error from Slack API",
triggerID: "dummy_trigger_id",
modalViewRequest: ModalViewRequest{},
rawResp: `{
"ok": false,
"error": "dummy_error_from_slack",
"response_metadata": {
"warnings": [
"missing_charset"
],
"messages": [
"[WARN] A Content-Type HTTP header was presented but did not declare a charset, such as a 'utf-8'"
]
}
}`,
expectedResp: &ViewResponse{
SlackResponse{
Ok: false,
Error: dummySlackErr.Error(),
ResponseMetadata: ResponseMetadata{
Messages: []string{"[WARN] A Content-Type HTTP header was presented but did not declare a charset, such as a 'utf-8'"},
Warnings: []string{"missing_charset"},
},
},
View{},
},
expectedErr: dummySlackErr,
},
{
caseName: "success",
triggerID: "dummy_trigger_id",
modalViewRequest: ModalViewRequest{},
rawResp: `{
"ok": true,
"view": {
"id": "VMHU10V25",
"team_id": "T8N4K1JN",
"type": "modal",
"title": {
"type": "plain_text",
"text": "Quite a plain modal"
},
"submit": {
"type": "plain_text",
"text": "Create"
},
"blocks": [
{
"type": "input",
"block_id": "a_block_id",
"label": {
"type": "plain_text",
"text": "A simple label"
},
"optional": false,
"element": {
"type": "plain_text_input",
"placeholder": {
"type": "plain_text",
"text": "Placeholder text"
},
"action_id": "an_action_id"
}
}
],
"private_metadata": "Shh it is a secret",
"callback_id": "identify_your_modals",
"external_id": "",
"state": {
"values": {}
},
"hash": "156772938.1827394",
"clear_on_close": false,
"notify_on_close": false,
"root_view_id": "VMHU10V25",
"app_id": "AA4928AQ",
"bot_id": "BA13894H"
}
}`,
expectedResp: &ViewResponse{
SlackResponse{
Ok: true,
Error: "",
},
View{
ID: "VMHU10V25",
Type: VTModal,
TeamID: "T8N4K1JN",
Title: &TextBlockObject{
Type: PlainTextType,
Text: "Quite a plain modal",
},
Submit: &TextBlockObject{
Type: PlainTextType,
Text: "Create",
},
CallbackID: "identify_your_modals",
PrivateMetadata: "Shh it is a secret",
State: &ViewState{},
Hash: "156772938.1827394",
RootViewID: "VMHU10V25",
AppID: "AA4928AQ",
BotID: "BA13894H",
Blocks: Blocks{
BlockSet: []Block{
NewInputBlock(
"a_block_id",
&TextBlockObject{
Type: PlainTextType,
Text: "A simple label",
},
&TextBlockObject{
Type: PlainTextType,
Text: "A simple hint",
},
NewPlainTextInputBlockElement(
&TextBlockObject{
Type: PlainTextType,
Text: "Placeholder text",
},
"an_action_id",
)),
},
},
},
},
expectedErr: nil,
},
}
h := &viewsHandler{}
http.HandleFunc("/views.open", h.handler)
for _, c := range cases {
t.Run(c.caseName, func(t *testing.T) {
h.rawResponse = c.rawResp
resp, err := api.OpenView(c.triggerID, c.modalViewRequest)
if c.expectedErr == nil && err != nil {
t.Fatalf("unexpected error: %s\n", err)
}
if c.expectedErr != nil && err == nil {
t.Fatalf("expected %s, but did not raise an error", c.expectedErr)
}
if c.expectedErr != nil && err != nil && c.expectedErr.Error() != err.Error() {
t.Fatalf("expected %s as error but got %s\n", c.expectedErr, err)
}
if resp == nil || c.expectedResp == nil {
return
}
if !reflect.DeepEqual(resp.ResponseMetadata.Messages, c.expectedResp.ResponseMetadata.Messages) {
t.Fatalf("expected:\n\t%v\n but got:\n\t%v\n", c.expectedResp.ResponseMetadata.Messages, resp.ResponseMetadata.Messages)
}
if !reflect.DeepEqual(resp.ResponseMetadata.Warnings, c.expectedResp.ResponseMetadata.Warnings) {
t.Fatalf("expected:\n\t%v\n but got:\n\t%v\n", c.expectedResp.ResponseMetadata.Warnings, resp.ResponseMetadata.Warnings)
}
})
}
}
func TestSlack_View_PublishView(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
cases := []struct {
caseName string
userID string
rawResp string
expectedResp *ViewResponse
expectedErr error
}{
{
caseName: "pass empty user_id",
userID: "",
rawResp: "",
expectedResp: nil,
expectedErr: ErrParametersMissing,
},
{
caseName: "raise an error from Slack API",
userID: "dummy_user_id",
rawResp: `{
"ok": false,
"error": "dummy_error_from_slack",
"response_metadata": {
"warnings": [
"missing_charset"
],
"messages": [
"[WARN] A Content-Type HTTP header was presented but did not declare a charset, such as a 'utf-8'"
]
}
}`,
expectedResp: &ViewResponse{
SlackResponse{
Ok: false,
Error: dummySlackErr.Error(),
ResponseMetadata: ResponseMetadata{
Messages: []string{"[WARN] A Content-Type HTTP header was presented but did not declare a charset, such as a 'utf-8'"},
Warnings: []string{"missing_charset"},
},
},
View{},
},
expectedErr: dummySlackErr,
},
{
caseName: "success",
userID: "dummy_user_id",
rawResp: `{
"ok": true,
"view": {
"id": "VMHU10V25",
"team_id": "T8N4K1JN",
"type": "home",
"close": null,
"submit": null,
"blocks": [
{
"type": "input",
"block_id": "a_block_id",
"label": {
"type": "plain_text",
"text": "A simple label"
},
"optional": false,
"element": {
"type": "plain_text_input",
"placeholder": {
"type": "plain_text",
"text": "Placeholder text"
},
"action_id": "an_action_id"
}
}
],
"private_metadata": "Shh it is a secret",
"callback_id": "identify_your_home_tab",
"state": {
"values": {}
},
"hash": "156772938.1827394",
"clear_on_close": false,
"notify_on_close": false,
"root_view_id": "VMHU10V25",
"previous_view_id": null,
"app_id": "AA4928AQ",
"external_id": "",
"bot_id": "BA13894H"
}
}`,
expectedResp: &ViewResponse{
SlackResponse{
Ok: true,
Error: "",
},
View{
ID: "VMHU10V25",
Type: VTHomeTab,
TeamID: "T8N4K1JN",
CallbackID: "identify_your_home_tab",
PrivateMetadata: "Shh it is a secret",
State: &ViewState{},
Hash: "156772938.1827394",
RootViewID: "VMHU10V25",
AppID: "AA4928AQ",
BotID: "BA13894H",
Blocks: Blocks{
BlockSet: []Block{
NewInputBlock(
"a_block_id",
&TextBlockObject{
Type: PlainTextType,
Text: "A simple label",
},
&TextBlockObject{
Type: PlainTextType,
Text: "A simple hint",
},
NewPlainTextInputBlockElement(
&TextBlockObject{
Type: PlainTextType,
Text: "Placeholder text",
},
"an_action_id",
)),
},
},
},
},
expectedErr: nil,
},
}
h := &viewsHandler{}
http.HandleFunc("/views.publish", h.handler)
for _, c := range cases {
t.Run(c.caseName, func(t *testing.T) {
h.rawResponse = c.rawResp
resp, err := api.PublishView(c.userID, HomeTabViewRequest{}, "dummy_hash")
if c.expectedErr == nil && err != nil {
t.Fatalf("unexpected error: %s\n", err)
}
if c.expectedErr != nil && err == nil {
t.Fatalf("expected %s, but did not raise an error", c.expectedErr)
}
if c.expectedErr != nil && err != nil && c.expectedErr.Error() != err.Error() {
t.Fatalf("expected %s as error but got %s\n", c.expectedErr, err)
}
if resp == nil || c.expectedResp == nil {
return
}
if !reflect.DeepEqual(resp.ResponseMetadata.Messages, c.expectedResp.ResponseMetadata.Messages) {
t.Fatalf("expected:\n\t%v\n but got:\n\t%v\n", c.expectedResp.ResponseMetadata.Messages, resp.ResponseMetadata.Messages)
}
if !reflect.DeepEqual(resp.ResponseMetadata.Warnings, c.expectedResp.ResponseMetadata.Warnings) {
t.Fatalf("expected:\n\t%v\n but got:\n\t%v\n", c.expectedResp.ResponseMetadata.Warnings, resp.ResponseMetadata.Warnings)
}
})
}
}
func TestSlack_PushView(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
cases := []struct {
caseName string
triggerID string
rawResp string
expectedResp *ViewResponse
expectedErr error
}{
{
caseName: "pass empty trigger_id",
triggerID: "",
rawResp: "",
expectedResp: nil,
expectedErr: ErrParametersMissing,
},
{
caseName: "raise an error from Slack API",
triggerID: "dummy_trigger_id",
rawResp: `{
"ok": false,
"error": "dummy_error_from_slack",
"response_metadata": {
"warnings": [
"missing_charset"
],
"messages": [
"[WARN] A Content-Type HTTP header was presented but did not declare a charset, such as a 'utf-8'"
]
}
}`,
expectedResp: &ViewResponse{
SlackResponse{
Ok: false,
Error: dummySlackErr.Error(),
ResponseMetadata: ResponseMetadata{
Messages: []string{"[WARN] A Content-Type HTTP header was presented but did not declare a charset, such as a 'utf-8'"},
Warnings: []string{"missing_charset"},
},
},
View{},
},
expectedErr: dummySlackErr,
},
{
caseName: "success",
triggerID: "dummy_trigger_id",
rawResp: `{
"ok": true,
"view": {
"id": "VMHU10V25",
"team_id": "T8N4K1JN",
"type": "modal",
"title": {
"type": "plain_text",
"text": "Quite a plain modal"
},
"submit": {
"type": "plain_text",
"text": "Create"
},
"blocks": [
{
"type": "input",
"block_id": "a_block_id",
"label": {
"type": "plain_text",
"text": "A simple label"
},
"optional": false,
"element": {
"type": "plain_text_input",
"placeholder": {
"type": "plain_text",
"text": "Placeholder text"
},
"action_id": "an_action_id"
}
}
],
"private_metadata": "Shh it is a secret",
"callback_id": "identify_your_modals",
"external_id": "",
"state": {
"values": {}
},
"hash": "156772938.1827394",
"clear_on_close": false,
"notify_on_close": false,
"root_view_id": "VMHU10V25",
"app_id": "AA4928AQ",
"bot_id": "BA13894H"
}
}`,
expectedResp: &ViewResponse{
SlackResponse{
Ok: true,
Error: "",
},
View{
ID: "VMHU10V25",
Type: VTModal,
TeamID: "T8N4K1JN",
Title: &TextBlockObject{
Type: PlainTextType,
Text: "Quite a plain modal",
},
Submit: &TextBlockObject{
Type: PlainTextType,
Text: "Create",
},
CallbackID: "identify_your_modals",
PrivateMetadata: "Shh it is a secret",
State: &ViewState{},
Hash: "156772938.1827394",
RootViewID: "VMHU10V25",
AppID: "AA4928AQ",
BotID: "BA13894H",
Blocks: Blocks{
BlockSet: []Block{
NewInputBlock(
"a_block_id",
&TextBlockObject{
Type: PlainTextType,
Text: "A simple label",
},
&TextBlockObject{
Type: PlainTextType,
Text: "A simple hint",
},
NewPlainTextInputBlockElement(
&TextBlockObject{
Type: PlainTextType,
Text: "Placeholder text",
},
"an_action_id",
)),
},
},
},
},
expectedErr: nil,
},
}
h := &viewsHandler{}
http.HandleFunc("/views.push", h.handler)
for _, c := range cases {
t.Run(c.caseName, func(t *testing.T) {
h.rawResponse = c.rawResp
resp, err := api.PushView(c.triggerID, ModalViewRequest{})
if c.expectedErr == nil && err != nil {
t.Fatalf("unexpected error: %s\n", err)
}
if c.expectedErr != nil && err == nil {
t.Fatalf("expected %s, but did not raise an error", c.expectedErr)
}
if c.expectedErr != nil && err != nil && c.expectedErr.Error() != err.Error() {
t.Fatalf("expected %s as error but got %s\n", c.expectedErr, err)
}
if resp == nil || c.expectedResp == nil {
return
}
if !reflect.DeepEqual(resp.ResponseMetadata.Messages, c.expectedResp.ResponseMetadata.Messages) {
t.Fatalf("expected:\n\t%v\n but got:\n\t%v\n", c.expectedResp.ResponseMetadata.Messages, resp.ResponseMetadata.Messages)
}
if !reflect.DeepEqual(resp.ResponseMetadata.Warnings, c.expectedResp.ResponseMetadata.Warnings) {
t.Fatalf("expected:\n\t%v\n but got:\n\t%v\n", c.expectedResp.ResponseMetadata.Warnings, resp.ResponseMetadata.Warnings)
}
})
}
}
func TestSlack_UpdateView(t *testing.T) {
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
cases := []struct {
caseName string
externalID string
viewID string
rawResp string
expectedResp *ViewResponse
expectedErr error
}{
{
caseName: "pass empty external_id and empty view_id",
externalID: "",
viewID: "",
rawResp: "",
expectedResp: nil,
expectedErr: ErrParametersMissing,
},
{
caseName: "raise an error from Slack API",
externalID: "dummy_external_id",
viewID: "",
rawResp: `{
"ok": false,
"error": "dummy_error_from_slack",
"response_metadata": {
"warnings": [
"missing_charset"
],
"messages": [
"[WARN] A Content-Type HTTP header was presented but did not declare a charset, such as a 'utf-8'"
]
}
}`,
expectedResp: &ViewResponse{
SlackResponse{
Ok: false,
Error: dummySlackErr.Error(),
ResponseMetadata: ResponseMetadata{
Messages: []string{"[WARN] A Content-Type HTTP header was presented but did not declare a charset, such as a 'utf-8'"},
Warnings: []string{"missing_charset"},
},
},
View{},
},
expectedErr: dummySlackErr,
},
{
caseName: "success",
externalID: "",
viewID: "dummy_view_id",
rawResp: `{
"ok": true,
"view": {
"id": "VMHU10V25",
"team_id": "T8N4K1JN",
"type": "modal",
"title": {
"type": "plain_text",
"text": "Quite a plain modal"
},
"submit": {
"type": "plain_text",
"text": "Create"
},
"blocks": [
{
"type": "input",
"block_id": "a_block_id",
"label": {
"type": "plain_text",
"text": "A simple label"
},
"optional": false,
"element": {
"type": "plain_text_input",
"placeholder": {
"type": "plain_text",
"text": "Placeholder text"
},
"action_id": "an_action_id"
}
}
],
"private_metadata": "Shh it is a secret",
"callback_id": "identify_your_modals",
"external_id": "",
"state": {
"values": {}
},
"hash": "156772938.1827394",
"clear_on_close": false,
"notify_on_close": false,
"root_view_id": "VMHU10V25",
"app_id": "AA4928AQ",
"bot_id": "BA13894H"
}
}`,
expectedResp: &ViewResponse{
SlackResponse{
Ok: true,
Error: "",
},
View{
ID: "VMHU10V25",
Type: VTModal,
TeamID: "T8N4K1JN",
Title: &TextBlockObject{
Type: PlainTextType,
Text: "Quite a plain modal",
},
Submit: &TextBlockObject{
Type: PlainTextType,
Text: "Create",
},
CallbackID: "identify_your_modals",
PrivateMetadata: "Shh it is a secret",
State: &ViewState{},
Hash: "156772938.1827394",
RootViewID: "VMHU10V25",
AppID: "AA4928AQ",
BotID: "BA13894H",
Blocks: Blocks{
BlockSet: []Block{
NewInputBlock(
"a_block_id",
&TextBlockObject{
Type: PlainTextType,
Text: "A simple label",
},
&TextBlockObject{
Type: PlainTextType,
Text: "A simple hint",
},
NewPlainTextInputBlockElement(
&TextBlockObject{
Type: PlainTextType,
Text: "Placeholder text",
},
"an_action_id",
)),
},
},
},
},
expectedErr: nil,
},
}
h := &viewsHandler{}
http.HandleFunc("/views.update", h.handler)
for _, c := range cases {
t.Run(c.caseName, func(t *testing.T) {
h.rawResponse = c.rawResp
resp, err := api.UpdateView(ModalViewRequest{}, c.externalID, "dummy_hash", c.viewID)
if c.expectedErr == nil && err != nil {
t.Fatalf("unexpected error: %s\n", err)
}
if c.expectedErr != nil && err == nil {
t.Fatalf("expected %s, but did not raise an error", c.expectedErr)
}
if c.expectedErr != nil && err != nil && c.expectedErr.Error() != err.Error() {
t.Fatalf("expected %s as error but got %s\n", c.expectedErr, err)
}
if resp == nil || c.expectedResp == nil {
return
}
if !reflect.DeepEqual(resp.ResponseMetadata.Messages, c.expectedResp.ResponseMetadata.Messages) {
t.Fatalf("expected:\n\t%v\n but got:\n\t%v\n", c.expectedResp.ResponseMetadata.Messages, resp.ResponseMetadata.Messages)
}
if !reflect.DeepEqual(resp.ResponseMetadata.Warnings, c.expectedResp.ResponseMetadata.Warnings) {
t.Fatalf("expected:\n\t%v\n but got:\n\t%v\n", c.expectedResp.ResponseMetadata.Warnings, resp.ResponseMetadata.Warnings)
}
})
}
}
func assertViewSubmissionResponse(t *testing.T, resp *ViewSubmissionResponse, encoded string) {
var decoded *ViewSubmissionResponse
assert.Nil(t, json.Unmarshal([]byte(encoded), &decoded))
assert.Equal(t, decoded, resp)
}
func TestSlack_ClearViewSubmissionResponse(t *testing.T) {
resp := NewClearViewSubmissionResponse()
rawResp := `{
"response_action": "clear"
}`
assertViewSubmissionResponse(t, resp, rawResp)
}
func TestSlack_UpdateViewSubmissionResponse(t *testing.T) {
resp := NewUpdateViewSubmissionResponse(&ModalViewRequest{
Type: VTModal,
Title: NewTextBlockObject("plain_text", "Test update view submission response", false, false),
Blocks: Blocks{BlockSet: []Block{NewFileBlock("file_block_id", "external_string", "source_string")}},
})
rawResp := `{
"response_action": "update",
"view": {
"type": "modal",
"title": {
"type": "plain_text",
"text": "Test update view submission response"
},
"blocks": [
{
"type": "file",
"block_id": "file_block_id",
"external_id": "external_string",
"source": "source_string"
}
]
}
}`
assertViewSubmissionResponse(t, resp, rawResp)
}
func TestSlack_PushViewSubmissionResponse(t *testing.T) {
resp := NewPushViewSubmissionResponse(&ModalViewRequest{
Type: VTModal,
Title: NewTextBlockObject("plain_text", "Test update view submission response", false, false),
Blocks: Blocks{
BlockSet: []Block{
NewContextBlock(
"context_block_id",
NewTextBlockObject("plain_text", "Context text", false, false),
NewImageBlockElement("image_url", "alt_text"),
),
},
},
})
rawResp := `{
"response_action": "push",
"view": {
"type": "modal",
"title": {
"type": "plain_text",
"text": "Test update view submission response"
},
"blocks": [
{
"type": "context",
"block_id": "context_block_id",
"elements": [
{
"type": "plain_text",
"text": "Context text"
},
{
"type": "image",
"image_url": "image_url",
"alt_text": "alt_text"
}
]
}
]
}
}`
assertViewSubmissionResponse(t, resp, rawResp)
}
func TestSlack_ErrorsViewSubmissionResponse(t *testing.T) {
resp := NewErrorsViewSubmissionResponse(map[string]string{
"input_text_action_id": "Please input a name that's at least 6 characters long",
"file_action_id": "File exceeded size limit of 5 KB",
})
rawResp := `{
"response_action": "errors",
"errors": {
"input_text_action_id": "Please input a name that's at least 6 characters long",
"file_action_id": "File exceeded size limit of 5 KB"
}
}`
assertViewSubmissionResponse(t, resp, rawResp)
}
slack-0.11.3/webhooks.go 0000664 0000000 0000000 00000004016 14307410331 0015036 0 ustar 00root root 0000000 0000000 package slack
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"net/http"
)
type WebhookMessage struct {
Username string `json:"username,omitempty"`
IconEmoji string `json:"icon_emoji,omitempty"`
IconURL string `json:"icon_url,omitempty"`
Channel string `json:"channel,omitempty"`
ThreadTimestamp string `json:"thread_ts,omitempty"`
Text string `json:"text,omitempty"`
Attachments []Attachment `json:"attachments,omitempty"`
Parse string `json:"parse,omitempty"`
Blocks *Blocks `json:"blocks,omitempty"`
ResponseType string `json:"response_type,omitempty"`
ReplaceOriginal bool `json:"replace_original,omitempty"`
DeleteOriginal bool `json:"delete_original,omitempty"`
ReplyBroadcast bool `json:"reply_broadcast,omitempty"`
}
func PostWebhook(url string, msg *WebhookMessage) error {
return PostWebhookCustomHTTPContext(context.Background(), url, http.DefaultClient, msg)
}
func PostWebhookContext(ctx context.Context, url string, msg *WebhookMessage) error {
return PostWebhookCustomHTTPContext(ctx, url, http.DefaultClient, msg)
}
func PostWebhookCustomHTTP(url string, httpClient *http.Client, msg *WebhookMessage) error {
return PostWebhookCustomHTTPContext(context.Background(), url, httpClient, msg)
}
func PostWebhookCustomHTTPContext(ctx context.Context, url string, httpClient *http.Client, msg *WebhookMessage) error {
raw, err := json.Marshal(msg)
if err != nil {
return fmt.Errorf("marshal failed: %w", err)
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(raw))
if err != nil {
return fmt.Errorf("failed new request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
resp, err := httpClient.Do(req)
if err != nil {
return fmt.Errorf("failed to post webhook: %w", err)
}
defer func() {
io.Copy(ioutil.Discard, resp.Body)
resp.Body.Close()
}()
return checkStatusCode(resp, discard{})
}
slack-0.11.3/webhooks_test.go 0000664 0000000 0000000 00000004656 14307410331 0016107 0 ustar 00root root 0000000 0000000 package slack
import (
"encoding/json"
"net/http"
"reflect"
"testing"
"github.com/stretchr/testify/assert"
)
func TestPostWebhook_OK(t *testing.T) {
once.Do(startServer)
var receivedPayload WebhookMessage
http.HandleFunc("/webhook", func(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
decoder := json.NewDecoder(r.Body)
err := decoder.Decode(&receivedPayload)
if err != nil {
t.Errorf("Request contained invalid JSON, %s", err)
}
response := []byte(`{}`)
rw.Write(response)
})
url := "http://" + serverAddr + "/webhook"
payload := &WebhookMessage{
Text: "Test Text",
Attachments: []Attachment{
{
Text: "Foo",
},
},
}
err := PostWebhook(url, payload)
if err != nil {
t.Errorf("Expected not to receive error: %s", err)
}
if !reflect.DeepEqual(payload, &receivedPayload) {
t.Errorf("Payload did not match\nwant: %#v\n got: %#v", payload, receivedPayload)
}
}
func TestPostWebhook_NotOK(t *testing.T) {
once.Do(startServer)
http.HandleFunc("/webhook2", func(rw http.ResponseWriter, r *http.Request) {
rw.WriteHeader(http.StatusInternalServerError)
rw.Write([]byte("500 - Something bad happened!"))
})
url := "http://" + serverAddr + "/webhook2"
err := PostWebhook(url, &WebhookMessage{})
if err == nil {
t.Errorf("Expected to receive error")
}
}
func TestWebhookMessage_WithBlocks(t *testing.T) {
textBlockObject := NewTextBlockObject("plain_text", "text", false, false)
sectionBlock := NewSectionBlock(textBlockObject, nil, nil)
singleBlock := &Blocks{BlockSet: []Block{sectionBlock}}
twoBlocks := &Blocks{BlockSet: []Block{sectionBlock, sectionBlock}}
msgSingleBlock := WebhookMessage{Blocks: singleBlock}
assert.Equal(t, 1, len(msgSingleBlock.Blocks.BlockSet))
msgJsonSingleBlock, _ := json.Marshal(msgSingleBlock)
assert.Equal(t, `{"blocks":[{"type":"section","text":{"type":"plain_text","text":"text"}}]}`, string(msgJsonSingleBlock))
msgTwoBlocks := WebhookMessage{Blocks: twoBlocks}
assert.Equal(t, 2, len(msgTwoBlocks.Blocks.BlockSet))
msgJsonTwoBlocks, _ := json.Marshal(msgTwoBlocks)
assert.Equal(t, `{"blocks":[{"type":"section","text":{"type":"plain_text","text":"text"}},{"type":"section","text":{"type":"plain_text","text":"text"}}]}`, string(msgJsonTwoBlocks))
msgNoBlocks := WebhookMessage{Text: "foo"}
msgJsonNoBlocks, _ := json.Marshal(msgNoBlocks)
assert.Equal(t, `{"text":"foo"}`, string(msgJsonNoBlocks))
}
slack-0.11.3/websocket.go 0000664 0000000 0000000 00000005157 14307410331 0015212 0 ustar 00root root 0000000 0000000 package slack
import (
"net/url"
"sync"
"time"
"github.com/gorilla/websocket"
)
const (
// MaxMessageTextLength is the current maximum message length in number of characters as defined here
// https://api.slack.com/rtm#limits
MaxMessageTextLength = 4000
)
// RTM represents a managed websocket connection. It also supports
// all the methods of the `Client` type.
//
// Create this element with Client's NewRTM() or NewRTMWithOptions(*RTMOptions)
type RTM struct {
// Client is the main API, embedded
Client
idGen IDGenerator
pingInterval time.Duration
pingDeadman *time.Timer
// Connection life-cycle
conn *websocket.Conn
IncomingEvents chan RTMEvent
outgoingMessages chan OutgoingMessage
killChannel chan bool
disconnected chan struct{}
disconnectedm *sync.Once
forcePing chan bool
// UserDetails upon connection
info *Info
// useRTMStart should be set to true if you want to use
// rtm.start to connect to Slack, otherwise it will use
// rtm.connect
useRTMStart bool
// dialer is a gorilla/websocket Dialer. If nil, use the default
// Dialer.
dialer *websocket.Dialer
// mu is mutex used to prevent RTM connection race conditions
mu *sync.Mutex
// connParams is a map of flags for connection parameters.
connParams url.Values
}
// signal that we are disconnected by closing the channel.
// protect it with a mutex to ensure it only happens once.
func (rtm *RTM) disconnect() {
rtm.disconnectedm.Do(func() {
close(rtm.disconnected)
})
}
// Disconnect and wait, blocking until a successful disconnection.
func (rtm *RTM) Disconnect() error {
// always push into the kill channel when invoked,
// this lets the ManagedConnection() function properly clean up.
// if the buffer is full then just continue on.
select {
case rtm.killChannel <- true:
return nil
case <-rtm.disconnected:
return ErrAlreadyDisconnected
}
}
// GetInfo returns the info structure received when calling
// "startrtm", holding metadata needed to implement a full
// chat client. It will be non-nil after a call to StartRTM().
func (rtm *RTM) GetInfo() *Info {
return rtm.info
}
// SendMessage submits a simple message through the websocket. For
// more complicated messages, use `rtm.PostMessage` with a complete
// struct describing your attachments and all.
func (rtm *RTM) SendMessage(msg *OutgoingMessage) {
if msg == nil {
rtm.Debugln("Error: Attempted to SendMessage(nil)")
return
}
rtm.outgoingMessages <- *msg
}
func (rtm *RTM) resetDeadman() {
rtm.pingDeadman.Reset(deadmanDuration(rtm.pingInterval))
}
func deadmanDuration(d time.Duration) time.Duration {
return d * 4
}
slack-0.11.3/websocket_channels.go 0000664 0000000 0000000 00000004324 14307410331 0017060 0 ustar 00root root 0000000 0000000 package slack
// ChannelCreatedEvent represents the Channel created event
type ChannelCreatedEvent struct {
Type string `json:"type"`
Channel ChannelCreatedInfo `json:"channel"`
EventTimestamp string `json:"event_ts"`
}
// ChannelCreatedInfo represents the information associated with the Channel created event
type ChannelCreatedInfo struct {
ID string `json:"id"`
IsChannel bool `json:"is_channel"`
Name string `json:"name"`
Created int `json:"created"`
Creator string `json:"creator"`
}
// ChannelJoinedEvent represents the Channel joined event
type ChannelJoinedEvent struct {
Type string `json:"type"`
Channel Channel `json:"channel"`
}
// ChannelInfoEvent represents the Channel info event
type ChannelInfoEvent struct {
// channel_left
// channel_deleted
// channel_archive
// channel_unarchive
Type string `json:"type"`
Channel string `json:"channel"`
User string `json:"user,omitempty"`
Timestamp string `json:"ts,omitempty"`
}
// ChannelRenameEvent represents the Channel rename event
type ChannelRenameEvent struct {
Type string `json:"type"`
Channel ChannelRenameInfo `json:"channel"`
Timestamp string `json:"event_ts"`
}
// ChannelRenameInfo represents the information associated with a Channel rename event
type ChannelRenameInfo struct {
ID string `json:"id"`
Name string `json:"name"`
Created int `json:"created"`
}
// ChannelHistoryChangedEvent represents the Channel history changed event
type ChannelHistoryChangedEvent struct {
Type string `json:"type"`
Latest string `json:"latest"`
Timestamp string `json:"ts"`
EventTimestamp string `json:"event_ts"`
}
// ChannelMarkedEvent represents the Channel marked event
type ChannelMarkedEvent ChannelInfoEvent
// ChannelLeftEvent represents the Channel left event
type ChannelLeftEvent ChannelInfoEvent
// ChannelDeletedEvent represents the Channel deleted event
type ChannelDeletedEvent ChannelInfoEvent
// ChannelArchiveEvent represents the Channel archive event
type ChannelArchiveEvent ChannelInfoEvent
// ChannelUnarchiveEvent represents the Channel unarchive event
type ChannelUnarchiveEvent ChannelInfoEvent
slack-0.11.3/websocket_desktop_notification.go 0000664 0000000 0000000 00000001323 14307410331 0021500 0 ustar 00root root 0000000 0000000 package slack
// DesktopNotificationEvent represents the update event for Desktop Notification.
type DesktopNotificationEvent struct {
Type string `json:"type"`
Title string `json:"title"`
Subtitle string `json:"subtitle"`
Message string `json:"msg"`
Timestamp string `json:"ts"`
Content string `json:"content"`
Channel string `json:"channel"`
LaunchURI string `json:"launchUri"`
AvatarImage string `json:"avatarImage"`
SsbFilename string `json:"ssbFilename"`
ImageURI string `json:"imageUri"`
IsShared bool `json:"is_shared"`
IsChannelInvite bool `json:"is_channel_invite"`
EventTimestamp string `json:"event_ts"`
}
slack-0.11.3/websocket_dm.go 0000664 0000000 0000000 00000001306 14307410331 0015662 0 ustar 00root root 0000000 0000000 package slack
// IMCreatedEvent represents the IM created event
type IMCreatedEvent struct {
Type string `json:"type"`
User string `json:"user"`
Channel ChannelCreatedInfo `json:"channel"`
}
// IMHistoryChangedEvent represents the IM history changed event
type IMHistoryChangedEvent ChannelHistoryChangedEvent
// IMOpenEvent represents the IM open event
type IMOpenEvent ChannelInfoEvent
// IMCloseEvent represents the IM close event
type IMCloseEvent ChannelInfoEvent
// IMMarkedEvent represents the IM marked event
type IMMarkedEvent ChannelInfoEvent
// IMMarkedHistoryChanged represents the IM marked history changed event
type IMMarkedHistoryChanged ChannelInfoEvent
slack-0.11.3/websocket_dnd.go 0000664 0000000 0000000 00000000327 14307410331 0016031 0 ustar 00root root 0000000 0000000 package slack
// DNDUpdatedEvent represents the update event for Do Not Disturb
type DNDUpdatedEvent struct {
Type string `json:"type"`
User string `json:"user"`
Status DNDStatus `json:"dnd_status"`
}
slack-0.11.3/websocket_files.go 0000664 0000000 0000000 00000002606 14307410331 0016370 0 ustar 00root root 0000000 0000000 package slack
// FileActionEvent represents the File action event
type fileActionEvent struct {
Type string `json:"type"`
EventTimestamp string `json:"event_ts"`
File File `json:"file"`
// FileID is used for FileDeletedEvent
FileID string `json:"file_id,omitempty"`
}
// FileCreatedEvent represents the File created event
type FileCreatedEvent fileActionEvent
// FileSharedEvent represents the File shared event
type FileSharedEvent fileActionEvent
// FilePublicEvent represents the File public event
type FilePublicEvent fileActionEvent
// FileUnsharedEvent represents the File unshared event
type FileUnsharedEvent fileActionEvent
// FileChangeEvent represents the File change event
type FileChangeEvent fileActionEvent
// FileDeletedEvent represents the File deleted event
type FileDeletedEvent fileActionEvent
// FilePrivateEvent represents the File private event
type FilePrivateEvent fileActionEvent
// FileCommentAddedEvent represents the File comment added event
type FileCommentAddedEvent struct {
fileActionEvent
Comment Comment `json:"comment"`
}
// FileCommentEditedEvent represents the File comment edited event
type FileCommentEditedEvent struct {
fileActionEvent
Comment Comment `json:"comment"`
}
// FileCommentDeletedEvent represents the File comment deleted event
type FileCommentDeletedEvent struct {
fileActionEvent
Comment string `json:"comment"`
}
slack-0.11.3/websocket_groups.go 0000664 0000000 0000000 00000003023 14307410331 0016577 0 ustar 00root root 0000000 0000000 package slack
// GroupCreatedEvent represents the Group created event
type GroupCreatedEvent struct {
Type string `json:"type"`
User string `json:"user"`
Channel ChannelCreatedInfo `json:"channel"`
}
// XXX: Should we really do this? event.Group is probably nicer than event.Channel
// even though the api returns "channel"
// GroupMarkedEvent represents the Group marked event
type GroupMarkedEvent ChannelInfoEvent
// GroupOpenEvent represents the Group open event
type GroupOpenEvent ChannelInfoEvent
// GroupCloseEvent represents the Group close event
type GroupCloseEvent ChannelInfoEvent
// GroupArchiveEvent represents the Group archive event
type GroupArchiveEvent ChannelInfoEvent
// GroupUnarchiveEvent represents the Group unarchive event
type GroupUnarchiveEvent ChannelInfoEvent
// GroupLeftEvent represents the Group left event
type GroupLeftEvent ChannelInfoEvent
// GroupJoinedEvent represents the Group joined event
type GroupJoinedEvent ChannelJoinedEvent
// GroupRenameEvent represents the Group rename event
type GroupRenameEvent struct {
Type string `json:"type"`
Group GroupRenameInfo `json:"channel"`
Timestamp string `json:"ts"`
}
// GroupRenameInfo represents the group info related to the renamed group
type GroupRenameInfo struct {
ID string `json:"id"`
Name string `json:"name"`
Created string `json:"created"`
}
// GroupHistoryChangedEvent represents the Group history changed event
type GroupHistoryChangedEvent ChannelHistoryChangedEvent
slack-0.11.3/websocket_internals.go 0000664 0000000 0000000 00000004567 14307410331 0017275 0 ustar 00root root 0000000 0000000 package slack
import (
"fmt"
"time"
)
/**
* Internal events, created by this lib and not mapped to Slack APIs.
*/
// ConnectedEvent is used for when we connect to Slack
type ConnectedEvent struct {
ConnectionCount int // 1 = first time, 2 = second time
Info *Info
}
// ConnectionErrorEvent contains information about a connection error
type ConnectionErrorEvent struct {
Attempt int
Backoff time.Duration // how long we'll wait before the next attempt
ErrorObj error
}
func (c *ConnectionErrorEvent) Error() string {
return c.ErrorObj.Error()
}
// ConnectingEvent contains information about our connection attempt
type ConnectingEvent struct {
Attempt int // 1 = first attempt, 2 = second attempt
ConnectionCount int
}
// DisconnectedEvent contains information about how we disconnected
type DisconnectedEvent struct {
Intentional bool
Cause error
}
// LatencyReport contains information about connection latency
type LatencyReport struct {
Value time.Duration
}
// InvalidAuthEvent is used in case we can't even authenticate with the API
type InvalidAuthEvent struct{}
// UnmarshallingErrorEvent is used when there are issues deconstructing a response
type UnmarshallingErrorEvent struct {
ErrorObj error
}
func (u UnmarshallingErrorEvent) Error() string {
return u.ErrorObj.Error()
}
// MessageTooLongEvent is used when sending a message that is too long
type MessageTooLongEvent struct {
Message OutgoingMessage
MaxLength int
}
func (m *MessageTooLongEvent) Error() string {
return fmt.Sprintf("Message too long (max %d characters)", m.MaxLength)
}
// RateLimitEvent is used when Slack warns that rate-limits are being hit.
type RateLimitEvent struct{}
func (e *RateLimitEvent) Error() string {
return "Messages are being sent too fast."
}
// OutgoingErrorEvent contains information in case there were errors sending messages
type OutgoingErrorEvent struct {
Message OutgoingMessage
ErrorObj error
}
func (o OutgoingErrorEvent) Error() string {
return o.ErrorObj.Error()
}
// IncomingEventError contains information about an unexpected error receiving a websocket event
type IncomingEventError struct {
ErrorObj error
}
func (i *IncomingEventError) Error() string {
return i.ErrorObj.Error()
}
// AckErrorEvent i
type AckErrorEvent struct {
ErrorObj error
ReplyTo int
}
func (a *AckErrorEvent) Error() string {
return a.ErrorObj.Error()
}
slack-0.11.3/websocket_managed_conn.go 0000664 0000000 0000000 00000046505 14307410331 0017705 0 ustar 00root root 0000000 0000000 package slack
import (
"encoding/json"
"fmt"
"io"
"net/http"
stdurl "net/url"
"reflect"
"time"
"github.com/gorilla/websocket"
"github.com/slack-go/slack/internal/backoff"
"github.com/slack-go/slack/internal/errorsx"
"github.com/slack-go/slack/internal/timex"
)
// UnmappedError represents error occurred when there is no mapping between given event name
// and corresponding Go struct.
type UnmappedError struct {
// EventType returns event type name.
EventType string
// RawEvent returns raw event body.
RawEvent json.RawMessage
ctxMsg string
}
// NewUnmappedError returns new UnmappedError instance.
func NewUnmappedError(ctxMsg, eventType string, raw json.RawMessage) *UnmappedError {
return &UnmappedError{
ctxMsg: ctxMsg,
EventType: eventType,
RawEvent: raw,
}
}
// Error returns human-readable error message.
func (u UnmappedError) Error() string {
return fmt.Sprintf("%s: Received unmapped event %q", u.ctxMsg, u.EventType)
}
// ManageConnection can be called on a Slack RTM instance returned by the
// NewRTM method. It will connect to the slack RTM API and handle all incoming
// and outgoing events. If a connection fails then it will attempt to reconnect
// and will notify any listeners through an error event on the IncomingEvents
// channel.
//
// If the connection ends and the disconnect was unintentional then this will
// attempt to reconnect.
//
// This should only be called once per slack API! Otherwise expect undefined
// behavior.
//
// The defined error events are located in websocket_internals.go.
func (rtm *RTM) ManageConnection() {
var (
err error
info *Info
conn *websocket.Conn
)
for connectionCount := 0; ; connectionCount++ {
// start trying to connect
// the returned err is already passed onto the IncomingEvents channel
if info, conn, err = rtm.connect(connectionCount, rtm.useRTMStart); err != nil {
// when the connection is unsuccessful its fatal, and we need to bail out.
rtm.Debugf("Failed to connect with RTM on try %d: %s", connectionCount, err)
rtm.disconnect()
return
}
// lock to prevent data races with Disconnect particularly around isConnected
// and conn.
rtm.mu.Lock()
rtm.conn = conn
rtm.info = info
rtm.mu.Unlock()
rtm.IncomingEvents <- RTMEvent{"connected", &ConnectedEvent{
ConnectionCount: connectionCount,
Info: info,
}}
rtm.Debugf("RTM connection succeeded on try %d", connectionCount)
rawEvents := make(chan json.RawMessage)
// we're now connected so we can set up listeners
go rtm.handleIncomingEvents(rawEvents)
// this should be a blocking call until the connection has ended
rtm.handleEvents(rawEvents)
select {
case <-rtm.disconnected:
// after handle events returns we need to check if we're disconnected
// when this happens we need to cleanup the newly created connection.
if err = conn.Close(); err != nil {
rtm.Debugln("failed to close conn on disconnected RTM", err)
}
return
default:
// otherwise continue and run the loop again to reconnect
}
}
}
// connect attempts to connect to the slack websocket API. It handles any
// errors that occur while connecting and will return once a connection
// has been successfully opened.
// If useRTMStart is false then it uses rtm.connect to create the connection,
// otherwise it uses rtm.start.
func (rtm *RTM) connect(connectionCount int, useRTMStart bool) (*Info, *websocket.Conn, error) {
const (
errInvalidAuth = "invalid_auth"
errInactiveAccount = "account_inactive"
errMissingAuthToken = "not_authed"
errTokenRevoked = "token_revoked"
)
// used to provide exponential backoff wait time with jitter before trying
// to connect to slack again
boff := &backoff.Backoff{
Max: 5 * time.Minute,
}
for {
var (
backoff time.Duration
)
// send connecting event
rtm.IncomingEvents <- RTMEvent{"connecting", &ConnectingEvent{
Attempt: boff.Attempts() + 1,
ConnectionCount: connectionCount,
}}
// attempt to start the connection
info, conn, err := rtm.startRTMAndDial(useRTMStart)
if err == nil {
return info, conn, nil
}
// check for fatal errors
switch err.Error() {
case errInvalidAuth, errInactiveAccount, errMissingAuthToken, errTokenRevoked:
rtm.Debugf("invalid auth when connecting with RTM: %s", err)
rtm.IncomingEvents <- RTMEvent{"invalid_auth", &InvalidAuthEvent{}}
return nil, nil, err
default:
}
switch actual := err.(type) {
case StatusCodeError:
if actual.Code == http.StatusNotFound {
rtm.Debugf("invalid auth when connecting with RTM: %s", err)
rtm.IncomingEvents <- RTMEvent{"invalid_auth", &InvalidAuthEvent{}}
return nil, nil, err
}
case *RateLimitedError:
backoff = actual.RetryAfter
default:
}
backoff = timex.Max(backoff, boff.Duration())
// any other errors are treated as recoverable and we try again after
// sending the event along the IncomingEvents channel
rtm.IncomingEvents <- RTMEvent{"connection_error", &ConnectionErrorEvent{
Attempt: boff.Attempts(),
Backoff: backoff,
ErrorObj: err,
}}
// get time we should wait before attempting to connect again
rtm.Debugf("reconnection %d failed: %s reconnecting in %v\n", boff.Attempts(), err, backoff)
// wait for one of the following to occur,
// backoff duration has elapsed, killChannel is signalled, or
// the rtm finishes disconnecting.
select {
case <-time.After(backoff): // retry after the backoff.
case intentional := <-rtm.killChannel:
if intentional {
rtm.killConnection(intentional, ErrRTMDisconnected)
return nil, nil, ErrRTMDisconnected
}
case <-rtm.disconnected:
return nil, nil, ErrRTMDisconnected
}
}
}
// startRTMAndDial attempts to connect to the slack websocket. If useRTMStart is true,
// then it returns the full information returned by the "rtm.start" method on the
// slack API. Else it uses the "rtm.connect" method to connect
func (rtm *RTM) startRTMAndDial(useRTMStart bool) (info *Info, _ *websocket.Conn, err error) {
var (
url string
)
if useRTMStart {
rtm.Debugf("Starting RTM")
info, url, err = rtm.StartRTM()
} else {
rtm.Debugf("Connecting to RTM")
info, url, err = rtm.ConnectRTM()
}
if err != nil {
rtm.Debugf("Failed to start or connect to RTM: %s", err)
return nil, nil, err
}
// install connection parameters
u, err := stdurl.Parse(url)
if err != nil {
return nil, nil, err
}
u.RawQuery = rtm.connParams.Encode()
url = u.String()
rtm.Debugf("Dialing to websocket on url %s", url)
// Only use HTTPS for connections to prevent MITM attacks on the connection.
upgradeHeader := http.Header{}
upgradeHeader.Add("Origin", "https://api.slack.com")
dialer := websocket.DefaultDialer
if rtm.dialer != nil {
dialer = rtm.dialer
}
conn, _, err := dialer.Dial(url, upgradeHeader)
if err != nil {
rtm.Debugf("Failed to dial to the websocket: %s", err)
return nil, nil, err
}
return info, conn, err
}
// killConnection stops the websocket connection and signals to all goroutines
// that they should cease listening to the connection for events.
//
// This should not be called directly! Instead a boolean value (true for
// intentional, false otherwise) should be sent to the killChannel on the RTM.
func (rtm *RTM) killConnection(intentional bool, cause error) (err error) {
rtm.Debugln("killing connection", cause)
if rtm.conn != nil {
err = rtm.conn.Close()
}
rtm.IncomingEvents <- RTMEvent{"disconnected", &DisconnectedEvent{Intentional: intentional, Cause: cause}}
if intentional {
rtm.disconnect()
}
return err
}
// handleEvents is a blocking function that handles all events. This sends
// pings when asked to (on rtm.forcePing) and upon every given elapsed
// interval. This also sends outgoing messages that are received from the RTM's
// outgoingMessages channel. This also handles incoming raw events from the RTM
// rawEvents channel.
func (rtm *RTM) handleEvents(events chan json.RawMessage) {
ticker := time.NewTicker(rtm.pingInterval)
defer ticker.Stop()
for {
select {
// catch "stop" signal on channel close
case intentional := <-rtm.killChannel:
_ = rtm.killConnection(intentional, errorsx.String("signaled"))
return
// detect when the connection is dead.
case <-rtm.pingDeadman.C:
_ = rtm.killConnection(false, ErrRTMDeadman)
return
// send pings on ticker interval
case <-ticker.C:
if err := rtm.ping(); err != nil {
_ = rtm.killConnection(false, err)
return
}
case <-rtm.forcePing:
if err := rtm.ping(); err != nil {
_ = rtm.killConnection(false, err)
return
}
// listen for messages that need to be sent
case msg := <-rtm.outgoingMessages:
rtm.sendOutgoingMessage(msg)
// listen for incoming messages that need to be parsed
case rawEvent := <-events:
switch rtm.handleRawEvent(rawEvent) {
case rtmEventTypeGoodbye:
// kill the connection, but DO NOT RETURN, a follow up kill signal will
// be sent that still needs to be processed. this duplication is because
// the event reader restarts once it emits the goodbye event.
// unlike the other cases in this function a final read will be triggered
// against the connection which will emit a kill signal. if we return early
// this kill signal will be processed by the next connection.
_ = rtm.killConnection(false, ErrRTMGoodbye)
default:
}
}
}
}
// handleIncomingEvents monitors the RTM's opened websocket for any incoming
// events. It pushes the raw events into the channel.
//
// This will stop executing once the RTM's when a fatal error is detected, or
// a disconnect occurs.
func (rtm *RTM) handleIncomingEvents(events chan json.RawMessage) {
for {
if err := rtm.receiveIncomingEvent(events); err != nil {
select {
case rtm.killChannel <- false:
case <-rtm.disconnected:
}
return
}
}
}
func (rtm *RTM) sendWithDeadline(msg interface{}) error {
// set a write deadline on the connection
if err := rtm.conn.SetWriteDeadline(time.Now().Add(10 * time.Second)); err != nil {
return err
}
if err := rtm.conn.WriteJSON(msg); err != nil {
return err
}
// remove write deadline
return rtm.conn.SetWriteDeadline(time.Time{})
}
// sendOutgoingMessage sends the given OutgoingMessage to the slack websocket.
//
// It does not currently detect if a outgoing message fails due to a disconnect
// and instead lets a future failed 'PING' detect the failed connection.
func (rtm *RTM) sendOutgoingMessage(msg OutgoingMessage) {
rtm.Debugln("Sending message:", msg)
if len([]rune(msg.Text)) > MaxMessageTextLength {
rtm.IncomingEvents <- RTMEvent{"outgoing_error", &MessageTooLongEvent{
Message: msg,
MaxLength: MaxMessageTextLength,
}}
return
}
if err := rtm.sendWithDeadline(msg); err != nil {
rtm.IncomingEvents <- RTMEvent{"outgoing_error", &OutgoingErrorEvent{
Message: msg,
ErrorObj: err,
}}
}
}
// ping sends a 'PING' message to the RTM's websocket. If the 'PING' message
// fails to send then this returns an error signifying that the connection
// should be considered disconnected.
//
// This does not handle incoming 'PONG' responses but does store the time of
// each successful 'PING' send so latency can be detected upon a 'PONG'
// response.
func (rtm *RTM) ping() error {
id := rtm.idGen.Next()
rtm.Debugln("Sending PING ", id)
msg := &Ping{ID: id, Type: "ping", Timestamp: time.Now().Unix()}
if err := rtm.sendWithDeadline(msg); err != nil {
rtm.Debugf("RTM Error sending 'PING %d': %s", id, err.Error())
return err
}
return nil
}
// receiveIncomingEvent attempts to receive an event from the RTM's websocket.
// This will block until a frame is available from the websocket.
// If the read from the websocket results in a fatal error, this function will return non-nil.
func (rtm *RTM) receiveIncomingEvent(events chan json.RawMessage) error {
event := json.RawMessage{}
err := rtm.conn.ReadJSON(&event)
// check if the connection was closed.
if websocket.IsUnexpectedCloseError(err) {
return err
}
switch {
case err == io.ErrUnexpectedEOF:
// EOF's don't seem to signify a failed connection so instead we ignore
// them here and detect a failed connection upon attempting to send a
// 'PING' message
// trigger a 'PING' to detect potential websocket disconnect
select {
case rtm.forcePing <- true:
case <-rtm.disconnected:
}
case err != nil:
// All other errors from ReadJSON come from NextReader, and should
// kill the read loop and force a reconnect.
rtm.IncomingEvents <- RTMEvent{"incoming_error", &IncomingEventError{
ErrorObj: err,
}}
return err
case len(event) == 0:
rtm.Debugln("Received empty event")
default:
rtm.Debugln("Incoming Event:", string(event))
select {
case events <- event:
case <-rtm.disconnected:
rtm.Debugln("disonnected while attempting to send raw event")
}
}
return nil
}
// handleRawEvent takes a raw JSON message received from the slack websocket
// and handles the encoded event.
// returns the event type of the message.
func (rtm *RTM) handleRawEvent(rawEvent json.RawMessage) string {
event := &Event{}
err := json.Unmarshal(rawEvent, event)
if err != nil {
rtm.IncomingEvents <- RTMEvent{"unmarshalling_error", &UnmarshallingErrorEvent{err}}
return ""
}
switch event.Type {
case rtmEventTypeAck:
rtm.handleAck(rawEvent)
case rtmEventTypeHello:
rtm.IncomingEvents <- RTMEvent{"hello", &HelloEvent{}}
case rtmEventTypePong:
rtm.handlePong(rawEvent)
case rtmEventTypeGoodbye:
// just return the event type up for goodbye, will be handled by caller.
default:
rtm.handleEvent(event.Type, rawEvent)
}
return event.Type
}
// handleAck handles an incoming 'ACK' message.
func (rtm *RTM) handleAck(event json.RawMessage) {
ack := &AckMessage{}
if err := json.Unmarshal(event, ack); err != nil {
rtm.Debugln("RTM Error unmarshalling 'ack' event:", err)
rtm.Debugln(" -> Erroneous 'ack' event:", string(event))
return
}
if ack.Ok {
rtm.IncomingEvents <- RTMEvent{"ack", ack}
} else if ack.RTMResponse.Error != nil {
// As there is no documentation for RTM error-codes, this
// identification of a rate-limit warning is very brittle.
if ack.RTMResponse.Error.Code == -1 && ack.RTMResponse.Error.Msg == "slow down, too many messages..." {
rtm.IncomingEvents <- RTMEvent{"ack_error", &RateLimitEvent{}}
} else {
rtm.IncomingEvents <- RTMEvent{"ack_error", &AckErrorEvent{ack.Error, ack.ReplyTo}}
}
} else {
rtm.IncomingEvents <- RTMEvent{"ack_error", &AckErrorEvent{ErrorObj: fmt.Errorf("ack decode failure")}}
}
}
// handlePong handles an incoming 'PONG' message which should be in response to
// a previously sent 'PING' message. This is then used to compute the
// connection's latency.
func (rtm *RTM) handlePong(event json.RawMessage) {
var (
p Pong
)
rtm.resetDeadman()
if err := json.Unmarshal(event, &p); err != nil {
rtm.Client.log.Println("RTM Error unmarshalling 'pong' event:", err)
return
}
latency := time.Since(time.Unix(p.Timestamp, 0))
rtm.IncomingEvents <- RTMEvent{"latency_report", &LatencyReport{Value: latency}}
}
// handleEvent is the "default" response to an event that does not have a
// special case. It matches the command's name to a mapping of defined events
// and then sends the corresponding event struct to the IncomingEvents channel.
// If the event type is not found or the event cannot be unmarshalled into the
// correct struct then this sends an UnmarshallingErrorEvent to the
// IncomingEvents channel.
func (rtm *RTM) handleEvent(typeStr string, event json.RawMessage) {
v, exists := EventMapping[typeStr]
if !exists {
rtm.Debugf("RTM Error - received unmapped event %q: %s\n", typeStr, string(event))
err := NewUnmappedError("RTM Error", typeStr, event)
rtm.IncomingEvents <- RTMEvent{"unmarshalling_error", &UnmarshallingErrorEvent{err}}
return
}
t := reflect.TypeOf(v)
recvEvent := reflect.New(t).Interface()
err := json.Unmarshal(event, recvEvent)
if err != nil {
rtm.Debugf("RTM Error, could not unmarshall event %q: %s\n", typeStr, string(event))
err := fmt.Errorf("RTM Error: Could not unmarshall event %q", typeStr)
rtm.IncomingEvents <- RTMEvent{"unmarshalling_error", &UnmarshallingErrorEvent{err}}
return
}
rtm.IncomingEvents <- RTMEvent{typeStr, recvEvent}
}
// EventMapping holds a mapping of event names to their corresponding struct
// implementations. The structs should be instances of the unmarshalling
// target for the matching event type.
var EventMapping = map[string]interface{}{
"message": MessageEvent{},
"presence_change": PresenceChangeEvent{},
"user_typing": UserTypingEvent{},
"channel_marked": ChannelMarkedEvent{},
"channel_created": ChannelCreatedEvent{},
"channel_joined": ChannelJoinedEvent{},
"channel_left": ChannelLeftEvent{},
"channel_deleted": ChannelDeletedEvent{},
"channel_rename": ChannelRenameEvent{},
"channel_archive": ChannelArchiveEvent{},
"channel_unarchive": ChannelUnarchiveEvent{},
"channel_history_changed": ChannelHistoryChangedEvent{},
"dnd_updated": DNDUpdatedEvent{},
"dnd_updated_user": DNDUpdatedEvent{},
"im_created": IMCreatedEvent{},
"im_open": IMOpenEvent{},
"im_close": IMCloseEvent{},
"im_marked": IMMarkedEvent{},
"im_history_changed": IMHistoryChangedEvent{},
"group_marked": GroupMarkedEvent{},
"group_open": GroupOpenEvent{},
"group_joined": GroupJoinedEvent{},
"group_left": GroupLeftEvent{},
"group_close": GroupCloseEvent{},
"group_rename": GroupRenameEvent{},
"group_archive": GroupArchiveEvent{},
"group_unarchive": GroupUnarchiveEvent{},
"group_history_changed": GroupHistoryChangedEvent{},
"file_created": FileCreatedEvent{},
"file_shared": FileSharedEvent{},
"file_unshared": FileUnsharedEvent{},
"file_public": FilePublicEvent{},
"file_private": FilePrivateEvent{},
"file_change": FileChangeEvent{},
"file_deleted": FileDeletedEvent{},
"file_comment_added": FileCommentAddedEvent{},
"file_comment_edited": FileCommentEditedEvent{},
"file_comment_deleted": FileCommentDeletedEvent{},
"pin_added": PinAddedEvent{},
"pin_removed": PinRemovedEvent{},
"star_added": StarAddedEvent{},
"star_removed": StarRemovedEvent{},
"reaction_added": ReactionAddedEvent{},
"reaction_removed": ReactionRemovedEvent{},
"pref_change": PrefChangeEvent{},
"team_join": TeamJoinEvent{},
"team_rename": TeamRenameEvent{},
"team_pref_change": TeamPrefChangeEvent{},
"team_domain_change": TeamDomainChangeEvent{},
"team_migration_started": TeamMigrationStartedEvent{},
"manual_presence_change": ManualPresenceChangeEvent{},
"user_change": UserChangeEvent{},
"emoji_changed": EmojiChangedEvent{},
"commands_changed": CommandsChangedEvent{},
"email_domain_changed": EmailDomainChangedEvent{},
"bot_added": BotAddedEvent{},
"bot_changed": BotChangedEvent{},
"accounts_changed": AccountsChangedEvent{},
"reconnect_url": ReconnectUrlEvent{},
"member_joined_channel": MemberJoinedChannelEvent{},
"member_left_channel": MemberLeftChannelEvent{},
"subteam_created": SubteamCreatedEvent{},
"subteam_members_changed": SubteamMembersChangedEvent{},
"subteam_self_added": SubteamSelfAddedEvent{},
"subteam_self_removed": SubteamSelfRemovedEvent{},
"subteam_updated": SubteamUpdatedEvent{},
"desktop_notification": DesktopNotificationEvent{},
"mobile_in_app_notification": MobileInAppNotificationEvent{},
}
slack-0.11.3/websocket_managed_conn_test.go 0000664 0000000 0000000 00000022502 14307410331 0020733 0 ustar 00root root 0000000 0000000 package slack_test
import (
"encoding/json"
"fmt"
"log"
"net/http"
"testing"
"time"
websocket "github.com/gorilla/websocket"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/slack-go/slack"
"github.com/slack-go/slack/slacktest"
)
const (
testMessage = "test message"
testToken = "TEST_TOKEN"
)
func TestRTMBeforeEvents(t *testing.T) {
// Set up the test server.
testServer := slacktest.NewTestServer()
go testServer.Start()
// Setup and start the RTM.
api := slack.New(testToken, slack.OptionAPIURL(testServer.GetAPIURL()))
rtm := api.NewRTM()
done := make(chan struct{})
go func() {
for msg := range rtm.IncomingEvents {
switch ev := msg.Data.(type) {
case *slack.DisconnectedEvent:
if ev.Intentional {
close(done)
return
}
default:
// t.Logf("Discarded event of type '%s' with content '%#v'", msg.Type, ev)
}
}
}()
go rtm.Disconnect()
go rtm.ManageConnection()
select {
case <-done:
case <-time.After(5 * time.Second):
t.Error("timed out waiting for disconnect")
t.Fail()
}
}
func TestRTMGoodbye(t *testing.T) {
// Set up the test server.
testServer := slacktest.NewTestServer(
func(c slacktest.Customize) {
c.Handle("/ws", slacktest.Websocket(func(conn *websocket.Conn) {
if err := slacktest.RTMServerSendGoodbye(conn); err != nil {
log.Println("failed to send goodbye", err)
}
}))
},
)
go testServer.Start()
// Setup and start the RTM.
api := slack.New(
testToken,
slack.OptionAPIURL(testServer.GetAPIURL()),
)
rtm := api.NewRTM(
slack.RTMOptionPingInterval(100 * time.Millisecond),
)
done := make(chan struct{})
go rtm.ManageConnection()
connected := 0
disconnected := 0
func() {
for msg := range rtm.IncomingEvents {
switch ev := msg.Data.(type) {
case *slack.ConnectedEvent:
connected += 1
if connected > 5 {
rtm.Disconnect()
}
case *slack.DisconnectedEvent:
// t.Log("disconnect event received", ev.Intentional, ev.Cause)
if ev.Intentional {
close(done)
return
}
disconnected += 1
default:
// t.Logf("Discarded event of type '%s' with content '%#v'", msg.Type, ev)
}
}
}()
select {
case <-done:
// magic numbers from empirical testing.
assert.Equal(t, connected <= 7, true)
assert.Equal(t, disconnected <= 12, true)
case <-time.After(5 * time.Second):
t.Error("timed out waiting for disconnect")
t.Fail()
}
}
func TestRTMDeadConnection(t *testing.T) {
// Set up the test server.
testServer := slacktest.NewTestServer(
func(c slacktest.Customize) {
c.Handle("/ws", slacktest.Websocket(func(conn *websocket.Conn) {
// closes immediately
}))
},
)
go testServer.Start()
// Setup and start the RTM.
api := slack.New(
testToken,
slack.OptionAPIURL(testServer.GetAPIURL()),
)
rtm := api.NewRTM(
slack.RTMOptionPingInterval(100 * time.Millisecond),
)
go rtm.ManageConnection()
done := make(chan struct{})
connected := 0
disconnected := 0
func() {
for msg := range rtm.IncomingEvents {
switch ev := msg.Data.(type) {
case *slack.ConnectedEvent:
connected += 1
if connected > 5 {
rtm.Disconnect()
}
case *slack.DisconnectedEvent:
// t.Log("disconnect event received", ev.Intentional, ev.Cause)
if ev.Intentional {
close(done)
return
}
disconnected += 1
default:
// t.Logf("Discarded event of type '%s' with content '%#v'", msg.Type, ev)
}
}
}()
select {
case <-done:
// magic numbers from empirical testing.
assert.Equal(t, connected <= 7, true)
assert.Equal(t, disconnected <= 7, true)
case <-time.After(5 * time.Second):
t.Error("timed out waiting for disconnect")
t.Fail()
}
}
func TestRTMDisconnect(t *testing.T) {
// actually connect to slack here w/ an invalid token
api := slack.New(testToken)
rtm := api.NewRTM()
go rtm.ManageConnection()
// Observe incoming messages.
done := make(chan struct{})
connectingReceived := false
disconnectedReceived := false
go func() {
for msg := range rtm.IncomingEvents {
switch ev := msg.Data.(type) {
case *slack.InvalidAuthEvent:
t.Log("invalid auth event received")
disconnectedReceived = true
close(done)
case *slack.ConnectingEvent:
connectingReceived = true
case *slack.ConnectedEvent:
t.Error("received connected events on an invalid connection")
t.Fail()
default:
t.Logf("discarded event of type '%s' with content '%#v'", msg.Type, ev)
}
}
}()
select {
case <-done:
case <-time.After(5 * time.Second):
t.Error("timed out waiting for disconnect")
t.Fail()
}
// Verify that all expected events have been received by the RTM client.
assert.True(t, connectingReceived, "Should have received a connecting event from the RTM instance.")
assert.True(t, disconnectedReceived, "Should have received a disconnected event from the RTM instance.")
}
func TestRTMConnectRateLimit(t *testing.T) {
// Set up the test server.
testServer := slacktest.NewTestServer(
func(c slacktest.Customize) {
c.Handle("/rtm.connect", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Add("Retry-After", "1")
w.WriteHeader(http.StatusTooManyRequests)
}))
},
)
go testServer.Start()
// Setup and start the RTM.
api := slack.New(testToken, slack.OptionAPIURL(testServer.GetAPIURL()))
rtm := api.NewRTM()
go rtm.ManageConnection()
// Observe incoming failures
connectionFailure := make(chan *slack.ConnectionErrorEvent)
go func() {
for msg := range rtm.IncomingEvents {
switch ev := msg.Data.(type) {
case *slack.ConnectingEvent:
case *slack.ConnectionErrorEvent:
connectionFailure <- ev
if ev.Attempt > 5 {
rtm.Disconnect()
}
case *slack.DisconnectedEvent:
if ev.Intentional {
close(connectionFailure)
return
}
default:
t.Logf("Discarded event of type '%s' with content '%#v'", msg.Type, ev)
}
}
}()
previous := time.Duration(0)
for ev := range connectionFailure {
assert.True(t, previous <= ev.Backoff, fmt.Sprintf("backoff should increase during rate limits: %v <= %v", previous, ev.Backoff))
previous = ev.Backoff
}
testServer.Stop()
}
func TestRTMSingleConnect(t *testing.T) {
// Set up the test server.
testServer := slacktest.NewTestServer()
go testServer.Start()
// Setup and start the RTM.
api := slack.New(testToken, slack.OptionAPIURL(testServer.GetAPIURL()))
rtm := api.NewRTM()
go rtm.ManageConnection()
// Observe incoming messages.
done := make(chan struct{})
connectingReceived := false
connectedReceived := false
testMessageReceived := false
go func() {
for msg := range rtm.IncomingEvents {
switch ev := msg.Data.(type) {
case *slack.ConnectingEvent:
if connectingReceived {
t.Error("Received multiple connecting events.")
t.Fail()
}
connectingReceived = true
case *slack.ConnectedEvent:
if connectedReceived {
t.Error("Received multiple connected events.")
t.Fail()
}
connectedReceived = true
case *slack.MessageEvent:
if ev.Text == testMessage {
testMessageReceived = true
rtm.Disconnect()
}
t.Logf("Discarding message with content %+v", ev)
case *slack.DisconnectedEvent:
if ev.Intentional {
done <- struct{}{}
return
}
default:
t.Logf("Discarded event of type '%s' with content '%#v'", msg.Type, ev)
}
}
}()
// Send a message and sleep for some time to make sure the message can be processed client-side.
testServer.SendDirectMessageToBot(testMessage)
<-done
testServer.Stop()
// Verify that all expected events have been received by the RTM client.
assert.True(t, connectingReceived, "Should have received a connecting event from the RTM instance.")
assert.True(t, connectedReceived, "Should have received a connected event from the RTM instance.")
assert.True(t, testMessageReceived, "Should have received a test message from the server.")
}
func TestRTMUnmappedError(t *testing.T) {
const unmappedEventName = "user_status_changed"
// Set up the test server.
testServer := slacktest.NewTestServer()
go testServer.Start()
// Setup and start the RTM.
api := slack.New(testToken, slack.OptionAPIURL(testServer.GetAPIURL()))
rtm := api.NewRTM()
go rtm.ManageConnection()
// Observe incoming messages.
done := make(chan struct{})
var gotUnmarshallingError *slack.UnmarshallingErrorEvent
go func() {
for msg := range rtm.IncomingEvents {
switch ev := msg.Data.(type) {
case *slack.UnmarshallingErrorEvent:
gotUnmarshallingError = ev
rtm.Disconnect()
case *slack.DisconnectedEvent:
if ev.Intentional {
done <- struct{}{}
return
}
default:
t.Logf("Discarded event of type '%s' with content '%#v'", msg.Type, ev)
}
}
}()
// Send a message and sleep for some time to make sure the message can be processed client-side.
testServer.SendToWebsocket(fixSlackMessage(t, unmappedEventName))
<-done
testServer.Stop()
// Verify that we got the expected error with details
unmappedErr, ok := gotUnmarshallingError.ErrorObj.(*slack.UnmappedError)
require.True(t, ok)
assert.Equal(t, unmappedEventName, unmappedErr.EventType)
}
func fixSlackMessage(t *testing.T, eType string) string {
t.Helper()
m := slack.Message{
Msg: slack.Msg{
Type: eType,
Text: "Fixture Slack message",
Timestamp: fmt.Sprintf("%d", time.Now().Unix()),
},
}
msg, err := json.Marshal(m)
require.NoError(t, err)
return string(msg)
}
slack-0.11.3/websocket_misc.go 0000664 0000000 0000000 00000007342 14307410331 0016223 0 ustar 00root root 0000000 0000000 package slack
import (
"encoding/json"
"fmt"
)
// AckMessage is used for messages received in reply to other messages
type AckMessage struct {
ReplyTo int `json:"reply_to"`
Timestamp string `json:"ts"`
Text string `json:"text"`
RTMResponse
}
// RTMResponse encapsulates response details as returned by the Slack API
type RTMResponse struct {
Ok bool `json:"ok"`
Error *RTMError `json:"error"`
}
// RTMError encapsulates error information as returned by the Slack API
type RTMError struct {
Code int
Msg string
}
func (s RTMError) Error() string {
return fmt.Sprintf("Code %d - %s", s.Code, s.Msg)
}
// MessageEvent represents a Slack Message (used as the event type for an incoming message)
type MessageEvent Message
// RTMEvent is the main wrapper. You will find all the other messages attached
type RTMEvent struct {
Type string
Data interface{}
}
// HelloEvent represents the hello event
type HelloEvent struct{}
// PresenceChangeEvent represents the presence change event
type PresenceChangeEvent struct {
Type string `json:"type"`
Presence string `json:"presence"`
User string `json:"user"`
Users []string `json:"users"`
}
// UserTypingEvent represents the user typing event
type UserTypingEvent struct {
Type string `json:"type"`
User string `json:"user"`
Channel string `json:"channel"`
}
// PrefChangeEvent represents a user preferences change event
type PrefChangeEvent struct {
Type string `json:"type"`
Name string `json:"name"`
Value json.RawMessage `json:"value"`
}
// ManualPresenceChangeEvent represents the manual presence change event
type ManualPresenceChangeEvent struct {
Type string `json:"type"`
Presence string `json:"presence"`
}
// UserChangeEvent represents the user change event
type UserChangeEvent struct {
Type string `json:"type"`
User User `json:"user"`
}
// EmojiChangedEvent represents the emoji changed event
type EmojiChangedEvent struct {
Type string `json:"type"`
SubType string `json:"subtype"`
Name string `json:"name"`
Names []string `json:"names"`
Value string `json:"value"`
EventTimestamp string `json:"event_ts"`
}
// CommandsChangedEvent represents the commands changed event
type CommandsChangedEvent struct {
Type string `json:"type"`
EventTimestamp string `json:"event_ts"`
}
// EmailDomainChangedEvent represents the email domain changed event
type EmailDomainChangedEvent struct {
Type string `json:"type"`
EventTimestamp string `json:"event_ts"`
EmailDomain string `json:"email_domain"`
}
// BotAddedEvent represents the bot added event
type BotAddedEvent struct {
Type string `json:"type"`
Bot Bot `json:"bot"`
}
// BotChangedEvent represents the bot changed event
type BotChangedEvent struct {
Type string `json:"type"`
Bot Bot `json:"bot"`
}
// AccountsChangedEvent represents the accounts changed event
type AccountsChangedEvent struct {
Type string `json:"type"`
}
// ReconnectUrlEvent represents the receiving reconnect url event
type ReconnectUrlEvent struct {
Type string `json:"type"`
URL string `json:"url"`
}
// MemberJoinedChannelEvent, a user joined a public or private channel
type MemberJoinedChannelEvent struct {
Type string `json:"type"`
User string `json:"user"`
Channel string `json:"channel"`
ChannelType string `json:"channel_type"`
Team string `json:"team"`
Inviter string `json:"inviter"`
}
// MemberLeftChannelEvent a user left a public or private channel
type MemberLeftChannelEvent struct {
Type string `json:"type"`
User string `json:"user"`
Channel string `json:"channel"`
ChannelType string `json:"channel_type"`
Team string `json:"team"`
}
slack-0.11.3/websocket_mobile_in_app_notification.go 0000664 0000000 0000000 00000001465 14307410331 0022633 0 ustar 00root root 0000000 0000000 package slack
// MobileInAppNotificationEvent represents the update event for Mobile App Notification.
type MobileInAppNotificationEvent struct {
Type string `json:"type"`
Title string `json:"title"`
Subtitle string `json:"subtitle"`
Timestamp string `json:"ts"`
Channel string `json:"channel"`
AvatarImage string `json:"avatarImage"`
IsShared bool `json:"is_shared"`
ChannelName string `json:"channel_name"`
AuthorID string `json:"author_id"`
AuthorDisplayName string `json:"author_display_name"`
MessageText string `json:"msg_text"`
PushID string `json:"push_id"`
NotifcationID string `json:"notif_id"`
MobileLaunchURI string `json:"mobileLaunchUri"`
EventTimestamp string `json:"event_ts"`
}
slack-0.11.3/websocket_pins.go 0000664 0000000 0000000 00000000676 14307410331 0016244 0 ustar 00root root 0000000 0000000 package slack
type pinEvent struct {
Type string `json:"type"`
User string `json:"user"`
Item Item `json:"item"`
Channel string `json:"channel_id"`
EventTimestamp string `json:"event_ts"`
HasPins bool `json:"has_pins,omitempty"`
}
// PinAddedEvent represents the Pin added event
type PinAddedEvent pinEvent
// PinRemovedEvent represents the Pin removed event
type PinRemovedEvent pinEvent
slack-0.11.3/websocket_reactions.go 0000664 0000000 0000000 00000001516 14307410331 0017254 0 ustar 00root root 0000000 0000000 package slack
// reactionItem is a lighter-weight item than is returned by the reactions list.
type reactionItem struct {
Type string `json:"type"`
Channel string `json:"channel,omitempty"`
File string `json:"file,omitempty"`
FileComment string `json:"file_comment,omitempty"`
Timestamp string `json:"ts,omitempty"`
}
type reactionEvent struct {
Type string `json:"type"`
User string `json:"user"`
ItemUser string `json:"item_user"`
Item reactionItem `json:"item"`
Reaction string `json:"reaction"`
EventTimestamp string `json:"event_ts"`
}
// ReactionAddedEvent represents the Reaction added event
type ReactionAddedEvent reactionEvent
// ReactionRemovedEvent represents the Reaction removed event
type ReactionRemovedEvent reactionEvent
slack-0.11.3/websocket_stars.go 0000664 0000000 0000000 00000000575 14307410331 0016425 0 ustar 00root root 0000000 0000000 package slack
type starEvent struct {
Type string `json:"type"`
User string `json:"user"`
Item StarredItem `json:"item"`
EventTimestamp string `json:"event_ts"`
}
// StarAddedEvent represents the Star added event
type StarAddedEvent starEvent
// StarRemovedEvent represents the Star removed event
type StarRemovedEvent starEvent
slack-0.11.3/websocket_subteam.go 0000664 0000000 0000000 00000002462 14307410331 0016726 0 ustar 00root root 0000000 0000000 package slack
// SubteamCreatedEvent represents the Subteam created event
type SubteamCreatedEvent struct {
Type string `json:"type"`
Subteam UserGroup `json:"subteam"`
}
// SubteamCreatedEvent represents the membership of an existing User Group has changed event
type SubteamMembersChangedEvent struct {
Type string `json:"type"`
SubteamID string `json:"subteam_id"`
TeamID string `json:"team_id"`
DatePreviousUpdate JSONTime `json:"date_previous_update"`
DateUpdate JSONTime `json:"date_update"`
AddedUsers []string `json:"added_users"`
AddedUsersCount int `json:"added_users_count"`
RemovedUsers []string `json:"removed_users"`
RemovedUsersCount int `json:"removed_users_count"`
}
// SubteamSelfAddedEvent represents an event of you have been added to a User Group
type SubteamSelfAddedEvent struct {
Type string `json:"type"`
SubteamID string `json:"subteam_id"`
}
// SubteamSelfRemovedEvent represents an event of you have been removed from a User Group
type SubteamSelfRemovedEvent SubteamSelfAddedEvent
// SubteamUpdatedEvent represents an event of an existing User Group has been updated or its members changed
type SubteamUpdatedEvent struct {
Type string `json:"type"`
Subteam UserGroup `json:"subteam"`
}
slack-0.11.3/websocket_teams.go 0000664 0000000 0000000 00000001625 14307410331 0016377 0 ustar 00root root 0000000 0000000 package slack
// TeamJoinEvent represents the Team join event
type TeamJoinEvent struct {
Type string `json:"type"`
User User `json:"user"`
}
// TeamRenameEvent represents the Team rename event
type TeamRenameEvent struct {
Type string `json:"type"`
Name string `json:"name,omitempty"`
EventTimestamp string `json:"event_ts,omitempty"`
}
// TeamPrefChangeEvent represents the Team preference change event
type TeamPrefChangeEvent struct {
Type string `json:"type"`
Name string `json:"name,omitempty"`
Value []string `json:"value,omitempty"`
}
// TeamDomainChangeEvent represents the Team domain change event
type TeamDomainChangeEvent struct {
Type string `json:"type"`
URL string `json:"url"`
Domain string `json:"domain"`
}
// TeamMigrationStartedEvent represents the Team migration started event
type TeamMigrationStartedEvent struct {
Type string `json:"type"`
}
slack-0.11.3/workflow_step.go 0000664 0000000 0000000 00000005212 14307410331 0016121 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"encoding/json"
)
const VTWorkflowStep ViewType = "workflow_step"
type (
ConfigurationModalRequest struct {
ModalViewRequest
}
WorkflowStepCompleteResponse struct {
WorkflowStepEditID string `json:"workflow_step_edit_id"`
Inputs *WorkflowStepInputs `json:"inputs,omitempty"`
Outputs *[]WorkflowStepOutput `json:"outputs,omitempty"`
}
WorkflowStepInputElement struct {
Value string `json:"value"`
SkipVariableReplacement bool `json:"skip_variable_replacement"`
}
WorkflowStepInputs map[string]WorkflowStepInputElement
WorkflowStepOutput struct {
Name string `json:"name"`
Type string `json:"type"`
Label string `json:"label"`
}
)
func NewConfigurationModalRequest(blocks Blocks, privateMetaData string, externalID string) *ConfigurationModalRequest {
return &ConfigurationModalRequest{
ModalViewRequest{
Type: VTWorkflowStep,
Title: nil, // slack configuration modal must not have a title!
Blocks: blocks,
PrivateMetadata: privateMetaData,
ExternalID: externalID,
},
}
}
func (api *Client) SaveWorkflowStepConfiguration(workflowStepEditID string, inputs *WorkflowStepInputs, outputs *[]WorkflowStepOutput) error {
return api.SaveWorkflowStepConfigurationContext(context.Background(), workflowStepEditID, inputs, outputs)
}
func (api *Client) SaveWorkflowStepConfigurationContext(ctx context.Context, workflowStepEditID string, inputs *WorkflowStepInputs, outputs *[]WorkflowStepOutput) error {
// More information: https://api.slack.com/methods/workflows.updateStep
wscr := WorkflowStepCompleteResponse{
WorkflowStepEditID: workflowStepEditID,
Inputs: inputs,
Outputs: outputs,
}
endpoint := api.endpoint + "workflows.updateStep"
jsonData, err := json.Marshal(wscr)
if err != nil {
return err
}
response := &SlackResponse{}
if err := postJSON(ctx, api.httpclient, endpoint, api.token, jsonData, response, api); err != nil {
return err
}
if !response.Ok {
return response.Err()
}
return nil
}
func GetInitialOptionFromWorkflowStepInput(selection *SelectBlockElement, inputs *WorkflowStepInputs, options []*OptionBlockObject) (*OptionBlockObject, bool) {
if len(*inputs) == 0 {
return &OptionBlockObject{}, false
}
if len(options) == 0 {
return &OptionBlockObject{}, false
}
if val, ok := (*inputs)[selection.ActionID]; ok {
if val.SkipVariableReplacement {
return &OptionBlockObject{}, false
}
for _, option := range options {
if option.Value == val.Value {
return option, true
}
}
}
return &OptionBlockObject{}, false
}
slack-0.11.3/workflow_step_execute.go 0000664 0000000 0000000 00000004201 14307410331 0017640 0 ustar 00root root 0000000 0000000 package slack
import (
"context"
"encoding/json"
)
type (
WorkflowStepCompletedRequest struct {
WorkflowStepExecuteID string `json:"workflow_step_execute_id"`
Outputs map[string]string `json:"outputs"`
}
WorkflowStepFailedRequest struct {
WorkflowStepExecuteID string `json:"workflow_step_execute_id"`
Error struct {
Message string `json:"message"`
} `json:"error"`
}
)
type WorkflowStepCompletedRequestOption func(opt WorkflowStepCompletedRequest) error
func WorkflowStepCompletedRequestOptionOutput(outputs map[string]string) WorkflowStepCompletedRequestOption {
return func(opt WorkflowStepCompletedRequest) error {
if len(outputs) > 0 {
opt.Outputs = outputs
}
return nil
}
}
// WorkflowStepCompleted indicates step is completed
func (api *Client) WorkflowStepCompleted(workflowStepExecuteID string, options ...WorkflowStepCompletedRequestOption) error {
// More information: https://api.slack.com/methods/workflows.stepCompleted
r := WorkflowStepCompletedRequest{
WorkflowStepExecuteID: workflowStepExecuteID,
}
for _, option := range options {
option(r)
}
endpoint := api.endpoint + "workflows.stepCompleted"
jsonData, err := json.Marshal(r)
if err != nil {
return err
}
response := &SlackResponse{}
if err := postJSON(context.Background(), api.httpclient, endpoint, api.token, jsonData, response, api); err != nil {
return err
}
if !response.Ok {
return response.Err()
}
return nil
}
// WorkflowStepFailed indicates step is failed
func (api *Client) WorkflowStepFailed(workflowStepExecuteID string, errorMessage string) error {
// More information: https://api.slack.com/methods/workflows.stepFailed
r := WorkflowStepFailedRequest{
WorkflowStepExecuteID: workflowStepExecuteID,
}
r.Error.Message = errorMessage
endpoint := api.endpoint + "workflows.stepFailed"
jsonData, err := json.Marshal(r)
if err != nil {
return err
}
response := &SlackResponse{}
if err := postJSON(context.Background(), api.httpclient, endpoint, api.token, jsonData, response, api); err != nil {
return err
}
if !response.Ok {
return response.Err()
}
return nil
}
slack-0.11.3/workflow_step_execute_test.go 0000664 0000000 0000000 00000001614 14307410331 0020704 0 ustar 00root root 0000000 0000000 package slack
import (
"encoding/json"
"net/http"
"testing"
)
func workflowStepHandler(rw http.ResponseWriter, r *http.Request) {
rw.Header().Set("Content-Type", "application/json")
response, _ := json.Marshal(SlackResponse{
Ok: true,
})
rw.Write(response)
}
func TestWorkflowStepCompleted(t *testing.T) {
http.HandleFunc("/workflows.stepCompleted", workflowStepHandler)
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
if err := api.WorkflowStepCompleted("executeID"); err != nil {
t.Errorf("Unexpected error: %s", err)
}
}
func TestWorkflowStepFailed(t *testing.T) {
http.HandleFunc("/workflows.stepFailed", workflowStepHandler)
once.Do(startServer)
api := New("testing-token", OptionAPIURL("http://"+serverAddr+"/"))
if err := api.WorkflowStepFailed("executeID", "error message"); err != nil {
t.Errorf("Unexpected error: %s", err)
}
}
slack-0.11.3/workflow_step_test.go 0000664 0000000 0000000 00000011417 14307410331 0017164 0 ustar 00root root 0000000 0000000 package slack
import (
"testing"
"github.com/google/go-cmp/cmp"
)
const (
IDExampleSelectInput = "ae9642ae-a9ef-4394-904b-a5c7a83bf4a6"
IDSelectOptionBlock = "832bf7af-22ea-4acb-82e3-a0cc3722052b"
)
func TestNewConfigurationModalRequest(t *testing.T) {
blocks := configModalBlocks()
privateMetaData := "An optional string that will be sent to your app in view_submission and block_actions events. Max length of 3000 characters."
externalID := "c4baf441-fbc1-4131-b349-7c8df0ae7df6"
result := NewConfigurationModalRequest(blocks, privateMetaData, externalID)
if result.ModalViewRequest.Title != nil {
t.Fail()
}
if result.PrivateMetadata != privateMetaData {
t.Fail()
}
if result.ExternalID != externalID {
t.Fail()
}
}
func TestGetInitialOptionFromWorkflowStepInput(t *testing.T) {
options, testOption := createOptionBlockObjects()
selection := createSelection(options)
scenarios := []struct {
options []*OptionBlockObject
inputs *WorkflowStepInputs
expectedResult *OptionBlockObject
expectedFlag bool
}{
{
options: options,
inputs: createWorkflowStepInputs1(),
expectedResult: &OptionBlockObject{},
expectedFlag: false,
},
{
options: []*OptionBlockObject{},
inputs: createWorkflowStepInputs4(testOption.Value),
expectedResult: &OptionBlockObject{},
expectedFlag: false,
},
{
options: options,
inputs: createWorkflowStepInputs2(),
expectedResult: &OptionBlockObject{},
expectedFlag: false,
},
{
options: options,
inputs: createWorkflowStepInputs3(),
expectedResult: &OptionBlockObject{},
expectedFlag: false,
},
{
options: options,
inputs: createWorkflowStepInputs4(testOption.Value),
expectedResult: testOption,
expectedFlag: true,
},
}
for _, scenario := range scenarios {
result, ok := GetInitialOptionFromWorkflowStepInput(selection, scenario.inputs, scenario.options)
if ok != scenario.expectedFlag {
t.Fail()
}
if !cmp.Equal(result, scenario.expectedResult) {
t.Fail()
}
}
}
func createOptionBlockObjects() ([]*OptionBlockObject, *OptionBlockObject) {
var options []*OptionBlockObject
options = append(
options,
NewOptionBlockObject("one", NewTextBlockObject("plain_text", "One", false, false), nil),
)
option2 := NewOptionBlockObject("two", NewTextBlockObject("plain_text", "Two", false, false), nil)
options = append(
options,
option2,
)
options = append(
options,
NewOptionBlockObject("three", NewTextBlockObject("plain_text", "Three", false, false), nil),
)
return options, option2
}
func createSelection(options []*OptionBlockObject) *SelectBlockElement {
return NewOptionsSelectBlockElement(
"static_select",
NewTextBlockObject("plain_text", "your choice", false, false),
IDExampleSelectInput,
options...,
)
}
func configModalBlocks() Blocks {
headerText := NewTextBlockObject("mrkdwn", "Hello World!\nThis is your workflow step app configuration view", false, false)
headerSection := NewSectionBlock(headerText, nil, nil)
options, _ := createOptionBlockObjects()
selection := createSelection(options)
inputBlock := NewInputBlock(
IDSelectOptionBlock,
NewTextBlockObject("plain_text", "Select an option", false, false),
NewTextBlockObject("plain_text", "Hint", false, false),
selection,
)
blocks := Blocks{
BlockSet: []Block{
headerSection,
inputBlock,
},
}
return blocks
}
func createWorkflowStepInputs1() *WorkflowStepInputs {
return &WorkflowStepInputs{}
}
func createWorkflowStepInputs2() *WorkflowStepInputs {
return &WorkflowStepInputs{
"test": WorkflowStepInputElement{
Value: "random-string",
SkipVariableReplacement: false,
},
"123-test": WorkflowStepInputElement{
Value: "another-string",
SkipVariableReplacement: false,
},
}
}
func createWorkflowStepInputs3() *WorkflowStepInputs {
return &WorkflowStepInputs{
"test": WorkflowStepInputElement{
Value: "random-string",
SkipVariableReplacement: false,
},
"123-test": WorkflowStepInputElement{
Value: "another-string",
SkipVariableReplacement: false,
},
IDExampleSelectInput: WorkflowStepInputElement{
Value: "lorem-ipsum",
SkipVariableReplacement: true,
},
}
}
func createWorkflowStepInputs4(optionValue string) *WorkflowStepInputs {
return &WorkflowStepInputs{
"test": WorkflowStepInputElement{
Value: "random-string",
SkipVariableReplacement: false,
},
"123-test": WorkflowStepInputElement{
Value: "another-string",
SkipVariableReplacement: false,
},
IDExampleSelectInput: WorkflowStepInputElement{
Value: optionValue,
SkipVariableReplacement: false,
},
}
}