private void DefaultHttpContext(
HttpContext context,
MemoryStream memoryStream = null,
bool isCount = false,
bool useProduct = false,
bool isSingle = false)
{
var request = context.Features.Get <IHttpRequestFeature>();
request.Method = HttpMethods.Post;
var contextName = useProduct ? nameof(TestProductsContext) :
nameof(TestWidgetsContext);
var collectionName = useProduct ? nameof(TestProductsContext.Products) :
nameof(TestWidgetsContext.Widgets);
request.Path = $"/efcore/{contextName}/{collectionName}";
var bytes = Encoding.UTF8.GetBytes(queryJson(isCount, useProduct, isSingle));
var requestStream = new MemoryStream(bytes);
request.Body = requestStream;
request.Headers.Add("Content-Type", "application/json");
request.Headers.Add("Content-Length", requestStream.Length.ToString());
var responseBody = memoryStream ?? new MemoryStream();
var responseBodyFeature = new StreamResponseBodyFeature(responseBody);
context.Features.Set <IHttpResponseBodyFeature>(responseBodyFeature);
}
public RPCMiddlewareTest()
{
this.authorization = new Mock <IRPCAuthorization>();
this.delegateContext = new Mock <RequestDelegate>();
this.httpContext = new DefaultHttpContext();
this.response = new HttpResponseFeature();
this.responseBody = new StreamResponseBodyFeature(new MemoryStream());
this.request = new HttpRequestFeature();
this.featureCollection = new FeatureCollection();
this.httpContextFactory = new Mock <IHttpContextFactory>();
this.httpContextFactory.Setup(f => f.Create(It.IsAny <FeatureCollection>())).Returns((FeatureCollection f) =>
{
DefaultHttpContext newHttpContext = new DefaultHttpContext();
newHttpContext.Initialize(f);
return(newHttpContext);
});
var nodeSettings = new NodeSettings(new StraxRegTest());
this.rpcSettings = new RpcSettings(nodeSettings);
this.middleware = new RPCMiddleware(this.delegateContext.Object, this.authorization.Object, this.LoggerFactory.Object, this.httpContextFactory.Object, new DataFolder(string.Empty), this.rpcSettings);
}
private static DefaultHttpContext SetupDefaultContextWithResponseBodyStream(Stream bodyStream)
{
var defaultContext = new DefaultHttpContext();
var response = new StreamResponseBodyFeature(bodyStream);
var featureCollection = new FeatureCollection();
featureCollection.Set <IHttpResponseBodyFeature>(response);
defaultContext.Initialize(featureCollection);
return(defaultContext);
}
protected virtual void OverrideRequestDataFeatures(IFeatureCollection newFeatures, IFeatureCollection originalFeatures, IUntypedCall call, Encoding requestEncoding)
{
var itemsFeature = CreateItems(originalFeatures.Get <IItemsFeature>());
itemsFeature.Items[JsonRpcConstants.RequestItemKey] = call;
itemsFeature.Items[JsonRpcConstants.NestedPipelineItemKey] = true;
newFeatures.Set(itemsFeature);
var requestFeature = CreateRequest(originalFeatures.Get <IHttpRequestFeature>(), call, requestEncoding);
newFeatures.Set(requestFeature);
var responseFeature = new StreamResponseBodyFeature(new MemoryStream());
newFeatures.Set <IHttpResponseBodyFeature>(responseFeature);
}
public void DisableBufferingCallsInnerFeature()
{
// Arrange
var stream = new MemoryStream();
var innerFeature = new InnerDisableBufferingFeature(stream, null);
var streamResponseBodyFeature = new StreamResponseBodyFeature(stream, innerFeature);
// Act
streamResponseBodyFeature.DisableBuffering();
//Assert
Assert.True(innerFeature.DisableBufferingCalled);
}
private async Task AssertExecution(IHttpRequestFeature requestFeature, IHttpResponseFeature responseFeature,
Stream responseStream,
BatchMiddlewareEvents batchMiddlewareEvents,
params ResponseFeature[] responseFeatures)
{
var featureCollection = new FeatureCollection();
featureCollection.Set(requestFeature);
featureCollection.Set(responseFeature);
IHttpResponseBodyFeature responseBodyFeature = new StreamResponseBodyFeature(responseStream);
featureCollection.Set(responseBodyFeature);
var defaultContext = new DefaultHttpContext(featureCollection);
var middleware = CreateMiddleware(CreateRequestDelegate(responseFeatures), batchMiddlewareEvents);
await middleware.Invoke(defaultContext).ConfigureAwait(false);
}
public async Task GivenValidBodyInvokeCalledThenShouldReturnResult()
{
nextInvoked = false;
var target = NewMiddleware();
var context = new DefaultHttpContext();
var request = context.Features.Get <IHttpRequestFeature>();
request.Method = HttpMethods.Post;
request.Path = "/efcore/testwidgetscontext/widgets";
parseRoute(context, request.Path);
var bytes = Encoding.UTF8.GetBytes(queryJson());
var requestStream = new MemoryStream(bytes);
request.Body = requestStream;
request.Headers.Add("Content-Type", "application/json");
request.Headers.Add("Content-Length", requestStream.Length.ToString());
var responseBody = new MemoryStream();
var responseBodyFeature = new StreamResponseBodyFeature(responseBody);
context.Features.Set <IHttpResponseBodyFeature>(responseBodyFeature);
await target.Invoke(context, GetServiceProvider());
Assert.Equal((int)HttpStatusCode.OK, context.Response.StatusCode);
context.Response.Body.Flush();
context.Response.Body.Position = 0;
using var reader = new StreamReader(context.Response.Body);
var json = reader.ReadToEnd();
Assert.False(string.IsNullOrWhiteSpace(json));
var result = JsonSerializer.Deserialize <TestWidget[]>(json);
Assert.NotNull(result);
Assert.Equal(5, result.Length);
}
/// <summary>
/// Invokes single request.
/// </summary>
/// <param name="httpContext">Source batch request context.</param>
/// <param name="requestObj">Single request object.</param>
/// <returns>Single response objects.</returns>
private async Task <JObject> InvokeSingleAsync(HttpContext httpContext, JObject requestObj)
{
var contextFeatures = new FeatureCollection(httpContext.Features);
var requestFeature = new HttpRequestFeature()
{
Body = new MemoryStream(Encoding.UTF8.GetBytes(requestObj.ToString())),
Headers = httpContext.Request.Headers,
Method = httpContext.Request.Method,
Protocol = httpContext.Request.Protocol,
Scheme = httpContext.Request.Scheme,
QueryString = httpContext.Request.QueryString.Value
};
contextFeatures.Set <IHttpRequestFeature>(requestFeature);
var responseMemoryStream = new MemoryStream();
var responseFeature = new StreamResponseBodyFeature(responseMemoryStream);
contextFeatures.Set <IHttpResponseFeature>(new HttpResponseFeature());
contextFeatures.Set <IHttpResponseBodyFeature>(responseFeature);
contextFeatures.Set <IHttpRequestLifetimeFeature>(new HttpRequestLifetimeFeature());
var context = this.httpContextFactory.Create(contextFeatures);
JObject response;
try
{
await this.next.Invoke(context).ConfigureAwait(false);
if (responseMemoryStream.Length == 0)
{
throw new Exception("Method not found");
}
responseMemoryStream.Position = 0;
using (var streamReader = new StreamReader(responseMemoryStream))
using (var textReader = new JsonTextReader(streamReader))
{
// Ensure floats are parsed as decimals and not as doubles.
textReader.FloatParseHandling = FloatParseHandling.Decimal;
response = await JObject.LoadAsync(textReader);
}
}
catch (Exception ex)
{
await this.HandleRpcInvokeExceptionAsync(context, ex);
context.Response.Body.Position = 0;
using (var streamReader = new StreamReader(context.Response.Body, Encoding.Default, true, 1024, true))
using (var textReader = new JsonTextReader(streamReader))
{
// Ensure floats are parsed as decimals and not as doubles.
textReader.FloatParseHandling = FloatParseHandling.Decimal;
string val = streamReader.ReadToEnd();
context.Response.Body.Position = 0;
response = await JObject.LoadAsync(textReader);
}
}
if (requestObj.ContainsKey("id"))
{
response["id"] = requestObj["id"];
}
else
{
response.Remove("id");
}
return(response);
}
public async Task InvokeAsync(HttpContext context, IWebHostEnvironment webHostEnvironment)
{
var cancellationToken = context.RequestAborted;
var requestEncoding = _options.RequestEncoding ?? Encoding.UTF8;
var excludeUrls = _options.ExcludeUrls;
var modifyResponse = excludeUrls == null || !excludeUrls.Any(bl => context.Request.Path.Value != null &&
context.Request.Path.Value.ToLowerInvariant().Contains(bl));
if (!modifyResponse)
{
await _next(context);
return;
}
var responseBodyPooledStream = new DisposablePooledStream(_pooledStreamManager, nameof(I18NMiddleware));
context.Response.RegisterForDisposeAsync(responseBodyPooledStream);
var httpResponseBodyFeature = context.Features.Get <IHttpResponseBodyFeature>();
var httpResponseFeature = context.Features.Get <IHttpResponseFeature>();
var streamResponseBodyFeature = new StreamResponseBodyFeature(responseBodyPooledStream);
context.Features.Set <IHttpResponseBodyFeature>(streamResponseBodyFeature);
await _next(context).ConfigureAwait(false);
// Force dynamic content type in order reset Content-Length header.
httpResponseFeature.Headers.ContentLength = null;
var httpResponseBodyStream = (Stream)responseBodyPooledStream;
httpResponseBodyStream.Seek(0, SeekOrigin.Begin);
var contentType = GetRequestContentType(context);
var validContentTypes = _options.ValidContentTypes;
var replaceNuggets = validContentTypes != null && validContentTypes.Contains(contentType);
if (replaceNuggets)
{
var requestCultureInfo = GetRequestCultureInfo(context);
var cultureDictionary = _localizationManager.GetDictionary(requestCultureInfo, !_options.CacheEnabled);
_logger?.LogDebug(
$"Request path: {context.Request.Path}. Culture name: {cultureDictionary.CultureName}. Translations: {cultureDictionary.Translations.Count}.");
var responseBody = await ReadResponseBodyAsStringAsync(httpResponseBodyStream, requestEncoding);
string responseBodyTranslated;
if (webHostEnvironment.IsDevelopment())
{
var sw = new Stopwatch();
sw.Restart();
responseBodyTranslated = _nuggetReplacer.Replace(cultureDictionary, responseBody);
sw.Stop();
_logger?.LogDebug($"Replaced body in {sw.ElapsedMilliseconds} ms.");
const string i18NMiddlewareName = "X-" + nameof(I18NMiddleware) + "-Ms";
httpResponseFeature.Headers[i18NMiddlewareName] = sw.ElapsedMilliseconds.ToString();
}
else
{
responseBodyTranslated = _nuggetReplacer.Replace(cultureDictionary, responseBody);
}
var stringContent = new StringContent(responseBodyTranslated, requestEncoding, contentType);
#if NET50
await stringContent.CopyToAsync(httpResponseBodyFeature.Stream, cancellationToke);
#else
await stringContent.CopyToAsync(httpResponseBodyFeature.Stream);
#endif
return;
}
await httpResponseBodyStream.CopyToAsync(httpResponseBodyFeature.Stream, cancellationToken).ConfigureAwait(false);
}
