public RPCMiddlewareTest()
{
this.authorization = new Mock <IRPCAuthorization>();
this.delegateContext = new Mock <RequestDelegate>();
this.httpContext = new DefaultHttpContext();
this.response = new HttpResponseFeature();
this.request = new HttpRequestFeature();
this.response.Body = new MemoryStream();
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 StratisRegTest());
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);
}
async Task <HttpRequestFeature> CreateRequestAsync(Stream stream, CancellationToken cancellationToken)
{
var firstLine = await stream.ReadLineAsync(cancellationToken).ConfigureAwait(false);
var parts = firstLine.Split(' ');
var result = new HttpRequestFeature();
result.Method = parts[0];
var uri = new Uri(parts[1], UriKind.RelativeOrAbsolute);
if (!uri.IsAbsoluteUri)
{
uri = new Uri(_localhostUri, uri);
}
result.Protocol = parts[2];
for (; ;)
{
var line = await stream.ReadLineAsync(cancellationToken).ConfigureAwait(false);
if (line.Length == 0)
{
break;
}
(var name, var values) = HttpParser.ParseHeaderNameValues(line);
result.Headers.Add(name, new Microsoft.Extensions.Primitives.StringValues(values.ToArray()));
}
result.Scheme = uri.Scheme;
result.Path = PathString.FromUriComponent(uri);
result.QueryString = QueryString.FromUriComponent(uri).Value;
result.Body = new BodyStream(stream, result.Headers.ContentLength);
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="areaName">The name of the area containing the Emails view folder if applicable</param>
/// <returns></returns>
#if ASPNET5
ActionContext CreateControllerContext(string areaName, IHttpRequestFeature requsetFeature)
{
var routeData = new Microsoft.AspNetCore.Routing.RouteData();
routeData.Values["controller"] = EmailViewDirectoryName;
// if populated will add searching the named Area for the view
if (!string.IsNullOrWhiteSpace(areaName))
{
routeData.DataTokens["Area"] = areaName;
}
var actionDescriptor = new ActionDescriptor();
actionDescriptor.RouteValues = routeData.Values.ToDictionary(kv => kv.Key, kv => kv.Value.ToString());
FeatureCollection featureCollection = new FeatureCollection();
var requsetFeature_local = new HttpRequestFeature();
requsetFeature_local.Method = "GET";
requsetFeature_local.Protocol = requsetFeature?.Protocol;
requsetFeature_local.PathBase = requsetFeature?.PathBase;
requsetFeature_local.Scheme = requsetFeature?.Scheme;
featureCollection.Set <IHttpRequestFeature>(requsetFeature_local);
featureCollection.Set <IHttpResponseFeature>(new HttpResponseFeature());
var httpContext = new DefaultHttpContext(featureCollection);
httpContext.RequestServices = serviceProvider;
var actionContext = new ActionContext(httpContext, routeData, actionDescriptor);
actionContext.RouteData = routeData;
return(actionContext);
}
public void RouteAsyncLoadsRouteContextOntoRouteData()
{
var request = new HttpRequestFeature();
SetupRequestBody(request, "{\"method\": \"GET\"}");
var context = new RouteContext(this.PrepareDefaultHttpContext(request));
RouteContext callback = null;
this.inner.Setup(i => i.RouteAsync(It.IsAny <RouteContext>()))
.Callback <RouteContext>((r) => { callback = r; })
.Returns(Task.FromResult(0));
var desciptors = new ActionDescriptorCollection(new List <ControllerActionDescriptor>
{
new ControllerActionDescriptor
{
ActionName = "GET",
ControllerName = "RPCController"
}
}, 1);
this.actionDescriptor.Setup(a => a.ActionDescriptors)
.Returns(desciptors);
Task task = this.handler.RouteAsync(context);
task.Wait();
Assert.Equal("GET", callback.RouteData.Values["action"]);
Assert.Equal("RPCController", callback.RouteData.Values["controller"]);
Assert.True(callback.RouteData.Values["req"].GetType() == typeof(JObject));
}
private static void SetupRequestBody(HttpRequestFeature request, string requestBody)
{
request.Body = new MemoryStream();
byte[] bytes = Encoding.ASCII.GetBytes(requestBody);
request.Body.Write(bytes, 0, bytes.Length);
request.Body.Position = 0;
}
public ViewRenderService(
IHttpContextAccessor httpContextAccessor,
IRazorViewEngine razorViewEngine,
ITempDataProvider tempDataProvider,
IServiceProvider serviceProvider,
IConfiguration configuration)
{
_httpContext = httpContextAccessor.HttpContext;
_razorViewEngine = razorViewEngine;
_tempDataProvider = tempDataProvider;
_serviceProvider = serviceProvider;
_configuration = configuration;
var emailBaseUrl = _configuration.GetSection("Email:BaseUrl").Get <string>();
var url = new Uri(emailBaseUrl);
_cultureInfo = CultureInfo.GetCultureInfo("en-NZ");
_defaultRequestFeature = new HttpRequestFeature
{
Headers =
{
{ HeaderNames.Host, url.Authority },
{ HeaderNames.AcceptLanguage, "en-NZ" },
},
Scheme = url.Scheme,
QueryString = url.Query,
Path = url.AbsolutePath,
};
}
public void TestNegotiateHandlerWithMultipleEndpointsAndCustomRouter()
{
var config = new ConfigurationBuilder().Build();
var router = new TestCustomRouter(ConnectionString3);
var serviceProvider = new ServiceCollection().AddSignalR()
.AddAzureSignalR(
o => o.Endpoints = new ServiceEndpoint[]
{
new ServiceEndpoint(ConnectionString2),
new ServiceEndpoint(ConnectionString3),
new ServiceEndpoint(ConnectionString4),
})
.Services
.AddLogging()
.AddSingleton <IEndpointRouter>(router)
.AddSingleton <IConfiguration>(config)
.BuildServiceProvider();
var requestFeature = new HttpRequestFeature
{
Path = "/user/path/negotiate/",
};
var features = new FeatureCollection();
features.Set <IHttpRequestFeature>(requestFeature);
var httpContext = new DefaultHttpContext(features);
var handler = serviceProvider.GetRequiredService <NegotiateHandler>();
var negotiateResponse = handler.Process(httpContext, "chat");
Assert.NotNull(negotiateResponse);
Assert.Equal($"http://localhost3/client/?hub=chat&asrs.op=%2Fuser%2Fpath", negotiateResponse.Url);
}
public async Task TestNegotiateHandlerResponseContainsValidMaxPollInterval(int maxPollInterval)
{
var config = new ConfigurationBuilder().Build();
var serviceProvider = new ServiceCollection().AddSignalR()
.AddAzureSignalR(o =>
{
o.ConnectionString = DefaultConnectionString;
o.MaxPollIntervalInSeconds = maxPollInterval;
})
.Services
.AddLogging()
.AddSingleton <IConfiguration>(config)
.BuildServiceProvider();
var requestFeature = new HttpRequestFeature
{
Path = "/user/path/negotiate/",
QueryString = "?endpoint=chosen"
};
var responseFeature = new HttpResponseFeature();
var features = new FeatureCollection();
features.Set <IHttpRequestFeature>(requestFeature);
features.Set <IHttpResponseFeature>(responseFeature);
var httpContext = new DefaultHttpContext(features);
var handler = serviceProvider.GetRequiredService <NegotiateHandler>();
var response = await handler.Process(httpContext, "chat");
Assert.Equal(200, responseFeature.StatusCode);
var tokens = JwtTokenHelper.JwtHandler.ReadJwtToken(response.AccessToken);
Assert.Contains(tokens.Claims, x => x.Type == Constants.ClaimType.MaxPollInterval && x.Value == maxPollInterval.ToString());
}
async Task <HttpRequestFeature> CreateRequesteAsync(Stream stream)
{
var lineReader = new ByLineReader(stream, 1024);
var requestLine = await lineReader.NextLineAsync().ConfigureAwait(false);
var firstLine = HttpParser.GetAsciiString(requestLine);
var parts = firstLine.Split(' ');
var result = new HttpRequestFeature();
result.Method = parts[0];
var uri = new Uri("http://localhost" + parts[1]);
result.Protocol = parts[2];
for (; ;)
{
var line = await lineReader.NextLineAsync().ConfigureAwait(false);
if (line.Count == 0)
{
break;
}
(var name, var values) = HttpParser.ParseHeaderNameValue(line);
result.Headers.Add(name, new Microsoft.Extensions.Primitives.StringValues(values.ToArray()));
}
result.Scheme = uri.Scheme;
result.Path = PathString.FromUriComponent(uri);
result.QueryString = QueryString.FromUriComponent(uri).Value;
result.Body = new StreamWithPrefix(lineReader.Remaining, stream, result.Headers.ContentLength);
return(result);
}
public void GenerateNegotiateResponseWithPathAndQuery(string path, string queryString, string expectedQueryString)
{
var config = new ConfigurationBuilder().Build();
var serviceProvider = new ServiceCollection().AddSignalR()
.AddAzureSignalR(o => o.ConnectionString = DefaultConnectionString)
.Services
.AddLogging()
.AddSingleton <IConfiguration>(config)
.BuildServiceProvider();
var requestFeature = new HttpRequestFeature
{
Path = path,
QueryString = queryString
};
var features = new FeatureCollection();
features.Set <IHttpRequestFeature>(requestFeature);
var httpContext = new DefaultHttpContext(features);
var handler = serviceProvider.GetRequiredService <NegotiateHandler>();
var negotiateResponse = handler.Process(httpContext, "chat");
Assert.NotNull(negotiateResponse);
Assert.EndsWith($"?hub=chat&{expectedQueryString}", negotiateResponse.Url);
}
public void Configure(IApplicationBuilder app)
{
app.UseDeveloperExceptionPage();
app.Run(context =>
{
var server = context.RequestServices.GetRequiredService <IServer>();
var gate = server.Features.Get <RequestGate>();
var feature = context.Features.Get <IHttpRequestFeature>();
var mockRequest = new HttpRequestFeature
{
Scheme = feature.Scheme,
RawTarget = feature.RawTarget,
Protocol = feature.Protocol,
Method = feature.Method,
Path = feature.Path,
PathBase = feature.PathBase,
QueryString = feature.QueryString,
Headers = feature.Headers,
Body = new MemoryStream()
};
feature.Body.CopyTo(mockRequest.Body, 1024);
mockRequest.Body.Seek(0, SeekOrigin.Begin);
gate.Request = mockRequest;
context.Response.StatusCode = (int)HttpStatusCode.OK;
return(Task.CompletedTask);
});
}
public async Task AbortNonSuccessStatusCode()
{
var requestFeature = new HttpRequestFeature {
Path = "/api/batch"
};
requestFeature.Headers.Add(HeaderNames.ContentType,
"multipart/mixed; boundary=\"batch_357647d1-a6b5-4e6a-aa73-edfc88d8866e\"");
requestFeature.Body = TestUtilities.GetNormalizedContentStream("MultipartRequest.txt");
var responseFeature = new HttpResponseFeature();
var mockedEvents = new MockedBatchEventHandler();
using (responseFeature.Body = new MemoryStream())
{
await AssertExecution(requestFeature, responseFeature, mockedEvents,
CreateFirstResponse(),
CreateInternalServerResponse(),
CreateThirdResponse(),
CreateFourthResponse()).ConfigureAwait(false);
Assert.Equal(StatusCodes.Status500InternalServerError, responseFeature.StatusCode);
Assert.Equal(1, mockedEvents.BatchEndCount);
Assert.Equal(1, mockedEvents.BatchStartCount);
Assert.Equal(2, mockedEvents.BatchRequestPreparationCount);
Assert.Equal(2, mockedEvents.BatchRequestExecutingCount);
Assert.Equal(2, mockedEvents.BatchRequestExecutedCount);
}
}
public void GenerateNegotiateResponseWithAppName(string appName, string expectedResponse)
{
var config = new ConfigurationBuilder().Build();
var serviceProvider = new ServiceCollection().AddSignalR()
.AddAzureSignalR(o =>
{
o.ConnectionString = DefaultConnectionString;
o.ApplicationName = appName;
})
.Services
.AddLogging()
.AddSingleton <IConfiguration>(config)
.BuildServiceProvider();
var requestFeature = new HttpRequestFeature
{
};
var features = new FeatureCollection();
features.Set <IHttpRequestFeature>(requestFeature);
var httpContext = new DefaultHttpContext(features);
var handler = serviceProvider.GetRequiredService <NegotiateHandler>();
var negotiateResponse = handler.Process(httpContext, "chat");
Assert.NotNull(negotiateResponse);
Assert.EndsWith(expectedResponse, negotiateResponse.Url);
}
private static FeatureCollection BuildFeatureCollection(HttpRequestFeature requestFeature, HttpResponseFeature responseFeature)
{
var features = new FeatureCollection();
features.Set <IHttpRequestFeature>(requestFeature);
features.Set <IHttpResponseFeature>(responseFeature);
return(features);
}
public HttpContext Execute(HttpRequestFeature requestFeature,
Action <FeatureCollection> featureCollectionAction = null)
{
var task = ExecuteAsync(requestFeature, featureCollectionAction);
task.Wait();
return(task.Result);
}
public override async Task HandleBasicDeliver(String consumerTag, UInt64 deliveryTag, Boolean redelivered, String exchange, String routingKey, IBasicProperties properties, Byte[] body)
{
var app = _server._application;
var path = String.Empty;
if (properties.Headers.TryGetValue("path", out var pathObj))
{
path = Encoding.UTF8.GetString((Byte[])pathObj);
if (!path.StartsWith("/"))
{
path = "/" + path;
}
}
var requestFeature = new HttpRequestFeature
{
Body = new MemoryStream(body, writable: false),
Method = "GET",
Protocol = "http",
Path = path,
Scheme = "http",
};
var responseBodyStream = new MemoryStream();
var responseFeature = new HttpResponseFeature
{
Body = responseBodyStream,
};
var features = new FeatureCollection(_server._features);
features.Set <IHttpRequestFeature>(requestFeature);
features.Set <IHttpResponseFeature>(responseFeature);
var context = app.CreateContext(features);
await app.ProcessRequestAsync(context);
if (properties.IsReplyToPresent() && properties.ReplyToAddress != null)
{
var responseBody = responseBodyStream.ToArray();
var props = Model.CreateBasicProperties();
if (props.Headers == null)
{
props.Headers = new Dictionary <String, Object>();
}
foreach (var header in responseFeature.Headers)
{
props.Headers.Add(header.Key, Encoding.UTF8.GetBytes(header.Value));
}
Model.BasicPublish(properties.ReplyToAddress, props, responseBody);
}
Model.BasicAck(deliveryTag, multiple: false);
app.DisposeContext(context, null);
}
/// <summary>
/// Invokes batch request.
/// </summary>
/// <param name="httpContext">Source batch request context.</param>
/// <param name="requests">Array of requests.</param>
private async Task InvokeAsyncBatchAsync(HttpContext httpContext, JArray requests)
{
JArray responses = new JArray();
foreach (JObject requestObj in requests)
{
var contextFeatures = new FeatureCollection(httpContext.Features);
StringBuilder requestStringBuilder = new StringBuilder();
await requestObj.WriteToAsync(new JsonTextWriter(new StringWriter(requestStringBuilder)));
var requestFeature = new HttpRequestFeature()
{
Body = new MemoryStream(Encoding.UTF8.GetBytes(requestStringBuilder.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 HttpResponseFeature()
{
Body = responseMemoryStream
};
contextFeatures.Set <IHttpResponseFeature>(responseFeature);
contextFeatures.Set <IHttpRequestLifetimeFeature>(new HttpRequestLifetimeFeature());
var context = this.httpContextFactory.Create(contextFeatures);
try
{
await this.next.Invoke(context).ConfigureAwait(false);
}
catch (Exception ex)
{
await this.HandleRpcInvokeExceptionAsync(context, ex);
}
responseMemoryStream.Position = 0;
var response = (responseMemoryStream.Length == 0) ? CreateError(RPCErrorCode.RPC_METHOD_NOT_FOUND, "Method not found") : await JObject.LoadAsync(new JsonTextReader(new StreamReader(responseMemoryStream)));
responses.Add(response);
}
// Update the response with the array of responses.
using (StreamWriter streamWriter = new StreamWriter(httpContext.Response.Body))
using (JsonTextWriter textWriter = new JsonTextWriter(streamWriter))
{
await responses.WriteToAsync(textWriter);
}
}
private static IRequestCookieCollection MockRequestCookieCollection(string key, string value)
{
var requestFeature = new HttpRequestFeature();
var featureCollection = new FeatureCollection();
requestFeature.Headers = new HeaderDictionary {
{ HeaderNames.Cookie, new StringValues(key + "=" + value) }
};
featureCollection.Set <IHttpRequestFeature>(requestFeature);
var cookiesFeature = new RequestCookiesFeature(featureCollection);
return(cookiesFeature.Cookies);
}
public void EmptyKeysNotAddedToQueryCollection(string queryString)
{
var features = new FeatureCollection();
var request = new HttpRequestFeature();
request.QueryString = queryString;
features[typeof(IHttpRequestFeature)] = request;
var provider = new QueryFeature(features);
var queryCollection = provider.Query;
Assert.Equal(0, queryCollection.Count);
}
public void EmptyKeysNotAddedToQueryCollection(string queryString)
{
var features = new FeatureCollection();
features[typeof(IHttpRequestFeature)] = new HttpRequestFeature {
QueryString = queryString
};
var provider = new QueryFeature(features);
var queryCollection = provider.Query;
Assert.Equal(0, queryCollection.Count);
}
public RPCMiddlewareTest()
{
this.httpContext = new DefaultHttpContext();
this.authorization = new Mock <IRPCAuthorization>();
this.delegateContext = new Mock <RequestDelegate>();
this.httpContext = new DefaultHttpContext();
this.response = new HttpResponseFeature();
this.request = new HttpRequestFeature();
this.response.Body = new MemoryStream();
this.featureCollection = new FeatureCollection();
this.middleware = new RPCMiddleware(this.delegateContext.Object, this.authorization.Object, this.LoggerFactory.Object);
}
public void KeyWithoutValuesAddedToQueryCollection(string queryString, string emptyParam)
{
var features = new FeatureCollection();
var request = new HttpRequestFeature();
request.QueryString = queryString;
features[typeof(IHttpRequestFeature)] = request;
var provider = new QueryFeature(features);
var queryCollection = provider.Query;
Assert.True(queryCollection.Keys.Contains(emptyParam));
Assert.Equal(string.Empty, queryCollection[emptyParam]);
}
public void ParseEmptyOrNullQueryWorks(string queryString)
{
var features = new FeatureCollection();
features[typeof(IHttpRequestFeature)] = new HttpRequestFeature {
QueryString = queryString
};
var provider = new QueryFeature(features);
var queryCollection = provider.Query;
Assert.Empty(queryCollection);
}
private IHttpRequestFeature CreateHttpRequest(IMqRequestFeature mqRequest, IHeaderConverter headerConverter)
{
var props = mqRequest.Properties;
var headers = props?.Headers;
var httpRequest = new HttpRequestFeature
{
Scheme = "amqp",
Protocol = _mqConnection.Connection.Protocol.ApiName,
};
httpRequest.PathBase = _pathBaseBase
+ "/" + (mqRequest.Exchange ?? String.Empty)
+ "/" + (mqRequest.RoutingKey ?? String.Empty);
if (mqRequest.Body != null)
{
httpRequest.Body = new MemoryStream(mqRequest.Body, writable: false);
httpRequest.Headers[HeaderNames.ContentLength] = mqRequest.Body.LongLength.ToString();
}
if (props != null)
{
// TODO: fill headers from props.
}
if (headers != null)
{
if (headers.TryGetValue(HeaderNames.Method, out var rawMethod))
{
httpRequest.Method = headerConverter.ReadString(rawMethod);
}
if (headers.TryGetValue(HeaderNames.Path, out var rawPath))
{
httpRequest.Path = headerConverter.ReadString(rawPath);
}
if (headers.TryGetValue(HeaderNames.QueryString, out var rawQueryString))
{
httpRequest.QueryString = headerConverter.ReadString(rawQueryString);
}
foreach (var item in headers)
{
httpRequest.Headers[item.Key] = headerConverter.Read(item.Value);
}
}
return(httpRequest);
}
public void KeyWithoutValuesAddedToQueryCollection(string queryString, string emptyParam)
{
var features = new FeatureCollection();
features[typeof(IHttpRequestFeature)] = new HttpRequestFeature {
QueryString = queryString
};
var provider = new QueryFeature(features);
var queryCollection = provider.Query;
Assert.True(queryCollection.Keys.Contains(emptyParam));
Assert.Equal(string.Empty, queryCollection[emptyParam]);
}
public void ParseQueryWithEncodedKeyEncodedValuesWorks()
{
var features = new FeatureCollection();
features[typeof(IHttpRequestFeature)] = new HttpRequestFeature {
QueryString = "?fields+%5BtodoItems%5D=%5B+1+%5D&fields+%5BtodoItems%5D=%5B+2+%5D"
};
var provider = new QueryFeature(features);
var queryCollection = provider.Query;
Assert.Single(queryCollection);
Assert.Equal(new[] { "[ 1 ]", "[ 2 ]" }, queryCollection["fields [todoItems]"]);
}
public void ParseQueryWithEncodedKeyEmptyValueWorks()
{
var features = new FeatureCollection();
features[typeof(IHttpRequestFeature)] = new HttpRequestFeature {
QueryString = "?fields+%5BtodoItems%5D="
};
var provider = new QueryFeature(features);
var queryCollection = provider.Query;
Assert.Single(queryCollection);
Assert.Equal("", queryCollection["fields [todoItems]"].FirstOrDefault());
}
public void ParseQueryWithEmptyKeyWorks()
{
var features = new FeatureCollection();
features[typeof(IHttpRequestFeature)] = new HttpRequestFeature {
QueryString = "?=value1&="
};
var provider = new QueryFeature(features);
var queryCollection = provider.Query;
Assert.Single(queryCollection);
Assert.Equal(new[] { "value1", "" }, queryCollection[""]);
}
public void ParseQueryWithThreefoldKeysGroups()
{
var features = new FeatureCollection();
features[typeof(IHttpRequestFeature)] = new HttpRequestFeature {
QueryString = "?key1=valueA&key2=valueB&key1=valueC&key1=valueD"
};
var provider = new QueryFeature(features);
var queryCollection = provider.Query;
Assert.Equal(2, queryCollection.Count);
Assert.Equal(new[] { "valueA", "valueC", "valueD" }, queryCollection["key1"]);
Assert.Equal("valueB", queryCollection["key2"].FirstOrDefault());
}
public void CaseInsensitiveWithFewKeys()
{
// need to use less than 10 keys to test array storage code path
var features = new FeatureCollection();
features[typeof(IHttpRequestFeature)] = new HttpRequestFeature {
QueryString = "?key=1&Key=2&key=3&Key=4&KEy=5"
};
var provider = new QueryFeature(features);
var queryCollection = provider.Query;
Assert.Equal(1, queryCollection.Count);
Assert.Equal(new[] { "1", "2", "3", "4", "5" }, queryCollection["KEY"]);
}
public void ParseQueryWithEmptyValuesWorks()
{
var features = new FeatureCollection();
features[typeof(IHttpRequestFeature)] = new HttpRequestFeature {
QueryString = "?key1=&key2="
};
var provider = new QueryFeature(features);
var queryCollection = provider.Query;
Assert.Equal(2, queryCollection.Count);
Assert.Equal(string.Empty, queryCollection["key1"].FirstOrDefault());
Assert.Equal(string.Empty, queryCollection["key2"].FirstOrDefault());
}
public void ParseQueryWithUniqueKeysWorks(string queryString)
{
var features = new FeatureCollection();
features[typeof(IHttpRequestFeature)] = new HttpRequestFeature {
QueryString = queryString
};
var provider = new QueryFeature(features);
var queryCollection = provider.Query;
Assert.Equal(2, queryCollection.Count);
Assert.Equal("value1", queryCollection["key1"].FirstOrDefault());
Assert.Equal("value2", queryCollection["key2"].FirstOrDefault());
}
public void QueryReturnsParsedQueryCollection()
{
// Arrange
var features = new FeatureCollection();
var request = new HttpRequestFeature();
request.QueryString = "foo=bar";
features[typeof(IHttpRequestFeature)] = request;
var provider = new QueryFeature(features);
// Act
var queryCollection = provider.Query;
// Assert
Assert.Equal("bar", queryCollection["foo"]);
}
