private RedisSubscription(RedisConnectionSettings connectionSettings, Encoding encoding)
{
_connection = new RedisConnection(connectionSettings);
_writer = new RespWriter(_connection.GetStream());
_reader = new RespReader(_connection.GetStream());
_encoding = encoding ?? throw new ArgumentNullException(nameof(encoding));
}
public async Task SimpleConnect()
{
var stream = new MemoryStream();
var respWriter = new RespWriter(stream);
var hi = new SimpleStringMessage("HI {\"v\":\"1\"}");
var ok = new SimpleStringMessage("OK");
await respWriter.WriteAsync(hi);
await respWriter.WriteAsync(ok);
stream.Position = 0;
var transport = new Mock <IConnectionTransport>();
transport
.Setup(t => t.GetStreamAsync())
.Returns(Task.FromResult((Stream)stream));
var transportFactory = new Mock <IConnectionTransportFactory>();
transportFactory
.Setup(f => f.CreateTransport())
.Returns(transport.Object);
var configuration = new Mock <IConnectionConfiguration>();
configuration
.Setup(c => c.TransportFactory)
.Returns(transportFactory.Object);
configuration
.Setup(c => c.Identity)
.Returns(WorkerConnectionIdentity.GenerateNew);
var connection = new FaktoryConnection(configuration.Object);
await connection.ConnectAsync();
}
public override void TestSynWithRsp1Handler(ReqReader request, RespWriter response)
{
string resp;
SynWithRsp1Result = Utils.CalcForSynRsp(request.FieldBeforeList, request.Nums, request.FieldAfterList, out resp);
response.result = resp;
}
public async Task <T> ExecuteAsync()
{
using (var writer = new RespWriter(_stream))
{
await WriteStartCommandAsync(writer);
await WriteParametersAsync(writer);
await WriteEndCommandAsync(writer);
}
using var reader = new RespReader(_stream);
return(ReadResult(reader).Result);
}
public T Execute()
{
using (var writer = new RespWriter(_stream))
{
WriteStartCommand(writer);
WriteParameters(writer);
WriteEndCommand(writer);
}
using var reader = new RespReader(_stream);
return(ReadResult(reader).Result);
}
private static async Task AssertWrite(string rawMessage, RespMessage message)
{
var stream = new MemoryStream();
var respWriter = new RespWriter(stream);
await respWriter.WriteAsync(message);
stream.Position = 0;
var streamReader = new StreamReader(stream);
var actual = await streamReader.ReadToEndAsync();
Assert.That(actual, Is.EqualTo(rawMessage));
}
public async Task Should_write_normal_messages(string name, string rawMessage, RespMessage message)
{
await AssertWrite(rawMessage, message);
var stream = new MemoryStream();
var respWriter = new RespWriter(stream);
await respWriter.WriteAsync(message);
stream.Position = 0;
var streamReader = new StreamReader(stream);
var actual = await streamReader.ReadToEndAsync();
Assert.That(actual, Is.EqualTo(rawMessage));
}
private static async Task WriteEndCommandAsync(RespWriter writer)
{
await writer.WriteEndArrayAsync();
}
private static async Task WriteParameterBulkStringAsync(RespWriter writer, byte[] value)
{
await writer.WriteBulkStringAsync(value);
}
private static async Task WriteParameterIntegerAsync(RespWriter writer, long value)
{
await writer.WriteIntegerAsync(value);
}
private static async Task WriteParameterSimpleStringUnsafeAsync(RespWriter writer, string value)
{
await writer.WriteSimpleStringUnsafeAsync(value);
}
private static async Task WriteStartCommandAsync(RespWriter writer, string command)
{
await writer.WriteStartArrayAsync();
await writer.WriteBulkStringAsync(command);
}
