public void SerializeWritesMetricsAsExpectedByEndpoint()
{
ExceptionTelemetry expected = CreateExceptionTelemetry();
expected.Metrics.Add("TestMetric", 4.2);
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, DataPlatformModel.ExceptionData>(expected);
Assert.Equal(expected.Metrics.ToArray(), item.Data.BaseData.Measurements.ToArray());
}
public void SerializeWritesNullValuesAsExpectedByEndpoint()
{
ExceptionTelemetry original = new ExceptionTelemetry();
original.Exception = null;
original.SeverityLevel = null;
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, DataPlatformModel.ExceptionData>(original);
Assert.Equal(2, item.Data.BaseData.Ver);
}
public void SerializeWritesInnerExceptionAsAdditionalItemInExceptionsArrayExpectedByEndpoint()
{
var innerException = new Exception("Inner Message");
var exception = new Exception("Root Message", innerException);
ExceptionTelemetry expected = CreateExceptionTelemetry(exception);
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, DataPlatformModel.ExceptionData>(expected);
Assert.Equal(innerException.Message, item.Data.BaseData.Exceptions[1].Message);
}
public void SerializeWritesNullValuesAsExpectedByEndpoint()
{
EventTelemetry original = new EventTelemetry();
original.Name = null;
((ITelemetry)original).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <AI.EventData>(original);
Assert.AreEqual(2, item.data.baseData.ver);
}
public void SerializeWritesNullValuesAsExpectedByEndpoint()
{
EventTelemetry original = new EventTelemetry();
original.Name = null;
((ITelemetry)original).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <EventTelemetry, DataPlatformModel.EventData>(original);
Assert.Equal(2, item.Data.BaseData.Ver);
}
public void DependencyTelemetryHasCorrectValueOfSamplingPercentageAfterSerialization()
{
var telemetry = this.CreateRemoteDependencyTelemetry("mycommand");
((ISupportSampling)telemetry).SamplingPercentage = 10;
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <AI.RemoteDependencyData>(telemetry);
Assert.AreEqual(10, item.sampleRate);
}
public void EventTelemetryHasCorrectValueOfSamplingPercentageAfterSerialization()
{
var telemetry = new EventTelemetry("my event");
((ISupportSampling)telemetry).SamplingPercentage = 10;
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <AI.EventData>(telemetry);
Assert.AreEqual(10, item.sampleRate);
}
public void SerializeWritesMetricsAsExpectedByEndpoint()
{
ExceptionTelemetry expected = CreateExceptionTelemetry();
expected.Metrics.Add("TestMetric", 4.2);
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <AI.ExceptionData>(expected);
AssertEx.AreEqual(expected.Metrics.ToArray(), item.data.baseData.measurements.ToArray());
}
public void PageViewPerformanceTelemetryHasCorrectValueOfSamplingPercentageAfterSerialization()
{
var telemetry = new PageViewPerformanceTelemetry("my page view");
((ISupportSampling)telemetry).SamplingPercentage = 10;
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <AI.PageViewPerfData>(telemetry);
Assert.AreEqual(10, item.sampleRate);
}
public void SerializeWritesStateAsExpectedByEndpoint()
{
var telemetry = new SessionStateTelemetry {
State = SessionState.End
};
TelemetryItem <EventData> envelope = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <SessionStateTelemetry, EventData>(telemetry);
Assert.AreEqual("Session ended", envelope.data.baseData.name);
Assert.AreEqual(2, envelope.data.baseData.ver);
}
public void SerializeWritesNullValuesAsExpectedByEndpoint()
{
ExceptionTelemetry original = new ExceptionTelemetry();
original.Exception = null;
original.SeverityLevel = null;
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <AI.ExceptionData>(original);
Assert.AreEqual(2, item.data.baseData.ver);
}
public void ExceptionTelemetryHasCorrectValueOfSamplingPercentageAfterSerialization()
{
var telemetry = new ExceptionTelemetry();
((ISupportSampling)telemetry).SamplingPercentage = 10;
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, AI.ExceptionData>(telemetry);
Assert.Equal(10, item.sampleRate);
}
public void SerializeWritesPropertiesAsExpectedByEndpoint()
{
ExceptionTelemetry expected = CreateExceptionTelemetry();
expected.Properties.Add("TestProperty", "TestValue");
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, AI.ExceptionData>(expected);
Assert.Equal(expected.Properties.ToArray(), item.data.baseData.properties.ToArray());
}
public void SerializeWritesStateAsExpectedByEndpoint()
{
var telemetry = new SessionStateTelemetry {
State = SessionState.End
};
TelemetryItem <SessionStateData> envelope = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <SessionStateTelemetry, SessionStateData>(telemetry);
Assert.Equal(DataPlatformModel.SessionState.End, envelope.Data.BaseData.State);
Assert.Equal(2, envelope.Data.BaseData.Ver);
}
public void SerializeWritesInnerExceptionsOfAggregateExceptionAsAdditionalItemsInExceptionsArrayExpectedByEndpoint()
{
var exception = new AggregateException("Test Exception", new[] { new Exception(), new Exception() });
ExceptionTelemetry expected = CreateExceptionTelemetry(exception);
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, DataPlatformModel.ExceptionData>(expected);
Assert.Equal(exception.GetHashCode(), item.Data.BaseData.Exceptions[1].OuterId);
Assert.Equal(exception.GetHashCode(), item.Data.BaseData.Exceptions[2].OuterId);
}
public void SerializeWritesInnerExceptionWithOuterIdLinkingItToItsParentException()
{
var innerException = new Exception();
var exception = new Exception("Test Exception", innerException);
ExceptionTelemetry expected = CreateExceptionTelemetry(exception);
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, DataPlatformModel.ExceptionData>(expected);
Assert.Equal(exception.GetHashCode(), item.Data.BaseData.Exceptions[1].OuterId);
}
public void TraceTelemetryHasCorrectValueOfSamplingPercentageAfterSerialization()
{
var telemetry = new TraceTelemetry("my trace");
((ISupportSampling)telemetry).SamplingPercentage = 10;
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <TraceTelemetry, DataPlatformModel.MessageData>(telemetry);
Assert.Equal(10, item.SampleRate);
}
public void SerializeWritesPropertiesAsExpectedByEndpoint()
{
ExceptionTelemetry expected = CreateExceptionTelemetry();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <AI.ExceptionData>(expected);
// IExtension is currently flattened into the properties by serialization
Utils.CopyDictionary(((MyTestExtension)expected.Extension).SerializeIntoDictionary(), expected.Properties);
AssertEx.AreEqual(expected.Properties.ToArray(), item.data.baseData.properties.ToArray());
}
public void SerializePopulatesRequiredFieldsOfExceptionTelemetry()
{
var exceptionTelemetry = new ExceptionTelemetry();
exceptionTelemetry.Context.InstrumentationKey = Guid.NewGuid().ToString();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <AI.ExceptionData>(exceptionTelemetry);
Assert.AreEqual(2, item.data.baseData.ver);
Assert.IsNotNull(item.data.baseData.exceptions);
Assert.AreEqual(0, item.data.baseData.exceptions.Count); // constructor without parameters does not initialize exception object
}
public void SerializeUsesExceptionMessageForInnerExceptions()
{
Exception outerException = new ArgumentException("Outer", new Exception("Inner"));
ExceptionTelemetry original = CreateExceptionTelemetry(outerException);
original.Message = "Custom";
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <AI.ExceptionData>(original);
Assert.AreEqual("Custom", item.data.baseData.exceptions[0].message);
Assert.AreEqual("Inner", item.data.baseData.exceptions[1].message);
}
public void SerializeWritesNullValuesAsExpectedByEndpoint()
{
TraceTelemetry original = new TraceTelemetry();
original.Message = null;
original.SeverityLevel = null;
((ITelemetry)original).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <TraceTelemetry, AI.MessageData>(original);
Assert.Equal(2, item.data.baseData.ver);
}
public void MetricTelemetrySerializesStructuredIKeyCorrectlyPreservingCaseOfPrefix()
{
var metricTelemetry = new MetricTelemetry();
metricTelemetry.Context.InstrumentationKey = "AIC-" + Guid.NewGuid().ToString();
((ITelemetry)metricTelemetry).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <AI.MetricData>(metricTelemetry);
Assert.AreEqual(metricTelemetry.Context.InstrumentationKey, item.iKey);
}
public void SerializeWritesHasFullStackPropertyAsItIsExpectedByEndpoint()
{
using (var stringWriter = new StringWriter(CultureInfo.InvariantCulture))
{
var exception = CreateExceptionWithStackTrace();
ExceptionTelemetry expected = CreateExceptionTelemetry(exception);
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <AI.ExceptionData>(expected);
Assert.IsTrue(item.data.baseData.exceptions[0].hasFullStack);
}
}
public void SerializeWritesItemSeverityLevelAsExpectedByEndpoint()
{
var expected = new TraceTelemetry {
SeverityLevel = SeverityLevel.Information
};
((ITelemetry)expected).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <TraceTelemetry, AI.MessageData>(expected);
Assert.Equal(AI.SeverityLevel.Information, item.data.baseData.severityLevel.Value);
}
public void SerializeWritesNullValuesAsExpectedByEndpoint()
{
PerformanceCounterTelemetry original = new PerformanceCounterTelemetry();
original.CategoryName = null;
original.CounterName = null;
original.InstanceName = null;
((ITelemetry)original).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <PerformanceCounterTelemetry, AI.MetricData>(original);
Assert.Equal(2, item.data.baseData.ver);
}
public void SerializeWritesItemSeverityLevelAsExpectedByEndpoint()
{
var expected = new TraceTelemetry {
SeverityLevel = SeverityLevel.Information
};
((ITelemetry)expected).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <TraceTelemetry, DataPlatformModel.MessageData>(expected);
Assert.Equal(Developer.Analytics.DataCollection.Model.v2.SeverityLevel.Information, item.Data.BaseData.SeverityLevel.Value);
}
public void SerializeWritesNullValuesAsExpectedByEndpoint()
{
DependencyTelemetry original = new DependencyTelemetry();
original.Name = null;
original.Data = null;
original.Type = null;
original.Success = null;
((ITelemetry)original).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <DependencyTelemetry, AI.RemoteDependencyData>(original);
Assert.AreEqual(2, item.data.baseData.ver);
}
public void RequestTelemetryHasCorrectValueOfSamplingPercentageAfterSerialization()
{
var telemetry = new RequestTelemetry {
Id = null
};
((ISupportSampling)telemetry).SamplingPercentage = 10;
((ITelemetry)telemetry).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <AI.RequestData>(telemetry);
Assert.AreEqual(10, item.sampleRate);
}
public void SanitizePopulatesIdWithErrorBecauseItIsRequiredByEndpoint()
{
var telemetry = new RequestTelemetry {
Id = null
};
((ITelemetry)telemetry).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <AI.RequestData>(telemetry);
// RequestTelemetry.Id is deprecated and you cannot access it. Method above will validate that all required fields would be populated
// AssertEx.Contains("id", telemetry.Id, StringComparison.OrdinalIgnoreCase);
// AssertEx.Contains("required", telemetry.Id, StringComparison.OrdinalIgnoreCase);
}
public void SerializeWritesNullValuesAsExpectedByEndpoint()
{
MetricTelemetry original = new MetricTelemetry();
original.Name = null;
original.Max = null;
original.Min = null;
original.Count = null;
original.StandardDeviation = null;
((ITelemetry)original).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <AI.MetricData>(original);
Assert.AreEqual(2, item.data.baseData.ver);
}
