SlackAPI/SlackAPI.Tests/Connect.cs at fd43c9b9969b18406f253ebfe8a24cf0ec1a498d · Inumedia/SlackAPI · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
using System;
using SlackAPI.Tests.Configuration;
using SlackAPI.Tests.Helpers;
using SlackAPI.WebSocketMessages;
using Xunit;

namespace SlackAPI.Tests
{
    [Collection("Integration tests")]
    public class Connect
    {
        const string TestText = "Test :D";
        private readonly IntegrationFixture fixture;

        public Connect(IntegrationFixture fixture)
        {
            this.fixture = fixture;
        }

        [Fact]
        public void TestConnectAsUser()
        {
            var client = this.fixture.UserClient;
            Assert.True(client.IsConnected, "Invalid, doesn't think it's connected.");
        }

        [Fact]
        public void TestConnectAsUserWithPresence()
        {
            var client = this.fixture.UserClientWithPresence;
            Assert.True(client.IsConnected, "Invalid, doesn't think it's connected.");
        }

        [Fact(Skip = "Unable to get a working test with data we have in config.json")]
        public void TestGetAccessToken()
        {
            // assemble
            var clientId = this.fixture.Config.ClientId;
            var clientSecret = this.fixture.Config.ClientSecret;
            var authCode = this.fixture.Config.AuthCode;

            // act
            var accessTokenResponse = GetAccessToken(clientId, clientSecret, "", authCode);

            // assert
            Assert.NotNull(accessTokenResponse);
            Assert.NotNull(accessTokenResponse.bot);
            Assert.NotNull(accessTokenResponse.bot.bot_user_id);
            Assert.NotNull(accessTokenResponse.bot.bot_access_token);
        }

        private AccessTokenResponse GetAccessToken(string clientId, string clientSecret, string redirectUri, string authCode)
        {
            AccessTokenResponse accessTokenResponse = null;

            using (var sync = new InSync(nameof(SlackClient.GetAccessToken)))
            {
                SlackClient.GetAccessToken(response =>
                {
                    accessTokenResponse = response;
                    sync.Proceed();

                }, clientId, clientSecret, redirectUri, authCode);
            }

            return accessTokenResponse;
        }

        [Fact]
        public void TestConnectAsBot()
        {
            var client = this.fixture.BotClient;
            Assert.True(client.IsConnected, "Invalid, doesn't think it's connected.");
        }

        [Fact]
        public void TestConnectPostAndDelete()
        {
            // given
            SlackSocketClient client = this.fixture.UserClient;
            string channel = this.fixture.Config.TestChannelId;

            // when
            DateTime messageTimestamp = PostMessage(client, channel);
            DeletedResponse deletedResponse = DeleteMessage(client, channel, messageTimestamp);

            // then
            Assert.NotNull(deletedResponse);
            Assert.True(deletedResponse.ok);
            Assert.Equal(channel, deletedResponse.channel);
            Assert.Equal(messageTimestamp, deletedResponse.ts);
        }

        private static DateTime PostMessage(SlackSocketClient client, string channel)
        {
            MessageReceived sendMessageResponse = null;

            using (var sync = new InSync(nameof(SlackSocketClient.SendMessage)))
            {
                client.SendMessage(response =>
                {
                    sendMessageResponse = response;
                    sync.Proceed();
                }, channel, TestText);
            }

            Assert.NotNull(sendMessageResponse);
            Assert.Equal(TestText, sendMessageResponse.text);

            return sendMessageResponse.ts;
        }

        private static DeletedResponse DeleteMessage(SlackSocketClient client, string channel, DateTime messageTimestamp)
        {
            DeletedResponse deletedResponse = null;

            using (var sync = new InSync(nameof(SlackClient.DeleteMessage)))
            {
                client.DeleteMessage(response =>
                {
                    deletedResponse = response;
                    sync.Proceed();
                }, channel, messageTimestamp);
            }

            return deletedResponse;
        }
    }
}