/// <summary>
/// Updates Log with Api Test result
/// </summary>
/// <param name="suiteId"></param>
/// <param name="apiTestId"></param>
/// <param name="hasPassed"></param>
/// <param name="apiTest"></param>
/// <param name="request"></param>
/// <param name="expectedStatusCode"></param>
/// <param name="expectedResponse"></param>
/// <param name="actualResponse"></param>
/// <param name="requestTime"></param>
/// <param name="responseTime"></param>
public void UpdateLog(string suiteId, string apiTestId, bool hasPassed, APIEndpointExecuter apiTest, APIEndpointExecuterResult apiTestResult, string request,
HttpStatusCode expectedStatusCode, string expectedResponse, string actualResponse, DateTime requestTime, DateTime responseTime)
{
log.Append(string.Format("Test : {0}{1}", apiTestId, Environment.NewLine));
log.Append(string.Format("Suite : {0}{1}", suiteId, Environment.NewLine));
log.Append(string.Format("Result: {0}{1}", hasPassed ? "PASSED" : "FAILED", Environment.NewLine));
log.Append(string.Format("REQUEST:{0}", Environment.NewLine));
log.Append(string.Format("{0} {1}{2}", apiTest._HttpVerb, apiTest._Uri, Environment.NewLine));
log.Append(string.Format("Date: {0}{1}", requestTime.ToString(), Environment.NewLine));
log.Append(string.Format("Time: {0}ms{1}", ((TimeSpan)(responseTime - requestTime)).TotalMilliseconds, Environment.NewLine));
log.Append(string.Format("Authorization: {0}{1}", apiTestResult.Request.Headers.Authorization.ToString(), Environment.NewLine));
log.Append(string.Format("Content:{0}", request));
log.Append(Environment.NewLine);
log.Append(Environment.NewLine);
log.Append(String.Format("EXPECTED RESPONSE: {0} {1}", (int)expectedStatusCode, expectedStatusCode.ToString()));
log.Append(expectedResponse);
log.Append(Environment.NewLine);
log.Append(String.Format("ACTUAL RESPONSE: {0} {1}", (int)apiTestResult.Response.StatusCode, apiTestResult.Response.StatusCode.ToString()));
log.Append(Environment.NewLine);
log.Append(actualResponse);
log.Append(Environment.NewLine);
for (int i = 0; i < 7; i++)
{
log.Append("--------------------");
}
log.Append(Environment.NewLine);
log.Append(Environment.NewLine);
log.Append(Environment.NewLine);
}
private void InsertRequestToLog(APIEndpointExecuter apiEndpointExecuter, APIEndpointExecuterResult apiEndpointExecuteResult, String jsonRequest)
{
DateTime requestTime = apiEndpointExecuteResult.Request.Headers.Date.Value.UtcDateTime;
DateTime responseTime = apiEndpointExecuteResult.ResponseReceivedOnUtc;
sbLog.Insert(0, string.Format("Content:{0}{1}", Environment.NewLine, jsonRequest));
sbLog.Insert(0, string.Format("Time: {0}ms{1}", (responseTime - requestTime).TotalMilliseconds, Environment.NewLine));
sbLog.Insert(0, string.Format("Authorization: {0}{1}", apiEndpointExecuteResult.Request.Headers.Authorization.ToString(), Environment.NewLine));
sbLog.Insert(0, string.Format("Date: {0}{1}", requestTime.ToString("r"), Environment.NewLine));
sbLog.Insert(0, string.Format("{0} {1}{2}", apiEndpointExecuter._HttpVerb, apiEndpointExecuter._Uri, Environment.NewLine));
sbLog.Insert(0, string.Format("REQUEST:{0}", Environment.NewLine));
}
private async Task SendRequest(long requestNumber, long totalRequests)
{
APIEndpointExecuter apiEndpointExecuter = null;
APIEndpointExecuterResult apiEndpointExecuterResult = null;
string jsonResponse = string.Empty;
string jsonRequestRaw = txtBxRequest.Text;
DateTimeOffset requestTime;
DateTime responseTime;
try
{
// Clear Status Code label
lblStatusCode.Text = String.Empty;
btnCompareResponse.Enabled = false;
// remove trailing '/' from baseURI
if (txtBaseURI.Text.EndsWith("/"))
{
txtBaseURI.Text = txtBaseURI.Text.Remove(txtBaseURI.Text.Length - 1, 1);
}
if (!txtBxURI.Text.StartsWith("/"))
{
txtBxURI.Text = "/" + txtBxURI.Text; // add trailing '/' to uri if it doesnt exist
}
// Updating Client State Before Execution
ClientState.BaseURI = txtBaseURI.Text;
ClientState.AccessKey = txtBxAccessKey.Text;
ClientState.SecretKey = txtBxSecretKey.Text;
// Create Endpoint Executer
apiEndpointExecuter = new APIEndpointExecuter(ClientState.BaseURI + txtBxURI.Text, (HttpMethod)cbHttpMethod.SelectedItem);
// Hide "Waiting For Response..." label
lblStatus.Text = "[ " + requestNumber + " / " + totalRequests + " ] Waiting For Response...";
lblStatus.Visible = true;
// disable send request button while text is running
btnSendRequest.Enabled = false;
/** BEGIN: Snippet to Update RAW Json Request with Base 64 String that was set from file **/
APIBuiltInTestCase selectedBuiltInTest = (
from i in BuiltInTestCaseRepo.Instance.AllTestCases
where i.Name.Equals(cBBuiltInTests.Text)
select i).FirstOrDefault();
if (chkBxUseFile.Checked && selectedBuiltInTest != null &&
selectedBuiltInTest.GetType().Equals(typeof(PostUploadTest)) && !string.IsNullOrEmpty(base64String))
{
try
{
jsonRequestRaw = GetJsonTextForNewDeviceDataForPostUpload();
}
catch { }
}
/** END: Snippet to Update Json Request with Base 64 String **/
// await for async method to finish
apiEndpointExecuterResult = await apiEndpointExecuter.Run(new Regex("(\r\n|\r|\n)").Replace(jsonRequestRaw, ""));
jsonResponse = apiEndpointExecuterResult.ResponseContent;
// Set last Json response for tool
lastJsonResponse = jsonResponse;
// Hide status label
lblStatus.Visible = false;
// Enable Compare Button
btnCompareResponse.Enabled = true;
// Update Response Status Code
if (apiEndpointExecuterResult.Response.StatusCode.Equals(System.Net.HttpStatusCode.OK) || apiEndpointExecuterResult.Response.StatusCode.Equals(System.Net.HttpStatusCode.Created))
{
lblStatusCode.ForeColor = Color.Green;
lblStatusCode.Image = StudyAdminAPITester.Properties.Resources.check_smaller;
}
else
{
lblStatusCode.ForeColor = Color.Red;
lblStatusCode.Image = StudyAdminAPITester.Properties.Resources.cancel_small;
}
lblStatusCode.ImageAlign = ContentAlignment.MiddleLeft;
lblStatusCode.Text = string.Format(" HTTP Status Code {0} {1}",
(int)apiEndpointExecuterResult.Response.StatusCode, (string)apiEndpointExecuterResult.Response.StatusCode.ToString());
// Update Log
lblStatus.Text = "[ " + requestNumber + " / " + totalRequests + " ] Updating Response Log...";
lblStatus.Visible = true;
this.Refresh();
InsertResposneToLog(jsonResponse, apiEndpointExecuterResult.Response.StatusCode);
InsertRequestToLog(apiEndpointExecuter, apiEndpointExecuterResult, txtBxRequest.Text);
txtBxResponse.Text = await Task.Run(() =>
{
return(sbLog.ToString());
});
// Hide status label
lblStatus.Visible = false;
// Focus on Response text box
txtBxResponse.Focus();
}
catch (HttpRequestException)
{
lblError.Text = string.Format("A problem occured while sending request to {0}", apiEndpointExecuter._Uri);
}
catch (Exception) // Catch Everything else
{
lblError.Text = "A problem has occured. Please contact the Study Admin Team.";
}
finally
{
lblStatus.Visible = false;
}
}
/// <summary>
/// Parses and runs ApiTest XElement
/// </summary>
/// <param name="suite"></param>
/// <param name="apiTestElement"></param>
/// <param name="XmlNamespace"></param>
/// <param name="resultsListBox"></param>
/// <returns></returns>
public async Task RunApiTest(String suite, XElement apiTestElement, XNamespace XmlNamespace, System.Windows.Forms.ListBox resultsListBox)
{
// Increment counter for Total number of tests (this will be shown when batch is complete)
TotalRunTests += 1;
// Retrieve XML Attributes for ApiTest XElement
string apiTestId = apiTestElement.Attributes("id").FirstOrDefault().Value;
string uri = apiTestElement.Attributes("Uri").FirstOrDefault().Value;
HttpMethod httpMethod = APIUtilities.GetHttpMethodFromText(apiTestElement.Attributes("HttpMethod").FirstOrDefault().Value);
bool includeDateInHttpHeader = true;
XAttribute includeDateInHeader = apiTestElement.Attributes("IncludeDateInHeader").FirstOrDefault();
if (includeDateInHeader != null)
{
includeDateInHttpHeader = bool.Parse(includeDateInHeader.Value);
}
// Set Base URI in ClinetState object from querying XElement
ClientState.BaseURI = RetrieveBaseURI(XmlNamespace, this.xmlConfig, apiTestElement.Attributes("BaseUriId").FirstOrDefault().Value);
// Retrieve Request Content before request is submitted to API
XElement requestContent = apiTestElement.Elements(XmlNamespace + "RequestContent").FirstOrDefault();
string request = string.Empty;
string requestFormatted = string.Empty;
if (requestContent != null)
{
request = requestContent.Value;
requestFormatted = new Regex(ClientState.RemoveNewLineRegEx).Replace(request, ""); // Removing New Lines before sent to API
}
// Create API Test Case Object
APIEndpointExecuter apiTestRun = new APIEndpointExecuter(string.Format("{0}{1}", ClientState.BaseURI, uri), httpMethod);
// Retrieve Expected Response
string expectedResponse = apiTestElement.Elements(XmlNamespace + "ExpectedResponse").FirstOrDefault().Value;
string expectedResponseFormatted = new Regex(ClientState.RemoveNewLineAndWhiteSpaceRegEx).Replace(expectedResponse, ""); // remove new lines and whitespace before comparing with actual response
HttpStatusCode expectedStatusCode = ((HttpStatusCode)(Convert.ToInt32(apiTestElement.Elements(XmlNamespace + "ExpectedStatusCode").FirstOrDefault().Value)));
DateTime requestTime = DateTime.Now;
APIEndpointExecuterResult apiTestRunResult = await apiTestRun.Run(new Regex(ClientState.RemoveNewLineRegEx).Replace(request, ""), includeDateInHttpHeader);
string actualResponseFormatted = new Regex(ClientState.RemoveNewLineAndWhiteSpaceRegEx).Replace(apiTestRunResult.ResponseContent, ""); // remove new lines and whitespace before comparing with expected response
DateTime responseTime = DateTime.Now;
HttpStatusCode actualStatusCode = apiTestRunResult.Response.StatusCode;
bool testPassed = (actualStatusCode.Equals(expectedStatusCode) && actualResponseFormatted.Equals(expectedResponseFormatted));
if (testPassed)
{
TotalPassed += 1;
}
else
{
TotalFailed += 1;
this.FailedTestLists.Add(string.Format("Test: {0} (Suite: {1})", apiTestId, suite));
}
resultsListBox.Items.Add(new ListBoxItem(testPassed ? Color.Green : Color.Red, String.Format(" ApiTest: {0} {1}", apiTestId, testPassed ? "PASSED" : "FAILED")));
resultsListBox.SelectedIndex = resultsListBox.Items.Count - 1;
// format request and expected response for log
string requestFormattedWithNewLines = new Regex(ClientState.RemoveNewLineRegEx).Replace(request, Environment.NewLine); // add new lines for readability purposes for log
string expectedResponseFormattedWithNewLines = new Regex(ClientState.RemoveNewLineRegEx).Replace(expectedResponse, Environment.NewLine); // add new lines for readability purposes for log
// Update Log
UpdateLog(suite, apiTestId, testPassed, apiTestRun, apiTestRunResult, requestFormattedWithNewLines, expectedStatusCode, expectedResponseFormattedWithNewLines, apiTestRunResult.ResponseContent, requestTime, responseTime);
}
