/// <inheritdoc/> public override async Task SendActivityAsync(BotActivity activity, CancellationToken cancellationToken) { if (_conversation == null) { await CreateConversationAsync().ConfigureAwait(false); if (activity.Type == ActivityTypes.ConversationUpdate) { // CreateConversationAsync sends a ConversationUpdate automatically. // Ignore the activity sent if it is the first one we are sending to the bot and it is a ConversationUpdate. // This can happen with recorded scripts where we get a conversation update from the transcript that we don't // want to use. return; } } var activityPost = new Activity { From = new ChannelAccount(_user), Text = activity.Text, Type = activity.Type }; await _dlClient.Conversations.PostActivityAsync(_conversation.ConversationId, activityPost, cancellationToken).ConfigureAwait(false); }
private async Task <DialogTurnResult> WelcomeStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) { var card = CardUtils.CreateCardFromJson("gretaWelcomeCard"); var activity = new Microsoft.Bot.Schema.Activity { Attachments = new List <Attachment>() { new Attachment() { Content = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(card)), ContentType = "application/vnd.microsoft.card.adaptive" } }, Type = ActivityTypes.Message }; var promptOptions = new PromptOptions { Prompt = MessageFactory.Text(registeredMsg), RetryPrompt = MessageFactory.Text(registeredMsg + " (Yes/No)") }; await stepContext.Context.SendActivityAsync(activity); return(await stepContext.PromptAsync(nameof(ConfirmPrompt), promptOptions, cancellationToken)); }
public void NamedPipeActivityTest() { const string pipeName = "test.pipe"; var logger = XUnitLogger.CreateLogger(_testOutput); // Arrange var activity = new Activity { Id = Guid.NewGuid().ToString("N"), Type = ActivityTypes.Message, From = new ChannelAccount { Id = "testUser" }, Conversation = new ConversationAccount { Id = Guid.NewGuid().ToString("N") }, Recipient = new ChannelAccount { Id = "testBot" }, ServiceUrl = "unknown", ChannelId = "test", Text = "hi" }; var bot = new StreamingTestBot((turnContext, cancellationToken) => { var activityClone = JsonConvert.DeserializeObject <Activity>(JsonConvert.SerializeObject(turnContext.Activity)); activityClone.Text = $"Echo: {turnContext.Activity.Text}"; return(turnContext.SendActivityAsync(activityClone, cancellationToken)); }); var verifiedResponse = false; var clientRequestHandler = new Mock <RequestHandler>(); clientRequestHandler .Setup(h => h.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), It.IsAny <ILogger <RequestHandler> >(), It.IsAny <object>(), It.IsAny <CancellationToken>())) .Returns <ReceiveRequest, ILogger <RequestHandler>, object, CancellationToken>((request, anonLogger, context, cancellationToken) => { var body = request.ReadBodyAsString(); var response = JsonConvert.DeserializeObject <Activity>(body, SerializationSettings.DefaultDeserializationSettings); Assert.NotNull(response); Assert.Equal("Echo: hi", response.Text); verifiedResponse = true; return(Task.FromResult(StreamingResponse.OK())); }); // Act var server = new CloudAdapter(new StreamingTestBotFrameworkAuthentication(), logger); var serverRunning = server.ConnectNamedPipeAsync(pipeName, bot, "testAppId", "testAudience", "testCallerId"); var client = new NamedPipeClient(pipeName, ".", clientRequestHandler.Object, logger: logger); var clientRunning = client.ConnectAsync(); SimulateMultiTurnConversation(1, new[] { activity }, client, logger); // Assert Assert.True(verifiedResponse); }
/// <inheritdoc/> public override async Task SendActivityAsync(BotActivity activity, CancellationToken cancellationToken) { if (_conversation == null) { await StartConversationAsync().ConfigureAwait(false); if (activity.Type == ActivityTypes.ConversationUpdate) { // StartConversationAsync sends a ConversationUpdate automatically. // Ignore the activity sent if it is the first one we are sending to the bot and it is a ConversationUpdate. // This can happen with recorded scripts where we get a conversation update from the transcript that we don't // want to use. return; } } var activityPost = new Activity { From = new ChannelAccount(_user), Text = activity.Text, Type = activity.Type }; _logger.LogDebug($"{DateTime.Now} Sending activity to conversation {_conversation.ConversationId}"); _logger.LogDebug(JsonConvert.SerializeObject(activityPost, Formatting.Indented)); await _dlClient.Conversations.PostActivityAsync(_conversation.ConversationId, activityPost, cancellationToken).ConfigureAwait(false); }
public async Task TestAdapter_GetTokenStatusWithFilter() { TestAdapter adapter = new TestAdapter(); string channelId = "directline"; string userId = "testUser"; string token = "abc123"; Activity activity = new Activity() { ChannelId = channelId, From = new ChannelAccount() { Id = userId, }, }; TurnContext turnContext = new TurnContext(adapter, activity); adapter.AddUserToken("ABC", channelId, userId, token); adapter.AddUserToken("DEF", channelId, userId, token); var status = await adapter.GetTokenStatusAsync(turnContext, userId, "DEF"); Assert.NotNull(status); Assert.Single(status); var oAuthAppCredentials = MicrosoftAppCredentials.Empty; status = await adapter.GetTokenStatusAsync(turnContext, oAuthAppCredentials, userId, "DEF"); Assert.NotNull(status); Assert.Single(status); }
public async Task TestAdapter_GetUserTokenAsyncReturnsToken() { TestAdapter adapter = new TestAdapter(); string connectionName = "myConnection"; string channelId = "directline"; string userId = "testUser"; string token = "abc123"; Activity activity = new Activity() { ChannelId = channelId, From = new ChannelAccount() { Id = userId, }, }; TurnContext turnContext = new TurnContext(adapter, activity); adapter.AddUserToken(connectionName, channelId, userId, token); var tokenResponse = await adapter.GetUserTokenAsync(turnContext, connectionName, null, CancellationToken.None); Assert.NotNull(tokenResponse); Assert.Equal(token, tokenResponse.Token); Assert.Equal(connectionName, tokenResponse.ConnectionName); var oAuthAppCredentials = MicrosoftAppCredentials.Empty; tokenResponse = await adapter.GetUserTokenAsync(turnContext, oAuthAppCredentials, connectionName, null, CancellationToken.None); Assert.NotNull(tokenResponse); Assert.Equal(token, tokenResponse.Token); Assert.Equal(connectionName, tokenResponse.ConnectionName); }
public async Task TestAdapter_SignOutNoop() { TestAdapter adapter = new TestAdapter(); string connectionName = "myConnection"; string channelId = "directline"; string userId = "testUser"; Activity activity = new Activity() { ChannelId = channelId, From = new ChannelAccount() { Id = userId, }, }; TurnContext turnContext = new TurnContext(adapter, activity); var oAuthAppCredentials = MicrosoftAppCredentials.Empty; await adapter.SignOutUserAsync(turnContext); await adapter.SignOutUserAsync(turnContext, connectionName); await adapter.SignOutUserAsync(turnContext, connectionName, userId); await adapter.SignOutUserAsync(turnContext, connectionName : null, userId); await adapter.SignOutUserAsync(turnContext, oAuthAppCredentials, connectionName, userId); }
public async Task TestAdapter_GetSignInLinkWithNoUserId() { TestAdapter adapter = new TestAdapter(); string connectionName = "myConnection"; string channelId = "directline"; string userId = "testUser"; Activity activity = new Activity() { ChannelId = channelId, From = new ChannelAccount() { Id = userId, }, }; TurnContext turnContext = new TurnContext(adapter, activity); var link = await adapter.GetOauthSignInLinkAsync(turnContext, connectionName, CancellationToken.None); Assert.NotNull(link); Assert.True(link.Length > 0); var oAuthAppCredentials = MicrosoftAppCredentials.Empty; link = await adapter.GetOauthSignInLinkAsync(turnContext, oAuthAppCredentials, connectionName, CancellationToken.None); Assert.NotNull(link); Assert.True(link.Length > 0); }
/// <summary> /// Adds a message (an activity) to the log associated with the given user. /// </summary> /// <param name="activity">The activity to add.</param> /// <param name="user">The user associated with the message.</param> public async Task AddMessageLog(Microsoft.Bot.Schema.Activity activity, ConversationReference user, bool replace = false) { if (_messageLogsTable != null) { // Add to AzureTable var body = new MessageLog(user); body.AddMessage(activity); var msg = new MessageLogEntity { PartitionKey = PartitionKey, RowKey = activity.Conversation.Id, Body = body.ToJson() }; if (!replace) { await AzureStorageHelper.InsertAsync(_messageLogsTable, msg); } else { await AzureStorageHelper.ReplaceAsync(_messageLogsTable, msg); } } else { // Add to InMemory storage } }
private void StatusBox_KeyUp(object sender, KeyEventArgs e) { this.StopAnyTTSPlayback(); if (e.Key != Key.Enter) { return; } e.Handled = true; if (this.connector == null) { this.InitSpeechConnector(); } var bfActivity = Activity.CreateMessageActivity(); bfActivity.Text = this.statusBox.Text; if (!string.IsNullOrEmpty(this.settings.RuntimeSettings.Profile.FromId)) { bfActivity.From = new ChannelAccount(this.settings.RuntimeSettings.Profile.FromId); } this.statusBox.Clear(); var jsonConnectorActivity = JsonConvert.SerializeObject(bfActivity); this.Messages.Add(new MessageDisplay(bfActivity.Text, Sender.User)); this.Activities.Add(new ActivityDisplay(jsonConnectorActivity, bfActivity, Sender.User)); string id = this.connector.SendActivityAsync(jsonConnectorActivity).Result; Debug.WriteLine($"SendActivityAsync called, id = {id}"); }
/// <summary> /// Validates an <see cref="Activity"/> according to an expected activity <see cref="TestScriptItem"/>. /// </summary> /// <param name="expectedActivity">The expected activity of type <see cref="TestScriptItem"/>.</param> /// <param name="actualActivity">The actual response <see cref="Activity"/> received.</param> /// <param name="cancellationToken">Optional. A <see cref="CancellationToken"/> that can be used by other objects /// or threads to receive notice of cancellation.</param> /// <returns>A task that represents the work queued to execute.</returns> protected virtual Task AssertActivityAsync(TestScriptItem expectedActivity, Activity actualActivity, CancellationToken cancellationToken = default) { var templateRegex = new Regex(@"\{\{[\w\s]*\}\}"); foreach (var assertion in expectedActivity.Assertions) { var template = templateRegex.Match(assertion); if (template.Success) { ValidateVariable(template.Value, actualActivity); } var(result, error) = Expression.Parse(assertion).TryEvaluate <bool>(actualActivity); if (!result) { throw new InvalidOperationException($"Assertion failed: {assertion}."); } if (error != null) { throw new InvalidOperationException(error); } } return(Task.CompletedTask); }
public async Task TestDateLogUpdateActivities() { if (StorageEmulatorHelper.CheckEmulator()) { ContainerInit(); var dateTimeStartOffset1 = new DateTimeOffset(DateTime.Now); var dateTimeStartOffset2 = new DateTimeOffset(DateTime.UtcNow); var conversation = TestAdapter.CreateConversation(Guid.NewGuid().ToString("n")); TestAdapter adapter = new TestAdapter(conversation) .Use(new TranscriptLoggerMiddleware(TranscriptStore)); Activity activityToUpdate = null; await new TestFlow(adapter, async(context, cancellationToken) => { if (context.Activity.Text == "update") { activityToUpdate.Text = "new response"; await context.UpdateActivityAsync(activityToUpdate); } else { var activity = context.Activity.CreateReply("response"); var response = await context.SendActivityAsync(activity); activity.Id = response.Id; // clone the activity, so we can use it to do an update activityToUpdate = JsonConvert.DeserializeObject <Activity>(JsonConvert.SerializeObject(activity)); } }) .Send("foo") .Send("update") .AssertReply("new response") .StartTestAsync(); await Task.Delay(5000); // Perform some queries var pagedResult = await TranscriptStore.GetTranscriptActivitiesAsync(conversation.ChannelId, conversation.Conversation.Id, null, dateTimeStartOffset1.DateTime); Assert.AreEqual(3, pagedResult.Items.Length); Assert.AreEqual("foo", pagedResult.Items[0].AsMessageActivity().Text); Assert.AreEqual("new response", pagedResult.Items[1].AsMessageActivity().Text); Assert.AreEqual("update", pagedResult.Items[2].AsMessageActivity().Text); // Perform some queries pagedResult = await TranscriptStore.GetTranscriptActivitiesAsync(conversation.ChannelId, conversation.Conversation.Id, null, DateTimeOffset.MinValue); Assert.AreEqual(3, pagedResult.Items.Length); Assert.AreEqual("foo", pagedResult.Items[0].AsMessageActivity().Text); Assert.AreEqual("new response", pagedResult.Items[1].AsMessageActivity().Text); Assert.AreEqual("update", pagedResult.Items[2].AsMessageActivity().Text); // Perform some queries pagedResult = await TranscriptStore.GetTranscriptActivitiesAsync(conversation.ChannelId, conversation.Conversation.Id, null, DateTimeOffset.MaxValue); Assert.AreEqual(0, pagedResult.Items.Length); } }
private void RunStreamingCrashTest(Action <WebSocket, TestWebSocketConnectionFeature.WebSocketChannel, WebSocketClient, CancellationTokenSource, CancellationTokenSource> induceCrash) { var logger = XUnitLogger.CreateLogger(_testOutput); var serverCts = new CancellationTokenSource(); var clientCts = new CancellationTokenSource(); using (var connection = new TestWebSocketConnectionFeature()) { var webSocket = connection.AcceptAsync().Result; var clientWebSocket = connection.Client; var bot = new StreamingTestBot((turnContext, cancellationToken) => Task.CompletedTask); var server = new CloudAdapter(new StreamingTestBotFrameworkAuthentication(), logger); var serverRunning = server.ProcessAsync(CreateWebSocketUpgradeRequest(webSocket), new Mock <HttpResponse>().Object, bot, serverCts.Token); var clientRequestHandler = new Mock <RequestHandler>(); clientRequestHandler .Setup(h => h.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), It.IsAny <ILogger <RequestHandler> >(), It.IsAny <object>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(StreamingResponse.OK())); using (var client = new WebSocketClient("wss://test", clientRequestHandler.Object, logger: logger)) { var clientRunning = client.ConnectInternalAsync(clientWebSocket, clientCts.Token); var activity = new Activity { Id = Guid.NewGuid().ToString("N"), Type = ActivityTypes.Message, From = new ChannelAccount { Id = "testUser" }, Conversation = new ConversationAccount { Id = Guid.NewGuid().ToString("N") }, Recipient = new ChannelAccount { Id = "testBot" }, ServiceUrl = "wss://InvalidServiceUrl/api/messages", ChannelId = "test", Text = "hi" }; var content = new StringContent(JsonConvert.SerializeObject(activity), Encoding.UTF8, "application/json"); var response = client.SendAsync(StreamingRequest.CreatePost("/api/messages", content)).Result; Assert.Equal(200, response.StatusCode); induceCrash(webSocket, clientWebSocket, client, serverCts, clientCts); clientRunning.Wait(); Assert.True(clientRunning.IsCompletedSuccessfully); } serverRunning.Wait(); Assert.True(serverRunning.IsCompletedSuccessfully); } }
private Microsoft.Bot.Schema.Activity CreateResponse(Microsoft.Bot.Schema.Activity activity, Attachment attachment) { var response = activity.CreateReply(); response.Attachments = new List <Attachment>() { attachment }; return(response); }
protected override async Task OnMembersAddedAsync(IList <ChannelAccount> membersAdded, ITurnContext <IConversationUpdateActivity> turnContext, CancellationToken cancellationToken) { foreach (var member in membersAdded) { if (member.Id != turnContext.Activity.Recipient.Id) { Activity reply = MostrarMenuInicial(); await turnContext.SendActivityAsync(reply, cancellationToken); } } }
private void ProcessActivity(BotActivity botActivity, int activitySeq) { if (botActivity.From.Id.StartsWith(_options.BotId, StringComparison.CurrentCultureIgnoreCase)) { botActivity.From.Role = RoleTypes.Bot; botActivity.Recipient = new BotChannelAccount(role: RoleTypes.User); _activityQueue.Add(activitySeq, botActivity); _logger.LogDebug($"{DateTime.Now} Added activity to queue (key is {activitySeq} activity ID is {botActivity.Id}. Activity queue length: {_activityQueue.Count} - Future activities queue length: {_futureQueue.Count}"); } }
/// <summary> /// Adds a message (an activity) to the log associated with the given user. /// </summary> /// <param name="activity">The activity to add.</param> /// <param name="user">The user associated with the message.</param> public void AddMessageLog(Microsoft.Bot.Schema.Activity activity, ConversationReference user) { if (_messageLogsTable != null) { // Add to AzureTable } else { // Add to InMemory storage } }
private async Task ExecuteTestScriptAsync(string callerName, CancellationToken cancellationToken, Dictionary <string, string> scriptParams = null) { _logger.LogInformation($"\n------ Starting test {callerName} ----------"); using var reader = new StreamReader(_testScriptPath); var plainTestScript = await reader.ReadToEndAsync().ConfigureAwait(false); if (scriptParams != null && scriptParams.Any()) { var replacement = string.Join("|", scriptParams.Keys.Select(k => $@"\$\{{\s?{k}\s?\}}").ToArray()); plainTestScript = Regex.Replace(plainTestScript, replacement, m => scriptParams[m.Value.Trim(new char[] { '$', '{', '}' })]); } var testScript = JsonConvert.DeserializeObject <TestScript>(plainTestScript); foreach (var scriptActivity in testScript.Items) { switch (scriptActivity.Role) { case RoleTypes.User: // Send the activity. var sendActivity = new Activity { Type = scriptActivity.Type, Text = scriptActivity.Text }; // Think time await Task.Delay(TimeSpan.FromMilliseconds(_thinkTime), cancellationToken).ConfigureAwait(false); await SendActivityAsync(sendActivity, cancellationToken).ConfigureAwait(false); break; case RoleTypes.Bot: if (IgnoreScriptActivity(scriptActivity)) { break; } var nextReply = await GetNextReplyAsync(cancellationToken).ConfigureAwait(false); await AssertActivityAsync(scriptActivity, nextReply, cancellationToken).ConfigureAwait(false); break; default: throw new InvalidOperationException($"Invalid script activity type {scriptActivity.Role}."); } } _logger.LogInformation($"======== Finished running script: {Stopwatch.Elapsed} =============\n"); }
private void ShowException(Exception e) { this.RunOnUiThread(() => { Debug.WriteLine(e); this.Messages.Add(new MessageDisplay($"App Error (see log for details): {Environment.NewLine} {e.Source} : {e.Message}", Sender.Channel)); var trace = new Microsoft.Bot.Schema.Activity { Type = "Exception", Value = e, }; this.Activities.Add(new ActivityDisplay(JsonConvert.SerializeObject(trace), trace, Sender.Channel)); }); }
public async Task TestAdapter_GetUserTokenAsyncReturnsTokenWithMagicCode() { TestAdapter adapter = new TestAdapter(); string connectionName = "myConnection"; string channelId = "directline"; string userId = "testUser"; string token = "abc123"; string magicCode = "888999"; Activity activity = new Activity() { ChannelId = channelId, From = new ChannelAccount() { Id = userId, }, }; TurnContext turnContext = new TurnContext(adapter, activity); adapter.AddUserToken(connectionName, channelId, userId, token, magicCode); // First it's null var tokenResponse = await adapter.GetUserTokenAsync(turnContext, connectionName, null, CancellationToken.None); Assert.Null(tokenResponse); // Can be retrieved with magic code tokenResponse = await adapter.GetUserTokenAsync(turnContext, connectionName, magicCode, CancellationToken.None); Assert.NotNull(tokenResponse); Assert.Equal(token, tokenResponse.Token); Assert.Equal(connectionName, tokenResponse.ConnectionName); // Then can be retrieved without magic code tokenResponse = await adapter.GetUserTokenAsync(turnContext, connectionName, null, CancellationToken.None); Assert.NotNull(tokenResponse); Assert.Equal(token, tokenResponse.Token); Assert.Equal(connectionName, tokenResponse.ConnectionName); // Then can be retrieved using customized AppCredentials var oAuthAppCredentials = MicrosoftAppCredentials.Empty; tokenResponse = await adapter.GetUserTokenAsync(turnContext, oAuthAppCredentials, connectionName, null, CancellationToken.None); Assert.NotNull(tokenResponse); Assert.Equal(token, tokenResponse.Token); Assert.Equal(connectionName, tokenResponse.ConnectionName); }
public static ConversationReference GetConversationReference(Microsoft.Bot.Schema.Activity activity) { BotAssert.ActivityNotNull(activity); ConversationReference r = new ConversationReference { ActivityId = activity.Id, User = activity.From, Bot = activity.Recipient, Conversation = activity.Conversation, ChannelId = activity.ChannelId, ServiceUrl = activity.ServiceUrl }; return(r); }
public async Task LogActivities() { if (StorageEmulatorHelper.CheckEmulator()) { ContainerInit(); var conversation = TestAdapter.CreateConversation(Guid.NewGuid().ToString("n")); TestAdapter adapter = new TestAdapter(conversation) .Use(new TranscriptLoggerMiddleware(TranscriptStore)); await new TestFlow(adapter, async(context, cancellationToken) => { var typingActivity = new Activity { Type = ActivityTypes.Typing, RelatesTo = context.Activity.RelatesTo }; await context.SendActivityAsync(typingActivity); await Task.Delay(500); await context.SendActivityAsync("echo:" + context.Activity.Text); }) .Send("foo") .AssertReply((activity) => Assert.AreEqual(activity.Type, ActivityTypes.Typing)) .AssertReply("echo:foo") .Send("bar") .AssertReply((activity) => Assert.AreEqual(activity.Type, ActivityTypes.Typing)) .AssertReply("echo:bar") .StartTestAsync(); await Task.Delay(1000); var pagedResult = await TranscriptStore.GetTranscriptActivitiesAsync(conversation.ChannelId, conversation.Conversation.Id); Assert.AreEqual(6, pagedResult.Items.Length); Assert.AreEqual("foo", pagedResult.Items[0].AsMessageActivity().Text); Assert.IsNotNull(pagedResult.Items[1].AsTypingActivity()); Assert.AreEqual("echo:foo", pagedResult.Items[2].AsMessageActivity().Text); Assert.AreEqual("bar", pagedResult.Items[3].AsMessageActivity().Text); Assert.IsNotNull(pagedResult.Items[4].AsTypingActivity()); Assert.AreEqual("echo:bar", pagedResult.Items[5].AsMessageActivity().Text); foreach (var activity in pagedResult.Items) { Assert.IsTrue(!string.IsNullOrWhiteSpace(activity.Id)); Assert.IsTrue(activity.Timestamp > default(DateTimeOffset)); } } }
/// <summary> /// Validates an <see cref="Activity"/> according to an expected activity <see cref="TestScriptItem"/>. /// </summary> /// <param name="expectedActivity">The expected activity of type <see cref="TestScriptItem"/>.</param> /// <param name="actualActivity">The actual response <see cref="Activity"/> received.</param> /// <param name="cancellationToken">Optional. A <see cref="CancellationToken"/> that can be used by other objects /// or threads to receive notice of cancellation.</param> /// <returns>A task that represents the work queued to execute.</returns> protected virtual Task AssertActivityAsync(TestScriptItem expectedActivity, Activity actualActivity, CancellationToken cancellationToken = default) { foreach (var assertion in expectedActivity.Assertions) { var(result, error) = Expression.Parse(assertion).TryEvaluate <bool>(actualActivity); if (!result) { throw new Exception($"Assertion failed: {assertion}."); } if (error != null) { throw new Exception(error); } } return(Task.CompletedTask); }
private async Task ExecuteTestScriptAsync(string callerName, CancellationToken cancellationToken) { _logger.LogInformation($"\n------ Starting test {callerName} ----------"); using var reader = new StreamReader(_testScriptPath); var testScript = JsonConvert.DeserializeObject <TestScript>(await reader.ReadToEndAsync().ConfigureAwait(false)); foreach (var scriptActivity in testScript.Items) { switch (scriptActivity.Role) { case RoleTypes.User: // Send the activity. var sendActivity = new Activity { Type = scriptActivity.Type, Text = scriptActivity.Text }; await SendActivityAsync(sendActivity, cancellationToken).ConfigureAwait(false); break; case RoleTypes.Bot: if (IgnoreScriptActivity(scriptActivity)) { break; } var nextReply = await GetNextReplyAsync(cancellationToken).ConfigureAwait(false); await AssertActivityAsync(scriptActivity, nextReply, cancellationToken).ConfigureAwait(false); break; default: throw new InvalidOperationException($"Invalid script activity type {scriptActivity.Role}."); } } _logger.LogInformation($"======== Finished running script: {Stopwatch.Elapsed} =============\n"); }
public async Task LogUpdateActivities() { if (CheckEmulator()) { var conversation = TestAdapter.CreateConversation(Guid.NewGuid().ToString("n")); TestAdapter adapter = new TestAdapter(conversation) .Use(new TranscriptLoggerMiddleware(TranscriptStore)); Activity activityToUpdate = null; await new TestFlow(adapter, async(context, cancellationToken) => { if (context.Activity.Text == "update") { activityToUpdate.Text = "new response"; await context.UpdateActivityAsync(activityToUpdate); } else { var activity = context.Activity.CreateReply("response"); var response = await context.SendActivityAsync(activity); activity.Id = response.Id; // clone the activity, so we can use it to do an update activityToUpdate = JsonConvert.DeserializeObject <Activity>(JsonConvert.SerializeObject(activity)); } }) .Send("foo") .Send("update") .AssertReply("new response") .StartTestAsync(); await Task.Delay(1000); var pagedResult = await TranscriptStore.GetTranscriptActivitiesAsync(conversation.ChannelId, conversation.Conversation.Id); Assert.AreEqual(3, pagedResult.Items.Length); Assert.AreEqual("foo", pagedResult.Items[0].AsMessageActivity().Text); Assert.AreEqual("new response", pagedResult.Items[1].AsMessageActivity().Text); Assert.AreEqual("update", pagedResult.Items[2].AsMessageActivity().Text); } }
public async Task TestAdapter_GetUserTokenAsyncReturnsNullWithCode() { TestAdapter adapter = new TestAdapter(); Activity activity = new Activity() { ChannelId = "directline", From = new ChannelAccount() { Id = "testUser", }, }; TurnContext turnContext = new TurnContext(adapter, activity); var token = await adapter.GetUserTokenAsync(turnContext, "myConnection", "abc123", CancellationToken.None); Assert.Null(token); var oAuthAppCredentials = MicrosoftAppCredentials.Empty; token = await adapter.GetUserTokenAsync(turnContext, oAuthAppCredentials, "myConnection", "abc123", CancellationToken.None); Assert.Null(token); }
/// <summary> /// Validates the variable date in the bots message with the value between double curly braces. /// </summary> /// <param name="value">The assertion containing the variable.</param> /// <param name="actualActivity">The activity with the message containing the date.</param> protected void ValidateVariable(string value, Activity actualActivity) { var dateRegex = new Regex(@"(\d{1,4}([.\-/])\d{1,2}([.\-/])\d{1,4})"); var wordRegex = new Regex(@"[\w]+"); var dateMatch = dateRegex.Match(actualActivity.Text); var resultExpression = string.Empty; var expectedExpression = wordRegex.Match(value).Value; var dateValue = string.Empty; if (dateMatch.Success) { dateValue = dateMatch.Value; var date = Convert.ToDateTime(dateMatch.Value, CultureInfo.InvariantCulture); resultExpression = EvaluateDate(date); } if (resultExpression != expectedExpression) { throw new InvalidOperationException($"Assertion failed. The variable '{expectedExpression}' does not match with the value {dateValue}."); } actualActivity.Text = actualActivity.Text.Replace(dateMatch.Value, value); }
public override Task <SignInResource> GetSignInResourceAsync(string connectionName, Activity activity, string finalRedirect, CancellationToken cancellationToken) { return(Task.FromResult(new SignInResource())); }
public override Task <AuthenticateRequestResult> AuthenticateRequestAsync(Activity activity, string authHeader, CancellationToken cancellationToken) { throw new NotImplementedException(); }
public override Task <ResourceResponse> UpdateActivityAsync(ITurnContext turnContext, Schema.Activity activity, CancellationToken cancellationToken) { throw new NotSupportedException("Github API doesn't support UpdateActivity semantics, use ((GithubAdapter)turncontext.Adapter).Client to make API calls."); }