Fix base64 deserialization when JSON encoder escapes forward slashes (#1342)
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com>
This commit is contained in:
Copilot
GitHub
parent
74622d0c9c
commit
774a1dba35
3 changed files with 710 additions and 48 deletions
|
|
@ -1,5 +1,6 @@
|
|||
using Microsoft.Extensions.AI;
|
||||
using ModelContextProtocol.Protocol;
|
||||
using ModelContextProtocol.Tests.Protocol;
|
||||
using System.Text.Json;
|
||||
using System.Text.Json.Serialization;
|
||||
|
||||
|
|
@ -402,6 +403,183 @@ public class AIContentExtensionsTests
|
|||
|
||||
Assert.Null(exception);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public void ImageContentBlock_ToAIContent_RoundTrips(byte[] originalBytes)
|
||||
{
|
||||
var image = ImageContentBlock.FromBytes(originalBytes, "image/png");
|
||||
|
||||
var aiContent = Assert.IsType<DataContent>(image.ToAIContent());
|
||||
Assert.Equal("image/png", aiContent.MediaType);
|
||||
Assert.Equal(originalBytes, aiContent.Data.ToArray());
|
||||
|
||||
var roundTripped = Assert.IsType<ImageContentBlock>(aiContent.ToContentBlock());
|
||||
Assert.Equal("image/png", roundTripped.MimeType);
|
||||
Assert.Equal(originalBytes, roundTripped.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public void ImageContentBlock_DataSetter_ToAIContent_RoundTrips(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
var image = new ImageContentBlock
|
||||
{
|
||||
Data = System.Text.Encoding.UTF8.GetBytes(base64),
|
||||
MimeType = "image/jpeg"
|
||||
};
|
||||
|
||||
var aiContent = Assert.IsType<DataContent>(image.ToAIContent());
|
||||
Assert.Equal("image/jpeg", aiContent.MediaType);
|
||||
Assert.Equal(originalBytes, aiContent.Data.ToArray());
|
||||
|
||||
var roundTripped = Assert.IsType<ImageContentBlock>(aiContent.ToContentBlock());
|
||||
Assert.Equal("image/jpeg", roundTripped.MimeType);
|
||||
Assert.Equal(originalBytes, roundTripped.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public void AudioContentBlock_ToAIContent_RoundTrips(byte[] originalBytes)
|
||||
{
|
||||
var audio = AudioContentBlock.FromBytes(originalBytes, "audio/wav");
|
||||
|
||||
var aiContent = Assert.IsType<DataContent>(audio.ToAIContent());
|
||||
Assert.Equal("audio/wav", aiContent.MediaType);
|
||||
Assert.Equal(originalBytes, aiContent.Data.ToArray());
|
||||
|
||||
var roundTripped = Assert.IsType<AudioContentBlock>(aiContent.ToContentBlock());
|
||||
Assert.Equal("audio/wav", roundTripped.MimeType);
|
||||
Assert.Equal(originalBytes, roundTripped.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public void AudioContentBlock_DataSetter_ToAIContent_RoundTrips(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
var audio = new AudioContentBlock
|
||||
{
|
||||
Data = System.Text.Encoding.UTF8.GetBytes(base64),
|
||||
MimeType = "audio/mp3"
|
||||
};
|
||||
|
||||
var aiContent = Assert.IsType<DataContent>(audio.ToAIContent());
|
||||
Assert.Equal("audio/mp3", aiContent.MediaType);
|
||||
Assert.Equal(originalBytes, aiContent.Data.ToArray());
|
||||
|
||||
var roundTripped = Assert.IsType<AudioContentBlock>(aiContent.ToContentBlock());
|
||||
Assert.Equal("audio/mp3", roundTripped.MimeType);
|
||||
Assert.Equal(originalBytes, roundTripped.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public void BlobResourceContents_ToAIContent_RoundTrips(byte[] originalBytes)
|
||||
{
|
||||
var blob = BlobResourceContents.FromBytes(originalBytes, "file:///test.bin", "application/octet-stream");
|
||||
var embedded = new EmbeddedResourceBlock { Resource = blob };
|
||||
|
||||
var aiContent = Assert.IsType<DataContent>(embedded.ToAIContent());
|
||||
Assert.Equal("application/octet-stream", aiContent.MediaType);
|
||||
Assert.Equal(originalBytes, aiContent.Data.ToArray());
|
||||
|
||||
var roundTripped = Assert.IsType<EmbeddedResourceBlock>(aiContent.ToContentBlock());
|
||||
var roundTrippedBlob = Assert.IsType<BlobResourceContents>(roundTripped.Resource);
|
||||
Assert.Equal("application/octet-stream", roundTrippedBlob.MimeType);
|
||||
Assert.Equal(originalBytes, roundTrippedBlob.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public void BlobResourceContents_BlobSetter_ToAIContent_RoundTrips(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
var blob = new BlobResourceContents
|
||||
{
|
||||
Blob = System.Text.Encoding.UTF8.GetBytes(base64),
|
||||
Uri = "file:///test.bin",
|
||||
MimeType = "application/octet-stream"
|
||||
};
|
||||
var embedded = new EmbeddedResourceBlock { Resource = blob };
|
||||
|
||||
var aiContent = Assert.IsType<DataContent>(embedded.ToAIContent());
|
||||
Assert.Equal("application/octet-stream", aiContent.MediaType);
|
||||
Assert.Equal(originalBytes, aiContent.Data.ToArray());
|
||||
|
||||
var roundTripped = Assert.IsType<EmbeddedResourceBlock>(aiContent.ToContentBlock());
|
||||
var roundTrippedBlob = Assert.IsType<BlobResourceContents>(roundTripped.Resource);
|
||||
Assert.Equal("application/octet-stream", roundTrippedBlob.MimeType);
|
||||
Assert.Equal(originalBytes, roundTrippedBlob.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public void ImageContentBlock_JsonDeserialized_ToAIContent_RoundTrips(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
string json = $$"""{"type":"image","data":"{{base64}}","mimeType":"image/png"}""";
|
||||
|
||||
var image = Assert.IsType<ImageContentBlock>(
|
||||
JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
|
||||
var aiContent = Assert.IsType<DataContent>(image.ToAIContent());
|
||||
Assert.Equal(originalBytes, aiContent.Data.ToArray());
|
||||
|
||||
var roundTripped = Assert.IsType<ImageContentBlock>(aiContent.ToContentBlock());
|
||||
Assert.Equal(originalBytes, roundTripped.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public void ImageContentBlock_EscapedJsonDeserialized_ToAIContent_RoundTrips(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
string json = $$"""{"type":"image","data":"{{base64.Replace("/", "\\/")}}","mimeType":"image/png"}""";
|
||||
|
||||
var image = Assert.IsType<ImageContentBlock>(
|
||||
JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
|
||||
var aiContent = Assert.IsType<DataContent>(image.ToAIContent());
|
||||
Assert.Equal(originalBytes, aiContent.Data.ToArray());
|
||||
|
||||
var roundTripped = Assert.IsType<ImageContentBlock>(aiContent.ToContentBlock());
|
||||
Assert.Equal(originalBytes, roundTripped.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public void AudioContentBlock_EscapedJsonDeserialized_ToAIContent_RoundTrips(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
string json = $$"""{"type":"audio","data":"{{base64.Replace("/", "\\/")}}","mimeType":"audio/wav"}""";
|
||||
|
||||
var audio = Assert.IsType<AudioContentBlock>(
|
||||
JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
|
||||
var aiContent = Assert.IsType<DataContent>(audio.ToAIContent());
|
||||
Assert.Equal(originalBytes, aiContent.Data.ToArray());
|
||||
|
||||
var roundTripped = Assert.IsType<AudioContentBlock>(aiContent.ToContentBlock());
|
||||
Assert.Equal(originalBytes, roundTripped.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public void BlobResourceContents_EscapedJsonDeserialized_ToAIContent_RoundTrips(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
string json = $$"""{"uri":"file:///test.bin","blob":"{{base64.Replace("/", "\\/")}}","mimeType":"application/octet-stream"}""";
|
||||
|
||||
var blob = Assert.IsType<BlobResourceContents>(
|
||||
JsonSerializer.Deserialize<ResourceContents>(json, McpJsonUtilities.DefaultOptions));
|
||||
var embedded = new EmbeddedResourceBlock { Resource = blob };
|
||||
|
||||
var aiContent = Assert.IsType<DataContent>(embedded.ToAIContent());
|
||||
Assert.Equal(originalBytes, aiContent.Data.ToArray());
|
||||
|
||||
var roundTripped = Assert.IsType<EmbeddedResourceBlock>(aiContent.ToContentBlock());
|
||||
var roundTrippedBlob = Assert.IsType<BlobResourceContents>(roundTripped.Resource);
|
||||
Assert.Equal(originalBytes, roundTrippedBlob.DecodedData.ToArray());
|
||||
}
|
||||
}
|
||||
|
||||
// Test type for named user-defined type test
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
using ModelContextProtocol.Protocol;
|
||||
using System.Text;
|
||||
using System.Text.Json;
|
||||
|
||||
namespace ModelContextProtocol.Tests.Protocol;
|
||||
|
|
@ -290,4 +291,275 @@ public class ContentBlockTests
|
|||
{
|
||||
Assert.ThrowsAny<ArgumentException>(() => AudioContentBlock.FromBytes((byte[])[1, 2, 3], mimeType!));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ImageContentBlock_Deserialization_HandlesEscapedForwardSlashInBase64()
|
||||
{
|
||||
// Base64 uses '/' which some JSON encoders escape as '\/' (valid JSON).
|
||||
// The converter must unescape before storing the base64 UTF-8 bytes.
|
||||
byte[] originalBytes = [0xFF, 0xD8, 0xFF, 0xE0]; // sample bytes that produce '/' in base64
|
||||
string base64 = Convert.ToBase64String(originalBytes); // "/9j/4A=="
|
||||
Assert.Contains("/", base64);
|
||||
|
||||
// Simulate a JSON encoder that escapes '/' as '\/'
|
||||
string json = $$"""{"type":"image","data":"{{base64.Replace("/", "\\/")}}","mimeType":"image/jpeg"}""";
|
||||
|
||||
var deserialized = JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions);
|
||||
var image = Assert.IsType<ImageContentBlock>(deserialized);
|
||||
Assert.Equal(base64, System.Text.Encoding.UTF8.GetString(image.Data.ToArray()));
|
||||
Assert.Equal(originalBytes, image.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AudioContentBlock_Deserialization_HandlesEscapedForwardSlashInBase64()
|
||||
{
|
||||
byte[] originalBytes = [0xFF, 0xD8, 0xFF, 0xE0];
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
Assert.Contains("/", base64);
|
||||
|
||||
string json = $$"""{"type":"audio","data":"{{base64.Replace("/", "\\/")}}","mimeType":"audio/wav"}""";
|
||||
|
||||
var deserialized = JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions);
|
||||
var audio = Assert.IsType<AudioContentBlock>(deserialized);
|
||||
Assert.Equal(base64, System.Text.Encoding.UTF8.GetString(audio.Data.ToArray()));
|
||||
Assert.Equal(originalBytes, audio.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Provides test data for base64 roundtrip tests. Each entry is a byte array that exercises
|
||||
/// different base64 encoding characteristics:
|
||||
/// - Various lengths producing 0, 1, or 2 padding characters
|
||||
/// - Bytes that produce all 64 base64 alphabet characters including '+' and '/'
|
||||
/// </summary>
|
||||
public static TheoryData<byte[]> Base64TestData()
|
||||
{
|
||||
var data = new TheoryData<byte[]>
|
||||
{
|
||||
Array.Empty<byte>(), // empty: ""
|
||||
new byte[] { 0x00 }, // 1 byte, 2 padding chars: "AA=="
|
||||
new byte[] { 0x00, 0x01 }, // 2 bytes, 1 padding char: "AAE="
|
||||
new byte[] { 0x00, 0x01, 0x02 }, // 3 bytes, no padding: "AAEC"
|
||||
new byte[] { 0xFF, 0xD8, 0xFF, 0xE0 }, // produces '/' in base64: "/9j/4A=="
|
||||
new byte[] { 0xFB, 0xEF, 0xBE }, // produces '+' in base64: "++++"
|
||||
};
|
||||
|
||||
// All 256 byte values to exercise the full base64 alphabet
|
||||
byte[] allBytes = new byte[256];
|
||||
for (int i = 0; i < 256; i++)
|
||||
{
|
||||
allBytes[i] = (byte)i;
|
||||
}
|
||||
data.Add(allBytes);
|
||||
|
||||
// Larger payload (1024 bytes)
|
||||
byte[] largePayload = new byte[1024];
|
||||
new Random(42).NextBytes(largePayload);
|
||||
data.Add(largePayload);
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void ImageContentBlock_FromBytes_RoundtripsCorrectly(byte[] originalBytes)
|
||||
{
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
var image = ImageContentBlock.FromBytes(originalBytes, "image/png");
|
||||
|
||||
Assert.Equal("image/png", image.MimeType);
|
||||
Assert.Equal(originalBytes, image.DecodedData.ToArray());
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(image.Data.ToArray()));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void ImageContentBlock_DataSetter_RoundtripsCorrectly(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
|
||||
|
||||
var image = new ImageContentBlock { Data = base64Utf8, MimeType = "image/png" };
|
||||
|
||||
Assert.Equal(base64Utf8, image.Data.ToArray());
|
||||
Assert.Equal(originalBytes, image.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void ImageContentBlock_JsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
|
||||
|
||||
var original = new ImageContentBlock { Data = base64Utf8, MimeType = "image/png" };
|
||||
string json = JsonSerializer.Serialize<ContentBlock>(original, McpJsonUtilities.DefaultOptions);
|
||||
var deserialized = Assert.IsType<ImageContentBlock>(
|
||||
JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(base64Utf8, deserialized.Data.ToArray());
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void ImageContentBlock_FromBytes_JsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
var original = ImageContentBlock.FromBytes(originalBytes, "image/jpeg");
|
||||
string json = JsonSerializer.Serialize<ContentBlock>(original, McpJsonUtilities.DefaultOptions);
|
||||
var deserialized = Assert.IsType<ImageContentBlock>(
|
||||
JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(deserialized.Data.ToArray()));
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void ImageContentBlock_EscapedJsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
// Simulate JSON encoder that escapes '/' as '\/'
|
||||
string json = $$"""{"type":"image","data":"{{base64.Replace("/", "\\/")}}","mimeType":"image/png"}""";
|
||||
|
||||
var deserialized = Assert.IsType<ImageContentBlock>(
|
||||
JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(base64, Encoding.UTF8.GetString(deserialized.Data.ToArray()));
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ImageContentBlock_DataSetterInvalidatesCachedDecodedData()
|
||||
{
|
||||
byte[] bytes1 = [1, 2, 3];
|
||||
var image = ImageContentBlock.FromBytes(bytes1, "image/png");
|
||||
|
||||
// Access DecodedData to populate cache
|
||||
Assert.Equal(bytes1, image.DecodedData.ToArray());
|
||||
|
||||
// Set new Data to invalidate cache
|
||||
byte[] newBytes = [4, 5, 6];
|
||||
string newBase64 = Convert.ToBase64String(newBytes);
|
||||
image.Data = Encoding.UTF8.GetBytes(newBase64);
|
||||
|
||||
Assert.Equal(newBytes, image.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void AudioContentBlock_FromBytes_RoundtripsCorrectly(byte[] originalBytes)
|
||||
{
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
var audio = AudioContentBlock.FromBytes(originalBytes, "audio/wav");
|
||||
|
||||
Assert.Equal("audio/wav", audio.MimeType);
|
||||
Assert.Equal(originalBytes, audio.DecodedData.ToArray());
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(audio.Data.ToArray()));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void AudioContentBlock_DataSetter_RoundtripsCorrectly(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
|
||||
|
||||
var audio = new AudioContentBlock { Data = base64Utf8, MimeType = "audio/wav" };
|
||||
|
||||
Assert.Equal(base64Utf8, audio.Data.ToArray());
|
||||
Assert.Equal(originalBytes, audio.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void AudioContentBlock_JsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
|
||||
|
||||
var original = new AudioContentBlock { Data = base64Utf8, MimeType = "audio/wav" };
|
||||
string json = JsonSerializer.Serialize<ContentBlock>(original, McpJsonUtilities.DefaultOptions);
|
||||
var deserialized = Assert.IsType<AudioContentBlock>(
|
||||
JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(base64Utf8, deserialized.Data.ToArray());
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void AudioContentBlock_FromBytes_JsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
var original = AudioContentBlock.FromBytes(originalBytes, "audio/mp3");
|
||||
string json = JsonSerializer.Serialize<ContentBlock>(original, McpJsonUtilities.DefaultOptions);
|
||||
var deserialized = Assert.IsType<AudioContentBlock>(
|
||||
JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(deserialized.Data.ToArray()));
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void AudioContentBlock_EscapedJsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
string json = $$"""{"type":"audio","data":"{{base64.Replace("/", "\\/")}}","mimeType":"audio/wav"}""";
|
||||
|
||||
var deserialized = Assert.IsType<AudioContentBlock>(
|
||||
JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(base64, Encoding.UTF8.GetString(deserialized.Data.ToArray()));
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AudioContentBlock_DataSetterInvalidatesCachedDecodedData()
|
||||
{
|
||||
byte[] bytes1 = [1, 2, 3];
|
||||
var audio = AudioContentBlock.FromBytes(bytes1, "audio/wav");
|
||||
|
||||
Assert.Equal(bytes1, audio.DecodedData.ToArray());
|
||||
|
||||
byte[] newBytes = [4, 5, 6];
|
||||
string newBase64 = Convert.ToBase64String(newBytes);
|
||||
audio.Data = Encoding.UTF8.GetBytes(newBase64);
|
||||
|
||||
Assert.Equal(newBytes, audio.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void ImageContentBlock_FromBytes_LazilyEncodesData(byte[] originalBytes)
|
||||
{
|
||||
// FromBytes should only decode when Data is accessed
|
||||
var image = ImageContentBlock.FromBytes(originalBytes, "image/png");
|
||||
|
||||
// First, access DecodedData without touching Data
|
||||
Assert.Equal(originalBytes, image.DecodedData.ToArray());
|
||||
|
||||
// Now access Data and verify it lazily encoded correctly
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(image.Data.ToArray()));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void AudioContentBlock_FromBytes_LazilyEncodesData(byte[] originalBytes)
|
||||
{
|
||||
var audio = AudioContentBlock.FromBytes(originalBytes, "audio/wav");
|
||||
|
||||
Assert.Equal(originalBytes, audio.DecodedData.ToArray());
|
||||
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(audio.Data.ToArray()));
|
||||
}
|
||||
}
|
||||
|
|
@ -1,4 +1,5 @@
|
|||
using ModelContextProtocol.Protocol;
|
||||
using System.Text;
|
||||
using System.Text.Json;
|
||||
|
||||
namespace ModelContextProtocol.Tests.Protocol;
|
||||
|
|
@ -489,4 +490,129 @@ public static class ResourceContentsTests
|
|||
|
||||
Assert.DoesNotContain("mimeType", json);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public static void BlobResourceContents_Deserialization_HandlesEscapedForwardSlashInBase64()
|
||||
{
|
||||
// Base64 uses '/' which some JSON encoders escape as '\/' (valid JSON).
|
||||
// The converter must unescape before storing the base64 UTF-8 bytes.
|
||||
byte[] originalBytes = [0xFF, 0xD8, 0xFF, 0xE0]; // sample bytes that produce '/' in base64
|
||||
string base64 = Convert.ToBase64String(originalBytes); // "/9j/4A=="
|
||||
Assert.Contains("/", base64);
|
||||
|
||||
// Simulate a JSON encoder that escapes '/' as '\/'
|
||||
string json = $$"""{"uri":"file:///test.bin","blob":"{{base64.Replace("/", "\\/")}}","mimeType":"application/octet-stream"}""";
|
||||
|
||||
var deserialized = JsonSerializer.Deserialize<ResourceContents>(json, McpJsonUtilities.DefaultOptions);
|
||||
var blob = Assert.IsType<BlobResourceContents>(deserialized);
|
||||
Assert.Equal(base64, System.Text.Encoding.UTF8.GetString(blob.Blob.ToArray()));
|
||||
Assert.Equal(originalBytes, blob.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public static void BlobResourceContents_FromBytes_RoundtripsCorrectly(byte[] originalBytes)
|
||||
{
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
var blob = BlobResourceContents.FromBytes(originalBytes, "file:///test.bin", "application/octet-stream");
|
||||
|
||||
Assert.Equal("file:///test.bin", blob.Uri);
|
||||
Assert.Equal("application/octet-stream", blob.MimeType);
|
||||
Assert.Equal(originalBytes, blob.DecodedData.ToArray());
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(blob.Blob.ToArray()));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public static void BlobResourceContents_BlobSetter_RoundtripsCorrectly(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
|
||||
|
||||
var blob = new BlobResourceContents { Blob = base64Utf8, Uri = "file:///test.bin" };
|
||||
|
||||
Assert.Equal(base64Utf8, blob.Blob.ToArray());
|
||||
Assert.Equal(originalBytes, blob.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public static void BlobResourceContents_JsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
|
||||
|
||||
var original = new BlobResourceContents
|
||||
{
|
||||
Blob = base64Utf8,
|
||||
Uri = "file:///test.bin",
|
||||
MimeType = "application/octet-stream"
|
||||
};
|
||||
string json = JsonSerializer.Serialize<ResourceContents>(original, McpJsonUtilities.DefaultOptions);
|
||||
var deserialized = Assert.IsType<BlobResourceContents>(
|
||||
JsonSerializer.Deserialize<ResourceContents>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(base64Utf8, deserialized.Blob.ToArray());
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public static void BlobResourceContents_FromBytes_JsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
var original = BlobResourceContents.FromBytes(originalBytes, "file:///test.bin", "application/octet-stream");
|
||||
string json = JsonSerializer.Serialize<ResourceContents>(original, McpJsonUtilities.DefaultOptions);
|
||||
var deserialized = Assert.IsType<BlobResourceContents>(
|
||||
JsonSerializer.Deserialize<ResourceContents>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(deserialized.Blob.ToArray()));
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public static void BlobResourceContents_EscapedJsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
string json = $$"""{"uri":"file:///test.bin","blob":"{{base64.Replace("/", "\\/")}}","mimeType":"application/octet-stream"}""";
|
||||
|
||||
var deserialized = Assert.IsType<BlobResourceContents>(
|
||||
JsonSerializer.Deserialize<ResourceContents>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(base64, Encoding.UTF8.GetString(deserialized.Blob.ToArray()));
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public static void BlobResourceContents_BlobSetterInvalidatesCachedDecodedData()
|
||||
{
|
||||
byte[] bytes1 = [1, 2, 3];
|
||||
var blob = BlobResourceContents.FromBytes(bytes1, "file:///test.bin");
|
||||
|
||||
Assert.Equal(bytes1, blob.DecodedData.ToArray());
|
||||
|
||||
byte[] newBytes = [4, 5, 6];
|
||||
string newBase64 = Convert.ToBase64String(newBytes);
|
||||
blob.Blob = Encoding.UTF8.GetBytes(newBase64);
|
||||
|
||||
Assert.Equal(newBytes, blob.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public static void BlobResourceContents_FromBytes_LazilyEncodesBlob(byte[] originalBytes)
|
||||
{
|
||||
var blob = BlobResourceContents.FromBytes(originalBytes, "file:///test.bin");
|
||||
|
||||
// Access DecodedData first without touching Blob
|
||||
Assert.Equal(originalBytes, blob.DecodedData.ToArray());
|
||||
|
||||
// Now access Blob and verify lazy encoding
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(blob.Blob.ToArray()));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue