public void Equality2Fact()
{
var graphQLError1 = new GraphQLError("message");
var graphQLError2 = new GraphQLError("message");
Assert.Equal(graphQLError1, graphQLError2);
}
public void InEquality1Fact()
{
var graphQLError1 = new GraphQLError("message1");
var graphQLError2 = new GraphQLError("message2");
Assert.NotEqual(graphQLError1, graphQLError2);
}
public void AddError(string message, RequestObjectBase item, string errorType = ErrorCodes.BadRequest)
{
var path = item.GetRequestObjectPath();
var err = new GraphQLError(message, path, item.SourceLocation, errorType);
AddError(err);
}
private GraphQLError AddVariableError(string message)
{
var err = new GraphQLError(message, null, SourceLocation.StartLocation, ErrorCodes.InputError);
_requestContext.AddError(err);
return(err);
}
public static void AddInputError(this IRequestContext context, InvalidInputException exc)
{
var path = exc.Anchor.GetRequestObjectPath();
var loc = exc.Anchor.SourceLocation;
var err = new GraphQLError(exc.Message, path, loc, ErrorCodes.InputError);
context.AddError(err);
}
public static void AddInputError(this RequestContext context, string message, RequestObjectBase anchor)
{
var path = anchor.GetRequestObjectPath();
var loc = anchor.SourceLocation;
var err = new GraphQLError(message, path, loc, ErrorCodes.InputError);
context.AddError(err);
}
private void AddError(string message, ParseTreeNode node)
{
var path = _path.ToArray().Reverse().ToArray();
var loc = node?.GetLocation() ?? SourceLocation.StartLocation;
var err = new GraphQLError(message, path, loc, ErrorCodes.BadRequest);
_requestContext.AddError(err);
}
internal static void ThrowRequestCancelled(this FieldContext fieldContext)
{
var reqCtx = (RequestContext)fieldContext.RequestContext;
var err = new GraphQLError($"Request cancelled",
fieldContext.GetFullRequestPath(), fieldContext.SelectionField.SourceLocation, type: "Cancel");
reqCtx.AddError(err);
throw new AbortRequestException();
}
public void ConstructorFact()
{
var graphQLError = new GraphQLError("message");
Assert.NotNull(graphQLError.Message);
Assert.Null(graphQLError.Extensions);
Assert.Null(graphQLError.Locations);
Assert.Null(graphQLError.Path);
}
internal static void ThrowObjectCountExceededQuota(this FieldContext fieldContext)
{
var reqCtx = (RequestContext)fieldContext.RequestContext;
var quota = reqCtx.Quota;
var err = new GraphQLError($"Output object count exceeded maximum ({quota.MaxOutputObjects}) allowed by quota.",
fieldContext.GetFullRequestPath(), fieldContext.SelectionField.SourceLocation, type: "Quota");
reqCtx.AddError(err);
throw new AbortRequestException();
}
private void AddError(RequestContext context, string message, IList <object> path)
{
var err = new GraphQLError()
{
Message = "Variables: " + message,
Path = path
};
context.AddError(err);
}
public void ThrowExceptionIfGraphQLErrorResponseHasError_whenErrorExceptionIsNull_throwsUnexpectedException()
{
GraphQLError error = new GraphQLError();
GraphQLResponse response = new GraphQLResponse();
response.errors = new List <GraphQLError>();
response.errors.Add(new GraphQLError());
Assert.Throws <UnexpectedException> (() => BraintreeGraphQLService.ThrowExceptionIfGraphQLErrorResponseHasError(response));
}
private void OnCancelled()
{
if (!_externalCancelled)
{
// we assume it's timeout, token is already signaling; add error
var err = new GraphQLError(
$"Request canceled, request time exceeded max specified by quota ({Quota.MaxOutputObjects}).", type: "Quota");
AddError(err);
}
}
public static GraphQLError AddError(this IFieldContext fieldContext, string message,
string type = ErrorCodes.InputError)
{
var loc = fieldContext.SelectionField.SourceLocation;
var path = fieldContext.GetFullRequestPath();
var err = new GraphQLError(message, path, loc, type);
fieldContext.AddError(err);
return(err);
}
public void AddError(GraphQLError error, Exception sourceException = null)
{
lock (this.Lock) {
this.Response.Errors.Add(error);
if (sourceException != null)
{
this.Exceptions.Add(sourceException);
}
this.Failed = true;
}
}
internal static void ThrowFieldDepthExceededQuota(this FieldContext fieldContext)
{
var reqCtx = (RequestContext)fieldContext.RequestContext;
var quota = reqCtx.Quota;
var sourceLoc = fieldContext.SourceLocation;
var err = new GraphQLError($"Query depth exceeded maximum ({quota.MaxDepth}) allowed by quota.",
fieldContext.GetFullRequestPath(), sourceLoc, type: "Quota");
reqCtx.AddError(err);
throw new AbortRequestException();
}
public async Task <IActionResult> Post([FromBody] GraphQLQuery query)
{
this._schemaFactory.WithHttpRequest(this.Request)
.DefinePolicy();
if (this._schemaFactory.Type == EPolicyType.Unknown)
{
return(this.BadRequest());
}
var executionOptions = new ExecutionOptions
{
Schema = this._schemaFactory.ProvideSchema(),
Query = query.Query,
Inputs = query.Variables.ToInputs(),
UserContext = this._schemaFactory.ProvideContext(),
};
var result = await this._documentExecuter.ExecuteAsync(executionOptions).ConfigureAwait(false);
if (result.Errors?.Count > 0)
{
var response = new GraphQLError
{
Message = "Internal server error: ",
Code = 500
};
result.Errors?.ForEach(c =>
{
if (c.InnerException != null && c.InnerException is AmazingException exception)
{
response.Message = exception.Message;
response.Code = (int)exception.Status;
}
else if (c.InnerException != null)
{
response.Message = c.InnerException.Message;
}
else
{
response.Message += c.Message;
}
});
return(Ok(new
{
errors = new List <GraphQLError> {
response
}
}));
}
return(this.Ok(result));
}
public static GraphQLError AddError(this RequestContext requestContext, Exception exc,
IList <object> path = null, SourceLocation location = null)
{
var err = new GraphQLError(exc.Message, path, location, ErrorCodes.ServerError);
var withDet = requestContext.Server.Settings.Options.IsSet(GraphQLServerOptions.ReturnExceptionDetails);
if (withDet)
{
err.Extensions["Details"] = exc.ToText();
}
requestContext.AddError(err, exc);
return(err);
}
public static void AddError(this FieldContext fieldContext, Exception exc, string errorType)
{
var reqCtx = (RequestContext)fieldContext.RequestContext;
var path = fieldContext.GetFullRequestPath();
var err = new GraphQLError(exc.Message, path, fieldContext.SelectionField.SourceLocation, type: errorType);
var withDet = reqCtx.Server.Settings.Options.IsSet(GraphQLServerOptions.ReturnExceptionDetails);
if (withDet)
{
err.Extensions["Details"] = exc.ToText();
}
reqCtx.AddError(err, exc);
}
public void InEquality2Fact()
{
var graphQLError1 = new GraphQLError("message")
{
Locations = new[] { new GraphQLLocation {
Column = 1, Line = 2
} }
};
var graphQLError2 = new GraphQLError("message")
{
Locations = new[] { new GraphQLLocation {
Column = 2, Line = 1
} }
};
Assert.NotEqual(graphQLError1, graphQLError2);
}
public void GetHashCodeFact()
{
var graphQLError1 = new GraphQLError("message")
{
Locations = new[] { new GraphQLLocation {
Column = 1, Line = 2
} }
};
var graphQLError2 = new GraphQLError("message")
{
Locations = new[] { new GraphQLLocation {
Column = 1, Line = 2
} }
};
Assert.True(graphQLError1.GetHashCode() == graphQLError2.GetHashCode());
}
public void ThrowExceptionIfGraphQLErrorResponseHasError_whenErrorClassIsUnsupportedClient_throwsUnsupportedClientException()
{
Dictionary <string, string> extensions = new Dictionary <string, string>();
extensions.Add("errorClass", "UNSUPPORTED_CLIENT");
GraphQLError error = new GraphQLError();
error.extensions = extensions;
GraphQLResponse response = new GraphQLResponse();
response.errors = new List <GraphQLError>();
response.errors.Add(error);
Assert.Throws <UpgradeRequiredException> (() => BraintreeGraphQLService.ThrowExceptionIfGraphQLErrorResponseHasError(response));
}
public void ThrowExceptionIfGraphQLErrorResponseHasError_whenErrorClassIsNotFound_throwsNotFoundException()
{
Dictionary <string, string> extensions = new Dictionary <string, string>();
extensions.Add("errorClass", "NOT_FOUND");
GraphQLError error = new GraphQLError();
error.extensions = extensions;
GraphQLResponse response = new GraphQLResponse();
response.errors = new List <GraphQLError>();
response.errors.Add(error);
Assert.Throws <NotFoundException> (() => BraintreeGraphQLService.ThrowExceptionIfGraphQLErrorResponseHasError(response));
}
public void ThrowExceptionIfGraphQLErrorResponseHasError_whenErrorClassIsAuthorization_throwsAuthorizationException()
{
Dictionary <string, string> extensions = new Dictionary <string, string>();
extensions.Add("errorClass", "AUTHORIZATION");
GraphQLError error = new GraphQLError();
error.extensions = extensions;
GraphQLResponse response = new GraphQLResponse();
response.errors = new List <GraphQLError>();
response.errors.Add(error);
Assert.Throws <AuthorizationException> (() => BraintreeGraphQLService.ThrowExceptionIfGraphQLErrorResponseHasError(response));
}
public void ThrowExceptionIfGraphQLErrorResponseHasError_whenErrorClassIsUnknown_throwsUnexpectedException()
{
Dictionary <string, string> extensions = new Dictionary <string, string>();
extensions.Add("errorClass", "UNKNOWN");
GraphQLError error = new GraphQLError();
error.extensions = extensions;
GraphQLResponse response = new GraphQLResponse();
response.errors = new List <GraphQLError>();
response.errors.Add(error);
Assert.Throws <UnexpectedException> (() => BraintreeGraphQLService.ThrowExceptionIfGraphQLErrorResponseHasError(response));
}
public void ThrowExceptionIfGraphQLErrorResponseHasError_whenErrorClassIsBraintreeServiceAvailability_throwsDownForMaintanceException()
{
Dictionary <string, string> extensions = new Dictionary <string, string>();
extensions.Add("errorClass", "SERVICE_AVAILABILITY");
GraphQLError error = new GraphQLError();
error.extensions = extensions;
GraphQLResponse response = new GraphQLResponse();
response.errors = new List <GraphQLError>();
response.errors.Add(error);
Assert.Throws <DownForMaintenanceException> (() => BraintreeGraphQLService.ThrowExceptionIfGraphQLErrorResponseHasError(response));
}
public void EqualityOperatorFact()
{
var graphQLError1 = new GraphQLError("message")
{
Locations = new[] { new GraphQLLocation {
Column = 1, Line = 2
} }
};
var graphQLError2 = new GraphQLError("message")
{
Locations = new[] { new GraphQLLocation {
Column = 1, Line = 2
} }
};
Assert.True(graphQLError1 == graphQLError2);
}
public void ThrowExceptionIfGraphQLErrorResponseHasError_whenErrorClassIsResourceLimit_throwsTooManyRequestsException()
{
Dictionary <string, string> extensions = new Dictionary <string, string>();
extensions.Add("errorClass", "RESOURCE_LIMIT");
GraphQLError error = new GraphQLError();
error.extensions = extensions;
GraphQLResponse response = new GraphQLResponse();
response.errors = new List <GraphQLError>();
response.errors.Add(error);
Assert.Throws <TooManyRequestsException> (() => BraintreeGraphQLService.ThrowExceptionIfGraphQLErrorResponseHasError(response));
}
public void DoNotThrowExceptionIfGraphQLErrorResponseHasError_whenErrorClassIsValidation()
{
Dictionary <string, string> extensions = new Dictionary <string, string>();
extensions.Add("errorClass", "VALIDATION");
GraphQLError error = new GraphQLError();
error.extensions = extensions;
GraphQLResponse response = new GraphQLResponse();
response.errors = new List <GraphQLError>();
response.errors.Add(error);
BraintreeGraphQLService.ThrowExceptionIfGraphQLErrorResponseHasError(response);
}
public void ThrowExceptionIfGraphQLErrorResponseHasError_whenErrorClassIsInternal_throwsServerException()
{
Dictionary <string, string> extensions = new Dictionary <string, string>();
extensions.Add("errorClass", "INTERNAL");
GraphQLError error = new GraphQLError();
error.extensions = extensions;
GraphQLResponse response = new GraphQLResponse();
response.errors = new List <GraphQLError>();
response.errors.Add(error);
Assert.Throws <ServerException> (() => BraintreeGraphQLService.ThrowExceptionIfGraphQLErrorResponseHasError(response));
}
