static async Task <int> runAsync(string roadName, IConfigurationSettings configuration)
{
httpClient.BaseAddress = configuration.BaseUri;
var httpClientAdapter = new HttpClientAdapter(httpClient);
// Construct the api Uri to pass
var uri = $"/road/{roadName}?app_id={configuration.AppId}&app_key={configuration.AppKey}";
IResponseInterpreter <RoadCorridor> responseInterpreter = new ResponseInterpreter <RoadCorridor>(r => new CurrentRoadStatus
{
DisplayName = r.DisplayName,
StatusSeverity = r.StatusSeverity,
StatusSeverityDescription = r.StatusSeverityDescription
});
// Construct the api requestor passing in the httpClient and the class that interprets the response
var apiRequestor = new ApiRequestor <RoadCorridor>(httpClientAdapter, responseInterpreter);
// Make the request and format the response into the CurrentRoadStatus entity
var interpretedResponse = await apiRequestor.GetApiResult(uri);
// Deconstruct the response tuple
var responseCode = interpretedResponse.Item1;
var currentRoadStatus = interpretedResponse.Item2;
// Write out the appropriate message
FormattedOutputFactory formattedOutputFactory = new FormattedOutputFactory(Console.Out);
var formattedOutput = formattedOutputFactory.GenerateFormattedOutput(responseCode);
formattedOutput.WriteOutput(roadName, currentRoadStatus);
// Return an integer result to return back to the console
return((int)responseCode);
}
private Task <TResponse> RequestWithTimeoutAsync <TResponse>(TimeSpan timeout, string path, CancellationToken cancellationToken)
{
if (timeout.TotalSeconds < 1 || timeout.TotalMinutes > 2)
{
throw new ArgumentOutOfRangeException(nameof(timeout), "Timeout must be between 1 second and 2 minutes.");
}
return(ApiRequestor.RequestJsonSerializedAsync <TResponse>(HttpMethod.Post, $"{path}?timeout={timeout.TotalSeconds}", null, cancellationToken));
}
public async Task ApiRequestor_GetApiResult_NullUri_ArgumentNullException()
{
// arrange
var httpClient = new MockHttpClientAdapter(null);
var apiRequestor = new ApiRequestor <TestResponseData>(httpClient, responseInterpreter);
// act
// assert
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await apiRequestor.GetApiResult(null));
}
public List <PlaylistItem> GetPlaylistItems(string playlistID)
{
string url = "https://www.googleapis.com/youtube/v3/playlistItems";
Dictionary <string, string> parameters = new Dictionary <string, string> {
{ "part", "snippet" },
{ "playlistId", playlistID },
{ "maxResults", "50" },
{ "key", ApiKey }
};
return(ApiRequestor.GetResponse <List <PlaylistItem> >(url, parameters));
}
public async Task ApiRequestor_GetApiResult_OtherHttpResponse_FailedResult()
{
// arrange
var httpClient = new MockHttpClientAdapter(HttpRequestMessageHelper.CreateInvalidResponse());
var apiRequestor = new ApiRequestor <TestResponseData>(httpClient, responseInterpreter);
// act
var result = await apiRequestor.GetApiResult(testUri);
// assert
Assert.AreEqual(result.Item1, ResponseEnum.Failed);
Assert.IsNull(result.Item2);
}
public async Task IntegrationTest_ValidRequest()
{
const string roadName = "a2";
const string apiPath = "/road/a2";
// arrange
var response = HttpRequestMessageHelper.CreateOKResponseWithContent();
var httpClientAdapter = new MockHttpClientAdapter(response);
IResponseInterpreter <RoadCorridor> responseInterpreter =
new ResponseInterpreter <RoadCorridor>(r => new CurrentRoadStatus
{
DisplayName = r.DisplayName,
StatusSeverity = r.StatusSeverity,
StatusSeverityDescription = r.StatusSeverityDescription
});
IApiRequestor apiRequestor = new ApiRequestor <RoadCorridor>(httpClientAdapter, responseInterpreter);
//act
var interpretedResponse = await apiRequestor.GetApiResult(apiPath);
// Deconstruct the tuple
var responseCode = interpretedResponse.Item1;
var currentRoadStatus = interpretedResponse.Item2;
var stringBuilder = new StringBuilder();
using (var stringWriter = new StringWriter(stringBuilder))
{
FormattedOutputFactory formattedOutputFactory = new FormattedOutputFactory(stringWriter);
var formattedOutput = formattedOutputFactory.GenerateFormattedOutput(responseCode);
formattedOutput.WriteOutput(roadName, currentRoadStatus);
}
// assert
StringReader stringReader = new StringReader(stringBuilder.ToString());
var line1 = stringReader.ReadLine();
Assert.AreEqual(String.Format(SuccessFormattedOutput.SuccessMessageLine1, currentRoadStatus.DisplayName), line1);
var line2 = stringReader.ReadLine();
Assert.AreEqual(String.Format(SuccessFormattedOutput.SuccessMessageLine2, currentRoadStatus.StatusSeverity), line2);
var line3 = stringReader.ReadLine();
Assert.AreEqual(String.Format(SuccessFormattedOutput.SuccessMessageLine3, currentRoadStatus.StatusSeverityDescription), line3);
}
public async Task ApiRequestor_GetApiResult_OkHttpResponse_SuccessResult()
{
// arrange
var currentRoadStatus = new Entities.CurrentRoadStatus {
DisplayName = "A2", StatusSeverity = "Good", StatusSeverityDescription = "Good"
};
var responseInterpreter = new MockRequestInterpreter <TestResponseData>(currentRoadStatus);
var httpClient = new MockHttpClientAdapter(HttpRequestMessageHelper.CreateOKResponse());
var apiRequestor = new ApiRequestor <TestResponseData>(httpClient, responseInterpreter);
// act
var result = await apiRequestor.GetApiResult(testUri);
// assert
Assert.AreEqual(result.Item1, ResponseEnum.Success);
Assert.AreEqual(currentRoadStatus.DisplayName, result.Item2.DisplayName);
Assert.AreEqual(currentRoadStatus.StatusSeverity, result.Item2.StatusSeverity);
Assert.AreEqual(currentRoadStatus.StatusSeverityDescription, result.Item2.StatusSeverityDescription);
}
public ApiResult <TextParserServiceResult> Parse(string text)
{
var dic = new Dictionary <string, string>()
{
{ "url", Settings["LuisEndPoint"] },
{ "id", Settings["LuisId"] },
{ "key", Settings["LuisKey"] },
};
var client = new RestClient(dic["url"]);
var request = GetRequest(dic, text);
var requestor = new ApiRequestor();
var result = requestor.Execute <List <TextParserServiceResult> >(client, request);
return(new ApiResult <TextParserServiceResult>()
{
Code = result.Code,
Exception = result.Exception,
HasErrors = result.HasErrors,
Message = result.Message,
Result = result.Result.FirstOrDefault()
});
}
/// <summary>
/// Edit a server within your account.
/// </summary>
/// <param name="serverUuid">The UUID of the server to edit.</param>
/// <param name="changes">The changes to make to the server.</param>
public virtual Task <TServerEntity> EditServerAsync <TServerEntity>(Guid serverUuid, ServerEditEntity changes, CancellationToken cancellationToken = default)
where TServerEntity : class
{
return(ApiRequestor.RequestJsonSerializedAsync <ServerEditEntity, TServerEntity>(HttpMethod.Post, $"server/{serverUuid}/edit", changes, cancellationToken));
}
/// <summary>
/// Deploy a new server to your account.
/// </summary>
/// <param name="configuration">The configuration for the new server.</param>
public virtual Task <TServerEntity> DeployServerAsync <TServerEntity>(ServerDeployEntity configuration, CancellationToken cancellationToken = default)
where TServerEntity : class
{
return(ApiRequestor.RequestJsonSerializedAsync <ServerDeployEntity, TServerEntity>(HttpMethod.Post, "server/new", configuration, cancellationToken));
}
/// <summary>
/// Get the current user.
/// </summary>
public virtual Task <TUserEntity> GetUserAsync <TUserEntity>(CancellationToken cancellationToken = default)
where TUserEntity : class
{
return(ApiRequestor.RequestJsonSerializedAsync <TUserEntity>(HttpMethod.Get, "account", cancellationToken));
}
/// <summary>
/// Gets local, upcoming sporting events.
/// </summary>
/// <param name="request">The request configuration.</param>
public virtual Task<TSportsResponseEntity> GetSportsAsync<TSportsResponseEntity>(RequestEntity request, CancellationToken cancellationToken = default)
where TSportsResponseEntity : class
{
return ApiRequestor.RequestJsonSerializedAsync<TSportsResponseEntity>(HttpMethod.Get, "sports.json", request.GetQueryParameters(), null, cancellationToken);
}
/// <summary>
/// Gets the referral overview for the current user.
/// </summary>
public virtual Task <TReferralOverviewEntity> GetReferralOverviewAsync <TReferralOverviewEntity>(CancellationToken cancellationToken = default)
where TReferralOverviewEntity : class
{
return(ApiRequestor.RequestJsonSerializedAsync <TReferralOverviewEntity>(HttpMethod.Get, "account/referral_overview", cancellationToken));
}
/// <summary>
/// Get all package properties.
/// </summary>
/// <param name="packageName">The package name.</param>
public virtual Task <TPackagePropertyEntity[]> ListAllPackagePropertiesAsync <TPackagePropertyEntity>(string packageName, CancellationToken cancellationToken = default)
where TPackagePropertyEntity : class
{
return(ApiRequestor.RequestJsonSerializedAsync <TPackagePropertyEntity[]>(HttpMethod.Get, $"package/{packageName}/properties", cancellationToken));
}
/// <summary>
/// Get a package.
/// </summary>
/// <param name="packageName">The name of the package.</param>
public virtual Task <TPackageEntity> GetPackageAsync <TPackageEntity>(string packageName, CancellationToken cancellationToken = default)
where TPackageEntity : class
{
return(ApiRequestor.RequestJsonSerializedAsync <TPackageEntity>(HttpMethod.Get, $"package/{packageName}", cancellationToken));
}
/// <summary>
/// Looks up location information about an IP address. Supports IPv4 and IPv6.
/// </summary>
/// <param name="ipAddress">The IP address to look up.</param>
public virtual Task <TIPLookupEntity> LookIPAddressAsync <TIPLookupEntity>(string ipAddress, CancellationToken cancellationToken = default)
where TIPLookupEntity : class
{
return(ApiRequestor.RequestJsonSerializedAsync <TIPLookupEntity>(HttpMethod.Get, "ip.json", new[] { $"q={ipAddress}" }, null, cancellationToken));
}
/// <summary>
/// Gets historical resource usage information for a server.
/// </summary>
/// <param name="serverUuid">The UUID of the server.</param>
/// <param name="from">The date and time to get the usage information from.</param>
public virtual Task <TServerHistoricalUsageEntity> GetHistoricalUsageAsync <TServerHistoricalUsageEntity>(Guid serverUuid, DateTime from, CancellationToken cancellationToken = default)
where TServerHistoricalUsageEntity : class
{
return(ApiRequestor.RequestJsonSerializedAsync <TServerHistoricalUsageEntity>(HttpMethod.Get, $"server/{serverUuid}/stats?from={from:o}&cpu=true&ram=true&storage=true", cancellationToken));
}
/// <summary>
/// Get the number of players that are currently connected to a server.
/// </summary>
/// <param name="serverUuid">The UUID of the server to get the active player count for.</param>
public virtual Task <TServerPlayersEntity> GetPlayersAsync <TServerPlayersEntity>(Guid serverUuid, CancellationToken cancellationToken = default)
where TServerPlayersEntity : class
{
return(ApiRequestor.RequestJsonSerializedAsync <TServerPlayersEntity>(HttpMethod.Get, $"server/{serverUuid}/players", cancellationToken));
}
/// <summary>
/// Gets the forecast.
/// </summary>
/// <param name="request">The request configuration.</param>
public virtual Task <TForecastResponseEntity> GetForecastAsync <TForecastResponseEntity>(ForecastRequestEntity request, CancellationToken cancellationToken = default)
where TForecastResponseEntity : class
{
return(ApiRequestor.RequestJsonSerializedAsync <TForecastResponseEntity>(HttpMethod.Get, "forecast.json", request.GetQueryParameters(), null, cancellationToken));
}
public ApiResult <object> Add(IEntity entity)
{
var apiCaller = new ApiRequestor();
return(apiCaller.Execute <object>(GetClient(), GetRequest(entity), HttpStatusCode.Created, null));
}
/// <summary>
/// Get all available packages.
/// </summary>
public virtual Task <TPackageEntity[]> ListAllPackagesAsync <TPackageEntity>(CancellationToken cancellationToken = default)
where TPackageEntity : class
{
return(ApiRequestor.RequestEntireListJsonSerializedAsync <TPackageEntity>("package", cancellationToken));
}
/// <summary>
/// Get all available regions.
/// </summary>
public virtual Task <TRegionEntity[]> ListAllRegionsAsync <TRegionEntity>(CancellationToken cancellationToken = default)
where TRegionEntity : class
{
return(ApiRequestor.RequestEntireListJsonSerializedAsync <TRegionEntity>("region", cancellationToken));
}
/// <summary>
/// Get all of the servers in your account. The returned servers are sorted by date created in acsending order (oldest servers at the top).
/// </summary>
public virtual Task <TServerEntity[]> ListAllServersAsync <TServerEntity>(CancellationToken cancellationToken = default)
where TServerEntity : class
{
return(ApiRequestor.RequestEntireListJsonSerializedAsync <TServerEntity>("server", cancellationToken));
}
/// <summary>
/// Get the balance for the current user, in all supported currencies.
/// </summary>
public virtual Task <TBalanceEntity[]> GetBalanceAsync <TBalanceEntity>(CancellationToken cancellationToken = default)
where TBalanceEntity : class
{
return(ApiRequestor.RequestJsonSerializedAsync <TBalanceEntity[]>(HttpMethod.Get, "account/balance", cancellationToken));
}
/// <summary>
/// Get a region.
/// </summary>
/// <param name="regionName">The name of the region.</param>
public virtual Task <TRegionEntity> GetRegionAsync <TRegionEntity>(string regionName, CancellationToken cancellationToken = default)
where TRegionEntity : class
{
return(ApiRequestor.RequestJsonSerializedAsync <TRegionEntity>(HttpMethod.Get, $"region/{regionName}", cancellationToken));
}
/// <summary>
/// Delete a server from your account.
/// </summary>
/// <param name="serverUuid">The UUID of the server to delete.</param>
public virtual Task DeleteServerAsync(Guid serverUuid, CancellationToken cancellationToken = default)
{
return(ApiRequestor.RequestAsync(HttpMethod.Delete, $"server/{serverUuid}", null, cancellationToken));
}
/// <summary>
/// Get a page of regions.
/// </summary>
/// <param name="limit">The maximum number of regions that can be returned. Minimum: 1, maximum: 50.</param>
/// <param name="page">The cursor for the next batch of results. Minimum: 1.</param>
public virtual Task <ResultResponseEntity <TRegionEntity> > ListRegionsAsync <TRegionEntity>(int limit = 25, int page = 1, CancellationToken cancellationToken = default)
where TRegionEntity : class
{
return(ApiRequestor.RequestResultResponseJsonSerializedAsync <TRegionEntity>(limit, page, "region", cancellationToken));
}
/// <summary>
/// Input a command into the console of a server.
/// </summary>
/// <param name="serverUuid">The UUID of the server to send the command to.</param>
/// <param name="command">The command to enter into the server's console.</param>
public virtual Task SendCommandAsync(Guid serverUuid, ServerConsoleInputEntity command, CancellationToken cancellationToken = default)
{
return(ApiRequestor.RequestAsync(HttpMethod.Post, $"server/{serverUuid}/console", command, cancellationToken));
}
/// <summary>
/// Gets information about a time zone using automation location.
/// </summary>
/// <param name="request">The request configuration.</param>
public virtual Task <TTimeZoneResponseEntity> GetTimeZoneAsync <TTimeZoneResponseEntity>(RequestEntity request, CancellationToken cancellationToken = default)
where TTimeZoneResponseEntity : class
{
return(ApiRequestor.RequestJsonSerializedAsync <TTimeZoneResponseEntity>(HttpMethod.Get, "timezone.json", request.GetQueryParameters(), null, cancellationToken));
}
/// <summary>
/// Searches for a location based on a query.
/// </summary>
/// <param name="query">The location query.</param>
public virtual Task <TSearchEntity[]> SearchAsync <TSearchEntity>(string query, CancellationToken cancellationToken = default)
{
return(ApiRequestor.RequestJsonSerializedAsync <TSearchEntity[]>(HttpMethod.Get, "search.json", new[] { $"q={query}" }, null, cancellationToken));
}
