public void Authentication_UseMultiInterfaceStreamContent_Success() { RemoteInvoke(async useManagedHandlerString => { string username = "******"; string password = "******"; Uri uri = Configuration.Http.BasicAuthUriForCreds(secure: false, userName: username, password: password); HttpClientHandler handler = CreateHttpClientHandler(useManagedHandlerString); handler.Credentials = new NetworkCredential(username, password); using (var client = new HttpClient(handler)) { byte[] postData = Encoding.UTF8.GetBytes("This is data to post."); var stream = new MultiInterfaceReadOnlyStream(postData); var content = new MultiInterfaceStreamContent(stream); using (HttpResponseMessage response = await client.PostAsync(uri, content)) { Assert.Equal(HttpStatusCode.OK, response.StatusCode); string responseContent = await response.Content.ReadAsStringAsync(); } } return(SuccessExitCode); }, UseManagedHandler.ToString()).Dispose(); }
public void Authentication_UseStreamContent_Throws() { RemoteInvoke(async useManagedHandlerString => { // This test validates the current limitation of CoreFx's NetFxToWinRtStreamAdapter // which throws exceptions when trying to rewind a .NET Stream when it needs to be // re-POST'd to the server. string username = "******"; string password = "******"; Uri uri = Configuration.Http.BasicAuthUriForCreds(secure: false, userName: username, password: password); HttpClientHandler handler = CreateHttpClientHandler(useManagedHandlerString); handler.Credentials = new NetworkCredential(username, password); using (var client = new HttpClient(handler)) { byte[] postData = Encoding.UTF8.GetBytes("This is data to post."); var stream = new MemoryStream(postData, false); var content = new StreamContent(stream); await Assert.ThrowsAsync <HttpRequestException>(() => client.PostAsync(uri, content)); } return(SuccessExitCode); }, UseManagedHandler.ToString()).Dispose(); }
public void Manual_SendClientCertificateWithNoEKUToRemoteServer_OK() { if (!CanTestClientCertificates) // can't use [Conditional*] right now as it's evaluated at the wrong time for the managed handler { _output.WriteLine($"Skipping {nameof(Manual_SendClientCertificateWithNoEKUToRemoteServer_OK)}()"); return; } // UAP HTTP stack caches connections per-process. This causes interference when these tests run in // the same process as the other tests. Each test needs to be isolated to its own process. // See dicussion: https://github.com/dotnet/corefx/issues/21945 RemoteInvoke(async useManagedHandlerString => { var cert = Configuration.Certificates.GetNoEKUCertificate(); HttpClientHandler handler = CreateHttpClientHandler(useManagedHandlerString); handler.ClientCertificates.Add(cert); using (var client = new HttpClient(handler)) { HttpResponseMessage response = await client.GetAsync(Configuration.Http.EchoClientCertificateRemoteServer); Assert.Equal(HttpStatusCode.OK, response.StatusCode); string body = await response.Content.ReadAsStringAsync(); byte[] bytes = Convert.FromBase64String(body); var receivedCert = new X509Certificate2(bytes); Assert.Equal(cert, receivedCert); return(SuccessExitCode); } }, UseManagedHandler.ToString()).Dispose(); }
public void Manual_SendClientCertificateWithServerAuthEKUToRemoteServer_Forbidden() { if (UseManagedHandler) { // TODO #23128: The managed handler is currently sending out client certificates when it shouldn't. return; } if (!CanTestClientCertificates) // can't use [Conditional*] right now as it's evaluated at the wrong time for the managed handler { _output.WriteLine($"Skipping {nameof(Manual_SendClientCertificateWithServerAuthEKUToRemoteServer_Forbidden)}()"); return; } // UAP HTTP stack caches connections per-process. This causes interference when these tests run in // the same process as the other tests. Each test needs to be isolated to its own process. // See dicussion: https://github.com/dotnet/corefx/issues/21945 RemoteInvoke(async useManagedHandlerString => { var cert = Configuration.Certificates.GetServerCertificate(); HttpClientHandler handler = CreateHttpClientHandler(useManagedHandlerString); handler.ClientCertificates.Add(cert); using (var client = new HttpClient(handler)) { HttpResponseMessage response = await client.GetAsync(Configuration.Http.EchoClientCertificateRemoteServer); Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode); return(SuccessExitCode); } }, UseManagedHandler.ToString()).Dispose(); }
public async Task UseCallback_BadCertificate_ExpectedPolicyErrors(string url, SslPolicyErrors expectedErrors) { if (!BackendSupportsCustomCertificateHandlingAndClientSupportsDHECipherSuites) { return; } if (PlatformDetection.IsUap) { // UAP HTTP stack caches connections per-process. This causes interference when these tests run in // the same process as the other tests. Each test needs to be isolated to its own process. // See dicussion: https://github.com/dotnet/corefx/issues/21945 RemoteInvoke((remoteUrl, remoteExpectedErrors, useManagedHandlerString) => { UseCallback_BadCertificate_ExpectedPolicyErrors_Helper( remoteUrl, bool.Parse(useManagedHandlerString), (SslPolicyErrors)Enum.Parse(typeof(SslPolicyErrors), remoteExpectedErrors)).Wait(); return(SuccessExitCode); }, url, expectedErrors.ToString(), UseManagedHandler.ToString()).Dispose(); } else { await UseCallback_BadCertificate_ExpectedPolicyErrors_Helper(url, UseManagedHandler, expectedErrors); } }
public void ProxySetViaEnvironmentVariable_DefaultProxyCredentialsUsed(bool useProxy) { bool envVarsSupported = UseManagedHandler || !RuntimeInformation.IsOSPlatform(OSPlatform.Windows); if (!envVarsSupported) { return; } int port = 0; Task <LoopbackGetRequestHttpProxy.ProxyResult> proxyTask = null; if (useProxy) { proxyTask = LoopbackGetRequestHttpProxy.StartAsync(out port, requireAuth: true, expectCreds: true); } const string ExpectedUsername = "******"; const string ExpectedPassword = "******"; // libcurl will read a default proxy from the http_proxy environment variable. Ensure that when it does, // our default proxy credentials are used. To avoid messing up anything else in this process, we run the // test in another process. var psi = new ProcessStartInfo(); psi.Environment.Add("http_proxy", $"http://localhost:{port}"); RemoteInvoke((useProxyString, useManagedHandlerString) => { using (HttpClientHandler handler = CreateHttpClientHandler(useManagedHandlerString)) using (var client = new HttpClient(handler)) { var creds = new NetworkCredential(ExpectedUsername, ExpectedPassword); handler.DefaultProxyCredentials = creds; handler.UseProxy = bool.Parse(useProxyString); Task <HttpResponseMessage> responseTask = client.GetAsync(Configuration.Http.RemoteEchoServer); Task <string> responseStringTask = responseTask.ContinueWith(t => { using (t.Result) return(t.Result.Content.ReadAsStringAsync()); }, TaskScheduler.Default).Unwrap(); Task.WaitAll(responseTask, responseStringTask); TestHelper.VerifyResponseBody(responseStringTask.Result, responseTask.Result.Content.Headers.ContentMD5, false, null); } return(SuccessExitCode); }, useProxy.ToString(), UseManagedHandler.ToString(), new RemoteInvokeOptions { StartInfo = psi }).Dispose(); if (useProxy) { Assert.Equal($"{ExpectedUsername}:{ExpectedPassword}", proxyTask.Result.AuthenticationHeaderValue); } }
public void SendAsync_ExpectedDiagnosticSourceNoLogging() { RemoteInvoke(useManagedHandlerString => { bool requestLogged = false; bool responseLogged = false; bool activityStartLogged = false; bool activityStopLogged = false; var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp => { if (kvp.Key.Equals("System.Net.Http.Request")) { requestLogged = true; } else if (kvp.Key.Equals("System.Net.Http.Response")) { responseLogged = true; } else if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Start")) { activityStartLogged = true; } else if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Stop")) { activityStopLogged = true; } }); using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver)) { using (HttpClient client = CreateHttpClient(useManagedHandlerString)) { LoopbackServer.CreateServerAsync(async(server, url) => { Task <List <string> > requestLines = LoopbackServer.AcceptSocketAsync(server, (s, stream, reader, writer) => LoopbackServer.ReadWriteAcceptedAsync(s, reader, writer)); Task <HttpResponseMessage> response = client.GetAsync(url); await Task.WhenAll(response, requestLines); AssertNoHeadersAreInjected(requestLines.Result); response.Result.Dispose(); }).Wait(); } Assert.False(requestLogged, "Request was logged while logging disabled."); Assert.False(activityStartLogged, "HttpRequestOut.Start was logged while logging disabled."); WaitForFalse(() => responseLogged, TimeSpan.FromSeconds(1), "Response was logged while logging disabled."); Assert.False(activityStopLogged, "HttpRequestOut.Stop was logged while logging disabled."); } return(SuccessExitCode); }, UseManagedHandler.ToString()).Dispose(); }
public void SendAsync_ExpectedDiagnosticSourceNewAndDeprecatedEventsLogging() { RemoteInvoke(useManagedHandlerString => { bool requestLogged = false; bool responseLogged = false; bool activityStartLogged = false; bool activityStopLogged = false; var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp => { if (kvp.Key.Equals("System.Net.Http.Request")) { requestLogged = true; } else if (kvp.Key.Equals("System.Net.Http.Response")) { responseLogged = true; } else if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Start")) { activityStartLogged = true; } else if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Stop")) { activityStopLogged = true; } }); using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver)) { diagnosticListenerObserver.Enable(); using (HttpClient client = CreateHttpClient(useManagedHandlerString)) { client.GetAsync(Configuration.Http.RemoteEchoServer).Result.Dispose(); } Assert.True(activityStartLogged, "HttpRequestOut.Start was not logged."); Assert.True(requestLogged, "Request was not logged."); // Poll with a timeout since logging response is not synchronized with returning a response. WaitForTrue(() => activityStopLogged, TimeSpan.FromSeconds(1), "HttpRequestOut.Stop was not logged within 1 second timeout."); Assert.True(responseLogged, "Response was not logged."); diagnosticListenerObserver.Disable(); } return(SuccessExitCode); }, UseManagedHandler.ToString()).Dispose(); }
public void SendAsync_ExpectedDiagnosticSourceUrlFilteredActivityLogging() { RemoteInvoke(useManagedHandlerString => { bool activityStartLogged = false; bool activityStopLogged = false; var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp => { if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Start")) { activityStartLogged = true; } else if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Stop")) { activityStopLogged = true; } }); using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver)) { diagnosticListenerObserver.Enable((s, r, _) => { if (s.StartsWith("System.Net.Http.HttpRequestOut")) { var request = r as HttpRequestMessage; if (request != null) { return(!request.RequestUri.Equals(Configuration.Http.RemoteEchoServer)); } } return(true); }); using (HttpClient client = CreateHttpClient(useManagedHandlerString)) { client.GetAsync(Configuration.Http.RemoteEchoServer).Result.Dispose(); } Assert.False(activityStartLogged, "HttpRequestOut.Start was logged while URL disabled."); // Poll with a timeout since logging response is not synchronized with returning a response. Assert.False(activityStopLogged, "HttpRequestOut.Stop was logged while URL disabled."); diagnosticListenerObserver.Disable(); } return(SuccessExitCode); }, UseManagedHandler.ToString()).Dispose(); }
public void SendAsync_ExpectedDiagnosticCancelledActivityLogging() { RemoteInvoke(useManagedHandlerString => { bool cancelLogged = false; var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp => { if (kvp.Key == "System.Net.Http.HttpRequestOut.Stop") { Assert.NotNull(kvp.Value); GetPropertyValueFromAnonymousTypeInstance <HttpRequestMessage>(kvp.Value, "Request"); var status = GetPropertyValueFromAnonymousTypeInstance <TaskStatus>(kvp.Value, "RequestTaskStatus"); Assert.Equal(TaskStatus.Canceled, status); Volatile.Write(ref cancelLogged, true); } }); using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver)) { diagnosticListenerObserver.Enable(); using (HttpClient client = CreateHttpClient(useManagedHandlerString)) { LoopbackServer.CreateServerAsync(async(server, url) => { CancellationTokenSource tcs = new CancellationTokenSource(); Task request = LoopbackServer.AcceptSocketAsync(server, (s, stream, reader, writer) => { tcs.Cancel(); return(LoopbackServer.ReadWriteAcceptedAsync(s, reader, writer)); }); Task response = client.GetAsync(url, tcs.Token); await Assert.ThrowsAnyAsync <Exception>(() => TestHelper.WhenAllCompletedOrAnyFailed(response, request)); }).Wait(); } } // Poll with a timeout since logging response is not synchronized with returning a response. WaitForTrue(() => Volatile.Read(ref cancelLogged), TimeSpan.FromSeconds(1), "Cancellation was not logged within 1 second timeout."); diagnosticListenerObserver.Disable(); return(SuccessExitCode); }, UseManagedHandler.ToString()).Dispose(); }
public void SendAsync_ExpectedDiagnosticExceptionActivityLogging() { RemoteInvoke(useManagedHandlerString => { bool exceptionLogged = false; bool activityStopLogged = false; var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp => { if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Stop")) { Assert.NotNull(kvp.Value); GetPropertyValueFromAnonymousTypeInstance <HttpRequestMessage>(kvp.Value, "Request"); var requestStatus = GetPropertyValueFromAnonymousTypeInstance <TaskStatus>(kvp.Value, "RequestTaskStatus"); Assert.Equal(TaskStatus.Faulted, requestStatus); activityStopLogged = true; } else if (kvp.Key.Equals("System.Net.Http.Exception")) { Assert.NotNull(kvp.Value); GetPropertyValueFromAnonymousTypeInstance <Exception>(kvp.Value, "Exception"); exceptionLogged = true; } }); using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver)) { diagnosticListenerObserver.Enable(); using (HttpClient client = CreateHttpClient(useManagedHandlerString)) { Assert.ThrowsAsync <HttpRequestException>(() => client.GetAsync($"http://{Guid.NewGuid()}.com")).Wait(); } // Poll with a timeout since logging response is not synchronized with returning a response. WaitForTrue(() => activityStopLogged, TimeSpan.FromSeconds(1), "Response with exception was not logged within 1 second timeout."); Assert.True(exceptionLogged, "Exception was not logged"); diagnosticListenerObserver.Disable(); } return(SuccessExitCode); }, UseManagedHandler.ToString()).Dispose(); }
public void SendAsync_HttpTracingEnabled_Succeeds() { RemoteInvoke(async useManagedHandlerString => { using (var listener = new TestEventListener("Microsoft-System-Net-Http", EventLevel.Verbose)) { var events = new ConcurrentQueue <EventWrittenEventArgs>(); await listener.RunWithCallbackAsync(events.Enqueue, async() => { // Exercise various code paths to get coverage of tracing using (HttpClient client = CreateHttpClient(useManagedHandlerString)) { // Do a get to a loopback server await LoopbackServer.CreateServerAsync(async(server, url) => { await TestHelper.WhenAllCompletedOrAnyFailed( LoopbackServer.ReadRequestAndSendResponseAsync(server), client.GetAsync(url)); }); // Do a post to a remote server byte[] expectedData = Enumerable.Range(0, 20000).Select(i => unchecked ((byte)i)).ToArray(); HttpContent content = new ByteArrayContent(expectedData); content.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(expectedData); using (HttpResponseMessage response = await client.PostAsync(Configuration.Http.RemoteEchoServer, content)) { Assert.Equal(HttpStatusCode.OK, response.StatusCode); } } }); // We don't validate receiving specific events, but rather that we do at least // receive some events, and that enabling tracing doesn't cause other failures // in processing. Assert.DoesNotContain(events, ev => ev.EventId == 0); // make sure there are no event source error messages Assert.InRange(events.Count, 1, int.MaxValue); } return(SuccessExitCode); }, UseManagedHandler.ToString()).Dispose(); }
public void Authentication_UseMultiInterfaceNonRewindableStreamContent_Throws() { RemoteInvoke(async useManagedHandlerString => { string username = "******"; string password = "******"; Uri uri = Configuration.Http.BasicAuthUriForCreds(secure: false, userName: username, password: password); HttpClientHandler handler = CreateHttpClientHandler(useManagedHandlerString); handler.Credentials = new NetworkCredential(username, password); using (var client = new HttpClient(handler)) { byte[] postData = Encoding.UTF8.GetBytes("This is data to post."); var stream = new MultiInterfaceNonRewindableReadOnlyStream(postData); var content = new MultiInterfaceStreamContent(stream); await Assert.ThrowsAsync <HttpRequestException>(() => client.PostAsync(uri, content)); } return(SuccessExitCode); }, UseManagedHandler.ToString()).Dispose(); }
public async Task UseCallback_BadCertificate_ExpectedPolicyErrors(string url, SslPolicyErrors expectedErrors) { const int SEC_E_BUFFER_TOO_SMALL = unchecked ((int)0x80090321); if (!BackendSupportsCustomCertificateHandlingAndClientSupportsDHECipherSuites) { return; } try { if (PlatformDetection.IsUap) { // UAP HTTP stack caches connections per-process. This causes interference when these tests run in // the same process as the other tests. Each test needs to be isolated to its own process. // See dicussion: https://github.com/dotnet/corefx/issues/21945 RemoteInvoke((remoteUrl, remoteExpectedErrors, useManagedHandlerString) => { UseCallback_BadCertificate_ExpectedPolicyErrors_Helper( remoteUrl, bool.Parse(useManagedHandlerString), (SslPolicyErrors)Enum.Parse(typeof(SslPolicyErrors), remoteExpectedErrors)).Wait(); return(SuccessExitCode); }, url, expectedErrors.ToString(), UseManagedHandler.ToString()).Dispose(); } else { await UseCallback_BadCertificate_ExpectedPolicyErrors_Helper(url, UseManagedHandler, expectedErrors); } } catch (HttpRequestException e) when(e.InnerException?.GetType().Name == "WinHttpException" && e.InnerException.HResult == SEC_E_BUFFER_TOO_SMALL && !PlatformDetection.IsWindows10Version1607OrGreater) { // Testing on old Windows versions can hit https://github.com/dotnet/corefx/issues/7812 // Ignore SEC_E_BUFFER_TOO_SMALL error on such cases. } }
public void SendAsync_ExpectedDiagnosticSourceLogging() { RemoteInvoke(useManagedHandlerString => { bool requestLogged = false; Guid requestGuid = Guid.Empty; bool responseLogged = false; Guid responseGuid = Guid.Empty; bool exceptionLogged = false; bool activityLogged = false; var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp => { if (kvp.Key.Equals("System.Net.Http.Request")) { Assert.NotNull(kvp.Value); GetPropertyValueFromAnonymousTypeInstance <HttpRequestMessage>(kvp.Value, "Request"); requestGuid = GetPropertyValueFromAnonymousTypeInstance <Guid>(kvp.Value, "LoggingRequestId"); requestLogged = true; } else if (kvp.Key.Equals("System.Net.Http.Response")) { Assert.NotNull(kvp.Value); GetPropertyValueFromAnonymousTypeInstance <HttpResponseMessage>(kvp.Value, "Response"); responseGuid = GetPropertyValueFromAnonymousTypeInstance <Guid>(kvp.Value, "LoggingRequestId"); var requestStatus = GetPropertyValueFromAnonymousTypeInstance <TaskStatus>(kvp.Value, "RequestTaskStatus"); Assert.Equal(TaskStatus.RanToCompletion, requestStatus); responseLogged = true; } else if (kvp.Key.Equals("System.Net.Http.Exception")) { exceptionLogged = true; } else if (kvp.Key.StartsWith("System.Net.Http.HttpRequestOut")) { activityLogged = true; } }); using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver)) { diagnosticListenerObserver.Enable(s => !s.Contains("HttpRequestOut")); using (HttpClient client = CreateHttpClient(useManagedHandlerString)) { client.GetAsync(Configuration.Http.RemoteEchoServer).Result.Dispose(); } Assert.True(requestLogged, "Request was not logged."); // Poll with a timeout since logging response is not synchronized with returning a response. WaitForTrue(() => responseLogged, TimeSpan.FromSeconds(1), "Response was not logged within 1 second timeout."); Assert.Equal(requestGuid, responseGuid); Assert.False(exceptionLogged, "Exception was logged for successful request"); Assert.False(activityLogged, "HttpOutReq was logged while HttpOutReq logging was disabled"); diagnosticListenerObserver.Disable(); } return(SuccessExitCode); }, UseManagedHandler.ToString()).Dispose(); }
public void SendAsync_ExpectedDiagnosticSourceActivityLogging() { RemoteInvoke(useManagedHandlerString => { bool requestLogged = false; bool responseLogged = false; bool activityStartLogged = false; bool activityStopLogged = false; bool exceptionLogged = false; Activity parentActivity = new Activity("parent"); parentActivity.AddBaggage("correlationId", Guid.NewGuid().ToString()); parentActivity.AddBaggage("moreBaggage", Guid.NewGuid().ToString()); parentActivity.AddTag("tag", "tag"); //add tag to ensure it is not injected into request parentActivity.Start(); var diagnosticListenerObserver = new FakeDiagnosticListenerObserver(kvp => { if (kvp.Key.Equals("System.Net.Http.Request")) { requestLogged = true; } else if (kvp.Key.Equals("System.Net.Http.Response")) { responseLogged = true; } else if (kvp.Key.Equals("System.Net.Http.Exception")) { exceptionLogged = true; } else if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Start")) { Assert.NotNull(kvp.Value); Assert.NotNull(Activity.Current); Assert.Equal(parentActivity, Activity.Current.Parent); GetPropertyValueFromAnonymousTypeInstance <HttpRequestMessage>(kvp.Value, "Request"); activityStartLogged = true; } else if (kvp.Key.Equals("System.Net.Http.HttpRequestOut.Stop")) { Assert.NotNull(kvp.Value); Assert.NotNull(Activity.Current); Assert.Equal(parentActivity, Activity.Current.Parent); Assert.True(Activity.Current.Duration != TimeSpan.Zero); GetPropertyValueFromAnonymousTypeInstance <HttpRequestMessage>(kvp.Value, "Request"); GetPropertyValueFromAnonymousTypeInstance <HttpResponseMessage>(kvp.Value, "Response"); var requestStatus = GetPropertyValueFromAnonymousTypeInstance <TaskStatus>(kvp.Value, "RequestTaskStatus"); Assert.Equal(TaskStatus.RanToCompletion, requestStatus); activityStopLogged = true; } }); using (DiagnosticListener.AllListeners.Subscribe(diagnosticListenerObserver)) { diagnosticListenerObserver.Enable(s => s.Contains("HttpRequestOut")); using (HttpClient client = CreateHttpClient(useManagedHandlerString)) { LoopbackServer.CreateServerAsync(async(server, url) => { Task <List <string> > requestLines = LoopbackServer.AcceptSocketAsync(server, (s, stream, reader, writer) => LoopbackServer.ReadWriteAcceptedAsync(s, reader, writer)); Task <HttpResponseMessage> response = client.GetAsync(url); await Task.WhenAll(response, requestLines); AssertHeadersAreInjected(requestLines.Result, parentActivity); response.Result.Dispose(); }).Wait(); } Assert.True(activityStartLogged, "HttpRequestOut.Start was not logged."); Assert.False(requestLogged, "Request was logged when Activity logging was enabled."); // Poll with a timeout since logging response is not synchronized with returning a response. WaitForTrue(() => activityStopLogged, TimeSpan.FromSeconds(1), "HttpRequestOut.Stop was not logged within 1 second timeout."); Assert.False(exceptionLogged, "Exception was logged for successful request"); Assert.False(responseLogged, "Response was logged when Activity logging was enabled."); diagnosticListenerObserver.Disable(); } return(SuccessExitCode); }, UseManagedHandler.ToString()).Dispose(); }