Fixes #1699

Author: alexeyzimarev

src/RestSharp/Parameters/FileParameter.cs

@@ -60,6 +60,8 @@ public static FileParameter Create(string name, byte[] data, string filename, st
         Stream GetFile() {
             var stream = new MemoryStream();
             stream.Write(data, 0, data.Length);
+            stream.Flush();
+            stream.Seek(0, SeekOrigin.Begin);
             return stream;
         }
     }
@@ -69,7 +71,6 @@ Stream GetFile() {
     /// </summary>
     /// <param name="name">The parameter name to use in the request.</param>
     /// <param name="getFile">Delegate that will be called with the request stream so you can write to it..</param>
-    /// <param name="contentLength">The length of the data that will be written by te writer.</param>
     /// <param name="fileName">The filename to use in the request.</param>
     /// <param name="contentType">Optional: parameter content type, default is "application/g-zip"</param>
     /// <returns>The <see cref="FileParameter" /> using the default content type.</returns>
@@ -88,7 +89,7 @@ public static FileParameter FromFile(string fullPath, string? name = null, strin
         var fileName = Path.GetFileName(fullPath);
         var parameterName = name ?? fileName;
 
-        return new FileParameter(parameterName, fileName, GetFile);
+        return new FileParameter(parameterName, fileName, GetFile, contentType);
 
         Stream GetFile() => File.OpenRead(fullPath);
     }

src/RestSharp/Request/RequestContent.cs

@@ -16,6 +16,7 @@
 using System.Runtime.Serialization;
 using RestSharp.Extensions;
 using static RestSharp.KnownHeaders;
+
 // ReSharper disable SuggestBaseTypeForParameter
 
 namespace RestSharp;
@@ -176,5 +177,8 @@ string GetContentTypeHeader(string contentType) {
         return boundary.IsEmpty() ? contentType : $"{contentType}; boundary=\"{boundary}\"";
     }
 
-    public void Dispose() => _streams.ForEach(x => x.Dispose());
+    public void Dispose() {
+        _streams.ForEach(x => x.Dispose());
+        Content?.Dispose();
+    }
 }

src/RestSharp/Request/RestRequest.cs

@@ -61,7 +61,6 @@ static IEnumerable<KeyValuePair<string, string>> ParseQuery(string query)
     public RestRequest(Uri resource, Method method = Method.Get)
         : this(resource.IsAbsoluteUri ? resource.AbsoluteUri : resource.OriginalString, method) { }
 
-    // readonly List<Parameter>     _parameters = new();
     readonly List<FileParameter> _files = new();
 
     /// <summary>

test/RestSharp.IntegrationTests/FileTests.cs renamed to test/RestSharp.IntegrationTests/DownloadFileTests.cs

@@ -4,8 +4,8 @@
 
 namespace RestSharp.IntegrationTests;
 
-public class FileTests : IDisposable {
-    public FileTests() {
+public sealed class DownloadFileTests : IDisposable {
+    public DownloadFileTests() {
         _server = HttpServerFixture.StartServer("Assets/Koala.jpg", FileHandler);
         _client = new RestClient(_server.Url);
     }
@@ -25,9 +25,9 @@ void FileHandler(HttpListenerRequest request, HttpListenerResponse response) {
         reader.BaseStream.CopyTo(response.OutputStream);
     }
 
-    HttpServerFixture _server;
-    RestClient        _client;
-    readonly string   _path = AppDomain.CurrentDomain.BaseDirectory;
+    readonly HttpServerFixture _server;
+    readonly RestClient        _client;
+    readonly string            _path = AppDomain.CurrentDomain.BaseDirectory;
 
     [Fact]
     public async Task AdvancedResponseWriter_without_ResponseWriter_reads_stream() {

test/RestSharp.IntegrationTests/Fixtures/TestServer.cs

@@ -2,7 +2,10 @@
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Routing.Constraints;
 using Microsoft.Extensions.Logging;
+using RestSharp.Extensions;
 using RestSharp.Tests.Shared.Extensions;
 
 namespace RestSharp.IntegrationTests.Fixtures;
@@ -42,20 +45,46 @@ public HttpServer(ITestOutputHelper output = null) {
         // ReSharper disable once ConvertClosureToMethodGroup
         _app.MapGet("status", (int code) => Results.StatusCode(code));
         _app.MapGet("headers", HandleHeaders);
+        _app.MapDelete("delete", () => new TestResponse { Message = "Works!" });
 
         // PUT
         _app.MapPut(
             "content",
             async context => {
-                var content  = await context.Request.Body.StreamToStringAsync();
+                var content = await context.Request.Body.StreamToStringAsync();
                 await context.Response.WriteAsync(content);
             }
         );
 
+        // Upload file
+        var assetPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Assets");
+
+        _app.MapPost("/upload", HandleUpload);
+
         IResult HandleHeaders(HttpContext ctx) {
             var response = ctx.Request.Headers.Select(x => new TestServerResponse(x.Key, x.Value));
             return Results.Ok(response);
         }
+
+        async Task<IResult> HandleUpload(HttpRequest req) {
+            if (!req.HasFormContentType) {
+                return Results.BadRequest("It's not a form");
+            }
+
+            var form = await req.ReadFormAsync();
+            var file = form.Files["file"];
+
+            if (file is null) {
+                return Results.BadRequest("File parameter 'file' is not present");
+            }
+
+            await using var stream = file.OpenReadStream();
+
+            var received = await stream.ReadAsBytes(default);
+            var expected = await File.ReadAllBytesAsync(Path.Combine(assetPath, file.FileName));
+
+            return Results.Ok(new UploadResponse(file.FileName, file.Length, received.SequenceEqual(expected)));
+        }
     }
 
     public Uri Url => new(Address);
@@ -70,4 +99,8 @@ public async Task Stop() {
 
 record TestServerResponse(string Name, string Value);
 
+record UploadRequest(string Filename, IFormFile File);
+
+record UploadResponse(string FileName, long Length, bool Equal);
+
 record ContentResponse(string Content);

test/RestSharp.IntegrationTests/RequestTests.cs

@@ -61,4 +61,21 @@ public async Task Can_Timeout_GET_Async() {
 
         Assert.Equal(ResponseStatus.TimedOut, response.ResponseStatus);
     }
+
+    [Fact]
+    public async Task Can_Perform_Delete_With_Response_Type() {
+        var request  = new RestRequest("delete");
+        var response = await _client.ExecuteAsync<Response>(request, Method.Delete);
+
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+        response.Data!.Message.Should().Be("Works!");
+    }
+
+    [Fact]
+    public async Task Can_Delete_With_Response_Type_using_extension() {
+        var request  = new RestRequest("delete");
+        var response = await _client.DeleteAsync<Response>(request);
+
+        response!.Message.Should().Be("Works!");
+    }
 }

test/RestSharp.IntegrationTests/UploadFileTests.cs

@@ -0,0 +1,54 @@
+using RestSharp.IntegrationTests.Fixtures;
+
+namespace RestSharp.IntegrationTests;
+
+[Collection(nameof(TestServerCollection))]
+public class UploadFileTests {
+    readonly RestClient _client;
+    readonly string     _path = AppDomain.CurrentDomain.BaseDirectory;
+
+    public UploadFileTests(TestServerFixture fixture) => _client = new RestClient(fixture.Server.Url);
+
+    [Fact]
+    public async Task Should_upload_from_file() {
+        const string filename = "Koala.jpg";
+
+        var path = Path.Combine(_path, "Assets", filename);
+
+        var request  = new RestRequest("upload").AddFile("file", path);
+        var response = await _client.PostAsync<UploadResponse>(request);
+
+        var expected = new UploadResponse(filename, new FileInfo(path).Length, true);
+
+        response.Should().BeEquivalentTo(expected);
+    }
+
+    [Fact]
+    public async Task Should_upload_from_bytes() {
+        const string filename = "Koala.jpg";
+
+        var path  = Path.Combine(_path, "Assets", filename);
+        var bytes = await File.ReadAllBytesAsync(path);
+
+        var request  = new RestRequest("upload").AddFile("file", bytes, filename);
+        var response = await _client.PostAsync<UploadResponse>(request);
+
+        var expected = new UploadResponse(filename, new FileInfo(path).Length, true);
+
+        response.Should().BeEquivalentTo(expected);
+    }
+
+    [Fact]
+    public async Task Should_upload_from_stream() {
+        const string filename = "Koala.jpg";
+
+        var path = Path.Combine(_path, "Assets", filename);
+
+        var request  = new RestRequest("upload").AddFile("file", () => File.OpenRead(path), filename);
+        var response = await _client.PostAsync<UploadResponse>(request);
+
+        var expected = new UploadResponse(filename, new FileInfo(path).Length, true);
+
+        response.Should().BeEquivalentTo(expected);
+    }
+}