public void SelectAndApplyActivity_SetupExecute_GivenCaseConvertActivityApplied_ToUpperApplied()
{
//------------Setup for test--------------------------
var activity = new DsfCaseConvertActivity
{
ConvertCollection = new List <ICaseConvertTO>
{
new CaseConvertTO("[[a]]", "UPPER", "[[a]]", 1)
{
ExpressionToConvert = "[[a]]"
}
}
};
SetupArguments("", "", activity);
//------------Execute Test---------------------------
ExecuteProcess(DataObject);
//------------Assert Results-------------------------
var names = DataObject.Environment.EvalAsListOfStrings("[[Person(*).Name]]", 0);
Assert.IsTrue(names.Any(s => s == "BOB"));
Assert.IsTrue(names.Any(s => s == "DORA"));
Assert.IsTrue(names.Any(s => s == "SUPERMAN"));
Assert.IsTrue(names.Any(s => s == "BATMAN"));
Assert.IsTrue(names.Any(s => s == "ORLANDO"));
}
public void DsfCaseConvert_UpdateForEachInputs_WhenContainsMatchingStar_UpdateSuccessful()
{
//------------Setup for test--------------------------
List <ICaseConvertTO> fieldsCollection = new List <ICaseConvertTO>
{
new CaseConvertTO("[[rs(*).val]]", "text", "[[result]]", 1)
};
var dsfCaseConvert = new DsfCaseConvertActivity {
ConvertCollection = fieldsCollection
};
//------------Execute Test---------------------------
dsfCaseConvert.UpdateForEachInputs(new List <Tuple <string, string> >
{
new Tuple <string, string>("[[rs(*).val]]", "[[rs(1).val]]"),
});
//------------Assert Results-------------------------
var collection = dsfCaseConvert.ConvertCollection;
Assert.AreEqual("[[rs(1).val]]", collection[0].StringToConvert);
}
public void SelectAndApplyActivity_SetupExecute_GivenCaseConvertActivityApplied_ToCorrectIndex()
{
//------------Setup for test--------------------------
var activity = new DsfCaseConvertActivity
{
ConvertCollection = new List <ICaseConvertTO>
{
new CaseConvertTO("[[a]]", "UPPER", "[[a]]", 1)
{
ExpressionToConvert = "[[a]]"
}
}
};
SetupArguments("", "", activity);
//------------Execute Test---------------------------
ExecuteProcess(DataObject);
//------------Assert Results-------------------------
var names = DataObject.Environment.EvalAsListOfStrings("[[Person(*).Name]]", 0);
Assert.AreEqual("BOB", names[0]);
Assert.AreEqual("DORA", names[1]);
Assert.AreEqual("SUPERMAN", names[2]);
Assert.AreEqual("BATMAN", names[3]);
Assert.AreEqual("ORLANDO", names[4]);
}
public void GetActivityFieldsOffCaseConvertActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfCaseConvertActivity caseConvertActivity = new DsfCaseConvertActivity { ConvertCollection = new List<ICaseConvertTO> { new CaseConvertTO("[[StringToConvert]]", "UPPER", "[[Result]]", 1), new CaseConvertTO("[[StringToConvert2]]", "UPPER", "[[Result2]]", 2) } };
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.DataGridActivity);
List<string> actual = strategy.GetActivityFields(caseConvertActivity);
List<string> expected = new List<string> { "[[StringToConvert]]", "[[Result]]", "[[StringToConvert2]]", "[[Result2]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void FalseArm_Different_Object_Is_Equal()
{
//---------------Set up test pack-------------------
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
var dsfCalculateActivity = new DsfCalculateActivity()
{
NextNodes = new List <IDev2Activity>()
{
dsfBaseConvertActivity
}
};
;
var dsfCaseConvertActivity = new DsfCaseConvertActivity()
{
NextNodes = new List <IDev2Activity>()
{
dsfCalculateActivity
}
};
var trueArms = new List <IDev2Activity>
{
dsfCaseConvertActivity
};
var trueArms1 = new List <IDev2Activity>
{
dsfCalculateActivity,
};
var uniqueId = Guid.NewGuid().ToString();
var decision = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a"
,
FalseArm = trueArms
};
var decision1 = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a"
,
FalseArm = trueArms1
};
//---------------Assert Precondition----------------
Assert.IsNotNull(decision);
//---------------Execute Test ----------------------
var equals = decision.Equals(decision1);
//---------------Test Result -----------------------
Assert.IsTrue(equals);
}
public void Mode_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var dev2DecisionStack = new Dev2DecisionStack()
{
Mode = Dev2DecisionMode.AND
};
var dev2DecisionStack1 = new Dev2DecisionStack()
{
Mode = Dev2DecisionMode.OR
};
var dsfCaseConvertActivity = new DsfCaseConvertActivity();
var dsfCalculateActivity = new DsfCalculateActivity();
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
var trueArms = new List <IDev2Activity>
{
dsfBaseConvertActivity,
dsfCalculateActivity,
dsfCaseConvertActivity
};
var trueArms1 = new List <IDev2Activity>
{
dsfBaseConvertActivity,
dsfCalculateActivity,
dsfCaseConvertActivity
};
var uniqueId = Guid.NewGuid().ToString();
var decision = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a",
FalseArm = trueArms,
Conditions = dev2DecisionStack
};
var decision1 = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a",
FalseArm = trueArms1,
Conditions = dev2DecisionStack1
};
//---------------Assert Precondition----------------
Assert.IsNotNull(decision);
//---------------Execute Test ----------------------
var equals = decision.Equals(decision1);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
public void SelectAndApplyActivity_SetupExecute_GivenCaseConvertActivityApplied_ToCorrectIndex_ComplexObjects()
{
//------------Setup for test--------------------------
var activity = new DsfCaseConvertActivity
{
ConvertCollection = new List <ICaseConvertTO>
{
new CaseConvertTO("[[a]]", "UPPER", "[[a]]", 1)
{
ExpressionToConvert = "[[a]]"
}
}
};
DataObject.Environment = new ExecutionEnvironment();
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Name]]", "Bob"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Name]]", "Dora"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Name]]", "Superman"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Name]]", "Batman"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Name]]", "Orlando"), 0);
const string dataSource = "[[@Person(*).Name]]";
const string alias = "[[a]]";
var dsfSelectAndApplyActivity = new DsfSelectAndApplyActivity
{
DataSource = dataSource,
Alias = alias,
//ApplyActivityFunc = activity
};
var handler = activity as Activity;
dsfSelectAndApplyActivity.ApplyActivityFunc.Handler = handler;
TestStartNode = new FlowStep
{
Action = dsfSelectAndApplyActivity
};
CurrentDl = "";
TestData = "";
//------------Execute Test---------------------------
ExecuteProcess(DataObject);
//------------Assert Results-------------------------
var names = DataObject.Environment.EvalAsListOfStrings("[[@Person(*).Name]]", 0);
Assert.AreEqual("BOB", names[0]);
Assert.AreEqual("DORA", names[1]);
Assert.AreEqual("SUPERMAN", names[2]);
Assert.AreEqual("BATMAN", names[3]);
Assert.AreEqual("ORLANDO", names[4]);
}
// ReSharper disable InconsistentNaming
public void QuickVariableInput_Using_Case_Convert_Check_Row_Count_Expected_3()
// ReSharper restore InconsistentNaming
{
DsfCaseConvertActivity activity = new DsfCaseConvertActivity();
activity.ConvertCollection.Add(new CaseConvertTO("[[result1]]", "UPPER", "[[result1]]", 1));
activity.ConvertCollection.Add(new CaseConvertTO("[[result2]]", "UPPER", "[[result2]]", 2));
activity.ConvertCollection.Add(new CaseConvertTO("[[result3]]", "UPPER", "[[result3]]", 3));
ModelItem modelItem = TestModelItemFactory.CreateModelItem(activity);
QuickVariableInputModel model = new QuickVariableInputModel(TestModelItemFactory.CreateModelItem(activity), activity);
int colCount = model.GetCollectionCount();
Assert.AreEqual(3, colCount);
}
public void GetActivityFieldsOffCaseConvertActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfCaseConvertActivity caseConvertActivity = new DsfCaseConvertActivity();
caseConvertActivity.ConvertCollection = new List <ICaseConvertTO> {
new CaseConvertTO("[[StringToConvert]]", "UPPER", "[[Result]]", 1), new CaseConvertTO("[[StringToConvert2]]", "UPPER", "[[Result2]]", 2)
};
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.DataGridActivity);
List <string> actual = strategy.GetActivityFields(caseConvertActivity);
List <string> expected = new List <string> {
"[[StringToConvert]]", "[[Result]]", "[[StringToConvert2]]", "[[Result2]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void GivenItContainsCaseConvertAs(string parentName, string activityName, Table table)
{
var activity = new DsfCaseConvertActivity {
DisplayName = activityName
};
foreach (var tableRow in table.Rows)
{
var variableToConvert = tableRow["Variable"];
var conversionType = tableRow["Type"];
activity.ConvertCollection.Add(new CaseConvertTO(variableToConvert, conversionType, variableToConvert, 1, true));
}
_commonSteps.AddActivityToActivityList(parentName, activityName, activity);
}
public void QuickVariableInput_Using_Case_Convert_Check_Row_Count_Expected_3()
{
var activity = new DsfCaseConvertActivity();
activity.ConvertCollection.Add(new CaseConvertTO("[[result1]]", "UPPER", "[[result1]]", 1));
activity.ConvertCollection.Add(new CaseConvertTO("[[result2]]", "UPPER", "[[result2]]", 2));
activity.ConvertCollection.Add(new CaseConvertTO("[[result3]]", "UPPER", "[[result3]]", 3));
var modelItem = TestModelItemFactory.CreateModelItem(activity);
var model = new QuickVariableInputModel(TestModelItemFactory.CreateModelItem(activity), activity);
var colCount = model.GetCollectionCount();
Assert.AreEqual(3, colCount);
}
public void DsfCaseConvertActivity_GetOutputs_Called_ShouldReturnListWithResultValueInIt()
{
//------------Setup for test--------------------------
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[[testVar]]", "UPPER", "[[testVar]]", 1), CaseConverterFactory.CreateCaseConverterTO("[[testVar2]]", "UPPER", "[[testVar2]]", 1)
};
var act = new DsfCaseConvertActivity {
ConvertCollection = convertCollection
};
//------------Execute Test---------------------------
var outputs = act.GetOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(2, outputs.Count);
Assert.AreEqual("[[testVar]]", outputs[0]);
Assert.AreEqual("[[testVar2]]", outputs[1]);
}
public void AddListToCollectionWhereNotOverwriteEmptyListExpectAddToCollection()
{
//------------Setup for test--------------------------
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO>()
{
new CaseConvertTO("", "UPPER", "[[testVar]]", 1)
};
var activity = new DsfCaseConvertActivity();
activity.ConvertCollection = convertCollection;
var modelItem = TestModelItemUtil.CreateModelItem(activity);
//------------Execute Test---------------------------
activity.AddListToCollection(new[] { "[[Var1]]" }, false, modelItem);
//------------Assert Results-------------------------
Assert.AreEqual(2, activity.ConvertCollection.Count);
}
// ReSharper disable InconsistentNaming
public void QuickVariableInput_Using_Case_Convert_Check_Row_Count_Expected_3()
// ReSharper restore InconsistentNaming
{
DsfCaseConvertActivity activity = new DsfCaseConvertActivity();
activity.ConvertCollection.Add(new CaseConvertTO("[[result1]]", "UPPER", "[[result1]]", 1));
activity.ConvertCollection.Add(new CaseConvertTO("[[result2]]", "UPPER", "[[result2]]", 2));
activity.ConvertCollection.Add(new CaseConvertTO("[[result3]]", "UPPER", "[[result3]]", 3));
ModelItem modelItem = TestModelItemFactory.CreateModelItem(activity);
QuickVariableInputModel model = new QuickVariableInputModel(TestModelItemFactory.CreateModelItem(activity), activity);
int colCount = model.GetCollectionCount();
Assert.AreEqual(3, colCount);
}
// ReSharper disable InconsistentNaming
public void QuickVariableInput_Using_Case_Convert_Add_List_To_Collection_Overwrite_False_Expected_5()
// ReSharper restore InconsistentNaming
{
DsfCaseConvertActivity activity = new DsfCaseConvertActivity();
activity.ConvertCollection.Add(new CaseConvertTO("[[result1]]", "UPPER", "[[result1]]", 1));
activity.ConvertCollection.Add(new CaseConvertTO("[[result2]]", "UPPER", "[[result2]]", 2));
activity.ConvertCollection.Add(new CaseConvertTO("[[result3]]", "UPPER", "[[result3]]", 3));
QuickVariableInputModel model = new QuickVariableInputModel(TestModelItemFactory.CreateModelItem(activity), activity);
IList <string> listToAdd = new List <string>();
listToAdd.Add("[[Add1]]");
listToAdd.Add("[[Add2]]");
model.AddListToCollection(listToAdd, false);
int colCount = model.GetCollectionCount();
Assert.AreEqual(5, colCount);
}
public void DsfCaseConvert_GetForEachOutputs_Normal_UpdateSuccessful()
{
//------------Setup for test--------------------------
List <ICaseConvertTO> fieldsCollection = new List <ICaseConvertTO>
{
new CaseConvertTO("[[result]]", "text", "[[rs(*).val]]", 1)
};
var dsfCaseConvert = new DsfCaseConvertActivity {
ConvertCollection = fieldsCollection
};
//------------Execute Test---------------------------
var inputs = dsfCaseConvert.GetForEachOutputs();
//------------Assert Results-------------------------
Assert.AreEqual("[[result]]", inputs[0].Value);
Assert.AreEqual("[[rs(*).val]]", inputs[0].Name);
}
public void QuickVariableInput_Using_Case_Convert_Add_List_To_Collection_Overwrite_True_Expected_5()
{
var activity = new DsfCaseConvertActivity();
activity.ConvertCollection.Add(new CaseConvertTO("[[result1]]", "UPPER", "[[result1]]", 1));
activity.ConvertCollection.Add(new CaseConvertTO("[[result2]]", "UPPER", "[[result2]]", 2));
activity.ConvertCollection.Add(new CaseConvertTO("[[result3]]", "UPPER", "[[result3]]", 3));
var model = new QuickVariableInputModel(TestModelItemFactory.CreateModelItem(activity), activity);
IList <string> listToAdd = new List <string>();
listToAdd.Add("[[Add1]]");
listToAdd.Add("[[Add2]]");
model.AddListToCollection(listToAdd, true);
var colCount = model.GetCollectionCount();
Assert.AreEqual(2, colCount);
}
public void DsfCaseConvertActivity_GetState_Returns_Inputs_And_Outputs()
{
//------------Setup for test--------------------------
var fieldsCollection = new List <ICaseConvertTO>
{
new CaseConvertTO("[[result]]", "text", "[[rs(*).val]]", 1)
};
var dsfCaseConvert = new DsfCaseConvertActivity {
ConvertCollection = fieldsCollection
};
var expectedResults = ActivityHelper.GetSerializedStateValueFromCollection(fieldsCollection);
//------------Execute Test---------------------------
var stateList = dsfCaseConvert.GetState();
//------------Assert Results-------------------------
Assert.IsNotNull(stateList);
Assert.AreEqual(1, stateList.Count());
Assert.AreEqual(StateVariable.StateType.InputOutput, stateList.ToList()[0].Type);
Assert.AreEqual("Convert Collection", stateList.ToList()[0].Name);
Assert.AreEqual(expectedResults, stateList.ToList()[0].Value);
}
protected override void BuildDataList()
{
BuildShapeAndTestData();
var caseConvert = new DsfCaseConvertActivity();
TestStartNode = new FlowStep
{
Action = caseConvert
};
int row = 1;
var caseConversion = ScenarioContext.Current.Get<List<Tuple<string, string>>>("caseConversion");
foreach(dynamic variable in caseConversion)
{
caseConvert.ConvertCollection.Add(new CaseConvertTO(variable.Item1, variable.Item2, variable.Item1, row));
row++;
}
ScenarioContext.Current.Add("activity", caseConvert);
}
/// <summary>
/// Gets all the fields for a specific activity
/// </summary>
/// <param name="activity">The activity that the fields will be retrieved from</param>
/// <returns>Returns all the fields in a list of strings</returns>
public List <string> GetActivityFields(object activity)
{
List <string> results = new List <string>();
Type activityType = activity.GetType();
if (activityType == typeof(DsfBaseConvertActivity))
{
DsfBaseConvertActivity bcAct = activity as DsfBaseConvertActivity;
if (bcAct != null)
{
results.AddRange(InternalFindMissing(bcAct.ConvertCollection));
}
}
else if (activityType == typeof(DsfCaseConvertActivity))
{
DsfCaseConvertActivity ccAct = activity as DsfCaseConvertActivity;
if (ccAct != null)
{
results.AddRange(InternalFindMissing(ccAct.ConvertCollection));
}
}
else if (activityType == typeof(DsfMultiAssignActivity))
{
DsfMultiAssignActivity maAct = activity as DsfMultiAssignActivity;
if (maAct != null)
{
results.AddRange(InternalFindMissing(maAct.FieldsCollection));
}
}
else if (activityType == typeof(DsfGatherSystemInformationActivity))
{
DsfGatherSystemInformationActivity maAct = activity as DsfGatherSystemInformationActivity;
if (maAct != null)
{
results.AddRange(InternalFindMissing(maAct.SystemInformationCollection));
}
}
return(results);
}
protected override void BuildDataList()
{
BuildShapeAndTestData();
var caseConvert = new DsfCaseConvertActivity();
TestStartNode = new FlowStep
{
Action = caseConvert
};
int row = 1;
var caseConversion = ScenarioContext.Current.Get <List <Tuple <string, string> > >("caseConversion");
foreach (dynamic variable in caseConversion)
{
caseConvert.ConvertCollection.Add(new CaseConvertTO(variable.Item1, variable.Item2, variable.Item1, row));
row++;
}
ScenarioContext.Current.Add("activity", caseConvert);
}
public void QuickVariableInputViewModel_AddCommand_RecordSet_ShouldPass()
{
//------------Setup for test--------------------------
var activity = new DsfCaseConvertActivity();
activity.ConvertCollection.Add(new CaseConvertTO("[[result1]]", "UPPER", "[[result1]]", 1));
activity.ConvertCollection.Add(new CaseConvertTO("[[result2]]", "UPPER", "[[result2]]", 2));
activity.ConvertCollection.Add(new CaseConvertTO("[[result3]]", "UPPER", "[[result3]]", 3));
var model = new QuickVariableInputModel(TestModelItemFactory.CreateModelItem(activity), activity);
var quickVariableInputViewModel = new QuickVariableInputViewModel(model);
//------------Execute Test---------------------------
quickVariableInputViewModel.SplitType = "Chars";
quickVariableInputViewModel.SplitToken = "(";
quickVariableInputViewModel.MakeDataListReady(new List <string> {
"rec().set", "Test 4", "T e s t"
});
quickVariableInputViewModel.VariableListString = "rec().set";
quickVariableInputViewModel.Prefix = "rec().set";
quickVariableInputViewModel.AddCommand.Execute(null);
//------------Assert Results-------------------------
Assert.AreEqual("Chars", quickVariableInputViewModel.SplitType);
}
public void SequenceDesignerViewModel_ActivityNames_WhenMoreThan4_Has4NamesLastItemEllipsis()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var dsfGatherSystemInformationActivity = new DsfGatherSystemInformationActivity();
dsfSequenceActivity.Activities.Add(dsfGatherSystemInformationActivity);
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfBaseConvertActivity);
var dsfCaseConvertActivity = new DsfCaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfCaseConvertActivity);
var dsfCalculateActivity = new DsfCalculateActivity();
dsfSequenceActivity.Activities.Add(dsfCalculateActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
//------------Execute Test---------------------------
var activityNames = sequenceDesignerViewModel.ActivityNames;
//------------Assert Results-------------------------
Assert.AreEqual(5, activityNames.Count);
Assert.AreEqual(dsfMultiAssignActivity.DisplayName, activityNames[0]);
Assert.AreEqual(dsfFindRecordsMultipleCriteriaActivity.DisplayName, activityNames[1]);
Assert.AreEqual(dsfGatherSystemInformationActivity.DisplayName, activityNames[2]);
Assert.AreEqual(dsfBaseConvertActivity.DisplayName, activityNames[3]);
Assert.AreEqual("...", activityNames[4]);
CollectionAssert.DoesNotContain(activityNames, dsfCaseConvertActivity.DisplayName);
CollectionAssert.DoesNotContain(activityNames, dsfCalculateActivity.DisplayName);
}
public void GivenItContainsCaseConvertAs(string parentName, string activityName, Table table)
{
DsfCaseConvertActivity activity = new DsfCaseConvertActivity { DisplayName = activityName };
foreach(var tableRow in table.Rows)
{
var variableToConvert = tableRow["Variable"];
var conversionType = tableRow["Type"];
activity.ConvertCollection.Add(new CaseConvertTO(variableToConvert, conversionType, variableToConvert, 1, true));
}
CommonSteps.AddActivityToActivityList(parentName, activityName, activity);
}
public void SequenceDesignerViewModel_ActivityNames_WhenMoreThan4_Has4NamesLastItemEllipsis()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var dsfGatherSystemInformationActivity = new DsfGatherSystemInformationActivity();
dsfSequenceActivity.Activities.Add(dsfGatherSystemInformationActivity);
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfBaseConvertActivity);
var dsfCaseConvertActivity = new DsfCaseConvertActivity();
dsfSequenceActivity.Activities.Add(dsfCaseConvertActivity);
var dsfCalculateActivity = new DsfCalculateActivity();
dsfSequenceActivity.Activities.Add(dsfCalculateActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
//------------Execute Test---------------------------
var activityNames = sequenceDesignerViewModel.ActivityNames;
//------------Assert Results-------------------------
Assert.AreEqual(5, activityNames.Count);
Assert.AreEqual(dsfMultiAssignActivity.DisplayName, activityNames[0]);
Assert.AreEqual(dsfFindRecordsMultipleCriteriaActivity.DisplayName, activityNames[1]);
Assert.AreEqual(dsfGatherSystemInformationActivity.DisplayName, activityNames[2]);
Assert.AreEqual(dsfBaseConvertActivity.DisplayName, activityNames[3]);
Assert.AreEqual("...", activityNames[4]);
CollectionAssert.DoesNotContain(activityNames, dsfCaseConvertActivity.DisplayName);
CollectionAssert.DoesNotContain(activityNames, dsfCalculateActivity.DisplayName);
}
public void DsfCaseConvert_GetForEachOutputs_Normal_UpdateSuccessful()
{
//------------Setup for test--------------------------
List<ICaseConvertTO> fieldsCollection = new List<ICaseConvertTO>
{
new CaseConvertTO( "[[result]]","text", "[[rs(*).val]]",1)
};
var dsfCaseConvert = new DsfCaseConvertActivity { ConvertCollection = fieldsCollection };
//------------Execute Test---------------------------
var inputs = dsfCaseConvert.GetForEachOutputs();
//------------Assert Results-------------------------
Assert.AreEqual("[[result]]", inputs[0].Value);
Assert.AreEqual("[[rs(*).val]]", inputs[0].Name);
}
public void DsfCaseConvert_UpdateForEachOutputs_WhenContainsMatchingStar_UpdateSuccessful()
{
//------------Setup for test--------------------------
List<ICaseConvertTO> fieldsCollection = new List<ICaseConvertTO>
{
new CaseConvertTO( "[[result]]","text", "[[rs(*).val]]",1)
};
var dsfCaseConvert = new DsfCaseConvertActivity { ConvertCollection = fieldsCollection };
//------------Execute Test---------------------------
dsfCaseConvert.UpdateForEachOutputs(new List<Tuple<string, string>>
{
new Tuple<string, string>("[[rs(*).val]]", "[[rs(1).val]]"),
});
//------------Assert Results-------------------------
var collection = dsfCaseConvert.ConvertCollection;
Assert.AreEqual("[[rs(1).val]]", collection[0].Result);
}
public void QuickVariableInput_Using_Case_Convert_Add_List_To_Collection_Overwrite_False_Expected_5()
{
DsfCaseConvertActivity activity = new DsfCaseConvertActivity();
activity.ConvertCollection.Add(new CaseConvertTO("[[result1]]", "UPPER", "[[result1]]", 1));
activity.ConvertCollection.Add(new CaseConvertTO("[[result2]]", "UPPER", "[[result2]]", 2));
activity.ConvertCollection.Add(new CaseConvertTO("[[result3]]", "UPPER", "[[result3]]", 3));
QuickVariableInputModel model = new QuickVariableInputModel(TestModelItemFactory.CreateModelItem(activity), activity);
IList<string> listToAdd = new List<string>();
listToAdd.Add("[[Add1]]");
listToAdd.Add("[[Add2]]");
model.AddListToCollection(listToAdd, false);
int colCount = model.GetCollectionCount();
Assert.AreEqual(5, colCount);
}
/// <summary>
/// Gets all the fields for a specific activity
/// </summary>
/// <param name="activity">The activity that the fields will be retrieved from</param>
/// <returns>Returns all the fields in a list of strings</returns>
public List <string> GetActivityFields(object activity)
{
List <string> results = new List <string>();
Type activityType = activity.GetType();
if (activityType == typeof(DsfBaseConvertActivity))
{
DsfBaseConvertActivity bcAct = activity as DsfBaseConvertActivity;
if (bcAct != null)
{
results.AddRange(InternalFindMissing(bcAct.ConvertCollection));
}
}
else if (activityType == typeof(DsfCaseConvertActivity))
{
DsfCaseConvertActivity ccAct = activity as DsfCaseConvertActivity;
if (ccAct != null)
{
results.AddRange(InternalFindMissing(ccAct.ConvertCollection));
}
}
else if (activityType == typeof(DsfMultiAssignActivity))
{
DsfMultiAssignActivity maAct = activity as DsfMultiAssignActivity;
if (maAct != null)
{
results.AddRange(InternalFindMissing(maAct.FieldsCollection));
}
}
else if (activityType == typeof(DsfMultiAssignObjectActivity))
{
DsfMultiAssignObjectActivity maAct = activity as DsfMultiAssignObjectActivity;
if (maAct != null)
{
results.AddRange(InternalFindMissing(maAct.FieldsCollection));
}
}
else if (activityType == typeof(DsfGatherSystemInformationActivity))
{
DsfGatherSystemInformationActivity maAct = activity as DsfGatherSystemInformationActivity;
if (maAct != null)
{
results.AddRange(InternalFindMissing(maAct.SystemInformationCollection));
}
}
else if (activityType == typeof(DsfSqlServerDatabaseActivity))
{
var maAct = activity as DsfSqlServerDatabaseActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfMySqlDatabaseActivity))
{
var maAct = activity as DsfMySqlDatabaseActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfPostgreSqlActivity))
{
var maAct = activity as DsfPostgreSqlActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfOracleDatabaseActivity))
{
var maAct = activity as DsfOracleDatabaseActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfODBCDatabaseActivity))
{
var maAct = activity as DsfODBCDatabaseActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.CommandText != null)
{
results.Add(maAct.CommandText);
}
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfWebPostActivity))
{
var maAct = activity as DsfWebPostActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.QueryString != null)
{
results.Add(maAct.QueryString);
}
if (maAct.PostData != null)
{
results.Add(maAct.PostData);
}
if (maAct.Headers != null)
{
foreach (var nameValue in maAct.Headers)
{
results.Add(nameValue.Name);
results.Add(nameValue.Value);
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
}
}
else if (activityType == typeof(DsfWebDeleteActivity))
{
var maAct = activity as DsfWebDeleteActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.QueryString != null)
{
results.Add(maAct.QueryString);
}
if (maAct.Headers != null)
{
foreach (var nameValue in maAct.Headers)
{
results.Add(nameValue.Name);
results.Add(nameValue.Value);
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfWebPutActivity))
{
var maAct = activity as DsfWebPutActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.QueryString != null)
{
results.Add(maAct.QueryString);
}
if (maAct.PutData != null)
{
results.Add(maAct.PutData);
}
if (maAct.Headers != null)
{
foreach (var nameValue in maAct.Headers)
{
results.Add(nameValue.Name);
results.Add(nameValue.Value);
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfWebGetActivity))
{
var maAct = activity as DsfWebGetActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (maAct.QueryString != null)
{
results.Add(maAct.QueryString);
}
if (maAct.Headers != null)
{
foreach (var nameValue in maAct.Headers)
{
results.Add(nameValue.Name);
results.Add(nameValue.Value);
}
}
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfDotNetDllActivity))
{
var maAct = activity as DsfDotNetDllActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfEnhancedDotNetDllActivity))
{
var maAct = activity as DsfEnhancedDotNetDllActivity;
if (maAct != null)
{
if (maAct.ConstructorInputs != null)
{
results.AddRange(InternalFindMissing(maAct.ConstructorInputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (maAct.MethodsToRun != null)
{
foreach (var pluginAction in maAct.MethodsToRun)
{
if (pluginAction?.Inputs != null)
{
results.AddRange(InternalFindMissing(pluginAction.Inputs));
}
if (!string.IsNullOrEmpty(pluginAction?.OutputVariable))
{
results.Add(pluginAction.OutputVariable);
}
}
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfComDllActivity))
{
var maAct = activity as DsfComDllActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
else if (activityType == typeof(DsfWcfEndPointActivity))
{
var maAct = activity as DsfWcfEndPointActivity;
if (maAct != null)
{
if (maAct.Inputs != null)
{
results.AddRange(InternalFindMissing(maAct.Inputs));
}
if (!string.IsNullOrEmpty(maAct.OnErrorVariable))
{
results.Add(maAct.OnErrorVariable);
}
if (maAct.IsObject)
{
if (!string.IsNullOrEmpty(maAct.ObjectName))
{
results.Add(maAct.ObjectName);
}
}
else
{
if (maAct.Outputs != null)
{
results.AddRange(InternalFindMissing(maAct.Outputs));
}
}
if (!string.IsNullOrEmpty(maAct.OnErrorWorkflow))
{
results.Add(maAct.OnErrorWorkflow);
}
}
}
return(results);
}
public void Conditions_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var dev2DecisionStack = new Dev2DecisionStack()
{
TheStack = new List <Dev2Decision>()
{
new Dev2Decision()
{
Cols1 = new List <DataStorage.WarewolfAtom>()
{
DataStorage.WarewolfAtom.NewDataString("a")
}
},
new Dev2Decision()
{
Cols1 = new List <DataStorage.WarewolfAtom>()
{
DataStorage.WarewolfAtom.NewDataString("a")
}
}
},
DisplayText = "a"
,
FalseArmText = "ErrorArm"
,
TrueArmText = "true Arm",
Version = "2",
Mode = Dev2DecisionMode.AND
};
var dev2DecisionStack1 = new Dev2DecisionStack()
{
TheStack = new List <Dev2Decision>()
{
new Dev2Decision()
{
Cols1 = new List <DataStorage.WarewolfAtom>()
{
DataStorage.WarewolfAtom.NewDataString("a")
},
Col2 = "Col1"
},
new Dev2Decision()
{
Cols1 = new List <DataStorage.WarewolfAtom>()
{
DataStorage.WarewolfAtom.NewDataString("a")
}
}
},
DisplayText = "a"
,
FalseArmText = "ErrorArm"
,
TrueArmText = "true Arm",
Version = "2",
Mode = Dev2DecisionMode.AND
};
var dsfCaseConvertActivity = new DsfCaseConvertActivity();
var dsfCalculateActivity = new DsfCalculateActivity();
var dsfBaseConvertActivity = new DsfBaseConvertActivity();
var trueArms = new List <IDev2Activity>
{
dsfBaseConvertActivity,
dsfCalculateActivity,
dsfCaseConvertActivity
};
var trueArms1 = new List <IDev2Activity>
{
dsfBaseConvertActivity,
dsfCalculateActivity,
dsfCaseConvertActivity
};
var uniqueId = Guid.NewGuid().ToString();
var decision = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a",
FalseArm = trueArms,
Conditions = dev2DecisionStack
};
var decision1 = new Dev2.Activities.DsfDecision()
{
UniqueID = uniqueId
,
DisplayName = "a",
FalseArm = trueArms1,
Conditions = dev2DecisionStack1
};
//---------------Assert Precondition----------------
Assert.IsNotNull(decision);
//---------------Execute Test ----------------------
var equals = decision.Equals(decision1);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
