public void TestGetResponseAsync3_WebRequestTimeout_NoThrow()
{
using (CancellationTokenSource cts = new CancellationTokenSource())
{
WebRequest request = WebRequest.CreateHttp("http://httpbin.org/delay/6");
request.Timeout = 1000;
request.Method = "GET";
Task <WebResponse> responseTask = null;
try
{
responseTask = WebRequestExtensions.GetResponseAsync(request, false, cts.Token);
responseTask.Wait();
Assert.Fail("Expected a WebException wrapped in an AggregateException");
}
catch (AggregateException ex)
{
Assert.IsNotNull(responseTask);
Assert.AreEqual(TaskStatus.Faulted, responseTask.Status);
Assert.AreEqual(1, ex.InnerExceptions.Count);
Assert.IsInstanceOfType(ex.InnerExceptions[0], typeof(WebException));
WebException webException = (WebException)ex.InnerExceptions[0];
Assert.AreEqual(WebExceptionStatus.Timeout, webException.Status);
}
}
}
public void TestGetRequestStreamAsync()
{
WebRequest request = WebRequest.CreateHttp("http://httpbin.org/post");
request.Method = "POST";
string sampleData = "Sample Data";
byte[] buffer = Encoding.UTF8.GetBytes(sampleData);
MemoryStream outputStream = new MemoryStream();
Task testTask =
WebRequestExtensions.GetRequestStreamAsync(request)
.Then(task => StreamExtensions.WriteAsync(task.Result, buffer, 0, buffer.Length, CancellationToken.None))
.Then(task => WebRequestExtensions.GetResponseAsync(request))
.Then(task => StreamExtensions.CopyToAsync(task.Result.GetResponseStream(), outputStream));
testTask.Wait();
Assert.AreEqual(TaskStatus.RanToCompletion, testTask.Status);
Console.Error.WriteLine(Encoding.UTF8.GetString(outputStream.GetBuffer()));
PostData postData = JsonConvert.DeserializeObject <PostData>(Encoding.UTF8.GetString(outputStream.GetBuffer()));
Assert.AreEqual(sampleData, postData.data);
Assert.AreEqual(request.RequestUri.OriginalString, postData.url);
}
public void TestGetResponseAsync3_Timeout_Throw()
{
using (CancellationTokenSource cts = new CancellationTokenSource())
{
cts.CancelAfter(TimeSpan.FromSeconds(2));
WebRequest request = WebRequest.CreateHttp("http://httpbin.org/delay/6");
request.Method = "GET";
Task <WebResponse> responseTask = null;
try
{
responseTask = WebRequestExtensions.GetResponseAsync(request, true, cts.Token);
responseTask.Wait();
Assert.Fail("Expected a TaskCanceledException wrapped in an AggregateException");
}
catch (AggregateException ex)
{
Assert.IsNotNull(responseTask);
Assert.AreEqual(TaskStatus.Canceled, responseTask.Status);
Assert.AreEqual(1, ex.InnerExceptions.Count);
Assert.IsInstanceOfType(ex.InnerExceptions[0], typeof(TaskCanceledException));
}
}
}
protected override IDictionary <string, string> GetUserData(string accessToken)
{
var openid = GetOpenid(accessToken);
var url = (UserInfoEndpoint + "?" + accessToken)
.AddQueryParam("openid", openid)
.AddQueryParam("oauth_consumer_key", this.appId)
.AddQueryParam("format", "json");
var text = WebRequestExtensions.Get(url);
var graphData = JsonHelper.Deserialize <TencentGraphData>(text);
var dictionary = new Dictionary <string, string>();
dictionary.AddItemIfNotEmpty("id", openid);
dictionary.AddItemIfNotEmpty("username", graphData.NickName);
dictionary.AddItemIfNotEmpty("name", graphData.NickName);
//dictionary.AddItemIfNotEmpty("msg", graphData.Msg);
//dictionary.AddItemIfNotEmpty("gender", graphData.Gender);
//dictionary.AddItemIfNotEmpty("figureurl", graphData.Figureurl);
//dictionary.AddItemIfNotEmpty("figureurl_1", graphData.Figureurl_1);
//dictionary.AddItemIfNotEmpty("figureurl_2", graphData.Figureurl_2);
//dictionary.AddItemIfNotEmpty("figureurl_qq_1", graphData.Figureurl_qq_1);
//dictionary.AddItemIfNotEmpty("figureurl_qq_2", graphData.Figureurl_qq_2);
//dictionary.AddItemIfNotEmpty("is_yellow_vip", graphData.Is_yellow_vip.ToString());
//dictionary.AddItemIfNotEmpty("vip", graphData.Vip.ToString());
//dictionary.AddItemIfNotEmpty("level", graphData.Level.ToString());
return(dictionary);
}
public void TestGetResponseAsync3_Error_NoThrow()
{
using (CancellationTokenSource cts = new CancellationTokenSource())
{
cts.CancelAfter(TimeSpan.FromSeconds(2));
WebRequest request = WebRequest.CreateHttp("http://httpbin.org/status/404");
request.Method = "GET";
WebResponse response = null;
MemoryStream outputStream = new MemoryStream();
Task testTask =
WebRequestExtensions.GetResponseAsync(request, false, cts.Token)
.Then(task =>
{
response = task.Result;
return(CopyToAsync(task.Result.GetResponseStream(), outputStream));
});
testTask.Wait();
Assert.AreEqual(TaskStatus.RanToCompletion, testTask.Status);
Console.Error.WriteLine(Encoding.UTF8.GetString(outputStream.GetBuffer()));
Assert.IsInstanceOfType(response, typeof(HttpWebResponse));
Assert.AreEqual(HttpStatusCode.NotFound, ((HttpWebResponse)response).StatusCode);
}
}
protected override string QueryAccessToken(Uri returnUrl, string authorizationCode)
{
var dict = (new Dictionary <string, string>
{
{
"client_id",
this.appId
},
{
"redirect_uri",
returnUrl.AbsoluteUri.UrlEncode()
},
{
"client_secret",
this.appSecret
},
{
"code",
authorizationCode
},
{
"scope",
"email"
}
});
var text = WebRequestExtensions.Post(TokenEndpoint, dict);
var result = JsonHelper.Deserialize <dynamic>(text);
uid = result["uid"].ToString();
return(result["access_token"]);
}
public static void TestAsyncDown()
{
var request = WebRequest.Create("https://www.baidu.com/");
//WebRequestExtensions.DownloadStringAsync(request).Subscribe(str=>Console.WriteLine(str.Substring(0,10)),e=>Console.WriteLine(e.Message));
WebRequestExtensions.DownLoadTask(request).Subscribe(Console.WriteLine, e => Console.WriteLine(e.Message));
//Console.WriteLine(str);
}
private string GetOpenid(string accessToken)
{
var requestUri = UrlUtility.CombineQueryString(OpenIdEndpoint, accessToken);
var text = WebRequestExtensions.Get(requestUri);
var result = string.Empty;
var regex = new Regex("\"openid\":\"(.*?)\"");
if (regex.IsMatch(text))
{
result = regex.Match(text).Groups[1].Value;
}
return(result);
}
public long UploadFile(string path, string url, string contentType = "form-data")
{
// Build request
var request = (HttpWebRequest)WebRequest.Create(url);
request.Method = WebRequestMethods.Http.Post;
request.AllowWriteStreamBuffering = false;
request.ContentType = contentType;
string fileName = Path.GetFileName(path);
request.Headers["Content-Disposition"] = string.Format("attachment; filename=\"{0}\"", fileName);
try
{
// Open source file
using (var fileStream = File.OpenRead(path))
{
// Set content length based on source file length
request.ContentLength = fileStream.Length;
// Get the request stream with the default timeout
using (var requestStream = WebRequestExtensions.GetRequestStreamWithTimeout(request, 30000))
{
// Upload the file with no timeout
fileStream.CopyTo(requestStream);
}
}
// Get response with the default timeout, and parse the response body
using (var response = WebRequestExtensions.GetResponseWithTimeout(request, 30000))
using (var responseStream = response.GetResponseStream())
using (var reader = new StreamReader(responseStream))
{
string json = reader.ReadToEnd();
var j = JObject.Parse(json);
return(j.Value <long>("Id"));
}
}
catch (WebException ex)
{
if (ex.Status == WebExceptionStatus.Timeout)
{
//LogError(ex, "Timeout while uploading '{0}'", fileName);
}
else
{
//LogError(ex, "Error while uploading '{0}'", fileName);
}
throw;
}
}
protected override string QueryAccessToken(Uri returnUrl, string authorizationCode)
{
var dict = new Dictionary <string, string>
{
{ "grant_type", "authorization_code" },
{ "client_id", this.appId },
{ "redirect_uri", returnUrl.AbsoluteUri },
{ "client_secret", this.appSecret },
{ "code", authorizationCode }
};
var text = WebRequestExtensions.Get(TokenEndpoint, dict);
var result = JsonHelper.Deserialize <dynamic>(text);
return(result["access_token"]);
}
protected override IDictionary <string, string> GetUserData(string accessToken)
{
var dict = new Dictionary <string, string>();
dict["access_token"] = accessToken;
dict["format"] = "json";
var json = WebRequestExtensions.Get(UserInfoEndpoint, dict);
var result = JsonHelper.Deserialize <dynamic>(json);
var dictionary = new Dictionary <string, string>();
dictionary.AddItemIfNotEmpty("id", result["uid"] as string);
dictionary.AddItemIfNotEmpty("username", result["name"] as string);
dictionary.AddItemIfNotEmpty("name", result["name"] as string);
return(dictionary);
}
protected override IDictionary <string, string> GetUserData(string accessToken)
{
var openid = GetOpenid(accessToken);
var url = (UserInfoEndpoint + "?" + accessToken)
.AddQueryParam("openid", openid)
.AddQueryParam("lang", "zh_CN");
var text = WebRequestExtensions.Get(url);
var graphData = JsonHelper.Deserialize <WeChatGraphData>(text);
var dictionary = new Dictionary <string, string>();
dictionary.AddItemIfNotEmpty("id", openid);
dictionary.AddItemIfNotEmpty("username", graphData.nickname);
dictionary.AddItemIfNotEmpty("name", graphData.nickname);
return(dictionary);
}
protected override IDictionary <string, string> GetUserData(string accessToken)
{
var dict = new Dictionary <string, string>();
dict["access_token"] = accessToken;
dict["id"] = NeteaseModel.Uid;
var text = WebRequestExtensions.Get(UserInfoEndpoint, dict);
var graphData = JsonHelper.Deserialize <NeteaseGraphData>(text);
var dictionary = new Dictionary <string, string>();
dictionary.AddItemIfNotEmpty("id", graphData.Id);
dictionary.AddItemIfNotEmpty("username", graphData.Id);
dictionary.AddItemIfNotEmpty("name", graphData.Screen_Name);
dictionary.AddItemIfNotEmpty("url", graphData.Url);
dictionary.AddItemIfNotEmpty("gender", graphData.Gender.ToString());
return(dictionary);
}
protected override IDictionary <string, string> GetUserData(string accessToken)
{
var dict = new Dictionary <string, string> {
{ "access_token", accessToken }
};
dynamic graphData;
var text = WebRequestExtensions.Get(UserInfoEndpoint, dict);
graphData = JsonHelper.Deserialize <dynamic>(text);
var dictionary = new Dictionary <string, string>();
dictionary.AddItemIfNotEmpty("id", graphData["response"]["id"].ToString() as string);
dictionary.AddItemIfNotEmpty("username", graphData["response"]["id"] as string);
dictionary.AddItemIfNotEmpty("name", graphData["response"]["name"] as string);
dictionary.AddItemIfNotEmpty("url", graphData["response"]["avatar"][1]["url"] as string);
return(dictionary);
}
protected override string QueryAccessToken(Uri returnUrl, string authorizationCode)
{
var dict = new Dictionary <string, string>();
dict["code"] = authorizationCode;
dict["client_id"] = this.appId;
dict["client_secret"] = this.appSecret;
dict["redirect_uri"] = returnUrl.AbsoluteUri.UrlEncode();
dict["grant_type"] = "authorization_code";
var json = WebRequestExtensions.Post(TokenEndpoint, dict);
if (!string.IsNullOrEmpty(json))
{
NeteaseModel = JsonHelper.Deserialize <NeteaseModel>(json);
return(NeteaseModel.Access_token);
}
throw new HttpException(500, "Get AccessToken failed!");
}
public void TestGetResponseAsync1()
{
WebRequest request = WebRequest.CreateHttp("http://httpbin.org/get");
request.Method = "GET";
MemoryStream outputStream = new MemoryStream();
Task testTask =
WebRequestExtensions.GetResponseAsync(request)
.Then(task => StreamExtensions.CopyToAsync(task.Result.GetResponseStream(), outputStream));
testTask.Wait();
Assert.AreEqual(TaskStatus.RanToCompletion, testTask.Status);
Console.Error.WriteLine(Encoding.UTF8.GetString(outputStream.GetBuffer()));
GetData getData = JsonConvert.DeserializeObject <GetData>(Encoding.UTF8.GetString(outputStream.GetBuffer()));
Assert.AreEqual(request.RequestUri.OriginalString, getData.url);
}
protected override IDictionary <string, string> GetUserData(string accessToken)
{
var dict = new Dictionary <string, string>();
dict["access_token"] = accessToken;
dict["uid"] = uid;
var result = WebRequestExtensions.Get(UserData, dict);
var graphData = JsonHelper.Deserialize <SinaGraphData>(result);
var dictionary = new Dictionary <string, string>();
dictionary.AddItemIfNotEmpty("id", graphData.Id);
dictionary.AddItemIfNotEmpty("username", graphData.Screen_Name);
dictionary.AddItemIfNotEmpty("name", graphData.Name);
//foreach (var item in res)
//{
// dictionary.AddItemIfNotEmpty(item.Key as string, item.Value.ToString() as string);
//}
return(dictionary);
}
public static void PutTokenInUrl(ref HttpWebRequest req)
{
string actualUrl = req.RequestUri.ToString();
string modifiedUrl = actualUrl;
if (req.RequestUri.Query == null || req.RequestUri.Query.Length == 0) // There is no query (?param=value¶m2=value2..) already set in the url
{
modifiedUrl += "?";
modifiedUrl += GameManager.Instance.GetApiManager().GetApiKeyParamName() + "=" + GameManager.Instance.GetApiManager().GetApiToken();
}
else
{
modifiedUrl += "&";
modifiedUrl += GameManager.Instance.GetApiManager().GetApiKeyParamName() + "=" + GameManager.Instance.GetApiManager().GetApiToken();
}
// We clone the actual request because we can't simply redefine uri after declaring HttpWebRequest
HttpWebRequest reqWithToken = WebRequestExtensions.CloneRequest(req, new Uri(modifiedUrl));
req = reqWithToken;
}
public void TestGetResponseAsync3_Success_Throw()
{
using (CancellationTokenSource cts = new CancellationTokenSource())
{
cts.CancelAfter(TimeSpan.FromSeconds(2));
WebRequest request = WebRequest.CreateHttp("http://httpbin.org/get");
request.Method = "GET";
MemoryStream outputStream = new MemoryStream();
Task testTask =
WebRequestExtensions.GetResponseAsync(request, true, cts.Token)
.Then(task => CopyToAsync(task.Result.GetResponseStream(), outputStream));
testTask.Wait();
Assert.AreEqual(TaskStatus.RanToCompletion, testTask.Status);
Console.Error.WriteLine(Encoding.UTF8.GetString(outputStream.GetBuffer()));
GetData getData = JsonConvert.DeserializeObject <GetData>(Encoding.UTF8.GetString(outputStream.GetBuffer()));
Assert.AreEqual(request.RequestUri.OriginalString, getData.url);
}
}
public void TestGetResponseAsync3_Error_Throw()
{
using (CancellationTokenSource cts = new CancellationTokenSource())
{
cts.CancelAfter(TimeSpan.FromSeconds(2));
WebRequest request = WebRequest.CreateHttp("http://httpbin.org/status/404");
request.Method = "GET";
MemoryStream outputStream = new MemoryStream();
Task testTask = null;
try
{
testTask =
WebRequestExtensions.GetResponseAsync(request, true, cts.Token)
.Then(task => CopyToAsync(task.Result.GetResponseStream(), outputStream));
testTask.Wait();
Assert.Fail("Expected a WebException wrapped in an AggregateException");
}
catch (AggregateException ex)
{
Assert.IsNotNull(testTask);
Assert.AreEqual(TaskStatus.Faulted, testTask.Status);
Assert.AreEqual(1, ex.InnerExceptions.Count);
Assert.IsInstanceOfType(ex.InnerExceptions[0], typeof(WebException));
WebException webException = (WebException)ex.InnerExceptions[0];
Assert.IsInstanceOfType(webException.Response, typeof(HttpWebResponse));
HttpWebResponse response = (HttpWebResponse)webException.Response;
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
}
}
}
public void TestGetResponseAsync1_NullRequest()
{
WebRequestExtensions.GetResponseAsync(null);
}
public void TestGetResponseAsync3_NullRequest_Throw()
{
WebRequestExtensions.GetResponseAsync(null, true, CancellationToken.None);
}
public void TestGetRequestStreamAsync_NullRequest()
{
WebRequestExtensions.GetRequestStreamAsync(null);
}
public void TestGetResponseAsync2_NullRequest()
{
WebRequestExtensions.GetResponseAsync(null, CancellationToken.None);
}
