public override void ExecuteTask(ISpecialExecutionTaskTestAction testAction)
{
IParameter IPfile = testAction.GetParameter("File", false, new[] { ActionMode.Input });
IParameter IPinverse = testAction.GetParameter("Exists", false, new[] { ActionMode.Input });
string file = IPfile.GetAsInputValue().Value;
string inverseString = IPinverse.GetAsInputValue().Value;
bool fileExists; // if this is true, the file should exists. Default value should be true
bool result;
bool success = Boolean.TryParse(inverseString, out fileExists);
if (!success)
{
testAction.SetResult(SpecialExecutionTaskResultState.Failed, "Inverse has to be an boolean");
return;
}
if (FileOrDirectoryExists(file))
{
result = fileExists; //if the file is found, the value of fileExists will be returned.
}
else
{
result = !fileExists; //if the file is not found, the inverse of fileExists will be returned.
}
if (result)
{
testAction.SetResult(SpecialExecutionTaskResultState.Ok, "Correct");
return;
}
testAction.SetResult(SpecialExecutionTaskResultState.Failed, "Incorrect");
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
String paraSettingsFile = testAction.GetParameterAsInputValue("File", false).Value;
if (string.IsNullOrEmpty(paraSettingsFile))
{
throw new ArgumentException(string.Format("Es muss eine Settingsdatei (File) angegeben sein."));
}
if (!Collections.Instance.CollectionExists(BufferCollectionPath))
{
throw new InvalidOperationException("Es existiert keine Buffer-Collection in den Einstellungen!");
}
XmlDocument doc = new XmlDocument();
doc.Load(paraSettingsFile);
XmlNode SettingsListNode = doc.SelectSingleNode("/root");
XmlNodeList SettingsNodeList = SettingsListNode.SelectNodes("CollectionEntry");
foreach (XmlNode node in SettingsNodeList)
{
string key = node.Attributes.GetNamedItem("name").Value;
string value = node.InnerText;
Buffers.Instance.SetBuffer(key, value, false);
}
return(new PassedActionResult("settings loaded from : " + paraSettingsFile));
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
String endPoint = testAction.GetParameterAsInputValue("EndPoint", false).Value;
String repositoryName = testAction.GetParameterAsInputValue("Repository", false).Value;
if (string.IsNullOrEmpty(endPoint))
{
throw new ArgumentException("End Point is a mandatory parameter.");
}
else
{
if (!endPoint.EndsWith("/"))
{
endPoint += "/";
}
}
if (string.IsNullOrEmpty(repositoryName))
{
throw new ArgumentException("Repository Name is a mandatory parameter.");
}
var client = new RestClient(new Uri(endPoint + "configuration/repositories/" + repositoryName));
var request = new RestRequest(Method.DELETE);
IRestResponse response = client.Execute(request);
HttpStatusCode statusMessage = response.StatusCode;
int statusCode = (int)statusMessage;
return(new PassedActionResult("Got response: " + statusCode + " " + statusMessage));
}
public override void ExecuteTask(ISpecialExecutionTaskTestAction testAction)
{
IParameter expectedFilePathParameter = testAction.GetParameter("ExpectedFile", false, new[] { ActionMode.Input });
IParameter actualFilePathParameter = testAction.GetParameter("ActualFile", false, new[] { ActionMode.Input });
string expectedFilePath = Environment.ExpandEnvironmentVariables(expectedFilePathParameter.GetAsInputValue().Value);
string actualFilePath = Environment.ExpandEnvironmentVariables(actualFilePathParameter.GetAsInputValue().Value);
string result = String.Empty;
try
{
result = FileComparer.Compare(expectedFilePath, actualFilePath);
}
catch (FileNotFoundException exc)
{
testAction.SetResult(SpecialExecutionTaskResultState.Failed, exc.Message);
return;
}
if (result == String.Empty)
{
testAction.SetResult(SpecialExecutionTaskResultState.Ok, "The contents of the files are identical.");
}
else
{
testAction.SetResult(SpecialExecutionTaskResultState.Failed, result);
}
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
String paraBuffer = testAction.GetParameterAsInputValue("Directory", false).Value;
if (string.IsNullOrEmpty(paraBuffer))
{
throw new ArgumentException(string.Format("Es muss ein Verzeichnis angegeben sein."));
}
int countFiles = 0;
if (Directory.Exists(paraBuffer))
{
string [] fileEntries = Directory.GetFiles(paraBuffer);
foreach (string fileName in fileEntries)
{
File.Delete(fileName);
countFiles++;
}
}
else
{
throw new ArgumentException(string.Format("Es wurde kein Verzeichnis angegeben."));
}
return(new PassedActionResult(string.Format("Removed files: {0}", countFiles)));
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
var action = testAction as SpecialExecutionTaskTestAction;
var module = action.TCItem.GetModule();
XModule xMod = module as XModule;
var xParams = xMod.GetXParams();
ModuleType moduleType = ModuleType.Method;
//if (!Enum.TryParse(xParams.Single(x => x.Name.ToLower() == "type").Value, out moduleType))
//{
// throw new InvalidOperationException("Invalid value in 'Type' Technical Parameter");
//}
ReflectionConfig config = new ReflectionConfig
{
ClassName = xParams.Single(x => x.Name.ToLower() == "classname").Value,
LibraryFile = xParams.Single(x => x.Name.ToLower() == "libraryfile").Value,
MethodName = xParams.Single(x => x.Name.ToLower() == "methodname").Value
};
var classObject = ActivateObject(config);
ActionResult result = null;
switch (moduleType)
{
case ModuleType.Class:
result = ExecuteClass(action, classObject);
break;
case ModuleType.Method:
result = ExecuteMethod(action, classObject, config);
break;
}
return(result);
}
protected static ProcessStartInfo CreateProcessStartInfo(
ISpecialExecutionTaskTestAction testAction,
IParameter pathParameter,
out string processArguments,
out string expandedPath)
{
IInputValue path = pathParameter.GetAsInputValue();
IInputValue directoryValue = testAction.GetParameterAsInputValue(Directory, true);
IParameter argumentsParameter = testAction.GetParameter(Arguments, true);
processArguments = string.Empty;
if (string.IsNullOrEmpty(path.Value))
{
throw new ArgumentException("Mandatory parameter '{Path}' not set.");
}
string directory = GetDirectory(directoryValue);
if (argumentsParameter != null)
{
processArguments = ParseArguments(argumentsParameter);
}
expandedPath = Environment.ExpandEnvironmentVariables(path.Value);
ProcessStartInfo processStartInfo = new ProcessStartInfo(expandedPath, processArguments);
if (!string.IsNullOrEmpty(directory))
{
processStartInfo.WorkingDirectory = directory;
}
return(processStartInfo);
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
String paraTargetHost = testAction.GetParameterAsInputValue("Host", false).Value;
if (string.IsNullOrEmpty(paraTargetHost))
{
throw new ArgumentException(string.Format("Es muss ein Ziel (Host) angegeben sein."));
}
string paraMessage = testAction.GetParameterAsInputValue("Message", false).Value;
if (string.IsNullOrEmpty(paraMessage))
{
throw new ArgumentException(string.Format("Es muss eine Message angegeben sein."));
}
string paraApi = testAction.GetParameterAsInputValue("API", false).Value;
if (string.IsNullOrEmpty(paraApi))
{
throw new ArgumentException(string.Format("Es muss eine API angegeben sein."));
}
Uri checkRequest = new Uri(string.Format("http://{0}/checkMessage/?api={1}", paraTargetHost, paraApi));
GetResponse(checkRequest);
return(new PassedActionResult("Check result for request " + checkRequest));
}
public override void ExecuteTask(ISpecialExecutionTaskTestAction testAction)
{
IInputValue path = testAction.GetParameterAsInputValue("Path");
//IParameter result = testAction.GetParameter("Result");
IParameter buffers = testAction.GetParameter("Buffers", true);
IEnumerable <IParameter> arguments = buffers.GetChildParameters("Buffer");
string returnValue = ExtractString(path.Value);
string[] words = returnValue.Split(',');
if (words.Length == arguments.Count())
{
int index = 0;
string resultText = "Buffers Created:";
foreach (IParameter argument in arguments)
{
IInputValue arg = argument.Value as IInputValue;
Buffers.Instance.SetBuffer(arg.Value, words[index], false);
resultText = resultText + Environment.NewLine
+ "Name: " + arg.Value + Environment.NewLine
+ "Value: " + words[index];
index = index + 1;
}
testAction.SetResultForParameter(buffers, SpecialExecutionTaskResultState.Ok, string.Format(resultText));
}
else
{
testAction.SetResultForParameter(buffers, SpecialExecutionTaskResultState.Failed, string.Format("File does not have all the buffers!"));
}
}
public override void ExecuteTask(ISpecialExecutionTaskTestAction testAction)
{
IParameter expectedFilePathParameter = testAction.GetParameter("ExpectedFile", false, new[] { ActionMode.Input });
IParameter actualFilePathParameter = testAction.GetParameter("ActualFile", false, new[] { ActionMode.Input });
string expectedFilePath = Environment.ExpandEnvironmentVariables(expectedFilePathParameter.GetAsInputValue().Value);
string actualFilePath = Environment.ExpandEnvironmentVariables(actualFilePathParameter.GetAsInputValue().Value);
string result = String.Empty;
try
{
result = FileComparer.Compare(expectedFilePath, actualFilePath);
}
catch (FileNotFoundException exc)
{
testAction.SetResult(SpecialExecutionTaskResultState.Failed, exc.Message);
return;
}
if (result == String.Empty)
{
testAction.SetResult(SpecialExecutionTaskResultState.Ok, "The contents of the files are identical.");
}
else
{
testAction.SetResult(SpecialExecutionTaskResultState.Failed, result);
}
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
IInputValue setfailed = testAction.GetParameterAsInputValue(c_SetFailed, false);
IInputValue failuretyp = testAction.GetParameterAsInputValue(c_FailureTyp, false);
IInputValue message = testAction.GetParameterAsInputValue(c_Message, false);
if (string.IsNullOrEmpty(setfailed.Value))
{
t_setfailed = "Failed";
}
else
{
t_setfailed = setfailed.Value;
}
if (!string.IsNullOrEmpty(failuretyp.Value))
{
t_failuretyp = failuretyp.Value;
}
if (!string.IsNullOrEmpty(message.Value))
{
t_message = message.Value;
}
string message_all = "Failuretyp: " + t_failuretyp + "; Message: " + t_message;
if (t_setfailed == "Failed")
{
try
{
if (t_failuretyp == "Warn" || t_failuretyp == "Absence" || t_failuretyp == "Missing")
{
return(new PassedActionResult("Test " + t_setfailed + " > " + message_all + " <"));
}
if (t_failuretyp == "Other Failure")
{
return(new PassedActionResult("Test " + t_setfailed + " > " + message_all + " <"));
}
else
{
throw (new TestFailedException("Test " + t_setfailed + " > " + message_all + " <"));
}
}
catch (TestFailedException e)
{
throw (new TestFailedException("Test " + t_setfailed + " > " + message_all + " <\r\n", e));
}
finally
{
}
// return new PassedActionResult("Test failed: " + message_all);
}
return(new PassedActionResult("Passed successfully: " + message_all));
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
IInputValue FilePath = testAction.GetParameterAsInputValue("FilePath", false); //isOptional=true
Process.Start(FilePath.Value);
return(new PassedActionResult("File Opened Successfully"));
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
bool completed = false;
string returnMsg = "";
IInputValue paramURL = testAction.GetParameterAsInputValue(URL, false);
IInputValue paramIsNewTab = testAction.GetParameterAsInputValue(isNewTab, false);
if (paramURL == null || string.IsNullOrEmpty(paramURL.Value))
{
throw new ArgumentException(string.Format("Mandatory parameter '{0}' not set.", URL));
}
if (paramIsNewTab == null || string.IsNullOrEmpty(paramIsNewTab.Value))
{
throw new ArgumentException(string.Format("Mandatory parameter '{0}' not set.", isNewTab));
}
try
{
if (paramIsNewTab.Value == "True")
{
ShellWindows shellWindows = new ShellWindows(); //Uses SHDocVw to get the Internet Explorer Instances
foreach (SHDocVw.InternetExplorer internetExplorerInstance in shellWindows)
{
string url = internetExplorerInstance.LocationURL;
if (!url.Contains("file:///"))
{
internetExplorerInstance.Navigate(paramURL.Value, 0x800);
completed = true;
returnMsg = "URL opened in new tab";
break;
}
}
}
if (!completed) // To open url in new window
{
Process procInNewWndow = new Process();
procInNewWndow.StartInfo.FileName = "C:\\Program Files\\Internet Explorer\\iexplore.exe";
procInNewWndow.StartInfo.Arguments = paramURL.Value;
procInNewWndow.StartInfo.UseShellExecute = true;
procInNewWndow.StartInfo.CreateNoWindow = false;
procInNewWndow.Start();
returnMsg = "URL opened in new window";
}
}
catch (Exception)
{
return(new UnknownFailedActionResult("Could not start program",
string.Format(
"Failed while trying to start:\nURL: {0}\r\nIsNewTab: {1}",
paramURL.Value, paramIsNewTab.Value),
""));
}
return(new PassedActionResult(returnMsg));
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
String relay = testAction.GetParameterAsInputValue("relay", false).Value;
if (string.IsNullOrEmpty(relay))
{
throw new ArgumentException(string.Format("Es muss ein SMTP Relay angegeben sein."));
}
String sendTo = testAction.GetParameterAsInputValue("to", false).Value;
if (string.IsNullOrEmpty(sendTo))
{
throw new ArgumentException(string.Format("Es muss ein Empfänger angegeben werden."));
}
String sendFrom = testAction.GetParameterAsInputValue("from", false).Value;
if (string.IsNullOrEmpty(sendFrom))
{
throw new ArgumentException(string.Format("Es muss ein Absender angegeben werden."));
}
String msgSubject = testAction.GetParameterAsInputValue("subject", false).Value;
if (string.IsNullOrEmpty(msgSubject))
{
throw new ArgumentException(string.Format("Es muss ein Betreff angegeben sein."));
}
String msgBody = testAction.GetParameterAsInputValue("body", false).Value;
if (string.IsNullOrEmpty(msgBody))
{
throw new ArgumentException(string.Format("Es muss ein Text (Body) angegeben sein."));
}
MailMessage message = new MailMessage(sendFrom, sendTo);
message.Subject = msgSubject;
message.Body = @msgBody;
using (SmtpClient client = new SmtpClient(relay)) {
// client.UseDefaultCredentials = true;
try {
client.Send(message);
return(new PassedActionResult("Message successfully sent."));
}
catch (Exception ex) {
return(new NotFoundFailedActionResult("Exception caught in CreateTestMessage2(): {0}",
ex.ToString()));
} finally {
}
}
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
String paraBuffer = testAction.GetParameterAsInputValue("Value", false).Value;
if (string.IsNullOrEmpty(paraBuffer))
{
throw new ArgumentException(string.Format("Es muss ein Buffer angegeben sein."));
}
return(new PassedActionResult(paraBuffer));
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
IInputValue showinfo = testAction.GetParameterAsInputValue(c_ShowInfo, false);
/*
* if (showinfo == null || string.IsNullOrEmpty(showinfo.Value))
* throw new ArgumentException(string.Format("Mandatory parameter '{0}' not set.", c_ShowInfo));
*/
return(new PassedActionResult("Info: " + showinfo.Value));
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
String inputStr = testAction.GetParameterAsInputValue("InputString", false).Value;
if (string.IsNullOrEmpty(inputStr))
{
throw new ArgumentException(string.Format("Please provide input string to be converted to uppercase!"));
}
string resultString = inputStr.ToUpper();
return(new PassedActionResult(resultString));
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
IInputValue name = testAction.GetParameterAsInputValue(Name, false);
string browserProcessName = string.Empty;
string result = string.Empty;
try
{
// Setting Browser process Name as per browserName
switch (name.Value)
{
case "Internet Explorer":
browserProcessName = "iexplore";
break;
case "Google Chrome":
browserProcessName = "chrome";
break;
case "Mozilla Firefox":
browserProcessName = "firefox";
break;
default:
return(new UnknownFailedActionResult("Could not kill program", string.Format("Failed while trying to kill {0}", name.Value), ""));
}
Process[] procs = Process.GetProcessesByName(browserProcessName);
if (procs.Length > 0)
{
foreach (Process proc in procs)
{
proc.Kill();
result = name.Value + " Browser closed Successfully";
}
}
else
{
result = name.Value + ERROR_BROWSER_NOTAVAILABLE;
}
}
catch (Exception)
{
return(new UnknownFailedActionResult("Could not kill program",
string.Format(
"Failed while trying to kill {0}",
name.Value),
""));
}
return(new PassedActionResult(result));
}
public override void ExecuteTask(ISpecialExecutionTaskTestAction testAction)
{
IParameter IPconnString = testAction.GetParameter("ConnectionString", false, new[] { ActionMode.Input });
IParameter IPquery = testAction.GetParameter("Query", false, new[] { ActionMode.Input });
IParameter IPresult = testAction.GetParameter("Result", true, new[] { ActionMode.Verify, ActionMode.Buffer });
string connString = IPconnString.GetAsInputValue().Value;
string query = IPquery.GetAsInputValue().Value;
if (File.Exists(query))
{
query = File.ReadAllText(query);
}
Datalink dl = new Datalink(connString);
if (!dl.IsValidSqlConnectionString())
{
throw new InvalidOperationException("Connectionstring is not valid or the database cannot be reached");
}
string result = dl.Execute(query);
if (IPresult != null)
{
IInputValue expectedResult = IPresult.Value as IInputValue;
if (IPresult.ActionMode == ActionMode.Buffer)
{
Buffers.Instance.SetBuffer(expectedResult.Value, result);
testAction.SetResult(SpecialExecutionTaskResultState.Ok, string.Format("Buffer {0} set to value {1}.", expectedResult.Value, result));
return;
}
if (expectedResult.Value == result)
{
testAction.SetResult(SpecialExecutionTaskResultState.Ok, "Actual rows match expected number of rows.");
}
else
{
testAction.SetResult(SpecialExecutionTaskResultState.Failed, string.Format("Expected result: {0}. Actual result {1}. Incorrect", expectedResult.Value, result.ToString()));
}
}
else
{
testAction.SetResult(SpecialExecutionTaskResultState.Ok, "Query executed");
}
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
String paraTargetHost = testAction.GetParameterAsInputValue("Host", false).Value;
if (string.IsNullOrEmpty(paraTargetHost))
{
throw new ArgumentException(string.Format("Es muss ein Ziel (Host) angegeben sein."));
}
Uri resetRequest = new Uri("http://" + paraTargetHost + "/resetSession");
GetResponse(resetRequest);
return(new PassedActionResult("Session reset on: " + paraTargetHost));
}
public override void ExecuteTask(ISpecialExecutionTaskTestAction testAction)
{
//The 2nd parameter of GetParameterAsInputValue Method defines if the argument is optional or not
//and if we don't provide the second parameter by default it is false(Means argument is mandetory)
IInputValue browserName = testAction.GetParameterAsInputValue("BrowserName", false);
bool result = EraseTemporaryFiles(browserName.Value);
if (result)
{
testAction.SetResult(SpecialExecutionTaskResultState.Ok, string.Format("Cache for {0} is cleared.", browserName.Value));
}
else
{
testAction.SetResult(SpecialExecutionTaskResultState.Failed, string.Format("Unable to clear cache for {0}.", browserName.Value));
}
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
String base64ImageRepresentation = testAction.GetParameterAsInputValue("Payload", false).Value;
String targetFile = testAction.GetParameterAsInputValue("TargetFile", false).Value;
if (targetFile != null && base64ImageRepresentation != null)
{
System.IO.File.WriteAllBytes(targetFile, Convert.FromBase64String(base64ImageRepresentation));
}
else
{
throw new ArgumentException();
}
return(new PassedActionResult("Decoding File successfully completed"));
}
public override void ExecuteTask(ISpecialExecutionTaskTestAction testAction)
{
IParameter IPconnString = testAction.GetParameter("ConnectionString", false, new[] { ActionMode.Input });
IParameter IPquery = testAction.GetParameter("Query", false, new[] { ActionMode.Input });
IParameter IPresult = testAction.GetParameter("Result", true, new[] { ActionMode.Verify, ActionMode.Buffer });
string connString = IPconnString.GetAsInputValue().Value;
string query = IPquery.GetAsInputValue().Value;
if (File.Exists(query))
{
query = File.ReadAllText(query);
}
Datalink dl = new Datalink(connString);
if (!dl.IsValidSqlConnectionString())
{
throw new InvalidOperationException("Connectionstring is not valid or the database cannot be reached");
}
string result = dl.Execute(query);
if (IPresult != null )
{
IInputValue expectedResult = IPresult.Value as IInputValue;
if (IPresult.ActionMode == ActionMode.Buffer)
{
Buffers.Instance.SetBuffer(expectedResult.Value, result);
testAction.SetResult(SpecialExecutionTaskResultState.Ok, string.Format("Buffer {0} set to value {1}.",expectedResult.Value, result));
return;
}
if (expectedResult.Value == result)
{
testAction.SetResult(SpecialExecutionTaskResultState.Ok, "Actual rows match expected number of rows.");
}
else
{
testAction.SetResult(SpecialExecutionTaskResultState.Failed, string.Format("Expected result: {0}. Actual result {1}. Incorrect", expectedResult.Value, result.ToString()));
}
}
else
{
testAction.SetResult(SpecialExecutionTaskResultState.Ok, "Query executed");
}
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
String sourceFile = testAction.GetParameterAsInputValue("InputFile", false).Value;
String bufferParameterName = testAction.GetParameterAsInputValue("BufferParamName", false).Value;
if (sourceFile != null && bufferParameterName != null)
{
string base64ImageRepresentation = Convert.ToBase64String(System.IO.File.ReadAllBytes(sourceFile));
Buffers.Instance.SetBuffer(bufferParameterName, base64ImageRepresentation, false);
}
else
{
throw new ArgumentException();
}
return(new PassedActionResult("Encoding File successfully completed"));
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
String paraExchangeFile = testAction.GetParameterAsInputValue("File", false).Value;
if (string.IsNullOrEmpty(paraExchangeFile)) {
throw new ArgumentException(string.Format("Es muss eine Exchangedatei (File) angegeben sein."));
}
if (!Collections.Instance.CollectionExists(BufferCollectionPath)) {
throw new InvalidOperationException("Es existiert keine Buffer-Collection in den Einstellungen!");
}
XmlDocument doc = new XmlDocument();
XmlDeclaration xmlDeclaration = doc.CreateXmlDeclaration("1.0", "UTF-8", null);
XmlElement root = doc.DocumentElement;
doc.InsertBefore(xmlDeclaration, root);
XmlElement bodyElement = doc.CreateElement(string.Empty, "exchange", string.Empty);
doc.AppendChild(bodyElement);
XmlElement varElement = doc.CreateElement(string.Empty, "variables", string.Empty);
bodyElement.AppendChild(varElement);
foreach (
KeyValuePair<string, string> buffer in Collections.Instance.GetCollectionEntries(BufferCollectionPath)) {
if (!string.IsNullOrEmpty(buffer.Value) && !buffer.Key.StartsWith("#")) {
XmlElement varKey = doc.CreateElement(string.Empty, buffer.Key, string.Empty);
XmlText varValue;
if (buffer.Key == "QAPass") {
varValue = doc.CreateTextNode("****");
varKey.AppendChild(varValue);
} else {
varValue = doc.CreateTextNode(buffer.Value);
varKey.AppendChild(varValue);
}
varElement.AppendChild(varKey);
}
}
doc.Save(paraExchangeFile);
return new PassedActionResult("Exchange generated to: " + paraExchangeFile);
}
public override void ExecuteTask(ISpecialExecutionTaskTestAction testAction)
{
IParameter IPprocess = testAction.GetParameter("Process", false, new[] { ActionMode.Input });
IParameter IPwaittimesecs = testAction.GetParameter("WaitTimeSecs", false, new[] { ActionMode.Input });
string process = IPprocess.GetAsInputValue().Value;
string waittimesecsString = IPwaittimesecs.GetAsInputValue().Value;
short waittimesecs = 0;
bool success = Int16.TryParse(waittimesecsString, out waittimesecs);
if (!success)
{
testAction.SetResult(SpecialExecutionTaskResultState.Failed, "WaitTimeSecs has to be an integer");
return;
}
if (waittimesecs == 0)
{
waittimesecs = DEFAULTWAITTIME;
}
Process[] pname = Process.GetProcessesByName(process);
if (pname.Length == 0)
{
testAction.SetResult(SpecialExecutionTaskResultState.Ok, string.Format("Proces {0} already ended or not started", process));
return;
}
short counter = 0;
while (counter < waittimesecs)
{
counter++;
Thread.Sleep(1000);
pname = Process.GetProcessesByName(process);
if (pname.Length == 0)
{
break;
}
}
testAction.SetResult(SpecialExecutionTaskResultState.Ok, string.Format("Proces {0} has ended after {1} seconds", process, counter));
}
public override void ExecuteTask(ISpecialExecutionTaskTestAction testAction)
{
foreach (IParameter parameter in testAction.Parameters)
{
//ActionMode input means set the buffer
if (parameter.ActionMode == ActionMode.Input)
{
IInputValue inputValue = parameter.GetAsInputValue();
//Buffers.Instance.SetBuffer(parameter.Name, inputValue.Value);
testAction.SetResultForParameter(parameter, SpecialExecutionTaskResultState.Ok, string.Format("Buffer {0} set to value {1}.", parameter.Name, inputValue.Value));
}
//Otherwise we let TBox handle the verification. Other ActionModes like WaitOn will lead to an exception.
else
{
//Don't need the return value of HandleActualValue in this case.
//HandleActualValue(testAction, parameter, Buffers.Instance.GetBuffer(parameter.Name));
}
}
}
public override void ExecuteTask(ISpecialExecutionTaskTestAction testAction)
{
if (!Collections.Instance.CollectionExists(BufferCollectionPath))
{
throw new InvalidOperationException("No Buffer-Collection is available in the settings!");
}
foreach (
KeyValuePair <string, string> buffer in Collections.Instance.GetCollectionEntries(BufferCollectionPath))
{
if (!string.IsNullOrEmpty(buffer.Value))
{
if ((!buffer.Key.StartsWith("LOCAL_")) && (!buffer.Key.StartsWith("ENV")) && (!buffer.Key.StartsWith("TOOLS_")))
{
Buffers.Instance.SetBuffer(buffer.Key, string.Empty, false);
}
}
}
testAction.SetResult(SpecialExecutionTaskResultState.Ok, "Successfully cleared all Buffers!");
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
String filePath = testAction.GetParameterAsInputValue("FilePath", false).Value;
String rowNumber = testAction.GetParameterAsInputValue("RowNumber", false).Value;
if (string.IsNullOrEmpty(filePath))
{
throw new ArgumentException(string.Format("Text file path is required."));
}
if (string.IsNullOrEmpty(rowNumber))
{
throw new ArgumentException(string.Format("Row number with column names is required."));
}
int i = 0;
int row = Int32.Parse(rowNumber);
int[] columnSize = { 14, 3, 4, 7, 7, 3, 3, 3, 10, 3, 6, 2, 5, 8, 6, 10, 13, 9, 8, 3, 16, 25, 8 };
string resultString = "Column Names: ";
string[] lines = File.ReadAllLines(filePath);
foreach (string line in lines)
{
if (line.Equals(lines[row - 1]) && i == 0)
{
string columnNames = line.Substring(1);
int columnLength = 0;
for (int x = 0; x < columnSize.Length; x++)
{
columnLength = columnSize[x];
resultString += columnNames.Substring(i, columnLength + 1).Trim() + ", ";
i = i + columnLength + 1;
}
}
}
return(new PassedActionResult(resultString));
}
public override void ExecuteTask(ISpecialExecutionTaskTestAction testAction)
{
// IParameter Parentparam = testAction.GetParameter("BufferCredentials",false);
// IEnumerable<IParameter> Childparam = Parentparam.GetChildParameters("BufferCredentials");
foreach (IParameter Param in testAction.Parameters)
{
if (Param.ActionMode == ActionMode.Input)
{
IInputValue inputValue = Param.GetAsInputValue();
Buffers.Instance.SetBuffer(Param.Name, Param.GetAsInputValue().Value, false);
testAction.SetResultForParameter(Param, SpecialExecutionTaskResultState.Ok, string.Format("Buffer {0} set for value {1}", Param.Name, inputValue.Value));
}
else
{
testAction.SetResultForParameter(Param, SpecialExecutionTaskResultState.Failed, string.Format("Fail"));
}
}
}
public override void ExecuteTask(ISpecialExecutionTaskTestAction testAction)
{
//Iterate over each TestStepValue
foreach (IParameter parameter in testAction.Parameters)
{
//ActionMode input means set the buffer
if (parameter.ActionMode == ActionMode.Input)
{
IInputValue inputValue = parameter.GetAsInputValue();
Buffers.Instance.SetBuffer(parameter.Name, inputValue.Value, false);
testAction.SetResultForParameter(parameter, SpecialExecutionTaskResultState.Ok, string.Format("Buffer {0} set to value {1}.", parameter.Name, inputValue.Value));
}
//Otherwise we let TBox handle the verification. Other ActionModes like WaitOn will lead to an exception.
else
{
//Don't need the return value of HandleActualValue in this case.
HandleActualValue(testAction, parameter, Buffers.Instance.GetBuffer(parameter.Name));
}
}
}
public override ActionResult Execute(ISpecialExecutionTaskTestAction testAction)
{
try
{
IInputValue buffer = testAction.GetParameterAsInputValue("Buffer Name", false, new[] { ActionMode.Input });
IInputValue folder = testAction.GetParameterAsInputValue("Folder Path", false, new[] { ActionMode.Input });
IInputValue fileName = testAction.GetParameterAsInputValue("File Name", false, new[] { ActionMode.Input });
string fileContent = Buffers.Instance.GetBuffer(buffer.Value);
if (fileContent.StartsWith("\"") && fileContent.EndsWith("\""))
{
fileContent = fileContent.TrimStart('"').TrimEnd('"').Replace("\"\"", "\"");
}
File.WriteAllText(Path.Combine(folder.Value, fileName.Value), fileContent);
return(new PassedActionResult("File created as '" + Path.Combine(folder.Value, fileName.Value) + "'."));
}
catch (Exception e)
{
return(new UnknownFailedActionResult(e.Message));
}
}
public override void ExecuteTask(ISpecialExecutionTaskTestAction testAction)
{
IParameter pathParameter = testAction.GetParameter(Path);
string processArguments = null, expandedPath = null;
ProcessStartInfo processStartInfo = null;
try {
processStartInfo = CreateProcessStartInfo(
testAction,
pathParameter,
out processArguments,
out expandedPath);
}
catch (FileNotFoundException e) {
testAction.SetResultForParameter(pathParameter, new UnknownFailedActionResult("Cannot find the given file'.", e.ToString(), expandedPath ?? string.Empty));
return;
}
IParameter exitParameter = testAction.GetParameter(WaitForExit, true, new[] { ActionMode.Select });
if (exitParameter != null)
{
StartProgramWithWaitForExit(
testAction,
exitParameter,
processStartInfo,
pathParameter,
expandedPath,
processArguments);
}
else
{
StartProgramWithoutWaitingForExit(
testAction,
processStartInfo,
expandedPath,
processArguments,
pathParameter);
}
}
private static void StartProgramWithoutWaitingForExit(
ISpecialExecutionTaskTestAction testAction,
ProcessStartInfo processStartInfo,
string expandedPath,
string processArguments,
IParameter pathParameter)
{
try {
Process.Start(processStartInfo);
testAction.SetResult(
SpecialExecutionTaskResultState.Ok,
"Started: " + expandedPath + " with arguments: " + processArguments);
}
catch (Win32Exception e) {
testAction.SetResultForParameter(
pathParameter,
SpecialExecutionTaskResultState.Failed,
CreateMessageForStartError(expandedPath, processArguments, e),
e.StackTrace,
"");
}
}
public override void ExecuteTask(ISpecialExecutionTaskTestAction testAction)
{
IParameter IPprocess = testAction.GetParameter("Process", false, new[] { ActionMode.Input });
IParameter IPwaittimesecs = testAction.GetParameter("WaitTimeSecs", false, new[] { ActionMode.Input });
string process = IPprocess.GetAsInputValue().Value;
string waittimesecsString = IPwaittimesecs.GetAsInputValue().Value;
short waittimesecs = 0;
bool success = Int16.TryParse(waittimesecsString, out waittimesecs);
if (!success)
{
testAction.SetResult(SpecialExecutionTaskResultState.Failed, "WaitTimeSecs has to be an integer");
return;
}
if (waittimesecs == 0)
waittimesecs = DEFAULTWAITTIME;
Process[] pname = Process.GetProcessesByName(process);
if (pname.Length == 0)
{
testAction.SetResult(SpecialExecutionTaskResultState.Ok, string.Format("Proces {0} already ended or not started", process));
return;
}
short counter = 0;
while (counter < waittimesecs)
{
counter++;
Thread.Sleep(1000);
pname = Process.GetProcessesByName(process);
if (pname.Length == 0)
break;
}
testAction.SetResult(SpecialExecutionTaskResultState.Ok, string.Format("Proces {0} has ended after {1} seconds", process, counter));
}
public override void ExecuteTask(ISpecialExecutionTaskTestAction testAction)
{
const string BEGINWHERE = " where 1=1 ";
const string BEGINSELECT = " select ";
const string BEGINORDER = " order by ";
const string ORDERDIRECTION = " desc ";
var connStringParam = testAction.SearchQuery.XParameters.ConfigurationParameters.FirstOrDefault( xParam => xParam.Name == "ConnectionString");
string connString = connStringParam.UnparsedValue;
var tableNameParam = testAction.SearchQuery.XParameters.ConfigurationParameters.FirstOrDefault(xParam => xParam.Name == "TableName");
string tableName = tableNameParam.UnparsedValue;
var orderAttribParam = testAction.SearchQuery.XParameters.ConfigurationParameters.FirstOrDefault(xParam => xParam.Name == "OrderAttribute");
string orderAttrib = orderAttribParam.UnparsedValue;
string queryWhere = BEGINWHERE;
string queryBegin = BEGINSELECT;
string query = string.Empty;
string queryOrder = string.Format("{0} {1} {2}", BEGINORDER, orderAttrib, ORDERDIRECTION);
int count = 0;
var constraints = testAction.Parameters.FindAll(p => p.ActionMode == ActionMode.Constraint);
if (constraints.Count > 0)
{
foreach (var parameter in constraints)
{
IInputValue value = parameter.Value as IInputValue;
queryWhere += string.Format(" and {0} = '{1}' ", parameter.Name, value.Value);
}
}
var buffersVerifies = testAction.Parameters.FindAll(p => p.ActionMode == ActionMode.Verify || p.ActionMode == ActionMode.Buffer);
if (buffersVerifies.Count == 0 )
{
// No use in continuing if there is nothing to verify or buffer
return;
}
queryBegin += String.Join(",", buffersVerifies.Select(p => p.Name).ToArray());
// Generate db query
query = string.Format("{0} FROM {1} {2} {3}", queryBegin, tableName, queryWhere, queryOrder);
// Connect to the database
Datalink dl = new Datalink();
dl.ConnectionString = connString;
if (!dl.IsValidSqlConnectionString())
{
testAction.SetResult(SpecialExecutionTaskResultState.Failed, string.Format("Cannot connect to the SQL database with the following connection string: {0}", connString));
return;
}
DataRow dr = dl.GetRowFromDb(query);
// If there is not a result from the database, set the testresult to failed
if (dr == null)
{
testAction.SetResult(SpecialExecutionTaskResultState.Failed, "No records found in with selected searchcriteria" );
return;
}
foreach (IParameter parameter in buffersVerifies.Where(p => p.ActionMode == ActionMode.Verify))
{
IInputValue value = parameter.Value as IInputValue;
if (value.Value == dr[parameter.Name].ToString())
{
testAction.SetResultForParameter(parameter, SpecialExecutionTaskResultState.Ok, string.Format("{0}: Expected value {1} matches actual value {2}.", parameter.Name, value.Value, dr[parameter.Name].ToString()));
}
else
{
count++;
testAction.SetResultForParameter(parameter, SpecialExecutionTaskResultState.Failed, string.Format("Error {0}: Expected value {1} does not match actual value {2}.", parameter.Name, value.Value, dr[parameter.Name].ToString()));
}
}
foreach (IParameter parameter in buffersVerifies.Where(p => p.ActionMode == ActionMode.Buffer))
{
IInputValue buffer = parameter.Value as IInputValue;
Buffers.Instance.SetBuffer(buffer.Value, dr[parameter.Name].ToString());
testAction.SetResultForParameter(parameter, SpecialExecutionTaskResultState.Ok, string.Format("Buffer {0} set to value {1}.", buffer.Value, dr[parameter.Name].ToString()));
}
if (count == 0)
{
testAction.SetResult(SpecialExecutionTaskResultState.Ok, "All values match.");
}
else
{
int numberOfVerifies = buffersVerifies.Count(p => p.ActionMode == ActionMode.Verify);
testAction.SetResult(SpecialExecutionTaskResultState.Failed, string.Format("{0} out of {1} values match.", numberOfVerifies - count, numberOfVerifies));
}
}
