public void TestMockStep_ServiceTestOutputs_HaveOutput()
{
var originalAct = new Mock <DsfActivityAbstract <string> >();
var env = new ExecutionEnvironment();
var dataMock = new Mock <IDSFDataObject>();
dataMock.Setup(o => o.Environment).Returns(() => env);
const string theValue = "theValue";
var input = new Mock <IServiceTestOutput>();
input.Setup(o => o.Variable).Returns(() => "[[list()]]");
input.Setup(o => o.Value).Returns(() => theValue);
var outputs = new List <IServiceTestOutput>
{
input.Object
};
var act = new TestMockStep(originalAct.Object, outputs);
act.Execute(dataMock.Object, 0);
var results = env.EvalAsListOfStrings("[[@list()]]", 0);
Assert.AreEqual(theValue, results[0]);
}
public void DsfDotNetMultiAssignActivity_RecordSetTypeBlankReassign()
{
var env = new ExecutionEnvironment();
env.Assign("[[alist().other]]", "asdf", 0);
env.Assign("[[list().name]]", "fdsa", 0);
var data = new Mock <IDSFDataObject>();
data.Setup(o => o.Environment).Returns(() => env);
data.Setup(o => o.IsDebugMode()).Returns(() => true);
var ob = new DsfDotNetMultiAssignActivity
{
FieldsCollection = new List <ActivityDTO>
{
new ActivityDTO("[[list().name]]", "[[alist().other]]", 0)
}
};
ob.Execute(data.Object, 0);
var value = env.EvalAsListOfStrings("[[list().name]]", 0);
Assert.AreEqual("asdf", value[0]);
var outputs = ob.GetDebugOutputs(env, 0);
Assert.AreEqual("[[list(2).name]]", outputs[0].ResultsList[1].Variable);
}
public void DsfDateTimeActivity_Execute_Blank_ShouldHaveNoErrorWithDebugOutput()
{
//------------Setup for test--------------------------
const string varName = "[[dt]]";
var act = new DsfDotNetDateTimeActivity
{
DateTime = "",
InputFormat = "",
OutputFormat = "",
TimeModifierType = "",
TimeModifierAmount = 0,
Result = varName,
TimeModifierAmountDisplay = 0.ToString(CultureInfo.InvariantCulture)
};
var dataMock = new Mock <IDSFDataObject>();
dataMock.Setup(o => o.IsDebugMode()).Returns(() => true);
var executionEnvironment = new ExecutionEnvironment();
dataMock.Setup(o => o.Environment).Returns(executionEnvironment);
var data = dataMock.Object;
//------------Execute Test---------------------------
act.Execute(data, 0);
//------------Assert Results-------------------------
var debugout = act.GetDebugOutputs(executionEnvironment, 0);
var value = executionEnvironment.EvalAsListOfStrings(varName, 0);
Assert.AreEqual(1, value.Count);
Assert.IsTrue(DateTime.TryParse(value[0], out DateTime datetimeResult), $"Failed to parse value: {value[0]} as a DateTime");
Assert.AreEqual(false, debugout[0].ResultsList[0].HasError);
Assert.AreEqual(varName, debugout[0].ResultsList[0].Variable);
Assert.AreEqual(DebugItemResultType.Variable, debugout[0].ResultsList[0].Type);
}
public void WarewolfParse_Eval_Assign_MultipleEvals_Star()
{
var assigns = new List <IAssignValue>
{
new AssignValue("[[rec().a]]", "25"),
new AssignValue("[[rec().b]]", "33"),
new AssignValue("[[rec().b]]", "26"),
new AssignValue("[[rec(*).a]]", "27"),
};
var testEnv = WarewolfTestData.CreateTestEnvEmpty("");
var testEnv2 = PublicFunctions.EvalMultiAssign(assigns, 0, testEnv);
var env = new ExecutionEnvironment();
env.AssignWithFrame(new AssignValue("[[rec().a]]", "25"), 0);
env.AssignWithFrame(new AssignValue("[[rec().a]]", "26"), 0);
env.AssignWithFrame(new AssignValue("[[rec().a]]", "27"), 0);
env.AssignWithFrame(new AssignValue("[[rec(*).a]]", "28"), 0);
var items = env.EvalAsListOfStrings("[[rec(*).a]]", 0);
Assert.AreEqual(items.ToArray()[0], "28");
Assert.AreEqual(items.ToArray()[1], "28");
}
public void WarewolfParse_Eval_Assign_MultipleEvals_Star_NonExistent()
{
var assigns = new List <IAssignValue>
{
new AssignValue("[[rec().a]]", "25"),
new AssignValue("[[rec().b]]", "33"),
new AssignValue("[[rec().b]]", "26"),
new AssignValue("[[rec(*).a]]", "27"),
};
var testEnv = WarewolfTestData.CreateTestEnvEmpty("");
// ReSharper disable UnusedVariable
var testEnv2 = PublicFunctions.EvalMultiAssign(assigns, 0, testEnv);
// ReSharper restore UnusedVariable
ExecutionEnvironment env = new ExecutionEnvironment();
env.AssignWithFrame(new AssignValue("[[rec().a]]", "25"), 0);
env.AssignWithFrame(new AssignValue("[[rec().a]]", "26"), 0);
env.AssignWithFrame(new AssignValue("[[rec().a]]", "27"), 0);
env.AssignWithFrame(new AssignValue("[[rsec(*).a]]", "28"), 0);
var items = env.EvalAsListOfStrings("[[rsec(*).a]]", 0);
Assert.AreEqual(items.Count, 1);
Assert.AreEqual(items[0], "28");
}
public void ExecutionEnvironment_EvalAsListOfString_WhenRecSet_ShouldReturnListOfAllValues()
{
//------------Setup for test--------------------------
_environment.Assign("[[rec(1).a]]", "27", 0);
_environment.Assign("[[rec(1).b]]", "bob", 0);
_environment.Assign("[[rec(2).a]]", "31", 0);
_environment.Assign("[[rec(2).b]]", "mary", 0);
//------------Execute Test---------------------------
var list = _environment.EvalAsListOfStrings("[[rec(*)]]", 0).ToList();
//------------Assert Results-------------------------
Assert.IsNotNull(list);
Assert.AreEqual("27", list[0]);
Assert.AreEqual("31", list[1]);
Assert.AreEqual("bob", list[2]);
Assert.AreEqual("mary", list[3]);
}
public void GivenRecSet_ExecutionEnvironmentEvalAssignFromNestedLast_TwoColumn_Should()
{
Assert.IsNotNull(_environment);
var evalMultiAssign = EvalMultiAssignTwoColumn();
var items = PublicFunctions.EvalEnvExpression("[[rec(*).a]]", 0, false, evalMultiAssign);
var warewolfAtomListresult = items as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
_environment.EvalAssignFromNestedLast("[[rec().a]]", warewolfAtomListresult, 0);
items = PublicFunctions.EvalEnvExpression("[[rec(*).b]]", 0, false, evalMultiAssign);
warewolfAtomListresult = items as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
_environment.EvalAssignFromNestedLast("[[rec().b]]", warewolfAtomListresult, 0);
items = PublicFunctions.EvalEnvExpression("[[rec(*).c]]", 0, false, evalMultiAssign);
warewolfAtomListresult = items as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
_environment.EvalAssignFromNestedLast("[[rec().c]]", warewolfAtomListresult, 0);
evalMultiAssign = EvalMultiAssignTwoColumn();
items = PublicFunctions.EvalEnvExpression("[[rec(*).a]]", 0, false, evalMultiAssign);
warewolfAtomListresult = items as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
_environment.EvalAssignFromNestedLast("[[rec().a]]", warewolfAtomListresult, 0);
items = PublicFunctions.EvalEnvExpression("[[rec(*).b]]", 0, false, evalMultiAssign);
warewolfAtomListresult = items as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
_environment.EvalAssignFromNestedLast("[[rec().b]]", warewolfAtomListresult, 0);
items = PublicFunctions.EvalEnvExpression("[[rec(*).c]]", 0, false, evalMultiAssign);
warewolfAtomListresult = items as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
_environment.EvalAssignFromNestedLast("[[rec().c]]", warewolfAtomListresult, 0);
var list_a = _environment.EvalAsListOfStrings("[[rec(*).a]]", 0);
var list_b = _environment.EvalAsListOfStrings("[[rec(*).b]]", 0);
var list_c = _environment.EvalAsListOfStrings("[[rec(*).c]]", 0);
Assert.AreEqual(list_a.Count, 4);
Assert.AreEqual(list_b.Count, 4);
Assert.AreEqual(list_c.Count, 4);
Assert.IsTrue(list_a[0].Equals("a11"));
Assert.IsTrue(list_a[1].Equals("ayy"));
Assert.IsTrue(list_a[2].Equals("a11"));
Assert.IsTrue(list_a[3].Equals("ayy"));
Assert.IsTrue(list_b[0].Equals(""));
Assert.IsTrue(list_b[1].Equals("b33"));
Assert.IsTrue(list_b[2].Equals(""));
Assert.IsTrue(list_b[3].Equals("b33"));
Assert.IsTrue(list_c[0].Equals("c22"));
Assert.IsTrue(list_c[1].Equals("czz"));
Assert.IsTrue(list_c[2].Equals("c22"));
Assert.IsTrue(list_c[3].Equals("czz"));
}
public void DsfDateTimeActivity_Execute_InvalidDateTime_ShouldHaveErrorWithDebugOutput()
{
//------------Setup for test--------------------------
const string varName = "[[dt]]";
var act = new DsfDotNetDateTimeActivity
{
DateTime = "a/p/R",
InputFormat = "",
OutputFormat = "",
TimeModifierType = "",
TimeModifierAmount = 1,
Result = varName,
TimeModifierAmountDisplay = 1.ToString(CultureInfo.InvariantCulture)
};
var dataMock = new Mock <IDSFDataObject>();
dataMock.Setup(o => o.IsDebugMode()).Returns(() => true);
var executionEnvironment = new ExecutionEnvironment();
dataMock.Setup(o => o.Environment).Returns(executionEnvironment);
var data = dataMock.Object;
var timeBefore = DateTime.Now;
//------------Execute Test---------------------------
var activity = act.Execute(data, 0);
//------------Assert Results-------------------------
var timeAfter = DateTime.Now;
var debugout = act.GetDebugOutputs(executionEnvironment, 0);
var value = executionEnvironment.EvalAsListOfStrings(varName, 0);
Assert.AreEqual(value.Count, 1);
Assert.AreEqual("", value[0]);
Assert.AreEqual(false, debugout[0].ResultsList[0].HasError);
Assert.AreEqual(varName, debugout[0].ResultsList[0].Variable);
Assert.AreEqual(DebugItemResultType.Variable, debugout[0].ResultsList[0].Type);
Assert.AreEqual("The string was not recognized as a valid DateTime. There is an unknown word starting at index 0.", executionEnvironment.FetchErrors());
}
static IList <string> GetWarewolfCPUInfo(DsfDotNetGatherSystemInformationActivity ob, ExecutionEnvironment env, Mock <IDSFDataObject> data)
{
ob.Execute(data.Object, 0);
return(env.EvalAsListOfStrings("[[warewolfCPU]]", 0));
}
public void GetCorrectSystemInformation_MultipleInformationGatherShouldHaveValues()
{
var ob = new DsfDotNetGatherSystemInformationActivity
{
SystemInformationCollection = new List <GatherSystemInformationTO>
{
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.ComputerName, "[[computerName]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.OperatingSystem, "[[operatingSystem]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.OperatingSystemVersion, "[[operatingSystemVersion]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.ServicePack, "[[servicePack]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.OSBitValue, "[[oSBitValue]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime, "[[fullDateTime]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.DateTimeFormat, "[[dateTimeFormat]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.DiskAvailable, "[[diskAvailable]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.DiskTotal, "[[diskTotal]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.VirtualMemoryAvailable, "[[virtualMemoryAvailable]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.VirtualMemoryTotal, "[[virtualMemoryTotal]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.PhysicalMemoryAvailable, "[[physicalMemoryAvailable]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.PhysicalMemoryTotal, "[[physicalMemoryTotal]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.CPUAvailable, "[[cPUAvailable]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.CPUTotal, "[[cPUTotal]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.Language, "[[language]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.Region, "[[region]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.UserRoles, "[[userRoles]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.UserName, "[[userName]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.Domain, "[[domain]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.NumberOfServerNICS, "[[numberOfServerNICS]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.MacAddress, "[[macAddress]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.GateWayAddress, "[[gateWayAddress]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.DNSAddress, "[[dNSAddress]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.IPv4Address, "[[iPv4Address]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.IPv6Address, "[[iPv6Address]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.WarewolfMemory, "[[warewolfMemory]]", 1),
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.WarewolfServerVersion, "[[warewolfServerVersion]]", 1),
}
};
var env = new ExecutionEnvironment();
var data = new Mock <IDSFDataObject>();
data.Setup(o => o.Environment).Returns(env);
data.Setup(o => o.IsDebugMode()).Returns(() => true);
ob.Execute(data.Object, 0);
var outputs = ob.GetOutputs();
var computer = env.EvalAsListOfStrings(outputs[0], 0);
var computerName = env.EvalAsListOfStrings("[[computerName]]", 0);
Assert.AreEqual(System.Environment.MachineName, computerName[0], "[[computerName]]");
var operatingSystem = env.EvalAsListOfStrings("[[operatingSystem]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(operatingSystem[0]), "[[operatingSystem]]");
var operatingSystemVersion = env.EvalAsListOfStrings("[[operatingSystemVersion]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(operatingSystemVersion[0]), "[[operatingSystemVersion]]");
var servicePack = env.EvalAsListOfStrings("[[servicePack]]", 0);
Assert.AreEqual(1, servicePack.Count, "[[servicePack]]");
var oSBitValue = env.EvalAsListOfStrings("[[oSBitValue]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(oSBitValue[0]), "[[oSBitValue]]");
var fullDateTime = env.EvalAsListOfStrings("[[fullDateTime]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(fullDateTime[0]), "[[fullDateTime]]");
var dateTimeFormat = env.EvalAsListOfStrings("[[dateTimeFormat]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(dateTimeFormat[0]), "[[dateTimeFormat]]");
var diskAvailable = env.EvalAsListOfStrings("[[diskAvailable]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(diskAvailable[0]), "[[diskAvailable]]");
var diskTotal = env.EvalAsListOfStrings("[[diskTotal]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(diskTotal[0]), "[[diskTotal]]");
var virtualMemoryAvailable = env.EvalAsListOfStrings("[[virtualMemoryAvailable]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(virtualMemoryAvailable[0]), "[[virtualMemoryAvailable]]");
var virtualMemoryTotal = env.EvalAsListOfStrings("[[virtualMemoryTotal]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(virtualMemoryTotal[0]), "[[virtualMemoryTotal]]");
var physicalMemoryAvailable = env.EvalAsListOfStrings("[[physicalMemoryAvailable]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(physicalMemoryAvailable[0]), "[[physicalMemoryAvailable]]");
var physicalMemoryTotal = env.EvalAsListOfStrings("[[physicalMemoryTotal]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(physicalMemoryTotal[0]), "[[physicalMemoryTotal]]");
var cPUAvailable = env.EvalAsListOfStrings("[[cPUAvailable]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(cPUAvailable[0]), "[[cPUAvailable]]");
var cPUTotal = env.EvalAsListOfStrings("[[cPUTotal]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(cPUTotal[0]), "[[cPUTotal]]");
var language = env.EvalAsListOfStrings("[[language]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(language[0]), "[[language]]");
var region = env.EvalAsListOfStrings("[[region]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(region[0]), "[[region]]");
var userRoles = env.EvalAsListOfStrings("[[userRoles]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(userRoles[0]), "[[userRoles]]");
var userName = env.EvalAsListOfStrings("[[userName]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(userName[0]), "[[userName]]");
var domain = env.EvalAsListOfStrings("[[domain]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(domain[0]), "[[domain]]");
var numberOfServerNICS = env.EvalAsListOfStrings("[[numberOfServerNICS]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(numberOfServerNICS[0]), "[[numberOfServerNICS]]");
var macAddress = env.EvalAsListOfStrings("[[macAddress]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(macAddress[0]), "[[macAddress]]");
var gateWayAddress = env.EvalAsListOfStrings("[[gateWayAddress]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(gateWayAddress[0]), "[[gateWayAddress]]");
var dNSAddress = env.EvalAsListOfStrings("[[dNSAddress]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(dNSAddress[0]), "[[dNSAddress]]");
var iPv4Address = env.EvalAsListOfStrings("[[iPv4Address]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(iPv4Address[0]), "[[iPv4Address]]");
var iPv6Address = env.EvalAsListOfStrings("[[iPv6Address]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(iPv6Address[0]), "[[iPv6Address]]");
var warewolfMemory = env.EvalAsListOfStrings("[[warewolfMemory]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(warewolfMemory[0]), "[[warewolfMemory]]");
var warewolfServerVersion = env.EvalAsListOfStrings("[[warewolfServerVersion]]", 0);
Assert.IsFalse(string.IsNullOrWhiteSpace(warewolfServerVersion[0]), "[[warewolfServerVersion]]");
}
