Implement file support with models, interface, and comprehensive tests

Co-authored-by: StevanFreeborn <65925598+StevanFreeborn@users.noreply.github.com>

tests/AnthropicClient.Tests/Integration/AnthropicApiClientFileTests.cs

@@ -0,0 +1,219 @@
+namespace AnthropicClient.Tests.Integration;
+
+public class AnthropicApiClientFileTests : IntegrationTest
+{
+  [Fact]
+  public async Task CreateFileAsync_WhenCalled_ItShouldReturnFileResponse()
+  {
+    var fileResponseJson = @"{
+      ""type"": ""file"",
+      ""id"": ""file_abc123"",
+      ""filename"": ""example.txt"",
+      ""content_type"": ""text/plain"",
+      ""size_bytes"": 1024,
+      ""created_at"": ""2024-03-15T10:30:00Z""
+    }";
+
+    _mockHttpMessageHandler
+      .WhenCreateFileRequest()
+      .Respond(HttpStatusCode.OK, "application/json", fileResponseJson);
+
+    var content = "Hello World"u8.ToArray();
+    var request = new FileRequest(content, "example.txt", "text/plain");
+
+    var result = await Client.CreateFileAsync(request);
+
+    result.IsSuccess.Should().BeTrue();
+    result.Value.Should().NotBeNull();
+    result.Value!.Id.Should().Be("file_abc123");
+    result.Value.Filename.Should().Be("example.txt");
+    result.Value.ContentType.Should().Be("text/plain");
+    result.Value.SizeBytes.Should().Be(1024);
+  }
+
+  [Fact]
+  public async Task ListFilesAsync_WhenCalled_ItShouldReturnFilesPage()
+  {
+    var filesResponseJson = @"{
+      ""data"": [
+        {
+          ""type"": ""file"",
+          ""id"": ""file_abc123"",
+          ""filename"": ""example.txt"",
+          ""content_type"": ""text/plain"",
+          ""size_bytes"": 1024,
+          ""created_at"": ""2024-03-15T10:30:00Z""
+        }
+      ],
+      ""has_more"": false,
+      ""first_id"": ""file_abc123"",
+      ""last_id"": ""file_abc123""
+    }";
+
+    _mockHttpMessageHandler
+      .WhenListFilesRequest()
+      .Respond(HttpStatusCode.OK, "application/json", filesResponseJson);
+
+    var result = await Client.ListFilesAsync();
+
+    result.IsSuccess.Should().BeTrue();
+    result.Value.Should().NotBeNull();
+    result.Value!.Data.Should().HaveCount(1);
+    result.Value.Data[0].Id.Should().Be("file_abc123");
+    result.Value.HasMore.Should().BeFalse();
+  }
+
+  [Fact]
+  public async Task GetFileAsync_WhenCalled_ItShouldReturnFileResponse()
+  {
+    var fileResponseJson = @"{
+      ""type"": ""file"",
+      ""id"": ""file_abc123"",
+      ""filename"": ""example.txt"",
+      ""content_type"": ""text/plain"",
+      ""size_bytes"": 1024,
+      ""created_at"": ""2024-03-15T10:30:00Z""
+    }";
+
+    _mockHttpMessageHandler
+      .WhenGetFileRequest("file_abc123")
+      .Respond(HttpStatusCode.OK, "application/json", fileResponseJson);
+
+    var result = await Client.GetFileAsync("file_abc123");
+
+    result.IsSuccess.Should().BeTrue();
+    result.Value.Should().NotBeNull();
+    result.Value!.Id.Should().Be("file_abc123");
+    result.Value.Filename.Should().Be("example.txt");
+  }
+
+  [Fact]
+  public async Task DownloadFileAsync_WhenCalled_ItShouldReturnFileContent()
+  {
+    var fileContent = "Hello World"u8.ToArray();
+
+    var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
+    {
+      Content = new ByteArrayContent(fileContent)
+    };
+    httpResponseMessage.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("text/plain");
+    httpResponseMessage.Content.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("attachment")
+    {
+      FileName = "\"example.txt\""
+    };
+
+    _mockHttpMessageHandler
+      .WhenDownloadFileRequest("file_abc123")
+      .Respond(_ => httpResponseMessage);
+
+    var result = await Client.DownloadFileAsync("file_abc123");
+
+    result.IsSuccess.Should().BeTrue();
+    result.Value.Should().NotBeNull();
+    result.Value!.Content.Should().BeEquivalentTo(fileContent);
+    result.Value.Filename.Should().Be("example.txt");
+    result.Value.ContentType.Should().Be("text/plain");
+    result.Value.SizeBytes.Should().Be(fileContent.Length);
+  }
+
+  [Fact]
+  public async Task DeleteFileAsync_WhenCalled_ItShouldReturnDeleteResponse()
+  {
+    var deleteResponseJson = @"{
+      ""type"": ""file_deleted"",
+      ""id"": ""file_abc123"",
+      ""deleted"": true
+    }";
+
+    _mockHttpMessageHandler
+      .WhenDeleteFileRequest("file_abc123")
+      .Respond(HttpStatusCode.OK, "application/json", deleteResponseJson);
+
+    var result = await Client.DeleteFileAsync("file_abc123");
+
+    result.IsSuccess.Should().BeTrue();
+    result.Value.Should().NotBeNull();
+    result.Value!.Id.Should().Be("file_abc123");
+    result.Value.Deleted.Should().BeTrue();
+  }
+
+  [Fact]
+  public async Task CreateFileAsync_WhenCalledAndErrorReturned_ItShouldHandleError()
+  {
+    var errorJson = @"{
+      ""type"": ""error"",
+      ""error"": {
+        ""type"": ""invalid_request_error"",
+        ""message"": ""File too large""
+      }
+    }";
+
+    _mockHttpMessageHandler
+      .WhenCreateFileRequest()
+      .Respond(HttpStatusCode.BadRequest, "application/json", errorJson);
+
+    var content = "Hello World"u8.ToArray();
+    var request = new FileRequest(content, "example.txt", "text/plain");
+
+    var result = await Client.CreateFileAsync(request);
+
+    result.IsSuccess.Should().BeFalse();
+    result.Error.Should().BeOfType<AnthropicError>();
+    result.Error.Error.Should().BeOfType<InvalidRequestError>();
+  }
+
+  [Fact]
+  public async Task ListAllFilesAsync_WhenCalled_ItShouldReturnAllPages()
+  {
+    var firstPageJson = @"{
+      ""data"": [
+        {
+          ""type"": ""file"",
+          ""id"": ""file_abc123"",
+          ""filename"": ""example1.txt"",
+          ""content_type"": ""text/plain"",
+          ""size_bytes"": 1024,
+          ""created_at"": ""2024-03-15T10:30:00Z""
+        }
+      ],
+      ""has_more"": true,
+      ""first_id"": ""file_abc123"",
+      ""last_id"": ""file_abc123""
+    }";
+
+    var secondPageJson = @"{
+      ""data"": [
+        {
+          ""type"": ""file"",
+          ""id"": ""file_def456"",
+          ""filename"": ""example2.txt"",
+          ""content_type"": ""text/plain"",
+          ""size_bytes"": 2048,
+          ""created_at"": ""2024-03-15T11:30:00Z""
+        }
+      ],
+      ""has_more"": false,
+      ""first_id"": ""file_def456"",
+      ""last_id"": ""file_def456""
+    }";
+
+    _mockHttpMessageHandler
+      .WhenListFilesRequest()
+      .Respond(HttpStatusCode.OK, "application/json", firstPageJson);
+
+    _mockHttpMessageHandler
+      .WhenListFilesRequest()
+      .Respond(HttpStatusCode.OK, "application/json", secondPageJson);
+
+    var pages = new List<AnthropicResult<Page<AnthropicFile>>>();
+    await foreach (var page in Client.ListAllFilesAsync(1))
+    {
+      pages.Add(page);
+    }
+
+    pages.Should().HaveCount(2);
+    pages.All(p => p.IsSuccess).Should().BeTrue();
+    pages[0].Value!.Data[0].Id.Should().Be("file_abc123");
+    pages[1].Value!.Data[0].Id.Should().Be("file_def456");
+  }
+}

tests/AnthropicClient.Tests/Integration/IntegrationTest.cs

@@ -20,6 +20,7 @@ public static class MockHttpMessageHandlerExtensions
   private static readonly string CountTokensEndpoint = $"{BaseUrl}/messages/count_tokens";
   private static readonly string MessageBatchesEndpoint = $"{BaseUrl}/messages/batches";
   private static readonly string ModelsEndpoint = $"{BaseUrl}/models";
+  private static readonly string FilesEndpoint = $"{BaseUrl}/files";
 
   private static MockedRequest SetupBaseRequest(
     this MockHttpMessageHandler mockHttpMessageHandler,
@@ -103,4 +104,34 @@ public static class MockHttpMessageHandlerExtensions
     return mockHttpMessageHandler
       .SetupBaseRequest(HttpMethod.Delete, $"{MessageBatchesEndpoint}/{batchId}");
   }
+
+  public static MockedRequest WhenCreateFileRequest(this MockHttpMessageHandler mockHttpMessageHandler)
+  {
+    return mockHttpMessageHandler
+      .SetupBaseRequest(HttpMethod.Post, FilesEndpoint);
+  }
+
+  public static MockedRequest WhenListFilesRequest(this MockHttpMessageHandler mockHttpMessageHandler)
+  {
+    return mockHttpMessageHandler
+      .SetupBaseRequest(HttpMethod.Get, FilesEndpoint);
+  }
+
+  public static MockedRequest WhenGetFileRequest(this MockHttpMessageHandler mockHttpMessageHandler, string fileId)
+  {
+    return mockHttpMessageHandler
+      .SetupBaseRequest(HttpMethod.Get, $"{FilesEndpoint}/{fileId}");
+  }
+
+  public static MockedRequest WhenDownloadFileRequest(this MockHttpMessageHandler mockHttpMessageHandler, string fileId)
+  {
+    return mockHttpMessageHandler
+      .SetupBaseRequest(HttpMethod.Get, $"{FilesEndpoint}/{fileId}/content");
+  }
+
+  public static MockedRequest WhenDeleteFileRequest(this MockHttpMessageHandler mockHttpMessageHandler, string fileId)
+  {
+    return mockHttpMessageHandler
+      .SetupBaseRequest(HttpMethod.Delete, $"{FilesEndpoint}/{fileId}");
+  }
 }

tests/AnthropicClient.Tests/Unit/Models/AnthropicFileTests.cs

@@ -0,0 +1,67 @@
+namespace AnthropicClient.Tests.Unit.Models;
+
+public class AnthropicFileTests : SerializationTest
+{
+  private const string SampleJson = @"{
+    ""type"": ""file"",
+    ""id"": ""file_abc123"",
+    ""filename"": ""example.txt"",
+    ""content_type"": ""text/plain"",
+    ""size_bytes"": 1024,
+    ""created_at"": ""2024-03-15T10:30:00Z""
+  }";
+
+  [Fact]
+  public void Constructor_WhenCalled_ItShouldReturnAnInstanceWithPropertiesSet()
+  {
+    var file = new AnthropicFile();
+
+    file.Type.Should().Be("file");
+    file.Id.Should().BeEmpty();
+    file.Filename.Should().BeEmpty();
+    file.ContentType.Should().BeEmpty();
+    file.SizeBytes.Should().Be(0);
+    file.CreatedAt.Should().Be(default);
+  }
+
+  [Fact]
+  public void JsonDeserialization_WhenDeserialized_ItShouldHaveExpectedValues()
+  {
+    var result = Deserialize<AnthropicFile>(SampleJson);
+
+    result.Should().NotBeNull();
+    result!.Type.Should().Be("file");
+    result.Id.Should().Be("file_abc123");
+    result.Filename.Should().Be("example.txt");
+    result.ContentType.Should().Be("text/plain");
+    result.SizeBytes.Should().Be(1024);
+    result.CreatedAt.Should().Be(new DateTimeOffset(2024, 3, 15, 10, 30, 0, TimeSpan.Zero));
+  }
+
+  [Fact]
+  public void JsonSerialization_WhenSerialized_ItShouldReturnExpectedShape()
+  {
+    var file = new AnthropicFile
+    {
+      Type = "file",
+      Id = "file_abc123",
+      Filename = "example.txt",
+      ContentType = "text/plain",
+      SizeBytes = 1024,
+      CreatedAt = new DateTimeOffset(2024, 3, 15, 10, 30, 0, TimeSpan.Zero)
+    };
+
+    var result = Serialize(file);
+
+    var expectedJson = @"{
+      ""type"": ""file"",
+      ""id"": ""file_abc123"",
+      ""filename"": ""example.txt"",
+      ""content_type"": ""text/plain"",
+      ""size_bytes"": 1024,
+      ""created_at"": ""2024-03-15T10:30:00+00:00""
+    }";
+
+    JsonAssert.Equal(expectedJson, result);
+  }
+}

tests/AnthropicClient.Tests/Unit/Models/FileDeleteResponseTests.cs

@@ -0,0 +1,52 @@
+namespace AnthropicClient.Tests.Unit.Models;
+
+public class FileDeleteResponseTests : SerializationTest
+{
+  private const string SampleJson = @"{
+    ""type"": ""file_deleted"",
+    ""id"": ""file_abc123"",
+    ""deleted"": true
+  }";
+
+  [Fact]
+  public void Constructor_WhenCalled_ItShouldReturnAnInstanceWithPropertiesSet()
+  {
+    var response = new FileDeleteResponse();
+
+    response.Type.Should().Be("file_deleted");
+    response.Id.Should().BeEmpty();
+    response.Deleted.Should().BeFalse();
+  }
+
+  [Fact]
+  public void JsonDeserialization_WhenDeserialized_ItShouldHaveExpectedValues()
+  {
+    var result = Deserialize<FileDeleteResponse>(SampleJson);
+
+    result.Should().NotBeNull();
+    result!.Type.Should().Be("file_deleted");
+    result.Id.Should().Be("file_abc123");
+    result.Deleted.Should().BeTrue();
+  }
+
+  [Fact]
+  public void JsonSerialization_WhenSerialized_ItShouldReturnExpectedShape()
+  {
+    var response = new FileDeleteResponse
+    {
+      Type = "file_deleted",
+      Id = "file_abc123",
+      Deleted = true
+    };
+
+    var result = Serialize(response);
+
+    var expectedJson = @"{
+      ""type"": ""file_deleted"",
+      ""id"": ""file_abc123"",
+      ""deleted"": true
+    }";
+
+    JsonAssert.Equal(expectedJson, result);
+  }
+}

tests/AnthropicClient.Tests/Unit/Models/FileDownloadResponseTests.cs

@@ -0,0 +1,20 @@
+namespace AnthropicClient.Tests.Unit.Models;
+
+public class FileDownloadResponseTests
+{
+  [Fact]
+  public void Constructor_WhenCalled_ItShouldReturnAnInstanceWithPropertiesSet()
+  {
+    var content = "Hello World"u8.ToArray();
+    var filename = "example.txt";
+    var contentType = "text/plain";
+    var sizeBytes = 1024;
+
+    var response = new FileDownloadResponse(content, filename, contentType, sizeBytes);
+
+    response.Content.Should().BeEquivalentTo(content);
+    response.Filename.Should().Be(filename);
+    response.ContentType.Should().Be(contentType);
+    response.SizeBytes.Should().Be(sizeBytes);
+  }
+}

tests/AnthropicClient.Tests/Unit/Models/FileRequestTests.cs

@@ -0,0 +1,103 @@
+namespace AnthropicClient.Tests.Unit.Models;
+
+public class FileRequestTests
+{
+  [Fact]
+  public void Constructor_WhenCalled_ItShouldReturnAnInstanceWithPropertiesSet()
+  {
+    var content = "Hello World"u8.ToArray();
+    var filename = "example.txt";
+    var contentType = "text/plain";
+    var purpose = "user_upload";
+
+    var request = new FileRequest(content, filename, contentType, purpose);
+
+    request.Content.Should().BeEquivalentTo(content);
+    request.Filename.Should().Be(filename);
+    request.ContentType.Should().Be(contentType);
+    request.Purpose.Should().Be(purpose);
+  }
+
+  [Fact]
+  public void Constructor_WhenCalledWithDefaultPurpose_ItShouldSetPurposeToUserUpload()
+  {
+    var content = "Hello World"u8.ToArray();
+    var filename = "example.txt";
+    var contentType = "text/plain";
+
+    var request = new FileRequest(content, filename, contentType);
+
+    request.Content.Should().BeEquivalentTo(content);
+    request.Filename.Should().Be(filename);
+    request.ContentType.Should().Be(contentType);
+    request.Purpose.Should().Be("user_upload");
+  }
+
+  [Fact]
+  public void Constructor_WhenContentIsNull_ItShouldThrowArgumentNullException()
+  {
+    var act = () => new FileRequest(null!, "example.txt", "text/plain");
+
+    act.Should().Throw<ArgumentNullException>().WithParameterName("content");
+  }
+
+  [Fact]
+  public void Constructor_WhenFilenameIsNull_ItShouldThrowArgumentException()
+  {
+    var content = "Hello World"u8.ToArray();
+
+    var act = () => new FileRequest(content, null!, "text/plain");
+
+    act.Should().Throw<ArgumentException>().WithParameterName("filename");
+  }
+
+  [Fact]
+  public void Constructor_WhenFilenameIsEmpty_ItShouldThrowArgumentException()
+  {
+    var content = "Hello World"u8.ToArray();
+
+    var act = () => new FileRequest(content, "", "text/plain");
+
+    act.Should().Throw<ArgumentException>().WithParameterName("filename");
+  }
+
+  [Fact]
+  public void Constructor_WhenContentTypeIsNull_ItShouldThrowArgumentException()
+  {
+    var content = "Hello World"u8.ToArray();
+
+    var act = () => new FileRequest(content, "example.txt", null!);
+
+    act.Should().Throw<ArgumentException>().WithParameterName("contentType");
+  }
+
+  [Fact]
+  public void Constructor_WhenContentTypeIsEmpty_ItShouldThrowArgumentException()
+  {
+    var content = "Hello World"u8.ToArray();
+
+    var act = () => new FileRequest(content, "example.txt", "");
+
+    act.Should().Throw<ArgumentException>().WithParameterName("contentType");
+  }
+
+  [Fact]
+  public void Constructor_WhenPurposeIsNull_ItShouldThrowArgumentException()
+  {
+    var content = "Hello World"u8.ToArray();
+
+    var act = () => new FileRequest(content, "example.txt", "text/plain", null!);
+
+    act.Should().Throw<ArgumentException>().WithParameterName("purpose");
+  }
+
+  [Fact]
+  public void Constructor_WhenPurposeIsEmpty_ItShouldThrowArgumentException()
+  {
+    var content = "Hello World"u8.ToArray();
+
+    var act = () => new FileRequest(content, "example.txt", "text/plain", "");
+
+    act.Should().Throw<ArgumentException>().WithParameterName("purpose");
+  }
+}