private async Task OnRequestCaptureTrafficEventHandler(object sender, SessionEventArgs e) => await Task.Run(
() =>
{
if (IsLoadTestingEnabled && CurrentTestName != null)
{
if (HttpRequestsPerTest.ContainsKey(CurrentTestName) && e.HttpClient != null && e.HttpClient.Request != null)
{
var htpRequestDto = _httpRequestDtoFactory.Create(e.HttpClient.Request, _previousHttpRequestDto);
if (e.HttpClient.Request.Method == "POST" || e.HttpClient.Request.Method == "PUT" || e.HttpClient.Request.Method == "PATCH")
{
try
{
htpRequestDto.Body = e.GetRequestBodyAsString().Result;
}
catch
{
// Ignore if doesn't have body
}
}
if (((ShouldFilterByHost && htpRequestDto.Headers.Any(x => x.Contains($"Host: {FilterHost}"))) || !ShouldFilterByHost) && !ShouldFilterRequest(htpRequestDto.Url))
{
if (_previousHttpRequestDto == null || !_previousHttpRequestDto.Equals(htpRequestDto))
{
HttpRequestsPerTest[CurrentTestName].Add(htpRequestDto);
_previousHttpRequestDto = htpRequestDto;
}
}
}
}
}).ConfigureAwait(false);
public void PostTestCleanup()
{
if (IsLoadTestingEnabled)
{
try
{
string requestFileDirectory = Path.GetDirectoryName(_requestsFilePath);
if (!Directory.Exists(requestFileDirectory))
{
Directory.CreateDirectory(requestFileDirectory);
}
ConcurrentBag <HttpRequestDto> httpRequestDto = HttpRequestsPerTest[CurrentTestName];
var jsonContent = _jsonSerializer.Serialize(httpRequestDto);
var testFilePath = Path.Combine(_requestsFilePath, $"{CurrentTestName}.json");
File.WriteAllText(testFilePath, jsonContent);
}
catch (UnauthorizedAccessException ex)
{
throw new UnauthorizedAccessException("Cannot save load test requests.", ex);
}
catch (PathTooLongException ex)
{
throw new PathTooLongException("Cannot save load test requests.", ex);
}
catch (IOException ex)
{
throw new IOException("Cannot save load test requests.", ex);
}
}
_previousHttpRequestDto = null;
CurrentTestName = null;
}
public TranslationsProxy(HttpClient client, HttpRequestDto request = null) : base(client, request)
{
if (request != null)
{
return;
}
Request.Parameters.Add($"{Config.ScopeKey}={Config.TranslationScope}");
}
public LanguagesProxy(HttpClient client, HttpRequestDto request = null) : base(client, request)
{
if (request != null)
{
return;
}
Request.Method = HttpMethod.Get.Method;
Request.Route = Config.LanguageRoute;
}
public override List <ResponseAssertionResults> Execute(HttpRequestDto httpRequestDto,
IMeasuredResponse response)
{
ResponseAssertionResultsCollection.Clear();
if (httpRequestDto.ResponseAssertions.Count > 0)
{
foreach (var responseAssertion in httpRequestDto.ResponseAssertions)
{
var responseAssertionResults = new ResponseAssertionResults
{
AssertionType = responseAssertion.ToString()
};
var htmlDocument = new HtmlDocument();
htmlDocument.LoadHtml(response.Content);
if (_loadTestLocators.Any(x => x.LocatorType.Equals(responseAssertion.Locator)))
{
var currentLocator =
_loadTestLocators.First(x => x.LocatorType.Equals(responseAssertion.Locator));
try
{
LoadTestElement htmlElement =
currentLocator.LocateElement(htmlDocument, responseAssertion.LocatorValue);
if (_loadTestEnsureHandler.Any(x => x.EnsureType.Equals(responseAssertion.AssertionType)))
{
var currentEnsureHandler = _loadTestEnsureHandler.First(x =>
x.EnsureType.Equals(responseAssertion.AssertionType));
responseAssertionResults =
currentEnsureHandler.Execute(htmlElement, responseAssertion.ExpectedValue);
}
else
{
responseAssertionResults.FailedMessage =
$"AssertionType {responseAssertion.AssertionType} is not supported.";
responseAssertionResults.Passed = false;
}
}
catch (Exception ex)
{
responseAssertionResults.FailedMessage = ex.Message;
responseAssertionResults.Passed = false;
}
}
else
{
responseAssertionResults.FailedMessage =
$"Locator {responseAssertion.Locator} is not supported.";
responseAssertionResults.Passed = false;
}
ResponseAssertionResultsCollection.Add(responseAssertionResults);
}
}
return(ResponseAssertionResultsCollection);
}
public async Task <ActionResult <HttpRequest> > PostHttpRequest(HttpRequestDto dto)
{
_logger.LogInformation($"Post request for DTO");
_logger.LogDebug(dto.ToString());
var httpRequest = ConvertDtoToModel(dto);
await _repositoryWrapper.HttpRequest.Add(httpRequest);
_logger.LogInformation($"Request added to db with id: {httpRequest.Id}");
return(CreatedAtAction("GetHttpRequest", new { id = httpRequest.Id }, httpRequest));
}
public override List <ResponseAssertionResults> Execute(HttpRequestDto httpRequestDto, IMeasuredResponse response)
{
ResponseAssertionResultsCollection.Clear();
var responseAssertionResults = new ResponseAssertionResults
{
AssertionType = "StatusCode is SUCCESS",
Passed = true,
};
if ((int)response.StatusCode <= 200 && (int)response.StatusCode >= 299)
{
responseAssertionResults.FailedMessage = $"Request's status code was not successful - {response.StatusCode} {response.ResponseUri}.";
}
ResponseAssertionResultsCollection.Add(responseAssertionResults);
return(ResponseAssertionResultsCollection);
}
private HttpRequest ConvertDtoToModel(HttpRequestDto dto)
{
_logger.LogInformation($"Converting DTO to model");
var model = new HttpRequest
{
Body = dto.Body,
BodyUsed = dto.BodyUsed,
ContentLength = dto.ContentLength,
Fetchers = dto.Fetchers,
//Headers =
Id = dto.Id,
Method = dto.Method,
Redirect = dto.Redirect,
Date = dto.Date,
Url = new RequestUrl {
Url = dto.Url.Split("?")[0]
},
};
_logger.LogInformation($"Converting DTO header list to model header list");
var headerList = new List <HttpHeader>();
dto.Headers.ForEach(header =>
{
headerList.Add(new HttpHeader()
{
Header = header[0],
Value = header[1],
});
});
model.Headers = headerList;
_logger.LogInformation($"Converted DTO to model");
_logger.LogDebug(model.ToString());
return(model);
}
public HttpRequestDto Create(Request request, HttpRequestDto previousHttpRequestDto)
{
var httpRequestDto = new HttpRequestDto
{
Url = request.Url,
Method = request.Method,
ContentType = request.ContentType,
CreationTime = DateTime.Now,
};
if (previousHttpRequestDto != null)
{
httpRequestDto.MillisecondsPauseAfterPreviousRequest = (httpRequestDto.CreationTime - previousHttpRequestDto.CreationTime).Milliseconds;
}
foreach (var item in request.Headers)
{
httpRequestDto.Headers.Add(item.ToString());
}
return(httpRequestDto);
}
public TranslateHtmlProxy(HttpClient client, string[] languages, string requestBody, string from, HttpRequestDto request = null)
: base(client, languages, requestBody, from, request)
{
if (request != null)
{
return;
}
Request.Parameters.Add($"{Config.TextTypeKey}={Config.TextTypeHtml}");
}
public TranslateProxy(HttpClient client, string[] languages, string requestBody, string from, HttpRequestDto request = null) : base(client, request)
{
SetLanguageParameters(languages);
SetContent(requestBody);
SetFromParameter(from);
if (request != null)
{
return;
}
SetDefaults();
}
