public void Exception_ResponseMessageConstructor()
{
var response = new RiotResponse(null);
var message = "TEST";
var ex1 = new RestException(response, message);
Assert.That(ex1.Response, Is.EqualTo(response));
Assert.That(ex1.Message, Is.EqualTo(message));
var ex2 = new NotFoundException(response, message);
Assert.That(ex2.Response, Is.EqualTo(response));
Assert.That(ex2.Message, Is.EqualTo(message));
var ex3 = new RateLimitExceededException(response, message);
Assert.That(ex3.Response, Is.EqualTo(response));
Assert.That(ex3.Message, Is.EqualTo(message));
var ex4 = new RestTimeoutException(response, message);
Assert.That(ex4.Response, Is.EqualTo(response));
Assert.That(ex4.Message, Is.EqualTo(message));
var ex5 = new ConnectionFailedException(response, message);
Assert.That(ex5.Response, Is.EqualTo(response));
Assert.That(ex5.Message, Is.EqualTo(message));
}
public void Exception_DefaultConstructor()
{
var ex1 = new RestException();
Assert.That(ex1.Response, Is.EqualTo(null));
Assert.That(ex1.Message, Is.EqualTo("A REST request failed."));
Assert.That(ex1.InnerException, Is.Null);
var ex2 = new NotFoundException();
Assert.That(ex2.Response, Is.EqualTo(null));
Assert.That(ex2.Message, Is.EqualTo("The requested resource was not found."));
Assert.That(ex2.InnerException, Is.Null);
var ex3 = new RateLimitExceededException();
Assert.That(ex3.Response, Is.EqualTo(null));
Assert.That(ex3.Message, Is.EqualTo("The rate limit for the current API key was exceeded."));
Assert.That(ex3.InnerException, Is.Null);
var ex4 = new RestTimeoutException();
Assert.That(ex4.Response, Is.EqualTo(null));
Assert.That(ex4.Message, Is.EqualTo("A REST request timed out."));
Assert.That(ex4.InnerException, Is.Null);
var ex5 = new ConnectionFailedException();
Assert.That(ex5.Response, Is.EqualTo(null));
Assert.That(ex5.Message, Is.EqualTo("Failed to connect to the server."));
Assert.That(ex5.InnerException, Is.Null);
}
public void Connect()
{
try
{
if (Connected)
{
return;
}
var gui = ConnectToGui();
ConnectToCompany(gui);
Connected = true;
}
catch (COMException e)
{
throw ConnectionFailedException.CreateFrom(e);
}
}
public void Connect()
{
try
{
if (Connected)
{
return;
}
var gui = new SboGuiApi();
gui.Connect(connectionString);
Application = gui.GetApplication();
}
catch (COMException e)
{
throw ConnectionFailedException.CreateFrom(e);
}
Connected = true;
}
public void Exception_ResponseConstructor_NullHttpResponse()
{
var response = new RiotResponse(null);
var ex1 = new RestException(response);
Assert.That(ex1.Response, Is.EqualTo(response));
var ex2 = new NotFoundException(response);
Assert.That(ex2.Response, Is.EqualTo(response));
var ex3 = new RateLimitExceededException(response);
Assert.That(ex3.Response, Is.EqualTo(response));
var ex4 = new RestTimeoutException(response);
Assert.That(ex4.Response, Is.EqualTo(response));
var ex5 = new ConnectionFailedException(response);
Assert.That(ex5.Response, Is.EqualTo(response));
}
public void Exception_ResponseConstructor()
{
var response = new RiotResponse(new HttpResponseMessage(System.Net.HttpStatusCode.OK));
var ex1 = new RestException(response);
Assert.That(ex1.Response, Is.EqualTo(response));
var ex2 = new NotFoundException(response);
Assert.That(ex2.Response, Is.EqualTo(response));
var ex3 = new RateLimitExceededException(response);
Assert.That(ex3.Response, Is.EqualTo(response));
var ex4 = new RestTimeoutException(response);
Assert.That(ex4.Response, Is.EqualTo(response));
var ex5 = new ConnectionFailedException(response);
Assert.That(ex5.Response, Is.EqualTo(response));
}
public void TestExceptions()
{
{
AlreadyExistsException v1 = new AlreadyExistsException("ex");
AlreadyExistsException v2 = (AlreadyExistsException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
ConfigurationException v1 = new ConfigurationException("ex");
ConfigurationException v2 = (ConfigurationException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
ConnectionBrokenException v1 = new ConnectionBrokenException("ex");
ConnectionBrokenException v2 = (ConnectionBrokenException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
ConnectionFailedException v1 = new ConnectionFailedException("ex");
ConnectionFailedException v2 = (ConnectionFailedException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
ConnectorException v1 = new ConnectorException("ex");
ConnectorException v2 = (ConnectorException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
ConnectorIOException v1 = new ConnectorIOException("ex");
ConnectorIOException v2 = (ConnectorIOException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
ConnectorSecurityException v1 = new ConnectorSecurityException("ex");
ConnectorSecurityException v2 = (ConnectorSecurityException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
InvalidCredentialException v1 = new InvalidCredentialException("ex");
InvalidCredentialException v2 = (InvalidCredentialException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
InvalidPasswordException v1 = new InvalidPasswordException("ex");
InvalidPasswordException v2 = (InvalidPasswordException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
PasswordExpiredException v1 = new PasswordExpiredException("ex");
v1.Uid = (new Uid("myuid"));
PasswordExpiredException v2 = (PasswordExpiredException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
Assert.AreEqual("myuid", v2.Uid.GetUidValue());
}
{
OperationTimeoutException v1 = new OperationTimeoutException("ex");
OperationTimeoutException v2 = (OperationTimeoutException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
PermissionDeniedException v1 = new PermissionDeniedException("ex");
PermissionDeniedException v2 = (PermissionDeniedException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
UnknownUidException v1 = new UnknownUidException("ex");
UnknownUidException v2 = (UnknownUidException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
ArgumentException v1 = new ArgumentException("my msg");
ArgumentException v2 = (ArgumentException)CloneObject(v1);
Assert.AreEqual("my msg", v2.Message);
}
{
ArgumentNullException v1 = new ArgumentNullException(null, "my msg 1");
ArgumentException v2 = (ArgumentException)CloneObject(v1);
Assert.AreEqual("my msg 1", v2.Message);
}
{
Exception v1 = new Exception("my msg2");
Exception v2 = (Exception)CloneObject(v1);
Assert.AreEqual("my msg2", v2.Message);
}
}
/// <summary>
/// Initializes an authorized connection to Telegram
/// </summary>
private async Task InitConnect()
{
Logger.Log(Logger.Level.Info, "Attempting connection");
// Attempt to connect X number of times
for (int i = 0; i < RetryCount; i++)
{
try
{
if (i > 0)
{
Logger.Log(Logger.Level.Info, "Reattempting connection");
}
Connection.Connect(ConnectionTimeout);
Logger.Log(Logger.Level.Info, $"Connection created after {i + 1} attempt(s)");
break;
}
catch (Exception ex)
{
Logger.Log(new ConnectionFailedException($"Connection attempt {i + 1} has failed.\n\n\t{ex.Message}", ex));
Logger.Log(Logger.Level.Info, $"Sleeping for {RetryDelay}ms");
await Task.Delay(RetryDelay);
}
}
if (!Connection.IsConnected)
{
var sad = new ConnectionFailedException($"Failed to connect to Telegram {RetryCount} times in a row.");
Logger.Log(sad);
throw sad;
}
// Determine if we need to secure the connection
if (State.AuthInfo.AuthKey == null)
{
Logger.Log(Logger.Level.Info, "Attempting to secure the connection");
// Initialize a new instance of the plan sender based on the same connection
using (var plain = new MTProtoPlainSender(Connection))
{
// Attempt to authenticate X number of times
for (int i = 0; i < RetryCount; i++)
{
try
{
if (i > 0)
{
Logger.Log(Logger.Level.Info, "Reattempting to secure the connection");
}
State.AuthInfo = await new Authenticator(plain).DoAuthentication().TimeoutAfter(ConnectionTimeout);
Logger.Log(Logger.Level.Info, $"Obtained a secure connection after {i + 1} attempt(s)");
break;
}
catch (Exception ex)
{
Logger.Log(Logger.Level.Error, $"Securing attempt {i + 1} has failed.\n\n\t{ex.Message}");
Logger.Log(Logger.Level.Info, $"Sleeping for {RetryDelay}ms");
await Task.Delay(RetryDelay);
}
}
}
// Determine if the authorization was successful
if (State.AuthInfo.AuthKey == null)
{
var sad = new ConnectionFailedException($"Failed to secure the connection {RetryCount} times in a row.");
Logger.Log(sad);
Disconnect();
throw sad;
}
}
// Get ourselves ready to handle requests
CommunicationEstablished = true;
Logger.Log <MTProtoSender>(Logger.Level.Debug, $"Attaching event handlers");
Connection.DataReceivedEvent += Connection_DataReceivedEvent;
Logger.Log <MTProtoSender>(Logger.Level.Debug, $"Starting Ack Handler");
AckCancellation = new CancellationTokenSource();
AckHandler = Task.Run(() => AckHandlerMethod(AckCancellation.Token));
}
