public void ToQueryString()
{
var Collection = new Dictionary<string, string>();
Collection.Add("A", "1");
Collection.Add("B", "2");
Assert.Equal("?A=1&B=2", Collection.ToQueryString());
}
public async Task<byte[]> GetEpisodePictureASync(int episodeId, int width, int height)
{
var postData = new Dictionary<string, string>();
postData.Add("id", episodeId);
if (width != 0)
postData.Add("width", width);
if (height != 0)
postData.Add("height", height);
postData.Add("picked", "show");
var options = "?" + postData.ToQueryString();
var response = await Get(EpisodeUrl + options);
if (response.StatusCode == HttpStatusCode.NotFound)
return null;
var stream = await response.Content.ReadAsBufferAsync();
var byteArray = stream.ToArray();
return byteArray.Length == 0 ? null : byteArray;
}
public async Task<IEnumerable<Models.Products.ProductSuggestItemOutputModel>> GetSuggestSimilarDocumentsAsync(int id, string offerType = null, string domainLanguage = "fr", int take = 3)
{
using (var dclient = this.CreateClient())
{
var client = dclient.Client;
var parameters = new Dictionary<string, string>();
var dico = new Dictionary<string, string>(){
{ "domainLanguage", domainLanguage },
{ "take", take.ToString() },
{ "offerType", offerType }
};
var queryString = dico.ToQueryString();
var url = "api/v2/products/{id}/suggests/similar".Replace("{id}", id.ToString());
if (!string.IsNullOrEmpty(queryString))
url = url + "?" + queryString;
var response = await client.GetAsync(this.GetUri(url)).ConfigureAwait(false);
await this.HandleResponseAsync(response).ConfigureAwait(false);
if (response.IsSuccessStatusCode)
return (await this.GetObjectAsync<IEnumerable<Models.Products.ProductSuggestItemOutputModel>>(response.Content).ConfigureAwait(false));
return Enumerable.Empty<Models.Products.ProductSuggestItemOutputModel>();
}
}
public async Task<RootAuth> AuthASync(string login, string password)
{
var postData = new Dictionary<string, string>();
postData.Add("login", login);
var md5Password = MD5CryptoServiceProvider.GetMd5String(password);
postData.Add("password", md5Password);
var options = "?" + postData.ToQueryString();
RootAuth response;
try
{
response = await Post<RootAuth>(AuthUrl + options, null);
ValidateResponse(response);
}
catch (ConnectionException ex)
{
if (!string.IsNullOrEmpty(ex.ResponseContent))
ValidateResponse(ex.ResponseContent);
throw;
}
return response;
}
public override string ToString()
{
Dictionary<string, string> parameters = new Dictionary<string, string>();
if (Lat.HasValue && Lon.HasValue)
{
parameters.Add("cp", string.Format("{0}~{1}", Lat.Value, Lon.Value));
}
if (Zoom.HasValue)
{
parameters.Add("lvl", Zoom.Value.ToString());
}
if (!String.IsNullOrWhiteSpace(Query))
{
parameters.Add("q", Query);
}
if (!String.IsNullOrWhiteSpace(Where))
{
parameters.Add("where", Where);
}
if (TrafficOn.HasValue)
{
parameters.Add("trfc", TrafficOn.Value ? "1" : "0");
}
if (RoadView.HasValue)
{
parameters.Add("sty", RoadView.Value ? "r" : "a");
}
return parameters.ToQueryString("bingmaps://dreamteam-mobile.com/");
}
public async Task <string> GetStringAsync(string path, Dictionary <string, object> parameters)
{
var client = await GetHttpClientAsync();
var result = await client.GetStringAsync($"{path}?{parameters?.ToQueryString()}", CheckErrorAsync);
return(result);
}
public void ToQueryStringOneValue()
{
var dict = new Dictionary<string, string>();
dict["foo"] = "bar";
Assert.AreEqual("?foo=bar",
dict.ToQueryString());
}
public async Task <QueryResult <T> > GetQueryResultAsync <T>(string segments, Dictionary <string, object> parameters) where T : class
{
var client = await GetHttpClientAsync();
var result = await client.GetAsync <QueryResult <T> >($"{segments}?{parameters?.ToQueryString()}", CheckErrorAsync);
return(result);
}
public void ToQueryStringUnsafeValues()
{
var dict = new Dictionary<string, string>();
dict["foo"] = "#?&%=";
Assert.AreEqual("?foo=%23%3F%26%25%3D",
dict.ToQueryString());
}
public async Task <T> PutAsync <T>(string segments, Dictionary <string, object> parameters, object model)
{
var client = await GetHttpClientAsync();
var result = await client.PutAsync <T>($"{segments}?{parameters?.ToQueryString()}", model, CheckErrorAsync);
return(result);
}
public async Task <ExecuteResult> StartPlanAsyncWithParametersAsQueryString(Plan plan, long planInstanceId, bool dryRun = false, Dictionary <string, string> dynamicParameters = null)
{
string planString = plan.ToYaml();
planString = CryptoHelpers.Encode(planString);
string requestUri = $"{_rootPath}/{planInstanceId}/?dryRun={dryRun}{dynamicParameters?.ToQueryString( asPartialQueryString: true )}";
return(await PostAsync <string, ExecuteResult>(planString, requestUri));
}
public void ToQueryStringTwoValues()
{
var dict = new Dictionary<string, string>();
dict["foo"] = "bar";
dict["ba"] = "zinga";
Assert.AreEqual("?foo=bar&ba=zinga",
dict.ToQueryString());
}
public void should_convert_string_dictionary_to_query_string()
{
var values = new Dictionary<string, string> {
{"key1", "value1"},
{"key2", "value2"}
};
values.ToQueryString().Should().Be("key1=value1&key2=value2");
}
/// <summary>
/// transform a dictionary into the query string that is translated in byte array then
/// </summary>
/// <param name="items"></param>
/// <returns></returns>
public static byte[] PostBytes(Dictionary<string, string> items)
{
if (items == null || !items.Any())
return null;
var bytes = Encoding.UTF8.GetBytes(items.ToQueryString());
return bytes.Any() ? bytes : null;
}
public static String getSignature(Dictionary <String, String> param, String secret)
{
string pStr = param.ToQueryString(Encoding.UTF8);
byte[] pByte = Encoding.UTF8.GetBytes(pStr + secret);
MD5 md5 = new MD5CryptoServiceProvider();
byte[] result = md5.ComputeHash(pByte);
return(Convert.ToBase64String(result));
}
public async Task <long> StartPlanAsync(string planName, bool dryRun = false, string requestNumber = null,
Dictionary <string, string> dynamicParameters = null, string nodeRootUrl = null)
{
requestNumber = requestNumber?.ToUrlEncodedOrNull("&requestNumber");
nodeRootUrl = nodeRootUrl?.ToUrlEncodedOrNull("&nodeRootUrl");
string qs = $"?dryRun={dryRun}{requestNumber}{nodeRootUrl}{dynamicParameters?.ToQueryString( asPartialQueryString: true )}";
string requestUri = $"{_rootPath}/{planName}/start/{qs}";
return(await GetAsync <long>(requestUri));
}
public Task <EventsResponse> GetEventsAsync(DateTime startDate, DateTime endDate, CancellationToken ct)
{
this.SetHeaders();
this.ValidateDates(ref startDate, ref endDate);
var dic = new Dictionary <string, object>();
dic.Add("startDate", this.FormatDate(startDate));
dic.Add("endDate", this.FormatDate(endDate));
return(this.GetAsync <EventsResponse>("/v2/users/self/events" + dic.ToQueryString(), ct));
}
/// <summary>
/// Helper to build requestUri for each server endpoint and include optional querystring parameters
/// </summary>
public static string GetRequestUri(Uri baseUri, string endPoint, Dictionary <string, string> parameters = null)
{
// Build QueryString if parameters are available
var queryString = parameters != null?parameters.ToQueryString() : string.Empty;
// Return Uri formatted to include base, endpoint and optional querystring
var requestUri = string.Format("{0}{1}{2}", baseUri, endPoint, queryString);
return(requestUri);
}
public void should_override_default_delimiters_when_writing()
{
var values = new Dictionary<string, string> {
{"key1", "value1"},
{"key2", "value2"}
};
values.ToQueryString(paramDelimiter: ' ', valueDelimiter: '@')
.Should().Be("key1@value1 key2@value2");
}
public void TestToQueryString()
{
Dictionary <string, string> testData = new Dictionary <string, string>();
string expectedResult = "";
Assert.AreEqual(expectedResult, testData.ToQueryString());
testData.Add("param", "Value");
expectedResult = "param=Value";
Assert.AreEqual(expectedResult, testData.ToQueryString());
testData.Add("2", "v2");
expectedResult = "2=v2¶m=Value";
Assert.AreEqual(expectedResult, testData.ToQueryString());
}
public void should_encode_values()
{
var values = new Dictionary <string, string> {
{ "name", "John Smith" },
{ "email", "*****@*****.**" }
};
values.ToQueryString(encode: true)
.Should().Be("name=John+Smith&email=email%40website.com");
}
public void should_override_default_delimiters_when_writing()
{
var values = new Dictionary <string, string> {
{ "key1", "value1" },
{ "key2", "value2" }
};
values.ToQueryString(paramDelimiter: ' ', valueDelimiter: '@')
.Should().Be("key1@value1 key2@value2");
}
public void PairsWithNullValuesAreIgnored()
{
var data = new Dictionary <string, object>()
{
["first"] = "1",
["second"] = null
};
Assert.AreEqual("first=1", data.ToQueryString());
}
public void should_encode_values()
{
var values = new Dictionary<string, string> {
{"name", "John Smith"},
{"email", "*****@*****.**"}
};
values.ToQueryString(encode: true)
.Should().Be("name=John+Smith&email=email%40website.com");
}
public void MultipleValueConcatenation()
{
var data = new Dictionary <string, object>()
{
["first"] = "1",
["second"] = 2
};
Assert.AreEqual("first=1&second=2", data.ToQueryString());
}
internal static async Task<T> Get<T>(string path, Dictionary<string, object> query = null,
CancellationToken cancellationToken = default)
{
var queryString = string.Empty;
if (query != null)
{
queryString = query.ToQueryString();
}
try
{
var response = await HttpClient.GetAsync(path + queryString, cancellationToken).ConfigureAwait(false);
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
Error error = null;
try
{
error = JsonSerializer.Deserialize<Error>(json);
}
catch
{
// ignore
}
if (!string.IsNullOrEmpty(error?.ErrorMessage))
{
throw new BitFlyerApiException(path, error.ErrorMessage, error);
}
throw new BitFlyerApiException(path,
$"Error has occurred. Response StatusCode:{response.StatusCode} ReasonPhrase:{response.ReasonPhrase}.");
}
return JsonSerializer.Deserialize<T>(json);
}
catch (WebException ex)
{
switch (ex.Status)
{
case WebExceptionStatus.RequestCanceled:
case WebExceptionStatus.Timeout:
throw new BitFlyerApiException(path, "Request Timeout");
default:
throw;
}
}
catch (TaskCanceledException)
{
throw new BitFlyerApiException(path, "Request Timeout");
}
catch (OperationCanceledException)
{
throw new BitFlyerApiException(path, "Request Timeout");
}
}
public static string GetObjectUrl(string storageUrl, string containerId, string objectId, Dictionary<string, string> queryParams = null)
{
var url = storageUrl + "/" + containerId.Encode() + "/" + objectId.Encode();
if (queryParams != null)
{
url += queryParams.ToQueryString();
}
return url;
}
public void OneItemDictionaryTest()
{
var dict = new Dictionary <string, string>()
{
{ "bob", "1" }
};
var value = dict.ToQueryString();
Assert.AreEqual("?bob=1", value);
}
/// <summary>
/// transform a dictionary into the query string that is translated in byte array then
/// </summary>
/// <param name="items"></param>
/// <returns></returns>
public static byte[] PostBytes(Dictionary <string, string> items)
{
if (items == null || !items.Any())
{
return(null);
}
var bytes = Encoding.UTF8.GetBytes(items.ToQueryString());
return(bytes.Any() ? bytes : null);
}
public static string GetAccountUrl(string storageUrl, Dictionary <string, string> queryParams = null)
{
var url = storageUrl;
if (queryParams != null)
{
url += queryParams.ToQueryString();
}
return(url);
}
public static void InitContent(dynamic viewBag, string nameSpace, string page, Dictionary<string, string> dimensions)
{
var repository = new ContentRepository(
new Uri(System.Configuration.ConfigurationManager.AppSettings["NeuCMSServiceURL"])
);
var content = repository.GetViewContents(nameSpace,page, dimensions.ToQueryString()).ToList();
dynamic neuCMSContent = new NeuCMSContent(content);
viewBag.NeuContent = neuCMSContent;
}
public static string GetAccountUrl(string storageUrl, Dictionary<string, string> queryParams = null)
{
var url = storageUrl;
if (queryParams != null)
{
url += queryParams.ToQueryString();
}
return url;
}
public static string GetObjectUrl(string storageUrl, string containerId, string objectId, Dictionary <string, string> queryParams = null)
{
var url = storageUrl + "/" + containerId.Encode() + "/" + objectId.Encode();
if (queryParams != null)
{
url += queryParams.ToQueryString();
}
return(url);
}
/// <summary>
/// 远程批量获取语言包
/// </summary>
/// <param name="input">需要翻译的词条（携带~符号）</param>
/// <param name="apiurl">远程接口地址</param>
/// <param name="languages">要翻译的语种</param>
/// <returns></returns>
public static Dictionary <string, Dictionary <Language, string> > Get(this string[] input, string apiurl, params Language[] languages)
{
Dictionary <string, string> data = new Dictionary <string, string>()
{
{ "Content", string.Concat("[", string.Join(",", input.Select(t => $"\"{ HttpUtility.JavaScriptStringEncode(t) }\"")), "]") },
{ "Language", string.Join(",", languages) },
{ "Action", "TranslateData" }
};
string result = NetAgent.UploadData(apiurl, data.ToQueryString(), Encoding.UTF8);
return(JsonConvert.DeserializeObject <Dictionary <string, Dictionary <Language, string> > >(result));
}
public static void InitContent(dynamic viewBag, string nameSpace, string page, Dictionary <string, string> dimensions)
{
var repository = new ContentRepository(
new Uri(System.Configuration.ConfigurationManager.AppSettings["NeuCMSServiceURL"])
);
var content = repository.GetViewContents(nameSpace, page, dimensions.ToQueryString()).ToList();
dynamic neuCMSContent = new NeuCMSContent(content);
viewBag.NeuContent = neuCMSContent;
}
private async Task <string> SendRequest(HttpMethod method, string path,
Dictionary <string, object> query = null, object body = null)
{
var queryString = string.Empty;
if (query != null)
{
queryString = query.ToQueryString();
}
using (var message = new HttpRequestMessage(method, path + queryString))
{
byte[] bodyBytes = null;
if (body != null)
{
bodyBytes = JsonSerializer.Serialize(body);
message.Content = new ByteArrayContent(bodyBytes);
message.Content.Headers.ContentType = MediaType;
}
var timestamp = DateTimeOffset.UtcNow.ToUnixTime().ToString();
var payload = bodyBytes == null?Encoding.UTF8.GetBytes(timestamp + method + path + queryString) :
Encoding.UTF8.GetBytes(timestamp + method + path + queryString).Concat(bodyBytes).ToArray();
var hash = SignWithHmacsha256(payload);
message.Headers.Add("ACCESS-KEY", _apiKey);
message.Headers.Add("ACCESS-TIMESTAMP", timestamp);
message.Headers.Add("ACCESS-SIGN", hash);
try
{
var response = await HttpClient.SendAsync(message);
var responseJson = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
var error = JsonSerializer.Deserialize <Error>(responseJson);
if (!string.IsNullOrEmpty(error?.ErrorMessage))
{
throw new BitFlyerApiException(path, error.ErrorMessage, error);
}
throw new BitFlyerApiException(path,
$"Error has occurred. Response StatusCode:{response.StatusCode} ReasonPhrase:{response.ReasonPhrase}.");
}
return(responseJson);
}
catch (TaskCanceledException)
{
throw new BitFlyerApiException(path, "Request Timeout");
}
}
}
public async Task<bool> UnArchiveASync(int showId)
{
var postData = new Dictionary<string, string>();
postData.Add("id", showId);
var options = "?" + postData.ToQueryString();
await Delete(ArchiveUrl + options);
return true;
}
public static string ToQueryString(this TaxLocationInfo locationInfo)
{
var dictionary = new Dictionary <string, object>
{
["country"] = locationInfo.Country,
["state"] = locationInfo.State,
["city"] = locationInfo.City,
["street"] = locationInfo.Street
};
return(dictionary.ToQueryString());
}
public async Task <bool> UnArchiveASync(int showId)
{
var postData = new Dictionary <string, string>();
postData.Add("id", showId);
var options = "?" + postData.ToQueryString();
await Delete(ArchiveUrl + options);
return(true);
}
public void ToQueryString_WhenDictionaryIsEmpty_QueryStringIsEmpty()
{
// Arrange
var parameters = new Dictionary <string, string>();
string expected = string.Empty;
// Act
var result = parameters.ToQueryString();
// Assert
result.Should().Be(expected);
}
public void ShouldGenerateBasicQueryString()
{
var queryCollection = new Dictionary <string, object>
{
{ "heroName", "yasuo" },
{ "filter", "assassin" }
};
var result = queryCollection.ToQueryString();
Assert.Equal("heroName=yasuo&filter=assassin", result);
}
public void MalformedRealm()
{
var values = new Dictionary<string, string>
{
{ "realm", "malformed" }
};
var client = new HttpClient();
var result = client.GetAsync(baseAddress + values.ToQueryString()).Result;
Assert.AreEqual<HttpStatusCode>(HttpStatusCode.BadRequest, result.StatusCode);
}
public void ShouldFormatKeyToLower()
{
var queryCollection = new Dictionary <string, object>
{
{ "HeroName", "yasuo" },
{ "Level", 100 }
};
var result = queryCollection.ToQueryString(opts => opts.KeyFormatter = key => key.ToLower());
Assert.Equal("heroname=yasuo&level=100", result);
}
public void Test()
{
var entity = EncryptServerHelper.ShowEncrypt("o8KB3uBl_0QJFEpnFUCnyYMPpZ9Y", "9EAFA395-3AFC-4D41-93CD-F801FBF8C8A3");
var dictionary = new Dictionary<object, object>
{
{"Encrypt",entity.Encrypt},
{"Sign",entity.Sign},
};
var postDataStr = dictionary.ToQueryString();
var requset = WebHelper.WebFormPost("http://hyinvite.21move.net/api/BindingUnbundling/", postDataStr);
}
public async Task <GetBotPositionsResponse> GetBotPositions(GetBotPositionsRequest request)
{
var queryParameters = new Dictionary <string, string>();
queryParameters.AddValueIfNotNullOrEmpty("signalProvider", _options.SignalProvider);
queryParameters.AddValueIfNotNullOrEmpty("signalProviderKey", _options.SignalProviderKey);
queryParameters.AddValueIfNotNullOrEmpty("exchange", request.Exchange.ToString().ToLower());
queryParameters.AddValueIfNotNullOrEmpty("baseAsset", request.BaseAsset);
var queryString = queryParameters.ToQueryString();
return(await this.GetAsync <GetBotPositionsResponse>($"v2/getBotAssetsPct{queryString}"));
}
public void CanCreateUrlQueryFromEmptyDictionary()
{
// Arrange
var parameters = new Dictionary <string, string>();
string expected = string.Empty;
// Act
var result = parameters.ToQueryString();
// Assert
Assert.AreEqual(expected, result);
}
public void ToQueryString_WhenDictionaryIsEmpty_QueryStringIsEmpty()
{
// Arrange
var parameters = new Dictionary <string, string>();
string expected = string.Empty;
// Act
var result = parameters.ToQueryString();
// Assert
Assert.AreEqual(expected, result);
}
public void NoCredentials()
{
var values = new Dictionary<string, string>
{
{ "realm", rp }
};
var client = new HttpClient();
var result = client.GetAsync(baseAddress + values.ToQueryString()).Result;
Assert.AreEqual<HttpStatusCode>(HttpStatusCode.Unauthorized, result.StatusCode);
}
public async Task <GetOrderInfoResponse> GetOrderInfo(GetOrderInfoRequest request)
{
var queryParameters = new Dictionary <string, string>();
queryParameters.AddValueIfNotNullOrEmpty("signalProvider", _options.SignalProvider);
queryParameters.AddValueIfNotNullOrEmpty("signalProviderKey", _options.SignalProviderKey);
queryParameters.AddValueIfNotNullOrEmpty("extId", request.ExternalId);
queryParameters.AddValueIfNotNullOrEmpty("orderId", request.OrderId);
var queryString = queryParameters.ToQueryString();
return(await this.GetAsync <GetOrderInfoResponse>($"v2/getOrderInfo{queryString}"));
}
public Task<string> GeneratePasswordAsync(int minLength, int maxLength)
{
var url = "api/v1/accounts/generated-passwords";
var dico = new Dictionary<string, string>()
{
{ "minLength", minLength.ToString() },
{ "maxLength", maxLength.ToString() },
};
url = url + "?" + dico.ToQueryString();
return this.PostWithResultAsync<string>(url, null);
}
public void MalformedRealm()
{
var values = new Dictionary<string, string>
{
{ "realm", "malformed" }
};
var client = new HttpClient();
client.SetBasicAuthenticationHeader(Constants.Credentials.ValidUserName, Constants.Credentials.ValidPassword);
var result = client.GetAsync(baseAddress + values.ToQueryString()).Result;
Assert.AreEqual<HttpStatusCode>(HttpStatusCode.BadRequest, result.StatusCode);
}
public async Task<Message> DeleteASync(int id)
{
var postData = new Dictionary<string, string>();
postData.Add("id", id);
var options = "?" + postData.ToQueryString();
var response = await Delete<RootMessage>(SendDeleteUrl + options);
ValidateResponse(response);
return response.Message;
}
public async Task<IList<Message>> GetDiscussionASync(int id)
{
var postData = new Dictionary<string, string>();
postData.Add("id", id);
var options = "?" + postData.ToQueryString();
var response = await Get<MessageList>(DiscussionUrl + options);
ValidateResponse(response);
return response.Messages;
}
public async Task<string> GenerateIframeTagAsync(int id, Models.Products.EmbedGenerateModel features)
{
var parameters = new Dictionary<string, string>();
this.generateParameters(parameters, features);
var queryString = parameters.ToQueryString();
var url = ApiUrls.EmbedUrl.Replace("{id}", id.ToString());
if (!string.IsNullOrEmpty(queryString))
url = url + "?" + queryString;
var model = await this.GetAsync<Models.Products.EmbedResponse>(url);
if (model == null)
return string.Empty;
return model.Content;
}
public async Task<IList<Show>> SearchASync(string title)
{
var postData = new Dictionary<string, string>();
postData.Add("title", title);
var options = "?" + postData.ToQueryString();
var response = await Get<ShowList>(SearchUrl + options);
ValidateResponse(response);
return response.Shows;
}
public async Task<Comment> DeleteAsync(int commentId)
{
var postData = new Dictionary<string, string>();
postData.Add("id", commentId);
var options = "?" + postData.ToQueryString();
var response = await Delete<RootComment>(DeleteUrl + options);
ValidateResponse(response);
return response.Comment;
}
public async Task<ProductCommentsOutput> GetCommentsAsync(int productId, int skip = 0, int take = 5, int repliesTake = 3)
{
var url = "api/v1/products/" + productId + "/comments";
var dico = new Dictionary<string, string>(){
{ "skip", skip.ToString() },
{ "take", take.ToString() },
{ "repliesTake", repliesTake.ToString() }
};
url = url + "?" + dico.ToQueryString();
var model = await this.GetAsync<ProductCommentsOutput>(url);
if (model == null)
return new ProductCommentsOutput() { Count = -1, Comments = Enumerable.Empty<ProductCommentOutput>() };
return model;
}
public async Task<Member> BlockASync(int memberId)
{
var postData = new Dictionary<string, string>();
postData.Add("id", memberId);
var options = "?" + postData.ToQueryString();
var response = await Post<RootMember>(BlockUnblockUrl + options, null);
ValidateResponse(response);
return response.Member;
}
public async Task<Member> RemoveASync(int memberId)
{
var postData = new Dictionary<string, string>();
postData.Add("id", memberId);
var options = "?" + postData.ToQueryString();
var response = await Delete<RootMember>(AddRemoveUrl + options);
ValidateResponse(response);
return response.Member;
}
public void ValidUserNameCredential()
{
var values = new Dictionary<string, string>
{
{ "realm", rp }
};
var client = new HttpClient();
client.SetBasicAuthenticationHeader(Constants.Credentials.ValidUserName, Constants.Credentials.ValidPassword);
var result = client.GetAsync(baseAddress + values.ToQueryString()).Result;
Assert.AreEqual<HttpStatusCode>(HttpStatusCode.OK, result.StatusCode);
Assert.AreEqual<string>("application/json", result.Content.Headers.ContentType.MediaType);
}
