public HttpRequestModel GivenTheRequest(string action, HttpMethod method) { var model = new HttpRequestModel(action, method); _httpRequests.Add(model); return(model); }
/// <inheritdoc /> public Task <bool> HandleStubGenerationAsync(HttpRequestModel request, StubConditionsModel conditions) { var pair = request.Headers.FirstOrDefault(p => p.Key.Equals("Authorization", StringComparison.OrdinalIgnoreCase)); if (string.IsNullOrWhiteSpace(pair.Value) || !pair.Value.Trim().ToLower().StartsWith("Basic", StringComparison.OrdinalIgnoreCase)) { return(Task.FromResult(false)); } var value = pair.Value; value = value.Replace("Basic ", string.Empty); var basicAuth = Encoding.UTF8.GetString(Convert.FromBase64String(value)); var parts = basicAuth.Split(':'); if (parts.Length != 2) { return(Task.FromResult(false)); } conditions.BasicAuthentication = new StubBasicAuthenticationModel { Username = parts[0], Password = parts[1] }; // Make sure the original Authorization header is removed here. conditions.Headers = conditions.Headers .Where(h => !h.Key.Equals("Authorization", StringComparison.OrdinalIgnoreCase)) .ToDictionary(d => d.Key, d => d.Value); return(Task.FromResult(true)); }
private async Task <ResultHandler <string> > GetStringResponseByHttpRequest(HttpRequestModel httpRequestModel) { Stopwatch stopwatch = Stopwatch.StartNew(); try { HttpRequestMessage httpRequestMessage = CreateHttpRequestMessage(httpRequestModel.MethodName, httpRequestModel.QueryString, httpRequestModel.HttpMethod, httpRequestModel.HttpContent); HttpClient httpClient = CreateHttpClient(httpRequestModel.ClientName, httpRequestModel.Headers); HttpResponseMessage httpResponseMessage = await SendHttpResponseMessage(httpRequestMessage, httpClient, httpRequestModel.CompletionOption, httpRequestModel.CancellationToken); httpResponseMessage.EnsureSuccessStatusCode(); var content = await httpResponseMessage.Content.ReadAsStringAsync(); return(ResultHandler.Ok(content)); } catch (TaskCanceledException tcex) { stopwatch.Stop(); _logger.LogError(tcex, $"GetStreamResponseByHttpRequest, time out was: {stopwatch.Elapsed.TotalSeconds}", new object[] { httpRequestModel }); return(ResultHandler.Fail <string>(tcex)); } catch (Exception ex) { _logger.LogError(ex, "GetStreamResponseByHttpRequest", new object[] { httpRequestModel }); return(ResultHandler.Fail <string>(ex)); } }
/// <inheritdoc /> public Task <bool> HandleStubGenerationAsync(HttpRequestModel request, StubConditionsModel conditions) { var pair = request.Headers.FirstOrDefault(p => p.Key.Equals("Content-Type", StringComparison.OrdinalIgnoreCase)); var contentType = pair.Value; if (string.IsNullOrWhiteSpace(contentType)) { return(Task.FromResult(false)); } var supportedContentTypes = new[] { Constants.JsonMime }; if (!supportedContentTypes.Any(sc => contentType.StartsWith(sc, StringComparison.OrdinalIgnoreCase))) { return(Task.FromResult(false)); } try { conditions.Json = JToken.Parse(request.Body); return(Task.FromResult(true)); } catch (Exception ex) { _logger.LogWarning(ex, "Exception occurred while trying to parse JSON."); return(Task.FromResult(false)); } }
/// <summary> /// Отправить HTTP-запрос (core-метод) /// </summary> private async Task <HttpResponseMessage> SendRequestCoreAsync(HttpRequestModel requestModel) { var httpRequestLogText = $"HTTP {requestModel.Method.Method} request to uri '{requestModel.Uri}'"; _logger.Information($"Sending {httpRequestLogText}..."); using var httpRequest = new HttpRequestMessage(requestModel.Method, requestModel.Uri); foreach (var httpHeader in requestModel.Headers) { httpRequest.Headers.Add(httpHeader.Key, httpHeader.Value); } if (requestModel.Body != null) { var httpRequestBodyJson = requestModel.Body.ToJson(); httpRequest.Content = new StringContent(httpRequestBodyJson, Encoding.UTF8, MediaTypeNames.Application.Json); _logger.Trace($"HTTP request body = '{httpRequestBodyJson}'"); } var httpResponse = await _httpClient.SendAsync(httpRequest); if (httpResponse.IsSuccessStatusCode) { _logger.Information($"{httpRequestLogText} was successfully sent"); } else { _logger.Warning($"{httpRequestLogText} failed (status code = '{httpResponse.StatusCode}')"); } return(httpResponse); }
private static async Task <HttpRequestModel> CreateRequest(HttpRequestMessage message) { var request = new HttpRequestModel { CorrelationId = message.Headers.GetValues("CorrelationId").First(), Body = await ReadContent(message.Content).ConfigureAwait(false), Method = message.Method.Method, Scheme = message.RequestUri.Scheme, Host = message.RequestUri.Host, Protocol = string.Empty, PathBase = message.RequestUri.PathAndQuery, Path = message.RequestUri.AbsoluteUri, QueryString = message.RequestUri.Query }; return(request); async Task <string> ReadContent(HttpContent content) { using (content) { string body; try { body = await content.ReadAsStringAsync().ConfigureAwait(false); } catch (Exception e) { body = $"Failed to read body. Error: {e}"; } return(body); } } }
private string Send(HttpRequestModel model) { string result = string.Empty; WebClient client = new WebClient(); client.Headers.Add("Content-Type", "application/json"); Dictionary <string, string> dic = null; try { dic = JsonConvert.DeserializeObject <Dictionary <string, string> >(model.Header); } catch (Exception) { throw new Exception("header格式不正确"); } if (dic != null) { foreach (var d in dic) { client.Headers.Add(d.Key, d.Value); } } return(result); }
private void resolveArray(string name, object value, ref HttpRequestModel model, HttpOperation operation, FieldInfo fi) { if (!string.IsNullOrEmpty(name)) { IEnumerator enumerator = ((Array)value).GetEnumerator(); try { while (enumerator.MoveNext()) { object current = enumerator.Current; if (!string.IsNullOrEmpty(current.ToString()) || (string.IsNullOrEmpty(current.ToString()) && !IgnoreWhenValueIsEmpty)) { model.AddQueryString(name + "[]", (current != null) ? current.ToString() : ""); } else { operation.Log("(HttpQueryStringAttribute)(OnRequestResolveModel) Query string part failed to add because the value is empty!", LogSeverity.WARNING); } } } finally { IDisposable disposable; if ((disposable = enumerator as IDisposable) != null) { disposable.Dispose(); } } } else { operation.Log("(HttpQueryStringAttribute)(OnRequestResolveModel) Query string part failed to add because the name is empty!", LogSeverity.WARNING); } }
/// <inheritdoc /> public Task <bool> HandleStubGenerationAsync(HttpRequestModel request, StubConditionsModel conditions) { var pair = request.Headers.FirstOrDefault(p => p.Key.Equals("Content-Type", StringComparison.OrdinalIgnoreCase)); var contentType = pair.Value; if (string.IsNullOrWhiteSpace(contentType)) { return(Task.FromResult(false)); } var supportedContentTypes = new[] { Constants.UrlEncodedFormMime, Constants.MultipartFormDataMime }; if ( !supportedContentTypes.Any(sc => contentType.StartsWith(sc, StringComparison.OrdinalIgnoreCase)) || string.IsNullOrWhiteSpace(request.Body)) { return(Task.FromResult(false)); } // If the body condition is already set, clear it here. conditions.Body = Array.Empty <string>(); var reader = new FormReader(request.Body); var form = reader.ReadForm(); conditions.Form = form.Select(f => new StubFormModel { Key = f.Key, Value = f.Value }); return(Task.FromResult(true)); }
public async Task <ResultHandler <TRes> > GetHttpResponse <TRes>(HttpRequestModel httpRequest) { try { if (!httpRequest.IsValid) { this._logger.LogError($"GetHttpResponse Not Valid! ValidationError: {httpRequest.ValidationError}", new object[] { httpRequest }); return(ResultHandler.Fail <TRes>(E_ErrorType.EntityNotValid)); } ResultHandler <Stream> resultHandler = await GetStreamResponseByHttpRequest(httpRequest); if (!resultHandler.Success) { this._logger.LogError("GetStreamResponseByHttpRequest Failed", new object[] { httpRequest }); return(ResultHandler.Fail <TRes>(resultHandler.ErrorType)); } using (Stream stream = resultHandler.Value) { TRes result = await JsonSerializer.DeserializeAsync <TRes>(stream, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true }, httpRequest.CancellationToken); return(ResultHandler.Ok(result)); } } catch (Exception ex) { this._logger.LogError("GetHttpResponse Exception", new object[] { httpRequest }); return(ResultHandler.Fail <TRes>(ex)); } }
protected override async Task <ActivityExecutionResult> OnExecuteAsync(HttpRequestTrigger activity, WorkflowExecutionContext workflowContext, CancellationToken cancellationToken) { var request = httpContextAccessor.HttpContext.Request; var model = new HttpRequestModel { Path = new Uri(request.Path.ToString(), UriKind.Relative), QueryString = request.Query.ToDictionary(x => x.Key, x => x.Value), Headers = request.Headers.ToDictionary(x => x.Key, x => x.Value), Method = request.Method }; if (activity.ReadContent) { if (request.HasFormContentType) { model.Form = (await request.ReadFormAsync(cancellationToken)).ToDictionary(x => x.Key, x => x.Value); } else { model.Content = await request.ReadBodyAsync(); } } workflowContext.CurrentScope.LastResult = model; return(TriggerEndpoint("Done")); }
/// <inheritdoc /> public Task <bool> HandleStubGenerationAsync(HttpRequestModel request, StubConditionsModel conditions) { var uri = new Uri(request.Url); conditions.Url.Path = uri.LocalPath; return(Task.FromResult(true)); }
public async Task HttpClientTest() { var strat = HttpRequestStrategy.GenerateDefaultStrategy(); strat.Path.Probability = 100; strat.Path.ValidManipulations = new List <string> { "BasicStringGeneration" }; strat.ValidManipulations = new List <string> { "BasicStringGeneration" }; var fuzzer = new HttpRequestModel(strat, 10);; var message = new HttpRequestMessage(HttpMethod.Get, "https://www.bing.com"); var fuzzMessage = fuzzer.Fuzz(message); Assert.NotEqual("/", fuzzMessage.RequestUri.AbsolutePath); using (var client = new HttpClient()) { var response = await client.SendAsync(message); Assert.False(response.IsSuccessStatusCode); Assert.Equal("BadRequest", response.StatusCode.ToString()); } }
/// <inheritdoc /> public async Task <StubModel> ConvertToStubAsync(OpenApiServer server, OpenApiLine line, string tenant) { var request = new HttpRequestModel { Body = _openApiDataFiller.BuildRequestBody(line.Operation), Headers = _openApiDataFiller.BuildRequestHeaders(line.Operation), Method = line.OperationType.ToString().ToUpper(), Url = $"{_openApiDataFiller.BuildServerUrl(server)}{_openApiDataFiller.BuildRelativeRequestPath(line.Operation, line.PathKey)}" }; var response = new HttpResponseModel { Content = _openApiDataFiller.BuildResponseBody(line.Response), Headers = _openApiDataFiller.BuildResponseHeaders(line.Response), StatusCode = _openApiDataFiller.BuildHttpStatusCode(line.ResponseKey) }; var stub = new StubModel { Tenant = tenant, Description = line.Operation.Summary, Conditions = await _httpRequestToConditionsService.ConvertToConditionsAsync(request), Response = await _httpResponseToStubResponseService.ConvertToResponseAsync(response), }; stub.EnsureStubId(); return(stub); }
private IHttpResponseModel MockSend(HttpRequestModel request) { if (MockResponseQueue.Count > 0) { var sentAtUtc = DateTimeOffset.UtcNow - TimeSpan.FromSeconds(-1); var mockResponse = MockResponseQueue.Dequeue(); mockResponse .Setup(mr => mr.SentAtUtc) .Returns(sentAtUtc); mockResponse .Setup(mr => mr.CompletedAtUtc) .Returns(DateTimeOffset.UtcNow); return(mockResponse.Object); } foreach (var lookupResponse in MockResponseLookup) { if (lookupResponse.MatchesRequest(request)) { return(lookupResponse.Process(request)); } } throw new NotImplementedException("There are no mocked responses queued or added to pattern match"); }
public HttpRequestModel Transform(HttpRequestMessage request) { var body = new Body() { Data = request.Content.ReadAsStringAsync().Result, ContentType = new ContentType() { MediaType = request.Content.Headers?.ContentType?.MediaType } }; if (request.Content?.Headers?.ContentType?.CharSet != null) { body.ContentType.CharSet = request.Content.Headers.ContentType.CharSet; } var method = request.Method; var query = request.RequestUri.Query; var port = request.RequestUri.Port; var headers = new Headers(); foreach (var httpRequestHeader in request.Headers) { headers.Add(httpRequestHeader.Key, string.Join(",", httpRequestHeader.Value)); } var localPath = request.RequestUri.LocalPath; var requestModel = new HttpRequestModel(body, method, headers, query, localPath, port); return(_processor.Execute(requestModel)); }
public async Task VerifyQueuedResponse() { var mockResponse1 = new Mock <IHttpResponseModel>(); mockResponse1 .Setup(mr => mr.TransactionId) .Returns(1); var mockResponse2 = new Mock <IHttpResponseModel>(); mockResponse2 .Setup(mr => mr.TransactionId) .Returns(2); var mockWebClient = new MockHttpWebClient(); mockWebClient.MockResponseQueue.Enqueue(mockResponse1); mockWebClient.MockResponseQueue.Enqueue(mockResponse2); var request = HttpRequestModel .CreateSimpleRequest(HttpAction.GET, new Uri("https://www.example.com/v1/object1")); // Expect Response1 var response = await mockWebClient.Execute(request); Assert.AreEqual(mockResponse1.Object.TransactionId, response.TransactionId); // Expect Response2 response = await mockWebClient.Execute(request); Assert.AreEqual(mockResponse2.Object.TransactionId, response.TransactionId); }
public void Execute_ShouldReplaceVirtualPathInFirstSegment() { Fixture.Freeze <Mock <IHostingEnvironment> >().SetupGet(m => m.ApplicationVirtualPath).Returns("/base"); var model = new HttpRequestModel(Fixture.Create <Body>(), Fixture.Create <Method>(), Fixture.Create <Headers>(), Fixture.Create <string>(), "/base/customer/1/base", 443); Sut.Execute(model).LocalPath.Should().Be("/customer/1/base"); }
/// <inheritdoc /> public Task <bool> HandleStubGenerationAsync(HttpRequestModel request, StubConditionsModel conditions) { if (string.IsNullOrWhiteSpace(request.Method)) { throw new InvalidOperationException("No HTTP method set; this is unexpected."); } conditions.Method = request.Method; return(Task.FromResult(true)); }
protected ApiHandlerBase(IOptions <VSCronOptions> vsCronOptions) { _vsCronOptions = vsCronOptions; RequestModel = new HttpRequestModel { Headers = new Dictionary <string, string>(), QueryParams = new Dictionary <string, object>() }; }
/// <inheritdoc /> public Task <bool> HandleStubGenerationAsync(HttpRequestModel request, StubConditionsModel conditions) { if (!request.Url.StartsWith("https", StringComparison.OrdinalIgnoreCase)) { return(Task.FromResult(false)); } conditions.Url.IsHttps = true; return(Task.FromResult(true)); }
public static HttpRequestMessage BuildHttpRequestMessage(HttpRequestModel reqModel) { var msg = new HttpRequestMessage { Method = GetHttpMethodFromAction(reqModel.Method), RequestUri = UriUtilities.GetFullUri(reqModel.RootUri, reqModel.RelativePath, reqModel.QueryStringParameters) }; if (reqModel.Body != null) { //Copy the stream contents. This is done to keep the request object //Re-usable in a retry scenario. (The send async used in the client will //not clean this up correctly if the request is cancelled via cancellation token) //The tradeoff here is bloated memory, we are taking the risk, with the assumption that //Request bodies will not be very large, generally (hopefully) var ms = new MemoryStream(); reqModel.Body.CopyToAsync(ms).Wait(); //Memory stream position needs to be reset for the send to function ms.Position = 0; msg.Content = new StreamContent(ms); } if (!string.IsNullOrWhiteSpace(reqModel.Authorization)) { msg.Headers.Add("Authorization", reqModel.Authorization); } if (!string.IsNullOrWhiteSpace(reqModel.Accept)) { msg.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(reqModel.Accept)); } if (msg.Content != null && !string.IsNullOrWhiteSpace(reqModel.ContentType)) { msg.Content.Headers.ContentType = new MediaTypeHeaderValue(reqModel.ContentType); } foreach (var requestHeader in reqModel.Headers) { //These headers are set above. if (requestHeader.Key.Equals("Authorization", StringComparison.InvariantCultureIgnoreCase) || requestHeader.Key.Equals("Accept", StringComparison.InvariantCultureIgnoreCase) || requestHeader.Key.Equals("Content-Type", StringComparison.InvariantCultureIgnoreCase)) { continue; } msg.Headers.Add(requestHeader.Key, requestHeader.Value); } return(msg); }
public async Task <ResultHandler <IEnumerable <UserModel> > > GetUsers(UsersRequest request) { try { if (request == null) { return(ResultHandler.Fail <IEnumerable <UserModel> >(E_ErrorType.EntityNotValid)); } Dictionary <string, string> nameValueCollection = new Dictionary <string, string>(); if (request.Id.HasValue) { nameValueCollection.Add("Id", request.Id.Value.ToString()); } HttpRequestModel httpRequestModel = new HttpRequestModel() { MethodName = "Users", CancellationToken = new System.Threading.CancellationToken(), ClientName = E_HttpClient.Typicode, CompletionOption = System.Net.Http.HttpCompletionOption.ResponseContentRead, Headers = null, HttpContent = null, HttpMethod = System.Net.Http.HttpMethod.Get, QueryString = nameValueCollection }; var usersResult = await this._httpClientFactoryService.GetHttpResponse <User[]>(httpRequestModel); if (!usersResult.Success) { return(ResultHandler.Fail <IEnumerable <UserModel> >(usersResult.ErrorType)); } List <UserModel> result = new List <UserModel>(); foreach (User user in usersResult.Value) { result.Add(new UserModel() { Id = user.Id, Name = user.Name }); } Thread.Sleep(TimeSpan.FromSeconds(_typicodeConfig.UsersThreadSleep)); return(ResultHandler.Ok <IEnumerable <UserModel> >(result)); } catch (System.Exception ex) { return(ResultHandler.Fail <IEnumerable <UserModel> >(ex)); } }
public override void OnRequestResolveModel(string name, object value, ref HttpRequestModel model, HttpOperation operation, FieldInfo fi) { if (!string.IsNullOrEmpty(name)) { model.AddUriTemplate("{" + ((!name.StartsWith("$")) ? ("$" + name) : name) + "}", (value != null) ? Uri.EscapeUriString(value.ToString()) : ""); } else { operation.Log("(HttpUriSegmentAttribute)(OnRequestResolveModel) URI template expression failed to add because the name is empty!", LogSeverity.WARNING); } }
public async Task <ResultHandler <IEnumerable <UserModel> > > GetUsers(UsersRequest request) { try { if (request == null) { return(ResultHandler.Fail <IEnumerable <UserModel> >(E_ErrorType.EntityNotValid)); } Dictionary <string, string> nameValueCollection = new Dictionary <string, string>(); nameValueCollection.Add("order", "desc"); nameValueCollection.Add("sort", "reputation"); nameValueCollection.Add("site", "stackoverflow"); HttpRequestModel httpRequestModel = new HttpRequestModel() { MethodName = "Users", CancellationToken = new System.Threading.CancellationToken(), ClientName = E_HttpClient.Stackoverflow, CompletionOption = System.Net.Http.HttpCompletionOption.ResponseContentRead, Headers = null, HttpContent = null, HttpMethod = System.Net.Http.HttpMethod.Get, QueryString = nameValueCollection }; var usersResult = await this._httpClientFactoryService.GetHttpResponse <UserResponse>(httpRequestModel); if (!usersResult.Success) { return(ResultHandler.Fail <IEnumerable <UserModel> >(usersResult.ErrorType)); } List <UserModel> result = new List <UserModel>(); foreach (User user in usersResult.Value.items) { result.Add(new UserModel() { Id = user.user_id, Name = user.display_name }); } Thread.Sleep(TimeSpan.FromSeconds(this._stackoverflowConfig.UsersThreadSleep)); return(ResultHandler.Ok <IEnumerable <UserModel> >(result)); } catch (System.Exception ex) { return(ResultHandler.Fail <IEnumerable <UserModel> >(ex)); } }
public override void OnRequestResolveModel(string name, object value, ref HttpRequestModel model, HttpOperation operation, FieldInfo fi) { if (!string.IsNullOrEmpty(name)) { model.AddBinaryFormField(name, FileName, MimeType, (value != null) ? ((byte[])value) : null); } else { operation.Log("(HttpBinaryFormFieldAttribute)(OnRequestResolveModel) Form binary field failed to add because the name is empty!", LogSeverity.WARNING); } }
public override void OnRequestResolveModel(string name, object value, ref HttpRequestModel model, HttpOperation operation, FieldInfo fi) { if (!string.IsNullOrEmpty(name)) { model.AddFormField(name, (value != null) ? value.ToString() : ""); } else { operation.Log("(HttpFormFieldAttribute)(OnRequestResolveModel) Form field failed to add because the name is empty!", LogSeverity.WARNING); } }
public override void OnRequestResolveModel(string name, object value, ref HttpRequestModel model, HttpOperation operation, FieldInfo fi) { if (value != null && value.GetType().IsArray) { resolveArray(name, value, ref model, operation, fi); } else { resolve(name, value, ref model, operation, fi); } }
private void GetPostRequest(HttpWebRequest mRequest, HttpRequestModel model) { byte[] data = Encoding.GetEncoding(model.Encode).GetBytes(model.Data); mRequest.Method = model.Type; mRequest.ContentType = "application/x-www-form-urlencoded"; mRequest.ContentLength = data.Length; mRequest.Timeout = 300000; using (Stream myRequestStream = mRequest.GetRequestStream()) { myRequestStream.Write(data, 0, data.Length); } }
private void resolve(string name, object value, ref HttpRequestModel model, HttpOperation operation, FieldInfo fi) { value = Convert.ChangeType(value, typeof(string)); if (!string.IsNullOrEmpty(name) && (!string.IsNullOrEmpty((string)value) || (string.IsNullOrEmpty((string)value) && !IgnoreWhenValueIsEmpty))) { model.AddQueryString(name, (value != null) ? value.ToString() : ""); } else { operation.Log("(HttpQueryStringAttribute)(OnRequestResolveModel) Query string part failed to add because the name is empty!", LogSeverity.WARNING); } }