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(); }