public void SetFailedFatallyStatus()
{
_engine = new AutomationEngineInstance(null);
_setQueueItem = new SetQueueItemStatusCommand();
string name = "FailedQueueItem";
AddQueueItem(name);
var queueItemDict = WorkQueueItem();
var client = AuthMethods.GetAuthToken();
var transactionKey = queueItemDict["LockTransactionKey"].ToString();
var queueItem = QueueItemMethods.GetQueueItemByLockTransactionKey(client, transactionKey);
VariableMethods.CreateTestVariable(null, _engine, "vQueueItem", typeof(Dictionary <,>));
_setQueueItem.v_QueueItem = "{vQueueItem}";
queueItemDict.StoreInUserVariable(_engine, _setQueueItem.v_QueueItem, typeof(Dictionary <,>));
_setQueueItem.v_QueueItemStatusType = "Failed - Fatal";
_setQueueItem.RunCommand(_engine);
queueItem = QueueItemMethods.GetQueueItemById(client, queueItem.Id);
Assert.Equal("Failed", queueItem.State);
}
public void CreatesDataTable()
{
_createDataTableCommand = new CreateDataTableCommand();
_engine = new AutomationEngineInstance(null);
OBData.DataTable columnNameDataTable = new OBData.DataTable
{
TableName = "ColumnNamesDataTable" + DateTime.Now.ToString("MMddyy.hhmmss")
};
VariableMethods.CreateTestVariable("Col1", _engine, "Col1", typeof(string));
VariableMethods.CreateTestVariable(null, _engine, "outputTable", typeof(OBData.DataTable));
columnNameDataTable.Columns.Add("{Col1}");
_createDataTableCommand.v_ColumnNameDataTable = columnNameDataTable;
_createDataTableCommand.v_OutputUserVariableName = "{outputTable}";
_createDataTableCommand.RunCommand(_engine);
OBData.DataTable expectedDt = new OBData.DataTable();
foreach (DataRow rwColumnName in columnNameDataTable.Rows)
{
expectedDt.Columns.Add(rwColumnName.Field <string>("Column Name").ConvertUserVariableToString(_engine));
}
OBData.DataTable resultDataTable = (OBData.DataTable)_createDataTableCommand.v_OutputUserVariableName.ConvertUserVariableToObject(_engine, typeof(OBData.DataTable));
for (int row = 0; row < expectedDt.Rows.Count; row++)
{
for (int col = 0; col < expectedDt.Columns.Count; col++)
{
Assert.Equal(expectedDt.Rows[row][expectedDt.Columns[col]], resultDataTable.Rows[row][resultDataTable.Columns[col]]);
}
}
}
public async void SplitsTextWithMultipleDelimiters()
{
_splitText = new SplitTextCommand();
_engine = new AutomationEngineInstance(null);
string inputText = "test text:with!multiple;delimiters";
List <string> splitCharacters = new List <string>();
splitCharacters.Add(" ");
splitCharacters.Add(":");
splitCharacters.Add("!");
splitCharacters.Add(";");
VariableMethods.CreateTestVariable(inputText, _engine, "input", typeof(string));
VariableMethods.CreateTestVariable(splitCharacters, _engine, "splitChar", typeof(List <>));
VariableMethods.CreateTestVariable(null, _engine, "output", typeof(List <>));
_splitText.v_InputText = "{input}";
_splitText.v_SplitCharacter = "{splitChar}";
_splitText.v_OutputUserVariableName = "{output}";
_splitText.RunCommand(_engine);
List <string> splitText = (List <string>)await "{output}".EvaluateCode(_engine);
Assert.Equal("test", splitText[0]);
Assert.Equal("text", splitText[1]);
Assert.Equal("with", splitText[2]);
Assert.Equal("multiple", splitText[3]);
Assert.Equal("delimiters", splitText[4]);
}
public void CompressesFilesWithPassword()
{
_engine = new AutomationEngineInstance(null);
_compressFiles = new CompressFilesCommand();
string projectDirectory = Directory.GetParent(Environment.CurrentDirectory).Parent.FullName;
string inputPath = Path.Combine(projectDirectory, @"Resources\toCompressWithPassword");
VariableMethods.CreateTestVariable(inputPath, _engine, "inputPath", typeof(string));
string outputPath = Environment.CurrentDirectory;
VariableMethods.CreateTestVariable(outputPath, _engine, "outputPath", typeof(string));
string password = "******";
VariableMethods.CreateTestVariable(password.ConvertStringToSecureString(), _engine, "testPassword", typeof(SecureString));
VariableMethods.CreateTestVariable(null, _engine, "output", typeof(string));
_compressFiles.v_DirectoryPathOrigin = "{inputPath}";
_compressFiles.v_Password = "******";
_compressFiles.v_PathDestination = "{outputPath}";
_compressFiles.v_OutputUserVariableName = "{output}";
_compressFiles.RunCommand(_engine);
Assert.True(IO.File.Exists(Path.Combine(Environment.CurrentDirectory, @"toCompressWithPassword.zip")));
IO.File.Delete(Path.Combine(outputPath, @"toCompressWithPassword.zip"));
}
public async System.Threading.Tasks.Task HandlesNonExistentQueue()
{
_engine = new AutomationEngineInstance(null);
_addQueueItem = new AddQueueItemCommand();
_workQueueItem = new WorkQueueItemCommand();
var textValue = "{ \"text\": \"testText\" }";
VariableMethods.CreateTestVariable(null, _engine, "output", typeof(Dictionary <,>));
VariableMethods.CreateTestVariable(textValue, _engine, "textValue", typeof(string));
_addQueueItem.v_QueueName = "UnitTestQueue";
_addQueueItem.v_QueueItemName = "WorkQueueItemJsonTest";
_addQueueItem.v_QueueItemType = "Json";
_addQueueItem.v_JsonType = "Test Type";
_addQueueItem.v_QueueItemTextValue = "{textValue}";
_addQueueItem.v_Priority = "10";
_addQueueItem.RunCommand(_engine);
_workQueueItem.v_QueueName = "NoQueue";
_workQueueItem.v_OutputUserVariableName = "{output}";
_workQueueItem.v_SaveAttachments = "No";
_workQueueItem.v_AttachmentDirectory = "";
await Assert.ThrowsAsync <DataException>(() => _workQueueItem.RunCommand(_engine));
}
public async Task HandlesNonExistentTransactionKey()
{
_engine = new AutomationEngineInstance(null);
_setQueueItem = new SetQueueItemStatusCommand();
var queueItemDict = new Dictionary <string, object>()
{
{ "LockTransactionKey", null },
{ "Name", "ExtendQueueItemTest" },
{ "Source", null },
{ "Event", null },
{ "Type", "Text" },
{ "JsonType", "Test Type" },
{ "DataJson", "Test Text" },
{ "Priority", 10 },
{ "LockedUntilUTC", DateTime.UtcNow.AddHours(1) }
};
VariableMethods.CreateTestVariable(null, _engine, "vQueueItem", typeof(Dictionary <,>));
_setQueueItem.v_QueueItem = "{vQueueItem}";
_setQueueItem.v_QueueItemStatusType = "Successful";
queueItemDict.SetVariableValue(_engine, _setQueueItem.v_QueueItem);
await Assert.ThrowsAsync <NullReferenceException>(() => _setQueueItem.RunCommand(_engine));
}
public void ExecuteScript(JobExecutionParams executionParams)
{
var engineContext = GetEngineContext(executionParams);
var engine = new AutomationEngineInstance(engineContext);
engine.ExecuteScriptSync();
}
public void ForwardsOutlookEmail()
{
_engine = new AutomationEngineInstance(null);
_getOutlookEmails = new GetOutlookEmailsCommand();
_forwardOutlookEmail = new ForwardOutlookEmailCommand();
_deleteOutlookEmail = new DeleteOutlookEmailCommand();
VariableMethods.CreateTestVariable(null, _engine, "emails", typeof(List <>));
_getOutlookEmails.v_SourceFolder = "TestInput";
_getOutlookEmails.v_Filter = "[Subject] = 'toForward'";
_getOutlookEmails.v_GetUnreadOnly = "No";
_getOutlookEmails.v_MarkAsRead = "No";
_getOutlookEmails.v_SaveMessagesAndAttachments = "No";
_getOutlookEmails.v_MessageDirectory = "";
_getOutlookEmails.v_AttachmentDirectory = "";
_getOutlookEmails.v_OutputUserVariableName = "{emails}";
_getOutlookEmails.RunCommand(_engine);
var emails = (List <MailItem>) "{emails}".ConvertUserVariableToObject(_engine, typeof(List <>));
MailItem email = emails[0];
VariableMethods.CreateTestVariable(email, _engine, "email", typeof(MailItem));
string forwardAddress = "*****@*****.**";
VariableMethods.CreateTestVariable(forwardAddress, _engine, "forwardEmail", typeof(string));
_forwardOutlookEmail.v_MailItem = "{email}";
_forwardOutlookEmail.v_Recipients = "{forwardEmail}";
_forwardOutlookEmail.RunCommand(_engine);
int attempts = 0;
do
{
System.Threading.Thread.Sleep(5000);
_getOutlookEmails.v_SourceFolder = "Inbox";
_getOutlookEmails.v_Filter = "[Subject] = 'toForward'";
_getOutlookEmails.v_GetUnreadOnly = "No";
_getOutlookEmails.v_MarkAsRead = "No";
_getOutlookEmails.v_SaveMessagesAndAttachments = "No";
_getOutlookEmails.v_MessageDirectory = "";
_getOutlookEmails.v_AttachmentDirectory = "";
_getOutlookEmails.v_OutputUserVariableName = "{emails}";
_getOutlookEmails.RunCommand(_engine);
emails = (List <MailItem>) "{emails}".ConvertUserVariableToObject(_engine, typeof(List <>));
attempts++;
} while (emails.Count < 1 & attempts < 5);
email = emails[0];
Assert.Equal("*****@*****.**", email.Sender.Address);
Assert.Equal("FW: toForward", email.Subject);
resetEmail(_engine, email);
}
public void SendServerEmailWithNoAttachments()
{
_engine = new AutomationEngineInstance(null);
_sendServerEmail = new SendServerEmailCommand();
string projectDirectory = Directory.GetParent(Environment.CurrentDirectory).Parent.FullName;
string filePath = Path.Combine(projectDirectory, @"Resources\");
string subject = "No Attachments";
string email = filePath + @"Download\" + $"{subject}.msg";
_sendServerEmail.v_AccountName = "NicolePersonalTest";
_sendServerEmail.v_ToRecipients = "*****@*****.**";
_sendServerEmail.v_CCRecipients = "";
_sendServerEmail.v_BCCRecipients = "";
_sendServerEmail.v_Subject = subject;
_sendServerEmail.v_Body = "Test Body";
_sendServerEmail.v_Attachments = "";
_sendServerEmail.RunCommand(_engine);
var emailMessage = GetEmail(filePath, subject);
Assert.True(File.Exists(email));
DeleteEmail(emailMessage);
File.Delete(email);
}
public async void GetsDataTableListItem()
{
_engine = new AutomationEngineInstance(null);
_getListItem = new GetListItemCommand();
List <OBDataTable> list = new List <OBDataTable>();
OBDataTable item1 = new OBDataTable();
item1.Columns.Add("d1col");
OBDataTable item2 = new OBDataTable();
item2.Columns.Add("d2col");
list.Add(item1);
list.Add(item2);
VariableMethods.CreateTestVariable(list, _engine, "inputList", typeof(List <>));
VariableMethods.CreateTestVariable(null, _engine, "output", typeof(OBDataTable));
_getListItem.v_ListName = "{inputList}";
_getListItem.v_ItemIndex = "1";
_getListItem.v_OutputUserVariableName = "{output}";
_getListItem.RunCommand(_engine);
Assert.Equal(item2, (OBDataTable)await "{output}".EvaluateCode(_engine));
}
public void RenamesFile()
{
_engine = new AutomationEngineInstance(null);
_renameFile = new RenameFileCommand();
string projectDirectory = Directory.GetParent(Environment.CurrentDirectory).Parent.FullName;
string inputPath = Path.Combine(projectDirectory, @"Resources\toRename.txt");
VariableMethods.CreateTestVariable(inputPath, _engine, "inputPath", typeof(string));
string newName = "newname.txt";
VariableMethods.CreateTestVariable(newName, _engine, "newName", typeof(string));
_renameFile.v_SourceFilePath = "{inputPath}";
_renameFile.v_NewName = "{newName}";
_renameFile.RunCommand(_engine);
string newFile = Path.Combine(projectDirectory, @"Resources\" + newName);
Assert.True(IO.File.Exists(newFile));
resetTestFilename(newFile);
}
public async void ExtractsAllBeforeText()
{
_engine = new AutomationEngineInstance(null);
_textExtraction = new TextExtractionCommand();
string input = "This is an example sentence";
OBData.DataTable extractParams = new OBData.DataTable();
extractParams.Columns.Add("Parameter Name");
extractParams.Columns.Add("Parameter Value");
DataRow row1 = extractParams.NewRow();
row1["Parameter Name"] = "Trailing Text";
row1["Parameter Value"] = "{trailingText}";
extractParams.Rows.Add(row1);
DataRow row2 = extractParams.NewRow();
row2["Parameter Name"] = "Skip Past Occurences";
row2["Parameter Value"] = "0";
extractParams.Rows.Add(row2);
VariableMethods.CreateTestVariable(" an example sentence", _engine, "trailingText", typeof(string));
VariableMethods.CreateTestVariable(input, _engine, "input", typeof(string));
VariableMethods.CreateTestVariable(null, _engine, "output", typeof(string));
_textExtraction.v_InputText = "{input}";
_textExtraction.v_TextExtractionType = "Extract All Before Text";
_textExtraction.v_TextExtractionTable = extractParams;
_textExtraction.v_OutputUserVariableName = "{output}";
_textExtraction.RunCommand(_engine);
Assert.Equal("This is", (string)await "{output}".EvaluateCode(_engine));
}
public void GetsOutlookEmailProperty(string prop, string propValue)
{
_engine = new AutomationEngineInstance(null);
_getOutlookEmails = new GetOutlookEmailsCommand();
_getOutlookEmailProperty = new GetOutlookEmailPropertyCommand();
VariableMethods.CreateTestVariable(null, _engine, "emails", typeof(List <>));
_getOutlookEmails.v_SourceFolder = "TestInput";
_getOutlookEmails.v_Filter = "[Subject] = 'subjectProp'";
_getOutlookEmails.v_GetUnreadOnly = "No";
_getOutlookEmails.v_MarkAsRead = "No";
_getOutlookEmails.v_SaveMessagesAndAttachments = "No";
_getOutlookEmails.v_MessageDirectory = "";
_getOutlookEmails.v_AttachmentDirectory = "";
_getOutlookEmails.v_OutputUserVariableName = "{emails}";
_getOutlookEmails.RunCommand(_engine);
var emails = (List <MailItem>) "{emails}".ConvertUserVariableToObject(_engine, typeof(List <>));
MailItem email = emails[0];
VariableMethods.CreateTestVariable(email, _engine, "email", typeof(MailItem));
VariableMethods.CreateTestVariable(null, _engine, "property", typeof(string));
_getOutlookEmailProperty.v_MailItem = "{email}";
_getOutlookEmailProperty.v_Property = prop;
_getOutlookEmailProperty.v_OutputUserVariableName = "{property}";
_getOutlookEmailProperty.RunCommand(_engine);
Assert.Equal(propValue, "{property}".ConvertUserVariableToString(_engine));
}
private async void resetCopyEmail(AutomationEngineInstance _engine)
{
_deleteOutlookEmail = new DeleteOutlookEmailCommand();
_getOutlookEmails = new GetOutlookEmailsCommand();
VariableMethods.CreateTestVariable(null, _engine, "emails", typeof(List <>));
_getOutlookEmails.v_SourceFolder = "MovedMail";
_getOutlookEmails.v_Filter = "[Subject] = 'toCopy'";
_getOutlookEmails.v_GetUnreadOnly = "No";
_getOutlookEmails.v_MarkAsRead = "No";
_getOutlookEmails.v_SaveMessagesAndAttachments = "No";
_getOutlookEmails.v_MessageDirectory = "";
_getOutlookEmails.v_AttachmentDirectory = "";
_getOutlookEmails.v_OutputUserVariableName = "{emails}";
_getOutlookEmails.RunCommand(_engine);
var emails = (List <MailItem>)await "{emails}".EvaluateCode(_engine);
MailItem email = emails[0];
VariableMethods.CreateTestVariable(email, _engine, "email", typeof(MailItem));
_deleteOutlookEmail.v_MailItem = "{email}";
_deleteOutlookEmail.v_DeleteReadOnly = "No";
_deleteOutlookEmail.RunCommand(_engine);
}
public void removesDataRow(string search, string andOr, int expectedIndex, string expectedName)
{
_removeDataRow = new RemoveDataRowCommand();
_engine = new AutomationEngineInstance(null);
OBData.DataTable inputTable = new OBData.DataTable();
inputTable.Columns.Add("firstname");
inputTable.Columns.Add("lastname");
DataRow row1 = inputTable.NewRow();
row1["firstname"] = "john";
row1["lastname"] = "smith";
inputTable.Rows.Add(row1);
DataRow row2 = inputTable.NewRow();
row2["firstname"] = "jane";
row2["lastname"] = "smith";
inputTable.Rows.Add(row2);
DataRow row3 = inputTable.NewRow();
row3["firstname"] = "jane";
row3["lastname"] = "doe";
inputTable.Rows.Add(row3);
VariableMethods.CreateTestVariable(inputTable, _engine, "inputTable", typeof(OBData.DataTable));
_removeDataRow.v_DataTable = "{inputTable}";
_removeDataRow.v_SearchItem = search;
_removeDataRow.v_AndOr = andOr;
_removeDataRow.RunCommand(_engine);
OBData.DataTable outputTable = (OBData.DataTable)_removeDataRow.v_DataTable.ConvertUserVariableToObject(_engine, typeof(OBData.DataTable));
Assert.True(outputTable.Rows[expectedIndex][0].Equals(expectedName));
}
public async void AddsDataRow()
{
_addDataRow = new AddDataRowCommand();
_engine = new AutomationEngineInstance(null);
OBData.DataTable inputTable = new OBData.DataTable();
inputTable.Columns.Add("firstname");
inputTable.Columns.Add("lastname");
DataRow inputrow = inputTable.NewRow();
inputrow["firstname"] = "john";
inputrow["lastname"] = "smith";
VariableMethods.CreateTestVariable(inputTable, _engine, "inputTable", typeof(OBData.DataTable));
_addDataRow.v_DataTable = "{inputTable}";
OBData.DataRow newrow = _addDataRow.v_DataRowDataTable.NewRow();
newrow["Column Name"] = "firstname";
newrow["Data"] = "john";
OBData.DataRow newrow2 = _addDataRow.v_DataRowDataTable.NewRow();
newrow2["Column Name"] = "lastname";
newrow2["Data"] = "smith";
_addDataRow.v_DataRowDataTable.Rows.Add(newrow);
_addDataRow.v_DataRowDataTable.Rows.Add(newrow2);
_addDataRow.RunCommand(_engine);
OBData.DataTable outputTable = (OBData.DataTable) await _addDataRow.v_DataTable.EvaluateCode(_engine);
Assert.Equal(inputTable.Rows[0]["firstname"], outputTable.Rows[0]["firstname"]);
Assert.Equal(inputTable.Rows[0]["lastname"], outputTable.Rows[0]["lastname"]);
}
public void AddsDictionaryItem()
{
_addDictionaryItem = new AddDictionaryItemCommand();
_engine = new AutomationEngineInstance(null);
Dictionary <string, string> inputDict = new Dictionary <string, string>();
VariableMethods.CreateTestVariable(inputDict, _engine, "inputDict", typeof(Dictionary <,>));
OBData.DataTable inputTable = new OBData.DataTable();
inputTable.Columns.Add("Keys");
inputTable.Columns.Add("Values");
DataRow row1 = inputTable.NewRow();
row1["Keys"] = "key1";
row1["Values"] = "val1";
inputTable.Rows.Add(row1);
VariableMethods.CreateTestVariable(inputTable, _engine, "inputTable", typeof(OBData.DataTable));
_addDictionaryItem.v_DictionaryName = "{inputDict}";
_addDictionaryItem.v_ColumnNameDataTable = (OBData.DataTable) "{inputTable}".ConvertUserVariableToObject(_engine, typeof(OBData.DataTable));
_addDictionaryItem.RunCommand(_engine);
Assert.Equal("val1", inputDict["key1"]);
}
public void UpdatesStringListItem()
{
_engine = new AutomationEngineInstance(null);
_updateListItem = new UpdateListItemCommand();
List <string> inputList = new List <string>();
inputList.Add("item1");
inputList.Add("item2");
string index = "0";
string item = "item3";
VariableMethods.CreateTestVariable(inputList, _engine, "inputList", typeof(List <>));
VariableMethods.CreateTestVariable(index, _engine, "index", typeof(string));
VariableMethods.CreateTestVariable(item, _engine, "item", typeof(string));
_updateListItem.v_ListName = "{inputList}";
_updateListItem.v_ListIndex = "{index}";
_updateListItem.v_ListItem = "{item}";
_updateListItem.RunCommand(_engine);
List <string> outputList = (List <string>) "{inputList}".ConvertUserVariableToObject(_engine, typeof(List <>));
Assert.Equal("item3", outputList[0]);
}
public async void SetFailedFatallyStatus()
{
_engine = new AutomationEngineInstance(null);
_setQueueItem = new SetQueueItemStatusCommand();
string name = "FailedQueueItem";
AddQueueItem(name);
var queueItemDict = await WorkQueueItem();
var transactionKey = queueItemDict["LockTransactionKey"].ToString();
var userInfo = ServerSessionVariableMethods.GetUserInfo(_engine);
var queueItem = QueueItemMethods.GetQueueItemByLockTransactionKey(userInfo, transactionKey.ToString());
VariableMethods.CreateTestVariable(null, _engine, "vQueueItem", typeof(Dictionary <,>));
_setQueueItem.v_QueueItem = "{vQueueItem}";
queueItemDict.SetVariableValue(_engine, _setQueueItem.v_QueueItem);
_setQueueItem.v_QueueItemStatusType = "Failed - Fatal";
_setQueueItem.RunCommand(_engine);
queueItem = QueueItemMethods.GetQueueItemById(userInfo, queueItem.Id);
Assert.Equal("Failed", queueItem.State);
}
public void UpdatesDataTableListItem()
{
_engine = new AutomationEngineInstance(null);
_updateListItem = new UpdateListItemCommand();
List <OBDataTable> inputList = new List <OBDataTable>();
OBDataTable item1 = new OBDataTable();
item1.Columns.Add("d1col");
OBDataTable item2 = new OBDataTable();
item2.Columns.Add("d2col");
inputList.Add(item1);
inputList.Add(item2);
string index = "0";
OBDataTable newitem = new OBDataTable();
newitem.Columns.Add("d3col");
VariableMethods.CreateTestVariable(inputList, _engine, "inputList", typeof(List <>));
VariableMethods.CreateTestVariable(index, _engine, "index", typeof(string));
VariableMethods.CreateTestVariable(newitem, _engine, "newitem", typeof(OBDataTable));
_updateListItem.v_ListName = "{inputList}";
_updateListItem.v_ListIndex = "{index}";
_updateListItem.v_ListItem = "{newitem}";
_updateListItem.RunCommand(_engine);
List <OBDataTable> outputList = (List <OBDataTable>) "{inputList}".ConvertUserVariableToObject(_engine, typeof(List <>));
Assert.Equal(newitem, outputList[0]);
}
public void CreatesDictionary()
{
_createDictionary = new CreateDictionaryCommand();
_engine = new AutomationEngineInstance(null);
OBData.DataTable inputDt = new OBData.DataTable();
inputDt.Columns.Add("Keys");
inputDt.Columns.Add("Values");
DataRow row1 = inputDt.NewRow();
row1["Keys"] = "key1";
row1["Values"] = "val1";
inputDt.Rows.Add(row1);
VariableMethods.CreateTestVariable(inputDt, _engine, "inputDt", typeof(OBData.DataTable));
VariableMethods.CreateTestVariable(null, _engine, "output", typeof(Dictionary <,>));
_createDictionary.v_ColumnNameDataTable = (OBData.DataTable) "{inputDt}".ConvertUserVariableToObject(_engine, typeof(OBData.DataTable));
_createDictionary.v_OutputUserVariableName = "{output}";
_createDictionary.RunCommand(_engine);
Dictionary <string, string> outDict = (Dictionary <string, string>) "{output}".ConvertUserVariableToObject(_engine, typeof(Dictionary <,>));
Assert.True(outDict.ContainsKey("key1"));
Assert.Equal("val1", outDict["key1"]);
}
public async void UpdatesNumberAsset()
{
_engine = new AutomationEngineInstance(null);
_updateAsset = new UpdateAssetCommand();
_getAsset = new GetAssetCommand();
string assetName = "testNumberAsset";
string newAsset = "70";
VariableMethods.CreateTestVariable(assetName, _engine, "assetName", typeof(string));
VariableMethods.CreateTestVariable(newAsset, _engine, "newAsset", typeof(string));
VariableMethods.CreateTestVariable(null, _engine, "output", typeof(string));
_updateAsset.v_AssetName = "{assetName}";
_updateAsset.v_AssetType = "Number";
_updateAsset.v_AssetFilePath = "";
_updateAsset.v_AssetValue = "{newAsset}";
_updateAsset.RunCommand(_engine);
_getAsset.v_AssetName = "{assetName}";
_getAsset.v_AssetType = "Number";
_getAsset.v_OutputUserVariableName = "{output}";
_getAsset.RunCommand(_engine);
string outputAsset = (string)await "{output}".EvaluateCode(_engine);
Assert.Equal("70", outputAsset);
resetAsset(assetName, "42", "Number");
}
public async void ParsesJSONModel()
{
_parseJSONModel = new ParseJSONModelCommand();
_engine = new AutomationEngineInstance(null);
string jsonObject = "{\"rect\":{\"length\":10, \"width\":5}}";
VariableMethods.CreateTestVariable(jsonObject, _engine, "input", typeof(string));
string selector = "rect.length";
VariableMethods.CreateTestVariable(selector, _engine, "selector", typeof(string));
VariableMethods.CreateTestVariable(null, _engine, "r1output", typeof(List <>));
OBDataTable selectorTable = new OBDataTable();
selectorTable.Columns.Add("Json Selector");
selectorTable.Columns.Add("Output Variable");
DataRow row1 = selectorTable.NewRow();
row1["Json Selector"] = "{selector}";
row1["Output Variable"] = "{r1output}";
selectorTable.Rows.Add(row1);
_parseJSONModel.v_JsonObject = "{input}";
_parseJSONModel.v_ParseObjects = selectorTable;
_parseJSONModel.RunCommand(_engine);
List <string> resultList = (List <string>)await "{r1output}".EvaluateCode(_engine);
Assert.Equal("10", resultList[0]);
}
public async void UpdatesJsonAsset()
{
_engine = new AutomationEngineInstance(null);
_updateAsset = new UpdateAssetCommand();
_getAsset = new GetAssetCommand();
string assetName = "testJsonAsset";
string newAsset = "{ \"text\": \"newText\" }";
VariableMethods.CreateTestVariable(assetName, _engine, "assetName", typeof(string));
VariableMethods.CreateTestVariable(newAsset, _engine, "newAsset", typeof(string));
VariableMethods.CreateTestVariable(null, _engine, "output", typeof(string));
_updateAsset.v_AssetName = "{assetName}";
_updateAsset.v_AssetType = "Json";
_updateAsset.v_AssetFilePath = "";
_updateAsset.v_AssetValue = "{newAsset}";
_updateAsset.RunCommand(_engine);
_getAsset.v_AssetName = "{assetName}";
_getAsset.v_AssetType = "Json";
_getAsset.v_OutputUserVariableName = "{output}";
_getAsset.RunCommand(_engine);
JObject outputAsset = (JObject)await "{output}".EvaluateCode(_engine);
Assert.Equal("newText", outputAsset["text"]);
resetAsset(assetName, "{ \"text\": \"testText\" }", "Json");
}
public async void getsDataRowValue(string option)
{
_getDataRowValue = new GetDataRowValueCommand();
_engine = new AutomationEngineInstance(null);
OBData.DataTable inputTable = new OBData.DataTable();
inputTable.Columns.Add("col1");
DataRow row = inputTable.NewRow();
row["col1"] = "data11";
inputTable.Rows.Add(row);
VariableMethods.CreateTestVariable(row, _engine, "inputRow", typeof(DataRow));
VariableMethods.CreateTestVariable(null, _engine, "outputValue", typeof(string));
_getDataRowValue.v_DataRow = "{inputRow}";
_getDataRowValue.v_Option = option;
if (option == "Column Name")
{
_getDataRowValue.v_DataValueIndex = "col1";
}
else
{
_getDataRowValue.v_DataValueIndex = "0";
}
_getDataRowValue.v_OutputUserVariableName = "{outputValue}";
_getDataRowValue.RunCommand(_engine);
string outputValue = (string)await _getDataRowValue.v_OutputUserVariableName.EvaluateCode(_engine);
Assert.Equal(inputTable.Rows[0]["col1"], outputValue);
}
public void AddsNumberAsset()
{
_engine = new AutomationEngineInstance(null);
_calculateAsset = new CalculateNumberAssetCommand();
_getAsset = new GetAssetCommand();
string assetName = "testIncrementNumberAsset";
string newAsset = "54";
VariableMethods.CreateTestVariable(assetName, _engine, "assetName", typeof(string));
VariableMethods.CreateTestVariable(newAsset, _engine, "newAsset", typeof(string));
VariableMethods.CreateTestVariable(null, _engine, "output", typeof(string));
_calculateAsset.v_AssetName = "{assetName}";
_calculateAsset.v_AssetActionType = "Add";
_calculateAsset.v_AssetActionValue = "5";
_calculateAsset.RunCommand(_engine);
_getAsset.v_AssetName = "{assetName}";
_getAsset.v_AssetType = "Number";
_getAsset.v_OutputUserVariableName = "{output}";
_getAsset.RunCommand(_engine);
string outputAsset = "{output}".ConvertUserVariableToString(_engine);
Assert.Equal(newAsset, outputAsset);
resetAsset(assetName, "49", "Number");
}
public void GetsFiles()
{
_engine = new AutomationEngineInstance(null);
_getFiles = new GetFilesCommand();
string projectDirectory = Directory.GetParent(Environment.CurrentDirectory).Parent.FullName;
string inputPath = Path.Combine(projectDirectory, @"Resources");
VariableMethods.CreateTestVariable(inputPath, _engine, "inputPath", typeof(string));
VariableMethods.CreateTestVariable(null, _engine, "output", typeof(List <>));
_getFiles.v_SourceFolderPath = "{inputPath}";
_getFiles.v_OutputUserVariableName = "{output}";
_getFiles.RunCommand(_engine);
List <string> fileList = (List <string>) "{output}".ConvertUserVariableToObject(_engine, typeof(List <>));
List <string> filenames = new List <string>();
foreach (string file in fileList)
{
output.WriteLine(file);
string[] splitPath = file.Split('\\');
string filename = splitPath[splitPath.Length - 1];
filenames.Add(filename);
}
Assert.Contains("compressed.zip", filenames);
Assert.Contains("toCompress.txt", filenames);
}
public void ExtractsFiles()
{
_engine = new AutomationEngineInstance(null);
_extractFiles = new ExtractFilesCommand();
string projectDirectory = Directory.GetParent(Environment.CurrentDirectory).Parent.FullName;
string inputPath = Path.Combine(projectDirectory, @"Resources\compressed.zip");
VariableMethods.CreateTestVariable(inputPath, _engine, "inputPath", typeof(string));
string outputPath = Environment.CurrentDirectory;
VariableMethods.CreateTestVariable(outputPath, _engine, "outputPath", typeof(string));
VariableMethods.CreateTestVariable(null, _engine, "output", typeof(List <>));
_extractFiles.v_FilePathOrigin = "{inputPath}";
_extractFiles.v_PathDestination = "{outputPath}";
_extractFiles.v_OutputUserVariableName = "{output}";
_extractFiles.RunCommand(_engine);
Assert.True(IO.File.Exists(Path.Combine(outputPath, @"compressed\compressed.txt")));
Assert.True(Directory.Exists(Path.Combine(outputPath, @"compressed\emptyFolder")));
Assert.True(IO.File.Exists(Path.Combine(outputPath, @"compressed\subfolder\subfolder2\deepfile.txt")));
IO.File.Delete(Path.Combine(outputPath, @"compressed\compressed.txt"));
Directory.Delete(Path.Combine(outputPath, @"compressed\emptyFolder"));
IO.File.Delete(Path.Combine(outputPath, @"compressed\subfolder\subfolder2\deepfile.txt"));
Directory.Delete(Path.Combine(outputPath, @"compressed\subfolder\subfolder2"));
Directory.Delete(Path.Combine(outputPath, @"compressed\subfolder"));
Directory.Delete(Path.Combine(outputPath, @"compressed"));
}
public void WorkQueueItemNoAttachments()
{
_engine = new AutomationEngineInstance(null);
_addQueueItem = new AddQueueItemCommand();
_workQueueItem = new WorkQueueItemCommand();
VariableMethods.CreateTestVariable(null, _engine, "output", typeof(Dictionary <,>));
_addQueueItem.v_QueueName = "UnitTestQueue";
_addQueueItem.v_QueueItemName = "WorkQueueItemNoAttachmentTest";
_addQueueItem.v_QueueItemType = "Text";
_addQueueItem.v_JsonType = "Test Type";
_addQueueItem.v_QueueItemTextValue = "Test Text";
_addQueueItem.v_Priority = "10";
_addQueueItem.RunCommand(_engine);
_workQueueItem.v_QueueName = "UnitTestQueue";
_workQueueItem.v_OutputUserVariableName = "{output}";
_workQueueItem.v_SaveAttachments = "No";
_workQueueItem.v_AttachmentDirectory = "";
_workQueueItem.RunCommand(_engine);
var queueItemObject = (Dictionary <string, object>) "{output}".ConvertUserVariableToObject(_engine, typeof(Dictionary <,>));
var client = AuthMethods.GetAuthToken();
var queueItem = QueueItemMethods.GetQueueItemByLockTransactionKey(client, queueItemObject["LockTransactionKey"].ToString());
Assert.Equal("InProgress", queueItem.State);
}
public void CorrectlyPerformsOperation(DateTime input, string calcMethod, string increment, dynamic expectedResult)
{
_dateCalculation = new DateCalculationCommand();
_engine = new AutomationEngineInstance(null);
string defaultFormat = "MM/dd/yyyy hh:mm:ss";
if (calcMethod.Contains("Get"))
{
defaultFormat = null;
}
VariableMethods.CreateTestVariable(defaultFormat, _engine, "format", typeof(string));
VariableMethods.CreateTestVariable(increment, _engine, "increment", typeof(string));
VariableMethods.CreateTestVariable(input, _engine, "inputDate", typeof(string));
VariableMethods.CreateTestVariable(null, _engine, "output", typeof(string));
_dateCalculation.v_InputDate = "{inputDate}";
_dateCalculation.v_CalculationMethod = calcMethod;
_dateCalculation.v_Increment = "{increment}";
_dateCalculation.v_ToStringFormat = defaultFormat != null ? "{format}":null;
_dateCalculation.v_OutputUserVariableName = "{output}";
_dateCalculation.RunCommand(_engine);
if (expectedResult.GetType() == typeof(DateTime))
{
Assert.Equal(expectedResult.ToString(defaultFormat), _dateCalculation.v_OutputUserVariableName.ConvertUserVariableToString(_engine));
}
else if (expectedResult.GetType() == typeof(int))
{
Assert.Equal(expectedResult, Int32.Parse(_dateCalculation.v_OutputUserVariableName.ConvertUserVariableToString(_engine)));
}
}
