public async Task ShouldHaveRightUrl(string paramName, Func <IApi08, Task <HttpResponseMessage> > sendRequestAsync)
{
string url = "http://example.org";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, url + $"/api/posts?{paramName}={ApiKey}")
.Respond(HttpStatusCode.OK);
var settings = new RestSettings()
{
HttpMessageHandlerFactory = () => mockHttp
};
settings.CustomParameters.Add("customKey", ApiKey);
IApi08 restClient = RestClient.For <IApi08>(url, settings);
var httpResponse = await sendRequestAsync(restClient);
httpResponse.StatusCode
.Should()
.Be(HttpStatusCode.OK);
mockHttp.VerifyNoOutstandingExpectation();
}
////http://football.ua/handlers/stanfy/authors.ashx
//public Task<ResponseCategory> LoadAuthorsCategoriesAsync()
//{
// var request = new HttpRequestMessage();
// var parser = new XmlParser<ResponseCategory>();
// request.RequestUri = new Uri("http://football.ua/handlers/stanfy/authors.ashx");
// var settings = new RestSettings<>
// return _restClient.SendMessageAsync(request, parser);
//}
public Task <List <FeedItem> > LoadAuthorsFeedAsync(FeedItem lastFeedItem = null, string filterCode = "")
{
var request = new HttpRequestMessage();
var parser = new RssFeedParser();
var requestUriBuilder = new ParameterUriBuilder("http://football.ua/handlers/stanfy/news.ashx");
requestUriBuilder.Add("type", "author");
if (lastFeedItem != null)
{
var dateTimeOffset = lastFeedItem.Date.ToString("dd.MM.yyyy HH:mm:sszzz");
dateTimeOffset = dateTimeOffset.Remove(dateTimeOffset.LastIndexOf(":"), 1);
requestUriBuilder.Add("before", dateTimeOffset);
}
if (!string.IsNullOrEmpty(filterCode))
{
requestUriBuilder.Add("filterCode", filterCode);
}
request.RequestUri = requestUriBuilder.BuildParametersUri();
var restSettings = new RestSettings <List <FeedItem> >()
.AddMode(RequestAccessMode.Server)
.AddParser(parser)
.AddRequestMessage(request);
return(_restClient.SendAsync(restSettings, null));
}
public async Task <MatchesResponse> LoadMatchesAsync(DateTime date, CancellationToken cancellationToken)
{
var month = date.Month;
var year = date.Year;
var day = date.Day - 1;
if (day == 0)
{
month -= 1;
if (month == 0)
{
year -= 1;
month = 12;
}
day = DateTime.DaysInMonth(date.Year, month);
}
var dtKey = string.Format("{0}-{1}-{2}T00:00:00", year, month, day);
var uri = new ParameterUriBuilder("http://services.football.ua/api/FootballGameBlockMain/GameList");
uri.Add("dt", dtKey);
uri.Add("direction", "false");
uri.Add("callback", "");
uri.Add("_1413706301734", "");
var requestMessage = new HttpRequestMessage(HttpMethod.Get, uri.BuildParametersUri());
var settings = new RestSettings <MatchesResponse>()
.AddMode(RequestAccessMode.Server)
.AddParser(new JsonParser <MatchesResponse>())
.AddRequestMessage(requestMessage);
return(await _restClient.SendAsync <MatchesResponse>(settings, null));
}
public async Task ShouldCallStreamMethod()
{
string url = "http://example.org";
string response = "hello";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, url + "/api/posts")
.Respond("text/plain", response);
var settings = new RestSettings()
{
HttpMessageHandlerFactory = () => mockHttp
};
IApi05 restClient = RestClient.For <IApi05>(url, settings);
using (Stream stream = await restClient.GetStreamAsync())
using (StreamReader reader = new StreamReader(stream))
{
var stringResponse = reader.ReadToEnd();
stringResponse.ShouldBeEquivalentTo(response);
}
mockHttp.VerifyNoOutstandingExpectation();
}
public async Task ShouldSerializeContent()
{
string hostUrl = "http://www.mocky.io";
string relativeUrl = "/v2/5a68c5a32e0000be27d5b580";
var testObject = new TestObject()
{
Value = "test"
};
RestSettings settings = new RestSettings();
settings.MediaTypeFormatters.Default = new TestMediaFormatter(JsonSerializer.Create(new JsonSerializerSettings()));
IRestClient restClient = new SimpleRestClient(settings);
restClient.HttpClient = new HttpClient();
restClient.HttpClient.BaseAddress = new Uri(hostUrl);
var restRequest = RestRequest.Post(restClient)
.WithUriTemplate(relativeUrl)
.WithContent(testObject, "testObject");
var response = await restRequest.ReadAsObject <TestObject>();
response.Value.ShouldBeEquivalentTo("success");
}
public async Task <Models.News.RssNewsDetailsChannelItem> GetDetailsAsync(int id, DateTimeOffset publishedDate, bool requestIfExists = false)
{
var uriBuilder = new ParameterUriBuilder("http://football.ua/hnd/Android/NewsItem.ashx");
uriBuilder.Add("news_id", id.ToString());
var requestMessage = new HttpRequestMessage(HttpMethod.Get, uriBuilder.BuildParametersUri());
var settings = new RestSettings <rss>();
settings.AddParser(new XmlParser <rss>())
.AddRequestMessage(requestMessage)
.AddMode(RequestAccessMode.Server);
var result = await _restClient.SendAsync <rss>(settings, (Tuple <rss, DateTimeOffset?> tupleData) =>
{
if (!tupleData.Item2.HasValue)
{
return(true);
}
return(requestIfExists && Math.Abs((publishedDate.UtcDateTime - tupleData.Item2.Value).TotalDays) < 1);
});
return(result?.Channel?.Item);
}
public async Task <IList <NewsItem> > LoadNewsAsync(DateTimeOffset dateTime, string code, Action <Exception> onError = null)
{
var uriBuider = new ParameterUriBuilder("http://services.football.ua/api/News/GetArchive");
uriBuider.Add("pageId", code);
uriBuider.Add("teamId", "0");
uriBuider.Add("datePublish", dateTime.ToString("yyyy-MM-ddTHH:mm:sszzz", CultureInfo.InvariantCulture));
uriBuider.Add("count", "20");
uriBuider.Add("imageFormat", "s318x171");
uriBuider.Add("callback", "");
uriBuider.Add("_1480515720809", "");
var settings = new RestSettings <NewsResponse>();
settings.AddMode(RequestAccessMode.Server)
.AddParser(new JsonParser <NewsResponse>())
.AddRequestMessage(new HttpRequestMessage(HttpMethod.Get, uriBuider.BuildParametersUri()));
var newsResponse = await _restClient.SendAsync(settings, onError : onError);
try
{
var fillDetailsTask = newsResponse.News.Select(x => GetDetailsAsync(x.Id, x.DateTimeOffsetPublish, false));
await Task.WhenAll(fillDetailsTask);
}
catch (Exception)
{
// ignore fill details task
}
return(newsResponse.News);
}
public async Task ShouldUseValueFormatter()
{
string url = "http://example.org";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, url + $"/api/posts?apiKey={AlwaysSameValue}")
.Respond(HttpStatusCode.OK);
var settings = new RestSettings()
{
HttpMessageHandlerFactory = () => mockHttp
};
settings.UrlParameterFormatters.Default = new ValueFormatter();
IApi08 restClient = RestClient.For <IApi08>(url, settings);
var httpResponse = await restClient.Get07Async(new Entities.Person());
httpResponse.StatusCode
.Should()
.Be(HttpStatusCode.OK);
mockHttp.VerifyNoOutstandingExpectation();
}
public async Task ShouldBeRightUrl <T>(string relativeUrl, Func <T, Task <HttpResponseMessage> > sendRequestAsync)
where T : class
{
string url = "http://example.org";
string fullUrl = url + relativeUrl;
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, fullUrl)
.Respond(HttpStatusCode.OK);
var settings = new RestSettings()
{
HttpMessageHandlerFactory = () => mockHttp
};
settings.CustomParameters.Add("api_key", "4ab542de1f");
T restClient = RestClient.For <T>(url, settings);
var httpResponse = await sendRequestAsync(restClient);
httpResponse.RequestMessage
.RequestUri
.OriginalString
.ShouldBeEquivalentTo(fullUrl);
httpResponse.StatusCode
.Should()
.Be(HttpStatusCode.OK);
mockHttp.VerifyNoOutstandingExpectation();
}
protected RestResourceServiceBase(
IRestProxy restProxy,
IRestCallBuilderFactory restCallBuilderFactory,
IRestSettingsProvider restSettingsProvider)
{
_restProxy = restProxy;
_restCallBuilderFactory = restCallBuilderFactory;
RestSettings = restSettingsProvider.ProvideRestSettings();
}
/// <summary>
/// Creates a REST client from an <see cref="Uri"/>.
/// </summary>
/// <typeparam name="T">The type of the REST client.</typeparam>
/// <param name="hostUri">The <see cref="Uri"/>.</param>
/// <param name="settings">The REST settings.</param>
/// <returns></returns>
public T Create <T>(Uri hostUri, RestSettings settings)
where T : class
{
var handler = settings?.HttpMessageHandlerFactory?.Invoke() ?? new HttpClientHandler();
return(this.Create <T>(new HttpClient(handler)
{
BaseAddress = hostUri
}, settings));
}
public async Task <MatchDetails> LoadMatchDetailsAsync(string detailsLink, int gameId)
{
var request = new HttpRequestMessage();
request.RequestUri = new Uri(detailsLink);
var settings = new RestSettings <MatchDetails>()
.AddMode(RequestAccessMode.Server)
.AddParser(new MatchDetailsParser())
.AddRequestMessage(request);
return(await _restClient.SendAsync(settings, null));
}
/// <summary>
/// Creates a REST client from a <see cref="HttpClient"/>.
/// </summary>
/// <typeparam name="T">The type of the REST client.</typeparam>
/// <param name="httpClient">The <see cref="HttpClient"/>.</param>
/// <param name="settings">The REST settings.</param>
/// <returns></returns>
public T Create <T>(HttpClient httpClient, RestSettings settings)
where T : class
{
settings = settings ?? new RestSettings();
if (!this.initializers.TryGetValue(typeof(T), out Func <IRestClient> initializer))
{
throw new ArgumentException($"The type '{typeof(T).FullName}' is not a Rest interface.");
}
IRestClient restClient = initializer();
restClient.HttpClient = httpClient;
restClient.Settings = settings;
return((T)restClient);
}
public void ShouldThrowNotRestInterface()
{
string url = "http://example.org";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, url + "/api/posts")
.Respond(HttpStatusCode.OK);
var settings = new RestSettings()
{
HttpMessageHandlerFactory = () => mockHttp
};
Action job = () => RestClient.For <IApi04>(url, settings);
job.ShouldThrow <ArgumentException>();
}
public void ShoulBeCancelled()
{
string url = "http://example.org";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, url + "/api/posts")
.Respond(HttpStatusCode.OK);
var settings = new RestSettings()
{
HttpMessageHandlerFactory = () => mockHttp
};
IApi03 restClient = RestClient.For <IApi03>(url, settings);
CancellationToken cancellationToken = new CancellationToken(true);
Assert.ThrowsAsync <TaskCanceledException>(async() => await restClient.GetCancellableAsync(cancellationToken));
}
public async Task ShouldSendRequest()
{
string url = "http://example.org";
string response = "hello";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, url + "/api/posts")
.Respond("text/plain", response);
var settings = new RestSettings()
{
HttpMessageHandlerFactory = () => mockHttp
};
IApi05 restClient = RestClient.For <IApi05>(url, settings);
await restClient.GetAsync();
mockHttp.VerifyNoOutstandingExpectation();
}
public async Task ShouldCallIsKoMethod()
{
string url = "http://example.org";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, url + "/api/ko")
.Respond(HttpStatusCode.InternalServerError);
var settings = new RestSettings()
{
HttpMessageHandlerFactory = () => mockHttp
};
IApi05 restClient = RestClient.For <IApi05>(url, settings);
bool isKo = await restClient.GetBoolIsKoAsync();
isKo.Should().BeFalse();
mockHttp.VerifyNoOutstandingExpectation();
}
public Task<CommentsResponse> LoadCommentsAsync(int id, int pageIndex, CommentType commentType)
{
var request = new HttpRequestMessage();
var uriBuilder = new ParameterUriBuilder("http://services.football.ua/api/Comment/Comments");
uriBuilder.Add("itemId", id.ToString());
uriBuilder.Add("commentType", ((int)commentType).ToString());
uriBuilder.Add("pageIndex", pageIndex.ToString());
uriBuilder.Add("pageSize", "25");
uriBuilder.Add("sort", "0");
uriBuilder.Add("anchor", "");
uriBuilder.Add("callback","");
request.RequestUri = uriBuilder.BuildParametersUri();
var settings = new RestSettings<CommentsResponse>()
.AddMode(RequestAccessMode.Server)
.AddParser(new JsonParser<CommentsResponse>())
.AddRequestMessage(request);
return _restClient.SendAsync(settings, null);
}
public async Task ShouldBeHttpMethod(HttpMethod httpMethod, Func <IApi01, Task <HttpResponseMessage> > sendRequestAsync)
{
string url = "http://example.org";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(httpMethod, url + "/api/posts")
.Respond(HttpStatusCode.OK);
var settings = new RestSettings()
{
HttpMessageHandlerFactory = () => mockHttp
};
IApi01 restClient = RestClient.For <IApi01>(url, settings);
var httpResponse = await sendRequestAsync(restClient);
httpResponse.StatusCode
.Should()
.Be(HttpStatusCode.OK);
mockHttp.VerifyNoOutstandingExpectation();
}
public async Task ShouldBeRightUrl(string expectedUrl, string hostUrl, string uriTemplatePrefix, string uriTemplate, string uriTemplateSuffix)
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, expectedUrl)
.Respond(HttpStatusCode.OK);
RestSettings settings = new RestSettings();
settings.CustomParameters.Add("cversion", "v3");
settings.CustomParameters.Add("ctest", "72");
IRestClient restClient = new SimpleRestClient(settings);
restClient.HttpClient = new HttpClient(mockHttp);
restClient.HttpClient.BaseAddress = new Uri(hostUrl);
var restRequest = RestRequest.Get(restClient)
.WithUriTemplatePrefix(uriTemplatePrefix)
.WithUriTemplateSuffix(uriTemplateSuffix)
.WithUriTemplate(uriTemplate)
.WithUriVariable("version", "v2")
.WithUriVariable("test", "45");
var httpResponse = await restRequest.ReadAsHttpResponseMessageAsync();
httpResponse.RequestMessage
.RequestUri
.OriginalString
.ShouldBeEquivalentTo(expectedUrl);
httpResponse.StatusCode
.Should()
.Be(HttpStatusCode.OK);
mockHttp.VerifyNoOutstandingExpectation();
}
public async Task ShouldBeHttpMethod(string headerValue, Func <IApi06, Task <HttpResponseMessage> > sendRequestAsync)
{
string url = "http://example.org";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, url + "/api/posts")
.Respond(HttpStatusCode.OK);
var settings = new RestSettings()
{
HttpMessageHandlerFactory = () => mockHttp
};
settings.CustomParameters.Add("apiKey", ApiKey);
IApi06 restClient = RestClient.For <IApi06>(url, settings);
var httpResponse = await sendRequestAsync(restClient);
httpResponse.StatusCode
.Should()
.Be(HttpStatusCode.OK);
httpResponse.RequestMessage
.Headers
.GetValues("X-DoLess-Scope")
.Should()
.Contain(headerValue);
httpResponse.RequestMessage
.Headers
.GetValues("X-DoLess-ApiKey")
.Should()
.Contain(ApiKey);
mockHttp.VerifyNoOutstandingExpectation();
}
public async Task ShouldCallHttpResponseMessageMethod()
{
string url = "http://example.org";
string response = "hello";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, url + "/api/posts")
.Respond("text/plain", response);
var settings = new RestSettings()
{
HttpMessageHandlerFactory = () => mockHttp
};
IApi05 restClient = RestClient.For <IApi05>(url, settings);
HttpResponseMessage httpResponseMessage = await restClient.GetHttpResponseMessageAsync();
httpResponseMessage.Content
.Should()
.BeOfType <StringContent>();
mockHttp.VerifyNoOutstandingExpectation();
}
public async Task ShouldCallByteArrayMethod()
{
string url = "http://example.org";
string response = "hello";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, url + "/api/posts")
.Respond("text/plain", response);
var settings = new RestSettings()
{
HttpMessageHandlerFactory = () => mockHttp
};
IApi05 restClient = RestClient.For <IApi05>(url, settings);
byte[] bytes = await restClient.GetByteArrayAsync();
string stringResponse = Encoding.UTF8.GetString(bytes);
stringResponse.ShouldBeEquivalentTo(response);
mockHttp.VerifyNoOutstandingExpectation();
}
public abstract IEnumerable <RestResponse> PATCH(string url, SerializationContext data, RestSettings restSettings);
public abstract IEnumerable <RestResponse> DELETE(string url, RestSettings restSettings);
public InfoAction(IWebhook webhook, RestSettings restSettings) : base(webhook, restSettings)
{
}
public override async Task <RestResponse[]> POST(string url, SerializationContext data, RestSettings restSettings)
{
return(await Raw("POST", url, POST_ALLOWED_STATUSES, restSettings, data).ConfigureAwait(false));
}
public override async Task <RestResponse[]> DELETE(string url, RestSettings restSettings)
{
return(await Raw("DELETE", url, DELETE_ALLOWED_STATUSES, restSettings).ConfigureAwait(false));
}
public override async Task <RestResponse[]> PATCH(string url, SerializationContext data, RestSettings restSettings)
{
Contract.AssertRequiredSerizationType(data, SerializationType.APPLICATION_JSON);
return(await Raw("PATH", url, PATCH_ALLOWED_STATUSES, restSettings, data).ConfigureAwait(false));
}
private async Task <RestResponse[]> Raw(string method, string url, IReadOnlyCollection <HttpStatusCode> allowedStatuses, RestSettings restSettings, SerializationContext?data = null)
{
Contract.EnsureWebhookIsNotBroken(_webhook.Status);
Contract.AssertArgumentNotTrue(string.IsNullOrEmpty(method), nameof(method));
Contract.AssertArgumentNotTrue(string.IsNullOrEmpty(url), nameof(url));
Contract.AssertNotNull(allowedStatuses, nameof(allowedStatuses));
Contract.CheckForNull(restSettings, nameof(restSettings));
List <RestResponse> responses = new List <RestResponse>();
uint currentAttimpts = 0;
// Used to prevent calls if something went wrong
bool forceStop = false;
do
{
if (responses.Count != 0)
{
await _webhook.ActionManager.FollowRateLimit(responses.Last().RateLimit).ConfigureAwait(false);
}
HttpWebRequest request = WebRequest.CreateHttp(url);
request.CachePolicy = _cachePolicy;
request.Method = method;
// Calling 'GetRequestStream()' after setting the request type
using var requestStream = request.GetRequestStream();
PrepareRequest(request, requestStream, data);
// Identify themselves
request.UserAgent = $"DSharp4Webhook ({WebhookProvider.LibraryUrl}, {WebhookProvider.LibraryVersion})";
// The content type is assigned in 'PrepareRequest'
// Uses it for accurate measurement RateLimit
request.Headers.Set("X-RateLimit-Precision", "millisecond");
// Disabling keep-alive, this is a one-time connection
request.KeepAlive = false;
// I noticed a memory leak on a stress test
// It wat because System.PinnableBufferCache not cleared
// If we use 'request.AllowWriteStreamBuffering = false', it just stops working and throwing an WebException
RestResponse restResponse;
using (HttpWebResponse response = request.GetResponseNoException())
{
RateLimitInfo rateLimitInfo = new RateLimitInfo(response.Headers.GetAsDictionary());
restResponse = new RestResponse(response, rateLimitInfo, currentAttimpts);
responses.Add(restResponse);
// Processing the necessary status codes
ProcessStatusCode(response.StatusCode, ref forceStop, allowedStatuses);
}
Log(new LogContext(LogSensitivity.VERBOSE, $"[A {currentAttimpts}] [SC {(int)responses.Last().StatusCode}] [RLR {restResponse.RateLimit.Reset:yyyy-MM-dd HH:mm:ss.fff zzz}] [RLMW {restResponse.RateLimit.MustWait}] Post request completed:{(restResponse.Content?.Length != 0 ? string.Concat(Environment.NewLine, restResponse.Content ?? string.Empty) : " No content")}", _webhook.Id));
// first of all we check the forceStop so that we don't go any further if
#pragma warning disable IDE0075 // Simplify conditional expression
} while (!forceStop && (!allowedStatuses.Contains(responses.Last().StatusCode) && (restSettings.Attempts > 0 ? ++currentAttimpts <= restSettings.Attempts : true)));
#pragma warning restore IDE0075 // Simplify conditional expression
return(responses.ToArray());
}
