/// <summary>
/// This is the main method which will fetch xml data from Test Manager and parse it
/// and call action method of test driver, and set OR dictionary value for each step.
/// After execution of each step it will call method of reporting and pass step execution result.
/// Updated this method for CSV files.
/// </summary>
/// <param name="testCaseId">Test Case ID</param>
/// <param name="iterationTestCase">Optional field, if non nagetive value is present, that means, it is for child
/// test case that have test data, it is like 1-1, 1-2, 2-4, ...</param>
/// <param name="parentTestCaseId">Optional field, used for child test case data</param>
/// <returns></returns>
private static void ExecuteTestCase(string testCaseId, string iterationTestCase = null, string parentTestCaseId = null, string projectSpecific = null)
{
DataSet xmlTestCaseDataSet = null;
int testCaseIdExists = -1;
string projectSpecificTestCaseFile = string.Empty;
Utility.SetVariable("reusabledefaultfile", testCaseId.Substring(0, testCaseId.IndexOf('.')));
#region Retrieve test case workflow from test manager and set to local dataset
DataSet xmlTestCaseFlow;
try
{
if (projectSpecific == "true")
{
#region project specific reusable test cases fetching
string globalActionFileName = "";
if (!Path.GetExtension(Utility.GetVariable("reusabledefaultfile").ToLower().Trim()).Equals(Property.ExcelSheetExtension.ToLower()))
globalActionFileName = Utility.GetVariable("reusabledefaultfile") + Property.ExcelSheetExtension;
else
globalActionFileName = Utility.GetVariable("reusabledefaultfile").Trim();
string TempglobalActionFileName = globalActionFileName.Substring(0, globalActionFileName.LastIndexOf('.'));
if (Property.TestCaseIdParameter == 0)
projectSpecificTestCaseFile = Common.Utility.GetParameter("TestCaseId");
else
projectSpecificTestCaseFile = Property.TestCaseIdSeperator + TempglobalActionFileName;
_objTestManager = container.Resolve<Manager>(new ResolverOverride[]
{
new ParameterOverride("testCaseId", projectSpecificTestCaseFile), new ParameterOverride("testCasefilename", globalActionFileName)
});
//new Krypton.Manager(projectSpecificTestCaseFile, globalActionFileName);
xmlTestCaseFlow = _objTestManager.GetTestCaseXml(Property.TestQuery,true,false);
//checking if test case id exists in the file or not
for (int drCnt = 0; drCnt < xmlTestCaseFlow.Tables[0].Rows.Count; drCnt++)
{
if (xmlTestCaseFlow.Tables[0].Rows[drCnt][KryptonConstants.TEST_CASE_ID].ToString().Equals(testCaseId, StringComparison.OrdinalIgnoreCase))
{
testCaseIdExists = drCnt;
break;
}
}
if (testCaseIdExists < 0)//if not exists in the main test flow
{
#region KRYPTON0253
string[] sep = { Property.TestCaseIdSeperator};
string[] testFlowSheetName = testCaseId.Split(sep, StringSplitOptions.None);
xmlTestCaseFlow = _objTestManager.GetTestCaseXml(testFlowSheetName[0], false, true);
//checking if test case id exists in the file or not
for (int drCnt = 0; drCnt < xmlTestCaseFlow.Tables[0].Rows.Count; drCnt++)
{
if (xmlTestCaseFlow.Tables[0].Rows[drCnt][KryptonConstants.TEST_CASE_ID].ToString().Equals(testCaseId, StringComparison.OrdinalIgnoreCase))
{
testCaseIdExists = drCnt;
break;
}
}
if (testCaseIdExists < 0)
{
throw new KryptonException(Utility.GetCommonMsgVariable("KRYPTONERRCODE0049") + " [" + testCaseId + "] ", string.Empty);
}
#endregion
}
#endregion
}
else
{
_objTestManager = container.Resolve<Manager>(new ResolverOverride[]
{
new ParameterOverride("testCaseId", testCaseId), new ParameterOverride("testCasefilename", string.Empty)
});
//new Manager(testCaseId);
xmlTestCaseFlow = _objTestManager.GetTestCaseXml(Property.TestQuery, false, false);
//checking if test case id exists in the file or not
for (int drCnt = 0; drCnt < xmlTestCaseFlow.Tables[0].Rows.Count; drCnt++)
{
if (xmlTestCaseFlow.Tables[0].Rows[drCnt][KryptonConstants.TEST_CASE_ID].ToString().Equals(testCaseId, StringComparison.OrdinalIgnoreCase))
{
testCaseIdExists = drCnt;
break;
}
}
if (testCaseIdExists < 0)
{
throw new KryptonException(Utility.GetCommonMsgVariable("KRYPTONERRCODE0049") + " [" + testCaseId + "] ", string.Empty);
}
}
}
catch (Exception exception)
{
using (StreamWriter sw = new StreamWriter(Property.ErrorLog))
{
sw.WriteLine("In catch throw 0049exception 3");
}
throw new KryptonException(Utility.GetCommonMsgVariable("KRYPTONERRCODE0049") + " [" + testCaseId + "] ", exception.Message);
}
#endregion
//Retrieve test case data if required from test manage based on iteration specified
bool isTestDataUsed = false;
int startingDataRow = 1;
int endingDataRow = 1;
if (iterationTestCase.IsNullOrWhiteSpace())
{
isTestDataUsed = false;
}
else
{
#region iteration step separtion
//to fetch iteration step rows
if (iterationTestCase.Contains('-'))
iterationTestCase = iterationTestCase.Replace("-", "^");
string[] strIteration = iterationTestCase.Split('^');
if (Regex.IsMatch(strIteration[0], "([0-9]*)"))
{
startingDataRow = int.Parse(strIteration[0]);
}
if (strIteration.Length > 1)
{
if (Regex.IsMatch(strIteration[1], "([0-9]*)"))
{
endingDataRow = int.Parse(strIteration[1]);
}
}
else
{
endingDataRow = startingDataRow;
}
#endregion
isTestDataUsed = true;
}
string xmlTestCaseName = null; //intialize of test case name
string xmlTestCaseBrowser = null; //intialize of test case browser
//Start a loop for all test data records
for (int testDataCounter = startingDataRow; testDataCounter < endingDataRow + 1; testDataCounter++)
{
//Storing the Iteration number to a Dictionary key 'Iteration'.
Utility.SetVariable("Iteration", testDataCounter.ToString());
if (isTestDataUsed)
{
xmlTestCaseDataSet = null;
}
//to check if the loop reach the starting of the current test case records.
bool currentTestCaseRecords = false;
if (isTestDataUsed)
{
xmlTestCaseDataSet = null;
}
//Start a loop for all test case flow record
for (int caseRowCnt = testCaseIdExists; caseRowCnt < xmlTestCaseFlow.Tables[0].Rows.Count; caseRowCnt++)
{
string xmlTestCaseId = xmlTestCaseFlow.Tables[0].Rows[caseRowCnt][KryptonConstants.TEST_CASE_ID].ToString();
#region to check record for current test case
if (xmlTestCaseId.IsNullOrWhiteSpace() == false && xmlTestCaseId.Equals(testCaseId, StringComparison.OrdinalIgnoreCase))
currentTestCaseRecords = true;
else if (xmlTestCaseId.IsNullOrWhiteSpace() == false && xmlTestCaseId.Equals(testCaseId, StringComparison.OrdinalIgnoreCase) == false)
currentTestCaseRecords = false;
if (xmlTestCaseFlow.Tables[0].Rows[caseRowCnt][KryptonConstants.STEP_ACTION].ToString().Trim().IsNullOrWhiteSpace())
currentTestCaseRecords = false;
if (currentTestCaseRecords == false)
continue;
#endregion
//set test case name attribute to xml log file and that will be call once
if (xmlTestCaseName == null && parentTestCaseId.IsNullOrWhiteSpace())
{
xmlTestCaseName = xmlTestCaseFlow.Tables[0].Rows[caseRowCnt][KryptonConstants.TEST_SCENARIO].ToString();
XmlLog.AddTestAttribute("TestCase Name", xmlTestCaseName);
}
#region variable declaration and set value
string xmlTestCaseStepAction = xmlTestCaseFlow.Tables[0].Rows[caseRowCnt][KryptonConstants.STEP_ACTION].ToString().Trim();
string xmlTestCaseIteration = xmlTestCaseFlow.Tables[0].Rows[caseRowCnt][KryptonConstants.ITERATION].ToString().Trim();
string xmlTestCaseData = xmlTestCaseFlow.Tables[0].Rows[caseRowCnt][KryptonConstants.DATA].ToString().Trim();
string xmlTestCaseObj = xmlTestCaseFlow.Tables[0].Rows[caseRowCnt][KryptonConstants.TEST_OBJECT].ToString().Trim();
string xmlTestCaseParent = xmlTestCaseFlow.Tables[0].Rows[caseRowCnt][KryptonConstants.PARENT].ToString().Trim();
string xmlTestCaseOption = xmlTestCaseFlow.Tables[0].Rows[caseRowCnt][KryptonConstants.OPTIONS].ToString().Trim();
string xmlTestCaseComment = xmlTestCaseFlow.Tables[0].Rows[caseRowCnt][KryptonConstants.COMMENTS].ToString().Trim();
//Replace variables in string here for all columns and pass on
xmlTestCaseStepAction = Utility.ReplaceVariablesInString(xmlTestCaseStepAction);
xmlTestCaseData = Utility.ReplaceVariablesInString(xmlTestCaseData);
xmlTestCaseParent = Utility.ReplaceVariablesInString(xmlTestCaseParent);
xmlTestCaseObj = Utility.ReplaceVariablesInString(xmlTestCaseObj);
xmlTestCaseOption = Utility.ReplaceVariablesInString(xmlTestCaseOption);
xmlTestCaseComment = Utility.ReplaceVariablesInString(xmlTestCaseComment);
xmlTestCaseIteration = Utility.ReplaceVariablesInString(xmlTestCaseIteration);
#endregion
#region Read individual column values from Test Case Flow and pass on to test driver
if (xmlTestCaseStepAction.IsNullOrWhiteSpace() == false && ValidStepOption(xmlTestCaseOption) && Property.EndExecutionFlag != true)
{
string cleanUpString = Utility.GetCleanupTestCase(xmlTestCaseOption, "cleanuptestcaseid"); //capture Clean up test case id with options
if (!cleanUpString.Equals(string.Empty))
_cleanupTestCase = cleanUpString;
if (xmlTestCaseStepAction.Equals("runExcelTestCase", StringComparison.OrdinalIgnoreCase) == true)
{
//iteration method call for internal test case
ExecuteTestCase(xmlTestCaseData, xmlTestCaseIteration, testCaseId, null);
}
else
{
string testCaseData;
if (isTestDataUsed)
{
if (xmlTestCaseDataSet == null) // will call test data method only once
{
#region call to test case data method to fetch corresponding data
try
{
//fetching test data sheet name from the option field in the first line of the nested test case and set for the whole test case
string[] testDataSheet1 = Utility.GetTestMode(xmlTestCaseOption,
"TestDataSheet").Split(',');
var testDataSheet = testDataSheet1.Length > 1 ? testDataSheet1[1] : "test_data";
Property.TestDataSheet = testDataSheet;
if (projectSpecific == "true")
{
xmlTestCaseDataSet = TestCaseData(parentTestCaseId,
testDataCounter.ToString(),
xmlTestCaseObj, true);
}
else
{
xmlTestCaseDataSet = TestCaseData(testCaseId, testDataCounter.ToString(),
xmlTestCaseObj, false);
}
}
catch (Exception exception)
{
_stepNos++;
throw new KryptonException(Utility.GetCommonMsgVariable("KRYPTONERRCODE0050"), exception.Message);
}
#endregion
}
if (xmlTestCaseFlow.Tables[0].Rows[caseRowCnt]["data"].ToString().IsNullOrWhiteSpace() == false)
{
testCaseData = xmlTestCaseFlow.Tables[0].Rows[caseRowCnt]["data"].ToString();
}
else
{
//to fetch by [td] variable
testCaseData = "{$[TD]" + xmlTestCaseObj + "}";
}
}
else
testCaseData = xmlTestCaseData;
#region Handling test data situations for verifyDatabase
if (xmlTestCaseStepAction.Equals("verifyDatabase", StringComparison.OrdinalIgnoreCase))
{
//for data from DBTestData sheet
try
{
DbTestData(testCaseId, xmlTestCaseData, xmlTestCaseObj);
testCaseData = xmlTestCaseData;
}
catch (Exception exception)
{
_stepNos++;
throw new KryptonException(Utility.GetCommonMsgVariable("KRYPTONERRCODE0050"), exception.Message);
}
}
#endregion
testCaseData = testCaseData.Trim();
#region Starting special script based on data given in options column.
string[] scriptToRunContents = Utility.GetTestMode(xmlTestCaseOption, "script").Split(',');
if (scriptToRunContents.Length > 1)
{
var scriptToRun = scriptToRunContents[1].ToLower();
try
{
if (!(scriptToRun.Contains(".exe"))) // Updated to Check if script provided already contains an extension
{
scriptToRun = scriptToRun + ".exe";
}
Console.WriteLine("Executing special script: " + scriptToRun);
Utility.SetProcessParameter(scriptToRun); //Add process name to process array before starting it.
if ((scriptToRun.Equals("KillTPRecoveryforCSA.exe", StringComparison.OrdinalIgnoreCase)) || (scriptToRun.Equals("KillParallelRecovery.exe", StringComparison.OrdinalIgnoreCase)))
{
foreach (Process process in Process.GetProcesses())
{
if (process.ProcessName.Equals("KryptonParallelRecovery", StringComparison.OrdinalIgnoreCase))
{
process.Kill();
break;
}
}
}
else
{
// Create process information and assign data
Process specialScriptProcess = new Process();
specialScriptProcess.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
specialScriptProcess.StartInfo.UseShellExecute = false;
specialScriptProcess.StartInfo.FileName = scriptToRun;
specialScriptProcess.StartInfo.ErrorDialog = false;
// Start the process
specialScriptProcess.Start();
specialScriptProcess.WaitForExit(10000);
}
}
catch (Exception ex)
{
KryptonException.Writeexception(ex);
}
}
#endregion
//Replace variables in string here for all columns and pass on
xmlTestCaseStepAction = Utility.ReplaceVariablesInString(xmlTestCaseStepAction);
xmlTestCaseParent = Utility.ReplaceVariablesInString(xmlTestCaseParent);
xmlTestCaseObj = Utility.ReplaceVariablesInString(xmlTestCaseObj);
xmlTestCaseOption = Utility.ReplaceVariablesInString(xmlTestCaseOption);
xmlTestCaseComment = Utility.ReplaceVariablesInString(xmlTestCaseComment);
xmlTestCaseIteration = Utility.ReplaceVariablesInString(xmlTestCaseIteration);
testCaseData = Utility.ReplaceVariablesInString(testCaseData);
if (xmlTestCaseOption.IndexOf("{append}", StringComparison.OrdinalIgnoreCase) >= 0)
{
testCaseData = Utility.ReplaceVariablesInString("{$" + xmlTestCaseObj + "}") + testCaseData;
}
//Replace variable with special charecters)
if (ValidStepOption(testCaseData) == false) continue;
#region call to TestDriver Action.Do method
try
{
//Initialize Step Log.
Property.InitializeStepLog();
if (xmlTestCaseOption.IndexOf("{optional}", StringComparison.OrdinalIgnoreCase) < 0 && !(xmlTestCaseStepAction.ToLower().Equals("setvariable") && Property.DebugMode.Equals("false")))
{
_stepNos++;
Property.StepNumber = _stepNos.ToString();
}
Console.WriteLine("Parent:" + xmlTestCaseParent);
Console.WriteLine("Object:" + xmlTestCaseObj);
Console.WriteLine("Step Action:" + xmlTestCaseStepAction);
if (testCaseData.IndexOf("{$[TD]", StringComparison.OrdinalIgnoreCase) < 0)
Console.WriteLine("Data:" + testCaseData);
else Console.WriteLine("Data:");
//Set TestDriver object dictionary
TestDriver.Action.ObjDataRow = GetTestOrData(xmlTestCaseParent, xmlTestCaseObj);
// In case of DragAndDrop, there are two objects to be handled simultaneously.
// Set second object dictionary
if (xmlTestCaseStepAction.Equals("DragAndDrop", StringComparison.OrdinalIgnoreCase) == true)
TestDriver.Action.ObjSecondDataRow = GetTestOrData(xmlTestCaseParent, xmlTestCaseData);
if (TestDriver.Action.ObjDataRow.ContainsKey(KryptonConstants.WHAT))
Console.WriteLine("OR Locator:" + TestDriver.Action.ObjDataRow[KryptonConstants.WHAT]);
else
Console.WriteLine("OR Locator:");
Property.ExecutionDate = DateTime.Now.ToString(Utility.GetParameter("DateFormat"));
Property.ExecutionTime = DateTime.Now.ToString(Utility.GetParameter("TimeFormat"));
TestStepAction.Do(xmlTestCaseStepAction, xmlTestCaseParent, xmlTestCaseObj,
testCaseData,
xmlTestCaseOption);
if (xmlTestCaseStepAction.Equals("closeallbrowsers",StringComparison.OrdinalIgnoreCase))
{
Utility.SetVariable("FirefoxProfilePath", Utility.GetParameter("FirefoxProfilePath"));
}
//if action method is not implemented is returned, need to check for project specific functions
if (Property.Remarks.IndexOf(Utility.GetCommonMsgVariable("KRYPTONERRCODE0025"), StringComparison.OrdinalIgnoreCase) >= 0)
{
#region checkprojectspecificfunction
if (xmlTestCaseStepAction.IndexOf(Property.TestCaseIdSeperator,
StringComparison.OrdinalIgnoreCase) >= 0)
{
if (xmlTestCaseOption.IndexOf("{optional}", StringComparison.OrdinalIgnoreCase) < 0)
{
_stepNos--;
}
#region KRYPTON0252
string[] argument = testCaseData.Split(Property.Seprator);
if (argument.Length > 0)
{
for (int argCount = 0; argCount < argument.Length; argCount++)
{
Utility.SetVariable("argument" + (argCount + 1), argument[argCount].Trim());
}
}
#endregion
ExecuteTestCase(xmlTestCaseStepAction, xmlTestCaseIteration, testCaseId,
"true");
continue;
}
#endregion
}
{
bool flag = xmlTestCaseOption.Equals("{NoReporting}") && Property.Status == ExecutionStatus.Fail || xmlTestCaseOption.Equals("{NoReporting}").Equals(false);
if ((xmlTestCaseOption.IndexOf("{optional}", StringComparison.OrdinalIgnoreCase) < 0))
{
if (flag)
{
if (Property.Status == ExecutionStatus.Fail &&
xmlTestCaseStepAction.IndexOf("verify",
StringComparison.OrdinalIgnoreCase) < 0)
{
TestSuiteResult = 1; //process fail
//Increment Failure Count only in case of non optional and non ignored step cases.
_failureCount++;
if ((_failureCount ==
int.Parse(Utility.GetParameter("FailedCountForExit")) &&
int.Parse(Utility.GetParameter("FailedCountForExit")) > 0)
|| Property.EndExecutionFlag == true)
{
if (Property.EndExecutionFlag == true)
Console.WriteLine(ConsoleMessages.MSG_EXCEUTION_ENDS);
else
Console.WriteLine(ConsoleMessages.MSG_FAILURE_EXCEED);
Property.StepComments = xmlTestCaseComment +
": End execution due to nos. of failure(s) exceeds failed counter defined in parameter file -" + _failureCount + ".";
XmlLog.WriteExecutionLog();
Property.EndExecutionFlag = true;
return;
}
Property.StepComments = xmlTestCaseComment;
XmlLog.WriteExecutionLog();
Console.WriteLine("Status:" + Property.Status);
Console.WriteLine("Remarks:" + Property.Remarks);
}
else
{
Property.StepComments = xmlTestCaseComment;
if (!(xmlTestCaseStepAction.ToLower().Equals("setvariable") && Property.DebugMode.Equals("false")))
XmlLog.WriteExecutionLog();
Console.WriteLine("Status:" + Property.Status);
Console.WriteLine("Remarks:" + Property.Remarks);
}
}
}
//set browser attribute to xml log file and that will be call once
if (xmlTestCaseBrowser == null && !Utility.GetVariable(Property.BrowserVersion).Equals("version", StringComparison.OrdinalIgnoreCase))
{
xmlTestCaseBrowser = Utility.GetVariable(Property.BrowserString) + Utility.GetVariable(Property.BrowserVersion);
XmlLog.AddTestAttribute("Browser", Utility.GetVariable(Property.BrowserString) + Utility.GetVariable(Property.BrowserVersion));
}
}
}
catch (ArgumentOutOfRangeException ex)
{
throw new Exception("Syntax error in test input.");
}
catch (Exception exception)
{
throw new Exception(Utility.GetCommonMsgVariable("KRYPTONERRCODE0051").Replace("{MSG}", exception.Message));
}
Console.WriteLine(ConsoleMessages.MSG_DASHED);
if (xmlTestCaseOption.IndexOf("{optional}", StringComparison.OrdinalIgnoreCase) < 0)
{
XmlLog.SaveXmlLog(); //Generation of xml log file
}
#endregion
}
}
}
}
}
/// <summary>
/// This method will copy report files from a temporary location used by Reporting module
/// to a given location that can be used by the QC or XStudio or similar test management modules. It also
/// generates a text file containing all result files' path for XStudio.
/// Source and destination paths will be fetched from the Property.cs file.
/// </summary>
/// <returns>True on success else False</returns>
public static bool UploadTestExecutionResults(List<string> inputTestIds = null)
{
bool res;
try
{
_strResultsSource = new DirectoryInfo(Property.ResultsSourcePath).Parent;
_strResultsDestination = new DirectoryInfo(Property.ResultsDestinationPath);
// Copy all result files from source directory to destination directory.
res = CopyAll(_strResultsSource, _strResultsDestination);
// Create a temporary file to make sure that the copy process has been completed.
bool resFinished = true;
if (_strResultsDestination.Parent != null)
{
StreamWriter sw = new StreamWriter(_strResultsDestination.Parent.FullName + "/ResultCopyCompleted.txt");
sw.WriteLine("Key: Copy Process Completed!");
sw.Close();
}
var directoryInfo = new DirectoryInfo(Property.ResultsSourcePath).Parent;
if (directoryInfo != null)
{
DirectoryInfo drParent = directoryInfo.Parent;
//to check if user wants to keep report history
string fileExt = string.Empty;
if (_strResultsDestination.Name.LastIndexOf('-') >= 0 && Utility.GetParameter("KeepReportHistory").Equals("true", StringComparison.OrdinalIgnoreCase) == true)
fileExt = _strResultsDestination.Name.Substring(_strResultsDestination.Name.LastIndexOf('-'),
_strResultsDestination.Name.Length - _strResultsDestination.Name.LastIndexOf('-'));
string rcProcessId = string.Empty;
if (!string.IsNullOrWhiteSpace(Property.RcProcessId))
rcProcessId = "-" + Property.RcProcessId; //Adding process id for Remote execution
if (drParent != null)
foreach (FileInfo fi in drParent.GetFiles())
{
if (fi.Name.IndexOf("HtmlReport", StringComparison.OrdinalIgnoreCase) >= 0
|| fi.Name.IndexOf("logo", StringComparison.OrdinalIgnoreCase) >= 0
|| fi.Name.IndexOf(Property.ReportZipFileName, StringComparison.OrdinalIgnoreCase) >= 0
|| fi.Name.IndexOf("." + Property.ScriptLanguage, StringComparison.OrdinalIgnoreCase) >= 0)
{
if (fi.Name.IndexOf("mail.html", StringComparison.OrdinalIgnoreCase) >= 0) // no need to copy this file to krypton result folder while sending mail through krypton
continue;
string fileName;
if (fi.Name.IndexOf("logo", StringComparison.OrdinalIgnoreCase) >= 0)
{
fileName = fi.Name;
}
else if (fi.Name.IndexOf("HtmlReport", StringComparison.OrdinalIgnoreCase) >= 0)
{
string htmlFileExt;
if (!string.IsNullOrWhiteSpace(Utility.GetParameter("TestSuite")))
{
htmlFileExt = Utility.GetParameter("TestSuite");
}
else
{
string[] testCaseIds = Utility.GetParameter("TestCaseId").Split(',');
if (testCaseIds.Length > 1) htmlFileExt = testCaseIds[0] + "...multiple";
else htmlFileExt = Utility.GetParameter("TestCaseId");
}
htmlFileExt = htmlFileExt + rcProcessId;
if (fi.Name.IndexOf("HtmlReports", StringComparison.OrdinalIgnoreCase) >= 0)
fileName = fi.Name.Substring(0, fi.Name.LastIndexOf('.')) +
"-" + htmlFileExt + fileExt + "s" + fi.Name.Substring(fi.Name.LastIndexOf('.'), fi.Name.Length - fi.Name.LastIndexOf('.'));
else
fileName = fi.Name.Substring(0, fi.Name.LastIndexOf('.')) +
"-" + htmlFileExt + fileExt + fi.Name.Substring(fi.Name.LastIndexOf('.'), fi.Name.Length - fi.Name.LastIndexOf('.'));
}
else
{
fileName = fi.Name.Substring(0, fi.Name.LastIndexOf('.')) +
fileExt +
fi.Name.Substring(fi.Name.LastIndexOf('.'), fi.Name.Length - fi.Name.LastIndexOf('.'));
}
if (_strResultsDestination.Parent != null)
{
fi.CopyTo(_strResultsDestination.Parent.FullName + "/" + fileName, true);
//if user wants to keep report history, folder name will be different, so need to change links in the html file also
if (string.IsNullOrWhiteSpace(fileExt) == false && fi.Name.Contains("HtmlReport"))
{
string htmlStr = File.ReadAllText(_strResultsDestination.Parent.FullName + "/" + fileName, Encoding.UTF8);
string testCaseId = string.Empty;
//Handle Test Case Id conditions
#region check for test suite
string testSuite = Utility.GetParameter("TestSuite");
if (!string.IsNullOrWhiteSpace(testSuite.Trim()) && string.IsNullOrWhiteSpace(Utility.GetParameter("TestCaseId").Trim()))
{
SetTestFilesLocation(Property.ManagerType); // get ManagerType from property.cs
Manager objTestManagerSuite = new Manager(testSuite);
var testSuiteData = objTestManagerSuite.GetTestCaseXml(Property.TestQuery, false, false);
for (int testCaseCnt = 0; testCaseCnt < testSuiteData.Tables[0].Rows.Count; testCaseCnt++)
{
if (!string.IsNullOrWhiteSpace(testSuiteData.Tables[0].Rows[testCaseCnt][KryptonConstants.TEST_CASE_ID].ToString().Trim()))
{
if (string.IsNullOrWhiteSpace(testCaseId))
testCaseId = testSuiteData.Tables[0].Rows[testCaseCnt][KryptonConstants.TEST_CASE_ID].ToString();
else
testCaseId = testCaseId + "," +
testSuiteData.Tables[0].Rows[testCaseCnt][KryptonConstants.TEST_CASE_ID];
}
}
}
else
{
testCaseId = Utility.GetParameter("TestCaseId");//override testcaseid parameter over test suite
}
#endregion
var testCases = inputTestIds != null ? inputTestIds.ToArray() : testCaseId.Split(',');
string[] testCasesIds = new string[testCases.Length];
int k = 0;
foreach (string testCase in testCases)
{
if (string.Join(";", testCasesIds).Contains(testCase + ";") == false)
{
testCasesIds[k] = testCase;
htmlStr = htmlStr.Replace("href='" + testCase + "\\",
"href='" + testCase + rcProcessId + fileExt + "\\");
k++;
}
}
File.WriteAllText(_strResultsDestination.Parent.FullName + "/" + fileName, htmlStr, Encoding.UTF8);
}
}
}
}
}
int resCheckLimit = 0;
do
{
if (_strResultsDestination.Parent != null && File.Exists(_strResultsDestination.Parent.FullName + "/ResultCopyCompleted.txt"))
{
File.Delete(_strResultsDestination.Parent.FullName + "/ResultCopyCompleted.txt");
resFinished = false;
}
else
{
if (resCheckLimit++ < 6)
Thread.Sleep(5000);
else
resFinished = false;
}
}
while (resFinished);
}
catch (Exception exception)
{
throw new KryptonException("error", exception.Message);
}
var fileUploadPath = Property.ResultsDestinationPath + "/" + (new DirectoryInfo(Property.ResultsSourcePath).Name);
// Extra actions are performed for particular test manager.
switch (_strManagerType.ToLower())
{
case "qc":
// Not Functional yet
break;
case "xstudio":
// XStudio requires a trigger that tells about the end of the execution.
// Generation of test_completed.txt file will notify XStudio.
TestManager.UploadTestResults(_resultFilesList, fileUploadPath);
break;
case "mstestmanager":
// Not Functional yet
TestManager.UploadTestResults(Property.FinalXmlPath, Property.FinalExecutionStatus);
break;
}
return res;
}
/// <summary>
/// This is Main console engine
/// execute test cases and generate log file
/// </summary>
/// <param name="args">console arguments which will override parameter.ini default parameters</param>
/// <returns></returns>
static int Main(string[] args)
{
string version = ConfigurationSettings.AppSettings["Version"];
RegisterDependencies();
Console.Title = "Krypton" + " v" + "2.0.1";
try
{
//To find application startup path.
string applicationPath = Application.StartupPath;
if (applicationPath.Length > 0)
{
Property.ApplicationPath = applicationPath + "\\";
}
else
{
DirectoryInfo dr = new DirectoryInfo("./");
Property.ApplicationPath = dr.FullName;
}
InitializeIniPath(args);
Utility.SetParameter("ApplicationPath", Property.ApplicationPath);
Utility.SetVariable("ApplicationPath", Property.ApplicationPath);
Utility.GetCommonMessageData();
//Parse ini file and put all parameters into global dictionary
#region Adding internal parameter, runbyevents.
/*
Parameter "runbyevents" means, certain methods will run using browser events instead of using native driver implemented methods.
This can also be passed from command line arguments, but is not added in parameter.ini file.
When its value is true, browser events will be used to perform operations instead of native methods.
E.g. arguments[0].click(); will be used instead of testobject.click when this parameter is true
*/
Property.Parameterdic.Add("runbyevents", "false");
Property.Runtimedic.Add("runbyevents", "false");
Utility.SetParameter("keyword", string.Empty);
Utility.SetVariable("keyword", string.Empty);
Utility.SetParameter("currentRelease", "0");
Utility.SetVariable("currentRelease", "0");
if (Path.IsPathRooted(Property.DestinationFolderDownload))
{
Utility.SetParameter("downloadpath", Property.DestinationFolderDownload);
Utility.SetVariable("downloadpath", Property.DestinationFolderDownload);
}
else
{
Utility.SetParameter("downloadpath", string.Concat(Property.ApplicationPath, Property.DestinationFolderDownload));
Utility.SetVariable("downloadpath", string.Concat(Property.ApplicationPath, Property.DestinationFolderDownload));
}
#endregion
Utility.CollectkeyValuePairs();
#region Parse arguments passed to executable. This may over-write ini file parameters, if names are same
if (args.Length != 0)
{
for (int i = 0; i < args.Length; i++)
{
string[] keyValuePair = args[i].Trim().Split('=');
string key = keyValuePair[0].Trim().ToLower();
string value = keyValuePair[1].Trim();
Utility.SetParameter(key, value);
Utility.SetVariable(key, value);
}
}
#endregion
// Set Environment File Paths
Property.EnvironmentFileLocation = Path.IsPathRooted(Utility.GetParameter("EnvironmentFileLocation")) ? Utility.GetParameter("EnvironmentFileLocation") : Path.Combine(Property.IniPath, Utility.GetParameter("EnvironmentFileLocation"));
Utility.UpdateKeyValuePairs();
Utility.ValidateParameters();
Property.RecoveryCount = Convert.ToInt16(Utility.GetParameter("recoverycount"));
// modified to set the value only if it is given in parameters.ini
if (Utility.GetParameter("globaltimeout") != string.Empty)
Property.GlobalTimeOut = Utility.GetParameter("globaltimeout");
//In case manager type is MSTestManager, user can pass on any of the following options:
//MSTestManager,MSTM,MTM,VSTM,VSTestManager
if (Utility.GetParameter("ManagerType").StartsWith("MSTestManager", StringComparison.OrdinalIgnoreCase) ||
Utility.GetParameter("ManagerType").StartsWith("MSTM", StringComparison.OrdinalIgnoreCase) ||
Utility.GetParameter("ManagerType").StartsWith("MTM", StringComparison.OrdinalIgnoreCase) ||
Utility.GetParameter("ManagerType").StartsWith("VSTM", StringComparison.OrdinalIgnoreCase) ||
Utility.GetParameter("ManagerType").StartsWith("VSTestManager", StringComparison.OrdinalIgnoreCase))
{
Utility.SetParameter("ManagerType", "MSTestManager");
Utility.SetVariable("ManagerType", "MSTestManager");
}
//Get browser settings
Utility.InitializeBrowser(Utility.GetParameter(Property.BrowserString));
Property.ApplicationUrl = Utility.GetParameter("ApplicationURL");
int num;
if (Property.Parameterdic.ContainsKey("waitforalert"))
if (!string.IsNullOrEmpty(Utility.GetParameter("Waitforalert")) && int.TryParse(Utility.GetParameter("Waitforalert"), out num))
Property.Waitforalert = int.Parse(Utility.GetParameter("Waitforalert"));
Property.ExcelSheetExtension = Utility.GetParameter("TestCaseFileExtension");
if (!Property.ExcelSheetExtension.StartsWith("."))
{
Property.ExcelSheetExtension = "." + Property.ExcelSheetExtension;
}
//Get Test Case File path
Property.TestCaseFilepath = Path.IsPathRooted(Utility.GetParameter("TestCaseLocation")) ? Utility.GetParameter("TestCaseLocation") : Path.Combine(Property.IniPath, Utility.GetParameter("TestCaseLocation"));
//set the ManagerType
if (Utility.GetParameter("ManagerType").IsNullOrWhiteSpace() == false)
Property.ManagerType = Utility.GetParameter("ManagerType");
if (Utility.GetParameter("ListOfUniqueCharacters").IsNullOrWhiteSpace() == false)
{
Property.ListOfUniqueCharacters = Utility.GetParameter("ListOfUniqueCharacters").Split(',');
}
//Handle Test Case Id conditions
#region check for test suite
if (Utility.GetParameter("TestSuite").Trim().IsNullOrWhiteSpace() && Utility.GetParameter("TestSuite") != string.Empty)
{
Utility.SetParameter("TestSuite", Utility.GetParameter("TestCaseId").Trim().Split('.')[0]);
}
else
{
TestSuite = Utility.GetParameter("TestSuite").Trim();
}
if (Property.Parameterdic["testsuite"] != string.Empty && Property.Parameterdic["testcaseid"] != string.Empty)
{
Property.Runtimedic["testcaseid"] = Property.Parameterdic["testcaseid"];
Utility.SetParameter("TestSuite", string.Empty);
Property.Runtimedic["testsuite"] = string.Empty;
}
if (Utility.GetParameter("TestSuite") != string.Empty)
{
var testsuiteFilePath =
Path.GetFullPath(Property.IniPath + "/" + Utility.GetParameter("TestSuiteLocation") + "/" +
Utility.GetParameter("TestSuite"));
//Read the suite excel file to dataset
DataSet suiteFileDataSet = Manager.GetSuiteDataSet(testsuiteFilePath);
Utility.SetParameter("TestCaseId", Utility.GetTestCaseIdFromSuiteDataset(suiteFileDataSet));
Property.Runtimedic["testcaseid"] = string.Empty;
}
if (!Utility.GetParameter("TestCaseId").Trim().IsNullOrWhiteSpace())
TestSuite = Utility.GetParameter("TestCaseId").Trim().Split('.')[0];
TestCaseId = Utility.GetParameter("TestCaseId");
Manager.IsTestSuite = false;
//Test Cases that Input From the Parameter.ini
#endregion
//Test Cases that are exit in file
string[] matchingTestCase = TestCaseId.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
string finalTestCases = null;
finalTestCases = Property.Runtimedic["testcaseid"];
if (Utility.GetParameter("TestSuite") != string.Empty)
{
finalTestCases = matchingTestCase.Aggregate(finalTestCases, (current, item) => current + "," + item);
finalTestCases = finalTestCases.Substring(1);
}
TestCases = finalTestCases.Split(',');
// Check if there is at least one test case id for test execution
if (TestCases.Length.Equals(0))
{
Console.WriteLine(Exceptions.ERROR_NOTESTCASEFOUND);
return TestSuiteResult;
}
KryptonUtility.SetProjectFilesPaths();
#region to get database from different ini files
string[] sqlConnectionStr = Property.DbConnectionString.Trim().Split(';');
for (int sqlParamCnt = 0; sqlParamCnt < sqlConnectionStr.Length; sqlParamCnt++)
{
if (sqlConnectionStr[sqlParamCnt].Trim().IndexOf("database", StringComparison.OrdinalIgnoreCase) >= 0)
{
string oriDatabase = sqlConnectionStr[sqlParamCnt];
sqlConnectionStr[sqlParamCnt] = Utility.GetParameter("write").IsNullOrWhiteSpace() == false
? "database=" + Utility.GetParameter("write")
: oriDatabase;
Property.SqlConnectionStringWrite = string.Join(";", sqlConnectionStr);
sqlConnectionStr[sqlParamCnt] = Utility.GetParameter("read").IsNullOrWhiteSpace() == false
? "database=" + Utility.GetParameter("read")
: oriDatabase;
Property.SqlConnectionStringRead = string.Join(";", sqlConnectionStr);
}
}
#endregion
//dbtestdata file path
Property.SqlQueryFilePath = Path.IsPathRooted(Utility.GetParameter("DBQueryFilePath")) ? Utility.GetParameter("DBQueryFilePath") : string.Concat(Property.IniPath, Utility.GetParameter("DBQueryFilePath"));
//to split testcaseid for test case excel file
Property.TestCaseIdSeperator = Utility.GetParameter("TestCaseIDSeperator");
//to fetch test case excel file from testcaseid
Property.TestCaseIdParameter = int.Parse(Utility.GetParameter("TestCaseIDParameter"));
Property.DebugMode = Utility.GetParameter("debugmode").Trim();
//for snapshot option
Property.SnapshotOption = Utility.GetParameter("SnapshotOption");
//for remote execution initialization
Property.IsRemoteExecution = Utility.GetParameter("RunRemoteExecution");
//Force snapshot option in case of remote driver
if (Property.IsRemoteExecution.Equals("true") && Property.SnapshotOption.Equals("always"))
{
Property.SnapshotOption = "on page change";
}
Property.RemoteUrl = Utility.GetParameter("RunOnRemoteBrowserUrl");
//for email templates
Property.EmailStartTemplate = Path.IsPathRooted(Utility.GetParameter("EmailStartTemplate")) ? Utility.GetParameter("EmailStartTemplate") : string.Concat(Property.IniPath, Utility.GetParameter("EmailStartTemplate"));
Property.EmailEndTemplate = Path.IsPathRooted(Utility.GetParameter("EmailEndTemplate")) ? Utility.GetParameter("EmailEndTemplate") : string.Concat(Property.IniPath, Utility.GetParameter("EmailEndTemplate"));
//scripting language
if (!Utility.GetVariable("ScriptLanguage").IsNullOrWhiteSpace())
Property.ScriptLanguage = Utility.GetVariable("ScriptLanguage");
}
catch (Exception exception)
{
Console.WriteLine(new KryptonException(exception.Message));
return TestSuiteResult;
}
if (!Utility.GetVariable("RCProcessId").IsNullOrWhiteSpace() && !Utility.GetVariable("RCProcessId").Equals("RCProcessId", StringComparison.OrdinalIgnoreCase))
Property.RcProcessId = Utility.GetVariable("RCProcessId");
if (!Utility.GetVariable("RCMachineId").IsNullOrWhiteSpace() && !Utility.GetVariable("RCMachineId").Equals("RCMachineId", StringComparison.OrdinalIgnoreCase))
{
Property.RcMachineId = Utility.GetVariable("RCMachineId");
//Update saucelabs machine status to protect identity of username and api key
if (Property.RcMachineId.ToLower().Contains(KryptonConstants.BROWSER_SAUCELABS))
Property.RcMachineId = KryptonConstants.BROWSER_SAUCELABS;
}
else
{
Property.RcMachineId = Environment.MachineName;
Utility.SetVariable("RCMachineId", Environment.MachineName);
Utility.SetParameter("RCMachineId", Environment.MachineName);
}
if (!Environment.UserName.IsNullOrWhiteSpace())
Property.RcUserName = Environment.UserName; //set logged in username
if (Utility.GetParameter("FailedCountForExit").IsNullOrWhiteSpace())
{
Utility.SetParameter("FailedCountForExit", Property.FailedCountForExit);
}
if (Utility.GetParameter("StartParallelRecovery").IsNullOrWhiteSpace())
{
Utility.SetParameter("StartParallelRecovery", Property.StartParallelRecovery);
}
Property.Date_Time = Utility.GetParameter("DateTimeFormat").Replace("/", "\\/");
//Execution start date and time set
DateTime dtNow = DateTime.Now;
#region source path location and clear temp folder
var sourcePath = "KRYPTONResults-" + Guid.NewGuid();
//HTML File location
Property.HtmlFileLocation = string.Format("{0}{1}", Path.GetTempPath(), sourcePath);
Property.ListOfFilesInTempFolder.Add(Property.HtmlFileLocation);
#endregion
Property.ExecutionStartDateTime = dtNow.ToString(Property.Date_Time);
FilePath = new string[TestCases.Length];
bool validation = false; //need to capture the validation steps so that it will not check for each test case
//when running in batch mode (more than one test case or in test suite), value of this parameter is always true, irrespective of what user specified
if (TestCases.Length > 1) Utility.SetParameter("closebrowseroncompletion", "true");
// final test case id to be stored in final test case variable
Property.FinalTestCase = TestCases[TestCases.Length - 1];
#region Setup Test Environment on Local Workstation
for (int testCaseCnt = 0; testCaseCnt < TestCases.Length; testCaseCnt++)
{
// This section handles setting test environment using command line provided in Environment specific ini files
// Retrieve command to be executed from variables
string envSetupCommand = Utility.GetVariable("EnvironmentSetupBatch");
envSetupCommand = Utility.ReplaceVariablesInString(envSetupCommand);
// Do not attempt to setup environment if no script needs to be executed
if (!(envSetupCommand.IsNullOrWhiteSpace()))
{
if (File.Exists(Path.Combine(Property.EnvironmentFileLocation, envSetupCommand)))
{
Process setupProcess = new Process
{
StartInfo =
{
WindowStyle = ProcessWindowStyle.Hidden,
UseShellExecute = false,
FileName = Path.Combine(Property.EnvironmentFileLocation, envSetupCommand),
ErrorDialog = false,
Arguments = Utility.GetParameter("Browser") +
" " + Utility.GetParameter("Environment") +
" " + "\"" + Utility.GetParameter("TestSuite").Trim() + "\"" +
" " + "\"" + Property.RcProcessId + "\""
}
};
//Pass on couple of extra arguments to setup batch file
//These includes BrowserType, TestEnvironment
// Start the process
setupProcess.Start();
setupProcess.WaitForExit();
try
{
if (!setupProcess.HasExited)
{
setupProcess.Kill();
}
}
catch (Exception e)
{
KryptonException.Writeexception(e);
}
}
else
{
Console.WriteLine(new KryptonException("Environment file: " + Property.ApplicationPath + envSetupCommand + " is not exist."));
return TestSuiteResult;
}
}
#endregion
string logDestinationExt = string.Empty;
if (Utility.GetParameter("KeepReportHistory").Equals("true", StringComparison.OrdinalIgnoreCase))
{
logDestinationExt = "-" + dtNow.ToString("ddMMyyhhmmss");
Property.DateTime = logDestinationExt;
}
Property.ResultsSourcePath = string.Format("{0}{1}\\{2}\\{3}", Path.GetTempPath(), sourcePath, TestCases[testCaseCnt].Trim(),
(testCaseCnt + 1).ToString());
//if user wants to keep report history, it will be available with dateandtime appended in the log destination folder
if (!Property.RcProcessId.IsNullOrWhiteSpace())
logDestinationExt = "-" + Property.RcProcessId + logDestinationExt;
if (Path.IsPathRooted(Utility.GetParameter("LogDestinationFolder")))
Property.ResultsDestinationPath = string.Format("{0}\\{1}{2}", Utility.GetParameter("LogDestinationFolder"),
TestCases[testCaseCnt].Trim(), logDestinationExt);
else
Property.ResultsDestinationPath = string.Format("{0}\\{1}{2}", string.Concat(Property.IniPath,
Utility.GetParameter("LogDestinationFolder")),
TestCases[testCaseCnt].Trim(), logDestinationExt);
//Initialize the logwriter to record any message/exception after test step completion
try
{
Logwriter = container.Resolve<IKryptonLogger>(new ResolverOverride[]
{
new ParameterOverride("testcasecnt",testCaseCnt)
});
//new KryptonFileLogWriter(testCaseCnt);
}
catch (Exception e)
{
KryptonException.Writeexception(e);
Console.WriteLine(Exceptions.ERROR_INVALIDTESTID + TestCases[testCaseCnt] + "in Test Suite: " + TestSuite); // If test case Id will be of more than 255 characters..
return TestSuiteResult;
}
#region Creating the xml log file path
try
{
FilePath[testCaseCnt] = string.Format("{0}\\{1}", Property.ResultsSourcePath, Property.LogFileName);
Reporting.LogFile.filePathName = FilePath[testCaseCnt];
XmlLog = Reporting.LogFile.Instance; //xml log file initialization
XmlLog.AddTestAttribute("TestCase Id", TestCases[testCaseCnt].Trim());
if (!Property.RcMachineId.IsNullOrWhiteSpace())
XmlLog.AddTestAttribute("RCMachineId", Property.RcMachineId);
}
catch (Exception exception)
{
Console.WriteLine(new KryptonException(exception.Message));
return TestSuiteResult;
}
#endregion
Property.ValidateSetup = Utility.GetParameter("ValidateSetup");
if (Property.ValidateSetup.Equals("true", StringComparison.OrdinalIgnoreCase))
{
#region validation
//once it validates it will not run for each test case
try
{
if (validation != true)
{
Validate.GetDriverValidation(
Utility.GetParameter(Property.DriverString).ToLower());
Property.Status = Validate.validate.ValidationProcess();
if (Property.Status == ExecutionStatus.Fail)
{
ReportHandler.WriteExceptionLog(new KryptonException("Validation Faild"), 0, "Validation");
return TestSuiteResult;
}
validation = true;
}
}
catch (Exception exception)
{
ReportHandler.WriteExceptionLog(new KryptonException(exception.Message), 0, "Validation");
return TestSuiteResult;
}
#endregion
}
else
{
validation = true;
}
//Added code for focus mouse to origin
if (testCaseCnt == 0 && Property.IsRemoteExecution.ToLower().Equals("false"))
{
Cursor.Position = new Point(0, 0);
}
_objTestManager = container.Resolve<Manager>(new ResolverOverride[]
{
new ParameterOverride("testCaseId", TestCases[testCaseCnt].Trim()), new ParameterOverride("testCasefilename", string.Empty)
});
//Call InitExecution method to allow manager pass on control
//to respective test manager for required settings
try
{
Manager.InitTestCaseExecution();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
#region Fetch OR data
////if OR data is fetched, this step will not execute for each test case
DataSet xmlRecoverFromPopupFlow = new DataSet();
DataSet xmlRecoverFromBrowserFlow = new DataSet();
try
{
if (_orTestData == null)
{
if (!Path.GetExtension(Utility.GetParameter("ORFileName")).ToLower().Equals(Property.ExcelSheetExtension.ToLower()))
Property.ObjectRepositoryFilename = Utility.GetParameter("ORFileName").ToLower() + Property.ExcelSheetExtension;
else
Property.ObjectRepositoryFilename = Utility.GetParameter("ORFileName").ToLower();
Manager.SetTestFilesLocation(Property.ManagerType); // get ManagerType from property.cs
OrData(); //To Fetch object Repository data and set in private global dataset
if (testCaseCnt == 0 && !Utility.GetParameter("RunRemoteExecution").ToLower().Equals("true"))
{
//reading RecoverPopup File.
xmlRecoverFromPopupFlow = _objTestManager.GetRecoverFromPopupXml();
xmlRecoverFromBrowserFlow = _objTestManager.GetRecoverFromBrowserXml();
#region Start Exe for Popups handling.
try
{
if (String.Compare(Utility.GetVariable("StartParallelRecovery"), "true", StringComparison.OrdinalIgnoreCase) == 0)
{
string ext = Path.GetExtension(Property.ParallelRecoverySheetName);
if (string.IsNullOrEmpty(ext))
Property.ParallelRecoverySheetName = Property.ParallelRecoverySheetName + Property.ExcelSheetExtension;
if (!File.Exists(Path.Combine(Property.RecoverFromPopupFilepath, Property.ParallelRecoverySheetName)))
{
Console.WriteLine(ConsoleMessages.MSG_PARALLEL_RECOVERY);
Console.WriteLine("Please make sure " + Property.ParallelRecoverySheetName + " exist at " + Property.RecoverFromPopupFilepath + " directory.");
return TestSuiteResult;
}
ProcessStartInfo processInfo = new ProcessStartInfo
{
FileName = Property.ApplicationPath + "KryptonParallelRecovery.exe",
CreateNoWindow = true,
WindowStyle = ProcessWindowStyle.Hidden,
Arguments =
"\"" + Property.RecoverFromPopupFilepath + "/" +
Property.ParallelRecoverySheetName + "\"" +
" " + "\"" + Property.Popup_Sheetname + "\"" +
" " + Process.GetCurrentProcess().Id
};
Utility.SetProcessParameter("KryptonParallelRecovery.exe");
Process parallelProcess = Process.Start(processInfo);
Thread.Sleep(1000);
if (parallelProcess.Id == 0 || parallelProcess.HasExited)
{
Console.WriteLine(Exceptions.ERROR_AUTOIT);
Console.WriteLine(Exceptions.ERROR_RECOVERY);
return TestSuiteResult;
}
}
}
catch (Exception e)
{
//Please register AutoIt dll
Console.WriteLine(Exceptions.ERROR_RECOVERY + e.Message);
Console.WriteLine(Exceptions.ERROR_AUTOIT);
return TestSuiteResult;
}
#endregion
}
}
}
catch (Exception exception)
{
ReportHandler.WriteExceptionLog(new KryptonException(exception.Message), 0, Exceptions.ERROR_OBJECTREPOSITORY);
return TestSuiteResult;
}
#endregion
if (TestStepAction == null) //so that driver will not initialize every time
TestStepAction = new TestDriver.Action(xmlRecoverFromPopupFlow, xmlRecoverFromBrowserFlow, _orTestData);
try
{
DateTime dtNow1 = DateTime.Now;
XmlLog.AddTestAttribute("ExecutionStartTime", dtNow1.ToString(Property.Date_Time));
Console.WriteLine(ConsoleMessages.MSG_DASHED);
Console.WriteLine("Starting Test Case: " + TestCases[testCaseCnt].Trim());
Console.WriteLine(ConsoleMessages.MSG_DASHED);
_failureCount = 0;
_stepNos = 0; //initialize the counter
Property.EndExecutionFlag = false;
ExecuteTestCase(TestCases[testCaseCnt].Trim()); //actual test flow
Property.EndExecutionFlag = false;
//Shutting down the driver if CloseBrowserOnCompletion is set to true.
if (Utility.GetParameter("closebrowseroncompletion").ToLower().Trim().Equals("true") || TestCases.Length > 1)
TestStepAction.Do("closeallbrowsers", "", "", "", "");
Console.WriteLine(ConsoleMessages.MSG_DASHED);
#region cleanup test flow
string[] cleanupCase = _cleanupTestCase.Split(',');
string cleanupTestCaseId = string.Empty;
if (cleanupCase.Length > 0 && cleanupCase[0].ToLower().Contains("cleanuptestcaseid"))
{
cleanupTestCaseId = cleanupCase[0].Split('=')[1].Replace("\"", "");
}
if (cleanupCase.Length > 1 && cleanupCase[1].ToLower().Contains("data"))
{
string[] argument = cleanupTestCaseId.Split(Property.Seprator);
for (int argCount = 0; argCount < argument.Length; argCount++)
{
Utility.SetVariable("argument" + (argCount + 1), argument[argCount].Trim());
}
}
string cleanupTestCaseIteration = null;
if (cleanupCase.Length > 2 && cleanupCase[2].ToLower().Contains("iteration"))
{
cleanupTestCaseIteration = cleanupCase[2].Split('=')[1].Replace("\"", ""); ;
}
if (cleanupTestCaseId.IsNullOrWhiteSpace() == false)
ExecuteTestCase(cleanupTestCaseId, cleanupTestCaseIteration, TestCaseId, "true");
#endregion
Console.WriteLine("Ending Test Case: " + TestCases[testCaseCnt].Trim());
Console.WriteLine(ConsoleMessages.MSG_DASHED);
XmlLog.AddTestAttribute("RCMachineId", Property.RcMachineId);
Utility.ClearRunTimeDic(); //clear run time dictionary and copy parameter dictionary in run time dictionary
//Calculate test execution duration
TimeSpan tcDurationSpan = (DateTime.Now - dtNow1);
TimeSpan tcDuration = new TimeSpan(tcDurationSpan.Hours, tcDurationSpan.Minutes, tcDurationSpan.Seconds);
XmlLog.AddTestAttribute("ExecutionDuration", tcDuration.ToString());
Console.WriteLine("Total test execution duration was " + tcDuration);
dtNow1 = DateTime.Now;
XmlLog.AddTestAttribute("ExecutionEndTime", dtNow1.ToString(Property.Date_Time));
XmlLog.AddTestAttribute("SauceJobUrl", Property.JobUrl);
}
catch (Exception exception)
{
ReportHandler.WriteExceptionLog(new KryptonException(exception.Message), _stepNos, "Execute Test Case");
}
Console.WriteLine(ConsoleMessages.MSG_DASHED);
Console.WriteLine(ConsoleMessages.MSG_EXCECUTION_COMPLETE_LOG);
Console.WriteLine(ConsoleMessages.MSG_DASHED);
try
{
//Generation of xml log file.snapshot
XmlLog.SaveXmlLog();
//for the last step all the file will upload after generation of html file.
if (testCaseCnt < TestCases.Length - 1)
Manager.UploadTestExecutionResults();
}
catch (Exception ex)
{
Logwriter.WriteLog("Message:-" + ex.Message + " InnerException:-" + ex.InnerException + " StackTrace:-" + ex.StackTrace);
}
#region for Angieslist: Batch command to execution on test completion
try
{
string testFinishCommand = Utility.GetVariable("TestCleanupBatch");
testFinishCommand = Utility.ReplaceVariablesInString(testFinishCommand);
if (!(testFinishCommand.IsNullOrWhiteSpace()))
{
testFinishCommand = Path.Combine(Property.ApplicationPath, testFinishCommand);
if (File.Exists(testFinishCommand))
{
//Create process information and assign data
Process setupProcess = new Process
{
StartInfo =
{
WindowStyle = ProcessWindowStyle.Hidden,
UseShellExecute = false,
FileName = testFinishCommand,
WorkingDirectory = Property.ApplicationPath,
ErrorDialog = false,
Arguments = Property.RcProcessId +
" " + "\"" + XmlLog.ExecutedXmlPath + "\""
}
};
// Start the process
setupProcess.Start();
//No need to wait for process to exit
setupProcess.WaitForExit(10000);
}
}
}
catch (Exception e)
{
Console.WriteLine(Exceptions.ERROR_CLEANUP + e.Message);
}
#endregion
}
//Stoping the IE Popup Thread after execution.
ExecuteThread = false;
#region Killing all the processes started by Krypton Application during execution.
try
{
string[] procesesToKill = Utility.GetAllProcesses();
foreach (string proc in procesesToKill)
{
foreach (Process process in Process.GetProcessesByName(proc.Substring(0, proc.LastIndexOf('.'))))
{
try
{
process.Kill();
process.WaitForExit(10000);
}
catch (Exception ex)
{
Logwriter.WriteLog("Message:-" + ex.Message + " InnerException:-" + ex.InnerException + " StackTrace:-" + ex.StackTrace);
}
}
}
}
catch (Exception ex)
{
Logwriter.WriteLog("Message:-" + ex.Message + " InnerException:-" + ex.InnerException + " StackTrace:-" + ex.StackTrace);
}
#endregion
//Shutting down the driver if CloseBrowserOnCompletion is set to true.
if (Utility.GetParameter("Browser").Equals(KryptonConstants.BROWSER_FIREFOX, StringComparison.OrdinalIgnoreCase))
{
}
if (!Utility.GetVariable("RCProcessId").IsNullOrWhiteSpace() && !Utility.GetVariable("RCProcessId").Equals("RCProcessId", StringComparison.OrdinalIgnoreCase))
TestStepAction.Do("shutdowndriver"); //shutdown driver process running in remote
TestDriver.Action.SaveScript();
Console.WriteLine(ConsoleMessages.MSG_EXCECUTION_COMPLETED_HTML);
//Execution end date and time set
dtNow = DateTime.Now;
Property.ExecutionEndDateTime = dtNow.ToString(Property.Date_Time);
try
{
ReportHandler.CreateHtmlReportSteps(MLstInputTestCaseIDs);
}
catch (Exception ex)
{
Logwriter.WriteLog("Message:-" + ex.Message + " InnerException:-" + ex.InnerException + " StackTrace:-" + ex.StackTrace);
return TestSuiteResult;
}
#region Delete temp folder.
/*List Of files that would be deleted here are :
1. Text file for Error message storage that would be generated per test suit.(Size in KB).
2. WebDriver Profile Folder that would be generated per test case.(Size ~ 23MB).
*/
try
{
foreach (string file in Property.ListOfFilesInTempFolder)
{
if (Directory.Exists(file))
{
Directory.Delete(file, true);
}
if (File.Exists(file))
{
File.Delete(file);
}
}
}
catch (IOException ex)
{
Logwriter.WriteLog("IO Exception Message:-" + ex.Message + " InnerException:-" + ex.InnerException + " StackTrace:-" + ex.StackTrace);
}
catch (Exception ex)
{
Console.WriteLine(Utility.GetCommonMsgVariable("KRYPTONERRCODE0048"));
Logwriter.WriteLog("Message:-" + ex.Message + " InnerException:-" + ex.InnerException + " StackTrace:-" + ex.StackTrace);
}
#endregion
Process[] allProcess = Process.GetProcesses();
foreach (Process process in allProcess)
{
if (process.ProcessName.Equals(KryptonConstants.CHROME_DRIVER, StringComparison.OrdinalIgnoreCase))
{
process.Kill();
}
if (process.ProcessName.Equals(KryptonConstants.IE_DRIVER, StringComparison.OrdinalIgnoreCase))
{
process.Kill();
}
}
using (StreamWriter sw = new StreamWriter(Property.ErrorLog))
{
sw.WriteLine("Task3");
}
//Wait for user input at the end of the execution is handled by configuration file
if (string.Equals(Utility.GetParameter("EndExecutionWaitRequired"), "false", StringComparison.OrdinalIgnoreCase))
{
Array.ForEach(Process.GetProcessesByName("cmd"), x => x.Kill());
}
return TestSuiteResult;
}
