public void TestMakeRequestTimeout()
{
string response;
var statusCode = new HttpRequestSender().MakeRequest("http://google.com", 1, out response);
Assert.AreEqual(statusCode, HttpStatusCode.RequestTimeout);
}
/// <summary>
/// 注册
/// </summary>
/// <param name="email">电子邮件</param>
/// <param name="password">密码</param>
/// <returns>成功返回盐</returns>
public async static Task <string> RegisterAsync(string email, string password)
{
try
{
var ps = MD5.GetMd5String(password); //把密码MD5加密
var param = GetDefaultParam();
param.Add(new KeyValuePair <string, string>("email", email));
param.Add(new KeyValuePair <string, string>("password", ps));
CancellationTokenSource cts = new CancellationTokenSource(10000);
var result = await HttpRequestSender.SendPostRequestAsync(UrlHelper.UserRegisterUri, param, cts.Token);
result.ParseResult();
if (result.IsRequestSuccessful)
{
JsonObject obj = JsonObject.Parse(result.JsonSrc);
var userInfo = JsonParser.GetJsonObjFromJsonObj(obj, "UserInfo");
var salt = JsonParser.GetStringFromJsonObj(userInfo, "Salt");
return(salt);
}
else
{
return(null);
}
}
catch (OperationCanceledException)
{
throw;
}
}
public void TestProcessResponseWithDataCollection()
{
List <BasicUserData> testUsersList = new List <BasicUserData>();
testUsersList.Add(new BasicUserData()
{
Login = "******",
URL = "url1"
});
testUsersList.Add(new BasicUserData()
{
Login = "******",
URL = "url2"
});
string listJson = JsonConvert.SerializeObject(testUsersList);
HttpResponseMessage message = new HttpResponseMessage(HttpStatusCode.OK);
message.Content = new StringContent(listJson);
HttpRequestSender requestSender = new HttpRequestSender("token");
ClientResponse <IEnumerable <BasicUserData> > testResponse = requestSender.ProcessHttpResponse <IEnumerable <BasicUserData> >(message, HttpRequestSenderTest.TestNotFoundMessage).GetAwaiter().GetResult();
Assert.Equal(MessagesHelper.StandartSuccessMessage, testResponse.Message);
Assert.Equal(OperationStatus.Susseess, testResponse.Status);
IEnumerable <BasicUserData> testUsersCollection = testResponse.ResponseData;
Assert.Equal(2, testUsersCollection.Count());
}
private void UpdateDetails(object sender, EventArgs e)
{
string requestURL = App.apiPath + App.productsApiPath + App.countryContextPathSuffix;
HttpResponseMessage response =
HttpRequestSender.SendHttpRequest(requestURL, viewModel.Item, HttpMethod.Put, true).GetAwaiter().GetResult();
requestURL = App.apiPath + App.productsApiPath + "/" + viewModel.Item.Id + App.countryContextPathSuffix;
response = HttpRequestSender.SendHttpRequest(requestURL, null, HttpMethod.Get, true).GetAwaiter().GetResult();
if (!response.IsSuccessStatusCode)
{
label_InfoForUser.Text = "Product details update failed.";
label_InfoForUser.TextColor = Color.Red;
return;
}
string editedItemStream = response.Content.ReadAsStringAsync()
.GetAwaiter().GetResult();
Item editedItem = JsonConvert.DeserializeObject <Item>(editedItemStream);
viewModel.Item = editedItem;
UpdatePageDetails();
ChangeDetailsEditMode(sender, e);
label_InfoForUser.Text = "Product details update succeded.";
label_InfoForUser.TextColor = Color.Green;
//App.Current.MainPage = new MainPage();
}
public async static Task <string> GetMyOrderAsync()
{
try
{
var param = GetDefaultParam();
param.Add(new KeyValuePair <string, string>("sid", UrlHelper.SID));
HttpClient client = new HttpClient();
CancellationTokenSource cts = new CancellationTokenSource(10000);
var result = await HttpRequestSender.SendPostRequestAsync(UrlHelper.ScheduleGetOrderUri +
"sid=" + UrlHelper.SID + "&access_token=" + UrlHelper.AccessToken,
param, cts.Token);
result.ParseResult();
if (result.IsRequestSuccessful)
{
var obj = JsonObject.Parse(result.JsonSrc);
var array = JsonParser.GetJsonArrayFromJsonObj(obj, "OrderList");
var firstObj = array.GetObjectAt(0);
var listOrder = JsonParser.GetStringFromJsonObj(firstObj, "list_order");
return(listOrder);
}
else
{
return(null);
}
}
catch (Exception e)
{
var task = Logger.LogAsync(e);
return(null);
}
}
/// <summary>
/// 获盐
/// </summary>
/// <param name="email">用户Email</param>
/// <returns></returns>
public async static Task <string> GetSaltAsync(string email)
{
try
{
var param = GetDefaultParam();
param.Add(new KeyValuePair <string, string>("email", email));
CancellationTokenSource cts = new CancellationTokenSource(10000);
var result = await HttpRequestSender.SendPostRequestAsync(UrlHelper.UserGetSalt, param, cts.Token);
result.ParseResult();
if (result.IsRequestSuccessful)
{
JsonObject obj = JsonObject.Parse(result.JsonSrc);
var salt = JsonParser.GetStringFromJsonObj(obj, "Salt");
return(salt);
}
else
{
return(null);
}
}
catch (OperationCanceledException)
{
throw;
}
}
public override void OnStartServer()
{
api = new HttpApiLogic(HttpRequestSender.GetInstance());
roads = RoadController.GetInstance();
roads.OnCustomStartServer();
var randomPositions = AchievementController.GetRandomPositions(COINS_COUNT, roads);
foreach (Vector2 position in randomPositions)
{
NetworkServer.Spawn(
Instantiate(
achievementPrefab,
new Vector3(position.x, 1.5f, position.y),
Quaternion.AngleAxis(45, Vector3.up) * Quaternion.AngleAxis(90, Vector3.forward)
)
);
}
var superPosition = AchievementController.GetPoint(roads);
NetworkServer.Spawn(
Instantiate(
superAchievementPrefab,
new Vector3(superPosition.x, 1.5f, superPosition.y),
Quaternion.AngleAxis(45, Vector3.up) * Quaternion.AngleAxis(90, Vector3.forward)
)
);
}
public void TestRequestWith500()
{
string response;
var statusCode = new HttpRequestSender().MakeRequest("http://localhost:24869/api/Values/abc", 5000, out response);
Assert.AreEqual(statusCode, HttpStatusCode.InternalServerError);
}
public void TestResponseIsNotNull()
{
string response;
var statusCode = new HttpRequestSender().MakeRequest("http://localhost:24869/api/Values", 5000, out response);
Assert.AreEqual(statusCode, HttpStatusCode.OK);
Assert.IsNotNull(response);
}
public static async Task <CommonRespMsg> GetCategories(CancellationToken token)
{
var param = GetDefaultParam();
var result = await HttpRequestSender.SendGetRequestAsync(UrlHelper.MakeFullUrlForGetReq(UrlHelper.GetCategories, param), token);
return(result);
}
public static async Task <CommonRespMsg> GetImageDetail(string id, CancellationToken token)
{
var param = GetDefaultParam();
var url = UrlHelper.MakeFullUrlForGetReq(UrlHelper.GetImageDetail + id, param);
var result = await HttpRequestSender.SendGetRequestAsync(url, token);
return(result);
}
internal async Task <CommonRespMsg> GetImageDetailAsync(string id, CancellationToken token)
{
var param = GetDefaultParam();
var url = Request.AppendParamsToUrl(Request.GetImageDetail + id, param);
var result = await HttpRequestSender.SendGetRequestAsync(url, token);
return(result);
}
internal async Task <CommonRespMsg> GetRandomImagesAsync(int count, CancellationToken token)
{
var param = GetDefaultParam();
param.Add(new KeyValuePair <string, string>("count", count.ToString()));
var result = await HttpRequestSender.SendGetRequestAsync(Request.AppendParamsToUrl(Request.GetRandomImages, param), token);
return(result);
}
public void TestProcessResponseWithCreatedCode()
{
HttpRequestSender requestSender = new HttpRequestSender("token");
HttpResponseMessage message = new HttpResponseMessage(HttpStatusCode.Created);
ClientResponse <string> testResponse = requestSender.ProcessHttpResponse <string>(message, HttpRequestSenderTest.TestNotFoundMessage).GetAwaiter().GetResult();
Assert.Equal(MessagesHelper.StandartSuccessMessage, testResponse.Message);
Assert.Equal(OperationStatus.Susseess, testResponse.Status);
Assert.Null(testResponse.ResponseData);
}
private string sendMessageRequest(string msg)
{
Dictionary <string, string> paras = new Dictionary <string, string>();
paras["username"] = ConfigurationManager.UserName;
paras["content"] = msg;
string rst = HttpRequestSender.sendRequest(String.Format("{0}/post", ConfigurationManager.MessageServerUrl), paras, "post");
return(rst);
}
public static async Task <CommonRespMsg> GetRandomImages(int count, CancellationToken token)
{
var param = GetDefaultParam();
param.Add(new KeyValuePair <string, string>("count", count.ToString()));
var result = await HttpRequestSender.SendGetRequestAsync(UrlHelper.MakeFullUrlForGetReq(UrlHelper.GetRandomImages, param), token);
return(result);
}
public void TestProcessResponseWithUnknownError()
{
HttpRequestSender requestSender = new HttpRequestSender("token");
HttpResponseMessage message = new HttpResponseMessage(HttpStatusCode.InternalServerError);
ClientResponse <string> testResponse = requestSender.ProcessHttpResponse <string>(message, HttpRequestSenderTest.TestNotFoundMessage).GetAwaiter().GetResult();
Assert.Equal(MessagesHelper.UnknownErrorMessage, testResponse.Message);
Assert.Equal(OperationStatus.UnknownState, testResponse.Status);
Assert.Null(testResponse.ResponseData);
}
private async void OnAuthCompletedAsync(object sender, AuthenticatorCompletedEventArgs e)
{
string UserInfoUrl = "https://www.googleapis.com/oauth2/v2/userinfo";
var authenticator = sender as OAuth2Authenticator;
if (authenticator != null)
{
authenticator.Completed -= OnAuthCompletedAsync;
authenticator.Error -= OnAuthErrorAsync;
}
GoogleUserModel user = null;
if (e.IsAuthenticated)
{
// If the user is authenticated, request their basic user data from Google
// UserInfoUrl = https://www.googleapis.com/oauth2/v2/userinfo
var request = new OAuth2Request("GET", new Uri(UserInfoUrl), null, e.Account);
var response = request.GetResponseAsync().GetAwaiter().GetResult();
if (response != null)
{
// Deserialize the data and store it in the account store
string userJson = response.GetResponseTextAsync().GetAwaiter().GetResult();
user = JsonConvert.DeserializeObject <GoogleUserModel>(userJson);
await DisplayAlert("Successful authorization", "Google have granted your credentials.", "OK");
string requestForBearerTokenURL = App.apiPath + App.usersApiPath + "/LogInUsingGoogleAccount?idToken="
+ e.Account.Properties["id_token"];
HttpResponseMessage responseForBearerToken =
HttpRequestSender.SendHttpRequest(requestForBearerTokenURL, user, HttpMethod.Post).GetAwaiter().GetResult();
string bearerTokenString = responseForBearerToken.Content.ReadAsStringAsync()
.GetAwaiter().GetResult();
if (bearerTokenString == "null")
{
label_InfoForUser.Text = "Service could not start session.";
label_InfoForUser.TextColor = Color.Red;
return;
}
TokenModel bearerToken = JsonConvert.DeserializeObject <TokenModel>(bearerTokenString);
BearerTokenModel.Instance.Token = bearerToken.Token;
App.Current.MainPage = new MainPage();
return;
}
}
await DisplayAlert("Unsuccessful authorization", "Google have not granted your credentials", "OK");
}
internal async Task <CommonRespMsg> GetImagesAsync(int page, int pageCount, CancellationToken token, string url)
{
var param = GetDefaultParam();
param.Add(new KeyValuePair <string, string>("page", page.ToString()));
param.Add(new KeyValuePair <string, string>("per_page", pageCount.ToString()));
var result = await HttpRequestSender.SendGetRequestAsync(Request.AppendParamsToUrl(url, param), token);
return(result);
}
public async Task WhenErrorReceivedAnExceptionIsThown()
{
using (var httpListener = new TestHttpListener(HttpStatusCode.Forbidden))
using (var httpRequestSender = new HttpRequestSender())
{
var requestMessage = new HttpRequestMessage(HttpMethod.Get, httpListener.ListeningUrl);
var doRequest = httpRequestSender.SendHttpRequest(requestMessage);
await Assert.ThrowsAsync <HttpRequestException>(() => doRequest);
}
}
public static async Task <CommonRespMsg> SearchImages(int page, int pageCount, string query, CancellationToken token)
{
var param = GetDefaultParam();
param.Add(new KeyValuePair <string, string>("page", page.ToString()));
param.Add(new KeyValuePair <string, string>("per_page", pageCount.ToString()));
param.Add(new KeyValuePair <string, string>("query", query));
var result = await HttpRequestSender.SendGetRequestAsync(UrlHelper.MakeFullUrlForGetReq(UrlHelper.SearchImages, param), token);
return(result);
}
public void WhenErrorReceivedAnExceptionIsThown()
{
using (var testHttpListener = new TestHttpListener(HttpStatusCode.Forbidden, null))
{
using (HttpRequestSender apiRequestSender = new HttpRequestSender())
{
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Get, testHttpListener.ListeningUrl);
Assert.ThrowsAsync <HttpRequestException>(async() => await apiRequestSender.SendHttpRequest(requestMessage));
}
}
}
private string SendHeartBeat()
{
string rst = HttpRequestSender.sendRequest(
String.Format("{0}/heartbeat?lasttime={1}&username={2}",
ConfigurationManager.MessageServerUrl,
LastSynchronizationTime,
ConfigurationManager.UserName),
null,
"get");
return(rst);
}
public async Task GetStringContentAsync_ValidRequestUri_ReturnContent()
{
// Arrange
var _HttpClient = new HttpClient();
var _RequestSender = new HttpRequestSender(_HttpClient);
var _Uri = new Uri("https://httpstat.us/200");
// Act
var _SearchResults = await _RequestSender.GetStringContentAsync(_Uri);
// Assert
Assert.NotNull(_SearchResults);
} //GetStringContentAsync_ValidRequestUri_ReturnContent
public void TestProcesResponseWithInvalidJson()
{
string invalidJson = "invalid json";
HttpResponseMessage message = new HttpResponseMessage(HttpStatusCode.OK);
message.Content = new StringContent(invalidJson);
HttpRequestSender requestSender = new HttpRequestSender("token");
ClientResponse <BasicUserData> testResponse = requestSender.ProcessHttpResponse <BasicUserData>(message, HttpRequestSenderTest.TestNotFoundMessage).GetAwaiter().GetResult();
string expextedMessage = $"{MessagesHelper.InvalidJsonMessage}: {invalidJson}";
Assert.Equal(expextedMessage, testResponse.Message);
Assert.Equal(OperationStatus.Error, testResponse.Status);
}
public async Task WhenSuccessReceivedResponseIsReturned()
{
using (var httpListener = new TestHttpListener(HttpStatusCode.OK))
using (var httpRequestSender = new HttpRequestSender())
{
var requestMessage = new HttpRequestMessage(HttpMethod.Get, httpListener.ListeningUrl);
var response = await httpRequestSender.SendHttpRequest(requestMessage);
Assert.Equal(
httpRequestSender.UserAgent,
response.RequestMessage.Headers.GetValues("User-Agent").First()
);
}
}
public async Task GetStringContentAsync_UnsuccessfulResponse_ThrowsHttpRequestException()
{
// Arrange
var _HttpClient = new HttpClient();
var _RequestSender = new HttpRequestSender(_HttpClient);
var _Uri = new Uri("https://httpstat.us/400");
// Act
var _Exception = await Record.ExceptionAsync(() => _RequestSender.GetStringContentAsync(_Uri));
// Assert
Assert.NotNull(_Exception);
Assert.IsType <HttpRequestException>(_Exception);
} //GetStringContentAsync_UnsuccessfulResponse_ThrowsHttpRequestException
async void Save_Clicked(object sender, EventArgs e)
{
string requestURL = App.apiPath + App.productsApiPath + App.countryContextPathSuffix;
HttpResponseMessage response =
HttpRequestSender.SendHttpRequest(requestURL, Item, HttpMethod.Post, true).GetAwaiter().GetResult();
if (!response.IsSuccessStatusCode)
{
return;
}
MessagingCenter.Send(this, "AddItem", Item);
await Navigation.PopModalAsync();
}
async Task ExecuteLoadItemsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
if (App.currentConnectionType == ConnectionType.Offline)
{
Items = App.offlineSync.OfflineItems;
}
else
{
if (Items == null)
{
Items = new ObservableCollection <Item>();
}
Items.Clear();
//var items = await DataStore.GetItemsAsync(true);
string requestURL = App.apiPath + App.productsApiPath + App.countryContextPathSuffix;
HttpResponseMessage response =
HttpRequestSender.SendHttpRequest(requestURL, null, HttpMethod.Get, true).GetAwaiter().GetResult();
string responseString = response.Content.ReadAsStringAsync()
.GetAwaiter().GetResult();
var items = JsonConvert.DeserializeObject <IEnumerable <Item> >(responseString);
foreach (var item in items)
{
Items.Add(item);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public async static Task <CommonRespMsg> GetCateInfoAsync()
{
try
{
CancellationTokenSource cts = new CancellationTokenSource(10000);
var result = await HttpRequestSender.SendGetRequestAsync(UrlHelper.UserGetCateUri + $"sid={UrlHelper.SID}&access_token={UrlHelper.AccessToken}&a={new Random().Next()}", cts.Token);
result.ParseResult();
return(result);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception)
{
return(null);
}
}
