public static string FillFailedRunsHtmlTemplate(bool isAlternateRow, TestSummary testSummary, string rowTemplate)
{
StringBuilder sbTestres = new StringBuilder();
string[] statusIcons = { "ü", "ä", "û", "a" };
string alternateRowCss = (isAlternateRow ? "ms-Grid-row-ms-bgColor-neutralLighterAlt" : "ms-Grid-row-ms-bgColor-neutralLighter");
string rootUrl = ConfigurationManager.AppSettings["ida:PostLogoutRedirectUri"];
if (rootUrl[rootUrl.Length - 1] == '/')
{
rootUrl = rootUrl.Remove(rootUrl.Length - 1);
}
return(String.Format(rowTemplate,
rootUrl,
testSummary.Id,
statusIcons[testSummary.Outcome],
testSummary.TestCasename,
GetTestDuration(testSummary.TestDuration),
testSummary.Error,
testSummary.Branch,
alternateRowCss,
testSummary.Configuration,
GetTestDate(testSummary.Testdate)));
}
private void SaveToFile(TestSummary testSummary)
{
if (!Directory.Exists(StoredProcedureTesterConsts.FilePath))
{
Directory.CreateDirectory(@"C:/Temp/StoredProcedureTester");
}
var path = Path.Combine(StoredProcedureTesterConsts.FilePath, StoredProcedureTesterConsts.Filename);
if (File.Exists(path))
{
using (var tw = new StreamWriter(path, true))
{
tw.WriteLine($"{testSummary.ToCsv()}");
}
}
else
{
using (var fs = File.Create(path))
{
}
using (var tw = new StreamWriter(path, true))
{
tw.WriteLine($"Date, Database Name, Unoptimised Stored Procedure Name, Optimised Stored Procedure Name, Unoptimised Total Speed (ms), Optimised Total Speed (ms), Difference (ms), Difference (%), Result");
tw.WriteLine($"{testSummary.ToCsv()}");
}
}
}
async void DoWorkAsync(object state)
{
var tesReportGeneratorFactory = new TestReportGeneratorFactory(this.storage);
List <ITestReportMetadata> reportMetadataList = await Settings.Current.GetReportMetadataListAsync(this.logger);
ITestResultReport[] testResultReports = await TestReportUtil.GenerateTestResultReportsAsync(Settings.Current.TrackingId, reportMetadataList, tesReportGeneratorFactory, this.logger);
if (testResultReports.Length == 0)
{
this.logger.LogInformation("No test result report is generated.");
return;
}
var testSummary = new TestSummary(testResultReports);
string reportsContent = JsonConvert.SerializeObject(testSummary, Formatting.Indented);
this.logger.LogInformation($"Test result report{Environment.NewLine}{reportsContent}");
await AzureLogAnalytics.Instance.PostAsync(
Settings.Current.LogAnalyticsWorkspaceId,
Settings.Current.LogAnalyticsSharedKey,
reportsContent,
Settings.Current.LogAnalyticsLogType);
this.logger.LogInformation("Successfully send reports to LogAnalytics");
}
public IActionResult SubmitTest()
{
int testId = 0;
if (Request.Cookies["testId"] != null)
{
testId = Convert.ToInt32(Request.Cookies["testId"]);
}
int currentUserId = 0;
if (Request.Cookies["Id"] != null)
{
currentUserId = Convert.ToInt32(Request.Cookies["Id"]);
}
int result = rnd.Next(0, 101);
TestSummary testSummary = new TestSummary
{
OwnerUserId = currentUserId,
TestId = testId,
Points = result,
CreatedDateTime = DateTime.Now
};
db.TestsResults.Add(testSummary);
db.SaveChanges();
return(RedirectToAction("Message", new { s = "Your result: " + result + "!" }));
}
public bool ExportData(TestSummary testSummaryCollection,
UnitTestResultCollection unitTestResultCollection,
string fileName, bool isIncludeOutput)
{
GenerateReport(unitTestResultCollection, testSummaryCollection, fileName, isIncludeOutput);
return(true);
}
private static void CreateSummaryHeaders(Document ws, TestSummary collection)
{
PdfPTable table = new PdfPTable(4);
PdfPCell headerCell = new PdfPCell(new Phrase("Summary"));
headerCell.Colspan = 4;
headerCell.HorizontalAlignment = 1; //0=Left, 1=Centre, 2=Right
headerCell.BackgroundColor = BaseColor.GREEN;
table.AddCell(headerCell);
table.AddCell("TotalTestCaseRun");
table.AddCell("Passed");
table.AddCell("Failed");
table.AddCell("Inconclusive");
table.AddCell(collection.TotalTestCaseRun.ToString());
table.AddCell(collection.Passed.ToString());
table.AddCell(collection.Failed.ToString());
table.AddCell(collection.Inconclusive.ToString());
table.SpacingBefore = 20f;
table.SpacingAfter = 20f;
ws.Add(table);
}
public void Push(Guid projectWatcherId, Guid reportId, TestSummary testSummary)
{
var template = ToastNotificationManager.GetTemplateContent(ToastTemplateType.ToastText01);
var launchAttribute = template.CreateAttribute(Launch);
var data = _jsonService.Serialize(new CallbackData
{
ProjectWatcherId = projectWatcherId,
ReportId = reportId
});
launchAttribute.Value = data;
template.DocumentElement.SetAttributeNode(launchAttribute);
var textNodes = template.GetElementsByTagName("text");
textNodes.Item(0).InnerText = testSummary.ToString();
var notification = new ToastNotification(template);
notification.ExpirationTime = DateTimeOffset.Now.AddSeconds(30);
notification.Activated += NotificationActivated;
_toastNotifier.Show(notification);
}
public async Task <TestSummary> Run(StoredProcedureTest currentTest, bool isRetry)
{
if (!isRetry)
{
_sqlBuilder.ResetSql();
}
_sqlBuilder.BuildSqlQueryText(currentTest);
TestSummary testSummary = await _sqlRunner.RunSqlAsync(currentTest);
return(testSummary);
}
private static async Task <TestSummary> RunStoredProcedureTester(StoredProcedureTest storedProcedureTest = null)
{
if (storedProcedureTest == null)
{
storedProcedureTest = StoredProcedureTestFactory.DefaultTest();
}
SqlTestRunner sqlTestRunner = new SqlTestRunner(new NullLogHelper());
TestSummary testSummary = await sqlTestRunner.Run(storedProcedureTest);
return(testSummary);
}
public CreateTestReportDto Map(TestSummary testSummary, IReadOnlyList <TestDetail> testDetails)
{
return(new CreateTestReportDto
{
TotalNumberOfTests = testSummary.TotalNumberOfTests,
TimeTakenInSecond = testSummary.TimeTakenInSecond,
ProjectName = testSummary.ProjectName,
NumberOfIgnoredTests = testSummary.NumberOfIgnoredTests,
NumberOfPassedTests = testSummary.NumberOfPassedTests,
NumberOfFailedTests = testSummary.NumberOfFailedTests,
TestDetails = _testDetailRequestDtoMapper.Map(testDetails)
});
}
public static void FillTestSummaries(ref NotebookService s)
{
List <TestSummary> _testSummaries = null;
_testSummaries = HttpRuntime.Cache.Get(CacheKey) as List <TestSummary>;
int id = s.TicketRequestID_API;
int id2 = s.TicketRequestID_UI;
if (_testSummaries == null)
{
_testSummaries = new List <TestSummary>();
SqlConnection _conn = null;
using (
_conn =
new SqlConnection(
"Data Source=auto-test-data;Initial Catalog=TestAutomation;Persist Security Info=True;User ID=sa;Password=Kr0ken!;Pooling=True")
)
{
_conn.Open();
var command = _conn.CreateCommand();
command.CommandType = CommandType.Text;
command.CommandText = "select t.ticketid, startdate, tests, passed,t.ticketrequestid,ignored,tsv.version from [TestAutomation].[dbo].[TicketStatusView] tsv, [TestAutomation].[dbo].[Ticket] t where tsv.Tests = tsv.Finished and t.ticketid = tsv.ticketid and t.TicketRequestID in (1089,1090,1091,1093,1094,1095,1472,1473,1474,1475,1476,1477,2214,2215 ) order by ticketid desc";
var reader = command.ExecuteReader();
while (reader.Read())
{
var t = new TestSummary {
Executed = reader.GetDateTime(1), Passed = reader.GetInt32(3)
};
t.TicketID = (int)reader.GetFieldValue <long>(0);
t.NotPassed = reader.GetInt32(2) - t.Passed - reader.GetInt32(5);
t.TicketRequestID = (int)reader.GetFieldValue <long>(4);
t.DetailsUri = string.Format("http://auto-test-data/report/Report.aspx?TicketIDs={0}&Details=true&SortExpr=Failcount desc", t.TicketID);
t.Build = !reader.IsDBNull(6) ? reader.GetString(6) : "(unknown)";
_testSummaries.Add(t);
}
reader.Close();
_conn.Close();
}
HttpRuntime.Cache.Add(CacheKey, _testSummaries, null, DateTime.Now.AddHours(4), Cache.NoSlidingExpiration,
CacheItemPriority.Default, null);
}
s.APITestSummaries = _testSummaries.FindAll(m => m.TicketRequestID == id);
s.UITestSummaries = _testSummaries.FindAll(m => m.TicketRequestID == id2);
}
private void ShowTestSummary(TestSummary summary)
{
var lvi = new ListViewItem(new string[]
{
summary.Integrator,
summary.TestSet,
summary.TargetError.ToString("0.0e00"),
summary.TotalCount.ToString(),
summary.FailedCount.ToString(),
summary.Time.ToString("0"),
summary.FunctionCalls.ToString()
});
listView2.Items.Add(lvi);
}
public async Task SaveResultsToDatabase(TestSummary testSummary)
{
var dbResults = testSummary.TestResults.Select(testResult => new Models.Db.TestResult
{
CorrelationId = testResult.CorrelationId,
DateTime = testResult.StartTime,
Duration = testResult.Duration,
TestRunId = testSummary.Id,
Pass = testResult.Pass,
TestGroup = testResult.TestGroup,
TestName = testResult.TestName
});
await _integreationTestDBService.InsertAsync(dbResults).ConfigureAwait(false);
}
public async Task GenerateTRXReport_Runs_TrxReportServiceGenerateTRXReportCalled()
{
await RunDependencyInjectedTestAsync
(
async (serviceProvider) =>
{
// Arrange
var trxReportServiceMock = serviceProvider.GetMock <ITRXReportService>();
var expectedSummary = "";
trxReportServiceMock
.Setup
(
trxReportService => trxReportService.GenerateTRXReport
(
It.IsAny <TestSummary>()
)
)
.Returns
(
expectedSummary
);
var testSummary = new TestSummary();
var uut = serviceProvider.GetRequiredService <IIntegrationTestService>();
var uutConcrete = (IntegrationTestService)uut;
// Act
var observed = uutConcrete.GenerateTRXReport(testSummary);
// Assert
trxReportServiceMock
.Verify
(
trxReportService => trxReportService.GenerateTRXReport
(
testSummary
),
Times.Once
);
await Task.CompletedTask.ConfigureAwait(false);
},
serviceCollection => ConfigureServices(serviceCollection)
);
}
public void Run(ITestSet tests, IIntegrator integrator, double targetError)
{
listView1.Items.Clear();
var summary = new TestSummary(tests, integrator, targetError);
var functions = tests.GetTestFunctions();
int total = 0, failed = 0;
Util.Tic();
foreach (var item in functions)
{
total++;
try
{
var value = integrator.Integrate(item, targetError);
Console.WriteLine(value);
var result = GetTestResult(item, value);
ShowTestResult(result, targetError);
summary.Add(result);
if (result.HasInvalidValue())
{
failed++;
}
}
catch (Exception e)
{
ProcessError(item, e);
failed++;
}
}
summary.Time = Util.Toc();
summary.TotalCount = total;
summary.FailedCount = failed;
ShowTestSummary(summary);
}
public async Task <TestSummary> RunTests(IEnumerable <Test> tests)
{
var testSummary = new TestSummary();
var tasks = new List <Task <Models.TestAutomation.TestResult> >();
foreach (var test in tests)
{
tasks.Add(Process(test.TestClass, test));
}
;
testSummary.StartDateTime = DateTime.UtcNow;
testSummary.TestResults = (await Task.WhenAll(tasks)).ToList();
testSummary.EndDateTime = DateTime.UtcNow;
testSummary.Id = _guidService.NewGuid().ToString();
return(testSummary);
}
private static void OnCompleteBackTest(TestSummary testSummary)
{
//Save to storage for later use if required
if (_tradesPath != null)
{
DisplayMessage("Saving trades csv...");
testSummary.ToCsv(_tradesPath);
}
if (_reportPath != null)
{
DisplayMessage("Saving report binary...");
testSummary.Save(_reportPath);
}
DisplayMessage("Done");
}
public Guid CreateTestReport(Guid projectWatcherId, TestSummary testSummary, IReadOnlyList <TestDetail> testDetails)
{
var request = _createTestReportDtoMapper.Map(testSummary, testDetails);
var responseMessage = _httpClient.Post(_jsonService, ApiUrlHelper.GetCreateTestReportUrl(projectWatcherId), request);
if (responseMessage.IsSuccessStatusCode)
{
_logger.LogInformation("Api accepted the request");
var responseText = responseMessage.Content.ReadAsStringAsync().GetAwaiter().GetResult();
var result = _jsonService.Deserialize <CreateTestReportResponseDto>(responseText);
return(result.ReportId);
}
throw new Exception("Api failed to accept the request.");
}
public IActionResult PurchaseHistory(int?IdOrder)
{
var tell = _orderService.GetDetailOrder(IdOrder.Value);
var purchaseHistory = new TestSummary();
decimal price = 0;
foreach (var item in tell)
{
var sum = new Summary(item.IdOrder, item.OrderFilm.Date, item.OrderFilm.Time, item.OrderFilm.Amount, item.CreateDate, item.Film.Name, item.Places, item.DeliveryType.TypeDelivery, item.PaymentMethod.MethodType);
price += item.Film.Price.OverallPrice * item.Places.Count();
purchaseHistory.Summ.Add(sum);
}
purchaseHistory.OverallPrice = price;
return(View(purchaseHistory));
}
async void DoWorkAsync(object state)
{
var testReportGeneratorFactory = new TestReportGeneratorFactory(this.storage, Settings.Current.NetworkControllerType, Settings.Current.LongHaulSpecificSettings);
List <ITestReportMetadata> reportMetadataList = await Settings.Current.GetReportMetadataListAsync(this.logger);
ITestResultReport[] testResultReports = await TestReportUtil.GenerateTestResultReportsAsync(Settings.Current.TrackingId, reportMetadataList, testReportGeneratorFactory, this.logger);
if (testResultReports.Length == 0)
{
this.logger.LogInformation("No test result report is generated.");
return;
}
string blobContainerUri = string.Empty;
if (this.serviceSpecificSettings.LogUploadEnabled)
{
try
{
Uri blobContainerWriteUriForLog = await TestReportUtil.GetOrCreateBlobContainerSasUriForLogAsync(this.serviceSpecificSettings.StorageAccountConnectionString);
blobContainerUri = $"{blobContainerWriteUriForLog.Scheme}{Uri.SchemeDelimiter}{blobContainerWriteUriForLog.Authority}{blobContainerWriteUriForLog.AbsolutePath}";
await TestReportUtil.UploadLogsAsync(Settings.Current.IoTHubConnectionString, blobContainerWriteUriForLog, this.logUploadDuration, this.logger);
}
catch (Exception ex)
{
this.logger.LogError(ex, "Exception happened when uploading logs");
}
}
var testSummary = new TestSummary(Settings.Current.TestInfo, testResultReports, blobContainerUri);
string reportsContent = JsonConvert.SerializeObject(testSummary, Formatting.Indented);
this.logger.LogInformation($"Test summary{Environment.NewLine}{reportsContent}");
await AzureLogAnalytics.Instance.PostAsync(
this.serviceSpecificSettings.LogAnalyticsWorkspaceId,
this.serviceSpecificSettings.LogAnalyticsSharedKey,
reportsContent,
this.serviceSpecificSettings.LogAnalyticsLogType);
this.logger.LogInformation("Successfully send reports to LogAnalytics");
}
public string GenerateLog(TestSummary testSummary, bool showSuccessLogsOnSuccess)
{
var logs = new List <string>();
foreach (var testGroup in testSummary.TestResults.GroupBy(e => e.TestsName))
{
logs.Add(testGroup.Key);
logs.Add("");
foreach (var result in testGroup.OrderBy(e => e.TestName))
{
var pass = result.Pass ? "PASS" : "FAIL";
logs.Add($"{ pass } { result.TestName } - { result.CorrelationId }");
if (
result.SuccessLog.Any() &&
(result.Pass && showSuccessLogsOnSuccess) ||
(!result.Pass)
)
{
foreach (var log in result.SuccessLog)
{
logs.Add($"+ {log}");
}
}
if (!result.Pass)
{
logs.Add($"- {result.Exception.Message}");
logs.Add("");
}
if (
result.SuccessLog.Any() &&
result.Pass &&
showSuccessLogsOnSuccess
)
{
logs.Add("");
}
}
logs.Add("");
}
return(String.Join(Environment.NewLine, logs.ToArray()));
}
public async Task <IActionResult> OrderFinish()
{
var user = await _userManager.GetUserAsync(User);
var pom = _orderService.GetSummary(user.Id);
var summary = new TestSummary();
decimal price = 0;
foreach (var item in pom)
{
var sum = new Summary(item.Film.Price.OverallPrice, item.IdTime, item.IdDate, item.Film.Name, item.CartPlaces, item.IdCartFilm);
price += item.Film.Price.OverallPrice * item.CartPlaces.Count();
sum.ChoosePaymentMethod = _orderService.GetAllMethod();
sum.ChooseDeliveryType = _orderService.GetAllDelivery();
summary.Summ.Add(sum);
}
summary.OverallPrice = price;
return(View("Summary", summary));
}
private bool CheckResult(TestSummary testSummary, ResultEnum resultEnum)
{
bool testResult = false;
bool firstTest = resultEnum.HasFlag(ResultEnum.FirstTest);
bool secondTest = resultEnum.HasFlag(ResultEnum.SecondTest);
bool thirdTest = resultEnum.HasFlag(ResultEnum.ThirdTest);
bool fourthTest = resultEnum.HasFlag(ResultEnum.FourthTest);
bool overallTest = resultEnum.HasFlag(ResultEnum.OverallTest);
if (testSummary.FirstTestResult.Result == firstTest &&
testSummary.SecondTestResult.Result == secondTest &&
testSummary.ThirdTestResult.Result == thirdTest &&
testSummary.FourthTestResult.Result == fourthTest &&
testSummary.OverallResult == overallTest)
{
testResult = true;
}
return(testResult);
}
public void Should_Get_Test_Result_For_Failed_Ignored_Message()
{
var testResultMessage = FakeDataHelper.GetFailed_Ignored_Message();
var messageParser = new MessageParser(new TestSummaryParser(), new TestDetailParser());
var testResult = messageParser.GetTestResult(testResultMessage);
var expectedResult = new TestSummary
{
TotalNumberOfTests = 2,
ProjectName = "TestProjectUsedByAutoTestRunner.dll",
NumberOfFailedTests = 1,
NumberOfIgnoredTests = 1,
NumberOfPassedTests = null,
TimeTakenInSecond = 1.7281m
};
testResult.Should().BeEquivalentTo(expectedResult);
}
private static TestSummary GenerateSummaries(IEnumerable <UrlTestStatus> statuses, int days)
{
var hours = days * 24;
var toDate = DateTime.Now.AddHours(hours * -1);
var summaryset = statuses.Where(status => status.StartedDateTime >= toDate).ToList();
var summary = new TestSummary
{
SummaryDescription = days == 1 ? "24 Hours" : $"{days} Days",
AverageDuration = summaryset.Average(s => s.Duration.Milliseconds),
Failed = summaryset.Count(s => !s.Succeeded),
Successful = summaryset.Count(s => s.Succeeded),
FromDate = summaryset.Min(s => s.StartedDateTime),
ToDate = summaryset.Max(s => s.StartedDateTime),
NumberOfTests = summaryset.Count
};
return(summary);
}
private void WriteResultsToUI(TestSummary testSummary)
{
//Results
lFirst.Text =
$"1st Test (Same number of rows returned): {testSummary.FirstTestResult.Result.GetResultString()}";
lSecond.Text =
$"2nd Test (Same number of columns returned): {testSummary.SecondTestResult.Result.GetResultString()}";
lThird.Text =
$"3rd Test (Same columns returned): {testSummary.ThirdTestResult.Result.GetResultString()}";
lFourth.Text =
$"4th Test (Same data returned): {testSummary.FourthTestResult.Result.GetResultString()}";
lOverall.Text = $"Overall Result: {testSummary.OverallResult.GetResultString()}";
//Message
l1st.Text = $"1st Test: {testSummary.FirstTestResult.Message}";
l2nd.Text = $"2nd Test: {testSummary.SecondTestResult.Message}";
l3rd.Text = $"3rd Test: {testSummary.ThirdTestResult.Message}";
l4th.Text = $"4th Test: {testSummary.FourthTestResult.Message}";
//Performance
lUnoptimisedTotalTime.Text =
$"Unoptimised Total Time (ms): {testSummary.UnoptimisedTotalTime.ToString()}";
lOptimisedTotalTime.Text =
$"Optimised Total Time (ms): {testSummary.OptimisedTotalTime.ToString()}";
lDifference.Text = $"Difference (ms):{testSummary.DifferenceTotalTime.ToString()}";
lDifferencePercent.Text = $"Difference (%): {testSummary.DifferencePercentage.ToString()}";
lDateTimeRun.Text = $"Date Time Run: {DateTime.Now.ToString("dd/MM/yy hh:mm:ss")}";
if (testSummary.OverallResult)
{
tabPage5.BackColor = Color.LightGreen;
}
else
{
tabPage5.BackColor = Color.LightCoral;
}
ShowResults();
tabControl1.SelectedIndex = 1;
}
private TestRunSummary TryParseTestRunSummary(XDocument xDocument, TestSummary summary)
{
try
{
var testRunSummary = new TestRunSummary();
testRunSummary.failedCount = summary.failedCount;
testRunSummary.inconclusiveCount = summary.inconclusiveCount;
testRunSummary.notRunCount = summary.notRunCount;
testRunSummary.skippedCount = summary.skippedCount;
testRunSummary.successCount = summary.successCount;
testRunSummary.testsCount = summary.testsCount;
var output = xDocument.Descendants("test-run").ToList <XElement>();
var resultInfo = output[0];
testRunSummary.time = Convert.ToInt64(Convert.ToDouble(resultInfo.Attribute("duration").Value) * 100000);
if (summary.success)
{
testRunSummary.result = 4;
}
else
{
if (summary.failedCount != 0)
{
testRunSummary.result = 5;
}
else if (summary.inconclusiveCount != 0)
{
testRunSummary.result = 0;
}
}
return(testRunSummary);
}
catch (Exception e)
{
string errMsg = "Failed to parse test run summary.";
WriteExceptionConsoleErrorMessage(errMsg, e);
throw;
}
}
private static void GenerateReport(UnitTestResultCollection unitTestResultCollection,
TestSummary testSummaryCollection, string fileName, bool isIncludeOutput)
{
var file = new System.IO.FileInfo(fileName);
if (file.Exists)
{
file.Delete();
}
using (var p = new Document())
{
//set the workbook properties and add a default sheet in it
PdfWriter.GetInstance(p, new FileStream(fileName, FileMode.Create));
SetWorkbookProperties(p);
////Create a sheet
p.Open();
p.AddTitle(unitTestResultCollection.CollectionName.ToString() + " - Test Report");
p.Add(new Paragraph(unitTestResultCollection.CollectionName + " - Trx2Any Report"));
BaseFont bfTimes = BaseFont.CreateFont(BaseFont.TIMES_ROMAN, BaseFont.CP1252, false);
var times = new iTextSharp.text.Font(bfTimes, 8, iTextSharp.text.Font.ITALIC, iTextSharp.text.BaseColor.RED);
p.Add(new Paragraph("This is a report generated by trx2any", times));
//ExcelWorksheet ws = CreateSheet(p, unitTestResultCollection.CollectionName);
DataTable dt = CommonUtilities.CreateDataTable(unitTestResultCollection, isIncludeOutput);
//Create Summary Table
CreateSummaryHeaders(p, testSummaryCollection);
CreateHeader(p, dt);
//CreateData(ws, ref rowIndex, dt);
//ws.Column(dt.Columns.Count).Width = 100;
//p.Save();
p.Close();
}
}
public TestSession Build()
{
if (_archive == null)
{
_archive = new ArchiveBuilder().WithArchiveType(ArchiveType.Noark3).Build();
}
var testSession = new TestSession(_archive);
foreach (var logEntry in _logEntries)
{
testSession.AddLogEntry(logEntry);
}
TestSuite testSuite = new TestSuite();
if (_testRuns.Count != 0)
{
foreach (var testRun in _testRuns)
{
testSuite.AddTestRun(testRun);
}
}
else
{
testSuite.AddTestRun(new TestRunBuilder().Build());
}
testSession.TestSuite = testSuite;
if (_testSummary == null)
{
_testSummary = new TestSummary(0, 0, 0);
}
testSession.TestSummary = _testSummary;
return(testSession);
}
private async Task RunTest(bool isRetry)
{
if (!isTestValid())
{
return;
}
logHelper.Log("Started generation");
currentTest.DatabaseName = tbDBName.Text;
currentTest.UnoptimisedStoredProcedureName = tbUnoptimisedSPName.Text;
currentTest.OptimisedStoredProcedureName = tbOptimisedSPName.Text;
try
{
TestSummary testSummary = await sqlTestRunner.Run(currentTest, isRetry);
tbOutput.Text = testSummary.Test.GeneratedSql;
WriteResultsToUI(testSummary);
}
catch (Exception e)
{
UpdateUIForTestFailed(e.Message);
}
}
