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();