public async Task InterceptOnUpdate()
{
bool adapterCalled = false;
void ValidateUpdate(Activity activity)
{
adapterCalled = true;
Assert.Fail("Should not be called.");
}
SimpleAdapter a = new SimpleAdapter(ValidateUpdate);
TurnContext c = new TurnContext(a, new Activity());
bool wasCalled = false;
c.OnUpdateActivity(async(context, activity, next) =>
{
Assert.IsNotNull(activity, "Null activity passed in");
wasCalled = true;
// Do Not Call Next
return(null);
});
await c.UpdateActivity(TestMessage.Message());
Assert.IsTrue(wasCalled); // Interceptor was called
Assert.IsFalse(adapterCalled); // Adapter was not
}
public async Task InterceptAndMutateOnSend()
{
bool foundIt = false;
void ValidateResponses(Activity[] activities)
{
Assert.IsNotNull(activities);
Assert.IsTrue(activities.Length == 1);
Assert.IsTrue(activities[0].Id == "changed");
foundIt = true;
}
SimpleAdapter a = new SimpleAdapter(ValidateResponses);
TurnContext c = new TurnContext(a, new Activity());
c.OnSendActivities(async(context, activities, next) =>
{
Assert.IsNotNull(activities, "Null Array passed in");
Assert.IsTrue(activities.Count() == 1);
Assert.IsTrue(activities[0].Id == "1234", "Unknown Id Passed In");
activities[0].Id = "changed";
return(await next());
});
await c.SendActivity(TestMessage.Message());
// Intercepted the message, changed it, and sent it on to the Adapter
Assert.IsTrue(foundIt);
}
public async Task CallOnUpdateBeforeDelivery()
{
bool foundActivity = false;
void ValidateUpdate(Activity activity)
{
Assert.IsNotNull(activity);
Assert.IsTrue(activity.Id == "1234");
foundActivity = true;
}
SimpleAdapter a = new SimpleAdapter(ValidateUpdate);
TurnContext c = new TurnContext(a, new Activity());
bool wasCalled = false;
c.OnUpdateActivity(async(context, activity, next) =>
{
Assert.IsNotNull(activity, "Null activity passed in");
wasCalled = true;
return(await next());
});
await c.UpdateActivity(TestMessage.Message());
Assert.IsTrue(wasCalled);
Assert.IsTrue(foundActivity);
}
public async Task AllowInterceptionOfDeliveryOnSend()
{
bool responsesSent = false;
void ValidateResponses(Activity[] activities)
{
responsesSent = true;
Assert.Fail("Should not be called. Interceptor did not work");
}
SimpleAdapter a = new SimpleAdapter(ValidateResponses);
TurnContext c = new TurnContext(a, new Activity());
int count = 0;
c.OnSendActivities(async(context, activities, next) =>
{
Assert.IsNotNull(activities, "Null Array passed in");
count = activities.Count();
// Do not call next.
return(null);
});
await c.SendActivity(TestMessage.Message());
Assert.IsTrue(count == 1);
Assert.IsFalse(responsesSent, "Responses made it to the adapter.");
}
public async Task InterceptOnUpdate()
{
bool adapterCalled = false;
void ValidateUpdate(Activity activity)
{
adapterCalled = true;
Assert.True(false); // Should not be called
}
var a = new SimpleAdapter(ValidateUpdate);
var c = new TurnContext(a, new Activity());
bool wasCalled = false;
c.OnUpdateActivity((context, activity, next) =>
{
Assert.NotNull(activity); // Null activity passed in
wasCalled = true;
// Do Not Call Next
return(Task.FromResult <ResourceResponse>(null));
});
await c.UpdateActivityAsync(TestMessage.Message());
Assert.True(wasCalled); // Interceptor was called
Assert.False(adapterCalled); // Adapter was not
}
public async Task AllowInterceptionOfDeliveryOnSend()
{
bool responsesSent = false;
void ValidateResponses(Activity[] activities)
{
responsesSent = true;
Assert.True(false); // Should not be called. Interceptor did not work
}
var a = new SimpleAdapter(ValidateResponses);
var c = new TurnContext(a, new Activity());
int count = 0;
c.OnSendActivities((context, activities, next) =>
{
Assert.NotNull(activities); // Null Array passed in
count = activities.Count();
// Do not call next.
return(Task.FromResult <ResourceResponse[]>(null));
});
await c.SendActivityAsync(TestMessage.Message());
Assert.True(count == 1);
Assert.False(responsesSent, "Responses made it to the adapter.");
}
public async Task InterceptAndMutateOnUpdate()
{
bool adapterCalled = false;
void ValidateUpdate(Activity activity)
{
Assert.IsTrue(activity.Id == "mutated");
adapterCalled = true;
}
SimpleAdapter a = new SimpleAdapter(ValidateUpdate);
TurnContext c = new TurnContext(a, new Activity());
c.OnUpdateActivity(async(context, activity, next) =>
{
Assert.IsNotNull(activity, "Null activity passed in");
Assert.IsTrue(activity.Id == "1234");
activity.Id = "mutated";
return(await next());
});
await c.UpdateActivity(TestMessage.Message());
Assert.IsTrue(adapterCalled); // Adapter was not
}
public async Task SendAndSetResponded()
{
var a = new SimpleAdapter();
var c = new TurnContext(a, new Activity());
Assert.False(c.Responded);
var response = await c.SendActivityAsync(TestMessage.Message("testtest"));
Assert.True(c.Responded);
Assert.True(response.Id == "testtest");
}
public async Task SendAndSetRespondedUsingIMessageActivity()
{
var a = new SimpleAdapter();
var c = new TurnContext(a, new Activity());
Assert.False(c.Responded);
var msg = TestMessage.Message().AsMessageActivity();
await c.SendActivityAsync(msg);
Assert.True(c.Responded);
}
public async Task DeleteOneActivityToAdapter()
{
bool deleteCalled = false;
void ValidateDelete(ConversationReference r)
{
Assert.NotNull(r);
Assert.True(r.ActivityId == "12345");
deleteCalled = true;
}
var a = new SimpleAdapter(ValidateDelete);
var c = new TurnContext(a, TestMessage.Message());
await c.DeleteActivityAsync("12345");
Assert.True(deleteCalled);
}
public async Task SendOneActivityToAdapter()
{
bool foundActivity = false;
void ValidateResponses(Activity[] activities)
{
Assert.True(activities.Count() == 1, "Incorrect Count");
Assert.True(activities[0].Id == "1234");
foundActivity = true;
}
var a = new SimpleAdapter(ValidateResponses);
var c = new TurnContext(a, new Activity());
await c.SendActivityAsync(TestMessage.Message());
Assert.True(foundActivity);
}
public async Task SendBatchOfActivities()
{
var a = new SimpleAdapter();
var c = new TurnContext(a, new Activity());
Assert.False(c.Responded);
var message1 = TestMessage.Message("message1");
var message2 = TestMessage.Message("message2");
var response = await c.SendActivitiesAsync(new IActivity[] { message1, message2 });
Assert.True(c.Responded);
Assert.True(response.Length == 2);
Assert.True(response[0].Id == "message1");
Assert.True(response[1].Id == "message2");
}
public async Task CallOnSendBeforeDelivery()
{
var a = new SimpleAdapter();
var c = new TurnContext(a, new Activity());
int count = 0;
c.OnSendActivities(async(context, activities, next) =>
{
Assert.NotNull(activities); // Null Array passed in
count = activities.Count();
return(await next());
});
await c.SendActivityAsync(TestMessage.Message());
Assert.True(count == 1);
}
public async Task PassResourceResponsesThrough()
{
void ValidateResponses(Activity[] activities)
{
// no need to do anything.
}
var a = new SimpleAdapter(ValidateResponses);
var c = new TurnContext(a, new Activity());
var activityId = Guid.NewGuid().ToString();
var activity = TestMessage.Message();
activity.Id = activityId;
var resourceResponse = await c.SendActivityAsync(activity);
Assert.IsTrue(resourceResponse.Id == activityId, "Incorrect response Id returned");
}
public async Task TraceActivitiesDoNoSetResponded()
{
var a = new SimpleAdapter();
var c = new TurnContext(a, new Activity());
Assert.False(c.Responded);
// Send a Trace Activity, and make sure responded is NOT set.
var trace = Activity.CreateTraceActivity("trace");
await c.SendActivityAsync(trace);
Assert.False(c.Responded);
// Just to sanity check everything, send a Message and verify the
// responded flag IS set.
var msg = TestMessage.Message().AsMessageActivity();
await c.SendActivityAsync(msg);
Assert.True(c.Responded);
}
public async Task UpdateOneActivityToAdapter()
{
bool foundActivity = false;
void ValidateUpdate(Activity activity)
{
Assert.NotNull(activity);
Assert.True(activity.Id == "test");
foundActivity = true;
}
var a = new SimpleAdapter(ValidateUpdate);
var c = new TurnContext(a, new Activity());
var message = TestMessage.Message("test");
var updateResult = await c.UpdateActivityAsync(message);
Assert.True(foundActivity);
Assert.True(updateResult.Id == "test");
}
public async Task ThrowExceptionInOnSend()
{
SimpleAdapter a = new SimpleAdapter();
TurnContext c = new TurnContext(a, new Activity());
c.OnSendActivities(async(context, activities, next) =>
{
throw new Exception("test");
});
try
{
await c.SendActivity(TestMessage.Message());
Assert.Fail("Should not get here");
}
catch (Exception ex)
{
Assert.IsTrue(ex.Message == "test");
}
}
public async Task ThrowExceptionInOnSend()
{
var a = new SimpleAdapter();
var c = new TurnContext(a, new Activity());
c.OnSendActivities((context, activities, next) =>
{
throw new Exception("test");
});
try
{
await c.SendActivityAsync(TestMessage.Message());
Assert.True(false); // Should not get here
}
catch (Exception ex)
{
Assert.True(ex.Message == "test");
}
}
public async Task GetLocaleFromActivity()
{
void ValidateResponses(Activity[] activities)
{
// no need to do anything.
}
var a = new SimpleAdapter(ValidateResponses);
var c = new TurnContext(a, new Activity());
var activityId = Guid.NewGuid().ToString();
var activity = TestMessage.Message();
activity.Id = activityId;
activity.Locale = "de-DE";
Task SimpleCallback(ITurnContext turnContext, CancellationToken cancellationToken)
{
Assert.Equal("de-DE", ((TurnContext)turnContext).Locale);
return(Task.CompletedTask);
}
await a.ProcessRequest(activity, SimpleCallback, default(CancellationToken));
}
public async Task RequestIsSet()
{
TurnContext c = new TurnContext(new SimpleAdapter(), TestMessage.Message());
Assert.IsTrue(c.Activity.Id == "1234");
}
public void RequestIsSet()
{
var c = new TurnContext(new SimpleAdapter(), TestMessage.Message());
Assert.True(c.Activity.Id == "1234");
}