/// <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>();
Dev2FindMissingStrategyFactory stratFac = new Dev2FindMissingStrategyFactory();
DsfSequenceActivity sequenceActivity = activity as DsfSequenceActivity;
if(sequenceActivity != null)
{
foreach(var innerActivity in sequenceActivity.Activities)
{
IDev2Activity dsfActivityAbstractString = innerActivity as IDev2Activity;
if(dsfActivityAbstractString != null)
{
GetResults(dsfActivityAbstractString, stratFac, results);
}
}
}
IEnumerable<PropertyInfo> properties = StringAttributeRefectionUtils.ExtractAdornedProperties<FindMissingAttribute>(activity);
// ReSharper disable LoopCanBeConvertedToQuery
foreach(PropertyInfo propertyInfo in properties)
// ReSharper restore LoopCanBeConvertedToQuery
{
object property = propertyInfo.GetValue(activity, null);
if(property != null)
{
results.Add(property.ToString());
}
}
return results;
}
public void GetActivityFieldsOffMultiAssignActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfMultiAssignActivity multiAssignActivity = new DsfMultiAssignActivity { FieldsCollection = new List<ActivityDTO> { new ActivityDTO("[[AssignRight1]]", "[[AssignLeft1]]", 1), new ActivityDTO("[[AssignRight2]]", "[[AssignLeft2]]", 2) } };
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.DataGridActivity);
List<string> actual = strategy.GetActivityFields(multiAssignActivity);
List<string> expected = new List<string> { "[[AssignRight1]]", "[[AssignLeft1]]", "[[AssignRight2]]", "[[AssignLeft2]]" };
CollectionAssert.AreEqual(expected, actual);
}
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 GetActivityFieldsOffBaseConvertActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfBaseConvertActivity baseConvertActivity = new DsfBaseConvertActivity { ConvertCollection = new List<BaseConvertTO> { new BaseConvertTO("[[FromExpression]]", "Text", "Binary", "[[ToExpression]]", 1), new BaseConvertTO("[[FromExpression2]]", "Text", "Binary", "[[ToExpression2]]", 2) } };
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.DataGridActivity);
List<string> actual = strategy.GetActivityFields(baseConvertActivity);
List<string> expected = new List<string> { "[[FromExpression]]", "[[ToExpression]]", "[[FromExpression2]]", "[[ToExpression2]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDsfCalculateActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfCalculateActivity activity = new DsfCalculateActivity();
activity.Expression = "[[Expression]]";
activity.Result = "[[Result]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "[[Expression]]", "[[Result]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDataMergeActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfDataMergeActivity dataMergeActivity = new DsfDataMergeActivity();
dataMergeActivity.OnErrorVariable = "[[onErr]]";
dataMergeActivity.MergeCollection = new List<DataMergeDTO> { new DataMergeDTO("[[InputVariable1]]", "None", "[[At1]]", 1, "[[Padding1]]", "Left"), new DataMergeDTO("[[InputVariable2]]", "None", "[[At2]]", 2, "[[Padding2]]", "Left") };
dataMergeActivity.Result = "[[Result]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.MixedActivity);
List<string> actual = strategy.GetActivityFields(dataMergeActivity);
List<string> expected = new List<string> { "[[Padding1]]", "[[InputVariable1]]", "[[At1]]", "[[Padding2]]", "[[InputVariable2]]", "[[At2]]", "[[Result]]", "[[onErr]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDataSplitActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfDataSplitActivity dataSplitActivity = new DsfDataSplitActivity();
dataSplitActivity.OnErrorVariable = "[[onErr]]";
dataSplitActivity.ResultsCollection = new List<DataSplitDTO> { new DataSplitDTO("[[OutputVariable1]]", "Index", "[[At1]]", 1) { EscapeChar = "[[Escaped1]]" }, new DataSplitDTO("[[OutputVariable2]]", "Index", "[[At2]]", 2) { EscapeChar = "[[Escaped2]]" } };
dataSplitActivity.SourceString = "[[SourceString]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.MixedActivity);
List<string> actual = strategy.GetActivityFields(dataSplitActivity);
List<string> expected = new List<string> { "[[Escaped1]]", "[[OutputVariable1]]", "[[At1]]", "[[Escaped2]]", "[[OutputVariable2]]", "[[At2]]", "[[SourceString]]", "[[onErr]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDsfActivityExpectedAllFindMissingFieldsToBeReturned()
{
var expectedOnError = new List<string> { "[[ErrorVar]]", "http://*****:*****@"<Inputs><Input Name=""reg"" Source=""NUD2347"" DefaultValue=""NUD2347""><Validator Type=""Required"" /></Input><Input Name=""asdfsad"" Source=""registration223"" DefaultValue=""w3rt24324""><Validator Type=""Required"" /></Input><Input Name=""number"" Source=""[[number]]"" /></Inputs>";
activity.OutputMapping = @"<Outputs><Output Name=""vehicleVin"" MapsTo=""VIN"" Value="""" /><Output Name=""vehicleColor"" MapsTo=""VehicleColor"" Value="""" /><Output Name=""speed"" MapsTo=""speed"" Value="""" Recordset=""Fines"" /><Output Name=""date"" MapsTo=""date"" Value=""Fines.Date"" Recordset=""Fines"" /><Output Name=""location"" MapsTo=""location"" Value="""" Recordset=""Fines"" /></Outputs>";
activity.OnErrorVariable = expectedOnError[0];
activity.OnErrorWorkflow = expectedOnError[1];
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.DsfActivity);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "NUD2347", "registration223", "[[number]]", "Fines.Date", expectedOnError[0], expectedOnError[1] };
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDsfForEachActivityWithADsfActivityInsideItExpectedAllFindMissingFieldsToBeReturned()
{
DsfActivity dsfActivity = new DsfActivity
{
InputMapping = @"<Inputs><Input Name=""reg"" Source=""NUD2347"" DefaultValue=""NUD2347""><Validator Type=""Required"" /></Input><Input Name=""asdfsad"" Source=""registration223"" DefaultValue=""w3rt24324""><Validator Type=""Required"" /></Input><Input Name=""number"" Source=""[[number]]"" /></Inputs>",
OutputMapping = @"<Outputs><Output Name=""vehicleVin"" MapsTo=""VIN"" Value="""" /><Output Name=""vehicleColor"" MapsTo=""VehicleColor"" Value="""" /><Output Name=""speed"" MapsTo=""speed"" Value="""" Recordset=""Fines"" /><Output Name=""date"" MapsTo=""date"" Value=""Fines.Date"" Recordset=""Fines"" /><Output Name=""location"" MapsTo=""location"" Value="""" Recordset=""Fines"" /></Outputs>"
};
DsfForEachActivity activity = new DsfForEachActivity
{
ForEachElementName = "5",
DataFunc = { Handler = dsfActivity }
};
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.ForEach);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "NUD2347", "registration223", "[[number]]", "Fines.Date", "5" };
CollectionAssert.AreEqual(expected, actual);
}
public void SequenceActivityFindMissingStrategy_GetActivityFields_WithAssignAndDecision_ReturnsAllVariables()
{
//------------Setup for test--------------------------
DsfMultiAssignActivity multiAssignActivity = new DsfMultiAssignActivity { FieldsCollection = new List<ActivityDTO> { new ActivityDTO("[[AssignRight1]]", "[[AssignLeft1]]", 1), new ActivityDTO("[[AssignRight2]]", "[[AssignLeft2]]", 2) } };
DsfFlowDecisionActivity decisionActivity = new DsfFlowDecisionActivity { OnErrorVariable = "[[error]]" };
DsfSequenceActivity activity = new DsfSequenceActivity();
activity.Activities.Add(multiAssignActivity);
activity.Activities.Add(decisionActivity);
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.Sequence);
//------------Execute Test---------------------------
List<string> actual = strategy.GetActivityFields(activity);
//------------Assert Results-------------------------
List<string> expected = new List<string> { "[[AssignRight1]]", "[[AssignLeft1]]", "[[AssignRight2]]", "[[AssignLeft2]]", "[[error]]" };
CollectionAssert.AreEqual(expected, actual);
}
/// <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>();
Dev2FindMissingStrategyFactory stratFac = new Dev2FindMissingStrategyFactory();
DsfForEachActivity forEachActivity = activity as DsfForEachActivity;
if(forEachActivity != null)
{
IFindMissingStrategy strategy;
enFindMissingType findMissingType;
var boolAct = forEachActivity.DataFunc.Handler as DsfNativeActivity<bool>;
if(boolAct == null)
{
DsfNativeActivity<string> stringAct = forEachActivity.DataFunc.Handler as DsfNativeActivity<string>;
if(stringAct != null)
{
findMissingType = stringAct.GetFindMissingType();
strategy = stratFac.CreateFindMissingStrategy(findMissingType);
results.AddRange(strategy.GetActivityFields(stringAct));
}
}
else
{
findMissingType = boolAct.GetFindMissingType();
strategy = stratFac.CreateFindMissingStrategy(findMissingType);
results.AddRange(strategy.GetActivityFields(boolAct));
}
}
IEnumerable<PropertyInfo> properties = StringAttributeRefectionUtils.ExtractAdornedProperties<FindMissingAttribute>(activity);
foreach(PropertyInfo propertyInfo in properties)
{
object property = propertyInfo.GetValue(activity, null);
if(property != null)
{
results.Add(property.ToString());
}
}
return results;
}
public void GetActivityFieldsOffDsfPathCopyActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfPathCopy activity = new DsfPathCopy();
activity.InputPath = "[[InputPath]]";
activity.OutputPath = "[[OutputPath]]";
activity.Password = "******";
activity.PrivateKeyFile = "[[KeyFile]]";
activity.Username = "******";
activity.DestinationPassword = "******";
activity.DestinationUsername = "******";
activity.DestinationPrivateKeyFile = "[[DestKeyFile]]";
activity.Result = "[[Result]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List <string> actual = strategy.GetActivityFields(activity);
List <string> expected = new List <string> {
"[[InputPath]]", "[[OutputPath]]", "[[DestUsername]]", "[[DestKeyFile]]", "[[DestPassword]]", "[[Password]]", "[[Username]]", "[[KeyFile]]", "[[Result]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void DataGridActivityFindMissingStrategy_GetActivityFields_WebPutActivity_ShouldReturnResults()
{
//------------Setup for test--------------------------
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.DataGridActivity);
var activity = new WebPutActivity
{
Inputs = new List <IServiceInput> {
new ServiceInput("Input1", "[[InputValue1]]"), new ServiceInput("Input2", "[[InputValue2]]"), new ServiceInput("Input3", "[[InputValue3]]")
},
Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("Output1", "OutputValue1", "rec"), new ServiceOutputMapping("Output2", "OutputValue2", "rec")
},
QueryString = "[[qstring]]",
Headers = new List <INameValue> {
new NameValue("Content-Type", "[[ctype]]")
},
OnErrorVariable = "[[err]]",
OnErrorWorkflow = "[[errSvc]]",
PutData = "[[putdata]]",
IsPutDataBase64 = true
};
//------------Execute Test---------------------------
var fields = strategy.GetActivityFields(activity);
//------------Assert Results-------------------------
Assert.AreEqual(11, fields.Count);
Assert.IsTrue(fields.Contains("[[InputValue1]]"));
Assert.IsTrue(fields.Contains("[[InputValue2]]"));
Assert.IsTrue(fields.Contains("[[InputValue3]]"));
Assert.IsTrue(fields.Contains("[[rec().OutputValue1]]"));
Assert.IsTrue(fields.Contains("[[rec().OutputValue2]]"));
Assert.IsTrue(fields.Contains("[[qstring]]"));
Assert.IsTrue(fields.Contains("[[err]]"));
Assert.IsTrue(fields.Contains("[[errSvc]]"));
Assert.IsTrue(fields.Contains("Content-Type"));
Assert.IsTrue(fields.Contains("[[ctype]]"));
Assert.IsTrue(fields.Contains("[[putdata]]"));
}
public void GetActivityFieldsOffDsfActivityExpectedAllFindMissingFieldsToBeReturned()
{
var expectedOnError = new List <string> {
"[[ErrorVar]]", "http://*****:*****@"<Inputs><Input Name=""reg"" Source=""NUD2347"" DefaultValue=""NUD2347""><Validator Type=""Required"" /></Input><Input Name=""asdfsad"" Source=""registration223"" DefaultValue=""w3rt24324""><Validator Type=""Required"" /></Input><Input Name=""number"" Source=""[[number]]"" /></Inputs>";
activity.OutputMapping = @"<Outputs><Output Name=""vehicleVin"" MapsTo=""VIN"" Value="""" /><Output Name=""vehicleColor"" MapsTo=""VehicleColor"" Value="""" /><Output Name=""speed"" MapsTo=""speed"" Value="""" Recordset=""Fines"" /><Output Name=""date"" MapsTo=""date"" Value=""Fines.Date"" Recordset=""Fines"" /><Output Name=""location"" MapsTo=""location"" Value="""" Recordset=""Fines"" /></Outputs>";
activity.OnErrorVariable = expectedOnError[0];
activity.OnErrorWorkflow = expectedOnError[1];
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.DsfActivity);
List <string> actual = strategy.GetActivityFields(activity);
List <string> expected = new List <string> {
"NUD2347", "registration223", "[[number]]", "Fines.Date", expectedOnError[0], expectedOnError[1]
};
CollectionAssert.AreEqual(expected, actual);
}
public void DataGridActivityFindMissingStrategy_GetActivityFields_AdvancedRecordsetActivity_GivenSqlQueryWithTwoField_ShouldReturnResults()
{
//--------------Arrange------------------------------
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.DataGridActivity);
var activity = new AdvancedRecordsetActivity()
{
SqlQuery = "Select id, name from person",
Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("id", "id", "TableCopy"), new ServiceOutputMapping("name", "name", "TableCopy")
},
};
//--------------Act----------------------------------
var fields = strategy.GetActivityFields(activity);
//--------------Assert-------------------------------
Assert.AreEqual(5, fields.Count);
Assert.IsTrue(fields.Contains("[[person()]]"));
Assert.IsTrue(fields.Contains("[[person().id]]"));
Assert.IsTrue(fields.Contains("[[person().name]]"));
Assert.IsTrue(fields.Contains("[[TableCopy().id]]"));
Assert.IsTrue(fields.Contains("[[TableCopy().name]]"));
}
public void Dev2FindMissingStrategyFactory_GetActivityFieldsOff_DsfPathRename_Activity_ExpectAllFindMissingFieldsToBeReturned()
{
var activity = new DsfPathRename
{
InputPath = "[[InputPath]]",
OutputPath = "[[OutputPath]]",
Password = "******",
Username = "******",
PrivateKeyFile = "[[KeyFile]]",
DestinationPassword = "******",
DestinationUsername = "******",
DestinationPrivateKeyFile = "[[DestKeyFile]]",
Result = "[[Result]]"
};
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
var actual = strategy.GetActivityFields(activity);
var expected = new List <string> {
"[[InputPath]]", "[[OutputPath]]", "[[DestUsername]]", "[[DestKeyFile]]", "[[DestPassword]]", "[[Password]]", "[[Username]]", "[[KeyFile]]", "[[Result]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOf_NativeActivity_ExpectErrorWorkflowFieldToBeReturned()
{
var act = new DsfFindRecordsMultipleCriteriaActivity
{
ResultsCollection = new List <FindRecordsTO>
{
new FindRecordsTO("criteria1", "any", 1),
new FindRecordsTO("criteria2", "any", 2)
},
OnErrorVariable = "[[onErr]]",
FieldsToSearch = "field1",
Result = "[[result]]",
OnErrorWorkflow = "errorWorkflow"
};
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.MixedActivity);
var actual = strategy.GetActivityFields(act);
var expected = new List <string> {
"", "", "criteria1", "", "", "criteria2", "field1", "[[result]]", "[[onErr]]", "errorWorkflow"
};
CollectionAssert.AreEqual(expected, actual);
}
public void DataGridActivityFindMissingStrategy_GetActivityFields_DsfEnhancedDotNetDllActivity_ShouldReturnResults()
{
//------------Setup for test--------------------------
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.DataGridActivity);
var activity = new DsfEnhancedDotNetDllActivity
{
ObjectName = "[[@Home]]",
ConstructorInputs = new List <IServiceInput>
{
new ServiceInput("name", "[[name]]")
},
MethodsToRun = new List <IPluginAction>
{
new PluginAction {
OutputVariable = "[[name1]]"
},
new PluginAction {
OutputVariable = "[[@nameObj]]"
}
},
OnErrorVariable = "[[err]]",
OnErrorWorkflow = "[[errSvc]]",
IsObject = true
};
//------------Execute Test---------------------------
var fields = strategy.GetActivityFields(activity);
//------------Assert Results-------------------------
Assert.AreEqual(6, fields.Count);
Assert.IsTrue(fields.Contains("[[@Home]]"));
Assert.IsTrue(fields.Contains("[[name]]"));
Assert.IsTrue(fields.Contains("[[name1]]"));
Assert.IsTrue(fields.Contains("[[@nameObj]]"));
Assert.IsTrue(fields.Contains("[[err]]"));
Assert.IsTrue(fields.Contains("[[errSvc]]"));
}
public void SequenceActivityFindMissingStrategy_GetActivityFields_WithAssignAndDataMerge_ReturnsAllVariables()
{
//------------Setup for test--------------------------
DsfMultiAssignActivity multiAssignActivity = new DsfMultiAssignActivity { FieldsCollection = new List<ActivityDTO> { new ActivityDTO("[[AssignRight1]]", "[[AssignLeft1]]", 1), new ActivityDTO("[[AssignRight2]]", "[[AssignLeft2]]", 2) } };
DsfDataMergeActivity dataMergeActivity = new DsfDataMergeActivity { Result = "[[Result]]" };
dataMergeActivity.MergeCollection.Add(new DataMergeDTO("[[rec().a]]", "Index", "6", 1, "[[b]]", "Left"));
DsfActivity dsfActivity = new DsfActivity { InputMapping = @"<Inputs><Input Name=""reg"" Source=""NUD2347"" DefaultValue=""NUD2347""><Validator Type=""Required"" /></Input><Input Name=""asdfsad"" Source=""registration223"" DefaultValue=""w3rt24324""><Validator Type=""Required"" /></Input><Input Name=""number"" Source=""[[number]]"" /></Inputs>", OutputMapping = @"<Outputs><Output Name=""vehicleVin"" MapsTo=""VIN"" Value="""" /><Output Name=""vehicleColor"" MapsTo=""VehicleColor"" Value="""" /><Output Name=""speed"" MapsTo=""speed"" Value="""" Recordset=""Fines"" /><Output Name=""date"" MapsTo=""date"" Value=""Fines.Date"" Recordset=""Fines"" /><Output Name=""location"" MapsTo=""location"" Value="""" Recordset=""Fines"" /></Outputs>" };
DsfForEachActivity forEachActivity = new DsfForEachActivity { ForEachElementName = "5", DataFunc = { Handler = dsfActivity } };
DsfSequenceActivity activity = new DsfSequenceActivity();
activity.Activities.Add(multiAssignActivity);
activity.Activities.Add(dataMergeActivity);
activity.Activities.Add(forEachActivity);
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.Sequence);
//------------Execute Test---------------------------
List<string> actual = strategy.GetActivityFields(activity);
//------------Assert Results-------------------------
List<string> expected = new List<string> { "[[AssignRight1]]", "[[AssignLeft1]]", "[[AssignRight2]]", "[[AssignLeft2]]", "[[b]]", "[[rec().a]]", "6", "[[Result]]", "NUD2347", "registration223", "[[number]]", "Fines.Date", "5" };
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDataSplitActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfDataSplitActivity dataSplitActivity = new DsfDataSplitActivity();
dataSplitActivity.OnErrorVariable = "[[onErr]]";
dataSplitActivity.ResultsCollection = new List <DataSplitDTO> {
new DataSplitDTO("[[OutputVariable1]]", "Index", "[[At1]]", 1)
{
EscapeChar = "[[Escaped1]]"
}, new DataSplitDTO("[[OutputVariable2]]", "Index", "[[At2]]", 2)
{
EscapeChar = "[[Escaped2]]"
}
};
dataSplitActivity.SourceString = "[[SourceString]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.MixedActivity);
List <string> actual = strategy.GetActivityFields(dataSplitActivity);
List <string> expected = new List <string> {
"[[Escaped1]]", "[[OutputVariable1]]", "[[At1]]", "[[Escaped2]]", "[[OutputVariable2]]", "[[At2]]", "[[SourceString]]", "[[onErr]]"
};
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDsfPathDeleteActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfPathDelete activity = new DsfPathDelete();
activity.InputPath = "[[InputPath]]";
activity.Password = "******";
activity.Username = "******";
activity.PrivateKeyFile = "[[KeyFile]]";
activity.Result = "[[Result]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "[[InputPath]]", "[[Password]]", "[[Username]]","[[KeyFile]]", "[[Result]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDsfIndexActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfIndexActivity activity = new DsfIndexActivity();
activity.InField = "[[InField]]";
activity.Characters = "[[Characters]]";
activity.Result = "[[Result]]";
activity.StartIndex = "[[StartIndex]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "[[InField]]", "[[Characters]]", "[[Result]]", "[[StartIndex]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDsfFindRecordsActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfFindRecordsActivity activity = new DsfFindRecordsActivity();
activity.FieldsToSearch = "[[FieldsToSearch]]";
activity.SearchCriteria = "[[SearchCriteria]]";
activity.Result = "[[Result]]";
activity.StartIndex = "[[StartIndex]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "[[FieldsToSearch]]", "[[SearchCriteria]]", "[[Result]]", "[[StartIndex]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDsfExecuteCommandLineActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfExecuteCommandLineActivity activity = new DsfExecuteCommandLineActivity();
activity.CommandFileName = "[[CommandFileName]]";
activity.CommandResult = "[[CommandResult]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "[[CommandFileName]]", "[[CommandResult]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDsfDateTimeDifferenceActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfDateTimeDifferenceActivity activity = new DsfDateTimeDifferenceActivity();
activity.Input1 = "[[Input1]]";
activity.Input2 = "[[Input2]]";
activity.InputFormat = "[[InputFormat]]";
activity.Result = "[[Result]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "[[Input1]]", "[[Input2]]", "[[InputFormat]]", "[[Result]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDsfCountRecordsetActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfCountRecordsetActivity activity = new DsfCountRecordsetActivity();
activity.RecordsetName = "[[RecordsetName]]";
activity.CountNumber = "[[CountNumber]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "[[RecordsetName]]", "[[CountNumber]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void MixedActivityFindMissingStrategy_GetActivityFields_DsfSqlBulkInsertActivity_AllFindMissingFieldsToBeReturned()
{
//------------Setup for test--------------------------
var activity = new DsfSqlBulkInsertActivity
{
Result = "[[Result]]", OnErrorVariable = "[[onErr]]", InputMappings = new List<DataColumnMapping>
{
new DataColumnMapping { InputColumn = "[[rs().Field1]]", OutputColumn = new DbColumn() },
new DataColumnMapping { InputColumn = "[[rs().Field2]]", OutputColumn = new DbColumn() },
}
};
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.MixedActivity);
//------------Execute Test---------------------------
var actual = strategy.GetActivityFields(activity);
//------------Assert Results-------------------------
var expected = new List<string> { "[[rs().Field1]]", "[[rs().Field2]]", "[[Result]]", "[[onErr]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDsfZipActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfZip activity = new DsfZip();
activity.ArchiveName = "[[ArchiveName]]";
activity.ArchivePassword = "******";
activity.CompressionRatio = "[[CompressionRatio]]";
activity.InputPath = "[[InputPath]]";
activity.OutputPath = "[[OutputPath]]";
activity.Password = "******";
activity.Username = "******";
activity.PrivateKeyFile = "[[KeyFile]]";
activity.DestinationPassword = "******";
activity.DestinationUsername = "******";
activity.DestinationPrivateKeyFile = "[[DestKeyFile]]";
activity.Result = "[[Result]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> {"[[ArchivePassword]]", "[[ArchiveName]]", "[[CompressionRatio]]", "[[InputPath]]", "[[OutputPath]]", "[[DestUsername]]","[[DestKeyFile]]", "[[DestPassword]]", "[[Password]]", "[[Username]]","[[KeyFile]]", "[[Result]]" };
CollectionAssert.AreEqual(expected, actual);
}
public void GetActivityFieldsOffDsfForEachActivityWithADsfMultiAssignActivityInsideItExpectedAllFindMissingFieldsToBeReturned()
{
DsfMultiAssignActivity multiAssignActivity = new DsfMultiAssignActivity { FieldsCollection = new List<ActivityDTO> { new ActivityDTO("[[AssignRight1]]", "[[AssignLeft1]]", 1), new ActivityDTO("[[AssignRight2]]", "[[AssignLeft2]]", 2) } };
DsfForEachActivity activity = new DsfForEachActivity
{
ForEachElementName = "5",
DataFunc = { Handler = multiAssignActivity }
};
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.ForEach);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "[[AssignRight1]]", "[[AssignLeft1]]", "[[AssignRight2]]", "[[AssignLeft2]]", "5" };
CollectionAssert.AreEqual(expected, actual);
}
static void GetResults(IDev2Activity dsfActivityAbstractString, Dev2FindMissingStrategyFactory stratFac, List<string> results)
{
enFindMissingType findMissingType = dsfActivityAbstractString.GetFindMissingType();
IFindMissingStrategy strategy = stratFac.CreateFindMissingStrategy(findMissingType);
results.AddRange(strategy.GetActivityFields(dsfActivityAbstractString));
}
/// <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>();
Dev2FindMissingStrategyFactory stratFac = new Dev2FindMissingStrategyFactory();
DsfForEachActivity forEachActivity = activity as DsfForEachActivity;
if (forEachActivity != null)
{
IFindMissingStrategy strategy;
enFindMissingType findMissingType;
var boolAct = forEachActivity.DataFunc.Handler as DsfNativeActivity <bool>;
if (boolAct == null)
{
DsfNativeActivity <string> stringAct = forEachActivity.DataFunc.Handler as DsfNativeActivity <string>;
if (stringAct != null)
{
findMissingType = stringAct.GetFindMissingType();
strategy = stratFac.CreateFindMissingStrategy(findMissingType);
results.AddRange(strategy.GetActivityFields(stringAct));
}
}
else
{
findMissingType = boolAct.GetFindMissingType();
strategy = stratFac.CreateFindMissingStrategy(findMissingType);
results.AddRange(strategy.GetActivityFields(boolAct));
}
}
DsfSelectAndApplyActivity selectAndApply = activity as DsfSelectAndApplyActivity;
if (selectAndApply != null)
{
IFindMissingStrategy strategy;
enFindMissingType findMissingType;
var boolAct = selectAndApply.ApplyActivityFunc.Handler as DsfNativeActivity <bool>;
if (boolAct == null)
{
DsfNativeActivity <string> stringAct = selectAndApply.ApplyActivityFunc.Handler as DsfNativeActivity <string>;
if (stringAct != null)
{
findMissingType = stringAct.GetFindMissingType();
strategy = stratFac.CreateFindMissingStrategy(findMissingType);
results.AddRange(strategy.GetActivityFields(stringAct));
}
}
else
{
findMissingType = boolAct.GetFindMissingType();
strategy = stratFac.CreateFindMissingStrategy(findMissingType);
results.AddRange(strategy.GetActivityFields(boolAct));
}
}
IEnumerable <PropertyInfo> properties = StringAttributeRefectionUtils.ExtractAdornedProperties <FindMissingAttribute>(activity);
foreach (PropertyInfo propertyInfo in properties)
{
object property = propertyInfo.GetValue(activity, null);
if (property != null)
{
results.Add(property.ToString());
}
}
return(results);
}
public void GetActivityFieldsOffDsfDateTimeActivityExpectedAllFindMissingFieldsToBeReturned()
{
DsfDateTimeActivity activity = new DsfDateTimeActivity();
activity.DateTime = "[[DateTime]]";
activity.InputFormat = "[[InputFormat]]";
activity.OutputFormat = "[[OutputFormat]]";
activity.TimeModifierAmountDisplay = "[[TimeModifierAmountDisplay]]";
activity.Result = "[[Result]]";
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity);
List<string> actual = strategy.GetActivityFields(activity);
List<string> expected = new List<string> { "[[DateTime]]", "[[InputFormat]]", "[[OutputFormat]]", "[[TimeModifierAmountDisplay]]", "[[Result]]" };
CollectionAssert.AreEqual(expected, actual);
}
