private string ReadFileAsString(FileEntry fileEntry)
{
Stream contentStream = null;
try
{
contentStream = new MemoryStream();
RequestResults requestResult =
this.Extractor.Read(fileEntry.Index, fileEntry.CompressedLength, ref contentStream);
switch (requestResult)
{
case RequestResults.Authenticated:
StreamReader sR = new StreamReader(contentStream);
return(sR.ReadToEnd());
case RequestResults.ContentNotExists:
throw new FileNotFoundException();
case RequestResults.PasswordError:
throw new Exceptions.DeploymentException(Global.SystemMessages.PASSWORD_WRONG, new SecurityException());
}
return(string.Empty);
}
finally
{
contentStream?.Close();
}
}
public RecordingResult()
{
RequestResult = RequestResults.Unset;
GeneratedRecordingsBlob = new RPRecordingsBlob();
Completed = false;
Success = false;
}
public RecordingResult()
{
RequestResult = RequestResults.Unset;
GeneratedRecordingsBlob = new RPRecordingsBlob();
Completed = false;
Success = false;
}
public void ProvideContentFileStream(string languageId, string requestedFilePath, out Stream outputStream)
{
outputStream = null;
if (string.IsNullOrEmpty(requestedFilePath))
{
return;
}
requestedFilePath = requestedFilePath.Replace('/', '\\');
if (requestedFilePath[0] == '\\')
{
requestedFilePath = requestedFilePath.Substring(1);
}
string requestPath = string.Empty;
string requestFile = requestedFilePath;
int lastIndex = requestedFilePath.LastIndexOf('\\');
if (lastIndex > -1)
{
requestPath = requestedFilePath.Substring(0, lastIndex + 1);
requestFile = requestedFilePath.Substring(lastIndex + 1);
}
FileEntry fileEntry =
this.Extractor.Get(
string.Concat(
this.ContentsRegistration(languageId),
requestPath
),
requestFile
);
if (fileEntry.Index == -1)
{
throw new FileNotFoundException();
}
outputStream = new MemoryStream();
RequestResults requestResult =
this.Extractor.Read(fileEntry.Index, fileEntry.CompressedLength, ref outputStream);
switch (requestResult)
{
case RequestResults.ContentNotExists:
throw new FileNotFoundException();
case RequestResults.PasswordError:
throw new Exceptions.DeploymentException(Global.SystemMessages.PASSWORD_WRONG, new SecurityException());
}
}
public void ProvideContentFileStream(string languageID, string requestedFilePath, out Stream outputStream)
{
outputStream = null;
if (string.IsNullOrEmpty(requestedFilePath))
{
return;
}
requestedFilePath = requestedFilePath.Replace('/', Path.DirectorySeparatorChar);
if (requestedFilePath[0] == Path.DirectorySeparatorChar)
{
requestedFilePath = requestedFilePath.Substring(1);
}
FileEntry fileEntry =
this.Decompiler.Get(
Path.Combine(
this.ContentsRegistration(languageID),
requestedFilePath.Replace(Path.GetFileName(requestedFilePath), string.Empty)
),
Path.GetFileName(requestedFilePath)
);
if (fileEntry.Index == -1)
{
return;
}
outputStream = new MemoryStream();
RequestResults requestResult =
this.Decompiler.Read(fileEntry.Index, fileEntry.CompressedLength, ref outputStream);
switch (requestResult)
{
case RequestResults.ContentNotExists:
throw new FileNotFoundException();
case RequestResults.PasswordError:
throw new Exception.DeploymentException(Global.SystemMessages.PASSWORD_WRONG, new SecurityException());
}
}
public RequestResults <Starship> GetByUrl <Starship>(string url, Dictionary <string, string> parameters)
{
RequestResults <Starship> swapiResponse;
string serializedParameters = "?" + SerializeDictionary(parameters);
string json = HttpRequest(apiUrl + url + serializedParameters, HttpMethod.GET);
if (json == "")
{
swapiResponse = new RequestResults <Starship>()
{
next = null
};
}
else
{
swapiResponse = JsonConvert.DeserializeObject <RequestResults <Starship> >(json);
}
return(swapiResponse);
}
private RequestResults <Starship> GetAllStarships(string entityName = "/starships/")
{
Dictionary <string, string> parameters = new Dictionary <string, string>();
parameters.Add("page", "1");
RequestClass req = new RequestClass();
RequestResults <Starship> result = req.GetByUrl <Starship>(entityName, parameters);
if (result != null)
{
while (result.next != null)
{
parameters["page"] = (Convert.ToInt32(parameters["page"]) + 1).ToString();
RequestResults <Starship> nextResult = req.GetByUrl <Starship>(entityName, parameters);
result.results.InsertRange(result.results.Count, nextResult.results);
result.next = String.IsNullOrEmpty(result.next) ? null : nextResult.next;
}
}
return(result);
}
public void Execute(TestScenario testScenario, TestScenarioResults testScenarioResults,
bool shouldExecuteRecordedRequestPauses, List <string> ignoreUrlRequestsPatterns)
{
var testScenarioRunResult = new TestScenarioRunResult();
var watch = Stopwatch.StartNew();
foreach (var httpRequestDto in testScenario.Requests)
{
if (ShouldFilterRequest(httpRequestDto.Url, ignoreUrlRequestsPatterns))
{
continue;
}
var requestResults = new RequestResults();
try
{
if (shouldExecuteRecordedRequestPauses)
{
Thread.Sleep(httpRequestDto.MillisecondsPauseAfterPreviousRequest);
}
var request = CreateRestRequest(httpRequestDto);
var response = ExecuteMeasuredRequest(request);
UpdateCookiesCollection(response);
requestResults.ExecutionTime = response.ExecutionTime;
requestResults.StatusCode = response.StatusCode;
requestResults.RequestUrl = response.ResponseUri.ToString();
requestResults.IsSuccessful = response.IsSuccessful;
if (!response.IsSuccessful)
{
requestResults.ResponseContent = response.ResponseUri.ToString();
}
foreach (var loadTestAssertionHandler in _loadTestAssertionHandlers)
{
var responseAssertionResults = loadTestAssertionHandler.Execute(httpRequestDto, response);
requestResults.ResponseAssertionResults.AddRange(responseAssertionResults);
}
}
catch (Exception ex)
{
requestResults.RequestUrl = httpRequestDto.Url;
requestResults.IsSuccessful = false;
requestResults.ResponseContent = $"{httpRequestDto.Url} {ex.Message}";
Console.WriteLine($"FAILED- {httpRequestDto.Url}");
}
testScenarioRunResult.RequestResults.Add(requestResults);
}
watch.Stop();
testScenarioRunResult.ExecutionTime = watch.Elapsed;
testScenarioResults.TimesExecuted++;
testScenarioResults.Weight = testScenario.Weight;
if (testScenarioRunResult.Passed)
{
testScenarioResults.TimesPassed++;
}
else
{
testScenarioResults.TimesFailed++;
}
testScenarioResults.TestScenarioRunResults.GetOrAdd(testScenarioRunResult.RunId, testScenarioRunResult);
}
