private void AssignWithFrame(int update, XmlNode subc, IDev2Definition definition)
{
if (definition.MapsTo == subc.Name || definition.Name == subc.Name)
{
DataObj.Environment.AssignWithFrame(new AssignValue(definition.RawValue, subc.InnerXml), update);
}
}
public void EvalAssignRecordSets_GivenValidArgs_ShouldEvaluateCorrectlyAndAssignCorrectly()
{
//---------------Set up test pack-------------------
var innerEnvironment = new Mock <IExecutionEnvironment>();
innerEnvironment.Setup(executionEnvironment => executionEnvironment.Eval(It.IsAny <string>(), It.IsAny <int>()))
.Returns(CommonFunctions.WarewolfEvalResult.NewWarewolfAtomListresult(new WarewolfAtomList <DataStorage.WarewolfAtom>(DataStorage.WarewolfAtom.NewDataString("Value"))))
.Verifiable();
var environment = new Mock <IExecutionEnvironment>();
environment.Setup(executionEnvironment => executionEnvironment.EvalAssignFromNestedStar(It.IsAny <string>(), It.IsAny <CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult>(), It.IsAny <int>())).Verifiable();
environment.Setup(executionEnvironment => executionEnvironment.EvalAssignFromNestedLast(It.IsAny <string>(), It.IsAny <CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult>(), It.IsAny <int>())).Verifiable();
environment.Setup(executionEnvironment => executionEnvironment.EvalAssignFromNestedNumeric(It.IsAny <string>(), It.IsAny <CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult>(), It.IsAny <int>())).Verifiable();
var builder = new RecordSetCollectionBuilder();
IList <IDev2Definition> outputs = new IDev2Definition[]
{
new Dev2Definition("rec(*).LastName", "rec(*).LastName", "[[rec(*).LastName]]", "rec", false, "[[rec(*).LastName]]", true, "[[rec(*).LastName]]"),
new Dev2Definition("rec1().LastName", "rec1().LastName", "[[rec1().LastName]]", "rec1", false, "[[rec1().LastName]]", true, "[[rec1().LastName]]"),
new Dev2Definition("rec2(1).LastName", "rec2(1).LastName", "[[rec2(1).LastName]]", "rec2", false, "[[rec2(1).LastName]]", true, "[[rec2(1).LastName]]"),
};
builder.SetParsedOutput(new List <IDev2Definition>(outputs));
var outputRecSets = builder.Generate();
//---------------Execute Test ----------------------
var methodInfo = typeof(EnvironmentOutputMappingManager).GetMethod("TryEvalAssignRecordSets", BindingFlags.NonPublic | BindingFlags.Static);
//---------------Test Result -----------------------
methodInfo.Invoke(null, new object[] { innerEnvironment.Object, environment.Object, 1, outputRecSets, outputs });
environment.Verify(executionEnvironment => executionEnvironment.EvalAssignFromNestedStar(It.IsAny <string>(), It.IsAny <CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult>(), It.IsAny <int>()));
environment.Verify(executionEnvironment => executionEnvironment.EvalAssignFromNestedLast(It.IsAny <string>(), It.IsAny <CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult>(), It.IsAny <int>()));
environment.Verify(executionEnvironment => executionEnvironment.EvalAssignFromNestedNumeric(It.IsAny <string>(), It.IsAny <CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult>(), It.IsAny <int>()));
}
static void CreateObjectInputs(IExecutionEnvironment outerEnvironment, IDev2Definition dev2Definition, IExecutionEnvironment env, int update)
{
if (DataListUtil.RemoveLanguageBrackets(dev2Definition.RawValue).StartsWith("@"))
{
var jVal = outerEnvironment.EvalJContainer(dev2Definition.RawValue);
env.AddToJsonObjects(DataListUtil.AddBracketsToValueIfNotExist(dev2Definition.Name), jVal);
}
else
{
var result = outerEnvironment.Eval(dev2Definition.RawValue, update);
if (result.IsWarewolfAtomListresult)
{
if (result is CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult data && data.Item.Any())
{
env.AssignWithFrame(new AssignValue(DataListUtil.AddBracketsToValueIfNotExist(dev2Definition.Name), ExecutionEnvironment.WarewolfAtomToString(data.Item.Last())), 0);
}
}
else
{
if (result is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult data)
{
env.AssignWithFrame(new AssignValue(DataListUtil.AddBracketsToValueIfNotExist(dev2Definition.Name), ExecutionEnvironment.WarewolfAtomToString(data.Item)), 0);
}
}
}
}
static void ProcessRecordsetInputs(IServiceTestModelTO serviceTestModelTO, IDev2Definition dev2Definition)
{
var rec = DataListUtil.CreateRecordsetDisplayValue(dev2Definition.RecordSetName, dev2Definition.Name, "");
var indexes = serviceTestModelTO.Inputs.Where(input => DataListUtil.ExtractRecordsetNameFromValue(input.Variable) == dev2Definition.RecordSetName).Select(input => DataListUtil.ExtractIndexRegionFromRecordset(input.Variable)).Distinct(StringComparer.OrdinalIgnoreCase).ToList();
if (serviceTestModelTO.Inputs.FirstOrDefault(input => DataListUtil.ReplaceRecordsetIndexWithBlank(input.Variable) == rec) == null)
{
if (indexes.Count == 0)
{
serviceTestModelTO.Inputs.Add(new ServiceTestInputTO
{
Variable = DataListUtil.CreateRecordsetDisplayValue(dev2Definition.RecordSetName, dev2Definition.Name, "1"),
Value = "",
EmptyIsNull = false
});
}
else
{
foreach (var index in indexes)
{
serviceTestModelTO.Inputs.Add(new ServiceTestInputTO
{
Variable = DataListUtil.CreateRecordsetDisplayValue(dev2Definition.RecordSetName, dev2Definition.Name, index),
Value = "",
EmptyIsNull = false
});
}
}
}
}
public void EvalAssignScalars_GivenValidArgs_ShouldEvaluateCorrectlyAndAssignCorrectly()
{
//---------------Set up test pack-------------------
var innerEnvironment = new Mock <IExecutionEnvironment>();
innerEnvironment.Setup(executionEnvironment => executionEnvironment.Eval(It.IsAny <string>(), It.IsAny <int>()))
.Returns(CommonFunctions.WarewolfEvalResult.NewWarewolfAtomResult(DataStorage.WarewolfAtom.NewDataString("")))
.Verifiable();
var environment = new Mock <IExecutionEnvironment>();
environment.Setup(executionEnvironment => executionEnvironment.Assign(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>())).Verifiable();
IList <IDev2Definition> scalars = new IDev2Definition[]
{
new Dev2Definition("LastName", "LastName", "[[LastName]]", "", false, "[[LastName]]", true, "[[LastName]]"),
new Dev2Definition("LastName", "LastName", "[[LastName]]", "", false, "[[LastName]]", true, "[[LastName]]"),
new Dev2Definition("LastName", "LastName", "[[LastName]]", "", false, "[[LastName]]", true, "[[LastName]]"),
};
//---------------Execute Test ----------------------
var methodInfo = typeof(EnvironmentOutputMappingManager).GetMethod("TryEvalAssignScalars", BindingFlags.NonPublic | BindingFlags.Static);
//---------------Test Result -----------------------
methodInfo.Invoke(null, new object[] { innerEnvironment.Object, environment.Object, 1, scalars });
environment.Verify(executionEnvironment => executionEnvironment.Assign(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>()), Times.Exactly(3));
innerEnvironment.Verify(executionEnvironment => executionEnvironment.Eval(It.IsAny <string>(), It.IsAny <int>()));
}
static void CreateScalarInputs(IExecutionEnvironment outerEnvironment, IDev2Definition dev2Definition, IExecutionEnvironment env, int update)
{
void ScalarAtomList(CommonFunctions.WarewolfEvalResult warewolfEvalResult)
{
if (warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult data && data.Item.Any())
{
env.AssignWithFrame(new AssignValue("[[" + dev2Definition.Name + "]]", ExecutionEnvironment.WarewolfAtomToString(data.Item.Last())), 0);
}
}
void ScalarAtom(CommonFunctions.WarewolfEvalResult warewolfEvalResult)
{
if (warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult data)
{
env.AssignWithFrame(new AssignValue("[[" + dev2Definition.Name + "]]", ExecutionEnvironment.WarewolfAtomToString(data.Item)), 0);
}
}
if (!string.IsNullOrEmpty(dev2Definition.Name))
{
env.AssignDataShape("[[" + dev2Definition.Name + "]]");
}
if (!dev2Definition.IsRecordSet && !string.IsNullOrEmpty(dev2Definition.RawValue))
{
var warewolfEvalResult = outerEnvironment.Eval(dev2Definition.RawValue, update);
if (warewolfEvalResult.IsWarewolfAtomListresult)
{
ScalarAtomList(warewolfEvalResult);
}
else
{
ScalarAtom(warewolfEvalResult);
}
}
}
public void TestOutputParsingScalar()
{
IList <IDev2Definition> defs = DataListFactory.CreateOutputParser().Parse(TestStrings.sampleActivityMappingScalar);
IDev2Definition d = defs[0];
Assert.IsTrue(defs.Count == 3 && d.MapsTo == "fname" && d.Value == "firstName" && d.Name == "FirstName" && !d.IsRecordSet);
}
public void TestOutputParsingRecordSet()
{
IList <IDev2Definition> defs = DataListFactory.CreateOutputParser().Parse(TestStrings.sampleActivityMappingRecordSets);
IRecordSetCollection recCol = DataListFactory.CreateRecordSetCollectionForDbService(defs, true);
IDev2Definition d = defs[0];
Assert.IsTrue(d.IsRecordSet);
Assert.AreEqual("ppl", recCol.RecordSetNames[0]);
Assert.AreEqual("ppl().firstName", recCol.RecordSets[0].Columns[0].Value);
}
public void InputOutputMappingViewModel_GetGenerationTO_InvalidViewModel_Expected_NullDev2DefinitionCreated()
{
InputOutputViewModelTestObject testObject = new InputOutputViewModelTestObject {
Name = null
};
SetInputOutputMappingViewModelFromTestMappingObject(testObject);
IDev2Definition actual = _inputOutputViewModel.GetGenerationTO();
// Not sure of the outcome here, it is a null name value, and the name is the most essential part of this
Assert.IsNotNull(actual);
}
void AtomListInputs(CommonFunctions.WarewolfEvalResult warewolfEvalResult, IDev2Definition dev2ColumnDefinition, IExecutionEnvironment env)
{
var recsetResult = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
DataListUtil.GetRecordsetIndexType(dev2ColumnDefinition.Value);
if (recsetResult != null)
{
var correctRecSet = "[[" + dev2ColumnDefinition.RecordSetName + "(*)." + dev2ColumnDefinition.Name + "]]";
env.EvalAssignFromNestedStar(correctRecSet, recsetResult, 0);
}
}
private static void GetValue(IBinaryDataListEntry tmpEntry, IDev2Definition defn)
{
if (String.IsNullOrEmpty(defn.RecordSetName))
{
tmpEntry.FetchScalar(); // ask trav what this side effect means
}
else
{
string error;
tmpEntry.MakeRecordsetEvaluateReady(GlobalConstants.AllIndexes, GlobalConstants.AllColumns, out error);
}
}
void AtomInputs(CommonFunctions.WarewolfEvalResult warewolfEvalResult, IDev2Definition dev2ColumnDefinition, IExecutionEnvironment env)
{
var recsetResult = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult;
if (dev2ColumnDefinition.IsRecordSet)
{
if (recsetResult != null)
{
var correctRecSet = "[[" + dev2ColumnDefinition.RecordSetName + "(*)." + dev2ColumnDefinition.Name + "]]";
env.AssignWithFrame(new AssignValue(correctRecSet, PublicFunctions.AtomtoString(recsetResult.Item)), 0);
}
}
}
private void AddWarewolfAtomResults(List <IDebugItem> results, IDev2Definition dev2Definition, CommonFunctions.WarewolfEvalResult tmpEntry, DebugItem itemToAdd)
{
if (tmpEntry is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult warewolfAtomResult)
{
var variableName = dev2Definition.Name;
if (!string.IsNullOrEmpty(dev2Definition.RecordSetName))
{
variableName = DataListUtil.CreateRecordsetDisplayValue(dev2Definition.RecordSetName, dev2Definition.Name, "1");
}
AddDebugItem(new DebugItemWarewolfAtomResult(warewolfAtomResult.Item.ToString(), DataListUtil.AddBracketsToValueIfNotExist(variableName), ""), itemToAdd);
}
results.Add(itemToAdd);
}
string CreateInjectValue(bool isOutputMapping, FuzzyMatchVo fuzzyMatch, IDev2Definition def)
{
string injectValue;
// When output mapping we need to replace the recordset name if present with MasterRecordset
//
string masterRecordsetName;
if (isOutputMapping && def.IsRecordSet && fuzzyMatch != null)
{
var field = def.Name;
var recordsetName = fuzzyMatch.FetchMatch(def.Name, def.RecordSetName);
if (!string.IsNullOrEmpty(recordsetName))
{
masterRecordsetName = recordsetName;
}
else
{
// we have no match, use the current mapping value ;)
masterRecordsetName = def.RecordSetName;
}
injectValue = FormatString(masterRecordsetName, field);
}
else
{
if (def.IsRecordSet)
{
if (fuzzyMatch != null)
{
var recordsetName = fuzzyMatch.FetchMatch(def.Name, def.RecordSetName);
masterRecordsetName = !String.IsNullOrEmpty(recordsetName) ? recordsetName : def.RecordSetName;
}
else
{
masterRecordsetName = def.RecordSetName;
}
injectValue = FormatString(masterRecordsetName, def.Name);
}
else
{
injectValue = DataListUtil.AddBracketsToValueIfNotExist(def.Name);
}
}
return(injectValue);
}
public void EvalAssignComplexObjects_GivenValidArgs_ShouldEvaluateCorrectlyAndAssignCorreclty()
{
//---------------Set up test pack-------------------
//EvalAssignScalars(IExecutionEnvironment innerEnvironment, IExecutionEnvironment environment, int update, IEnumerable<IDev2Definition> outputScalarList)
var innerEnvironment = new Mock <IExecutionEnvironment>();
var valueFunction = JToken.Parse("{}") as JContainer;
innerEnvironment.Setup(executionEnvironment => executionEnvironment.EvalJContainer(It.IsAny <string>()))
.Returns(valueFunction)
.Verifiable();
var environment = new Mock <IExecutionEnvironment>();
environment.Setup(executionEnvironment => executionEnvironment.AddToJsonObjects(It.IsAny <string>(), It.IsAny <JContainer>())).Verifiable();
IList <IDev2Definition> scalars = new IDev2Definition[]
{
new Dev2Definition("@obj.LastName", "@obj.LastName", "[[@obj.LastName]]", "", false, "[[@obj.LastName]]", true, "[[@obj.LastName]]")
{
IsObject = true
},
new Dev2Definition("@obj.LastName", "@obj.LastName", "[[@obj.LastName]]", "", false, "[[@obj.LastName]]", true, "[[@obj.LastName]]")
{
IsObject = true
},
new Dev2Definition("@obj.LastName", "@obj.LastName", "[[@obj.LastName]]", "", false, "[[@obj.LastName]]", true, "[[@obj.LastName]]")
{
IsObject = true
},
};
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var methodInfo = typeof(EnvironmentOutputMappingManager).GetMethod("EvalAssignComplexObjects", BindingFlags.NonPublic | BindingFlags.Static);
try
{
//---------------Test Result -----------------------
methodInfo.Invoke(null, new object[] { innerEnvironment.Object, environment.Object, scalars });
environment.Verify(executionEnvironment => executionEnvironment.AddToJsonObjects(It.IsAny <string>(), It.IsAny <JContainer>()), Times.Exactly(3));
innerEnvironment.Verify(executionEnvironment => executionEnvironment.EvalJContainer(It.IsAny <string>()), Times.Exactly(3));
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
static string GetVariableName(IDev2Definition value)
{
string variableName;
if (value.IsJsonArray && value.Name.StartsWith("@", StringComparison.Ordinal))
{
variableName = $"[[{value.Name}()]]";
}
else if (string.IsNullOrEmpty(value.RecordSetName))
{
variableName = $"[[{value.Name}]]";
}
else
{
variableName = $"[[{value.RecordSetName}(){(string.IsNullOrEmpty(value.Name) ? string.Empty : "." + value.Name)}]]";
}
return(variableName);
}
static void UpdateInputsForTest(IServiceTestModelTO serviceTestModelTO, IDev2Definition dev2Definition)
{
if (dev2Definition.IsRecordSet)
{
ProcessRecordsetInputs(serviceTestModelTO, dev2Definition);
}
else
{
if (serviceTestModelTO.Inputs.FirstOrDefault(input => input.Variable == dev2Definition.Name) == null)
{
serviceTestModelTO.Inputs.Add(new ServiceTestInputTO
{
Variable = dev2Definition.Name,
Value = "",
EmptyIsNull = false
});
}
}
}
private void CreateScalarInputs(IExecutionEnvironment outerEnvironment, IDev2Definition dev2Definition, IExecutionEnvironment env, int update)
{
if (!string.IsNullOrEmpty(dev2Definition.Name))
{
env.AssignDataShape("[[" + dev2Definition.Name + "]]");
}
if (!dev2Definition.IsRecordSet)
{
if (!string.IsNullOrEmpty(dev2Definition.RawValue))
{
var warewolfEvalResult = outerEnvironment.Eval(dev2Definition.RawValue, update);
if (warewolfEvalResult.IsWarewolfAtomListresult)
{
ScalarAtomList(warewolfEvalResult, env, dev2Definition);
}
else
{
ScalarAtom(warewolfEvalResult, env, dev2Definition);
}
}
}
}
static void EvalAssignComplexObjects(IExecutionEnvironment innerEnvironment, IExecutionEnvironment environment, IDev2Definition dev2Definition)
{
var warewolfEvalResult = innerEnvironment.EvalJContainer(DataListUtil.AddBracketsToValueIfNotExist(dev2Definition.Name));
if (warewolfEvalResult != null)
{
environment.AddToJsonObjects(DataListUtil.AddBracketsToValueIfNotExist(dev2Definition.Value), warewolfEvalResult);
}
}
static void EvalAssignScalars(IExecutionEnvironment innerEnvironment, IExecutionEnvironment environment, int update, IDev2Definition dev2Definition)
{
var warewolfEvalResult = innerEnvironment.Eval(DataListUtil.AddBracketsToValueIfNotExist(dev2Definition.Name), update);
if (warewolfEvalResult.IsWarewolfAtomListresult)
{
if (warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult data && data.Item.Any())
{
environment.Assign("[[" + dev2Definition.Value + "]]", ExecutionEnvironment.WarewolfAtomToString(data.Item.Last()), update);
}
}
else
{
if (warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult data)
{
environment.Assign(DataListUtil.AddBracketsToValueIfNotExist(dev2Definition.Value), ExecutionEnvironment.WarewolfAtomToString(data.Item), update);
}
}
}
string GetVariableName(IDev2Definition value)
{
return String.IsNullOrEmpty(value.RecordSetName)
? String.Format("[[{0}]]", value.Name)
: String.Format("[[{0}]]", value.RecordSetName);
}
void ScalarAtom(CommonFunctions.WarewolfEvalResult warewolfEvalResult, IExecutionEnvironment env, IDev2Definition dev2Definition)
{
if (warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult data)
{
env.AssignWithFrame(new AssignValue("[[" + dev2Definition.Name + "]]", ExecutionEnvironment.WarewolfAtomToString(data.Item)), 0);
}
}
public IDev2Definition GetGenerationTO()
{
IDev2Definition result = DataListFactory.CreateDefinition(Name, MapsTo, Value, RecordSetName, false, DefaultValue, Required, Value, EmptyToNull);
return(result);
}
static void EvalAssignRecordSets(IExecutionEnvironment innerEnvironment, IExecutionEnvironment environment, int update, IDev2Definition outPutRecSet, IDev2Definition outputColumnDefinitions)
{
var correctRecSet = "[[" + outputColumnDefinitions.RecordSetName + "(*)." + outputColumnDefinitions.Name + "]]";
var warewolfEvalResult = innerEnvironment.Eval(correctRecSet, 0);
if (warewolfEvalResult.IsWarewolfAtomListresult)
{
var recsetResult = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
if (outPutRecSet.IsRecordSet)
{
var enRecordsetIndexType = DataListUtil.GetRecordsetIndexType(outputColumnDefinitions.RawValue);
if (enRecordsetIndexType == enRecordsetIndexType.Star && recsetResult != null)
{
environment.EvalAssignFromNestedStar(outputColumnDefinitions.RawValue, recsetResult, update);
}
if (enRecordsetIndexType == enRecordsetIndexType.Blank && recsetResult != null)
{
environment.EvalAssignFromNestedLast(outputColumnDefinitions.RawValue, recsetResult, 0);
}
if (enRecordsetIndexType == enRecordsetIndexType.Numeric && recsetResult != null)
{
environment.EvalAssignFromNestedNumeric(outputColumnDefinitions.RawValue, recsetResult, 0);
}
}
}
}
public void InputOutputMappingViewModel_GetGenerationTO_ValidViewModel_Expected_Dev2DefinitionCreatedFromInputOutputViewModel()
{
IDev2Definition dev2Definition = _inputOutputViewModel.GetGenerationTO();
Assert.IsTrue(dev2Definition != null);
}
static void AtomListInputs(CommonFunctions.WarewolfEvalResult warewolfEvalResult, IDev2Definition dev2ColumnDefinition, IExecutionEnvironment env)
{
// TODO: why is this called but the return never used? can we remove this?
DataListUtil.GetRecordsetIndexType(dev2ColumnDefinition.Value);
if (warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult recsetResult)
{
var correctRecSet = "[[" + dev2ColumnDefinition.RecordSetName + "(*)." + dev2ColumnDefinition.Name + "]]";
env.EvalAssignFromNestedStar(correctRecSet, recsetResult, 0);
}
}
private void ScalarAtomList(CommonFunctions.WarewolfEvalResult warewolfEvalResult, IExecutionEnvironment env, IDev2Definition dev2Definition)
{
var data = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
if (data != null && data.Item.Any())
{
env.AssignWithFrame(new AssignValue("[[" + dev2Definition.Name + "]]", ExecutionEnvironment.WarewolfAtomToString(data.Item.Last())), 0);
}
}
static void AddTmpRecordsetNames(IDictionary <string, IList <IDev2Definition> > tmpCollections, IList <string> tmpNames, IDev2Definition tmp, string scanRsName)
{
if (tmp.IsRecordSet)
{
if (tmpCollections.ContainsKey(scanRsName))
{
tmpCollections[scanRsName].Add(tmp);
}
else
{
IList <IDev2Definition> newList = new List <IDev2Definition>();
newList.Add(tmp);
tmpCollections.Add(scanRsName, newList);
tmpNames.Add(scanRsName);
}
}
else
{
if (!string.IsNullOrEmpty(scanRsName))
{
if (tmpCollections.ContainsKey(scanRsName))
{
tmpCollections[scanRsName].Add(tmp);
}
else
{
IList <IDev2Definition> newList = new List <IDev2Definition>();
newList.Add(tmp);
tmpCollections.Add(scanRsName, newList);
tmpNames.Add(scanRsName);
}
}
}
}
string GetVariableName(IDev2Definition value)
{
return(String.IsNullOrEmpty(value.RecordSetName)
? String.Format("[[{0}]]", value.Name)
: String.Format("[[{0}(){1}]]", value.RecordSetName, String.IsNullOrEmpty(value.Name) ? String.Empty : "." + value.Name));
}
private string GetVariableName(IDev2Definition value)
{
return(string.IsNullOrEmpty(value.RecordSetName)
? $"[[{value.Name}]]"
: $"[[{value.RecordSetName}(){(string.IsNullOrEmpty(value.Name) ? string.Empty : "." + value.Name)}]]");
}
static IServiceTestModelTO UpdateOutputsForTest(IServiceTestModelTO serviceTestModelTO, IDev2Definition dev2Definition)
{
if (dev2Definition.IsRecordSet)
{
ProcessRecordsetOutputs(serviceTestModelTO, dev2Definition);
}
else
{
if (serviceTestModelTO.Outputs.FirstOrDefault(output => output.Variable == dev2Definition.Name) == null)
{
serviceTestModelTO.Outputs.Add(new ServiceTestOutputTO
{
Variable = dev2Definition.Name,
AssertOp = "=",
Value = ""
});
}
}
return(serviceTestModelTO);
}