public async Task HeadFile_HeadersButNotBodyServed(string baseUrl, string baseDir, string requestUrl)
        {
            var builder = new WebHostBuilder()
                          .ConfigureServices(services => services.AddSingleton(LoggerFactory))
                          .UseKestrel()
                          .UseWebRoot(Path.Combine(AppContext.BaseDirectory, baseDir))
                          .Configure(app => app.UseStaticFiles(new StaticFileOptions
            {
                RequestPath = new PathString(baseUrl),
            }));

            using (var server = builder.Start(TestUrlHelper.GetTestUrl(ServerType.Kestrel)))
            {
                var hostingEnvironment = server.Services.GetService <IWebHostEnvironment>();

                using (var client = new HttpClient {
                    BaseAddress = new Uri(server.GetAddress())
                })
                {
                    var fileInfo = hostingEnvironment.WebRootFileProvider.GetFileInfo(Path.GetFileName(requestUrl));
                    var request  = new HttpRequestMessage(HttpMethod.Head, requestUrl);
                    var response = await client.SendAsync(request);

                    Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                    Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
                    Assert.True(response.Content.Headers.ContentLength == fileInfo.Length);
                    Assert.Empty((await response.Content.ReadAsByteArrayAsync()));
                }
            }
        }
        public async Task FoundFile_LastModifiedTrimsSeconds()
        {
            using var host = new HostBuilder()
                             .ConfigureWebHost(webHostBuilder =>
            {
                webHostBuilder
                .ConfigureServices(services => services.AddSingleton(LoggerFactory))
                .UseKestrel()
                .UseUrls(TestUrlHelper.GetTestUrl(ServerType.Kestrel))
                .UseWebRoot(AppContext.BaseDirectory)
                .Configure(app => app.UseStaticFiles());
            }).Build();

            await host.StartAsync();

            using (var client = new HttpClient {
                BaseAddress = new Uri(Helpers.GetAddress(host))
            })
            {
                var last     = File.GetLastWriteTimeUtc(Path.Combine(AppContext.BaseDirectory, "TestDocument.txt"));
                var response = await client.GetAsync("TestDocument.txt");

                var trimmed = new DateTimeOffset(last.Year, last.Month, last.Day, last.Hour, last.Minute, last.Second, TimeSpan.Zero).ToUniversalTime();

                Assert.Equal(response.Content.Headers.LastModified.Value, trimmed);
            }
        }
        private async Task ClientDisconnect_NoWriteExceptionThrown(ServerType serverType)
        {
            var       interval         = TimeSpan.FromSeconds(15);
            var       requestReceived  = new TaskCompletionSource <int>(TaskCreationOptions.RunContinuationsAsynchronously);
            var       requestCancelled = new TaskCompletionSource <int>(TaskCreationOptions.RunContinuationsAsynchronously);
            var       responseComplete = new TaskCompletionSource <int>(TaskCreationOptions.RunContinuationsAsynchronously);
            Exception exception        = null;

            using var host = new HostBuilder()
                             .ConfigureWebHost(webHostBuilder =>
            {
                webHostBuilder
                .ConfigureServices(services => services.AddSingleton(LoggerFactory))
                .UseWebRoot(Path.Combine(AppContext.BaseDirectory))
                .Configure(app =>
                {
                    app.Use(async(context, next) =>
                    {
                        try
                        {
                            requestReceived.SetResult(0);
                            await requestCancelled.Task.TimeoutAfter(interval);
                            Assert.True(context.RequestAborted.WaitHandle.WaitOne(interval), "not aborted");
                            await next();
                        }
                        catch (Exception ex)
                        {
                            exception = ex;
                        }
                        responseComplete.SetResult(0);
                    });
                    app.UseStaticFiles();
                })
                .UseUrls(TestUrlHelper.GetTestUrl(serverType));

                if (serverType == ServerType.HttpSys)
                {
                    webHostBuilder.UseHttpSys();
                }
                else if (serverType == ServerType.Kestrel)
                {
                    webHostBuilder.UseKestrel();
                }
            }).Build();

            await host.StartAsync();

            // We don't use HttpClient here because it's disconnect behavior varies across platforms.
            var socket = SendSocketRequestAsync(Helpers.GetAddress(host), "/TestDocument1MB.txt");
            await requestReceived.Task.TimeoutAfter(interval);

            socket.LingerState = new LingerOption(true, 0);
            socket.Dispose();
            requestCancelled.SetResult(0);

            await responseComplete.Task.TimeoutAfter(interval);

            Assert.Null(exception);
        }
예제 #4
0
    public async Task ReturnsFileForDefaultPattern()
    {
        using var host = new HostBuilder()
                         .ConfigureWebHost(webHostBuilder =>
        {
            webHostBuilder
            .ConfigureServices(services =>
            {
                services.AddRouting();
                services.AddSingleton(LoggerFactory);
            })
            .UseKestrel()
            .UseUrls(TestUrlHelper.GetTestUrl(ServerType.Kestrel))
            .UseWebRoot(AppContext.BaseDirectory)
            .Configure(app =>
            {
                var environment = app.ApplicationServices.GetRequiredService <IWebHostEnvironment>();
                app.UseRouting();
                app.UseEndpoints(endpoints =>
                {
                    endpoints.Map("/hello", context =>
                    {
                        return(context.Response.WriteAsync("Hello, world!"));
                    });

                    endpoints.MapFallbackToFile("default.html", new StaticFileOptions()
                    {
                        FileProvider = new PhysicalFileProvider(Path.Combine(environment.WebRootPath, "SubFolder")),
                    });
                });
            });
        }).Build();

        await host.StartAsync();

        var environment = host.Services.GetRequiredService <IWebHostEnvironment>();

        using (var client = new HttpClient {
            BaseAddress = new Uri(Helpers.GetAddress(host))
        })
        {
            var response = await client.GetAsync("hello");

            var responseText = await response.Content.ReadAsStringAsync();

            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal("Hello, world!", responseText);

            response = await client.GetAsync("/");

            var responseContent = await response.Content.ReadAsByteArrayAsync();

            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            AssertFileEquals(environment, "SubFolder/default.html", responseContent);
        }
    }
        private void ClientDisconnect_NoWriteExceptionThrown(ServerType serverType)
        {
            var       interval         = TimeSpan.FromSeconds(15);
            var       requestReceived  = new ManualResetEvent(false);
            var       requestCancelled = new ManualResetEvent(false);
            var       responseComplete = new ManualResetEvent(false);
            Exception exception        = null;
            var       builder          = new WebHostBuilder()
                                         .ConfigureServices(services => services.AddSingleton(LoggerFactory))
                                         .UseWebRoot(Path.Combine(AppContext.BaseDirectory))
                                         .Configure(app =>
            {
                app.Use(async(context, next) =>
                {
                    try
                    {
                        requestReceived.Set();
                        Assert.True(requestCancelled.WaitOne(interval), "not cancelled");
                        Assert.True(context.RequestAborted.WaitHandle.WaitOne(interval), "not aborted");
                        await next();
                    }
                    catch (Exception ex)
                    {
                        exception = ex;
                    }
                    responseComplete.Set();
                });
                app.UseStaticFiles();
            });

            if (serverType == ServerType.HttpSys)
            {
                builder.UseHttpSys();
            }
            else if (serverType == ServerType.Kestrel)
            {
                builder.UseKestrel();
            }

            using (var server = builder.Start(TestUrlHelper.GetTestUrl(serverType)))
            {
                // We don't use HttpClient here because it's disconnect behavior varies across platforms.
                var socket = SendSocketRequestAsync(server.GetAddress(), "/TestDocument1MB.txt");
                Assert.True(requestReceived.WaitOne(interval), "not received");

                socket.LingerState = new LingerOption(true, 0);
                socket.Dispose();
                requestCancelled.Set();

                Assert.True(responseComplete.WaitOne(interval), "not completed");
                Assert.Null(exception);
            }
        }
예제 #6
0
    public async Task ReturnsFileForCustomPattern()
    {
        using var host = new HostBuilder()
                         .ConfigureWebHost(webHostBuilder =>
        {
            webHostBuilder
            .ConfigureServices(services =>
            {
                services.AddRouting();
                services.AddSingleton(LoggerFactory);
            })
            .UseKestrel()
            .UseUrls(TestUrlHelper.GetTestUrl(ServerType.Kestrel))
            .UseWebRoot(AppContext.BaseDirectory)
            .Configure(app =>
            {
                app.UseRouting();
                app.UseEndpoints(endpoints =>
                {
                    endpoints.Map("/hello", context =>
                    {
                        return(context.Response.WriteAsync("Hello, world!"));
                    });

                    endpoints.MapFallbackToFile("/prefix/{*path:nonfile}", "TestDocument.txt");
                });
            });
        }).Build();

        await host.StartAsync();

        var environment = host.Services.GetRequiredService <IWebHostEnvironment>();

        using (var client = new HttpClient {
            BaseAddress = new Uri(Helpers.GetAddress(host))
        })
        {
            var response = await client.GetAsync("hello");

            var responseText = await response.Content.ReadAsStringAsync();

            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal("Hello, world!", responseText);

            response = await client.GetAsync("prefix/Some-Path");

            var responseContent = await response.Content.ReadAsByteArrayAsync();

            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            AssertFileEquals(environment, "TestDocument.txt", responseContent);
        }
    }
        public async Task Endpoint_PassesThrough()
        {
            using var host = new HostBuilder()
                             .ConfigureWebHost(webHostBuilder =>
            {
                webHostBuilder
                .ConfigureServices(services => { services.AddSingleton(LoggerFactory); services.AddRouting(); })
                .UseKestrel()
                .UseUrls(TestUrlHelper.GetTestUrl(ServerType.Kestrel))
                .UseWebRoot(AppContext.BaseDirectory)
                .Configure(app =>
                {
                    // Routing first => static files noops
                    app.UseRouting();

                    app.Use(next => context =>
                    {
                        // Assign an endpoint, this will make the default files noop.
                        context.SetEndpoint(new Endpoint((c) =>
                        {
                            return(context.Response.WriteAsync("Hi from endpoint."));
                        },
                                                         new EndpointMetadataCollection(),
                                                         "test"));

                        return(next(context));
                    });

                    app.UseStaticFiles();

                    app.UseEndpoints(endpoints => { });
                });
            }).Build();

            await host.StartAsync();

            using (var client = new HttpClient {
                BaseAddress = new Uri(Helpers.GetAddress(host))
            })
            {
                var response = await client.GetAsync("TestDocument.txt");

                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                Assert.Equal("Hi from endpoint.", await response.Content.ReadAsStringAsync());
            }
        }
        public async Task ReturnsNotFoundWithoutWwwroot()
        {
            var builder = new WebHostBuilder()
                          .ConfigureServices(services => services.AddSingleton(LoggerFactory))
                          .UseKestrel()
                          .Configure(app => app.UseStaticFiles());

            using (var server = builder.Start(TestUrlHelper.GetTestUrl(ServerType.Kestrel)))
            {
                using (var client = new HttpClient {
                    BaseAddress = new Uri(server.GetAddress())
                })
                {
                    var response = await client.GetAsync("TestDocument.txt");

                    Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
                }
            }
        }
        private async Task FoundFile_Served(string baseUrl, string baseDir, string requestUrl)
        {
            using var host = new HostBuilder()
                             .ConfigureWebHost(webHostBuilder =>
            {
                webHostBuilder
                .ConfigureServices(services => services.AddSingleton(LoggerFactory))
                .UseKestrel()
                .UseUrls(TestUrlHelper.GetTestUrl(ServerType.Kestrel))
                .UseWebRoot(Path.Combine(AppContext.BaseDirectory, baseDir))
                .Configure(app => app.UseStaticFiles(new StaticFileOptions
                {
                    RequestPath = new PathString(baseUrl),
                }));
            }).Build();

            await host.StartAsync();

            var hostingEnvironment = host.Services.GetService <IWebHostEnvironment>();

            using (var client = new HttpClient {
                BaseAddress = new Uri(Helpers.GetAddress(host))
            })
            {
                var fileInfo = hostingEnvironment.WebRootFileProvider.GetFileInfo(Path.GetFileName(requestUrl));
                var response = await client.GetAsync(requestUrl);

                var responseContent = await response.Content.ReadAsByteArrayAsync();

                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
                Assert.True(response.Content.Headers.ContentLength == fileInfo.Length);
                Assert.Equal(response.Content.Headers.ContentLength, responseContent.Length);

                using (var stream = fileInfo.CreateReadStream())
                {
                    var fileContents = new byte[stream.Length];
                    stream.Read(fileContents, 0, (int)stream.Length);
                    Assert.True(responseContent.SequenceEqual(fileContents));
                }
            }
        }
예제 #10
0
    public void GenerateUrl_FastAndSlowPathsReturnsExpected(
        string appBase,
        string protocol,
        string host,
        string virtualPath,
        string fragment,
        string expected)
    {
        // Arrange
        var services      = CreateServices();
        var httpContext   = CreateHttpContext(services, appBase, host, protocol);
        var actionContext = CreateActionContext(httpContext);
        var urlHelper     = new TestUrlHelper(actionContext);

        // Act
        var url = urlHelper.GenerateUrl(protocol, host, virtualPath, fragment);

        // Assert
        Assert.Equal(expected, url);
    }