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