public object Deserialize(IByteBuffer buffer, SerializationMetadata metadata)
{
var rpcResult = new TRpcResult
{
ReqMsgId = buffer.ReadLongLE(),
Result = buffer.ToArray()
};
return(rpcResult);
}
public async Task ReturnError_Migration(string errorMessage)
{
this.BuildClientSettingsProps();
this.RegisterType <RpcResultHandler>();
var mSettings = this.BuildClientSettingsProps();
this.Resolve <Mock <ISessionWriter> >()
.BuildSuccessSave();
var dcOption = mSettings.Object.Config.DcOptions.First();
var messageId = Fixture.Create <long>();
var result = new TRpcError
{
ErrorMessage = errorMessage + dcOption.Id
};
var request = new TRpcResult
{
ReqMsgId = messageId,
Result = Serializer.Serialize(result).ToArray()
};
var requestEncoder = this.Resolve <RpcResultHandler>();
var channel = new EmbeddedChannel(requestEncoder);
// ---
channel.WriteInbound(request);
await Task.Delay(500).ConfigureAwait(false);
// ---
Assert.IsType <TMsgsAck>(channel.ReadOutbound <TMsgsAck>());
Assert.False(channel.Open);
Assert.Equal(dcOption.IpAddress, mSettings.Object.ClientSession.ServerAddress);
Assert.Equal(dcOption.Port, mSettings.Object.ClientSession.Port);
Assert.Null(mSettings.Object.ClientSession.AuthKey);
}
public void ReturnZippedResult()
{
this.BuildClientSettingsProps();
this.RegisterType <RpcResultHandler>();
var messageId = Fixture.Create <long>();
var result = new TPong();
var tgZipPacked = new TgZipPacked
{
PackedData = Fixture.CreateMany <byte>(8).ToArray()
};
var request = new TRpcResult
{
ReqMsgId = messageId,
Result = Serializer.Serialize(tgZipPacked).ToArray()
};
this.Resolve <Mock <IUnzippedService> >()
.Setup(service => service.UnzipPackage(tgZipPacked))
.Returns(() => result);
var mRequestService = this.Resolve <Mock <IRequestService> >()
.BuildReturnResult(messageId, result);
var requestEncoder = this.Resolve <RpcResultHandler>();
var channel = new EmbeddedChannel(requestEncoder);
// ---
channel.WriteInbound(request);
// ---
Assert.Null(channel.ReadOutbound <object>());
channel.Flush();
Assert.IsType <TMsgsAck>(channel.ReadOutbound <TMsgsAck>());
mRequestService.Verify(service => service.ReturnResult(messageId, result), Times.Once);
}
public void ReturnError_SimpleCases(string errorMessage, Type exceptionType)
{
this.BuildClientSettingsProps();
this.RegisterType <RpcResultHandler>();
var messageId = Fixture.Create <long>();
var result = new TRpcError
{
ErrorMessage = errorMessage
};
var request = new TRpcResult
{
ReqMsgId = messageId,
Result = Serializer.Serialize(result).ToArray()
};
var mRequestService = this.Resolve <Mock <IRequestService> >()
.BuildReturnException(messageId, exceptionType);
var requestEncoder = this.Resolve <RpcResultHandler>();
var channel = new EmbeddedChannel(requestEncoder);
// ---
channel.WriteInbound(request);
// ---
Assert.Null(channel.ReadOutbound <object>());
channel.Flush();
Assert.IsType <TMsgsAck>(channel.ReadOutbound <TMsgsAck>());
mRequestService.Verify(service => service.ReturnException(messageId, It.Is <Exception>(ex => ex.GetType() == exceptionType)), Times.Once);
}
public void Recieve_SimpleCall_NotThrows()
{
const long RequestMessageId = 1234;
var authKeyData = SessionMock.GenerateAuthKeyData();
const ulong sessionId = 123456;
const ulong salt = 654321;
uint[] rpcResponceCode = { 0xf35c6d01 };
var sendUser = new TDialog
{
ReadInboxMaxId = 132,
Peer = new TPeerUser {
UserId = 123
},
NotifySettings = new TPeerNotifySettingsEmpty(),
Draft = new TDraftMessageEmpty()
};
var mSession = SessionMock.Create().BuildSession(sessionId, salt, authKeyData);
this.RegisterMock(mSession);
var mClientSettings = ClientSettingsMock.Create().AttachSession(() => mSession.Object);
this.RegisterMock(mClientSettings);
var mTcpTransport = TcpTransportMock.Create().BuildReceieve(out var tsc);
this.RegisterMock(mTcpTransport);
var mConfrimSendService = ConfirmationSendServiceMock.Create().BuildAddForSend(messageId => Assert.Equal(RequestMessageId, messageId));
this.RegisterMock(mConfrimSendService);
var mRecieveHandler = RecieveHandlerMock.Create().BuildRecieveHandler(rpcResponceCode).BuildHandleResponce(
(code, reader) =>
{
Assert.Equal(RequestMessageId, reader.ReadInt64());
return(null);
});
this.RegisterMock(mRecieveHandler);
this.RegisterAdapterForHandler();
this.RegisterType <RecievingService>();
// ---
var rpcResult = new TRpcResult {
ReqMsgId = RequestMessageId, Result = sendUser
};
var recieveData = EncodePacket(Serializer.SerializeObject(rpcResult), RequestMessageId);
var mtProtoPlainSender = this.Resolve <RecievingService>();
mtProtoPlainSender.StartReceiving();
Thread.Sleep(500);
tsc.SetResult(recieveData);
Thread.Sleep(500);
// --
mRecieveHandler.Verify(recieveService => recieveService.HandleResponce(It.IsAny <BinaryReader>()), Times.Once);
mConfrimSendService.Verify(recieveService => recieveService.AddForSend(It.IsAny <long>()), Times.Once);
}