public void HasDefaultMessage()
{
var response = new ApiResponse<object> { StatusCode = HttpStatusCode.Forbidden };
var forbiddenException = new ForbiddenException(response);
Assert.Equal("Request Forbidden", forbiddenException.Message);
}
public void HasDefaultMessage()
{
var response = new Response(HttpStatusCode.Forbidden, null, new Dictionary<string, string>(), "application/json");
var forbiddenException = new ForbiddenException(response);
Assert.Equal("Request Forbidden", forbiddenException.Message);
}
public void IdentifiesMaxLoginAttepmtsExceededReason()
{
const string responseBody = "{\"message\":\"YOU SHALL NOT PASS!\"," +
"\"documentation_url\":\"http://developer.github.com/v3\"}";
var response = new ApiResponse<object> { Body = responseBody, StatusCode = HttpStatusCode.Forbidden };
var forbiddenException = new ForbiddenException(response);
Assert.Equal("YOU SHALL NOT PASS!", forbiddenException.ApiError.Message);
}
public void IdentifiesMaxLoginAttepmtsExceededReason()
{
const string responseBody = "{\"message\":\"YOU SHALL NOT PASS!\"," +
"\"documentation_url\":\"http://developer.github.com/v3\"}";
var response = new Response(
HttpStatusCode.Forbidden,
responseBody,
new Dictionary<string, string>(),
"application/json");
var forbiddenException = new ForbiddenException(response);
Assert.Equal("YOU SHALL NOT PASS!", forbiddenException.ApiError.Message);
}
public async Task Should_Throw_Exception_ChatNotInitiatedException()
{
//ToDo add exception. forward message from another bot. Forbidden: bot can't send messages to bots
await _fixture.SendTestCaseNotificationAsync(FactTitles.ShouldThrowExceptionChatNotInitiatedException,
"Forward a message to this chat from a user that never started a chat with this bot");
Update forwardedMessageUpdate = (await _fixture.UpdateReceiver.GetUpdatesAsync(u =>
u.Message.ForwardFrom != null, updateTypes: UpdateType.Message
)).Single();
await _fixture.UpdateReceiver.DiscardNewUpdatesAsync();
ForbiddenException e = await Assert.ThrowsAnyAsync <ForbiddenException>(() =>
BotClient.SendTextMessageAsync(
forwardedMessageUpdate.Message.ForwardFrom.Id,
$"Error! If you see this message, talk to @{forwardedMessageUpdate.Message.From.Username}"
)
);
Assert.IsType <ChatNotInitiatedException>(e);
}
public static void ThrowForbiddendExceptionOnItemOperation(
Uri physicalAddress,
DocumentServiceRequest request,
string activityId,
string errorMessage)
{
if (request.ResourceType == ResourceType.Document)
{
StoreRequestNameValueCollection headers = new StoreRequestNameValueCollection();
headers.Add(HttpConstants.HttpHeaders.ActivityId, activityId.ToString());
headers.Add(WFConstants.BackendHeaders.SubStatus, ((int)SubStatusCodes.WriteForbidden).ToString(CultureInfo.InvariantCulture));
headers.Add(HttpConstants.HttpHeaders.RequestCharge, ((double)9001).ToString(CultureInfo.InvariantCulture));
ForbiddenException forbiddenException = new ForbiddenException(
errorMessage,
headers,
physicalAddress);
throw forbiddenException;
}
}
private void MessagesAreAddedToMessagesCollectionUnderSameKey()
{
var message1 = "message1";
var message2 = "messages2";
var messages1 = new string[] { message1 };
var messages2 = new string[] { message2 };
var ex = new ForbiddenException();
ex.AddMessages(messages1);
ex.AddMessages(messages2);
Assert.Equal(1, ex.Messages.Count);
var values = ex.Messages.SelectMany(m => m.Value);
var keys = ex.Messages.Select(m => m.Key);
Assert.Contains(message1, values);
Assert.Contains(message2, values);
Assert.All(keys, k => Assert.Equal(Defaults.ErrorMessage.Key, k));
}
public async Task Should_Throw_ForbiddenException_Sending_Message_To_Bot()
{
//ToDo add exception. forward message from another bot. Forbidden: bot can't send messages to bots
await Fixture.SendTestInstructionsAsync(
"Forward a message to this chat from another bot"
);
Update forwardedMessageUpdate = (await Fixture.UpdateReceiver.GetUpdatesAsync(u =>
u.Message?.ForwardFrom != null, updateTypes: UpdateType.Message
)).Single();
await Fixture.UpdateReceiver.DiscardNewUpdatesAsync();
ForbiddenException exception = await Assert.ThrowsAsync <ForbiddenException>(
async() => await BotClient.SendTextMessageAsync(
forwardedMessageUpdate !.Message !.ForwardFrom !.Id,
$"Error! If you see this message, talk to @{forwardedMessageUpdate.Message.From!.Username}"
)
);
Assert.Equal(403, exception.ErrorCode);
Assert.Contains("bot can't send messages to bots", exception.Message);
}
internal static IActionResult ErrorResult <TModel>(BaseException exception)
{
LogError <TModel>("An error has occurred.", exception);
var @try = HandleException <TModel>(exception);
return(@try.Match(
failure => failure switch
{
InvalidRequestException _ => new BadRequestObjectResult(@try),
ForbiddenException _ => new ObjectResult(@try)
{
StatusCode = 403
},
NotFoundException _ => new NotFoundObjectResult(@try),
AlreadyExistsException _ => new ConflictObjectResult(@try),
UnauthorizedException _ => new UnauthorizedObjectResult(@try),
InvalidObjectException _ => new UnprocessableEntityObjectResult(@try),
_ => new ObjectResult(@try)
{
StatusCode = 500
},
},
private async Task ValidateRetryOnDatabaseAccountNotFoundAsync(bool enableMultipleWriteLocations, bool isReadRequest)
{
this.Initialize(
useMultipleWriteLocations: enableMultipleWriteLocations,
enableEndpointDiscovery: true,
isPreferredLocationsListEmpty: false);
await this.endpointManager.RefreshLocationAsync(this.databaseAccount);
ClientRetryPolicy retryPolicy = new ClientRetryPolicy(this.endpointManager, true, new RetryOptions());
int expectedRetryCount = isReadRequest || enableMultipleWriteLocations ? 2 : 1;
using (DocumentServiceRequest request = this.CreateRequest(isReadRequest: isReadRequest, isMasterResourceType: false))
{
int retryCount = 0;
try
{
await BackoffRetryUtility <bool> .ExecuteAsync(
() =>
{
retryCount++;
retryPolicy.OnBeforeSendRequest(request);
if (retryCount == 1)
{
Uri expectedEndpoint = LocationCacheTests.EndpointByLocation[this.preferredLocations[0]];
Assert.AreEqual(expectedEndpoint, request.RequestContext.LocationEndpointToRoute);
StoreRequestNameValueCollection headers = new StoreRequestNameValueCollection();
headers[WFConstants.BackendHeaders.SubStatus] = ((int)SubStatusCodes.DatabaseAccountNotFound).ToString();
DocumentClientException forbiddenException = new ForbiddenException(RMResources.NotFound, headers);
throw forbiddenException;
}
else if (retryCount == 2)
{
// Next request must go to next preferred endpoint
Uri expectedEndpoint = LocationCacheTests.EndpointByLocation[this.preferredLocations[1]];
Assert.AreEqual(expectedEndpoint, request.RequestContext.LocationEndpointToRoute);
return(Task.FromResult(true));
}
else
{
Assert.Fail();
}
return(Task.FromResult(true));
},
retryPolicy);
}
catch (ForbiddenException)
{
if (expectedRetryCount == 1)
{
DefaultTrace.TraceInformation("Received expected ForbiddenException");
}
else
{
Assert.Fail();
}
}
Assert.AreEqual(expectedRetryCount, retryCount);
}
}
/// <summary>
/// handle exception
/// </summary>
/// <param name="e"></param>
private static void HandlerLoginException(Exception e)
{
if (e is NetworkException)
{
LoginUI.instance.ShowMessage("Invalid network");
}
else if (e is BadRequestException)
{
BadRequestException bre = (BadRequestException)e;
LoginUI.instance.ShowMessage("Error : " + bre.reason);
switch (bre.reason)
{
case BadRequestException.Reason.INVALID_ACCOUNT_STATUS:
break;
case BadRequestException.Reason.INVALID_BUCKET:
break;
case BadRequestException.Reason.INVALID_INPUT_DATA:
break;
case BadRequestException.Reason.INVALID_JSON:
break;
case BadRequestException.Reason.PASSWORD_TOO_SHORT:
break;
case BadRequestException.Reason.QUERY_NOT_SUPPORTED:
break;
case BadRequestException.Reason.__UNKNOWN__:
break;
default:
break;
}
}
else if (e is ConflictException)
{
ConflictException ce = (ConflictException)e;
LoginUI.instance.ShowMessage("Error : " + ce.reason);
switch (ce.reason)
{
case ConflictException.Reason.__UNKNOWN__:
break;
case ConflictException.Reason.ACL_ALREADY_EXISTS:
break;
case ConflictException.Reason.BUCKET_ALREADY_EXISTS:
break;
case ConflictException.Reason.INVALID_STATUS:
break;
case ConflictException.Reason.OBJECT_ALREADY_EXISTS:
break;
case ConflictException.Reason.OBJECT_VERSION_IS_STALE:
break;
case ConflictException.Reason.USER_ALREADY_EXISTS:
break;
default:
break;
}
}
else if (e is ForbiddenException)
{
ForbiddenException fbe = (ForbiddenException)e;
LoginUI.instance.ShowMessage("Error : " + fbe.Status);
}
else if (e is CloudException)
{
CloudException ce = (CloudException)e;
LoginUI.instance.ShowMessage("Error : " + ce.Status);
}
else
{
LoginUI.instance.ShowMessage("Unknow error");
}
}
