public void Should_CreatePipeline_Without_CompressionHandler() { using (AuthenticationHandler authenticationHandler = (AuthenticationHandler)GraphClientFactory.CreatePipeline(handlers)) using (RetryHandler retryHandler = (RetryHandler)authenticationHandler.InnerHandler) using (RedirectHandler redirectHandler = (RedirectHandler)retryHandler.InnerHandler) #if iOS using (NSUrlSessionHandler innerMost = (NSUrlSessionHandler)redirectHandler.InnerHandler) #elif macOS using (Foundation.NSUrlSessionHandler innerMost = (Foundation.NSUrlSessionHandler)redirectHandler.InnerHandler) #endif { Assert.NotNull(authenticationHandler); Assert.NotNull(retryHandler); Assert.NotNull(redirectHandler); Assert.NotNull(innerMost); Assert.IsType <AuthenticationHandler>(authenticationHandler); Assert.IsType <RetryHandler>(retryHandler); Assert.IsType <RedirectHandler>(redirectHandler); #if iOS Assert.IsType <NSUrlSessionHandler>(innerMost); #elif macOS Assert.IsType <Foundation.NSUrlSessionHandler>(innerMost); #endif } }
public GraphClientFactoryTests() { this.testHttpMessageHandler = new MockRedirectHandler(); handlers = new DelegatingHandler[3]; handlers[0] = new RetryHandler(); handlers[1] = new RedirectHandler(); handlers[2] = new AuthenticationHandler(authenticationProvider.Object); }
public void RedirectHandler_Constructor() { using (RedirectHandler redirect = new RedirectHandler()) { Assert.Null(redirect.InnerHandler); Assert.IsType(typeof(RedirectHandler), redirect); } }
public void RedirectHandler_Constructor() { using (RedirectHandler redirect = new RedirectHandler()) { Assert.IsNull(redirect.InnerHandler, "HttpMessageHandler initialized."); Assert.IsInstanceOfType(redirect, typeof(RedirectHandler), "Unexpected redirect handler set."); } }
public IEnumerable<Handler> BrokenRedirect() { var post = new PostHandler () { Description = "Chunked post", Body = "Hello Chunked World!", Mode = TransferMode.Chunked, Flags = RequestFlags.Redirected }; var redirect = new RedirectHandler (post, HttpStatusCode.TemporaryRedirect) { Description = post.Description }; yield return redirect; }
public Task Redirect(TestContext ctx, CancellationToken cancellationToken, HttpServer server, [RedirectStatus] HttpStatusCode code, Handler handler) { var description = string.Format("{0}: {1}", code, handler.Value); var redirect = new RedirectHandler(handler, code, description); return(TestRunner.RunTraditional(ctx, server, redirect, cancellationToken, SendAsync)); }
static HttpMessageInvoker CreateInvoker(HttpResponseMessage httpResponseMessage1, HttpResponseMessage httpResponseMessage2 = null) { var redirectHandler = new RedirectHandler { InnerHandler = new MockRedirectHandler(httpResponseMessage1, httpResponseMessage2) }; var invoker = new HttpMessageInvoker(redirectHandler); return(invoker); }
public void RedirectHandler_Constructor() { using (RedirectHandler redirect = new RedirectHandler()) { Assert.Null(redirect.InnerHandler); Assert.NotNull(redirect.RedirectOption); Assert.Equal(5, redirect.RedirectOption.MaxRedirect); // default MaxRedirects is 5 Assert.IsType <RedirectHandler>(redirect); } }
public void MustClearAuthOnRedirect() { var target = new HelloWorldHandler(); var targetAuth = new AuthenticationHandler(AuthenticationType.ForceNone, target); var redirect = new RedirectHandler(targetAuth, HttpStatusCode.Redirect); var authHandler = new AuthenticationHandler(AuthenticationType.Basic, redirect); Run(authHandler); }
public static Task RunHttpClient( TestContext ctx, CancellationToken cancellationToken, HttpServer server, HttpClientHandler handler, RedirectHandler redirect = null, HttpStatusCode expectedStatus = HttpStatusCode.OK, WebExceptionStatus expectedError = WebExceptionStatus.Success) { var runner = new HttpClientTestRunner(server, handler, redirect); return(runner.Run(ctx, cancellationToken, expectedStatus, expectedError)); }
public void RedirectHandler_HttpMessageHandlerConstructor() { var _response1 = new HttpResponseMessage(HttpStatusCode.Found); var httpMessageHandler = new MockRedirectHander(_response1); var redirectHandler = new RedirectHandler(httpMessageHandler); Assert.IsNotNull(redirectHandler.InnerHandler, "HttpMessageHandler not initialized."); Assert.AreEqual(redirectHandler.InnerHandler, httpMessageHandler, "Unexpected message handler set."); Assert.IsInstanceOfType(redirectHandler, typeof(RedirectHandler), "Unexpected redirect handler set."); }
public async Task Redirect(TestContext ctx, CancellationToken cancellationToken, HttpServer server, [RedirectStatus] HttpStatusCode code, Handler handler) { var description = string.Format("{0}: {1}", code, handler.Value); var redirect = new RedirectHandler(handler, code, description); using (var operation = new TraditionalOperation(server, redirect, SendAsync)) await operation.Run(ctx, cancellationToken).ConfigureAwait(false); }
public Task RedirectAsGetNoBuffering(TestContext ctx, HttpServer server, CancellationToken cancellationToken) { var post = new PostHandler("RedirectAsGetNoBuffering", HttpContent.HelloChunked, TransferMode.Chunked) { Flags = RequestFlags.RedirectedAsGet, AllowWriteStreamBuffering = false }; var handler = new RedirectHandler(post, HttpStatusCode.Redirect); return(TestRunner.RunTraditional(ctx, server, handler, cancellationToken, SendAsync)); }
public RedirectHandlerTest() { var request = new Request { Method = "GET", Path = "/redirect", Version = "HTTP/1.1" }; var handler = new RedirectHandler(); _response = handler.Handle(request); }
public Task MustClearAuthOnRedirect( TestContext ctx, HttpServer server, CancellationToken cancellationToken) { var target = new HelloWorldHandler("Hello World"); var targetAuth = new AuthenticationHandler(AuthenticationType.ForceNone, target); var redirect = new RedirectHandler(targetAuth, HttpStatusCode.Redirect); var authHandler = new AuthenticationHandler(AuthenticationType.Basic, redirect); return(TestRunner.RunTraditional(ctx, server, authHandler, cancellationToken, SendAsync)); }
public void RedirectHandler_RedirectOptionConstructor() { using (RedirectHandler redirect = new RedirectHandler(new RedirectHandlerOption { MaxRedirect = 2 })) { Assert.Null(redirect.InnerHandler); Assert.NotNull(redirect.RedirectOption); Assert.Equal(2, redirect.RedirectOption.MaxRedirect); Assert.IsType <RedirectHandler>(redirect); } }
public async Task RedirectAsGetNoBuffering(TestContext ctx, HttpServer server, CancellationToken cancellationToken) { var post = new PostHandler("RedirectAsGetNoBuffering", HttpContent.HelloChunked, TransferMode.Chunked) { Flags = RequestFlags.RedirectedAsGet, AllowWriteStreamBuffering = false }; var handler = new RedirectHandler(post, HttpStatusCode.Redirect); using (var operation = new TraditionalOperation(server, handler, SendAsync)) await operation.Run(ctx, cancellationToken).ConfigureAwait(false); }
public async Task MustClearAuthOnRedirect( TestContext ctx, HttpServer server, CancellationToken cancellationToken) { var target = new HelloWorldHandler("Hello World"); var targetAuth = new AuthenticationHandler(AuthenticationType.ForceNone, target); var redirect = new RedirectHandler(targetAuth, HttpStatusCode.Redirect); var authHandler = new AuthenticationHandler(AuthenticationType.Basic, redirect); using (var operation = new TraditionalOperation(server, authHandler, true)) await operation.Run(ctx, cancellationToken).ConfigureAwait(false); }
public void RedirectNoBuffering() { var post = new PostHandler { Description = "Chunked post", Body = "Hello chunked world", Mode = TransferMode.Chunked, Flags = RequestFlags.Redirected, AllowWriteStreamBuffering = false }; var redirect = new RedirectHandler(post, HttpStatusCode.TemporaryRedirect); Run(redirect, HttpStatusCode.TemporaryRedirect, true); }
public Task RedirectNoBuffering( TestContext ctx, [HttpServer] HttpServer server, CancellationToken cancellationToken) { var post = new PostHandler("RedirectNoBuffering", HttpContent.HelloChunked, TransferMode.Chunked) { Flags = RequestFlags.Redirected, AllowWriteStreamBuffering = false }; var handler = new RedirectHandler(post, HttpStatusCode.TemporaryRedirect); return(TestRunner.RunTraditional( ctx, server, handler, cancellationToken, false, HttpStatusCode.TemporaryRedirect, WebExceptionStatus.ProtocolError)); }
public async Task RedirectNoBuffering(TestContext ctx, HttpServer server, CancellationToken cancellationToken) { var post = new PostHandler("RedirectNoBuffering", HttpContent.HelloChunked, TransferMode.Chunked) { Flags = RequestFlags.Redirected, AllowWriteStreamBuffering = false }; var handler = new RedirectHandler(post, HttpStatusCode.TemporaryRedirect); using (var operation = new TraditionalOperation( server, handler, SendAsync, HttpOperationFlags.ClientDoesNotSendRedirect, HttpStatusCode.TemporaryRedirect, WebExceptionStatus.ProtocolError)) { await operation.Run(ctx, cancellationToken).ConfigureAwait(false); } }
public void HandleRedirectResultWithNullResulte() { // Setup var mvc = new MvcEngine(); var handler = new RedirectHandler(_mockNavigator.Object); var values = new RouteDictionary(); var result = new RedirectResult { ControllerName = "Test", ActionName = "Index", Values = new RouteDictionary(), }; // Execute handler.Handle(a_mvc: mvc, a_controllerName: "AnotherTest", a_result: null); }
public void CreatePipelineWithHttpMessageHandlerInput() { using (RetryHandler retryHandler = (RetryHandler)GraphClientFactory.CreatePipeline(this.testHttpMessageHandler, handlers)) using (RedirectHandler redirectHandler = (RedirectHandler)retryHandler.InnerHandler) using (AuthenticationHandler authenticationHandler = (AuthenticationHandler)redirectHandler.InnerHandler) using (MockRedirectHandler innerMost = (MockRedirectHandler)authenticationHandler.InnerHandler) { Assert.NotNull(retryHandler); Assert.NotNull(redirectHandler); Assert.NotNull(authenticationHandler); Assert.NotNull(innerMost); Assert.IsType(typeof(RetryHandler), retryHandler); Assert.IsType(typeof(RedirectHandler), redirectHandler); Assert.IsType(typeof(AuthenticationHandler), authenticationHandler); Assert.IsType(typeof(MockRedirectHandler), innerMost); } }
public void CreatePipelineWithHttpMessageHandlerInput() { using (RetryHandler retryHandler = (RetryHandler)GraphClientFactory.CreatePipeline(handlers, this.testHttpMessageHandler)) using (RedirectHandler redirectHandler = (RedirectHandler)retryHandler.InnerHandler) using (AuthenticationHandler authenticationHandler = (AuthenticationHandler)redirectHandler.InnerHandler) using (MockRedirectHandler innerMost = (MockRedirectHandler)authenticationHandler.InnerHandler) { Assert.IsNotNull(retryHandler, "Create a middleware pipeline failed."); Assert.IsNotNull(redirectHandler, "Create a middleware pipeline failed."); Assert.IsNotNull(authenticationHandler, "Create a middleware pipeline failed."); Assert.IsNotNull(innerMost, "Create inner most HttpMessageHandler failed."); Assert.IsInstanceOfType(retryHandler, typeof(RetryHandler), "Pass pipeline failed in first level."); Assert.IsInstanceOfType(redirectHandler, typeof(RedirectHandler), "Pass pipeline failed in seconde level."); Assert.IsInstanceOfType(authenticationHandler, typeof(AuthenticationHandler), "Pass pipeline failed in third level."); Assert.IsInstanceOfType(innerMost, typeof(MockRedirectHandler), "Inner most HttpMessageHandler class error."); } }
public void HandleRedirectResultWithNullMvcEngine() { // Setup var handler = new RedirectHandler(_mockNavigator.Object); var values = new RouteDictionary(); var result = new RedirectResult { ControllerName = "Test", ActionName = "Index", Values = new RouteDictionary(), }; // Execute handler.Handle(a_mvc: null, a_controllerName: "AnotherTest", a_result: result); // Assert _mockNavigator.Verify(i => i.Navigate("Test", "Index", values), Times.Once); }
public async Task Test18750(TestContext ctx, HttpServer server, CancellationToken cancellationToken) { var post = new PostHandler("First post", new StringContent("var1=value&var2=value2")) { Flags = RequestFlags.RedirectedAsGet }; var redirect = new RedirectHandler(post, HttpStatusCode.Redirect); using (var operation = new WebClientOperation(server, redirect, WebClientOperationType.UploadStringTaskAsync)) { await operation.Run(ctx, cancellationToken).ConfigureAwait(false); } var secondPost = new PostHandler("Second post", new StringContent("Should send this")); using (var operation = new TraditionalOperation(server, secondPost, true)) { await operation.Run(ctx, cancellationToken).ConfigureAwait(false); } }
/// <summary> /// Configures Web API routes. /// </summary> /// <param name="configuration"></param> public static void Configure(HttpConfiguration configuration) { if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } configuration.MapHttpAttributeRoutes(); using (var handler = new RedirectHandler(m => m.RequestUri.ToString(), "swagger")) { configuration.Routes.MapHttpRoute( name: "swagger_root", routeTemplate: "", defaults: null, constraints: null, handler: handler); } }
public void HandleRedirectResultWithNoControllerName() { // Setup var mvc = new MvcEngine(); var handler = new RedirectHandler(_mockNavigator.Object); var values = new RouteDictionary(); var result = new RedirectResult { ControllerName = null, ActionName = "Index", Values = new RouteDictionary(), }; // Execute handler.Handle(mvc, "AnotherTest", result); // Assert _mockNavigator.Verify(i => i.Navigate("AnotherTest", "Index", values), Times.Once); }
public async Task Test18750(TestContext ctx, HttpServer server, CancellationToken cancellationToken) { var post = new PostHandler("First post", new StringContent("var1=value&var2=value2")) { Flags = RequestFlags.RedirectedAsGet }; var redirect = new RedirectHandler(post, HttpStatusCode.Redirect); var uri = redirect.RegisterRequest(server); using (var wc = new WebClient()) { var res = await wc.UploadStringTaskAsync(uri, post.Content.AsString()); ctx.LogDebug(2, "Test18750: {0}", res); } var secondPost = new PostHandler("Second post", new StringContent("Should send this")); await TestRunner.RunTraditional(ctx, server, secondPost, cancellationToken, SendAsync); }
public void Should_CreatePipeline_Without_HttpMessageHandlerInput() { using (AuthenticationHandler authenticationHandler = (AuthenticationHandler)GraphClientFactory.CreatePipeline(handlers)) using (CompressionHandler compressionHandler = (CompressionHandler)authenticationHandler.InnerHandler) using (RetryHandler retryHandler = (RetryHandler)compressionHandler.InnerHandler) using (RedirectHandler redirectHandler = (RedirectHandler)retryHandler.InnerHandler) using (HttpMessageHandler innerMost = redirectHandler.InnerHandler) { Assert.NotNull(authenticationHandler); Assert.NotNull(compressionHandler); Assert.NotNull(retryHandler); Assert.NotNull(redirectHandler); Assert.NotNull(innerMost); Assert.IsType <AuthenticationHandler>(authenticationHandler); Assert.IsType <CompressionHandler>(compressionHandler); Assert.IsType <RetryHandler>(retryHandler); Assert.IsType <RedirectHandler>(redirectHandler); Assert.True(innerMost is HttpMessageHandler); } }
public void CreatePipelineWithHttpMessageHandlerInput() { using (AuthenticationHandler authenticationHandler = (AuthenticationHandler)GraphClientFactory.CreatePipeline(handlers, this.testHttpMessageHandler)) using (CompressionHandler compressionHandler = (CompressionHandler)authenticationHandler.InnerHandler) using (RetryHandler retryHandler = (RetryHandler)compressionHandler.InnerHandler) using (RedirectHandler redirectHandler = (RedirectHandler)retryHandler.InnerHandler) using (MockRedirectHandler innerMost = (MockRedirectHandler)redirectHandler.InnerHandler) { Assert.NotNull(authenticationHandler); Assert.NotNull(compressionHandler); Assert.NotNull(retryHandler); Assert.NotNull(redirectHandler); Assert.NotNull(innerMost); Assert.IsType <AuthenticationHandler>(authenticationHandler); Assert.IsType <CompressionHandler>(compressionHandler); Assert.IsType <RetryHandler>(retryHandler); Assert.IsType <RedirectHandler>(redirectHandler); Assert.IsType <MockRedirectHandler>(innerMost); } }
public Task Redirect(TestContext ctx, HttpServer server, [RedirectStatus] HttpStatusCode code, PostHandler post, CancellationToken cancellationToken) { var support = DependencyInjector.Get <IPortableSupport> (); var isWindows = support.IsMicrosoftRuntime; var hasBody = post.Content != null || ((post.Flags & RequestFlags.ExplicitlySetLength) != 0) || (post.Mode == TransferMode.ContentLength); if ((hasBody || !isWindows) && (code == HttpStatusCode.MovedPermanently || code == HttpStatusCode.Found)) { post.Flags = RequestFlags.RedirectedAsGet; } else { post.Flags = RequestFlags.Redirected; } var identifier = string.Format("{0}: {1}", code, post.ID); var redirect = new RedirectHandler(post, code, identifier); return(TestRunner.RunTraditional(ctx, server, redirect, cancellationToken, SendAsync)); }
public void HandleRedirectResultWithNullControllerName() { // Setup var mvc = new MvcEngine(); var handler = new RedirectHandler(_mockNavigator.Object); var values = new RouteDictionary(); var result = new RedirectResult { ControllerName = "Test", ActionName = "Index", Values = new RouteDictionary(), }; // Execute handler.Handle(a_mvc: mvc, a_controllerName:null, a_result:result); }
public void WhenTheRequestIsMade() { _handler = new RedirectHandler(); _handler.ProcessRequest(mockContext.Object, oldUrl, newUrl); }
/// <summary> /// Read a stream and forwards all data to the indicated /// delegate. /// </summary> /// <param name="target">The receiving callback.</param> /// <param name="source">The input data <see cref="Stream"/>.</param> private static void RedirectStream( RedirectHandler target, Stream source ) { // Buffer byte[] aBuf = new byte[100000]; // Stop on any error try { // As long as necessary for (int nBytes = 0; (nBytes = source.Read( aBuf, 0, aBuf.Length )) > 0; ) if (null != target) target( aBuf, nBytes ); } catch { // Just ignore - partner may have died } // Send end code if (null != target) target( aBuf, 0 ); }