protected internal override async Task <HttpResponse> HandleRequest( TestContext ctx, HttpOperation operation, HttpConnection connection, HttpRequest request, RequestFlags effectiveFlags, CancellationToken cancellationToken) { if (RemoteEndPoint == null) { RemoteEndPoint = connection.RemoteEndPoint; } switch (TestRunner.EffectiveType) { case HttpInstrumentationTestType.CloseIdleConnection: case HttpInstrumentationTestType.CloseCustomConnectionGroup: case HttpInstrumentationTestType.AbortResponse: ctx.Assert(request.Method, Is.EqualTo("GET"), "method"); break; case HttpInstrumentationTestType.ReuseConnection2: ctx.Assert(request.Method, Is.EqualTo("POST"), "method"); break; case HttpInstrumentationTestType.NtlmInstrumentation: case HttpInstrumentationTestType.NtlmClosesConnection: case HttpInstrumentationTestType.NtlmReusesConnection: case HttpInstrumentationTestType.ParallelNtlm: case HttpInstrumentationTestType.NtlmWhileQueued: case HttpInstrumentationTestType.NtlmWhileQueued2: return(await HandleNtlmRequest( ctx, operation, connection, request, effectiveFlags, cancellationToken).ConfigureAwait(false)); case HttpInstrumentationTestType.ReuseConnection: case HttpInstrumentationTestType.ReuseCustomConnectionGroup: case HttpInstrumentationTestType.RedirectOnSameConnection: ctx.Assert(request.Method, Is.EqualTo("GET"), "method"); AssertReusingConnection(ctx, connection); break; case HttpInstrumentationTestType.ReuseAfterPartialRead: // We can't reuse the connection because we did not read the entire response. ctx.Assert(request.Method, Is.EqualTo("GET"), "method"); AssertNotReusingConnection(ctx, connection); break; case HttpInstrumentationTestType.CustomConnectionGroup: // We can't reuse the connection because we're in a different connection group. ctx.Assert(request.Method, Is.EqualTo("GET"), "method"); AssertNotReusingConnection(ctx, connection); break; default: throw ctx.AssertFail(TestRunner.EffectiveType); } HttpResponse response; HttpInstrumentationContent content; ListenerOperation redirect; switch (TestRunner.EffectiveType) { case HttpInstrumentationTestType.ReuseAfterPartialRead: return(new HttpResponse(HttpStatusCode.OK, Content) { WriteAsBlob = true }); case HttpInstrumentationTestType.AbortResponse: content = new HttpInstrumentationContent(TestRunner, currentRequest); return(new HttpResponse(HttpStatusCode.OK, content)); case HttpInstrumentationTestType.ReuseConnection2: return(new HttpResponse(HttpStatusCode.OK, Content)); case HttpInstrumentationTestType.RedirectOnSameConnection: redirect = operation.RegisterRedirect(ctx, Target); response = HttpResponse.CreateRedirect(HttpStatusCode.Redirect, redirect); response.SetBody(new StringContent($"{ME} Redirecting")); response.WriteAsBlob = true; return(response); default: return(HttpResponse.CreateSuccess(ME)); } }
async Task <HttpResponse> HandleNtlmRequest( TestContext ctx, HttpOperation operation, HttpConnection connection, HttpRequest request, RequestFlags effectiveFlags, CancellationToken cancellationToken) { var me = $"{ME}.{nameof (HandleNtlmRequest)}"; ctx.LogDebug(3, $"{me}: {connection.RemoteEndPoint}"); AuthenticationState state; var response = AuthManager.HandleAuthentication(ctx, connection, request, out state); ctx.LogDebug(3, $"{me}: {connection.RemoteEndPoint} - {state} {response}"); if (state == AuthenticationState.Unauthenticated) { ctx.Assert(currentAuthState, Is.EqualTo(AuthenticationState.None), "first request"); currentAuthState = AuthenticationState.Unauthenticated; } else if (TestRunner.EffectiveType == HttpInstrumentationTestType.NtlmInstrumentation) { if (state == AuthenticationState.Challenge) { ctx.LogDebug(3, $"{me}: {connection.RemoteEndPoint} {RemoteEndPoint}"); challengeEndPoint = connection.RemoteEndPoint; } else { ctx.Assert(connection.RemoteEndPoint, Is.EqualTo(challengeEndPoint), "must reuse connection"); } } if (TestRunner.EffectiveType == HttpInstrumentationTestType.ParallelNtlm) { var parallelOperation = TestRunner.StartParallelNtlm( ctx, this, state, cancellationToken); if (parallelOperation != null) { await parallelOperation.WaitForCompletion().ConfigureAwait(false); } } var keepAlive = !CloseConnection && (effectiveFlags & (RequestFlags.KeepAlive | RequestFlags.CloseConnection)) == RequestFlags.KeepAlive; if (response != null) { response.Redirect = operation.RegisterRedirect(ctx, this, request.Path); return(response); } cancellationToken.ThrowIfCancellationRequested(); HttpInstrumentationContent content; switch (TestRunner.EffectiveType) { case HttpInstrumentationTestType.NtlmWhileQueued: content = new HttpInstrumentationContent(TestRunner, currentRequest); return(new HttpResponse(HttpStatusCode.OK, content)); case HttpInstrumentationTestType.NtlmWhileQueued2: content = new HttpInstrumentationContent(TestRunner, currentRequest); return(new HttpResponse(HttpStatusCode.OK, content) { CloseConnection = true }); } var ret = await Target.HandleRequest(ctx, operation, connection, request, effectiveFlags, cancellationToken); ctx.LogDebug(3, $"{me} target done: {Target} {ret}"); ret.KeepAlive = false; return(ret); }