FileResultTests.cs

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using Microsoft.AspNetCore.InternalTesting;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.Extensions.Logging;
using Xunit.Abstractions;
 
namespace Microsoft.AspNetCore.Mvc.FunctionalTests;
 
public class FileResultTests : LoggedTest
{
    protected override void Initialize(TestContext context, MethodInfo methodInfo, object[] testMethodArguments, ITestOutputHelper testOutputHelper)
    {
        base.Initialize(context, methodInfo, testMethodArguments, testOutputHelper);
        Factory = new MvcTestFixture<FilesWebSite.Startup>(LoggerFactory);
        Client = Factory.CreateDefaultClient();
    }
 
    public override void Dispose()
    {
        Factory.Dispose();
        base.Dispose();
    }
 
    public WebApplicationFactory<FilesWebSite.Startup> Factory { get; private set; }
    public HttpClient Client { get; private set; }
 
    [ConditionalFact]
    // https://github.com/aspnet/Mvc/issues/2727
    [FrameworkSkipCondition(RuntimeFrameworks.Mono)]
    public async Task FileFromDisk_CanBeEnabled_WithMiddleware()
    {
        // Arrange & Act
        var response = await Client.GetAsync("http://localhost/DownloadFiles/DownloadFromDisk");
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
 
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
 
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal("This is a sample text file", body);
    }
 
    [Theory]
    [InlineData(0, 6, "This is")]
    [InlineData(17, 25, "text file")]
    [InlineData(0, 50, "This is a sample text file")]
    public async Task FileFromDisk_CanBeEnabled_WithMiddleware_RangeRequest(long start, long end, string expectedBody)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromDisk");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(start, end);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.PartialContent, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal(expectedBody, body);
    }
 
    [Theory]
    [InlineData("0-6")]
    [InlineData("bytes = ")]
    [InlineData("bytes = 1-4, 5-11")]
    public async Task FileFromDisk_CanBeEnabled_WithMiddleware_RangeRequestIgnored(string rangeString)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromDisk");
        httpRequestMessage.Headers.TryAddWithoutValidation("Range", rangeString);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.Equal("This is a sample text file", body);
    }
 
    [Theory]
    [InlineData("bytes = 35-36")]
    [InlineData("bytes = -0")]
    public async Task FileFromDisk_CanBeEnabled_WithMiddleware_RangeRequestNotSatisfiable(string rangeString)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromDisk");
        httpRequestMessage.Headers.TryAddWithoutValidation("Range", rangeString);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.RequestedRangeNotSatisfiable, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        Assert.Equal(0, response.Content.Headers.ContentLength);
        var body = await response.Content.ReadAsStringAsync();
        Assert.Empty(body);
    }
 
    [Theory]
    [InlineData(0, 6, "This is")]
    [InlineData(17, 25, "text file")]
    [InlineData(0, 50, "This is a sample text file")]
    public async Task FileFromDisk_CanBeEnabled_WithMiddleware_RangeRequest_WithLastModifiedAndEtag(long start, long end, string expectedBody)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromDisk_WithLastModifiedAndEtag");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(start, end);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.PartialContent, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal(expectedBody, body);
    }
 
    [Theory]
    [InlineData("0-6")]
    [InlineData("bytes = ")]
    [InlineData("bytes = 1-4, 5-11")]
    public async Task FileFromDisk_CanBeEnabled_WithMiddleware_RangeRequestIgnored_WithLastModifiedAndEtag(string rangeString)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromDiskWithFileName_WithLastModifiedAndEtag");
        httpRequestMessage.Headers.TryAddWithoutValidation("Range", rangeString);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.Equal("This is a sample text file", body);
    }
 
    [Theory]
    [InlineData("bytes = 35-36")]
    [InlineData("bytes = -0")]
    public async Task FileFromDisk_CanBeEnabled_WithMiddleware_RangeRequestNotSatisfiable_WithLastModifiedAndEtag(string rangeString)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromDiskWithFileName_WithLastModifiedAndEtag");
        httpRequestMessage.Headers.TryAddWithoutValidation("Range", rangeString);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.RequestedRangeNotSatisfiable, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        Assert.Equal(0, response.Content.Headers.ContentLength);
        var body = await response.Content.ReadAsStringAsync();
        Assert.Empty(body);
    }
 
    [ConditionalFact]
    // https://github.com/aspnet/Mvc/issues/2727
    [FrameworkSkipCondition(RuntimeFrameworks.Mono)]
    public async Task FileFromDisk_ReturnsFileWithFileName()
    {
        // Arrange & Act
        var response = await Client.GetAsync("http://localhost/DownloadFiles/DownloadFromDiskWithFileName");
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
 
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
 
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal("This is a sample text file", body);
 
        var contentDisposition = response.Content.Headers.ContentDisposition.ToString();
        Assert.NotNull(contentDisposition);
        Assert.Equal("attachment; filename=downloadName.txt; filename*=UTF-8''downloadName.txt", contentDisposition);
    }
 
    [Theory]
    [InlineData("GET", "This is a sample text file")]
    [InlineData("HEAD", "")]
    public async Task FileFromDisk_ReturnsFileWithFileName_RangeProcessingNotEnabled_RangeRequestedIgnored(string httpMethod, string expectedBody)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(new HttpMethod(httpMethod), "http://localhost/DownloadFiles/DownloadFromDiskWithFileName");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(0, 6);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.Equal(expectedBody, body);
    }
 
    [Fact]
    public async Task FileFromDisk_ReturnsFileWithFileName_IfRangeHeaderValid_RangeRequest_WithLastModifiedAndEtag()
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromDiskWithFileName_WithLastModifiedAndEtag");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(0, 6);
        httpRequestMessage.Headers.IfRange = new RangeConditionHeaderValue(new EntityTagHeaderValue("\"Etag\""));
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.PartialContent, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal("This is", body);
    }
 
    [Fact]
    public async Task FileFromDisk_ReturnsFileWithFileName_IfRangeHeaderInvalid_RangeRequestIgnored_WithLastModifiedAndEtag()
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromDiskWithFileName_WithLastModifiedAndEtag");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(0, 6);
        httpRequestMessage.Headers.IfRange = new RangeConditionHeaderValue(new EntityTagHeaderValue("\"NotEtag\""));
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.Equal("This is a sample text file", body);
    }
 
    // Use int for HttpStatusCode data because xUnit cannot serialize a GAC'd enum when running on .NET Framework.
    [Theory]
    [InlineData("", (int)HttpStatusCode.OK, 26)]
    [InlineData("bytes = 0-6", (int)HttpStatusCode.PartialContent, 7)]
    [InlineData("bytes = 17-25", (int)HttpStatusCode.PartialContent, 9)]
    [InlineData("bytes = 0-50", (int)HttpStatusCode.PartialContent, 26)]
    [InlineData("0-6", (int)HttpStatusCode.OK, 26)]
    [InlineData("bytes = ", (int)HttpStatusCode.OK, 26)]
    [InlineData("bytes = 1-4, 5-11", (int)HttpStatusCode.OK, 26)]
    [InlineData("bytes = 35-36", (int)HttpStatusCode.RequestedRangeNotSatisfiable, 0)]
    [InlineData("bytes = -0", (int)HttpStatusCode.RequestedRangeNotSatisfiable, 0)]
    public async Task FileFromDisk_ReturnsFileWithFileName_DoesNotServeBody_ForHeadRequest_WithLastModifiedAndEtag(
        string rangeString,
        int httpStatusCode,
        int expectedContentLength)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Head, "http://localhost/DownloadFiles/DownloadFromDiskWithFileName_WithLastModifiedAndEtag");
        httpRequestMessage.Headers.TryAddWithoutValidation("Range", rangeString);
        httpRequestMessage.Headers.IfRange = new RangeConditionHeaderValue(new EntityTagHeaderValue("\"Etag\""));
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(httpStatusCode, (int)response.StatusCode);
 
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
 
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal(string.Empty, body);
 
        var contentLength = response.Content.Headers.ContentLength;
        Assert.Equal(expectedContentLength, contentLength);
 
        var contentDisposition = response.Content.Headers.ContentDisposition.ToString();
        Assert.NotNull(contentDisposition);
        Assert.Equal("attachment; filename=downloadName.txt; filename*=UTF-8''downloadName.txt", contentDisposition);
    }
 
    [ConditionalFact]
    [OSSkipCondition(OperatingSystems.Windows)] // Creating symlinks requires special permissions on Windows
    public async Task FileFromDisk_ReturnsFileFromSymlink()
    {
        // Arrange & Act
        var response = await Client.GetAsync("http://localhost/DownloadFiles/DownloadFromDiskSymlink");
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
 
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
 
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal("This is a sample text file", body);
    }
 
    [Fact]
    public async Task FileFromStream_ReturnsFile()
    {
        // Arrange & Act
        var response = await Client.GetAsync("http://localhost/DownloadFiles/DownloadFromStream");
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
 
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
 
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal("This is sample text from a stream", body);
    }
 
    [Theory]
    [InlineData(0, 6, "This is")]
    [InlineData(25, 32, "a stream")]
    [InlineData(0, 50, "This is sample text from a stream")]
    public async Task FileFromStream_ReturnsFile_RangeRequest(long start, long end, string expectedBody)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromStream");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(start, end);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal(HttpStatusCode.PartialContent, response.StatusCode);
        Assert.Equal(expectedBody, body);
    }
 
    [Theory]
    [InlineData("0-6")]
    [InlineData("bytes = ")]
    [InlineData("bytes = 1-4, 5-11")]
    public async Task FileFromStream_ReturnsFile_RangeRequestIgnored(string rangeString)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromStream");
        httpRequestMessage.Headers.TryAddWithoutValidation("Range", rangeString);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.Equal("This is sample text from a stream", body);
    }
 
    [Theory]
    [InlineData("bytes = 35-36")]
    [InlineData("bytes = -0")]
    public async Task FileFromStream_ReturnsFile_RangeRequestNotSatisfiable(string rangeString)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromStream");
        httpRequestMessage.Headers.TryAddWithoutValidation("Range", rangeString);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
        var body = await response.Content.ReadAsStringAsync();
 
        // Assert
        Assert.Equal(HttpStatusCode.RequestedRangeNotSatisfiable, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        Assert.Equal(0, response.Content.Headers.ContentLength);
        Assert.Empty(body);
    }
 
    [Fact]
    public async Task FileFromStream_ReturnsFileWithFileName()
    {
        // Arrange & Act
        var response = await Client.GetAsync("http://localhost/DownloadFiles/DownloadFromStreamWithFileName");
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
 
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
 
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal("This is sample text from a stream", body);
 
        var contentDisposition = response.Content.Headers.ContentDisposition.ToString();
        Assert.NotNull(contentDisposition);
        Assert.Equal("attachment; filename=downloadName.txt; filename*=UTF-8''downloadName.txt", contentDisposition);
    }
 
    [Theory]
    [InlineData("GET", "This is sample text from a stream")]
    [InlineData("HEAD", "")]
    public async Task FileFromStream_ReturnsFileWithFileName_RangeProcessingNotEnabled_RangeRequestedIgnored(string httpMethod, string expectedBody)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(new HttpMethod(httpMethod), "http://localhost/DownloadFiles/DownloadFromStreamWithFileName");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(0, 6);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.Equal(expectedBody, body);
    }
 
    [Fact]
    public async Task FileFromStream_ReturnsFileWithFileName_IfRangeHeaderValid_RangeRequest()
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromStreamWithFileName_WithEtag");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(0, 6);
        httpRequestMessage.Headers.IfRange = new RangeConditionHeaderValue(new EntityTagHeaderValue("\"Etag\""));
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
        var body = await response.Content.ReadAsStringAsync();
 
        // Assert
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        Assert.NotNull(body);
        Assert.Equal(HttpStatusCode.PartialContent, response.StatusCode);
        Assert.Equal("This is", body);
    }
 
    [Fact]
    public async Task FileFromStream_ReturnsFileWithFileName_IfRangeHeaderInvalid_RangeRequestNotSatisfiable()
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromStreamWithFileName_WithEtag");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(0, 6);
        httpRequestMessage.Headers.IfRange = new RangeConditionHeaderValue(new EntityTagHeaderValue("\"NotEtag\""));
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        var body = await response.Content.ReadAsStringAsync();
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        Assert.Equal("This is sample text from a stream", body);
    }
 
    // Use int for HttpStatusCode data because xUnit cannot serialize a GAC'd enum when running on .NET Framework.
    [Theory]
    [InlineData("", (int)HttpStatusCode.OK, 33)]
    [InlineData("bytes = 0-6", (int)HttpStatusCode.PartialContent, 7)]
    [InlineData("bytes = 17-25", (int)HttpStatusCode.PartialContent, 9)]
    [InlineData("bytes = 0-50", (int)HttpStatusCode.PartialContent, 33)]
    [InlineData("0-6", (int)HttpStatusCode.OK, 33)]
    [InlineData("bytes = ", (int)HttpStatusCode.OK, 33)]
    [InlineData("bytes = 1-4, 5-11", (int)HttpStatusCode.OK, 33)]
    [InlineData("bytes = 35-36", (int)HttpStatusCode.RequestedRangeNotSatisfiable, 0)]
    [InlineData("bytes = -0", (int)HttpStatusCode.RequestedRangeNotSatisfiable, 0)]
    public async Task FileFromStream_ReturnsFileWithFileName_DoesNotServeBody_ForHeadRequest(
        string rangeString,
        int httpStatusCode,
        int expectedContentLength)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Head, "http://localhost/DownloadFiles/DownloadFromStreamWithFileName_WithEtag");
        httpRequestMessage.Headers.TryAddWithoutValidation("Range", rangeString);
        httpRequestMessage.Headers.IfRange = new RangeConditionHeaderValue(new EntityTagHeaderValue("\"Etag\""));
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(httpStatusCode, (int)response.StatusCode);
 
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
 
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal(string.Empty, body);
 
        var contentLength = response.Content.Headers.ContentLength;
        Assert.Equal(expectedContentLength, contentLength);
 
        var contentDisposition = response.Content.Headers.ContentDisposition.ToString();
        Assert.NotNull(contentDisposition);
        Assert.Equal("attachment; filename=downloadName.txt; filename*=UTF-8''downloadName.txt", contentDisposition);
    }
 
    [Fact]
    public async Task FileFromBinaryData_ReturnsFile()
    {
        // Arrange & Act
        var response = await Client.GetAsync("http://localhost/DownloadFiles/DownloadFromBinaryData");
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
 
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
 
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal("This is a sample text from a binary array", body);
    }
 
    [Theory]
    [InlineData(0, 6, "This is")]
    [InlineData(29, 40, "binary array")]
    [InlineData(0, 50, "This is a sample text from a binary array")]
    public async Task FileFromBinaryData_ReturnsFile_RangeRequest(long start, long end, string expectedBody)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromBinaryData");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(start, end);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
        var body = await response.Content.ReadAsStringAsync();
 
        // Assert
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        Assert.NotNull(body);
        Assert.Equal(HttpStatusCode.PartialContent, response.StatusCode);
        Assert.Equal(expectedBody, body);
    }
 
    [Theory]
    [InlineData("0-6")]
    [InlineData("bytes = ")]
    [InlineData("bytes = 1-4, 5-11")]
    public async Task FileFromBinaryData_ReturnsFile_RangeRequestIgnored(string rangeString)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromBinaryData");
        httpRequestMessage.Headers.TryAddWithoutValidation("Range", rangeString);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.Equal("This is a sample text from a binary array", body);
    }
 
    [Theory]
    [InlineData("bytes = 45-46")]
    [InlineData("bytes = -0")]
    public async Task FileFromBinaryData_ReturnsFile_RangeRequestNotSatisfiable(string rangeString)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromBinaryData");
        httpRequestMessage.Headers.TryAddWithoutValidation("Range", rangeString);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
        var body = await response.Content.ReadAsStringAsync();
 
        // Assert
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        Assert.NotNull(body);
        Assert.Equal(HttpStatusCode.RequestedRangeNotSatisfiable, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        Assert.Equal(0, response.Content.Headers.ContentLength);
        Assert.Empty(body);
    }
 
    [Fact]
    public async Task FileFromBinaryData_ReturnsFileWithFileName()
    {
        // Arrange & Act
        var response = await Client.GetAsync("http://localhost/DownloadFiles/DownloadFromBinaryDataWithFileName");
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
 
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
 
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal("This is a sample text from a binary array", body);
 
        var contentDisposition = response.Content.Headers.ContentDisposition.ToString();
        Assert.NotNull(contentDisposition);
        Assert.Equal("attachment; filename=downloadName.txt; filename*=UTF-8''downloadName.txt", contentDisposition);
    }
 
    [Theory]
    [InlineData("GET", "This is a sample text from a binary array")]
    [InlineData("HEAD", "")]
    public async Task FileFromBinaryData_ReturnsFileWithFileName_RangeProcessingNotEnabled_RangeRequestedIgnored(string httpMethod, string expectedBody)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(new HttpMethod(httpMethod), "http://localhost/DownloadFiles/DownloadFromBinaryDataWithFileName");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(0, 6);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.Equal(expectedBody, body);
    }
 
    [Fact]
    public async Task FileFromBinaryData_ReturnsFileWithFileName_IfRangeHeaderValid()
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromBinaryDataWithFileName_WithEtag");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(0, 6);
        httpRequestMessage.Headers.IfRange = new RangeConditionHeaderValue(new EntityTagHeaderValue("\"Etag\""));
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
        var body = await response.Content.ReadAsStringAsync();
 
        // Assert
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        Assert.NotNull(body);
        Assert.Equal(HttpStatusCode.PartialContent, response.StatusCode);
        Assert.Equal("This is", body);
    }
 
    [Fact]
    public async Task FileFromBinaryData_ReturnsFileWithFileName_IfRangeHeaderInvalid_RangeRequestIgnored()
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DownloadFiles/DownloadFromBinaryDataWithFileName_WithEtag");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(0, 6);
        httpRequestMessage.Headers.IfRange = new RangeConditionHeaderValue(new EntityTagHeaderValue("\"NotEtag\""));
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.Equal("This is a sample text from a binary array", body);
    }
 
    // Use int for HttpStatusCode data because xUnit cannot serialize a GAC'd enum when running on .NET Framework.
    [Theory]
    [InlineData("", (int)HttpStatusCode.OK, 41)]
    [InlineData("bytes = 0-6", (int)HttpStatusCode.PartialContent, 7)]
    [InlineData("bytes = 17-25", (int)HttpStatusCode.PartialContent, 9)]
    [InlineData("bytes = 0-50", (int)HttpStatusCode.PartialContent, 41)]
    [InlineData("0-6", (int)HttpStatusCode.OK, 41)]
    [InlineData("bytes = ", (int)HttpStatusCode.OK, 41)]
    [InlineData("bytes = 1-4, 5-11", (int)HttpStatusCode.OK, 41)]
    [InlineData("bytes = 45-46", (int)HttpStatusCode.RequestedRangeNotSatisfiable, 0)]
    [InlineData("bytes = -0", (int)HttpStatusCode.RequestedRangeNotSatisfiable, 0)]
    public async Task FileFromBinaryData_ReturnsFileWithFileName_DoesNotServeBody_ForHeadRequest(
        string rangeString,
        int httpStatusCode,
        int expectedContentLength)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Head, "http://localhost/DownloadFiles/DownloadFromBinaryDataWithFileName_WithEtag");
        httpRequestMessage.Headers.TryAddWithoutValidation("Range", rangeString);
        httpRequestMessage.Headers.IfRange = new RangeConditionHeaderValue(new EntityTagHeaderValue("\"Etag\""));
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(httpStatusCode, (int)response.StatusCode);
 
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
 
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal(string.Empty, body);
 
        var contentLength = response.Content.Headers.ContentLength;
        Assert.Equal(expectedContentLength, contentLength);
 
        var contentDisposition = response.Content.Headers.ContentDisposition.ToString();
        Assert.NotNull(contentDisposition);
        Assert.Equal("attachment; filename=downloadName.txt; filename*=UTF-8''downloadName.txt", contentDisposition);
    }
 
    [Fact]
    public async Task FileFromEmbeddedResources_ReturnsFileWithFileName()
    {
        // Arrange
        var expectedBody = "Sample text file as embedded resource.";
 
        // Act
        var response = await Client.GetAsync("http://localhost/EmbeddedFiles/DownloadFileWithFileName");
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
 
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
 
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal(expectedBody, body);
 
        var contentDisposition = response.Content.Headers.ContentDisposition.ToString();
        Assert.NotNull(contentDisposition);
        Assert.Equal("attachment; filename=downloadName.txt; filename*=UTF-8''downloadName.txt", contentDisposition);
    }
 
    [Theory]
    [InlineData(0, 6, "Sample ")]
    [InlineData(20, 37, "embedded resource.")]
    [InlineData(7, 50, "text file as embedded resource.")]
    public async Task FileFromEmbeddedResources_ReturnsFileWithFileName_RangeRequest(long start, long end, string expectedBody)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/EmbeddedFiles/DownloadFileWithFileName");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(start, end);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.PartialContent, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal(expectedBody, body);
        var contentDisposition = response.Content.Headers.ContentDisposition.ToString();
        Assert.NotNull(contentDisposition);
        Assert.Equal("attachment; filename=downloadName.txt; filename*=UTF-8''downloadName.txt", contentDisposition);
    }
 
    [Theory]
    [InlineData("GET", "Sample text file as embedded resource.")]
    [InlineData("HEAD", "")]
    public async Task FileFromEmbeddedResources_ReturnsFileWithFileName_RangeProcessingNotEnabled_RangeRequestedIgnored(string httpMethod, string expectedBody)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(new HttpMethod(httpMethod), "http://localhost/EmbeddedFiles/DownloadFileWithFileName_RangeProcessingNotEnabled");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(0, 6);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.Equal(expectedBody, body);
    }
 
    [Fact]
    public async Task FileFromEmbeddedResources_ReturnsFileWithFileName_IfRangeHeaderValid_RangeRequest()
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/EmbeddedFiles/DownloadFileWithFileName_WithEtag");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(0, 6);
        httpRequestMessage.Headers.IfRange = new RangeConditionHeaderValue(new EntityTagHeaderValue("\"Etag\""));
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.PartialContent, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal("Sample ", body);
        var contentDisposition = response.Content.Headers.ContentDisposition.ToString();
        Assert.NotNull(contentDisposition);
        Assert.Equal("attachment; filename=downloadName.txt; filename*=UTF-8''downloadName.txt", contentDisposition);
    }
 
    [Fact]
    public async Task FileFromEmbeddedResources_ReturnsFileWithFileName_IfRangeHeaderInvalid_RangeRequestIgnored()
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/EmbeddedFiles/DownloadFileWithFileName_WithEtag");
        httpRequestMessage.Headers.Range = new RangeHeaderValue(0, 6);
        httpRequestMessage.Headers.IfRange = new RangeConditionHeaderValue(new EntityTagHeaderValue("\"NotEtag\""));
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.Equal("Sample text file as embedded resource.", body);
        var contentDisposition = response.Content.Headers.ContentDisposition.ToString();
        Assert.NotNull(contentDisposition);
        Assert.Equal("attachment; filename=downloadName.txt; filename*=UTF-8''downloadName.txt", contentDisposition);
    }
 
    [Theory]
    [InlineData("0-6")]
    [InlineData("bytes = ")]
    [InlineData("bytes = 1-4, 5-11")]
    public async Task FileFromEmbeddedResources_ReturnsFileWithFileName_RangeRequestIgnored(string rangeString)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/EmbeddedFiles/DownloadFileWithFileName");
        httpRequestMessage.Headers.TryAddWithoutValidation("Range", rangeString);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        var body = await response.Content.ReadAsStringAsync();
        Assert.Equal("Sample text file as embedded resource.", body);
        var contentDisposition = response.Content.Headers.ContentDisposition.ToString();
        Assert.NotNull(contentDisposition);
        Assert.Equal("attachment; filename=downloadName.txt; filename*=UTF-8''downloadName.txt", contentDisposition);
    }
 
    [Theory]
    [InlineData("bytes = 45-46")]
    [InlineData("bytes = -0")]
    public async Task FileFromEmbeddedResources_ReturnsFileWithFileName_RangeRequestNotSatisfiable(string rangeString)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/EmbeddedFiles/DownloadFileWithFileName");
        httpRequestMessage.Headers.TryAddWithoutValidation("Range", rangeString);
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(HttpStatusCode.RequestedRangeNotSatisfiable, response.StatusCode);
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
        Assert.Equal(0, response.Content.Headers.ContentLength);
        var body = await response.Content.ReadAsStringAsync();
        Assert.Empty(body);
        var contentDisposition = response.Content.Headers.ContentDisposition.ToString();
        Assert.NotNull(contentDisposition);
        Assert.Equal("attachment; filename=downloadName.txt; filename*=UTF-8''downloadName.txt", contentDisposition);
    }
 
    // Use int for HttpStatusCode data because xUnit cannot serialize a GAC'd enum when running on .NET Framework.
    [Theory]
    [InlineData("", (int)HttpStatusCode.OK, 38)]
    [InlineData("bytes = 0-6", (int)HttpStatusCode.PartialContent, 7)]
    [InlineData("bytes = 17-25", (int)HttpStatusCode.PartialContent, 9)]
    [InlineData("bytes = 0-50", (int)HttpStatusCode.PartialContent, 38)]
    [InlineData("0-6", (int)HttpStatusCode.OK, 38)]
    [InlineData("bytes = ", (int)HttpStatusCode.OK, 38)]
    [InlineData("bytes = 1-4, 5-11", (int)HttpStatusCode.OK, 38)]
    [InlineData("bytes = 45-46", (int)HttpStatusCode.RequestedRangeNotSatisfiable, 0)]
    [InlineData("bytes = -0", (int)HttpStatusCode.RequestedRangeNotSatisfiable, 0)]
    public async Task FileFromEmbeddedResources_ReturnsFileWithFileName_DoesNotServeBody_ForHeadRequest(
        string rangeString,
        int httpStatusCode,
        int expectedContentLength)
    {
        // Arrange
        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Head, "http://localhost/EmbeddedFiles/DownloadFileWithFileName");
        httpRequestMessage.Headers.TryAddWithoutValidation("Range", rangeString);
        httpRequestMessage.Headers.IfRange = new RangeConditionHeaderValue(new EntityTagHeaderValue("\"Etag\""));
 
        // Act
        var response = await Client.SendAsync(httpRequestMessage);
 
        // Assert
        Assert.Equal(httpStatusCode, (int)response.StatusCode);
 
        Assert.NotNull(response.Content.Headers.ContentType);
        Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
 
        var body = await response.Content.ReadAsStringAsync();
        Assert.NotNull(body);
        Assert.Equal(string.Empty, body);
 
        var contentLength = response.Content.Headers.ContentLength;
        Assert.Equal(expectedContentLength, contentLength);
 
        var contentDisposition = response.Content.Headers.ContentDisposition.ToString();
        Assert.NotNull(contentDisposition);
        Assert.Equal("attachment; filename=downloadName.txt; filename*=UTF-8''downloadName.txt", contentDisposition);
    }
}
File: FileResultTests.cs	Web Access
Project: src\src\Mvc\test\Mvc.FunctionalTests\Microsoft.AspNetCore.Mvc.FunctionalTests.csproj (Microsoft.AspNetCore.Mvc.FunctionalTests)