public void SendMessage_IncorrectRequest_ReturnError()
{
var mockSqlProvider = new Mock <IFlurlProvider>();
var flurlCall = new FlurlCall()
{
HttpRequestMessage = new HttpRequestMessage()
{
Content = new StringContent("test")
}
};
var ex = new Exception()
{
HelpLink = "test"
};
var webService = new WebService(requestInfo);
mockSqlProvider
.Setup(u => u.SendRequest(It.IsAny <RequestInfo>())).Throws(new FlurlHttpTimeoutException(flurlCall, ex));
webService.fprovider = mockSqlProvider.Object;
var result = webService.SendMessage(requestInfo);
result.StatusCode.ToString().Should().Be("OK");
result.Content.ToString().Should().Be("test");
}
internal static bool HasAllQueryParams(this FlurlCall call, string[] names)
{
return(call.Request.Url.QueryParams
.Select(p => p.Name)
.Intersect(names)
.Count() == names.Length);
}
private void SetUserAgentHeader(FlurlCall call)
{
foreach (ProductInfoHeaderValue userAgent in UserAgents)
{
call.Request.Headers.Add("userAgent", userAgent.ToString());
}
}
internal static bool HasQueryParam(this FlurlCall call, string name, object value)
{
var paramVals = call.Request.Url.QueryParams
.Where(p => p.Name == name)
.Select(p => p.Value.ToInvariantString())
.ToList();
if (!paramVals.Any())
{
return(false);
}
if (value == null)
{
return(true);
}
if (value is string s)
{
return(paramVals.Any(v => MatchesPattern(v, s)));
}
if (value is IEnumerable en)
{
var values = en.Cast <object>().Select(o => o.ToInvariantString()).ToList();
return(values.Intersect(paramVals).Count() == values.Count);
}
return(paramVals.Any(v => v == value.ToInvariantString()));
}
internal static bool HasAnyVerb(this FlurlCall call, string[] verbs)
{
// for good measure, check both FlurlRequest.Verb and HttpRequestMessage.Method
return(verbs.Any(verb =>
call.Request.Verb.Method.OrdinalEquals(verb, true) &&
call.HttpRequestMessage.Method.Method.OrdinalEquals(verb, true)));
}
internal static bool HasAnyQueryParam(this FlurlCall call, string[] names)
{
var qp = call.Request.Url.QueryParams;
return(names.Any() ? qp
.Select(p => p.Name)
.Intersect(names)
.Any() : qp.Any());
}
private static string SerializeHttpCall(FlurlCall httpCall)
{
var settings = new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
};
return(JsonConvert.SerializeObject(httpCall, Formatting.Indented, settings));
}
private async Task ThrowApiExceptionAsync(FlurlCall call)
{
if (!(call.Exception is FlurlHttpException fex))
{
return;
}
var resp = await fex.GetResponseJsonAsync <ApiErrorResponse>();
throw new OrderCloudException(call, resp?.Errors);
}
protected virtual async Task OnBeforeCallAsync(FlurlCall httpCall)
{
Check.NotNull(httpCall, nameof(httpCall));
// If session requests no authorization needed
if (httpCall.Request?.Url?.ToString()?.Contains("_session", StringComparison.InvariantCultureIgnoreCase) == true)
{
return;
}
switch (_options.AuthenticationType)
{
case AuthenticationType.None:
break;
case AuthenticationType.Basic:
httpCall.Request = httpCall.Request.WithBasicAuth(_options.Username, _options.Password);
break;
case AuthenticationType.Cookie:
var isTokenExpired =
!_cookieCreationDate.HasValue ||
_cookieCreationDate.Value.AddMinutes(_options.CookiesDuration) < DateTime.Now;
if (isTokenExpired)
{
await LoginAsync().ConfigureAwait(false);
}
httpCall.Request = httpCall.Request.WithCookie("AuthSession", _cookieToken);
break;
case AuthenticationType.Proxy:
httpCall.Request = httpCall.Request.WithHeader("X-Auth-CouchDB-UserName", _options.Username)
.WithHeader("X-Auth-CouchDB-Roles", string.Join(",", _options.Roles));
if (_options.Password != null)
{
httpCall.Request = httpCall.Request.WithHeader("X-Auth-CouchDB-Token", _options.Password);
}
break;
case AuthenticationType.Jwt:
if (_options.JwtTokenGenerator == null)
{
throw new InvalidOperationException("JWT generation cannot be null.");
}
var jwt = await _options.JwtTokenGenerator().ConfigureAwait(false);
httpCall.Request = httpCall.Request.WithHeader("Authorization", jwt);
break;
default:
throw new NotSupportedException($"Authentication of type {_options.AuthenticationType} is not supported.");
}
}
private static string BuildMessage(FlurlCall call, ApiError[] errors)
{
var code = errors?.FirstOrDefault()?.ErrorCode;
var msg = errors?.FirstOrDefault()?.Message;
if (!string.IsNullOrEmpty(code) && !string.IsNullOrEmpty(msg))
{
return($"{code}: {msg}");
}
return(new[] { code, msg, call?.Exception?.Message, "An unknown error occurred." }
.FirstOrDefault(x => !string.IsNullOrEmpty(x)));
}
private async Task ThrowAuthExceptionAsync(FlurlCall call)
{
if (!(call.Exception is FlurlHttpException fex))
{
return;
}
var resp = await fex.GetResponseJsonAsync <AuthErrorResponse>();
var error = new ApiError {
ErrorCode = resp.error, Message = resp.error_description
};
throw new OrderCloudException(call, new[] { error });
}
private async Task EnsureTokenAsync(FlurlCall call)
{
var hasToken =
call.Request.Headers.TryGetFirst("Authorization", out var value) &&
(value as string) != "Bearer ";
if (!hasToken)
{
if (!IsAuthenticated)
{
await AuthenticateAsync().ConfigureAwait(false);
}
call.Request.WithOAuthBearerToken(TokenResponse.AccessToken);
}
}
/// <summary>
/// Traces an HTTP request
/// </summary>
/// <param name="httpCall">The Flurl HTTP call instance, containing information about the request and response.</param>
public static void TraceHttpCall(FlurlCall httpCall)
{
Http.TraceData(TraceEventType.Information, 0, SerializeHttpCall(httpCall));
}
/// <summary>
/// Traces a failed HTTP request
/// </summary>
/// <param name="httpCall">The Flurl HTTP call instance, containing information about the request and response.</param>
public static void TraceFailedHttpCall(FlurlCall httpCall)
{
Http.TraceData(TraceEventType.Error, 0, SerializeHttpCall(httpCall));
Http.Flush();
}
internal void LogCall(FlurlCall call) => _calls.Enqueue(call);
/// <summary>
/// null value means just check for existence by name
/// </summary>
internal static bool HasCookie(this FlurlCall call, string name, object value = null)
{
return((value == null) ?
call.Request.Cookies.Any(c => c.Name == name) :
MatchesValueOrPattern(call.Request.Cookies.FirstOrDefault(c => c.Name == name).Value, value));
}
internal static bool HasAnyVerb(this FlurlCall call, HttpMethod[] verbs)
{
return(verbs.Any(verb => call.HttpRequestMessage.Method == verb));
}
internal static bool HasQueryParams(this FlurlCall call, object values)
{
return(values.ToKeyValuePairs().All(kv => call.HasQueryParam(kv.Key, kv.Value)));
}
internal HttpTestSetup FindSetup(FlurlCall call)
{
return(_filteredSetups.FirstOrDefault(ts => ts.IsMatch(call)) ?? (HttpTestSetup)this);
}
internal OrderCloudException(FlurlCall call, ApiError[] errors) : base(BuildMessage(call, errors), call.Exception)
{
HttpStatus = call.HttpResponseMessage.StatusCode;
Errors = errors;
}
internal static bool HasAnyVerb(this FlurlCall call, HttpMethod[] verbs)
{
// for good measure, check both FlurlRequest.Verb and HttpRequestMessage.Method
return(verbs.Any(verb => call.Request.Verb == verb && call.HttpRequestMessage.Method == verb));
}
internal static bool HasHeader(this FlurlCall call, string name, string valuePattern)
{
var val = call.HttpRequestMessage.GetHeaderValue(name);
return(val != null && MatchesPattern(val, valuePattern));
}
/// <summary> /// Returns true if the given FlurlCall matches one of the URL patterns and all other criteria defined for this HttpTestSetup. /// </summary> internal bool IsMatch(FlurlCall call) => _filters.All(f => f(call));
/// <summary>
/// null value means just check for existence by name
/// </summary>
internal static bool HasHeader(this FlurlCall call, string name, object value = null)
{
return((value == null) ?
call.Request.Headers.Contains(name) :
call.Request.Headers.TryGetFirst(name, out var val) && MatchesValueOrPattern(val, value));
}
public FlurlException(FlurlCall flurlCall, Exception ex) : base(flurlCall, ex)
{
}
internal static bool HasAnyVerb(this FlurlCall call, string[] verbs)
{
return(verbs.Any(verb => call.HttpRequestMessage.Method.Method.Equals(verb, StringComparison.OrdinalIgnoreCase)));
}
