public static void ReturnNamedResourceAsWebPage(HttpMessage httpMessage, ISocketProxy socketProxy)
{
string destinationUrl = httpMessage.Headers.DestinationUrl().Substring(1);
var resourceStream = new ResourceReader().GetResource(destinationUrl);
var bytes = resourceStream.ReadFully();
socketProxy.SendWebPage(Encoding.ASCII.GetString(bytes));
}
public HttpNetworkAction(HttpMessage message)
{
RequestName = HttpNetworkController.Instance.HttpAddress + message.Request;
PostData = "";//= "version=" + Honey.NetworkManager.ServerVersion + "&id=" + PlayerManager.Id;
string additionalParameters = message.Parameters.Aggregate("", (current, par) => current + ("&" + par.Key + "=" + par.Value.ToLower()));
PostData += additionalParameters;
}
public void CreateBufferedCopy_Always_Returns_An_HttpMessageBuffer()
{
HttpRequestMessage request = new HttpRequestMessage();
HttpMessage message = new HttpMessage(request);
ExceptionAssert.Throws<NotSupportedException>(
SR.MessageReadWriteCopyNotSupported("ToHttpRequestMessage", "ToHttpResponseMessage", typeof(Message).FullName),
() =>
{
MessageBuffer buffer = message.CreateBufferedCopy(5);
});
}
/// <summary>
/// Modifies the OData get request to use the real server's Uri.
/// </summary>
public static void FixODataRequestPayload(
HttpMessage.Request request,
Uri serviceUri,
Uri mockServerUri)
{
// Fix the $link Uris
if (serviceUri != null &&
request.RequestText != null &&
request.RequestText.Contains("dataservices"))
{
request.RequestText =
request.RequestText.Replace(mockServerUri.ToString(), serviceUri.ToString());
}
}
public void Closing_Disposes_Of_The_HttpResponseMessage()
{
HttpResponseMessage response = new HttpResponseMessage();
response.Content = new ByteArrayContent(new byte[0]);
HttpMessage message = new HttpMessage(response);
message.Close();
Assert.AreEqual(MessageState.Closed, message.State, "HttpMessage.State should be closed.");
ExceptionAssert.ThrowsObjectDisposed(
typeof(ByteArrayContent).FullName,
() =>
{
response.Content.ReadAsByteArray();
});
}
public void BeginReply_Does_Not_Change_Message_State_When_Response_Is_HttpMessage()
{
HttpResponseMessage response = new HttpResponseMessage();
HttpMessage message = new HttpMessage(response);
response.StatusCode = HttpStatusCode.OK;
MessageState originalState = message.State;
MockRequestContext innerRequestContext = new MockRequestContext();
innerRequestContext.OnReplyReceived = innerMessage =>
{
Assert.AreEqual(originalState, innerMessage.State, "HttpMessageEncodingRequestContext.BeginReply should not have changed the message state.");
};
HttpMessageEncodingRequestContext requestContext = new HttpMessageEncodingRequestContext(innerRequestContext);
requestContext.BeginReply(message, null, null);
Assert.IsTrue(innerRequestContext.BeginReplyCalled, "HttpMessageEncodingRequestContext.BeginReply should have called BeginReply on the inner RequestContext.");
}
/// <summary>
/// Helper function to validate headers for Service request.
/// </summary>
public static void ValidateHeadersForServiceRequest(
HttpMessage.Request expected,
HttpMessage.Request actual)
{
Assert.IsTrue(
actual.Headers.Contains(DataServiceConstants.AccessTokenHeader),
"AccessToken header does not exist in the request");
Assert.IsTrue(
actual.Headers.Contains("x-ms-client-session-id"),
"session-id header does not exist in the request");
Assert.IsTrue(
actual.Headers.Contains("x-ms-client-request-id"),
"request-id header does not exist in the request");
Assert.IsTrue(
actual.Cookies.Contains(DataServiceConstants.AccessCookie),
"AccessCookie does not exist in the request");
}
/// <summary>
/// Helper function to validate headers for GetAccessToken request.
/// </summary>
public static void ValidateGetAccessTokenRequest(
HttpMessage.Request expected,
HttpMessage.Request actual)
{
Assert.IsTrue(
actual.RequestUri.AbsoluteUri.EndsWith("GetAccessToken"),
"Incorrect Uri specified for GetAccessToken");
Assert.IsTrue(
actual.Headers.Contains("sqlauthorization"),
"sqlauthorization header does not exist in the request");
Assert.AreEqual(
expected.Headers["sqlauthorization"],
actual.Headers["sqlauthorization"],
"sqlauthorization header does not match");
Assert.IsNull(
actual.RequestText,
"There should be no request text for GetAccessToken");
}
/// <summary>
/// Modifies the OData get responses to use the mock server's Uri.
/// </summary>
public static void FixODataResponseUri(
HttpMessage.Response response,
Uri serviceUri,
Uri mockServerUri)
{
if (serviceUri != null &&
response.ResponseText.Contains("dataservices") &&
response.ResponseText.Contains("</entry>"))
{
response.ResponseText =
response.ResponseText.Replace(serviceUri.ToString(), mockServerUri.ToString());
}
if (serviceUri != null &&
response.Headers.Contains("Location"))
{
response.Headers["Location"] = response.Headers["Location"].Replace(
serviceUri.ToString(),
mockServerUri.ToString());
}
}
public void BeginReply_Ignores_HttpResponseMessageProperty_If_Contains_HttpRequestMessage()
{
HttpRequestMessage request = new HttpRequestMessage();
HttpMessage message = new HttpMessage(request);
MockRequestContext innerRequestContext = new MockRequestContext();
innerRequestContext.OnReplyReceived = innerMessage =>
{
Assert.IsNotNull(innerMessage, "HttpMessageEncodingRequestContext.BeginReply should not have returned null.");
Assert.IsInstanceOfType(innerMessage, typeof(HttpMessage), "HttpMessageEncodingRequestContext.BeginReply should have returned an HttpMessage instance.");
Assert.AreSame(message, innerMessage, "HttpMessageEncodingRequestContext.BeginReply should have provided the same message instance as the HttpMessageEncodingRequestContext received.");
HttpResponseMessageProperty innerProperty = innerMessage.Properties[HttpResponseMessageProperty.Name] as HttpResponseMessageProperty;
Assert.IsNotNull(innerProperty, "The inner HttpMessage instance should have had an HttpResponseMessageProperty.");
Assert.AreEqual(HttpStatusCode.InternalServerError, innerProperty.StatusCode, "HttpResponseMessageProperty.StatusCode should have been HttpStatusCode.InternalServerError.");
Assert.IsTrue(innerProperty.SuppressEntityBody, "HttpResponseMessageProperty.SuppressEntityBody should have been 'true'.");
Assert.AreEqual(0, innerProperty.Headers.Count, "HttpResponseMessageProperty.Header.Count should have been zero.");
};
HttpMessageEncodingRequestContext requestContext = new HttpMessageEncodingRequestContext(innerRequestContext);
requestContext.BeginReply(message, null, null);
Assert.IsTrue(innerRequestContext.BeginReplyCalled, "HttpMessageEncodingRequestContext.BeginReply should have called BeginReply on the inner RequestContext.");
}
public void Reply_Returns_Same_HttpMessage_Instance_When_Response_Is_HttpMessage()
{
HttpResponseMessage response = new HttpResponseMessage();
response.StatusCode = HttpStatusCode.OK;
HttpMessage message = new HttpMessage(response);
MockRequestContext innerRequestContext = new MockRequestContext();
innerRequestContext.OnReplyReceived = innerMessage =>
{
Assert.IsNotNull(innerMessage, "HttpMessageEncodingRequestContext.Reply should not have returned null.");
Assert.IsInstanceOfType(innerMessage, typeof(HttpMessage), "HttpMessageEncodingRequestContext.Reply should have returned an HttpMessage instance.");
Assert.AreSame(message, innerMessage, "HttpMessageEncodingRequestContext.Reply should have provided the same message instance as the HttpMessageEncodingRequestContext received.");
HttpResponseMessage innerResponse = innerMessage.ToHttpResponseMessage();
Assert.IsNotNull(innerResponse, "ToHttpResponseMessage should not have returned null.");
Assert.AreSame(response, innerResponse, "HttpMessageEncodingRequestContext.Reply should have provided the same HttpResponseMessage instance as the HttpMessageEncodingRequestContext received.");
};
HttpMessageEncodingRequestContext requestContext = new HttpMessageEncodingRequestContext(innerRequestContext);
requestContext.Reply(message);
Assert.IsTrue(innerRequestContext.ReplyCalled, "HttpMessageEncodingRequestContext.Reply should have called Reply on the inner RequestContext.");
}
private async ValueTask ProcessAsync(HttpMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline, bool async)
{
CancellationToken oldToken = message.CancellationToken;
using CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(oldToken);
cts.CancelAfter(_networkTimeout);
try
{
message.CancellationToken = cts.Token;
if (async)
{
await ProcessNextAsync(message, pipeline).ConfigureAwait(false);
}
else
{
ProcessNext(message, pipeline);
}
}
finally
{
message.CancellationToken = oldToken;
cts.CancelAfter(Timeout.Infinite);
}
Stream?responseContentStream = message.Response.ContentStream;
if (responseContentStream == null || responseContentStream.CanSeek)
{
return;
}
if (message.BufferResponse)
{
if (_networkTimeout != Timeout.InfiniteTimeSpan)
{
cts.Token.Register(state => ((Stream)state)?.Dispose(), responseContentStream);
}
try
{
var bufferedStream = new MemoryStream();
if (async)
{
await CopyToAsync(responseContentStream, bufferedStream, cts).ConfigureAwait(false);
}
else
{
CopyTo(responseContentStream, bufferedStream, cts);
}
responseContentStream.Dispose();
bufferedStream.Position = 0;
message.Response.ContentStream = bufferedStream;
}
// We dispose stream on timeout so catch and check if cancellation token was cancelled
catch (ObjectDisposedException)
{
cts.Token.ThrowIfCancellationRequested();
throw;
}
}
else if (_networkTimeout != Timeout.InfiniteTimeSpan)
{
message.Response.ContentStream = new ReadTimeoutStream(responseContentStream, _networkTimeout);
}
}
public override async ValueTask ProcessAsync(HttpMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline)
{
await ProcessAsync(message, pipeline, true).ConfigureAwait(false);
}
public async Task OnReceived(IMessageSender sender, HttpContext context, IEnumerable <IActionFilter> actionFilters)
{
var serviceRoute = context.Items["route"] as ServiceRoute;
var path = (context.Items["path"]
?? HttpUtility.UrlDecode(GetRoutePath(context.Request.Path.ToString()))) as string;
if (serviceRoute == null)
{
serviceRoute = await _serviceRouteProvider.GetRouteByPathRegex(path);
}
IDictionary <string, object> parameters = context.Request.Query.ToDictionary(p => p.Key, p => (object)p.Value.ToString());
object serviceKey = null;
foreach (var key in _serviceKeys)
{
parameters.Remove(key, out object value);
if (value != null)
{
serviceKey = value;
break;
}
}
if (String.Compare(serviceRoute.ServiceDescriptor.RoutePath, path, true) != 0)
{
var @params = RouteTemplateSegmenter.Segment(serviceRoute.ServiceDescriptor.RoutePath, path);
foreach (var param in @params)
{
parameters.Add(param.Key, param.Value);
}
}
var httpMessage = new HttpMessage
{
Parameters = parameters,
RoutePath = serviceRoute.ServiceDescriptor.RoutePath,
ServiceKey = serviceKey?.ToString()
};
if (context.Request.HasFormContentType)
{
var collection = await GetFormCollection(context.Request);
httpMessage.Parameters.Add("form", collection);
if (!await OnActionExecuting(new ActionExecutingContext {
Context = context, Route = serviceRoute, Message = httpMessage
}, sender, actionFilters))
{
return;
}
await Received(sender, new TransportMessage(httpMessage));
}
else
{
StreamReader streamReader = new StreamReader(context.Request.Body);
var data = await streamReader.ReadToEndAsync();
if (context.Request.Method == "POST")
{
var bodyParams = _serializer.Deserialize <string, IDictionary <string, object> >(data) ?? new Dictionary <string, object>();
foreach (var param in bodyParams)
{
httpMessage.Parameters.Add(param.Key, param.Value);
}
if (!await OnActionExecuting(new ActionExecutingContext {
Context = context, Route = serviceRoute, Message = httpMessage
}, sender, actionFilters))
{
return;
}
await Received(sender, new TransportMessage(httpMessage));
}
else
{
if (!await OnActionExecuting(new ActionExecutingContext {
Context = context, Route = serviceRoute, Message = httpMessage
}, sender, actionFilters))
{
return;
}
await Received(sender, new TransportMessage(httpMessage));
}
}
await OnActionExecuted(context, httpMessage, actionFilters);
}
public override void Process(HttpMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline)
{
Debug.Assert(pipeline.IsEmpty);
_transport.Process(message);
}
/// <inheritdoc /> protected override bool AuthorizeRequestOnChallenge(HttpMessage message) => AuthorizeRequestOnChallengeInternalAsync(message, false).EnsureCompleted();
/// <summary>
/// Sets the package name and version portion of the UserAgent telemetry value.
/// Note: If <see cref="DiagnosticsOptions.IsTelemetryEnabled"/> is false, this value is never used.
/// </summary>
/// <param name="message">The <see cref="HttpMessage"/>.</param>
/// <param name="userAgentValue">The <see cref="SetUserAgentString"/>.</param>
public static void SetUserAgentString(this HttpMessage message, UserAgentValue userAgentValue)
{
message.SetInternalProperty(typeof(UserAgentValueKey), userAgentValue.ToString());
}
/// <summary> /// Sends the request contained by the <paramref name="message"/> and sets the <see cref="HttpMessage.Response"/> property to received response synchronously. /// </summary> /// <param name="message">The <see cref="HttpMessage"/> containing request and response.</param> public abstract void Process(HttpMessage message);
/// <summary> /// Sends the request contained by the <paramref name="message"/> and sets the <see cref="HttpMessage.Response"/> property to received response asynchronously. /// </summary> /// <param name="message">The <see cref="HttpMessage"/> containing request and response.</param> public abstract ValueTask ProcessAsync(HttpMessage message);
public override void OnSendingRequest(HttpMessage message)
{
ExecutionCount++;
}
public override void OnSendingRequest(HttpMessage message)
{
_message(message);
}
private async Task <HttpResultMessage <object> > LocalExecuteAsync(ServiceEntry entry, HttpMessage httpMessage)
{
HttpResultMessage <object> resultMessage = new HttpResultMessage <object>();
try
{
var result = await entry.Func(httpMessage.ServiceKey, httpMessage.Parameters);
var task = result as Task;
if (task == null)
{
resultMessage.Entity = result;
}
else
{
task.Wait();
var taskType = task.GetType().GetTypeInfo();
if (taskType.IsGenericType)
{
resultMessage.Entity = taskType.GetProperty("Result").GetValue(task);
}
}
resultMessage.IsSucceed = resultMessage.Entity != null;
resultMessage.StatusCode = resultMessage.IsSucceed ? (int)StatusCode.Success : (int)StatusCode.RequestError;
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(exception, "执行本地逻辑时候发生了错误。");
}
resultMessage.Message = "执行发生了错误。";
resultMessage.StatusCode = exception.HResult;
}
return(resultMessage);
}
private async Task <HttpResultMessage <object> > RemoteExecuteAsync(ServiceEntry entry, HttpMessage httpMessage)
{
HttpResultMessage <object> resultMessage = new HttpResultMessage <object>();
try {
resultMessage.Entity = await _serviceProxyProvider.Invoke <object>(httpMessage.Parameters, httpMessage.RoutePath, httpMessage.ServiceKey);
resultMessage.IsSucceed = resultMessage.Entity != default;
resultMessage.StatusCode = resultMessage.IsSucceed ? (int)StatusCode.Success : (int)StatusCode.RequestError;
}
catch (Exception ex)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(ex, "执行远程调用逻辑时候发生了错误。");
}
resultMessage = new HttpResultMessage <object> {
Entity = null, Message = "执行发生了错误。", StatusCode = (int)StatusCode.RequestError
};
}
return(resultMessage);
}
/// <inheritdoc /> protected override ValueTask <bool> AuthorizeRequestOnChallengeAsync(HttpMessage message) => AuthorizeRequestOnChallengeInternalAsync(message, true);
public void Reply_Throws_If__Message_Is_Closed()
{
HttpResponseMessage response = new HttpResponseMessage();
HttpMessage message = new HttpMessage(response);
message.Close();
MockRequestContext innerRequestContext = new MockRequestContext();
HttpMessageEncodingRequestContext requestContext = new HttpMessageEncodingRequestContext(innerRequestContext);
ExceptionAssert.Throws<ObjectDisposedException>(
SR.MessageClosed,
() =>
{
requestContext.Reply(message);
});
}
public override bool IsErrorResponse(HttpMessage message)
{
return(message.Response.Status switch
{
public void RequestMessage_Method_Determined_By_HttpRequestMessageProperty()
{
HttpRequestMessage innerRequest = new HttpRequestMessage();
innerRequest.Method = HttpMethod.Get;
Message innerMessage = new HttpMessage(innerRequest);
HttpRequestMessageProperty property = new HttpRequestMessageProperty();
property.Method = "PUT";
innerMessage.Properties.Add(HttpRequestMessageProperty.Name, property);
innerMessage.Headers.To = new Uri("http://thisUri.org");
MockRequestContext innerRequestContext = new MockRequestContext();
innerRequestContext.SetRequestMessage(innerMessage);
HttpMessageEncodingRequestContext requestContext = new HttpMessageEncodingRequestContext(innerRequestContext);
Message message = requestContext.RequestMessage;
HttpRequestMessage request = message.ToHttpRequestMessage();
Assert.AreEqual(HttpMethod.Put, request.Method, "HttpRequestMessage.Method should have been set to the the value of the HttpRequestMessageProperty.Method.");
}
private async Task <TResult> DeserialiseAsync <TResult>(HttpMessage message)
{
if (typeof(Void) == typeof(TResult))
{
return(default);
/// <summary>
/// Make an request to the real service and retrieve the response.
/// </summary>
/// <param name="originalRequest">The original request to mimic.</param>
/// <param name="requestUri">The Uri to make the request to.</param>
/// <returns>The response from the service.</returns>
private static HttpWebResponse MakeServiceRequest(
HttpMessage.Request originalRequest)
{
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(
originalRequest.RequestUri);
request.Method = originalRequest.Method;
// Copy all relevant headers to the request
if (originalRequest.UserAgent != null)
{
request.UserAgent = originalRequest.UserAgent;
}
if (originalRequest.ContentType != null)
{
request.ContentType = originalRequest.ContentType;
}
if (originalRequest.Accept != null)
{
request.Accept = originalRequest.Accept;
}
foreach (HttpMessage.Header header in originalRequest.Headers)
{
request.Headers.Add(header.Name, header.Value);
}
if (originalRequest.Certificate != null)
{
request.ClientCertificates.Add(originalRequest.Certificate);
}
// Copy all request cookies
request.CookieContainer = new CookieContainer();
foreach (HttpMessage.Cookie cookie in originalRequest.Cookies)
{
Cookie requestCookie = new Cookie(cookie.Name, cookie.Value);
requestCookie.Domain = request.RequestUri.Host;
requestCookie.Path = request.RequestUri.LocalPath;
request.CookieContainer.Add(requestCookie);
}
// Copy request streams
if (originalRequest.RequestText != null)
{
using (StreamWriter requestStream = new StreamWriter(request.GetRequestStream()))
{
requestStream.Write(originalRequest.RequestText);
}
}
// Send the real request and obtain the response
HttpWebResponse response;
try
{
response = (HttpWebResponse)request.GetResponse();
}
catch (WebException ex)
{
response = (HttpWebResponse)ex.Response;
}
return response;
}
/// <summary>
/// mvc HttpContext
/// </summary>
/// <param name="webHost"></param>
/// <param name="httpMessage"></param>
public HttpContext(IWebHost webHost, HttpMessage httpMessage) : base(webHost, httpMessage)
{
_routeTable = _webHost.RouteParam as RouteTable;
}
/// <inheritdoc /> protected override void AuthorizeRequest(HttpMessage message) => AuthorizeRequestInternal(message, false).EnsureCompleted();
public void TryGetPropertyReturnsFalseIfNotExist()
{
HttpMessage message = new HttpMessage(new MockRequest(), new ResponseClassifier());
Assert.False(message.TryGetProperty("someName", out _));
}
private async ValueTask ProcessAsync(HttpMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline, bool async)
{
Request request = message.Request;
s_eventSource.Request(request.ClientRequestId, request.Method.ToString(), FormatUri(request.Uri), FormatHeaders(request.Headers), _assemblyName);
Encoding?requestTextEncoding = null;
if (request.TryGetHeader(HttpHeader.Names.ContentType, out var contentType))
{
ContentTypeUtilities.TryGetTextEncoding(contentType, out requestTextEncoding);
}
var logWrapper = new ContentEventSourceWrapper(s_eventSource, _logContent, _maxLength, message.CancellationToken);
await logWrapper.LogAsync(request.ClientRequestId, request.Content, requestTextEncoding, async).ConfigureAwait(false).EnsureCompleted(async);
var before = Stopwatch.GetTimestamp();
try
{
if (async)
{
await ProcessNextAsync(message, pipeline).ConfigureAwait(false);
}
else
{
ProcessNext(message, pipeline);
}
}
catch (Exception ex)
{
s_eventSource.ExceptionResponse(request.ClientRequestId, ex.ToString());
throw;
}
var after = Stopwatch.GetTimestamp();
Response response = message.Response;
bool isError = response.IsError;
ContentTypeUtilities.TryGetTextEncoding(response.Headers.ContentType, out Encoding? responseTextEncoding);
bool wrapResponseContent = response.ContentStream != null &&
response.ContentStream?.CanSeek == false &&
logWrapper.IsEnabled(isError);
double elapsed = (after - before) / (double)Stopwatch.Frequency;
if (isError)
{
s_eventSource.ErrorResponse(response.ClientRequestId, response.Status, response.ReasonPhrase, FormatHeaders(response.Headers), elapsed);
}
else
{
s_eventSource.Response(response.ClientRequestId, response.Status, response.ReasonPhrase, FormatHeaders(response.Headers), elapsed);
}
if (wrapResponseContent)
{
response.ContentStream = new LoggingStream(response.ClientRequestId, logWrapper, _maxLength, response.ContentStream !, isError, responseTextEncoding);
}
else
{
await logWrapper.LogAsync(response.ClientRequestId, isError, response.ContentStream, responseTextEncoding, async).ConfigureAwait(false).EnsureCompleted(async);
}
if (elapsed > RequestTooLongTime)
{
s_eventSource.ResponseDelay(response.ClientRequestId, elapsed);
}
}
public void RequestMessage_Returns_HttpMessage_With_HttpRequestHeaders_Only_From_The_HttpRequestMessageProperty()
{
HttpRequestMessage innerRequest = new HttpRequestMessage();
innerRequest.Content = new ByteArrayContent(new byte[] { 0, 1, 2, 3, 4 });
innerRequest.Content.Headers.ContentType = new MediaTypeHeaderValue("notThisType/notThisSubType");
Message innerMessage = new HttpMessage(innerRequest);
innerMessage.Headers.To = new Uri("http://someHost.org/someService");
HttpRequestMessageProperty property = new HttpRequestMessageProperty();
property.Headers.Add(HttpRequestHeader.UserAgent, "SomeUserAgent");
property.Headers.Add(HttpRequestHeader.ContentType, "someType/someSubType");
innerMessage.Properties.Add(HttpRequestMessageProperty.Name, property);
MessageState originalState = innerMessage.State;
MockRequestContext innerRequestContext = new MockRequestContext();
innerRequestContext.SetRequestMessage(innerMessage);
HttpMessageEncodingRequestContext requestContext = new HttpMessageEncodingRequestContext(innerRequestContext);
Message message = requestContext.RequestMessage;
HttpRequestMessage request = message.ToHttpRequestMessage();
Assert.AreEqual(1, request.Headers.Count(), "HttpRequestMessage.Headers.Count should have been one.");
Assert.AreEqual(1, request.Content.Headers.Count(), "HttpRequestMessage.Headers.Count should have been one.");
Assert.AreEqual("SomeUserAgent", request.Headers.UserAgent.First().Product.ToString(), "The user agent header should have been 'SomeUserAgent'.");
Assert.AreEqual("someType/someSubType", request.Content.Headers.ContentType.MediaType, "The content type header should have been 'someType/someSubType'.");
}
public override ValueTask ProcessAsync(HttpMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline)
{
Debug.Assert(pipeline.IsEmpty);
return(_transport.ProcessAsync(message));
}
public void RequestMessage_Returns_Same_HttpContent_Instance_When_Inner_Request_Is_HttpMessage()
{
HttpRequestMessage innerRequest = new HttpRequestMessage();
innerRequest.Content = new ByteArrayContent(new byte[5] { 1, 2, 3, 4, 5 });
Message innerMessage = new HttpMessage(innerRequest);
innerMessage.Headers.To = new Uri("http://someHost.org/someService");
innerMessage.Properties.Add(HttpRequestMessageProperty.Name, new HttpRequestMessageProperty());
MockRequestContext innerRequestContext = new MockRequestContext();
innerRequestContext.SetRequestMessage(innerMessage);
HttpMessageEncodingRequestContext requestContext = new HttpMessageEncodingRequestContext(innerRequestContext);
Message message = requestContext.RequestMessage;
HttpRequestMessage request = message.ToHttpRequestMessage();
Assert.AreSame(innerRequest.Content, request.Content, "The HttpRequestMessage.Content should not have been changed by the HttpMessageEncodingRequestContext.");
}
public override void Process(HttpMessage message, ReadOnlyMemory <HttpPipelinePolicy> pipeline)
{
ProcessAsync(message, pipeline, false).EnsureCompleted();
}
public void RequestMessage_Returns_Same_HttpMessage_Sans_HttpRequestMessageProperty_Instance_When_Inner_Request_Is_HttpMessage()
{
HttpRequestMessage innerRequest = new HttpRequestMessage();
Message innerMessage = new HttpMessage(innerRequest);
innerMessage.Headers.To = new Uri("http://someHost.org/someService");
innerMessage.Properties.Add(HttpRequestMessageProperty.Name, new HttpRequestMessageProperty());
MockRequestContext innerRequestContext = new MockRequestContext();
innerRequestContext.SetRequestMessage(innerMessage);
HttpMessageEncodingRequestContext requestContext = new HttpMessageEncodingRequestContext(innerRequestContext);
Message message = requestContext.RequestMessage;
Assert.IsFalse(message.Properties.Keys.Contains(HttpResponseMessageProperty.Name), "The HttpMessage instance should not have had an HttpRequestMessageProperty.");
}
public void Reply_Replaces_HttpResponseMessageProperty_When_Response_Is_HttpMessage()
{
HttpResponseMessage response = new HttpResponseMessage();
response.Content = new ByteArrayContent(new byte[5] { 1, 2, 3, 4, 5 });
response.StatusCode = HttpStatusCode.Moved;
response.ReasonPhrase = "SomeReason";
response.Headers.Add("SomeHeader", "SomeHeaderValue");
HttpMessage message = new HttpMessage(response);
MockRequestContext innerRequestContext = new MockRequestContext();
innerRequestContext.OnReplyReceived = innerMessage =>
{
HttpResponseMessageProperty innerProperty = innerMessage.Properties[HttpResponseMessageProperty.Name] as HttpResponseMessageProperty;
Assert.IsNotNull(innerProperty, "The inner HttpMessage instance should have had an HttpResponseMessageProperty.");
Assert.AreEqual(HttpStatusCode.Moved, innerProperty.StatusCode, "HttpResponseMessageProperty.StatusCode should have been HttpStatusCode.Moved.");
Assert.IsFalse(innerProperty.SuppressEntityBody, "HttpResponseMessageProperty.SuppressEntityBody should have been 'false'.");
Assert.AreEqual(1, innerProperty.Headers.Count, "HttpResponseMessageProperty.Header.Count should have been 1.");
Assert.AreEqual("SomeHeaderValue", innerProperty.Headers["SomeHeader"], "HttpResponseMessageProperty.Header 'SomeHeader' value should have been 'SomeHeaderValue'.");
Assert.AreEqual("SomeReason", innerProperty.StatusDescription, "HttpResponseMessageProperty.StatusDescription value should have been 'SomeReason'.");
};
HttpMessageEncodingRequestContext requestContext = new HttpMessageEncodingRequestContext(innerRequestContext);
requestContext.Reply(message);
Assert.IsTrue(innerRequestContext.ReplyCalled, "HttpMessageEncodingRequestContext.Reply should have called Reply on the inner RequestContext.");
}
public InsufficientHttpMessageHandlingStepsException(HttpMessage httpMessage)
{
HttpMessage = httpMessage;
}
public void Reply_Sets_SuppressEntityBody_When_HttpContent_Of_HttpMessage_Is_Null()
{
HttpResponseMessage response = new HttpResponseMessage();
response.Content = null;
response.StatusCode = HttpStatusCode.OK;
HttpMessage message = new HttpMessage(response);
MockRequestContext innerRequestContext = new MockRequestContext();
innerRequestContext.OnReplyReceived = innerMessage =>
{
HttpResponseMessageProperty innerProperty = innerMessage.Properties[HttpResponseMessageProperty.Name] as HttpResponseMessageProperty;
Assert.IsTrue(innerProperty.SuppressEntityBody, "HttpResponseMessageProperty.SuppressEntityBody should have been 'true'.");
};
HttpMessageEncodingRequestContext requestContext = new HttpMessageEncodingRequestContext(innerRequestContext);
requestContext.Reply(message);
Assert.IsTrue(innerRequestContext.ReplyCalled, "HttpMessageEncodingRequestContext.Reply should have called Reply on the inner RequestContext.");
}
protected override bool ShouldSkipMessage(HttpMessage.SendOverHttp message)
{
bool shouldSkip;
return _endpointsToSkip.TryGetValue(message.EndPoint, out shouldSkip) && shouldSkip;
}
public void RequestMessage_Does_Not_Change_The_Message_State_When_Inner_Request_Is_HttpMessage()
{
HttpRequestMessage innerRequest = new HttpRequestMessage();
Message innerMessage = new HttpMessage(innerRequest);
innerMessage.Headers.To = new Uri("http://someHost.org/someService");
innerMessage.Properties.Add(HttpRequestMessageProperty.Name, new HttpRequestMessageProperty());
MessageState originalState = innerMessage.State;
MockRequestContext innerRequestContext = new MockRequestContext();
innerRequestContext.SetRequestMessage(innerMessage);
HttpMessageEncodingRequestContext requestContext = new HttpMessageEncodingRequestContext(innerRequestContext);
Message message = requestContext.RequestMessage;
Assert.AreEqual(originalState, message.State, "The state of the message should not have been changed by the HttpMessageEncodingRequestContext.");
}
/// <summary>
/// Helper function to validate headers for OData request.
/// </summary>
public static void ValidateHeadersForODataRequest(
HttpMessage.Request expected,
HttpMessage.Request actual)
{
DatabaseTestHelper.ValidateHeadersForServiceRequest(expected, actual);
Assert.IsTrue(
actual.Headers.Contains("DataServiceVersion"),
"DataServiceVersion header does not exist in the request");
Assert.AreEqual(
expected.Headers["DataServiceVersion"],
actual.Headers["DataServiceVersion"],
"DataServiceVersion header does not match");
}
public override bool IsRetriableResponse(HttpMessage message)
{
return(message.Response.Status == 500);
}
/// <inheritdoc /> protected override ValueTask AuthorizeRequestAsync(HttpMessage message) => AuthorizeRequestInternal(message, true);
public void RequestMessage_Returns_HttpMessage_With_Only_To_Header()
{
HttpRequestMessage innerRequest = new HttpRequestMessage();
innerRequest.Content = new ByteArrayContent(new byte[] { 0, 1, 2, 3, 4 });
Message innerMessage = new HttpMessage(innerRequest);
innerMessage.Headers.To = new Uri("http://someHost.org/someService");
HttpRequestMessageProperty property = new HttpRequestMessageProperty();
innerMessage.Properties.Add(HttpRequestMessageProperty.Name, property);
MockRequestContext innerRequestContext = new MockRequestContext();
innerRequestContext.SetRequestMessage(innerMessage);
HttpMessageEncodingRequestContext requestContext = new HttpMessageEncodingRequestContext(innerRequestContext);
Message message = requestContext.RequestMessage;
HttpRequestMessage request = message.ToHttpRequestMessage();
Assert.AreEqual(1, message.Headers.Count, "HttpMessage.Headers.Count should have been 1.");
Assert.AreEqual(new Uri("http://someHost.org/someService"), message.Headers.To, "HttpMessage.Headers.To should have been 'http://someHost.org/someService'.");
}
public override bool IsErrorResponse(HttpMessage message)
{
return(IsRetriableResponse(message));
}
public void RequestMessage_Returns_Same_HttpMessage_Instance_When_Inner_Request_Is_HttpMessage()
{
HttpRequestMessage innerRequest = new HttpRequestMessage();
Message innerMessage = new HttpMessage(innerRequest);
innerMessage.Headers.To = new Uri("http://someHost.org/someService");
innerMessage.Properties.Add(HttpRequestMessageProperty.Name, new HttpRequestMessageProperty());
MockRequestContext innerRequestContext = new MockRequestContext();
innerRequestContext.SetRequestMessage(innerMessage);
HttpMessageEncodingRequestContext requestContext = new HttpMessageEncodingRequestContext(innerRequestContext);
Message message = requestContext.RequestMessage;
HttpRequestMessage request = message.ToHttpRequestMessage();
Assert.IsNotNull(message, "HttpMessageEncodingRequestContext.RequestMessage should not have returned null.");
Assert.IsInstanceOfType(message, typeof(HttpMessage), "HttpMessageEncodingRequestContext.RequestMessage should not returned an HttpMessage instance.");
Assert.AreSame(innerMessage, message, "HttpMessageEncodingRequestContext.RequestMessage should have returned the same instance as the inner context's RequestMessage.");
Assert.IsNotNull(request, "ToHttpRequestMessage should have returned an HttpRequestMessage instance.");
Assert.AreSame(innerRequest, request, "HttpMessageEncodingRequestContext.RequestMessage should have returned the same HttpRequestMessage instance as the inner context.");
}
public async Task <Response <IReadOnlyList <Response> > > SendBatchRequestAsync(HttpMessage message, CancellationToken cancellationToken = default)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 202:
{
var responses = await Multipart.ParseAsync(
message.Response.ContentStream,
message.Response.Headers.ContentType,
false,
true,
cancellationToken)
.ConfigureAwait(false);
var failedSubResponse = responses.FirstOrDefault(r => r.Status >= 400);
if (failedSubResponse == null)
{
return(Response.FromValue(responses.ToList() as IReadOnlyList <Response>, message.Response));
}
RequestFailedException rfex = await _clientDiagnostics.CreateRequestFailedExceptionAsync(failedSubResponse).ConfigureAwait(false);
var ex = new TableTransactionFailedException(rfex);
throw ex;
}
default:
throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false);
}
}
public void RequestMessage_Uri_Determined_By_To_Header()
{
HttpRequestMessage innerRequest = new HttpRequestMessage();
innerRequest.RequestUri = new Uri("http://notThisUri.org");
Message innerMessage = new HttpMessage(innerRequest);
HttpRequestMessageProperty property = new HttpRequestMessageProperty();
innerMessage.Properties.Add(HttpRequestMessageProperty.Name, property);
innerMessage.Headers.To = new Uri("http://thisUri.org");
MockRequestContext innerRequestContext = new MockRequestContext();
innerRequestContext.SetRequestMessage(innerMessage);
HttpMessageEncodingRequestContext requestContext = new HttpMessageEncodingRequestContext(innerRequestContext);
Message message = requestContext.RequestMessage;
HttpRequestMessage request = message.ToHttpRequestMessage();
Assert.AreEqual(new Uri("http://thisUri.org").ToString(), request.RequestUri.ToString(), "HttpRequestMessage.Uri should have been set to the 'To' header value of the inner RequestContext message.");
}
public override void OnReceivedResponse(HttpMessage message)
{
Interlocked.Increment(ref numMsgGot);
}
public InsufficientHttpMessageHandlingStepsException(string message, Exception innerException, HttpMessage httpMessage)
: base(message, innerException)
{
HttpMessage = httpMessage;
}
public override void OnReceivedResponse(HttpMessage message)
{
Interlocked.Add(ref numMsgGot, 2);
}
private static string RequestTextToString(HttpMessage.Request request)
{
return request.RequestText == null ? String.Empty : request.RequestText;
}
public HttpContext(IWebHost webHost, HttpMessage httpMessage) : base(webHost, httpMessage)
{
}
/// <summary>
/// Retrieves an <see cref="HttpMessage"/> object from a real service.
/// </summary>
/// <param name="request">The request to mimic on the real service.</param>
/// <param name="baseUri">The request's base Uri.</param>
/// <param name="serviceBaseUri">The real service's base Uri.</param>
/// <param name="session">The object that stores request/response information.</param>
/// <returns>An <see cref="HttpMessage"/> object containing the request/response.</returns>
private static HttpMessage GetResponseInfoFromService(
HttpListenerRequest request,
Uri baseUri,
Uri serviceBaseUri,
HttpSession session)
{
// Construct the request to make
HttpMessage message = new HttpMessage();
message.RequestInfo = ConstructRequestInfo(request);
// Clone the request and modify it for the real service
HttpMessage.Request requestToSend = message.RequestInfo.Clone();
requestToSend.RequestUri = ChangeUriBase(request.Url, baseUri, serviceBaseUri);
if (session.RequestModifier != null)
{
session.RequestModifier(requestToSend);
}
HttpWebResponse response = MakeServiceRequest(requestToSend);
message.ResponseInfo = ConstructResponseInfo(serviceBaseUri, response);
return message;
}
public void Dispose()
{
HttpMessage.Dispose();
_tcs = null;
}
/// <summary>
/// Constructs the response from the specified <see cref="HttpMessage.Response"/>.
/// </summary>
/// <param name="responseInfo">The object that contains all info about the response.</param>
/// <param name="baseUri">The base Uri for the response.</param>
/// <param name="response">The response object to construct.</param>
private static void ConstructListenerResponse(
HttpMessage.Response responseInfo,
Uri baseUri,
HttpListenerResponse response)
{
// Set the status code
response.StatusCode = (int)responseInfo.StatusCode;
// Copy relevant response headers
foreach (HttpMessage.Header header in responseInfo.Headers)
{
response.Headers[header.Name] = header.Value;
}
// Copy response cookies
foreach (HttpMessage.Cookie responseCookie in responseInfo.Cookies)
{
Cookie cookie = new Cookie(responseCookie.Name, responseCookie.Value);
Uri cookieUri = responseCookie.RelativeUri;
if (!cookieUri.IsAbsoluteUri)
{
cookieUri = new Uri(baseUri, cookieUri);
}
cookie.Domain = cookieUri.Host;
cookie.Path = cookieUri.LocalPath;
response.Cookies.Add(cookie);
}
// Copy response stream
byte[] responseBytes = Encoding.UTF8.GetBytes(responseInfo.ResponseText);
response.ContentLength64 = responseBytes.Length;
using (BinaryWriter writer = new BinaryWriter(response.OutputStream))
{
writer.Write(responseBytes);
}
}
public override void Process(HttpMessage message)
{
RedirectToTestProxy(message);
_innerTransport.Process(message);
ProcessResponseAsync(message, false).EnsureCompleted();
}
