public void TestInvalidUrl()
{
UrlParser urlParser = new UrlParser("/source", new Location(new Uri("http://www.test.com/images"), "/destination"));
Assert.Throws <UrlParserException>(() =>
{
urlParser.Parse(new Uri("http://www.test.com/images/100x50-/test.jpg"));
});
}
public void TestUnknownModifier()
{
UrlParser urlParser = new UrlParser("/source", new Location(new Uri("http://www.test.com/images"), "/destination"));
Assert.Throws <UrlParserException>(() =>
{
urlParser.Parse(new Uri("http://www.test.com/images/100x50-elastic/test.jpeg"));
});
}
public void it_should_map_Add_method_correctly_with_additional_unneeded_parameters()
{
var mapping = _mapper.MapRequest(new RequestInfo(Verb.GET, (HttpUrl)UrlParser.Parse("http://temp.uri/api/test/add?random=1&operandB=2&_=whatever&operandA=1"), new MemoryStream(), new BasicClaimBasedIdentity()));
mapping.Should().NotBeNull();
mapping.Target.Should().NotBeNull();
mapping.Target.Should().BeOfType <TestController>();
mapping.Operation.UnderlyingMethod.Should().BeSameAs(typeof(TestController).GetMethod("Add"));
}
public void it_should_deny_access_to_secured_resourcefor_an_authenticated_identity()
{
var handler = SetupEnvironment((object)null, true, "Secured");
var result = handler.HandleRequest(new RequestInfo(Verb.GET, (HttpUrl)UrlParser.Parse("http://temp.uri/api/test"), new MemoryStream(), new BasicClaimBasedIdentity("test")));
result.Should().BeOfType <ExceptionResponseInfo>();
((ExceptionResponseInfo)result).Value.Should().BeOfType <AccessDeniedException>();
}
public void UrlsWithDifferentSchemeAreNotIdentical()
{
// create configuration without force http host patterns
var configuration = TestData.TestData.DefaultConfiguration;
configuration.ForceHttpHostPatterns = new List <string>();
var urlFormatter = new UrlFormatter();
var urlParser = new UrlParser();
var urlHelper = new UrlHelper(
configuration,
urlParser,
urlFormatter);
// create urls
var rawUrl1 = "http://www.test.local/url1";
var rawUrl2 = "https://www.test.local/url1";
var parsedUrl1 = urlParser.Parse(
rawUrl1,
configuration.DefaultUrl);
var parsedUrl2 = urlParser.Parse(
rawUrl2,
configuration.DefaultUrl);
var url1 = new Url
{
Raw = rawUrl1,
Parsed = parsedUrl1,
Formatted = urlFormatter.Format(
parsedUrl1)
};
var url2 = new Url
{
Raw = rawUrl2,
Parsed = parsedUrl2,
Formatted = urlFormatter.Format(
parsedUrl2)
};
// verify urls are identical using force http host pattern and one url has https scheme
Assert.AreEqual(
false,
urlHelper.AreIdentical(
url1.Formatted,
url2.Formatted));
}
public void it_should_unwrap_async_tasks_result()
{
var expected = 1;
var handler = SetupEnvironmentAsync(expected, true);
var result = handler.HandleRequest(new RequestInfo(Verb.GET, (HttpUrl)UrlParser.Parse("http://temp.uri/api/test"), new MemoryStream(), new BasicClaimBasedIdentity()));
result.Should().BeOfType <ObjectResponseInfo <int> >();
((ObjectResponseInfo <int>)result).Value.Should().Be(expected);
}
public void Setup()
{
UrlParser.Register <RelativeUrlParser>();
var controllerType = typeof(TestController);
var operationUrl = "/api/test/operation";
var methodInfo = controllerType.GetMethod("Operation");
var entryPoint = new EntryPointInfo(UrlParser.Parse("/api")).WithSecurityDetailsFrom(controllerType.Assembly);
_operationInfo = new FakeOperationInfo(methodInfo, UrlParser.Parse(operationUrl), null, new Regex(operationUrl)).WithSecurityDetailsFrom(methodInfo);
new FakeControllerInfo(entryPoint, UrlParser.Parse("/api/test"), _operationInfo).WithSecurityDetailsFrom(controllerType);
}
public Subscription(string resourceUrl, string callbackUrl, string notificationType, HttpClient notifier)
{
ResourceUrl = resourceUrl;
UrlParser parser = new UrlParser();
parser.Parse(callbackUrl); // ensure that the URL passed is non-null and that it is well-formed
SubscriberCallbackUrl = callbackUrl;
this.notifier = notifier;
NotificationType = notificationType;
SubID = Guid.NewGuid(); // generate a unique ID for this subscription resource
}
public void it_should_allow_methods_in_CORS_request()
{
var controller = new OptionsController(HttpStatusCode.MethodNotAllowed, "GET");
var request = new RequestInfo(Verb.OPTIONS, (HttpUrl)UrlParser.Parse("/"), new MemoryStream(), new BasicClaimBasedIdentity(), new Header("Origin", "temp.uri"), new Header("Access-Control-Request-Method", "GET"));
controller.Response = new StringResponseInfo(String.Empty, request);
controller.Allow();
controller.Response.Headers["Access-Control-Allow-Methods"].Should().Be("GET");
}
public void it_should_process_post_request_handlers()
{
var postRequestHandler = new Mock <IPostRequestHandler>(MockBehavior.Strict);
postRequestHandler.Setup(instance => instance.Process(It.IsAny <IResponseInfo>())).Returns(Task.FromResult(0));
var handler = SetupEnvironment(1, true, postRequestHandler: postRequestHandler.Object);
handler.HandleRequest(new RequestInfo(Verb.GET, (HttpUrl)UrlParser.Parse("http://temp.uri/api/test"), new MemoryStream(), new BasicClaimBasedIdentity()));
postRequestHandler.Verify(instance => instance.Process(It.IsAny <IResponseInfo>()), Times.Once);
}
public void Should_be_comparable(string url1, string url2, bool expected)
{
var r1 = new TopologyReplica(UrlParser.Parse(url1));
var r2 = new TopologyReplica(UrlParser.Parse(url2));
r1.Equals(r2).Should().Be(expected);
if (expected)
{
r1.GetHashCode().Should().Be(r2.GetHashCode());
}
}
public void it_should_create_an_instance_correctly()
{
var result = new FakeOperationInfo(
Method,
UrlParser.Parse("/"),
"/",
new Regex(".*"),
new ResultInfo(Result, new ToBodyAttribute(), "/", "test"),
new ArgumentInfo(Parameter, new FromUrlAttribute(), "/", "test"));
result.Should().BeOfType <FakeOperationInfo>();
}
public void it_should_process_model_transformers()
{
var modelTransformer = new Mock <IModelTransformer>(MockBehavior.Strict);
modelTransformer.Setup(instance => instance.Transform(It.IsAny <IRequestMapping>(), It.IsAny <IRequestInfo>(), It.IsAny <object>(), It.IsAny <object[]>()))
.Returns <IRequestInfo, object, object[]>((request, result, arguments) => Task.FromResult(result));
var handler = SetupEnvironment(1, true, modelTransformer: modelTransformer.Object);
handler.HandleRequest(new RequestInfo(Verb.GET, (HttpUrl)UrlParser.Parse("http://temp.uri/api/test"), new MemoryStream(), new BasicClaimBasedIdentity()));
modelTransformer.Verify(instance => instance.Transform(It.IsAny <IRequestMapping>(), It.IsAny <IRequestInfo>(), It.IsAny <object>(), It.IsAny <object[]>()), Times.Once);
}
public void TestFullUrlRandomOrder()
{
UrlParser urlParser = new UrlParser("/source", new Location(new Uri("http://www.test.com/images"), "/destination"));
UrlParserResult parserResult = urlParser.Parse(new Uri("http://www.test.com/images/100x50-npp-q32-c4-cover/test.jpeg"));
Assert.True(parserResult.Width == 100);
Assert.True(parserResult.Height == 50);
Assert.True(parserResult.ResizeMethod == ResizeMethod.Cover);
Assert.True(parserResult.Quality == 32);
Assert.True(parserResult.Compression == 4);
Assert.False(parserResult.PostProcess);
}
public void TestCommonUrl()
{
UrlParser urlParser = new UrlParser("/source", new Location(new Uri("http://www.test.com/images"), "/destination"));
UrlParserResult parserResult = urlParser.Parse(new Uri("http://www.test.com/images/100x50-scaledown/test.jpg"));
Assert.True(parserResult.Width == 100);
Assert.True(parserResult.Height == 50);
Assert.True(parserResult.ResizeMethod == ResizeMethod.ScaleDown);
Assert.Null(parserResult.Quality);
Assert.Null(parserResult.Compression);
Assert.Null(parserResult.PostProcess);
}
/// <summary>Converts a method into an operation descriptor..</summary>
/// <typeparam name="T">Type of the protocol specific command.</typeparam>
/// <param name="method">The method.</param>
/// <param name="baseUri">The call URI.</param>
/// <param name="verb">The verb.</param>
/// <param name="callUri">Call URI.</param>
/// <param name="values">Call values.</param>
/// <returns>Operation descriptor.</returns>
public static OperationInfo <T> ToOperationInfo <T>(this MethodInfo method, string baseUri, T verb, out string callUri, params object[] values)
{
var methodUri = method.GetCustomAttributes <RouteAttribute>().Select(attribute => attribute.Url.ToString()).FirstOrDefault() ?? method.Name.ToLower();
if ((methodUri == "list") || (methodUri == "get") || (methodUri == "create") || (methodUri == "post") ||
(methodUri == "update") || (methodUri == "put") || (methodUri == "delete"))
{
methodUri = String.Empty;
}
var actualCallUri = "/" + baseUri.Trim('/') + (methodUri.Length > 0 ? "/" + methodUri.TrimStart('/') : String.Empty);
var targetUriTemplate = actualCallUri;
var queryString = String.Empty;
var arguments = method.GetParameters()
.Where(parameter => !parameter.IsOut)
.Select((parameter, index) =>
{
string uriTemplate = null;
var target = parameter.GetParameterTarget();
if (target is FromUrlAttribute)
{
var temp = String.Format("/{{{0}}}", parameter.Name);
uriTemplate = (methodUri += temp);
targetUriTemplate += temp;
actualCallUri += temp;
}
else if (target is FromQueryStringAttribute)
{
queryString += (queryString.Length == 0 ? "?" : "&") + String.Format("{0}={{{0}}}", parameter.Name);
uriTemplate = methodUri + queryString;
}
return((ValueInfo) new ArgumentInfo(parameter, target, uriTemplate, (target is FromBodyAttribute ? null : parameter.Name)));
})
.Concat(method.GetParameters()
.Where(parameter => parameter.IsOut)
.Select(parameter => (ValueInfo) new ResultInfo(parameter, parameter.GetResultTarget(), null, null)));
if (method.ReturnParameter != null)
{
arguments = arguments.Concat(new[] { new ResultInfo(method.ReturnParameter, method.ReturnParameter.GetResultTarget(), null, null) });
}
arguments = arguments.ToArray();
callUri = actualCallUri + queryString;
targetUriTemplate += queryString;
var queryStringParameters = Regex.Matches(callUri, "[?&]([^=]+)=[^&]+").Cast <Match>();
var queryStringRegex = (queryStringParameters.Any() ? "[?&](" + String.Join("|", queryStringParameters.Select(item => item.Groups[1].Value)) + ")=[^&]+" : String.Empty);
var methodRegex = new Regex("^" + Regex.Replace(actualCallUri, "/{[^}]+}", "/[^\\/]+") + queryStringRegex + "$");
return(new OperationInfo <T>(method, (HttpUrl)UrlParser.Parse("/" + methodUri), targetUriTemplate, methodRegex, verb, (ValueInfo[])arguments));
}
public void it_should_deny_access_for_unauthenticated_identity()
{
var defaultAuthenticationScheme = new Mock <IDefaultAuthenticationScheme>(MockBehavior.Strict);
defaultAuthenticationScheme.Setup(instance => instance.Process(It.IsAny <IResponseInfo>())).Returns(Task.FromResult(0));
var handler = SetupEnvironment((object)null, true, "Authenticated", postRequestHandler: defaultAuthenticationScheme.Object);
var result = handler.HandleRequest(new RequestInfo(Verb.GET, (HttpUrl)UrlParser.Parse("http://temp.uri/api/test"), new MemoryStream(), new BasicClaimBasedIdentity()));
result.Should().BeOfType <ExceptionResponseInfo>();
((ExceptionResponseInfo)result).Value.Should().BeOfType <UnauthenticatedAccessException>();
defaultAuthenticationScheme.Verify(instance => instance.Process(It.IsAny <IResponseInfo>()), Times.Once);
}
/// <summary>Initializes a new instance of the <see cref="RouteAttribute" /> class.</summary>
/// <param name="url">Part of the URL associated with the method.</param>
public RouteAttribute(string url)
{
if (url == null)
{
throw new ArgumentNullException("url");
}
if (url.Length == 0)
{
throw new ArgumentOutOfRangeException("url");
}
Url = UrlParser.Parse((url[0] == '/' ? String.Empty : "/") + url);
}
private OperationInfo <Verb> CreateOperation(string methodName)
{
var method = typeof(TestController).GetMethod(methodName);
var arguments = method.GetParameters().Select(parameter => (ValueInfo) new ArgumentInfo(parameter, FromQueryStringAttribute.For(parameter), "test", "test"));
return(new OperationInfo <Verb>(
method,
(HttpUrl)UrlParser.Parse("/"),
(arguments.Any() ? "test" : null),
new Regex(".*"),
Verb.GET,
arguments.ToArray())
.WithSecurityDetailsFrom(method));
}
public static List <PlainTextSymbol> ParsePlainTextSymbols(string text, bool distinct = false)
{
var ptSyms = new List <PlainTextSymbol>();
List <IndexRange> idxRangs;
ptSyms.AddRange(_emojiParser.Parse(text, out idxRangs));
ptSyms.AddRange(_goodsParser.Parse(text, idxRangs, out idxRangs));
ptSyms.AddRange(_emailParser.Parse(text, idxRangs, out idxRangs));
ptSyms.AddRange(_urlParser.Parse(text, idxRangs, out idxRangs));
ptSyms.AddRange(_ipParser.Parse(text, idxRangs, out idxRangs));
ptSyms.AddRange(_arabParser.Parse(text, idxRangs, out idxRangs));
ptSyms.AddRange(_chNumberParser.Parse(text, idxRangs, out idxRangs));
ptSyms.AddRange(_englishParser.Parse(text, idxRangs, out idxRangs));
ptSyms.AddRange(_chineseParser.Parse(text, idxRangs, out idxRangs));
if (distinct)
{
for (int i = 0; i < text.Length; i++)
{
string ptext = text.Substring(i, 1).Trim();
if (ptext.Length == 1)
{
ptSyms.Add(new PlainTextSymbol(ptext, i, null));
}
}
}
ptSyms.Sort((l, r) =>
{
int diffVal = l.StartIndex.CompareTo(r.StartIndex);
if (diffVal == 0)
{
diffVal = l.Length.CompareTo(r.Length);
}
return(diffVal);
});
if (distinct)
{
for (int j = 1; j < ptSyms.Count; j++)
{
var pts1 = ptSyms[j - 1];
var pts2 = ptSyms[j];
if (pts1.StartIndex == pts2.StartIndex && pts1.Length == pts2.Length)
{
ptSyms.RemoveAt(j);
j--;
}
}
}
return(ptSyms);
}
void GoHome(bool needCheckEtag = false)
{
if (string.IsNullOrEmpty(Native?.Url))
{
return;
}
var naturl = UrlParser.Parse(Native.Url);
if (naturl.AbsoluteUrl == homeUrl)
{
return;
}
WebViewer.Uri = homeUrl;
LoadUrl(needCheckEtag: needCheckEtag);
}
private async Task HandleRequest(IOwinContext context)
{
var headers = new HeaderCollection();
context.Request.Headers.ForEach(header => headers[header.Key] = new Header(header.Key, header.Value));
var requestInfo = new RequestInfo(
Verb.Parse(context.Request.Method),
(HttpUrl)UrlParser.Parse(context.Request.Uri.AbsoluteUri.TrimEnd('/')),
context.Request.Body,
new OwinPrincipal(context.Authentication.User),
headers);
System.Runtime.Remoting.Messaging.CallContext.HostContext = requestInfo;
ResponseInfo response;
try
{
response = await _requestHandler.HandleRequestAsync(requestInfo);
}
finally
{
System.Runtime.Remoting.Messaging.CallContext.HostContext = null;
}
if ((IsResponseNoMatchingRouteFoundException(response)) && (Next != null))
{
await Next.Invoke(context);
return;
}
context.Response.StatusCode = (int)response.Status;
foreach (var header in response.Headers)
{
switch (header.Name)
{
case Header.ContentLength:
context.Response.ContentLength = response.Body.Length;
break;
default:
context.Response.Headers.Add(header.Name, header.Values.Select(headerValue => headerValue.ToString()).ToArray());
break;
}
}
response.Body.CopyTo(context.Response.Body);
}
public void Setup()
{
HttpUrl requestUrl = (HttpUrl)UrlParser.Parse("/test");
var classMapping = new Mock <IClassMapping>(MockBehavior.Strict);
classMapping.SetupGet(instance => instance.Uri).Returns(EntityConverter.Hydra.AddFragment("ApiDocumentation"));
var mapping = new Mock <IEntityMapping>(MockBehavior.Strict);
mapping.SetupGet(instance => instance.Classes).Returns(new[] { classMapping.Object });
var mappings = new Mock <IMappingsRepository>(MockBehavior.Strict);
mappings.Setup(instance => instance.MappingFor(typeof(IApiDocumentation))).Returns(mapping.Object);
var classEntity = new Mock <IClass>(MockBehavior.Strict);
var baseUriSelector = new Mock <IBaseUriSelectionPolicy>(MockBehavior.Strict);
baseUriSelector.Setup(instance => instance.SelectBaseUri(It.IsAny <EntityId>())).Returns(new Uri("http://temp.uri/"));
var context = new Mock <IEntityContext>(MockBehavior.Strict);
context.SetupGet(instance => instance.BaseUriSelector).Returns(baseUriSelector.Object);
context.SetupGet(instance => instance.Mappings).Returns(mappings.Object);
context.Setup(instance => instance.Create <IClass>(It.IsAny <EntityId>())).Returns(classEntity.Object);
_apiDocumentation = new Mock <IApiDocumentation>(MockBehavior.Strict);
_apiDocumentation.SetupGet(instance => instance.Context).Returns(context.Object);
_apiDocumentation.SetupGet(instance => instance.SupportedClasses).Returns(new List <IClass>());
_irrelevantApiDescriptionBuilder = new Mock <IApiDescriptionBuilder>(MockBehavior.Strict);
_apiDescriptionBuilder = new Mock <IApiDescriptionBuilder <TestController> >(MockBehavior.Strict);
_apiDescriptionBuilder.Setup(instance => instance.BuildDescription(_apiDocumentation.Object, null));
_apiDescriptionBuilderFactory = new Mock <IApiDescriptionBuilderFactory>(MockBehavior.Strict);
_apiDescriptionBuilderFactory.Setup(instance => instance.Create(It.Is <Type>(type => type == typeof(TestController)))).Returns(_apiDescriptionBuilder.Object);
string callUri;
var controllerDescription = new ControllerInfo <TestController>(
EntryPoint,
requestUrl.InsertSegments(0, ((HttpUrl)EntryPoint.Url).Segments),
typeof(TestController).GetMethod("Add").ToOperationInfo(requestUrl.InsertSegments(0, ((HttpUrl)EntryPoint.Url).Segments).ToString(), Verb.GET, out callUri));
_irrelevantControllerDescriptionBuilder = new Mock <IHttpControllerDescriptionBuilder>(MockBehavior.Strict);
_controllerDescriptionBuilder = new Mock <IHttpControllerDescriptionBuilder <TestController> >(MockBehavior.Strict);
_controllerDescriptionBuilder.As <IHttpControllerDescriptionBuilder>().Setup(instance => instance.BuildDescriptor()).Returns(controllerDescription);
var entryPointControllerDescription = new ControllerInfo <EntryPointDescriptionController>(null, UrlParser.Parse("/test"));
_entryPointControllerDescriptionBuilder = new Mock <IHttpControllerDescriptionBuilder <EntryPointDescriptionController> >(MockBehavior.Strict);
_entryPointControllerDescriptionBuilder.As <IHttpControllerDescriptionBuilder>().Setup(instance => instance.BuildDescriptor()).Returns(entryPointControllerDescription);
_descriptionBuilder = new ApiEntryPointDescriptionBuilder(
_apiDescriptionBuilderFactory.Object,
new[] { _controllerDescriptionBuilder.Object, _irrelevantControllerDescriptionBuilder.Object, _entryPointControllerDescriptionBuilder.Object });
_descriptionBuilder.EntryPoint = EntryPoint;
}
public void TestLocalSourceAndDestination()
{
UrlParser urlParser;
UrlParserResult parserResult;
urlParser = new UrlParser(@"c:\source", new Location(new Uri("http://site2.com/img/"), @"c:\inetpub\site2.com\img"));
parserResult = urlParser.Parse(new Uri("http://site2.com/img/400x400/test.jpg"));
Assert.True(parserResult.Source == @"c:\source\test.jpg");
Assert.True(parserResult.Destination == @"c:\inetpub\site2.com\img\400x400\test.jpg");
Assert.True(parserResult.ImageType == ImageType.Jpeg);
urlParser = new UrlParser(@"c:\source\", new Location(new Uri("http://site2.com/img"), @"c:\inetpub\site2.com\img\"));
parserResult = urlParser.Parse(new Uri("http://site2.com/img/path/400x400/test.jpeg"));
Assert.True(parserResult.Source == @"c:\source\path\test.jpeg");
Assert.True(parserResult.Destination == @"c:\inetpub\site2.com\img\path\400x400\test.jpeg");
Assert.True(parserResult.ImageType == ImageType.Jpeg);
urlParser = new UrlParser(@"C:\Source", new Location(new Uri("http://site2.com/Img"), @"c:\Inetpub\Site2.com\Img"));
parserResult = urlParser.Parse(new Uri("http://site2.com/Img/path/to/IMAGE/400x400/test.gif"));
Assert.True(parserResult.Source == @"C:\Source\path\to\IMAGE\test.gif");
Assert.True(parserResult.Destination == @"c:\Inetpub\Site2.com\Img\path\to\IMAGE\400x400\test.gif");
Assert.True(parserResult.ImageType == ImageType.Gif);
urlParser = new UrlParser("/var/source", new Location(new Uri("https://site2.com/img"), @"/var/www/site2.com/img"));
parserResult = urlParser.Parse(new Uri("https://site2.com/img/400x400/test.png"));
Assert.True(parserResult.Source == "/var/source/test.png");
Assert.True(parserResult.Destination == @"/var/www/site2.com/img/400x400/test.png");
Assert.True(parserResult.ImageType == ImageType.Png);
urlParser = new UrlParser("/var/source/", new Location(new Uri("https://site2.com/img/"), @"/var/www/site2.com/img/"));
parserResult = urlParser.Parse(new Uri("https://site2.com/img/path/400x400/test.jpg"));
Assert.True(parserResult.Source == "/var/source/path/test.jpg");
Assert.True(parserResult.Destination == @"/var/www/site2.com/img/path/400x400/test.jpg");
Assert.True(parserResult.ImageType == ImageType.Jpeg);
urlParser = new UrlParser("/var/SOURCE", new Location(new Uri("https://site2.com/Img"), @"/var/www/Site2.com/Img"));
parserResult = urlParser.Parse(new Uri("https://site2.com/Img/path/to/IMAGE/400x400/test.jpg"));
Assert.True(parserResult.Source == "/var/SOURCE/path/to/IMAGE/test.jpg");
Assert.True(parserResult.Destination == @"/var/www/Site2.com/Img/path/to/IMAGE/400x400/test.jpg");
Assert.True(parserResult.ImageType == ImageType.Jpeg);
Assert.Throws <UrlParserException>(() =>
{
parserResult = urlParser.Parse(new Uri("https://site2.com/incorrect/path/img/400x400/test.jpg"));
});
}
private void HandleRequest(HttpContext context)
{
var headers = new HeaderCollection();
context.Request.Headers.ForEach(headerName => ((IDictionary <string, string>)headers)[(string)headerName] = context.Request.Headers[(string)headerName]);
var requestInfo = new RequestInfo(
Verb.Parse(context.Request.HttpMethod),
(HttpUrl)UrlParser.Parse(context.Request.Url.AbsoluteUri.TrimEnd('/')),
context.Request.InputStream,
new HttpContextPrincipal(context.User),
headers);
context.Items["URSA.Http.RequestInfo"] = requestInfo;
ResponseInfo response;
try
{
response = _requestHandler.HandleRequest(requestInfo);
}
finally
{
context.Items.Remove("URSA.Http.RequestInfo");
}
context.Response.ContentEncoding = context.Response.HeaderEncoding = response.Encoding;
context.Response.StatusCode = (int)response.Status;
foreach (var header in response.Headers)
{
switch (header.Name)
{
case Header.ContentType:
context.Response.ContentType = header.Value;
break;
case Header.ContentLength:
break;
default:
context.Response.Headers.Add(header.Name, header.Value);
break;
}
}
response.Body.CopyTo(context.Response.OutputStream);
}
public void it_should_bind_response_from_header()
{
var expected = Guid.NewGuid();
var request = new RequestInfo(
Verb.GET,
(HttpUrl)UrlParser.Parse("http://temp.uri/"),
new MemoryStream(),
new BasicClaimBasedIdentity(),
new Header("Content-Type", "text/plain"),
new Header("Location", "http://temp.uri/" + expected));
_converterProvider.Setup(instance => instance.FindBestInputConverter(typeof(Guid), request, false)).Returns((IConverter)null);
var result = _resultBinder.BindResults <Guid>(request);
result.Should().HaveCount(1);
result[0].Should().Be(expected);
}
static void Main(string[] args)
{
IEnumerable <string> uris = new List <string>
{
"https://github.com/AnzhelikaKravchuk?tab=repositories",
"https://git_hub..com/AnzhelikaKr.avchuk.?tab=.repositories",
"https://github.com/AnzhelikaKravchuk/2017-2018.MMF.BSU",
"https://habrahabr.ru/company/it-grad/blog/341486/",
"http://habrahabr.ru/company///it-grad/?blog/341486/"
};
IValidator <string> validator = new UrlValidator();
IParser <UrlAddress> parser = new UrlParser(validator, uris);
IEnumerable <UrlAddress> urlAddresses = parser.Parse();
IStorage <UrlAddress> storage = new XmlStorage(urlAddresses);
storage.Save();
Console.ReadLine();
}
public void Setup()
{
(_converter = new Mock <IConverter>(MockBehavior.Strict)).Setup(instance => instance.CanConvertFrom <string>(It.IsAny <IResponseInfo>()))
.Returns <IResponseInfo>(response => CompatibilityLevel.ExactMatch);
(_converterProvider = new Mock <IConverterProvider>(MockBehavior.Strict)).Setup(instance => instance.FindBestOutputConverter <string>(It.IsAny <IResponseInfo>()))
.Returns <IResponseInfo>(response => _converter.Object);
_converter.Setup(instance => instance.ConvertFrom(Body, It.IsAny <ObjectResponseInfo <string> >()))
.Callback <string, IResponseInfo>((body, response) =>
{
using (var writer = new StreamWriter(response.Body))
{
writer.Write(body);
writer.Flush();
}
});
_request = new RequestInfo(Verb.GET, (HttpUrl)UrlParser.Parse("http://temp.org/"), new MemoryStream(), new BasicClaimBasedIdentity());
_response = new ObjectResponseInfo <string>(_request, Body, _converterProvider.Object);
}
public void it_should_bind_response_object()
{
var expected = new Person()
{
Key = 1, FirstName = "test", LastName = "test", Roles = new[] { "test" }
};
var body = new MemoryStream();
new JsonSerializer().Serialize(new StreamWriter(body), expected);
body.Seek(0, SeekOrigin.Begin);
var request = new RequestInfo(Verb.GET, (HttpUrl)UrlParser.Parse("http://temp.uri/"), body, new BasicClaimBasedIdentity(), new Header("Content-Type", "application/json"));
_converterProvider.Setup(instance => instance.FindBestInputConverter(typeof(Person), request, false)).Returns(_converter.Object);
_converter.Setup(instance => instance.ConvertTo(typeof(Person), request)).Returns(expected);
var result = _resultBinder.BindResults <Person>(request);
result.Should().HaveCount(1);
result[0].Should().Be(expected);
}
public void Setup()
{
var method = typeof(TestController).GetMethod("Add");
_controller = new TestController();
_operation = new OperationInfo <Verb>(
method,
(HttpUrl)UrlParser.Parse("/add"),
"/api/test/add?{?operandA}&{?operandB}",
new Regex(".*"),
Verb.GET,
method.GetParameters().Select(parameter => (ValueInfo) new ArgumentInfo(parameter, FromQueryStringAttribute.For(parameter), "add?{?" + parameter.Name + "}", parameter.Name)).ToArray());
var controllerInfo = new ControllerInfo <TestController>(null, (HttpUrl)UrlParser.Parse("api/test"), _operation);
Mock <IHttpControllerDescriptionBuilder> controllerDescriptionBuilder = new Mock <IHttpControllerDescriptionBuilder>(MockBehavior.Strict);
controllerDescriptionBuilder.Setup(instance => instance.BuildDescriptor()).Returns(controllerInfo);
Mock <IControllerActivator> controllerActivator = new Mock <IControllerActivator>(MockBehavior.Strict);
controllerActivator.Setup(instance => instance.CreateInstance(It.IsAny <Type>(), It.IsAny <IDictionary <string, object> >())).Returns(_controller);
_delegateMapper = new DelegateMapper(new[] { controllerDescriptionBuilder.Object }, controllerActivator.Object);
}
public override void EstablishContext()
{
var parser = new UrlParser();
parts = parser.Parse("hello/{name}").ToArray();
}
public override void EstablishContext()
{
UrlParser parser = new UrlParser();
parts = parser.Parse("hello/index").ToArray();
}