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); }