public async void GIVENAnyMessageActivity_WHENGetSentimentIsInvoked_THENScoreIsBeingReturned(
ITextAnalyticsClient textAnalyticsClient,
IActivityAdapter activity,
double sentiment)
{
// Arrange
var instrumentation = new SentimentClient(textAnalyticsClient);
var response = new HttpOperationResponse <SentimentBatchResult>
{
Body = new SentimentBatchResult(new[] { new SentimentBatchResultItem(null, sentiment) }),
};
Mock.Get(textAnalyticsClient)
.Setup(tac => tac.SentimentWithHttpMessagesAsync(
It.IsAny <bool?>(),
It.IsAny <MultiLanguageBatchInput>(),
It.IsAny <Dictionary <string, List <string> > >(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(response));
// Act
var score = await instrumentation.GetSentiment(activity)
.ConfigureAwait(false);
// Assert
score.Should().Be(sentiment);
}
public static void TrackEvent(this IActivityAdapter activity, QueryResult queryResult, InstrumentationSettings settings, TelemetryClient telemetryClient)
{
if (activity is null)
{
throw new ArgumentNullException(nameof(activity));
}
if (queryResult is null)
{
throw new ArgumentNullException(nameof(queryResult));
}
if (telemetryClient is null)
{
throw new ArgumentNullException(nameof(telemetryClient));
}
var properties = new Dictionary <string, string>
{
{ QnAConstants.UserQuery, activity.MessageActivity.Text },
{ QnAConstants.KnowledgeBaseQuestion, queryResult.KnowledgeBaseQuestion },
{ QnAConstants.KnowledgeBaseAnswer, queryResult.KnowledgeBaseAnswer },
{ QnAConstants.Score, queryResult.Score },
};
activity.TrackCustomEvent(telemetryClient, settings, EventTypes.QnaEvent, properties);
}
public void GIVENEmptySettings_WHENEventTelemetryBuilderIsConstructed_THENExceptionIsBeingThrown(
IActivityAdapter activity)
{
// Arrange
const InstrumentationSettings emptySettings = null;
// Act
// Assert
Assert.Throws <ArgumentNullException>(() => new EventTelemetryBuilder(activity, emptySettings));
}
public void GIVENEmptyActivity_WHENTrackCustomEventIsInvoked_THENExceptionIsBeingThrown(
InstrumentationSettings settings)
{
// Arrange
const IActivityAdapter emptyActivity = null;
// Act
// Assert
Assert.Throws <ArgumentNullException>(() => emptyActivity.TrackCustomEvent(this.telemetryClient, settings));
}
public void GIVENEmptyActivity_WHENToSentimentInputIsInvoked_THENEmptySentimentInputIsBeingReturned()
{
// Arrange
const IActivityAdapter activity = null;
// Act
var actualResult = activity.ToSentimentInput();
// Assert
actualResult.Should().BeNull();
}
public async void GIVENEmptyActivity_WHENTrackMessageSentimentIsInvoked_THENExceptionIsBeingThrown(
ISentimentClient sentimentClient,
InstrumentationSettings settings)
{
// Arrange
const IActivityAdapter emptyActivity = null;
// Act
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(() => emptyActivity.TrackMessageSentiment(this.telemetryClient, settings, sentimentClient))
.ConfigureAwait(false);
}
public async void GIVENEmptyMessageActivity_WHENGetSentimentIsInvoked_THENExceptionIsBeingThrown(
ITextAnalyticsClient textAnalyticsClient)
{
// Arrange
var instrumentation = new SentimentClient(textAnalyticsClient);
const IActivityAdapter emptyMessageActivity = null;
// Act
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(() => instrumentation.GetSentiment(emptyMessageActivity))
.ConfigureAwait(false);
}
public void GIVENEmptyActivity_WHENIsIncomingMessageIsInvoked_THENFalseIsBeingReturned()
{
// Arrange
const IActivityAdapter activity = null;
const bool expectedResult = false;
// Act
var actualResult = activity.IsIncomingMessage();
// Assert
actualResult.Should().Be(expectedResult);
}
public void GIVENAnyActivity_WHENTrackCustomEventIsInvoked_THENEventTelemetryIsBeingSent(
IActivityAdapter activity,
InstrumentationSettings settings)
{
// Arrange
// Act
activity.TrackCustomEvent(this.telemetryClient, settings);
// Assert
this.mockTelemetryChannel.Verify(
tc => tc.Send(It.Is <EventTelemetry>(t =>
t.Name == EventTypes.CustomEvent)),
Times.Once);
}
public async void GIVENDisposedSentimentClient_WHENGetSentimentIsInvoked_THENExceptionIsBeingThrown(
ITextAnalyticsClient textAnalyticsClient,
IActivityAdapter activity)
{
// Arrange
var instrumentation = new SentimentClient(textAnalyticsClient);
instrumentation.Dispose();
// Act
// Assert
await Assert.ThrowsAsync <ObjectDisposedException>(() => instrumentation.GetSentiment(activity))
.ConfigureAwait(false);
}
public void GIVENAdditionalProperties_WHENBuildIsInvoked_THENEventTelemetryWithPropertiesIsBeingCreated(
IActivityAdapter activity,
InstrumentationSettings settings,
IDictionary <string, string> properties)
{
// Arrange
var builder = new EventTelemetryBuilder(activity, settings, properties);
// Act
var eventTelemetry = builder.Build();
// Assert
eventTelemetry.Properties.Should().HaveCountGreaterOrEqualTo(properties.Count);
eventTelemetry.Properties.Should().Contain(properties);
}
public static MultiLanguageBatchInput ToSentimentInput(this IActivityAdapter activity)
{
return(activity == null
? null
: new MultiLanguageBatchInput(
new List <MultiLanguageInput>
{
new MultiLanguageInput
{
// TODO: investigate the following Language = activity.Locale,
Id = "1",
Text = activity.MessageActivity.Text,
},
}));
}
public void GIVENActivity_WHENToSentimentInputIsInvoked_THENSentimentInputIsBeingReturned(
IActivityAdapter activity)
{
// Arrange
const int expectedNumberOfDocuments = 1;
const string expectedSentimentInputId = "1";
// Act
var actualResult = activity.ToSentimentInput();
// Assert
actualResult.Documents.Should().HaveCount(expectedNumberOfDocuments);
actualResult.Documents.Should().ContainSingle(i =>
i.Text == activity.MessageActivity.Text &&
i.Id == expectedSentimentInputId);
}
public static void TrackCustomEvent(this IActivityAdapter activity, TelemetryClient telemetryClient, InstrumentationSettings settings, string eventName = EventTypes.CustomEvent, IDictionary <string, string> properties = null)
{
if (telemetryClient is null)
{
throw new ArgumentNullException(nameof(telemetryClient));
}
var builder = new EventTelemetryBuilder(activity, settings, properties);
var eventTelemetry = builder.Build();
eventTelemetry.Name = string.IsNullOrWhiteSpace(eventName)
? EventTypes.CustomEvent
: eventName;
telemetryClient.TrackEvent(eventTelemetry);
}
public void GIVENAdditionalPropertyToReplaceOriginalOne_WHENBuildIsInvoked_THENEventTelemetryWithReplacedPropertyIsBeingCreated(
IActivityAdapter activity,
InstrumentationSettings settings,
string additionalPropertyValue)
{
// Arrange
var additionalProperties = new Dictionary <string, string> {
{ BotConstants.TypeProperty, additionalPropertyValue }
};
var builder = new EventTelemetryBuilder(activity, settings, additionalProperties);
// Act
var eventTelemetry = builder.Build();
// Assert
activity.Type.Should().NotBe(additionalPropertyValue);
eventTelemetry.Properties.Should().Contain(additionalProperties);
}
GIVENAnyActivityAnyResultAnAnyProperty_WHENTrackIntentIsInvoked_THENEventTelemetryIsBeingSent(
IActivityAdapter activity,
IntentResult result,
InstrumentationSettings settings)
{
// Arrange
// Act
activity.TrackIntent(result, this.telemetryClient, settings);
// Assert
this.mockTelemetryChannel.Verify(
tc => tc.Send(It.Is <EventTelemetry>(t =>
t.Name == EventTypes.Intent &&
t.Properties[IntentConstants.Intent] == result.Intent &&
t.Properties[IntentConstants.Score] == result.Score &&
t.Properties[IntentConstants.Entities] == result.Entities)),
Times.Once);
}
public async Task <double?> GetSentiment(IActivityAdapter activity)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
if (this.disposed)
{
throw new ObjectDisposedException(this.GetType().FullName);
}
MultiLanguageBatchInput input = activity.ToSentimentInput();
SentimentBatchResult result = await this.textAnalyticsClient.SentimentAsync(null, input)
.ConfigureAwait(false);
return(result?.Documents[0].Score);
}
public void GIVENAnyActivity_WHENTrackEventIsInvoked_THENEventTelemetryIsBeingSent(
IActivityAdapter activity,
QueryResult queryResult,
InstrumentationSettings settings)
{
// Arrange
// Act
activity.TrackEvent(queryResult, settings, this.telemetryClient);
// Assert
this.mockTelemetryChannel.Verify(
tc => tc.Send(It.Is <EventTelemetry>(t =>
t.Name == EventTypes.QnaEvent &&
t.Properties[QnAConstants.UserQuery] == activity.MessageActivity.Text &&
t.Properties[QnAConstants.KnowledgeBaseQuestion] == queryResult.KnowledgeBaseQuestion &&
t.Properties[QnAConstants.KnowledgeBaseAnswer] == queryResult.KnowledgeBaseAnswer &&
t.Properties[QnAConstants.Score] == queryResult.Score.ToString(CultureInfo.InvariantCulture))),
Times.Once);
}
public static void TrackIntent(this IActivityAdapter activity, IntentResult result, TelemetryClient telemetryClient, InstrumentationSettings settings)
{
if (result is null)
{
throw new ArgumentNullException(nameof(result));
}
if (telemetryClient is null)
{
throw new ArgumentNullException(nameof(telemetryClient));
}
var properties = new Dictionary <string, string>
{
{ IntentConstants.Intent, result.Intent },
{ IntentConstants.Score, result.Score },
{ IntentConstants.Entities, result.Entities },
};
activity.TrackCustomEvent(telemetryClient, settings, EventTypes.Intent, properties);
}
public static async Task TrackMessageSentiment(this IActivityAdapter activity, TelemetryClient telemetryClient, InstrumentationSettings settings, ISentimentClient sentimentClient)
{
if (telemetryClient is null)
{
throw new ArgumentNullException(nameof(telemetryClient));
}
if (sentimentClient is null)
{
throw new ArgumentNullException(nameof(sentimentClient));
}
var score = await sentimentClient.GetSentiment(activity)
.ConfigureAwait(false);
var properties = new Dictionary <string, string>
{
{ SentimentConstants.Score, score.Value.ToString(CultureInfo.InvariantCulture) },
};
activity.TrackCustomEvent(telemetryClient, settings, EventTypes.MessageSentiment, properties);
}
GIVENAnyActivityAnyEventNameAndAnyProperty_WHENTrackCustomEventIsInvoked_THENEventTelemetryIsBeingSent(
IActivityAdapter activity,
string eventName,
string propertyKey,
string propertyValue,
InstrumentationSettings settings)
{
// Arrange
var properties = new Dictionary <string, string> {
{ propertyKey, propertyValue }
};
// Act
activity.TrackCustomEvent(this.telemetryClient, settings, eventName, properties);
// Assert
this.mockTelemetryChannel.Verify(
tc => tc.Send(It.Is <EventTelemetry>(t =>
t.Name == eventName &&
t.Properties[propertyKey] == propertyValue)),
Times.Once);
}
public async void GIVENAnyActivity_WHENTrackMessageSentimentIsInvoked_THENEventTelemetryIsBeingSent(
double sentimentScore,
IActivityAdapter activity,
ISentimentClient sentimentClient,
InstrumentationSettings settings)
{
// Arrange
Mock.Get(sentimentClient)
.Setup(s => s.GetSentiment(activity))
.Returns(Task.FromResult <double?>(sentimentScore));
// Act
await activity.TrackMessageSentiment(this.telemetryClient, settings, sentimentClient)
.ConfigureAwait(false);
// Assert
this.mockTelemetryChannel.Verify(
tc => tc.Send(It.Is <EventTelemetry>(t =>
t.Name == EventTypes.MessageSentiment &&
t.Properties[SentimentConstants.Score] == sentimentScore.ToString(CultureInfo.InvariantCulture))),
Times.Once);
}
public static bool IsIncomingMessage(this IActivityAdapter activity)
{
return(activity?.Type == ActivityTypes.Message && activity?.ReplyToId == null);
}
public void SetActivityLog(IActivityLogOperations <TObject, TResult, TSearch> activityLogInstance, IActivityAdapter activityAdapterInstance)
{
business.SetEventLog(activityLogInstance, activityAdapterInstance);
}
public void SetActivityLog(IActivityLogOperations <TObject, TResult, TSearch, TKey> instance, IActivityAdapter adapter)
{
business.SetEventLog(instance, adapter);
}
public void SetActivityLog(IActivityLogOperations <TObject> activityInstance, IActivityAdapter activityAdapterInstance)
{
business.SetEventLog(activityInstance, activityAdapterInstance);
}
public EventTelemetryBuilder(IActivityAdapter activity, InstrumentationSettings settings, IEnumerable <KeyValuePair <string, string> > additionalProperties = null)
{
this.activity = activity ?? throw new ArgumentNullException(nameof(activity));
this.settings = settings ?? throw new ArgumentNullException(nameof(settings));
this.additionalProperties = additionalProperties ?? Enumerable.Empty <KeyValuePair <string, string> >();
}
