public void AsksTransmitterToApplyPoliciesWhenNetworkAvailabilityChanges()
{
bool policiesApplied = false;
var transmitter = new StubTransmitter();
transmitter.OnApplyPolicies = () =>
{
policiesApplied = true;
};
var network = new StubNetwork();
var policy = new NetworkAvailabilityTransmissionPolicy(network);
policy.Initialize(transmitter);
network.OnStatusChanged(EventArgs.Empty);
Assert.True(policiesApplied);
}
public void ReadingDeviceUniqueIdYieldsCorrectValue()
{
DeviceContextInitializer source = new DeviceContextInitializer();
var telemetryContext = new TelemetryContext();
Assert.Null(telemetryContext.Device.Id);
source.Initialize(telemetryContext);
string id = telemetryContext.Device.Id;
object uniqueId;
DeviceExtendedProperties.TryGetValue("DeviceUniqueId", out uniqueId);
using (SHA256 hasher = new SHA256Managed())
{
Assert.Equal(Convert.ToBase64String(hasher.ComputeHash((byte[])uniqueId)), id);
}
}
public void DoesNotAbortRequestThatWasSentSuccessfully()
{
AsyncTest.Run(async() =>
{
bool requestAborted = false;
var request = new StubWebRequest {
OnAbort = () => requestAborted = true
};
var transmission = new TestableTransmission(timeout: TimeSpan.FromMilliseconds(50));
transmission.OnCreateRequest = uri => request;
await transmission.SendAsync();
await TaskEx.Delay(50); // Let timout detector finish
Assert.False(requestAborted);
});
}
public void HandlesExceptionsThrownByNetworkWhenAddingAddressChangedEventHandler()
{
using (var listener = new TestEventListener())
{
const long AllKeywords = -1;
listener.EnableEvents(TelemetryChannelEventSource.Log, EventLevel.Warning, (EventKeywords)AllKeywords);
var exception = new SocketException();
var network = new StubNetwork {
OnAddAddressChangedEventHandler = handler => { throw exception; }
};
var policy = new NetworkAvailabilityTransmissionPolicy(network);
policy.Initialize(new StubTransmitter());
EventWrittenEventArgs error = listener.Messages.First(arg => arg.EventId == 38);
Assert.Contains(exception.Message, (string)error.Payload[0], StringComparison.CurrentCulture);
}
}
public void WaitsForAsynchronousFlushToCompleteAndAllowsItsExceptionsToBubbleUp()
{
var expectedException = new Exception();
var tcs = new TaskCompletionSource <object>();
tcs.SetException(expectedException);
var mockTelemetryBuffer = new Mock <TelemetryChannel.Implementation.TelemetryBuffer>();
mockTelemetryBuffer.Setup(x => x.FlushAsync()).Returns(tcs.Task);
var channel = new ServerTelemetryChannel {
TelemetryBuffer = mockTelemetryBuffer.Object
};
channel.Initialize(TelemetryConfiguration.CreateDefault());
var actualException = Assert.Throws <Exception>(() => channel.Flush());
Assert.Same(expectedException, actualException);
}
public void InitializeCallsTransmitterInitialize()
{
var transmitterInitialized = new ManualResetEvent(false);
var transmitter = new StubTransmitter();
transmitter.OnInitialize = () =>
{
transmitterInitialized.Set();
};
var channel = new ServerTelemetryChannel {
Transmitter = transmitter
};
var initializedConfiguration = new TelemetryConfiguration();
channel.Initialize(initializedConfiguration);
Assert.True(transmitterInitialized.WaitOne(1000));
}
public void DimensionValuesAreAccentSensitive()
{
using (var manager = new MetricManager())
{
var dimensionSet1 = new Dictionary <string, string>()
{
{ "Dim1", "Value1" }
};
var dimensionSet2 = new Dictionary <string, string>()
{
{ "Dim1", "Válue1" }
};
Metric metric = manager.CreateMetric("My metric", dimensionSet1);
Metric other = manager.CreateMetric("My metric", dimensionSet2);
Assert.False(metric.Equals(other));
}
}
public void ReturnsFalseIfProcessHasNoRightToWriteToFilesInApplicationFolder()
{
var file = new StubPlatformFile {
OnOpen = () => { throw new UnauthorizedAccessException(); }
};
var folder = new StubPlatformFolder {
OnCreateFile = name => file
};
var provider = new StubApplicationFolderProvider {
OnGetApplicationFolder = () => folder
};
var storage = new TransmissionStorage();
storage.Initialize(provider);
bool result = storage.Enqueue(() => new StubTransmission());
Assert.False(result);
}
public void AllTelemetryCapturedWhenProductionRateIsLow()
{
var sentTelemetry = new List <ITelemetry>();
int itemsProduced = 0;
using (var tc = new TelemetryConfiguration()
{
TelemetryChannel = new StubTelemetryChannel()
})
{
var chainBuilder = new TelemetryProcessorChainBuilder(tc);
// set up addaptive sampling that evaluates and changes sampling % frequently
chainBuilder
.UseAdaptiveSampling(
new SamplingPercentageEstimatorSettings()
{
EvaluationInterval = TimeSpan.FromSeconds(1),
SamplingPercentageDecreaseTimeout = TimeSpan.FromSeconds(2),
SamplingPercentageIncreaseTimeout = TimeSpan.FromSeconds(2),
},
this.TraceSamplingPercentageEvaluation)
.Use((next) => new StubTelemetryProcessor(next)
{
OnProcess = (t) => sentTelemetry.Add(t)
});
chainBuilder.Build();
const int productionFrequencyMs = 1000;
using (var productionTimer = new Timer(
(state) => { tc.TelemetryProcessors.Process(new RequestTelemetry()); itemsProduced++; },
null,
productionFrequencyMs,
productionFrequencyMs))
{
Thread.Sleep(25000);
}
}
Assert.Equal(itemsProduced, sentTelemetry.Count);
}
public void Save_TransferPayment_CorrectlySaved()
{
var accountRepositorySetup = new Mock <IAccountRepository>();
accountRepositorySetup.SetupGet(x => x.Data).Returns(new ObservableCollection <Account>());
var categoryDataAccessSetup = new Mock <IRepository <Category> >();
categoryDataAccessSetup.SetupGet(x => x.Data).Returns(new ObservableCollection <Category>());
var paymentDataAccessMock = new PaymentDataAccessMock();
var repository = new PaymentRepository(new PaymentDataAccessMock(),
new RecurringPaymentDataAccessMock(),
accountRepositorySetup.Object,
categoryDataAccessSetup.Object);
var account = new Account
{
Id = 2,
Name = "TestAccount"
};
var targetAccount = new Account
{
Id = 3,
Name = "targetAccount"
};
var payment = new Payment
{
ChargedAccount = account,
ChargedAccountId = 2,
TargetAccount = targetAccount,
TargetAccountId = 3,
Amount = 20,
Type = (int)PaymentType.Transfer
};
repository.Save(payment);
Assert.Same(payment, repository.Data[0]);
Assert.Equal((int)PaymentType.Transfer, repository.Data[0].Type);
}
public void CartService_TransformCart_WorksCorrect()
{
var cart = new Cart
{
Items = new List <CartItem> {
new CartItem {
ProductId = 1, Quantity = 4
}
}
};
var products = new PagedProductDto
{
Products = new List <ProductDto>
{
new ProductDto
{
Id = 1,
ImageUrl = "image.jpg",
Name = "Test",
Order = 0,
Price = 1.11m,
}
},
TotalCount = 1
};
var product_data_mock = new Mock <IProductData>();
product_data_mock.Setup(c => c.GetProducts(It.IsAny <ProductFilter>())).Returns(products);
var cart_store_mock = new Mock <ICartStore>();
cart_store_mock.Setup(c => c.Cart).Returns(cart);
var cart_service = new CookieCartService(product_data_mock.Object, cart_store_mock.Object);
var result = cart_service.TransformCart();
Assert.Equal(4, result.ItemsCount);
Assert.Equal(1.11m, result.Items.First().Key.Price);
}
public void FirstChanceExceptionStatisticsTelemetryModuleWillNotDimCapTheSameOperationName()
{
var metrics = new List <KeyValuePair <Metric, double> >();
StubMetricProcessor stub = new StubMetricProcessor()
{
OnTrack = (m, v) =>
{
metrics.Add(new KeyValuePair <Metric, double>(m, v));
}
};
this.configuration.TelemetryInitializers.Add(new StubTelemetryInitializer()
{
OnInitialize = (item) =>
{
item.Context.Operation.Name = TestOperationName;
}
});
using (var module = new FirstChanceExceptionStatisticsTelemetryModule())
{
module.Initialize(this.configuration);
module.MetricManager.MetricProcessors.Add(stub);
for (int i = 0; i < 200; i++)
{
try
{
// FirstChanceExceptionStatisticsTelemetryModule will process this exception
throw new Exception("test");
}
catch (Exception exc)
{
// code to prevent profiler optimizations
Assert.Equal("test", exc.Message);
}
}
}
Assert.Equal(200, metrics.Count);
Assert.Equal(2, this.items.Count);
}
private void TestRequestTrackingWithW3CSupportEnabled(bool startActivity, bool addRequestId)
{
var headers = new Dictionary <string, string>
{
["traceparent"] = "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
["tracestate"] = "state=some",
["Correlation-Context"] = "k=v"
};
if (addRequestId)
{
headers.Add("Request-Id", "|abc.1.2.3.");
}
var context = HttpModuleHelper.GetFakeHttpContext(headers);
var module = this.RequestTrackingTelemetryModuleFactory(this.CreateDefaultConfig(context), enableW3CTracing: true);
if (startActivity)
{
var activity = new Activity("operation");
activity.Start();
}
module.OnBeginRequest(context);
var activityInitializedByW3CHeader = Activity.Current;
Assert.Equal("4bf92f3577b34da6a3ce929d0e0e4736", activityInitializedByW3CHeader.GetTraceId());
Assert.Equal("00f067aa0ba902b7", activityInitializedByW3CHeader.GetParentSpanId());
Assert.Equal(16, activityInitializedByW3CHeader.GetSpanId().Length);
Assert.Equal("state=some", activityInitializedByW3CHeader.GetTracestate());
Assert.Equal("v", activityInitializedByW3CHeader.Baggage.Single(t => t.Key == "k").Value);
var requestTelemetry = context.GetRequestTelemetry();
module.OnEndRequest(context);
Assert.Equal($"|4bf92f3577b34da6a3ce929d0e0e4736.{activityInitializedByW3CHeader.GetSpanId()}.", requestTelemetry.Id);
Assert.Equal("4bf92f3577b34da6a3ce929d0e0e4736", requestTelemetry.Context.Operation.Id);
Assert.Equal("|4bf92f3577b34da6a3ce929d0e0e4736.00f067aa0ba902b7.", requestTelemetry.Context.Operation.ParentId);
Assert.Equal("state=some", requestTelemetry.Properties[W3CConstants.TracestateTag]);
}
public void CheckOut_ModelState_Invalid_Returns_ViewModel()
{
var cart_service_mock = new Mock <ICartService>();
var order_service_mock = new Mock <IOrderService>();
var controller = new CartController(cart_service_mock.Object, order_service_mock.Object);
controller.ModelState.AddModelError("error", "InvalidModel");
const string expected_model_name = "Test order";
var result = controller.CheckOut(new OrderViewModel {
Name = expected_model_name
}, order_service_mock.Object);
var view_result = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <DetailsViewModel>(view_result.Model);
Assert.Equal(expected_model_name, model.OrderViewModel.Name);
}
public void DisposesHttpWebResponseToReleaseResources()
{
AsyncTest.Run(async() =>
{
bool responseDisposed = false;
var response = new StubWebResponse {
OnDispose = () => responseDisposed = true
};
var request = new StubWebRequest {
OnEndGetResponse = asyncResult => response
};
var transmission = new TestableTransmission {
OnCreateRequest = uri => request
};
await transmission.SendAsync();
Assert.True(responseDisposed);
});
}
public void AzureRoleEnvironmentTelemetryInitializerSetsTelemetryContextPropertiesWhenRoleEnvironmentIsAvailable()
{
var telemetryItem = new EventTelemetry();
var initializer = new AzureRoleEnvironmentTelemetryInitializer();
AzureRoleEnvironmentContextReader.BaseDirectory = ServiceRuntimeHelper.TestWithServiceRuntimePath;
AzureRoleEnvironmentContextReader.Instance = null;
ServiceRuntimeHelper.IsAvailable = true;
initializer.Initialize(telemetryItem);
string expectedRoleInstanceName = string.Format(
CultureInfo.InvariantCulture,
TestRoleInstance.IdFormat,
ServiceRuntimeHelper.RoleName,
ServiceRuntimeHelper.RoleInstanceOrdinal);
Assert.Equal(ServiceRuntimeHelper.RoleName, telemetryItem.Context.Cloud.RoleName);
Assert.Equal(expectedRoleInstanceName, telemetryItem.Context.Cloud.RoleInstance);
}
public void TransmissionProcessorTransmitsAllDataWhenNoOtherProcessorPresent()
{
var sentTelemetry = new List <ITelemetry>();
var channel = new StubTelemetryChannel {
OnSend = t => sentTelemetry.Add(t)
};
var configuration = new TelemetryConfiguration("Test key", channel);
var client = new TelemetryClient(configuration);
var transmissionProcessor = new TransmissionProcessor(configuration);
const int ItemsToGenerate = 100;
for (int i = 0; i < ItemsToGenerate; i++)
{
transmissionProcessor.Process(new RequestTelemetry());
}
Assert.Equal(ItemsToGenerate, sentTelemetry.Count);
}
public void ActiveUsesTelemetryConfigurationFactoryToInitializeTheInstance()
{
bool factoryInvoked = false;
TelemetryConfigurationFactory.Instance = new StubTelemetryConfigurationFactory
{
OnInitialize = (configuration, _) => { factoryInvoked = true; },
};
TelemetryConfiguration.Active = null;
try
{
var dummy = TelemetryConfiguration.Active;
Assert.True(factoryInvoked);
}
finally
{
TelemetryConfigurationFactory.Instance = null;
TelemetryConfiguration.Active = null;
}
}
public void AzureWebAppRoleEnvironmentTelemetryInitializerSetsRoleName()
{
var telemetryItem = new EventTelemetry();
var testVarName = "WEBSITE_" + Guid.NewGuid().ToString() + "_HOSTNAME";
Environment.SetEnvironmentVariable(testVarName, "TestRoleName.azurewebsites.net");
var initializer = new AzureWebAppRoleEnvironmentTelemetryInitializer()
{
WebAppHostNameEnvironmentVariable = testVarName
};
initializer.Initialize(telemetryItem);
Assert.Equal("TestRoleName", telemetryItem.Context.Cloud.RoleName);
Assert.Equal("TestRoleName.azurewebsites.net", telemetryItem.Context.GetInternalContext().NodeName);
Environment.SetEnvironmentVariable(testVarName, null);
}
public void Cart_Class_ItemsCount_returns_Correct_Quantity()
{
var cart = new Cart
{
Items = new List <CartItem>
{
new CartItem {
ProductId = 1, Quantity = 1
},
new CartItem {
ProductId = 2, Quantity = 3
},
}
};
const int expected_count = 4;
var actual_count = cart.ItemsCount;
Assert.Equal(expected_count, actual_count);
}
public void RetriesFailedTransmissionIfItsNumberOfAttemptsDidNotReachMaximum()
{
Transmission enqueuedTransmission = null;
var transmitter = new StubTransmitter();
transmitter.OnEnqueue = transmission =>
{
enqueuedTransmission = transmission;
};
var policy = new ErrorHandlingTransmissionPolicy();
policy.Initialize(transmitter);
var failedTransmission = new StubTransmission();
transmitter.OnTransmissionSent(new TransmissionProcessedEventArgs(failedTransmission, CreateException(statusCode: 408)));
Assert.Same(failedTransmission, enqueuedTransmission);
}
public void InitializeTelemetryProcessorFromConfigurationFileWhenEmptyTelemetryProcessorsTagSpecified()
{
// no TelemetryProcessors - TransmissionProcessor should be automatically created.
string configFileContents = Configuration(
@"
<TelemetryInitializers>
<Add Type=""" + typeof(StubTelemetryInitializer).AssemblyQualifiedName + @""" />
</TelemetryInitializers>
<TelemetryProcessors>
</TelemetryProcessors>"
);
TelemetryConfiguration configuration = new TelemetryConfiguration();
new TestableTelemetryConfigurationFactory().Initialize(configuration, null, configFileContents);
// Assume that LoadFromXml method is called, tested separately
Assert.True(configuration.TelemetryProcessors != null);
Assert.IsType <TransmissionProcessor>(configuration.TelemetryProcessorChain.FirstTelemetryProcessor);
}
public void HandlesExceptionsThrownByNetworkIsAvailable()
{
using (var listener = new TestEventListener())
{
const long AllKeywords = -1;
listener.EnableEvents(TelemetryChannelEventSource.Log, EventLevel.Warning, (EventKeywords)AllKeywords);
var exception = new SocketException();
var network = new StubNetwork {
OnIsAvailable = () => { throw exception; }
};
var policy = new NetworkAvailabilityTransmissionPolicy(network);
policy.Initialize(new StubTransmitter());
network.OnStatusChanged(EventArgs.Empty);
EventWrittenEventArgs error = listener.Messages.First();
Assert.Contains(exception.Message, (string)error.Payload[0], StringComparison.Ordinal);
}
}
public void OnEndDoesNotOverrideSourceField()
{
// ARRANGE
Dictionary <string, string> headers = new Dictionary <string, string>();
headers.Add(RequestResponseHeaders.RequestContextHeader, TestApplicationId1);
var context = HttpModuleHelper.GetFakeHttpContext(headers);
var module = this.RequestTrackingTelemetryModuleFactory();
module.OnBeginRequest(context);
context.GetRequestTelemetry().Source = TestApplicationId2;
// ACT
module.OnEndRequest(context);
// VALIDATE
Assert.Equal(TestApplicationId2, context.GetRequestTelemetry().Source);
}
public void CheckLevelCorrespondsToFrameForLongStack()
{
const int NumberOfStackFrames = 100;
var exp = this.CreateException(NumberOfStackFrames - 1);
ExceptionDetails expDetails = ExceptionConverter.ConvertToExceptionDetails(exp, null);
var stack = expDetails.parsedStack;
// Checking levels for first few and last few.
for (int i = 0; i < 10; ++i)
{
Assert.Equal(i, stack[i].level);
}
for (int j = NumberOfStackFrames - 1, i = 0; j > NumberOfStackFrames - 10; --j, i++)
{
Assert.Equal(j, stack[stack.Count - 1 - i].level);
}
}
public void Throw_thrown_ApplicationException2()
{
var controller = new HomeController();
const string expected_exception_message = "Test";
Exception actual_exception = null;
try
{
controller.Throw(expected_exception_message);
}
catch (Exception error)
{
actual_exception = error;
}
var app_exception = Assert.IsType <ApplicationException>(actual_exception);
Assert.Equal(expected_exception_message, app_exception.Message);
}
public void SerializesTelemetryIfBufferIsNotEmpty()
{
List <ITelemetry> serializedTelemetry = null;
var serializer = new StubTelemetrySerializer();
serializer.OnSerialize = telemetry =>
{
serializedTelemetry = new List <ITelemetry>(telemetry);
};
var telemetryBuffer = new TelemetryBuffer(serializer, new StubApplicationLifecycle());
var expectedTelemetry = new StubTelemetry();
telemetryBuffer.Process(expectedTelemetry);
telemetryBuffer.FlushAsync().GetAwaiter().GetResult();
Assert.Same(expectedTelemetry, serializedTelemetry.Single());
}
public void CartViewModel_Returns_Correct_ItemsCount()
{
var cart_view_model = new CartViewModel
{
Items = new Dictionary <ProductViewModel, int>
{
{ new ProductViewModel {
Id = 1, Name = "Product 1", Price = 0.5m
}, 1 },
{ new ProductViewModel {
Id = 2, Name = "Product 2", Price = 1.5m
}, 3 },
}
};
const int expected_count = 4;
var actual_count = cart_view_model.ItemsCount;
Assert.Equal(expected_count, actual_count);
}
public void PassesTransmissionToSenderAndReturnsTrue()
{
Transmission sentTransmission = null;
var sender = new StubTransmissionSender
{
OnEnqueue = getTransmission =>
{
sentTransmission = getTransmission();
return(sentTransmission != null);
},
};
Transmitter transmitter = CreateTransmitter(sender: sender);
var transmission = new StubTransmission();
transmitter.Enqueue(transmission);
Assert.Same(transmission, sentTransmission);
}
public void ResumesTransmissionSenderAfterPauseDuration()
{
var policyApplied = new AutoResetEvent(false);
var transmitter = new StubTransmitter(new TestableBackoffLogicManager(TimeSpan.FromMilliseconds(1)));
transmitter.OnApplyPolicies = () =>
{
policyApplied.Set();
};
var policy = new ErrorHandlingTransmissionPolicy();
policy.Initialize(transmitter);
transmitter.OnTransmissionSent(new TransmissionProcessedEventArgs(new StubTransmission(), CreateException(statusCode: 408)));
Assert.True(policyApplied.WaitOne(100));
Assert.True(policyApplied.WaitOne(100));
Assert.Null(policy.MaxSenderCapacity);
}
