public void ApplyActivityFunc_DifferentAssigns_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var newGuid = Guid.NewGuid();
var commonAssign = CommonAssign(newGuid);
var commonAssign1 = CommonAssign(Guid.NewGuid());
var uniqueId = Guid.NewGuid().ToString();
var dsfSelectAndApplyActivity = new DsfSelectAndApplyActivity()
{
UniqueID = uniqueId,
DisplayName = "AAA",
ApplyActivityFunc = new ActivityFunc <string, bool>()
{
Handler = commonAssign
}
};
var selectAndApplyActivity = new DsfSelectAndApplyActivity()
{
UniqueID = uniqueId,
DisplayName = "AAA",
ApplyActivityFunc = new ActivityFunc <string, bool>()
{
Handler = commonAssign1
}
};
//---------------Assert Precondition----------------
Assert.IsNotNull(dsfSelectAndApplyActivity);
//---------------Execute Test ----------------------
var @equals = dsfSelectAndApplyActivity.Equals(selectAndApplyActivity);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
DsfSelectAndApplyActivity SetupArguments(string currentDl, string testData, IDev2Activity activity, bool isInputMapping = false, string inputMapping = null)
{
//DsfActivity activity = inputMapping != null ? CreateWorkflow(inputMapping, isInputMapping) : CreateWorkflow();
DataObject.Environment = new ExecutionEnvironment();
DataObject.Environment.Assign("[[Person().Name]]", "Bob", 0);
DataObject.Environment.Assign("[[Person().Name]]", "Dora", 0);
DataObject.Environment.Assign("[[Person().Name]]", "Superman", 0);
DataObject.Environment.Assign("[[Person().Name]]", "Batman", 0);
DataObject.Environment.Assign("[[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;
TestData = currentDl;
return(dsfSelectAndApplyActivity);
}
DsfSelectAndApplyActivity SetupArgumentsForFormatNumber(string currentDl, string testData, IDev2Activity activity, bool isInputMapping = false, string inputMapping = null)
{
//DsfActivity activity = inputMapping != null ? CreateWorkflow(inputMapping, isInputMapping) : CreateWorkflow();
DataObject.Environment = new ExecutionEnvironment();
DataObject.Environment.Assign("[[Person().Age]]", "5.2687454", 0);
DataObject.Environment.Assign("[[Person().Age]]", "2.3", 0);
DataObject.Environment.Assign("[[Person().Age]]", "1", 0);
DataObject.Environment.Assign("[[Person().Age]]", "-3.4554", 0);
DataObject.Environment.Assign("[[Person().Age]]", "0.875768", 0);
const string dataSource = "[[Person(*).Age]]";
const string alias = "[[result]]";
var dsfSelectAndApplyActivity = new DsfSelectAndApplyActivity
{
DataSource = dataSource,
Alias = alias,
//ApplyActivity = activity
};
dsfSelectAndApplyActivity.ApplyActivityFunc.Handler = activity as Activity;
TestStartNode = new FlowStep
{
Action = dsfSelectAndApplyActivity
};
CurrentDl = testData;
TestData = currentDl;
return(dsfSelectAndApplyActivity);
}
public void SelectAndApplyActivity_GetForEachOutputs()
{
var activity = new DsfSelectAndApplyActivity();
activity.Alias = "[[Rec(*)]]";
var dsfForEachItems = activity.GetForEachOutputs();
Assert.AreEqual(dsfForEachItems.Single().Value, "[[Rec()]]");
}
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]);
}
public void UniqueIDDifferent_EmptySelectAndApply_Object_IsEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var dsfSelectAndApplyActivity = new DsfSelectAndApplyActivity();
var selectAndApplyActivity = new DsfSelectAndApplyActivity();
//---------------Assert Precondition----------------
Assert.IsNotNull(dsfSelectAndApplyActivity);
//---------------Execute Test ----------------------
var @equals = dsfSelectAndApplyActivity.Equals(selectAndApplyActivity);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
public void SelectAndApplyActivity_SetupExecute_GivenNumberFormatTool_ToCorrectFormat_ComplexObjects()
{
var activity = new DsfNumberFormatActivity
{
Expression = "[[result]]",
Result = "[[result]]",
RoundingType = enRoundingType.Up.GetDescription(),
RoundingDecimalPlaces = "2",
DecimalPlacesToShow = "2"
};
//------------Setup for test--------------------------
//SetupArgumentsForFormatNumber("", "", activity);
DataObject.Environment = new ExecutionEnvironment();
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Age]]", "5.2687454"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Age]]", "2.3"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Age]]", "1"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Age]]", "-3.4554"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Age]]", "0.875768"), 0);
const string dataSource = "[[@Person(*).Age]]";
const string alias = "[[result]]";
var dsfSelectAndApplyActivity = new DsfSelectAndApplyActivity
{
DataSource = dataSource,
Alias = alias,
//ApplyActivity = activity
};
dsfSelectAndApplyActivity.ApplyActivityFunc.Handler = activity;
TestStartNode = new FlowStep
{
Action = dsfSelectAndApplyActivity
};
CurrentDl = string.Empty;
TestData = string.Empty;
//------------Execute Test---------------------------
ExecuteProcess(DataObject);
//------------Assert Results-------------------------
var ages = DataObject.Environment.EvalAsListOfStrings("[[@Person(*).Age]]", 0);
Assert.AreEqual("5.27", ages[0]);
Assert.AreEqual("2.30", ages[1]);
Assert.AreEqual("1.00", ages[2]);
Assert.AreEqual("-3.46", ages[3]);
Assert.AreEqual("0.88", ages[4]);
}
public void DsfSelectAndApplyActivity_GetState_ReturnsStateVariable()
{
//---------------Set up test pack-------------------
//------------Setup for test--------------------------
var act = new DsfSelectAndApplyActivity
{
DataSource = "[[DataSource]]",
Alias = "[[Alias]]"
};
//------------Execute Test---------------------------
var stateItems = act.GetState();
Assert.AreEqual(2, stateItems.Count());
var expectedResults = new[]
{
new StateVariable
{
Name = "DataSource",
Type = StateVariable.StateType.Input,
Value = "[[DataSource]]"
},
new StateVariable
{
Name = "Alias",
Type = StateVariable.StateType.InputOutput,
Value = "[[Alias]]"
}
};
var iter = act.GetState().Select(
(item, index) => new
{
value = item,
expectValue = expectedResults[index]
}
);
//------------Assert Results-------------------------
foreach (var entry in iter)
{
Assert.AreEqual(entry.expectValue.Name, entry.value.Name);
Assert.AreEqual(entry.expectValue.Type, entry.value.Type);
Assert.AreEqual(entry.expectValue.Value, entry.value.Value);
}
}
ModelItem CreateModelItem()
{
var uniqueId = Guid.NewGuid().ToString();
var commonAssign = CommonAssign();
var dsfSelectAndApplyActivity = new DsfSelectAndApplyActivity
{
UniqueID = uniqueId,
DisplayName = "AAA",
ApplyActivityFunc = new ActivityFunc <string, bool>
{
Handler = commonAssign
}
};
return(ModelItemUtils.CreateModelItem(dsfSelectAndApplyActivity));
}
protected override void BuildDataList()
{
List <Tuple <string, string> > variableList;
scenarioContext.TryGetValue("variableList", out variableList);
if (variableList == null)
{
variableList = new List <Tuple <string, string> >();
scenarioContext.Add("variableList", variableList);
}
BuildShapeAndTestData();
string datasource;
if (!scenarioContext.TryGetValue("datasource", out datasource))
{
datasource = string.Empty;
}
string alias;
if (!scenarioContext.TryGetValue("alias", out alias))
{
alias = string.Empty;
}
Activity innerActivity = scenarioContext.Get <Activity>("innerActivity");
DsfSelectAndApplyActivity selectAndApplyTool = new DsfSelectAndApplyActivity();
selectAndApplyTool.DataSource = datasource;
selectAndApplyTool.Alias = alias;
selectAndApplyTool.ApplyActivityFunc.Handler = innerActivity;
TestStartNode = new FlowStep
{
Action = selectAndApplyTool
};
scenarioContext.Add("activity", selectAndApplyTool);
}
public void Equals_Given_Different_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var dsfSelectAndApplyActivity = new DsfSelectAndApplyActivity()
{
UniqueID = uniqueId, DisplayName = "A"
};
var selectAndApplyActivity = new DsfSelectAndApplyActivity()
{
UniqueID = uniqueId, DisplayName = "ass"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(dsfSelectAndApplyActivity);
//---------------Execute Test ----------------------
var @equals = dsfSelectAndApplyActivity.Equals(selectAndApplyActivity);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
public void SelectAndApplyActivity_SetupExecute_GivenNullDataSource_DataObjectsHasCorrectErrors()
{
var activity = new DsfNumberFormatActivity
{
Expression = "[[result]]",
Result = "[[result]]",
RoundingType = enRoundingType.Up.GetDescription(),
RoundingDecimalPlaces = "2",
DecimalPlacesToShow = "2"
};
//------------Setup for test--------------------------
//SetupArgumentsForFormatNumber("", "", activity);
DataObject.Environment = new ExecutionEnvironment();
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Age]]", "5.2687454"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Age]]", "2.3"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Age]]", "1"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Age]]", "-3.4554"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Age]]", "0.875768"), 0);
var dsfSelectAndApplyActivity = new DsfSelectAndApplyActivity();
dsfSelectAndApplyActivity.ApplyActivityFunc.Handler = activity;
TestStartNode = new FlowStep
{
Action = dsfSelectAndApplyActivity
};
CurrentDl = string.Empty;
TestData = string.Empty;
//------------Execute Test---------------------------
ExecuteProcess(DataObject);
//------------Assert Results-------------------------
var errors = DataObject.Environment.Errors;
Assert.AreEqual(2, errors.Count);
Assert.IsTrue(errors.Contains(ErrorResource.DataSourceEmpty));
Assert.IsTrue(errors.Contains(string.Format(ErrorResource.CanNotBeEmpty, "Alias")));
}
/// <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 SelectAndApplyActivity_UpdateForEachOutputs_ThrowsException()
{
var activity = new DsfSelectAndApplyActivity();
activity.UpdateForEachOutputs(new List <Tuple <string, string> >());
}
