153 lines
6.1 KiB
C#
153 lines
6.1 KiB
C#
using System.Text;
|
|
using System.Text.Json;
|
|
using GAJ3T.MusicGen.RiffGrooveBuilder.Server.Protocol;
|
|
|
|
namespace GAJ3T.MusicGen.RiffGrooveBuilder.UnitTests.Protocol;
|
|
|
|
public sealed class StdioTransportTests
|
|
{
|
|
[Theory]
|
|
[InlineData("\n")]
|
|
[InlineData("\r\n")]
|
|
public async Task ReadsUtf8FramesAndDoesNotSplitEscapedNewlines(string delimiter)
|
|
{
|
|
const string json = """{"text":"音楽 café 🎸\nsecond line"}""";
|
|
using var input = new MemoryStream(Encoding.UTF8.GetBytes(json + delimiter + "{}" + delimiter));
|
|
using var transport = new StdioTransport(input, Stream.Null);
|
|
Assert.Equal(json, (await transport.ReadFrameAsync())?.Json);
|
|
Assert.Equal("{}", (await transport.ReadFrameAsync())?.Json);
|
|
Assert.Null(await transport.ReadFrameAsync());
|
|
}
|
|
|
|
[Fact]
|
|
public async Task EmptyEofHasNoFrameButEmptyLinesAreFrames()
|
|
{
|
|
using var empty = new StdioTransport(Stream.Null, Stream.Null);
|
|
Assert.Null(await empty.ReadFrameAsync());
|
|
using var input = new MemoryStream("\n\r\n"u8.ToArray());
|
|
using var transport = new StdioTransport(input, Stream.Null);
|
|
Assert.Equal("", (await transport.ReadFrameAsync())?.Json);
|
|
Assert.Equal("", (await transport.ReadFrameAsync())?.Json);
|
|
Assert.Null(await transport.ReadFrameAsync());
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("{}")]
|
|
[InlineData("not json")]
|
|
[InlineData("{}\r")]
|
|
public async Task NonemptyFinalFrameIsDeliveredOnceWithoutRequiringNewline(string text)
|
|
{
|
|
using var input = new MemoryStream(Encoding.UTF8.GetBytes(text));
|
|
using var transport = new StdioTransport(input, Stream.Null);
|
|
Assert.Equal(text, (await transport.ReadFrameAsync())?.Json);
|
|
Assert.Null(await transport.ReadFrameAsync());
|
|
Assert.Null(await transport.ReadFrameAsync());
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(new byte[] { 0xff })]
|
|
[InlineData(new byte[] { 0xc0, 0x80 })]
|
|
[InlineData(new byte[] { 0xe2, 0x82 })]
|
|
[InlineData(new byte[] { 0xed, 0xa0, 0x80 })]
|
|
public async Task InvalidUtf8IsRejectedAndNextFrameSurvives(byte[] invalid)
|
|
{
|
|
using var input = new MemoryStream([.. invalid, (byte)'\n', .. "{}\n"u8.ToArray()]);
|
|
using var transport = new StdioTransport(input, Stream.Null);
|
|
var rejected = await transport.ReadFrameAsync();
|
|
Assert.Null(rejected?.Json);
|
|
Assert.Equal(-32700, rejected?.Error?.Code);
|
|
Assert.Equal("{}", (await transport.ReadFrameAsync())?.Json);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("12345678\n", true)]
|
|
[InlineData("12345678\r\n", true)]
|
|
[InlineData("éééé\n", true)]
|
|
[InlineData("123456789\n", false)]
|
|
[InlineData("123456789\r\n", false)]
|
|
[InlineData("ééééa\n", false)]
|
|
[InlineData("123456789", false)]
|
|
public async Task LimitCountsUtf8BytesExcludingCrLf(string frame, bool accepted)
|
|
{
|
|
using var input = new MemoryStream(Encoding.UTF8.GetBytes(frame));
|
|
using var transport = new StdioTransport(input, Stream.Null, maxFrameBytes: 8);
|
|
var result = Assert.IsType<StdioFrame>(await transport.ReadFrameAsync());
|
|
Assert.Equal(accepted, result.Error is null);
|
|
if (!accepted)
|
|
{
|
|
Assert.Equal(-32600, result.Error!.Code);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task OversizedMultiBufferFrameResynchronizesWithOneBoundedError()
|
|
{
|
|
using var input = new MemoryStream(Encoding.UTF8.GetBytes(new string('x', 100_000) + "\n{}\n"));
|
|
using var transport = new StdioTransport(input, Stream.Null, maxFrameBytes: 32);
|
|
var result = await transport.ReadFrameAsync();
|
|
Assert.Equal(-32600, result?.Error?.Code);
|
|
Assert.True(result?.Error?.Message.Length < 100);
|
|
Assert.Equal("{}", (await transport.ReadFrameAsync())?.Json);
|
|
Assert.Null(await transport.ReadFrameAsync());
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ConcurrentWritesAreCompleteFlushedJsonLinesAndStreamsRemainOwnedByCaller()
|
|
{
|
|
using var output = new YieldingStream();
|
|
using (var transport = new StdioTransport(Stream.Null, output))
|
|
{
|
|
await Task.WhenAll(Enumerable.Range(0, 100)
|
|
.Select(id => transport.WriteMessageAsync(new { id, text = "音楽\nsecond line" })));
|
|
}
|
|
|
|
Assert.Equal(100, output.Flushes);
|
|
var lines = Encoding.UTF8.GetString(output.ToArray()).Split('\n');
|
|
Assert.Equal("", lines[^1]);
|
|
var ids = lines[..^1].Select(line =>
|
|
{
|
|
using var json = JsonDocument.Parse(line);
|
|
Assert.Equal("音楽\nsecond line", json.RootElement.GetProperty("text").GetString());
|
|
return json.RootElement.GetProperty("id").GetInt32();
|
|
});
|
|
Assert.Equal(Enumerable.Range(0, 100), ids.Order());
|
|
Assert.True(output.CanWrite);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CancellationInterruptsAnIdleRead()
|
|
{
|
|
using var input = new ChannelStream();
|
|
using var transport = new StdioTransport(input, Stream.Null);
|
|
using var cancellation = new CancellationTokenSource();
|
|
var read = transport.ReadFrameAsync(cancellation.Token).AsTask();
|
|
cancellation.Cancel();
|
|
await Assert.ThrowsAnyAsync<OperationCanceledException>(() => read.WaitAsync(TimeSpan.FromSeconds(3)));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task InvalidUtf8InFinalFrameIsRejectedRatherThanSilentlyReplaced()
|
|
{
|
|
using var input = new MemoryStream([0xe2, 0x82]);
|
|
using var transport = new StdioTransport(input, Stream.Null);
|
|
Assert.Equal(-32700, (await transport.ReadFrameAsync())?.Error?.Code);
|
|
Assert.Null(await transport.ReadFrameAsync());
|
|
}
|
|
|
|
private sealed class YieldingStream : MemoryStream
|
|
{
|
|
public int Flushes { get; private set; }
|
|
public override async ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
|
|
{
|
|
await Task.Yield();
|
|
await base.WriteAsync(buffer, cancellationToken);
|
|
}
|
|
|
|
public override Task FlushAsync(CancellationToken cancellationToken)
|
|
{
|
|
Flushes++;
|
|
return base.FlushAsync(cancellationToken);
|
|
}
|
|
}
|
|
}
|