public void InvalidSearchPattern()
{
Assert.ThrowsException <InvalidWorkflowException>(() =>
WorkflowTester.CompileAndRun(new CleanUpFolder
{
SearchPattern = new InArgument <int>(100)
}, GetArgs(IOSamples.GetTestPath(), null)));
}
public void InvalidPath()
{
int filesCount = 0;
Assert.ThrowsException <FileNotFoundException>(() => WorkflowTester.Run(new ZipEntriesCount()
{
FilesCount = new System.Activities.OutArgument <int>(_ => filesCount)
}, GetArgs("../fake.zip")));
}
public void DefaultString()
{
var result = WorkflowTester.Invoke(new ExtractDataColumnValues <string>()
{
Column = new InArgument <string>("Col0")
}, GetArgs(Initialize(), "Col0"));
CollectionAssert.AreEqual(new[] { "A", "B", "C" }, result);
}
public void DefaultInt()
{
var result = WorkflowTester.Invoke(new ExtractDataColumnValues <int>()
{
Column = new InArgument <int>(1)
}, GetArgs(Initialize(), 1));
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, result);
}
[DataRow("A11", "ftp://some.ftp.com", "FTP")] // without '/' on the end
public void OLE2(string cell, string link, string label)
{
var args = CreateInsertHyperlinkArgs(_ole2file, cell, link, label);
var workflow = new InsertHyperlink {
UseScope = false
};
var result = WorkflowTester.Invoke(workflow, args);
Assert.IsTrue(result);
}
public async Task Default()
{
var createFile = CreateFileAfter(1);
var result = WorkflowTester.Run(new WaitDynamicFile(), GetArgs(IOSamples.GetTestPath("output"), null));
var expectedFileName = await createFile.ConfigureAwait(false);
var info = result.Get(p => p.Result) as FileInfo;
Assert.AreEqual(Path.GetFullPath(expectedFileName), info.FullName);
}
public void InvalidArgs()
{
Assert.ThrowsException <InvalidWorkflowException>(() => WorkflowTester.CompileAndInvoke(new EnumerateFiles()
{
Path = new InArgument <int>(10),
SearchPattern = new InArgument <bool>(true)
}));
Assert.ThrowsException <ArgumentException>(() => WorkflowTester.CompileAndInvoke(new EnumerateFiles()));
}
public void Default(string alg)
{
CodeActivity <IEncryption> handler = null;
switch (alg)
{
case nameof(AesAlgorithmEncryption):
handler = new AesAlgorithmEncryption();
break;
case nameof(DESAlgorithmEncryption):
handler = new DESAlgorithmEncryption();
break;
case nameof(RC2AlgorithmEncryption):
handler = new RC2AlgorithmEncryption();
break;
case nameof(RijndaelAlgorithmEncryption):
handler = new RijndaelAlgorithmEncryption();
break;
case nameof(TripleDESAlgorithmEncryption):
handler = new TripleDESAlgorithmEncryption();
break;
#if NET5_0
case nameof(AesGcmAlgorithmEncryption):
handler = new AesGcmAlgorithmEncryption();
break;
#endif
}
var text = Guid.NewGuid().ToString();
var secureString = new NetworkCredential("", CryptoKey).SecurePassword;
var activity = new TextEncryption()
{
Algorithm = new ActivityFunc <IEncryption>()
{
Handler = handler
},
Key = new InArgument <SecureString>(_ => secureString)
};
var encrypted = WorkflowTester.CompileAndInvoke(activity, GetArgs(text));
Assert.IsNotNull(encrypted);
Assert.AreNotEqual(text, encrypted);
activity.Action = Core.Enums.CryptoActions.Decrypt;
var decrypted = WorkflowTester.CompileAndInvoke(activity, GetArgs(encrypted));
Assert.IsNotNull(decrypted);
Assert.AreNotEqual(encrypted, decrypted);
Assert.AreEqual(text, decrypted);
}
public void Default(DataRowEvaluationMode valuesMode, int expectedCount)
{
var dt = Initialize();
var result = WorkflowTester.Invoke(new RemoveEmptyRows()
{
Mode = valuesMode
}, GetArgs(dt));
Assert.AreEqual(expectedCount, result.Rows.Count);
}
public void OpenXML(int expectedResult, string cellRange)
{
InsertHyperlinks(_openXmlFile);
var args = CreateRemoveHyperlinksArgs(_openXmlFile, cellRange);
var workflow = new RemoveHyperlinks {
UseScope = false
};
var result = WorkflowTester.Invoke(workflow, args);
Assert.AreEqual(expectedResult, result);
}
public void EmptyColumnName(string emptyColumnName)
{
var dt = DataTableHelper.CreateDataTable <string>(2, new[] {
new string[] { "A", "B" }
});
Assert.ThrowsException <InvalidWorkflowException>(() => WorkflowTester.Run(new PromoteHeaders
{
EmptyColumnName = emptyColumnName,
}, GetArgs(dt, null)));
}
public void Default(string sampleFile, int expectedFilesCount, int expectedFoldersCount)
{
var extractTo = IOSamples.GetTestPath("unzip");
WorkflowTester.Run(new Unzip(), GetArgs(IOSamples.GetTestPath(sampleFile), extractTo));
var files = Directory.GetFiles(extractTo, "*", SearchOption.AllDirectories);
var folders = Directory.GetDirectories(extractTo, "*", SearchOption.AllDirectories);
Assert.AreEqual(expectedFilesCount, files.Length);
Assert.AreEqual(expectedFoldersCount, folders.Length);
}
public void OLE2(string file)
{
var path = IOSamples.GetTestPath(file);
var args = new Dictionary <string, object>
{
{ nameof(GetSheetNames.WorkbookPath), path }
};
var result = WorkflowTester.Invoke(new GetSheetNames(), args);
CollectionAssert.AreEqual(new[] { "Sheet1", "Sheet2", "Sheet3", "Sheet4" }, result);
}
public void InvalidColumnReference()
{
Assert.ThrowsException <ArgumentException>(() => WorkflowTester.Invoke(new ExtractDataColumnValues <int>
{
Column = new InArgument <string>("InvalidColName")
}, GetArgs(Initialize(), 1)));
Assert.ThrowsException <ArgumentException>(() => WorkflowTester.Invoke(new ExtractDataColumnValues <int>
{
Column = new InArgument <int>(3)
}, GetArgs(Initialize(), 1)));
}
public async Task SearchPattern()
{
_ = CreateFileAfter(1, ".json");
_ = CreateFileAfter(2, ".yml");
var createFile = CreateFileAfter(3, ".txt");
var result = WorkflowTester.Run(new WaitDynamicFile(), GetArgs(IOSamples.GetTestPath("output"), "*.txt"));
var expectedFileName = await createFile.ConfigureAwait(false);
var info = result.Get(p => p.Result) as FileInfo;
Assert.AreEqual(Path.GetFullPath(expectedFileName), info.FullName);
}
public void Default()
{
var result = WorkflowTester.Invoke(new TransposeData(), GetArgs(Initialize()));
Assert.AreEqual("Col1", result.Columns[0].ColumnName);
Assert.AreEqual("Col2", result.Columns[1].ColumnName);
Assert.AreEqual("Col3", result.Columns[2].ColumnName);
Assert.AreEqual("Col4", result.Columns[3].ColumnName);
CollectionAssert.AreEqual(new[] { "Product", "A", "B", "C" }, result.Rows[0].ItemArray);
CollectionAssert.AreEqual(new object[] { "Quantity", "1", "2", "3" }, result.Rows[1].ItemArray);
CollectionAssert.AreEqual(new[] { "Color", "Red", "Green", "Blue" }, result.Rows[2].ItemArray);
}
[DataRow(1, 30000)] // clamps 20000
public async Task Intervals(int secondsToCreateFile, int interval)
{
var createFile = CreateFileAfter(secondsToCreateFile, ".txt");
var result = WorkflowTester.Run(new WaitDynamicFile
{
Interval = interval
}, GetArgs(IOSamples.GetTestPath("output"), "*.txt"));
var expectedFileName = await createFile.ConfigureAwait(false);
var info = result.Get(p => p.Result) as FileInfo;
Assert.AreEqual(Path.GetFullPath(expectedFileName), info.FullName);
}
public void EmptyColumNames(string emptyColName)
{
var dt = DataTableHelper.CreateDataTable <string>(1, new[] {
new string[] { "" }
});
var result = WorkflowTester.Run(new PromoteHeaders(), GetArgs(dt, emptyColName));
var outDt = (DataTable)result.Get(p => p.Result);
Assert.AreEqual(0, outDt.Rows.Count);
Assert.AreEqual(emptyColName, outDt.Columns[0].ColumnName);
}
public void Custom(string cols, ConditionOperator op, int expectedCount)
{
var dt = Initialize();
var values = cols.Split(',').Select(int.Parse).ToArray();
var result = WorkflowTester.CompileAndInvoke(new RemoveEmptyRows
{
Columns = new InArgument <int[]>(_ => values),
Mode = DataRowEvaluationMode.Custom,
Operator = op,
}, GetArgs(dt));
Assert.AreEqual(expectedCount, result.Rows.Count);
}
public void Default(string fileName, int files, int folders)
{
int filesCount = 0;
var result = WorkflowTester.Run(new ZipEntriesCount
{
FilesCount = new System.Activities.OutArgument <int>(_ => filesCount)
}, GetArgs(IOSamples.GetSamplePath(fileName)));
Assert.AreEqual(files, filesCount);
Assert.AreEqual(files, result.Get(p => p.FilesCount));
Assert.AreEqual(folders, result.Get(p => p.FoldersCount));
Assert.AreEqual(files + folders, result.Get(p => p.EntriesCount));
}
public async Task WaitForExistAndInterval(int interval)
{
var createFile = CreateFileAfter(3, ".json");
var result = WorkflowTester.Run(new WaitFile
{
WaitForExist = true,
Interval = interval,
}, GetArgs(IOSamples.GetTestPath("output/sample.json")));
var expectedFileName = await createFile.ConfigureAwait(false);
var info = result.Get(p => p.Result) as FileInfo;
Assert.AreEqual("sample.json", info.Name);
}
public void Default(string searchPattern, SearchOption option)
{
var path = IOSamples.GetTestPath("output");
var enumFiles = Directory.EnumerateFiles(path, searchPattern ?? "*", option);
var result = WorkflowTester.CompileAndInvoke(new EnumerateFiles()
{
Path = new InArgument <string>(path),
SearchPattern = new InArgument <string>(searchPattern),
SearchOption = option
});
CollectionAssert.AreEqual(enumFiles.ToList(), result.ToList());
}
public void Default()
{
var tester = new ContainerTester();
var container = new Container();
container.Activities.Add(tester.PlusOne());
container.Activities.Add(tester.PlusOne());
container.Activities.Add(new Exit());
container.Activities.Add(tester.PlusOne());
tester.SetContainer(container);
var result = WorkflowTester.Invoke(tester);
Assert.AreEqual(2, result);
}
public void LastWriteTime(bool deleteEmptyFolders, int minutesToAdd, int filesDeleted, int foldersDeleted)
{
ChangeLastWriteTime();
var folder = IOSamples.GetTestPath();
var output = WorkflowTester.CompileAndRun(new CleanUpFolder
{
DeleteEmptyFolders = deleteEmptyFolders
}, GetArgs(folder, DateTime.Now.AddMinutes(minutesToAdd)));
var result = (CleanUpFolderResult)output.Get(p => p.Result);
Assert.AreEqual(filesDeleted, result.FilesDeleted);
Assert.AreEqual(foldersDeleted, result.FoldersDeleted);
Assert.AreEqual(filesDeleted + foldersDeleted, result.TotalDeleted);
}
public void Merge(string name)
{
var args = new Dictionary <string, object> {
{ "Source", _config2 },
{ "Destination", _config },
{ "SectionName", name }
};
var result = WorkflowTester.Run(new MergeConfig
{
Override = true
}, args);
Assert.IsNotNull(_config);
Assert.AreSame(_config, (ConfigSection)result.Get(p => p.Destination));
}
public void Default()
{
var dt = DataTableHelper.CreateDataTable <object>(7);
WorkflowTester.CompileAndRun(new RemoveDataColumns
{
Columns = new InArgument <int[]>(_ => new int[] { 1, 3 })
}, GetArgs(dt));
// 0,1,2,3,4,5,6
// 0,1,2,4,5,6 (index 3 removed)
// 0,2,4,5,6 (index 1 removed)
Assert.AreEqual(dt.Columns.Count, 5);
Assert.AreEqual(dt.Columns[1].ColumnName, "Col2");
Assert.AreEqual(dt.Columns[2].ColumnName, "Col4");
}
public void Condition(bool condition, int expected)
{
var tester = new ContainerTester();
var container = new Container();
container.Activities.Add(tester.PlusOne());
container.Activities.Add(new Exit {
Condition = new InArgument <bool>(condition)
});
container.Activities.Add(tester.PlusOne());
tester.SetContainer(container);
var result = WorkflowTester.Invoke(tester);
Assert.AreEqual(expected, result);
}
public void Default()
{
var dt = DataTableHelper.CreateDataTable <string>(3, new[] {
new string[] { "A", "B", "C" },
new string[] { "Row1", "Row1", "Row1" },
new string[] { "Row2", "Row2", "Row2" },
});
var result = WorkflowTester.Run(new PromoteHeaders(), GetArgs(dt, null));
var outDt = (DataTable)result.Get(p => p.Result);
Assert.AreEqual(2, outDt.Rows.Count);
Assert.AreEqual("A", outDt.Columns[0].ColumnName);
Assert.AreEqual("B", outDt.Columns[1].ColumnName);
Assert.AreEqual("C", outDt.Columns[2].ColumnName);
}
public void MultiplePathsAndPatterns()
{
var path1 = IOSamples.GetTestPath("output");
var path2 = IOSamples.GetTestPath("output/inner3/deeper");
var result = WorkflowTester.CompileAndInvoke(new EnumerateFiles()
{
Path = new InArgument <string[]>(_ => new[] { path1, path2 }),
SearchPattern = new InArgument <string[]>(_ => new[] { "*.json", "*.txt" }),
SearchOption = SearchOption.TopDirectoryOnly
});
var path1Res = Directory.EnumerateFiles(path1, "*.*", SearchOption.TopDirectoryOnly).Where(path => Path.GetExtension(path) != ".yml");
var path2Res = Directory.EnumerateFiles(path2, "*.json", SearchOption.TopDirectoryOnly);
CollectionAssert.AreEqual(path1Res.Concat(path2Res).ToArray(), result.ToArray());
}
public void OLE2(int expectedRemovedLinks, string cellRange)
{
InsertHyperlinks(_ole2file);
var args = CreateRemoveHyperlinksArgs(_ole2file, cellRange);
var workflow = new RemoveHyperlinks {
UseScope = false
};
var result = WorkflowTester.Invoke(workflow, args);
Assert.AreEqual(expectedRemovedLinks, result);
using (var adapter = new OLE2WorkbookAdapter())
{
adapter.Open(_ole2file);
var links = adapter.GetHyperlinks("Sheet1", "");
Assert.AreEqual(5 - expectedRemovedLinks, links.Count(), "remaining links differ");
}
}
