public void SameTypeInnerErrorOfNonFulcrumType()
{
FulcrumApplication.Context.CorrelationId = Guid.NewGuid().ToString();
var innerFulcrumError = new FulcrumError
{
TechnicalMessage = Guid.NewGuid().ToString(),
InstanceId = Guid.NewGuid().ToString(),
Type = "NotFulcrum"
};
var fulcrumError = new FulcrumError
{
Type = FulcrumConflictException.ExceptionType,
TechnicalMessage = Guid.NewGuid().ToString(),
FriendlyMessage = Guid.NewGuid().ToString(),
InstanceId = Guid.NewGuid().ToString(),
CorrelationId = Guid.NewGuid().ToString(),
Code = Guid.NewGuid().ToString(),
ErrorLocation = Guid.NewGuid().ToString(),
IsRetryMeaningful = true,
MoreInfoUrl = Guid.NewGuid().ToString(),
RecommendedWaitTimeInSeconds = 100.0,
ServerTechnicalName = Guid.NewGuid().ToString(),
InnerError = innerFulcrumError,
InnerInstanceId = innerFulcrumError.InstanceId
};
var fulcrumException = ExceptionConverter.ToFulcrumException(fulcrumError);
// Inner exception
Assert.IsNull(fulcrumException.InnerException);
}
public void ExceptionToError()
{
var fulcrumException = new FulcrumAssertionFailedException(Guid.NewGuid().ToString())
{
TechnicalMessage = Guid.NewGuid().ToString(),
FriendlyMessage = Guid.NewGuid().ToString(),
CorrelationId = Guid.NewGuid().ToString(),
Code = Guid.NewGuid().ToString(),
ErrorLocation = Guid.NewGuid().ToString(),
MoreInfoUrl = Guid.NewGuid().ToString(),
RecommendedWaitTimeInSeconds = 100.0,
ServerTechnicalName = Guid.NewGuid().ToString()
};
var fulcrumError = new FulcrumError();
fulcrumError.CopyFrom(fulcrumException);
// Equal
UT.Assert.AreEqual(fulcrumError.Code, fulcrumException.Code);
UT.Assert.AreEqual(fulcrumError.RecommendedWaitTimeInSeconds, fulcrumException.RecommendedWaitTimeInSeconds);
UT.Assert.AreEqual(fulcrumError.ServerTechnicalName, fulcrumException.ServerTechnicalName);
UT.Assert.AreEqual(fulcrumError.FriendlyMessage, fulcrumException.FriendlyMessage);
UT.Assert.AreEqual(fulcrumError.Type, fulcrumException.Type);
UT.Assert.AreEqual(fulcrumError.MoreInfoUrl, fulcrumException.MoreInfoUrl);
UT.Assert.AreEqual(fulcrumError.ServerTechnicalName, fulcrumException.ServerTechnicalName);
UT.Assert.AreEqual(fulcrumError.CorrelationId, fulcrumException.CorrelationId);
UT.Assert.AreEqual(fulcrumError.InstanceId, fulcrumException.InstanceId);
UT.Assert.AreEqual(fulcrumError.IsRetryMeaningful, fulcrumException.IsRetryMeaningful);
UT.Assert.AreEqual(fulcrumError.ErrorLocation, fulcrumException.ErrorLocation);
UT.Assert.AreEqual(fulcrumError.InstanceId, fulcrumException.InstanceId);
UT.Assert.AreEqual(fulcrumError.InnerInstanceId, fulcrumException.InnerInstanceId);
// Other tests
UT.Assert.IsNull(fulcrumException.InnerException);
}
public void ConvertedTypeNoInnerError()
{
FulcrumApplication.Context.CorrelationId = Guid.NewGuid().ToString();
var fulcrumError = new FulcrumError
{
Type = FulcrumAssertionFailedException.ExceptionType,
TechnicalMessage = Guid.NewGuid().ToString(),
FriendlyMessage = Guid.NewGuid().ToString(),
InstanceId = Guid.NewGuid().ToString(),
CorrelationId = Guid.NewGuid().ToString(),
Code = Guid.NewGuid().ToString(),
ErrorLocation = Guid.NewGuid().ToString(),
IsRetryMeaningful = true,
MoreInfoUrl = Guid.NewGuid().ToString(),
RecommendedWaitTimeInSeconds = 100.0,
ServerTechnicalName = Guid.NewGuid().ToString()
};
var fulcrumException = ExceptionConverter.ToFulcrumException(fulcrumError);
Assert.AreNotEqual(fulcrumError.Type, fulcrumException.Type);
// Equal
Assert.IsNotNull(fulcrumException);
Assert.AreEqual(fulcrumError.TechnicalMessage, fulcrumException.TechnicalMessage);
Assert.AreEqual(fulcrumError.TechnicalMessage, fulcrumException.Message);
Assert.AreEqual(fulcrumError.RecommendedWaitTimeInSeconds, fulcrumException.RecommendedWaitTimeInSeconds);
Assert.AreEqual(fulcrumError.IsRetryMeaningful, fulcrumException.IsRetryMeaningful);
// NOT equal
Assert.AreNotEqual(fulcrumError.CorrelationId, fulcrumException.CorrelationId);
Assert.AreNotEqual(fulcrumError.ServerTechnicalName, fulcrumException.ServerTechnicalName);
Assert.AreNotEqual(fulcrumError.Code, fulcrumException.Code);
Assert.AreNotEqual(fulcrumError.FriendlyMessage, fulcrumException.FriendlyMessage);
Assert.AreEqual(FulcrumResourceException.ExceptionType, fulcrumException.Type);
Assert.AreNotEqual(fulcrumError.InstanceId, fulcrumException.InstanceId);
Assert.AreNotEqual(fulcrumError.MoreInfoUrl, fulcrumException.MoreInfoUrl);
Assert.IsNull(fulcrumException.ErrorLocation);
// Inner exception
Assert.IsNotNull(fulcrumException.InnerException);
var innerFulcrumException = fulcrumException.InnerException as FulcrumException;
Assert.IsNotNull(innerFulcrumException);
Assert.AreEqual(fulcrumError.InstanceId, innerFulcrumException.InstanceId);
Assert.AreEqual(fulcrumError.InnerInstanceId, innerFulcrumException.InnerInstanceId);
Assert.AreEqual(fulcrumError.ServerTechnicalName, innerFulcrumException.ServerTechnicalName);
Assert.AreEqual(fulcrumError.CorrelationId, innerFulcrumException.CorrelationId);
Assert.AreEqual(fulcrumError.Code, innerFulcrumException.Code);
Assert.AreEqual(fulcrumError.IsRetryMeaningful, innerFulcrumException.IsRetryMeaningful);
Assert.AreEqual(fulcrumError.FriendlyMessage, innerFulcrumException.FriendlyMessage);
Assert.AreEqual(fulcrumError.Type, innerFulcrumException.Type);
Assert.AreEqual(fulcrumError.InstanceId, innerFulcrumException.InstanceId);
Assert.AreEqual(fulcrumError.MoreInfoUrl, innerFulcrumException.MoreInfoUrl);
Assert.AreEqual(fulcrumError.ErrorLocation, innerFulcrumException.ErrorLocation);
}
private static void Verify(string sourceType, string targetType)
{
var fulcrumError = new FulcrumError
{
Type = sourceType
};
var fulcrumException = ExceptionConverter.ToFulcrumException(fulcrumError);
Assert.IsNotNull(fulcrumException);
Assert.AreEqual(targetType, fulcrumException.Type);
}
/// <summary>
/// Convert a <see cref="FulcrumError"/> (<paramref name="error"/>) into a <see cref="FulcrumException"/>.
/// </summary>
public static FulcrumException ToFulcrumException(FulcrumError error)
{
if (error == null)
{
return(null);
}
var fulcrumException = CreateFulcrumException(error);
fulcrumException.CopyFrom(error);
return(fulcrumException);
}
public void ConvertUnknownType()
{
var fulcrumError = new FulcrumError
{
Type = "UnknownErrorType"
};
var fulcrumException = ExceptionConverter.ToFulcrumException(fulcrumError);
Assert.IsNotNull(fulcrumException);
Assert.AreEqual(FulcrumAssertionFailedException.ExceptionType, fulcrumException.Type);
}
public async Task ApiContractException()
{
var response = await _ticketService.GetTicketAsync(null, "IGNORE");
var content = await GetContent(response);
Assert.IsNotNull(content);
var error = FulcrumError.Parse(content);
Assert.IsNotNull(error, $"Expected a JSON formatted error. (Content was \"{content}\".");
ValidateExceptionType <ServerContractException>(error);
}
/// <summary>
/// Convert an exception (<paramref name="exception"/>) into a <see cref="FulcrumError"/>.
/// </summary>
public static FulcrumError ToFulcrumError(Exception exception, bool topLevelMustBeFulcrumException)
{
if (exception == null)
{
return(null);
}
var fulcrumError = new FulcrumError();
if ((exception is FulcrumException fulcrumException))
{
fulcrumError.CopyFrom(fulcrumException);
}
/// <summary>
/// Checks a dictionary for the proper <see cref="HttpStatusCode"/> for <paramref name="error"/>.
/// </summary>
public static HttpStatusCode?ToHttpStatusCode(FulcrumError error)
{
if (error == null)
{
return(null);
}
if (!HttpStatusCodesCache.ContainsKey(error.Type))
{
return(null);
}
return(HttpStatusCodesCache[error.Type]);
}
/// <summary>
/// Convert an exception (<paramref name="e"/>) into a <see cref="FulcrumError"/>.
/// </summary>
public static FulcrumError ToFulcrumError(Exception e)
{
var fulcrumException = e as FulcrumException;
if (fulcrumException == null)
{
return(null);
}
var error = new FulcrumError();
error.CopyFrom(fulcrumException);
error.InnerError = ToFulcrumError(fulcrumException.InnerException);
return(error);
}
private static void ValidateStatusCode(HttpStatusCode statusCode, FulcrumError error)
{
var expectedStatusCode = ToHttpStatusCode(error);
if (expectedStatusCode == null)
{
throw new FulcrumAssertionFailedException(
$"The Type of the content could not be converted to an HTTP status code: {ToJsonString(error, Formatting.Indented)}.");
}
if (expectedStatusCode != statusCode)
{
throw new FulcrumAssertionFailedException(
$"The HTTP error response had status code {statusCode}, but was expected to have {expectedStatusCode.Value}, due to the Type in the content: \"{ToJsonString(error, Formatting.Indented)}");
}
}
private static FulcrumException CreateFulcrumException(FulcrumError error, bool okIfNotExists = false)
{
if (!FactoryMethodsCache.ContainsKey(error.Type))
{
if (okIfNotExists)
{
return(null);
}
var message = $"The Type ({error.Type}) was not recognized: {ToJsonString(error, Formatting.Indented)}. It must be added to {typeof(Converter).FullName}.";
return(new FulcrumAssertionFailedException(message, ToFulcrumException(error.InnerError)));
}
var factoryMethod = FactoryMethodsCache[error.Type];
var fulcrumException = factoryMethod(error.TechnicalMessage, ToFulcrumException(error.InnerError));
return(fulcrumException);
}
public async Task ConvertNormal()
{
var fulcrumException = new FulcrumServiceContractException("Test message");
var fulcrumError = new FulcrumError();
fulcrumError.CopyFrom(fulcrumException);
Assert.IsNotNull(fulcrumError);
var json = JObject.FromObject(fulcrumError);
var content = json.ToString(Formatting.Indented);
var responseMessage = new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent(content, Encoding.UTF8)
};
var result = await ExceptionConverter.ToFulcrumExceptionAsync(responseMessage);
Assert.AreEqual(fulcrumException.TechnicalMessage, result.TechnicalMessage);
}
private async Task VerifyException <TFacadeException, TBllException>(bool expectCopy = false)
where TFacadeException : FulcrumException
where TBllException : FulcrumException, new()
{
var response = await _ticketService.GetTicketAsync(TicketId, typeof(TFacadeException).Name);
var content = await GetContent(response);
Assert.IsNotNull(content);
var error = FulcrumError.Parse(content);
Assert.IsNotNull(error, $"Expected a JSON formatted error. (Content was \"{content}\".");
ValidateExceptionType <TBllException>(error);
if (typeof(TFacadeException) == typeof(TBllException) && !expectCopy)
{
// The following condition has been specially prepared for in the mock service.
// This would never happen in real life.
Assert.AreEqual(error.InstanceId, error.Code);
}
}
