private async Task TestSlackBody(string fileName, string contentType)
{
var callback = false;
var slackApi = GetSlackApiMock();
var slackAdapter = new SlackAdapter(slackApi.Object, _adapterOptions);
var httpRequest = GetHttpRequestMock(fileName, contentType);
var httpResponse = GetHttpResponseMock();
httpResponse.Setup(_ => _.Body.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Callback((byte[] data, int offset, int length, CancellationToken token) =>
{
if (length > 0)
{
var actual = Encoding.UTF8.GetString(data);
}
});
var bot = new Mock <IBot>();
bot.Setup(x => x.OnTurnAsync(It.IsAny <TurnContext>(), It.IsAny <CancellationToken>())).Callback(() =>
{
callback = true;
});
await slackAdapter.ProcessAsync(httpRequest.Object, httpResponse.Object, bot.Object, default);
Assert.True(callback);
}
public static IApplicationBuilder UseSlack(this IApplicationBuilder applicationBuilder)
{
var options = applicationBuilder.ApplicationServices.GetRequiredService <IOptions <SlackBotOptions> >().Value;
if (!options.IsValid)
{
throw new ArgumentException(
"Passed options are invalid."
);
}
var adapter = new SlackAdapter(options.SlackOptions);
foreach (var middleware in options.Middleware)
{
adapter.Use(middleware);
}
var paths = options.Paths;
if (!paths.BasePath.EndsWith("/"))
{
paths.BasePath += "/";
}
applicationBuilder.Map(
$"{paths.BasePath}{paths.RequestPath}",
botActivitiesAppBuilder => botActivitiesAppBuilder.Run(new SlackRequestHandler(adapter, options).HandleAsync));
return(applicationBuilder);
}
public async Task ProcessAsyncShouldFailWithSignatureMismatch()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
slackApi.Setup(x => x.VerifySignature(It.IsAny <HttpRequest>(), It.IsAny <string>())).Returns(false);
var slackAdapter = new SlackAdapter(slackApi.Object);
var payload = File.ReadAllText(Directory.GetCurrentDirectory() + @"/Files/MessageBody.json");
var stream = new MemoryStream(Encoding.UTF8.GetBytes(payload.ToString()));
var httpRequest = new Mock <HttpRequest>();
httpRequest.SetupGet(req => req.Body).Returns(stream);
var httpResponse = new Mock <HttpResponse>();
httpResponse.SetupAllProperties();
var mockStream = new Mock <Stream>();
httpResponse.SetupGet(req => req.Body).Returns(mockStream.Object);
httpResponse.Setup(_ => _.Body.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Callback((byte[] data, int offset, int length, CancellationToken token) =>
{
if (length > 0)
{
var actual = Encoding.UTF8.GetString(data);
}
});
await Assert.ThrowsAsync <Exception>(async() => { await slackAdapter.ProcessAsync(httpRequest.Object, httpResponse.Object, new Mock <IBot>().Object, default); });
}
public async Task UpdateActivityAsyncShouldSucceed()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
slackApi.Setup(x => x.UpdateAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(), null, It.IsAny <bool>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(new UpdateResponse {
ok = true
}));
var slackAdapter = new SlackAdapter(slackApi.Object);
var activity = new Mock <Activity>().SetupAllProperties();
activity.Object.Id = "MockActivityId";
activity.Object.Conversation = new ConversationAccount
{
Id = "MockConversationId",
};
activity.Object.Text = "Hello, Bot!";
ResourceResponse response;
using (var turnContext = new TurnContext(slackAdapter, activity.Object))
{
response = await slackAdapter.UpdateActivityAsync(turnContext, activity.Object, default);
}
Assert.Equal(activity.Object.Id, response.Id);
}
public async Task ProcessAsyncShouldSucceedWithUnknownEventType()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
slackApi.Setup(x => x.VerifySignature(It.IsAny <HttpRequest>(), It.IsAny <string>())).Returns(true);
var slackAdapter = new SlackAdapter(_testOptions, slackClient: slackApi.Object);
var payload = File.ReadAllText(Directory.GetCurrentDirectory() + @"/Files/UnknownEvent.json");
var stream = new MemoryStream(Encoding.UTF8.GetBytes(payload.ToString()));
var httpRequest = new Mock <HttpRequest>();
httpRequest.SetupGet(req => req.Body).Returns(stream);
var httpRequestHeader = new Mock <IHeaderDictionary>();
httpRequestHeader.SetupGet(x => x["Content-Type"]).Returns("application/json");
httpRequest.SetupGet(req => req.Headers).Returns(httpRequestHeader.Object);
var httpResponse = new Mock <HttpResponse>();
httpResponse.SetupAllProperties();
var mockStream = new Mock <Stream>();
httpResponse.SetupGet(req => req.Body).Returns(mockStream.Object);
await slackAdapter.ProcessAsync(httpRequest.Object, httpResponse.Object, new Mock <IBot>().Object, default);
Assert.Equal(httpResponse.Object.StatusCode, (int)HttpStatusCode.OK);
}
public async Task UpdateActivityAsyncShouldFailWithResponseError()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
slackApi.Setup(x => x.UpdateAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(), null, It.IsAny <bool>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(new UpdateResponse {
ok = false
}));
var slackAdapter = new SlackAdapter(slackApi.Object);
var activity = new Mock <Activity>().SetupAllProperties();
activity.Object.Id = "MockActivityId";
activity.Object.Conversation = new ConversationAccount
{
Id = "MockConversationId",
};
activity.Object.Text = "Hello, Bot!";
using (var turnContext = new TurnContext(slackAdapter, activity.Object))
{
await Assert.ThrowsAsync <Exception>(async() =>
{
await slackAdapter.UpdateActivityAsync(turnContext, activity.Object, default);
});
}
}
public async Task DeleteActivityAsyncShouldSucceed()
{
var deletedMessages = 0;
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
slackApi.Setup(x => x.DeleteMessageAsync(It.IsAny <string>(), It.IsAny <DateTime>(), It.IsAny <CancellationToken>())).Callback(() => { deletedMessages++; });
var slackAdapter = new SlackAdapter(slackApi.Object);
var activity = new Mock <Activity>();
activity.Object.Timestamp = new DateTimeOffset();
using (var context = new TurnContext(slackAdapter, activity.Object))
{
var reference = new ConversationReference
{
ChannelId = "channelId",
};
await slackAdapter.DeleteActivityAsync(context, reference, default);
}
Assert.Equal(1, deletedMessages);
}
public async Task SendActivitiesAsyncShouldSucceed()
{
var slackResponse = new SlackResponse
{
Ok = true,
Ts = "mockedTS",
};
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
slackApi.Setup(x => x.PostMessageAsync(It.IsAny <NewSlackMessage>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(slackResponse));
var slackAdapter = new SlackAdapter(slackApi.Object);
var activity = new Activity
{
Type = ActivityTypes.Message,
Text = "text",
Conversation = new ConversationAccount()
{
Id = "testConversationId",
},
};
Activity[] activities = { activity };
var turnContext = new TurnContext(slackAdapter, activity);
var responses = await slackAdapter.SendActivitiesAsync(turnContext, activities, default);
Assert.Equal(slackResponse.Ts, responses[0].Id);
}
public async Task ProcessAsyncShouldFailOnVerificationTokenMismatch()
{
_testOptions.SlackVerificationToken = "testToken";
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
slackApi.Setup(x => x.VerifySignature(It.IsAny <HttpRequest>(), It.IsAny <string>())).Returns(true);
var slackAdapter = new SlackAdapter(slackApi.Object);
var payload = File.ReadAllText(Directory.GetCurrentDirectory() + @"/Files/MessageBody.json");
var stream = new MemoryStream(Encoding.UTF8.GetBytes(payload.ToString()));
var httpRequest = new Mock <HttpRequest>();
httpRequest.SetupGet(req => req.Body).Returns(stream);
var httpResponse = new Mock <HttpResponse>();
httpResponse.SetupAllProperties();
var mockStream = new Mock <Stream>();
httpResponse.SetupGet(req => req.Body).Returns(mockStream.Object);
await Assert.ThrowsAsync <Exception>(async() => { await slackAdapter.ProcessAsync(httpRequest.Object, httpResponse.Object, new Mock <IBot>().Object, default); });
}
public SlackRequestHandler(
SlackAdapter adapter,
SlackBotOptions options
)
{
this.adapter = adapter;
this.jsonSettings = Default.JsonSettings(Default.SlackTypeResolver(Default.AssembliesContainingSlackTypes));
this.options = options;
}
public async Task ContinueConversationAsyncShouldFailWithNullBot()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
var slackAdapter = new SlackAdapter(slackApi.Object);
await Assert.ThrowsAsync <ArgumentNullException>(async() => { await slackAdapter.ContinueConversationAsync(new ConversationReference(), null, default); });
}
public async Task ProcessAsyncShouldFailOnVerificationTokenMismatch()
{
_testOptions.SlackVerificationToken = "testToken";
var slackApi = GetSlackApiMock();
var slackAdapter = new SlackAdapter(slackApi.Object, _adapterOptions);
var httpRequest = GetHttpRequestMock("MessageBody.json", "application/json");
var httpResponse = GetHttpResponseMock();
await Assert.ThrowsAsync <AuthenticationException>(async() => { await slackAdapter.ProcessAsync(httpRequest.Object, httpResponse.Object, new Mock <IBot>().Object, default); });
}
public async Task ProcessAsyncShouldSucceedWithUnknownEventType()
{
var slackApi = GetSlackApiMock();
var slackAdapter = new SlackAdapter(slackApi.Object, _adapterOptions);
var httpRequest = GetHttpRequestMock("UnknownEvent.json", "application/json");
var httpResponse = GetHttpResponseMock();
await slackAdapter.ProcessAsync(httpRequest.Object, httpResponse.Object, new Mock <IBot>().Object, default);
Assert.Equal(httpResponse.Object.StatusCode, (int)HttpStatusCode.OK);
}
public async Task ProcessAsyncShouldSucceedOnInteractiveMessage()
{
var callback = false;
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
slackApi.Setup(x => x.VerifySignature(It.IsAny <HttpRequest>(), It.IsAny <string>())).Returns(true);
var slackAdapter = new SlackAdapter(_testOptions, slackClient: slackApi.Object);
var payload = File.ReadAllText(Directory.GetCurrentDirectory() + @"/Files/InteractiveMessageBody.txt");
var stream = new MemoryStream(Encoding.UTF8.GetBytes(payload.ToString()));
var httpRequest = new Mock <HttpRequest>();
httpRequest.SetupGet(req => req.Body).Returns(stream);
var httpRequestHeader = new Mock <IHeaderDictionary>();
httpRequestHeader.SetupGet(x => x["Content-Type"]).Returns("application/x-www-form-urlencoded");
httpRequest.SetupGet(req => req.Headers).Returns(httpRequestHeader.Object);
var httpResponse = new Mock <HttpResponse>();
httpResponse.SetupAllProperties();
var mockStream = new Mock <Stream>();
httpResponse.SetupGet(req => req.Body).Returns(mockStream.Object);
httpResponse.Setup(_ => _.Body.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Callback((byte[] data, int offset, int length, CancellationToken token) =>
{
if (length > 0)
{
var actual = Encoding.UTF8.GetString(data);
}
});
var bot = new Mock <IBot>();
bot.Setup(x => x.OnTurnAsync(It.IsAny <TurnContext>(), It.IsAny <CancellationToken>())).Callback(() =>
{
callback = true;
});
await slackAdapter.ProcessAsync(httpRequest.Object, httpResponse.Object, bot.Object, default);
Assert.True(callback);
}
public async Task ContinueConversationAsyncShouldFailWithNullReference()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
var slackAdapter = new SlackAdapter(slackApi.Object, _adapterOptions);
Task BotsLogic(ITurnContext turnContext, CancellationToken cancellationToken)
{
return(Task.CompletedTask);
}
await Assert.ThrowsAsync <ArgumentNullException>(async() => { await slackAdapter.ContinueConversationAsync(null, BotsLogic, default); });
}
public async void ProcessAsyncShouldFailWithNullHttpResponse()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
var slackAdapter = new SlackAdapter(slackApi.Object);
var httpRequest = new Mock <HttpRequest>();
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await slackAdapter.ProcessAsync(httpRequest.Object, null, new Mock <IBot>().Object, default);
});
}
public async Task UpdateActivityAsyncShouldFailWithNullContext()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
var slackAdapter = new SlackAdapter(slackApi.Object);
var activity = new Activity();
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await slackAdapter.UpdateActivityAsync(null, activity, default);
});
}
public static bool TestSuccess(SlackAdapter sa)
{
bool ret = false;
try
{
string answer = Accessor.JsonGet(sa, URL);
Response response = Accessor.Deserialize <Response>(answer);
ret = response.Ok;
}
catch
{
}
return(ret);
}
public async Task DeleteActivityAsyncShouldFailWithNullReference()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
var slackAdapter = new SlackAdapter(slackApi.Object);
using (var context = new TurnContext(slackAdapter, new Activity()))
{
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await slackAdapter.DeleteActivityAsync(context, null, default);
});
}
}
static void Main(string[] args)
{
var options = new SlackOptions
{
BotUserToken = MySlackBotToken
};
var adapter = new SlackAdapter(options)
.Use(new SlackMessageTypeMiddleware());
var myBot = new MyBot();
adapter.ProcessActivityBySocketAsync(async(turnContext, cancellationToken) =>
{
await myBot.OnTurnAsync(turnContext, cancellationToken);
}).Wait();
}
public async Task ProcessAsyncShouldSucceedOnUrlVerification()
{
string actual = null;
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
slackApi.Setup(x => x.VerifySignature(It.IsAny <HttpRequest>(), It.IsAny <string>())).Returns(true);
var slackAdapter = new SlackAdapter(_testOptions, slackClient: slackApi.Object);
var payload = File.ReadAllText(Directory.GetCurrentDirectory() + @"/Files/URLVerificationBody.json");
var stream = new MemoryStream(Encoding.UTF8.GetBytes(payload.ToString()));
var deserializedPayload = JsonConvert.DeserializeObject <UrlVerificationEvent>(payload);
var httpRequest = new Mock <HttpRequest>();
httpRequest.SetupGet(req => req.Body).Returns(stream);
var httpRequestHeader = new Mock <IHeaderDictionary>();
httpRequestHeader.SetupGet(x => x["Content-Type"]).Returns("application/json");
httpRequest.SetupGet(req => req.Headers).Returns(httpRequestHeader.Object);
var httpResponse = new Mock <HttpResponse>();
var mockStream = new Mock <Stream>();
httpResponse.SetupGet(req => req.Body).Returns(mockStream.Object);
httpResponse.Setup(_ => _.Body.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Callback((byte[] data, int offset, int length, CancellationToken token) =>
{
if (length > 0)
{
actual = Encoding.UTF8.GetString(data);
}
});
await slackAdapter.ProcessAsync(httpRequest.Object, httpResponse.Object, new Mock <IBot>().Object, default);
Assert.Equal(actual, deserializedPayload.Challenge);
}
public static Authorisation Get(SlackAdapter sa)
{
Authorisation auth = null;
try
{
string answer = Accessor.JsonPostFormData(sa, URL);
Response response = Accessor.Deserialize <Response>(answer);
if (response.Ok)
{
auth = Accessor.Deserialize <Authorisation>(answer);
}
}
catch
{
}
return(auth);
}
public static PermissionInfo GetInfo(SlackAdapter sa)
{
PermissionInfo pi = null;
try
{
string answer = Accessor.JsonGet(sa, URL);
Response response = Accessor.Deserialize <Response>(answer);
if (response.Ok)
{
pi = Accessor.Deserialize <PermissionInfo>(answer);
}
}
catch
{
}
return(pi);
}
public async Task ContinueConversationAsyncShouldSucceed()
{
var callbackInvoked = false;
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
var slackAdapter = new SlackAdapter(slackApi.Object);
Task BotsLogic(ITurnContext turnContext, CancellationToken cancellationToken)
{
callbackInvoked = true;
return(Task.CompletedTask);
}
await slackAdapter.ContinueConversationAsync(new ConversationReference(), BotsLogic, default);
Assert.True(callbackInvoked);
}
public async Task UpdateActivityAsyncShouldFailWithNullActivityConversation()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
var slackAdapter = new SlackAdapter(slackApi.Object);
var activity = new Activity
{
Id = "testId",
Conversation = null,
};
using (var turnContext = new TurnContext(slackAdapter, activity))
{
await Assert.ThrowsAsync <ArgumentException>(async() =>
{
await slackAdapter.UpdateActivityAsync(turnContext, activity, default);
});
}
}
public async Task SendActivitiesAsyncShouldThrowExceptionWithNullContext()
{
var slackApi = new Mock <SlackClientWrapper>(_testOptions);
slackApi.Setup(x => x.TestAuthAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult("mockedUserId"));
var slackAdapter = new SlackAdapter(slackApi.Object);
var activity = new Activity
{
Id = "testId",
Type = ActivityTypes.Message,
Text = "text",
Conversation = new ConversationAccount()
{
Id = "testConversationId",
},
};
Activity[] activities = { activity };
await Assert.ThrowsAsync <ArgumentNullException>(async() => { await slackAdapter.SendActivitiesAsync(null, activities, default); });
}
public static void Main(string[] args)
{
if ("events".Equals(Mode) || "events".Equals(args[0]))
{
WebHost.CreateDefaultBuilder(args)
.UseStartup <Startup>().Build().Run();
}
else if ("rtm".Equals(Mode) || "rtm".Equals(args[0]))
{
var adapter = new SlackAdapter(Program.Options)
.Use(new SlackMessageTypeMiddleware());
var bot = new ExPonyakBot();
adapter.ProcessActivityBySocketAsync(async(turnContext, cancellationToken) =>
{
await bot.OnTurnAsync(turnContext, cancellationToken);
}).Wait();
}
else
{
throw new ArgumentException();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SlackController"/> class.
/// </summary>
/// <param name="adapter">The Slack adapter middleware.</param>
/// <param name="bot">The bot that can process the incoming messages/activities.</param>
public SlackController(SlackAdapter adapter, IBot bot)
{
this.adapter = adapter;
this.bot = bot;
}
public void Run(string[] args)
{
var resetEvent = new ManualResetEvent(false);
var tokenSource = new CancellationTokenSource();
var thread = new Thread(() =>
{
try
{
IAdapter adapter;
switch (args[0])
{
case "gitter":
adapter = new GitterAdapter(args[1]);
break;
case "slack":
adapter = new SlackAdapter(args[1]);
break;
default:
throw new NotImplementedException("Unknown NuBot adapter.");
}
new RobotFactory()
.AddPart <Echo>()
.AddPart <EchoWebHook>()
.AddPart <HelloGoodbye>()
.AddPart <IllBeBack>()
.UseAdapter(adapter)
.UseHttpServer(1337)
.RunAsync(tokenSource.Token)
.GetAwaiter()
.GetResult();
}
catch (OperationCanceledException)
{
}
catch (Exception exception)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(exception);
Console.ResetColor();
}
finally
{
resetEvent.Set();
}
});
thread.Start();
while (true)
{
var key = Console.ReadKey(true);
if ((key.Modifiers & ConsoleModifiers.Control) == ConsoleModifiers.Control && key.Key == ConsoleKey.C)
{
break;
}
}
tokenSource.Cancel();
resetEvent.WaitOne();
thread.Join();
Console.WriteLine("NuBot has stopped.");
Console.ReadKey();
}
public SlackController(SlackAdapter adapter, IBot bot)
{
_adapter = adapter;
_bot = bot;
}
