public void FailureSamplesTest(string template, string[] results, TestSet.TestCase testCase) { var uriTemplate = new UriTemplate(template); foreach (var variable in testCase.TestSet.Variables) { uriTemplate.SetParameter(variable.Key, variable.Value); } string result = null; ArgumentException aex = null; try { result = uriTemplate.Resolve(); } catch (ArgumentException ex) { aex = ex; } if (results[0] == "False") { Assert.NotNull(aex); } else { Assert.Contains(results, x => x == result); } }
/// <summary> /// Parameterize the link to construct a URI. /// </summary> /// <param name="parameters">Parameters to substitute into the template, if any.</param> /// <returns>A constructed URI.</returns> /// <remarks>This method ensures that templates containing parameters cannot be accidentally /// used as URIs.</remarks> public string GetUri(IDictionary <string, object> parameters = null) { if (Template == null) { throw new InvalidOperationException("Attempted to process an empty URI template."); } var template = new UriTemplate(Template); if (parameters != null) { var missing = parameters.Select(p => p.Key).Except(template.GetParameterNames()); if (missing.Any()) { throw new ArgumentException($"The URI template `{Template}` does not contain parameter: `{string.Join("`, `", missing)}`."); } foreach (var parameter in parameters) { var value = parameter.Value is DateTime time ? time.ToString("O") : parameter.Value; template.SetParameter(parameter.Key, value); } } return(template.Resolve()); }
//2.0 operations don't have a path so.... private OperationPath20 NormalizeOperationPath(NormalizationApiOperation op) { var pathBuilder = new StringBuilder('/'); var basePath = NormalizeBasePath(op.BasePath); if (!string.IsNullOrWhiteSpace(basePath)) { pathBuilder.Append(basePath); } if (!string.IsNullOrWhiteSpace(op.Path)) { var opPath = op.Path; if (opPath.StartsWith("/", StringComparison.InvariantCultureIgnoreCase)) { opPath = opPath.Length == 1 ? string.Empty : opPath.Substring(1); } pathBuilder.Append(opPath); } var path = pathBuilder.ToString(); var versionParam = op.Parameters.FirstOrDefault(x => x.Name.IndexOf(Constants.ParameterName_Version, StringComparison.InvariantCultureIgnoreCase) >= 0); if (versionParam != null) { var template = new UriTemplate(path, true); template.SetParameter(versionParam.Name, op.ApiVersion); path = template.Resolve(); op.Parameters.Remove(versionParam); } return(new OperationPath20(path)); }
static string ResolveLink(ILinked entity, string link, IDictionary <string, object> parameters = null) { Link linkItem; if (!entity.Links.TryGetValue(link, out linkItem)) { throw new NotSupportedException("The requested link isn't available."); } var expression = linkItem.GetUri(); var template = new UriTemplate(expression); if (parameters != null) { var missing = parameters.Select(p => p.Key).Except(template.GetParameterNames()).ToArray(); if (missing.Any()) { throw new ArgumentException("The URI template '" + expression + "' does not contain parameter: " + string.Join(",", missing)); } foreach (var parameter in parameters) { var value = parameter.Value is DateTime ? ((DateTime)parameter.Value).ToString("O") : parameter.Value; template.SetParameter(parameter.Key, value); } } return(template.Resolve()); }
/// <summary> /// Binds the <see cref="UriTemplate" /> /// to the specified <c>params</c> by position. /// </summary> /// <param name="template">The template.</param> /// <param name="baseUri">The base URI.</param> /// <param name="values">The values.</param> /// <returns></returns> /// <exception cref="ArgumentNullException">template - The expected URI template is not here.</exception> /// <exception cref="FormatException"></exception> public static Uri BindByPosition(this UriTemplate template, Uri baseUri, params string[] values) { if (template == null) { throw new ArgumentNullException("template", "The expected URI template is not here."); } var keys = template.GetParameterNames(); for (int i = 0; i < keys.Count(); i++) { template.AddParameter(keys.ElementAt(i), values.ElementAtOrDefault(i)); } var resolved = template.Resolve(); if (baseUri != null) { return(new UriBuilder(baseUri).WithPath(resolved).Uri); } else { var isAbsolute = Uri.IsWellFormedUriString(resolved, UriKind.Absolute); var isRelative = Uri.IsWellFormedUriString(resolved, UriKind.Relative); if (!isAbsolute && !isRelative) { throw new FormatException($"The resolved URI template, {resolved}, is in an unknown format."); } return(isAbsolute ? new Uri(resolved, UriKind.Absolute) : new Uri(resolved, UriKind.Relative)); } }
public async Task <ApiId[]> GetManagedApis() { // https://management.azure.com/subscriptions/83e6374a-dfa5-428b-82ef-eab6c6bdd383/providers/Microsoft.Web/locations/brazilsouth/managedApis?api-version=2015-08-01-preview" const string template = "/subscriptions/{subscriptionId}/providers/Microsoft.Web/locations/{location}/managedApis/?api-version={apiVersion}"; var parameters = new Dictionary <string, string>(); parameters["subscriptionId"] = subscriptionId; parameters["location"] = location; parameters["apiVersion"] = ApiVersion; var uriTemplate = new UriTemplate(template, true); // Add parameters one by one to avoid mismatch parameters count errors. foreach (var key in parameters) { uriTemplate = uriTemplate.AddParameter(key.Key, key.Value); } var resolvedUri = uriTemplate.Resolve(); // Build complete URI. Uri url = new Uri(_managementEndpointUri, resolvedUri); var json = await SendAsync <JObject>(HttpMethod.Get, url); var apis = json["value"].ToObject <ArmEnvelope <JToken>[]>(); return(Array.ConvertAll(apis, x => new ApiId { Id = x.Id, Name = x.Name })); }
public Uri GenerateRequestUrl(Type type, string query = "*", int start = 0, int limit = 10) { string metaTypeName = GetMetaTypeName(type); var ftsQueryRequest = new FTSQueryRequest { Statements = new List <Statement> { new Statement { Query = query } }, Start = start, Limit = limit }; var ftsQueryRequestString = JsonConvert.SerializeObject(ftsQueryRequest); var template = new UriTemplate(BaseAddress + "/" + SearchTemplate); template.SetParameter("metaType", metaTypeName); template.SetParameter("query", ftsQueryRequestString); return(new Uri(template.Resolve())); }
private static async Task <IList <JToken> > SimpleSearchAsyncCore(HttpClient httpClient, string apiDomain, string serviceType, string realm, string rawSearchExpression) { IList <JToken> pages = new List <JToken>(); httpClient.DefaultRequestHeaders.Remove("Accept"); httpClient.DefaultRequestHeaders.Add("Accept", "application/hal+json"); /// Check, whether simple search is supported: var registryServiceVersion = "0"; string defaultSimpleSearchUriTemplate = $"https://{apiDomain}/apis/{serviceType};version=0;realm={realm}/searches/simple?search={{search}}{{&offset,limit,sort}}"; string simpleSearchUriTemplate = await PlatformTools.PlatformToolsAsync.FindInRegistry(httpClient, apiDomain, serviceType, registryServiceVersion, "search:simple-search", defaultSimpleSearchUriTemplate, realm); UriTemplate simpleSearchUrlTemplate = new UriTemplate(simpleSearchUriTemplate); simpleSearchUrlTemplate.SetParameter("search", rawSearchExpression); Uri simpleSearchResultPageUrl = new Uri(simpleSearchUrlTemplate.Resolve()); httpClient.DefaultRequestHeaders.Remove("Accept"); httpClient.DefaultRequestHeaders.Add("Accept", "application/hal+json"); // Page through the result: do { using (HttpResponseMessage simpleSearchResultPage = await httpClient.GetAsync(simpleSearchResultPageUrl)) { HttpStatusCode simpleSearchStatus = simpleSearchResultPage.StatusCode; if (HttpStatusCode.OK == simpleSearchStatus) { string rawSearchResult = await simpleSearchResultPage.Content.ReadAsStringAsync(); JObject searchResult = JObject.Parse(rawSearchResult); var embeddedResults = searchResult.Properties().FirstOrDefault(it => "_embedded".Equals(it.Name)); if (null != embeddedResults) { pages.Add(embeddedResults); } else { Console.WriteLine($"No results found for search expression '{rawSearchExpression}'."); return(pages); } // If we have more results, follow the next link and get the next page: dynamic linkToNextPage = searchResult.SelectToken("_links.next"); simpleSearchResultPageUrl = null != linkToNextPage ? new Uri(linkToNextPage.href.ToString()) : null; } else { Console.WriteLine($"Search failed for search expression '{rawSearchExpression}'."); return(pages); } } }while (null != simpleSearchResultPageUrl); return(pages); }
// TODO: Use continuation token. public virtual Uri CreateRequestUri(string template, NameValueCollection parameters = null, Query query = null, ContinuationToken continuationToken = null) { var uriTemplate = new UriTemplate(template, true); if (parameters != null) { // Add parameters one by one to avoid mismatch parameters count errors. foreach (var key in parameters.AllKeys) { uriTemplate = uriTemplate.AddParameter(key, parameters[key]); } } var resolvedUri = uriTemplate.Resolve(); // Build complete URI. Uri completeUri = new Uri(RuntimeEndpoint, resolvedUri); var uriBuilder = new UriBuilder(completeUri.AbsoluteUri) { Query = query.Coalesce().QueryString }; return(uriBuilder.Uri); }
private static Uri ResolveDocumentationUri(ILinkObject link, string rel) { var template = new UriTemplate(link.Href.ToString()); template.SetParameter("rel", rel); return(new Uri(template.Resolve())); }
public void QueryParamsWithoutValuesTest() { var template = new UriTemplate("http://example.com/foo{?q1,q2}"); var actual = template.Resolve(new Dictionary <string, object>()); Assert.AreEqual("http://example.com/foo", actual); }
public void FactMethodName() { UriTemplate template = new UriTemplate("https://api.github.com/search/code?q={query}{&page,per_page,sort,order}"); template.SetParameter("query", "1234"); template.SetParameter("per_page", "19"); var result = template.Resolve(); }
public static void SpecTest(TestCase testCase) { Assume.That(!testCase.IsInvalid); var uriTemplate = new UriTemplate(testCase.Template); var uri = uriTemplate.Resolve(testCase.Suite.Variables); Assert.Contains(uri, testCase.Expecteds); }
public void ShouldHandleEncodingAParametersThatIsAUriWithAUriAsAParameter() { var template = new UriTemplate("http://example.org/go{?uri}"); template.SetParameter("uri", "http://example.org/?uri=http%3A%2F%2Fexample.org%2F"); var uriString = template.Resolve(); Assert.Equal("http://example.org/go?uri=http%3A%2F%2Fexample.org%2F%3Furi%3Dhttp%253A%252F%252Fexample.org%252F", uriString); }
public void ShouldAllowUriTemplateWithQueryParamsButNoValues() { var template = new UriTemplate("http://example.org/foo{?bar,baz}"); //template.SetParameter("bar", "yo"); //template.SetParameter("blar", "yuck"); var uriString = template.Resolve(); Assert.Equal("http://example.org/foo", uriString); }
public void ShouldAllowUriTemplateWithPathSegmentParameter() { var template = new UriTemplate("http://example.org/foo/{bar}/baz"); template.SetParameter("bar", "yo"); var uriString = template.Resolve(); Assert.Equal("http://example.org/foo/yo/baz", uriString); }
public void LabelExpansionWithDotPrefixAndEmptyKeys() { var template = new UriTemplate("X{.empty_keys}"); template.SetParameter("empty_keys", new Dictionary <string, string>()); var uriString = template.Resolve(); Assert.Equal("X", uriString); }
public void ShouldHandleUriEncoding() { var template = new UriTemplate("http://example.org/sparql{?query}"); template.SetParameter("query", "PREFIX dc: <http://purl.org/dc/elements/1.1/> SELECT ?book ?who WHERE { ?book dc:creator ?who }"); var uriString = template.Resolve(); Assert.Equal("http://example.org/sparql?query=PREFIX%20dc%3A%20%3Chttp%3A%2F%2Fpurl.org%2Fdc%2Felements%2F1.1%2F%3E%20SELECT%20%3Fbook%20%3Fwho%20WHERE%20%7B%20%3Fbook%20dc%3Acreator%20%3Fwho%20%7D", uriString); }
public void IntValueIsNotSupported_UseStringInstead() { var template = new UriTemplate("http://example.com/{guid}/{int}"); var ex = Assert.Throws <UriTemplateException>(() => template.Resolve(new Dictionary <string, object> { { "int", 42 } })); Assert.That(ex.Message, Does.Contain("Invalid value type of variable \"System.Int32\". Expected: string or IEnumerable<string> or IDictionary<string, string>.")); }
public void ShouldAllowUriTemplateWithQueryParamsWithOneValue() { var template = new UriTemplate("http://example.org/foo{?bar,baz}"); template.SetParameter("baz", "yo"); var uriString = template.Resolve(); Assert.Equal("http://example.org/foo?baz=yo", uriString); }
internal Uri ResolveTemplate(HalLink link, Dictionary <string, object> parameters) { var template = new UriTemplate(link.Href); foreach (var key in parameters.Keys) { template.SetParameter(key, parameters[key]); } return(new Uri(template.Resolve(), UriKind.Relative)); }
public void ResolveOptionalAndRequiredQueryParameters() { UriTemplate template = new UriTemplate("https://api.github.com/search/code?q={query}{&page,per_page,sort,order}"); template.SetParameter("query", "1234"); template.SetParameter("per_page", "19"); var result = template.Resolve(); Assert.Equal("https://api.github.com/search/code?q=1234&per_page=19", result); }
public void ReservedCharacterExpansion() { UriTemplate template = new UriTemplate("https://foo.com/{?format}"); template.SetParameter("format", "application/vnd.foo+xml"); var result = template.Resolve(); Assert.Equal("https://foo.com/?format=application%2Fvnd.foo%2Bxml", result); }
public void QueryParamsWithOneValueTest() { var template = new UriTemplate("http://example.com/foo{?q1,q2}"); var actual = template.Resolve(new Dictionary <string, object>() { { "q1", "abc" } }); Assert.AreEqual("http://example.com/foo?q1=abc", actual); }
public void PathSegmentTest() { var template = new UriTemplate("http://example.com/{path}"); var actual = template.Resolve(new Dictionary <string, object> { { "path", "foo" } }); Assert.AreEqual("http://example.com/foo", actual); }
public void Query_param_with_list_array() { var template = new UriTemplate("/foo/{foo}/baz{?haz}"); template.SetParameter("foo", "1234"); template.SetParameter("haz", new[] { "foo", "bar" }); var uri = template.Resolve(); Assert.Equal("/foo/1234/baz?haz=foo,bar", uri); }
public void Query_param_with_empty_array() { UriTemplate template = new UriTemplate("/foo/{foo}/baz{?haz*}"); template.SetParameter("foo", "1234"); template.SetParameter("haz", new string[] {}); string uri = template.Resolve(); Assert.Equal("/foo/1234/baz", uri); }
public void ShouldSupportUnicodeCharacters() { UriTemplate template = new UriTemplate("/lookup{?Stra%C3%9Fe}"); template.SetParameter("Stra%C3%9Fe", "Grüner Weg"); var result = template.Resolve(); Assert.Equal("/lookup?Stra%C3%9Fe=Gr%C3%BCner%20Weg", result); }
public void QueryParamsWithMultipleValuesTest() { var template = new UriTemplate("http://example.com/foo{?q1,q2}"); var actual = template.Resolve(new Dictionary <string, object> { { "q1", new string[] { "abc", "def", "ghi" } }, { "q2", "10" } }); Assert.AreEqual("http://example.com/foo?q1=abc,def,ghi&q2=10", actual); }
public void MultiplePathSegmentTest() { var template = new UriTemplate("http://example.com/{path1}/{path2}"); var actual = template.Resolve(new Dictionary <string, object> { { "path1", "foo" }, { "path2", "bar" } }); Assert.AreEqual("http://example.com/foo/bar", actual); }