public void TestSimpleBuildRequest()
{
BuildRequestConfiguration configuration = CreateTestProject(1);
try
{
TestTargetBuilder targetBuilder = (TestTargetBuilder)_host.GetComponent(BuildComponentType.TargetBuilder);
IConfigCache configCache = (IConfigCache)_host.GetComponent(BuildComponentType.ConfigCache);
configCache.AddConfiguration(configuration);
BuildRequest request = CreateNewBuildRequest(1, new string[1] {
"target1"
});
BuildRequestEntry entry = new BuildRequestEntry(request, configuration);
BuildResult result = new BuildResult(request);
result.AddResultsForTarget("target1", GetEmptySuccessfulTargetResult());
targetBuilder.SetResultsToReturn(result);
_requestBuilder.BuildRequest(GetNodeLoggingContext(), entry);
WaitForEvent(_buildRequestCompletedEvent, "Build Request Completed");
Assert.Equal(BuildRequestEntryState.Complete, entry.State);
Assert.Equal(entry, _buildRequestCompleted_Entry);
Assert.Equal(BuildResultCode.Success, _buildRequestCompleted_Entry.Result.OverallResult);
}
finally
{
DeleteTestProject(configuration);
}
}
public void Correct_playlistId_is_passed_to_fluentapi()
{
const string expectedPlaylistId = "test";
_fluentApi.ForPlaylistId(expectedPlaylistId).Response();
Expression <Func <Request> > specification = () => _requestBuilder.BuildRequest(A <RequestData> .That.Matches(x => x.Parameters["playlistId"] == expectedPlaylistId));
A.CallTo(specification).MustHaveHappened();
}
public async Task RequestBuilderGetsQuery()
{
var clientUnderTest = BuildTestGraphQLClient();
ReqBuilder.BuildRequest <TestResult, string, string, TestType>(
Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>(),
Arg.Any <FieldType>(), Arg.Any <string>(), Arg.Any <string>(), Arg.Any <TestType>())
.Returns(Results.Fail <GraphQLRequest>("Didn't try"));
var result = await clientUnderTest.ExecuteRequest <TestResult, string, string, TestType>(TestValues.QueryName, TestValues.Arg1, TestValues.Arg2, TestValues.Arg3);
ReqBuilder.Received().BuildRequest <TestResult, string, string, TestType>(TestValues.QueryName, TestValues.QueryName, "query", TestQuery, TestValues.Arg1, TestValues.Arg2, TestValues.Arg3);
}
public async Task <Response> Response()
{
var request = _requestBuilder.BuildRequest(_requestData);
try
{
return(await _httpClient.Send(request));
}
catch (WebException webException)
{
throw new ApiWebException(webException.Message, webException, request);
}
}
public void Basic_Parameters_Are_Hydrated()
{
var request = _requestBuilder.BuildRequest(
sender: "*****@*****.**",
recipent: "*****@*****.**",
subject: "Subject",
htmlBody: "<html>Hello</html>",
textBody: "Hello"
);
var items = ((MailgunRestRequest)request).RestSharpRequest.Parameters;
Assert.True(items.Exists(x => x.Name == "from" && (string)x.Value == "*****@*****.**"));
Assert.True(items.Exists(x => x.Name == "to" && (string)x.Value == "*****@*****.**"));
Assert.True(items.Exists(x => x.Name == "subject" && (string)x.Value == "Subject"));
Assert.True(items.Exists(x => x.Name == "html" && (string)x.Value == "<html>Hello</html>"));
Assert.True(items.Exists(x => x.Name == "text" && (string)x.Value == "Hello"));
}
public async Task <Option <TResult> > ExecuteRequest <TResult>(INotionRequest <TResult> notionRequest)
{
var myRequest = Interlocked.Add(ref _requestNumber, 1);
var request = _requestBuilder.BuildRequest(notionRequest);
_logger.LogInformation("Performing request {RequestNumber}", myRequest);
var result = await _restClient.ExecuteAsync <TResult>(request);
_logger.LogInformation("Finished request {RequestNumber}", myRequest);
if (!result.Value.HasValue)
{
return(Option.None);
}
return(result.Value.Value);
}
/// <summary>
/// Pipeline worker method that does the business logic and delegates to next middleware in the pipeline
/// </summary>
/// <param name="context">HttpContext</param>
/// <param name="builder">IRequestBuilder that converts HttpRequest to the respective builder type</param>
/// <returns></returns>
public async Task InvokeAsync(HttpContext context, IRequestBuilder builder)
{
try
{
context.Request.EnableBuffering();
await _next(context);
context.Request.Body.Position = 0;
}
finally
{
if (builder.Options != null && builder.Options.SaveRequest && builder.Options.StatusCodes.Contains(context.Response.StatusCode))
{
await builder.BuildRequest(context);
}
}
}
public async Task <Result <TResult> > ExecuteRequest <TResult, TArg1, TArg2, TArg3>(string name, TArg1 arg1, TArg2 arg2, TArg3 arg3, string operationName = null)
{
string operationType;
FieldType fieldType;
if (string.IsNullOrWhiteSpace(name))
{
return(Results.Fail <TResult>(new FluentResults.ExceptionalError(new ArgumentNullException(nameof(name)))));
}
operationName = string.IsNullOrWhiteSpace(operationName) ? name : operationName;
if (PartialSchemaProvider.Queries.TryGetValue(name, out fieldType))
{
operationType = "query";
}
else if (PartialSchemaProvider.Mutations.TryGetValue(name, out fieldType))
{
operationType = "mutation";
}
else
{
return(Results.Fail <TResult>(new FluentResults.ExceptionalError(new KeyNotFoundException($"No query or mutation \"{name}\" was found."))));
}
var request = RequestBuilder.BuildRequest <TResult, TArg1, TArg2, TArg3>(name, operationName, operationType, fieldType, arg1, arg2, arg3);
if (request.IsFailed)
{
return(request.ToResult <TResult>());
}
var result = await ExecuteRequest(request.Value);
if (result.Errors.Count == 0)
{
return(ResultBuilder.BuildTResult <TResult>(result, request.Value, name, fieldType.ResolvedType.IsNonNullGraphType()));
}
return(Results.Fail <TResult>(result.Errors.ToString()));
}
internal virtual async Task <TResponse> SendAsync <TResponse>(RequestBase request) //where TResponse : TMDbResponse
{
var expectedStatusCodes = new int[] { 200, 201 };
var httpRequestMessage = _requestBuilder.BuildRequest(Client.BaseAddress, request, _clientConfiguration);
var responseResult = new HttpResponseResult <TResponse>
{
ExpectedStatusCodes = expectedStatusCodes,
Request = httpRequestMessage,
Timer = Stopwatch.StartNew()
};
try
{
responseResult.Response = await Client.SendAsync(httpRequestMessage);
_statusCodeValidator.ValidateStatusCode(responseResult.Response, httpRequestMessage.RequestUri, expectedStatusCodes);
var responseText = await responseResult.Response.Content.ReadAsStringAsync();
responseResult.Result = responseText.ToObject <TResponse>(_clientConfiguration.ResponseSerializationSettings, true);
}
catch (Exception ex)
{
responseResult.Exception = ex;
_logger.LogException(ex);
if (ex.InnerException != null)
{
throw ex.InnerException;
}
throw;
}
finally
{
responseResult.Timer.Stop();
_logger.LogInfo(responseResult);
}
return(responseResult.Result);
}
public void Should_use_correct_http_method()
{
var requestData = MakeRequestData(TestedHttpMethod, false);
var request = _requestBuilder.BuildRequest(requestData);
Assert.That(request.Method, Is.EqualTo(TestedHttpMethod));
}
public async Task <string> GetRequest(string uri, string token) => await(await _sent.SendAsync(_builder.BuildRequest(HttpMethod.Get, url: new Uri(uri), token: token))).Content.ReadAsStringAsync();