public void Initialize(ISequenceFlowContainer flowContainer)
{
ISequence sequence = flowContainer as ISequence;
this.Index = sequence.Index;
this.StepParameters = new SequenceStepParameterCollection();
foreach (ISequenceStep sequenceStep in sequence.Steps)
{
SequenceStepParameter stepParameter = new SequenceStepParameter();
stepParameter.Initialize(sequenceStep);
this.StepParameters.Add(stepParameter);
}
this.VariableValues = new VariableInitValueCollection();
foreach (IVariable variable in sequence.Variables)
{
VariableInitValue initValue = new VariableInitValue()
{
Name = variable.Name
};
initValue.Initialize(variable);
this.VariableValues.Add(initValue);
}
}
public void Initialize(ISequenceFlowContainer parent)
{
ITestProject testProject = parent as ITestProject;
this.Parent = testProject;
ModuleUtils.SetElementName(this, testProject?.SequenceGroups);
Info.Modified = true;
if (null != testProject)
{
Info.Version = testProject.ModelVersion;
}
this.Available = true;
// 该参数只在序列化时生成
this.Parameters = null;
this.ExecutionModel = ExecutionModel.SequentialExecution;
this.SetUp = new Sequence()
{
Name = "SetUp",
Index = CommonConst.SetupIndex
};
this.TearDown = new Sequence()
{
Name = "TearDown",
Index = CommonConst.TeardownIndex
};
RefreshSignature();
}
public static CallStack GetStack(ISequenceStep step)
{
CallStack callStack = new CallStack();
ISequence sequence = null;
ISequenceGroup sequenceGroup = null;
while (null != step)
{
callStack.StepStack.Add(step.Index);
ISequenceFlowContainer parent = step.Parent;
if (parent is ISequence)
{
sequence = parent as ISequence;
}
step = parent as ISequenceStep;
}
if (null == sequence)
{
return(callStack);
}
callStack.Session = sequence.Index;
sequenceGroup = sequence.Parent as ISequenceGroup;
if (!(sequenceGroup?.Parent is ITestProject))
{
return(callStack);
}
ITestProject testProject = (ITestProject)sequenceGroup.Parent;
callStack.SessionIndex = testProject.SequenceGroups.IndexOf(sequenceGroup);
return(callStack);
}
private static bool HasVariableInSequence(ISequenceFlowContainer sequenceData, string variable)
{
if (null == sequenceData)
{
return(false);
}
if (sequenceData is ISequence)
{
ISequence sequence = sequenceData as ISequence;
// 如果存在则返回true
if (sequence.Variables.Any(item => item.Name.Equals(variable)))
{
return(true);
}
// 不存在时向上级查找
return(HasVariableInSequence(sequence.Parent, variable));
}
else if (sequenceData is ISequenceGroup)
{
ISequenceGroup sequenceGroup = sequenceData as ISequenceGroup;
return(sequenceGroup.Variables.Any(item => item.Name.Equals(variable)));
}
else if (sequenceData is ITestProject)
{
ITestProject testProject = sequenceData as ITestProject;
return(testProject.Variables.Any(item => item.Name.Equals(variable)));
}
return(false);
}
public void Initialize(ISequenceFlowContainer sequenceData)
{
_stateManageContext = new StateManageContext(_globalInfo, sequenceData);
if (sequenceData is ITestProject)
{
ITestProject testProject = (ITestProject)sequenceData;
SessionStateHandle testProjectStateHandle = new SessionStateHandle(testProject,
_stateManageContext);
_sessionStateHandles.Add(testProjectStateHandle.Session, testProjectStateHandle);
for (int index = 0; index < testProject.SequenceGroups.Count; index++)
{
SessionStateHandle stateHandle = new SessionStateHandle(index, testProject.SequenceGroups[index],
_stateManageContext);
_sessionStateHandles.Add(stateHandle.Session, stateHandle);
}
}
else
{
SessionStateHandle stateHandle = new SessionStateHandle(0, (ISequenceGroup)sequenceData,
_stateManageContext);
_sessionStateHandles.Add(stateHandle.Session, stateHandle);
}
_globalInfo.EventDispatcher = _stateManageContext.EventDispatcher;
}
public ISequenceStep AddSequenceStep(ISequenceFlowContainer parent, IList <ISequenceStep> stepDatas, int index)
{
if (parent is ISequence)
{
for (int n = 0; n < stepDatas.Count; n++)
{
((ISequence)parent).Steps.Insert(n + index, stepDatas[n]);
stepDatas[n].Parent = parent;
}
}
else if (parent is ISequenceStep)
{
for (int n = 0; n < stepDatas.Count; n++)
{
ISequenceStep parentStep = (ISequenceStep)parent;
if (parentStep.StepType == SequenceStepType.TryFinallyBlock ||
parentStep.StepType == SequenceStepType.SequenceCall)
{
I18N i18N = I18N.GetInstance(Constants.I18nName);
throw new TestflowDataException(ModuleErrorCode.InvalidEditOperation,
i18N.GetStr("InvalidOperation"));
}
parentStep.SubSteps.Insert(n + index, stepDatas[n]);
stepDatas[n].Parent = parent;
}
}
else
{
throw new TestflowDataException(ModuleErrorCode.InvalidEditOperation, "Parent needs to be Sequence or SequenceStep");
}
ContextSequenceGroupModify();
return(stepDatas[0]);
}
private void SetVariableAndArgumentType(string paramValue, ITypeData type, VariableTreeTable variableTree,
ISequenceFlowContainer parent)
{
IVariable variable;
IArgument argument;
string variableName = ModuleUtils.GetVarNameByParamValue(paramValue);
if (null != (variable = variableTree.GetVariable(variableName)))
{
if (!ModuleUtils.IsPropertyParam(paramValue))
{
variable.Type = type;
}
}
else if (null != (argument = variableTree.GetArgument(variableName)))
{
if (!ModuleUtils.IsPropertyParam(paramValue))
{
argument.Type = type;
}
}
else
{
ThrowIfVariableNotFound(variableName, parent);
}
}
public void Initialize(ISequenceFlowContainer sequenceData)
{
if (sequenceData is ITestProject)
{
ITestProject testProject = (ITestProject)sequenceData;
IList <ITypeData> callBackRelatedType = GetCallBackRelatedType(testProject);
IList <IAssemblyInfo>[] assemblyInfoCollections = new IList <IAssemblyInfo> [testProject.SequenceGroups.Count + 1];
IList <IAssemblyInfo> callBackRelatedAssembly = GetCallBackRelatedAssembly(callBackRelatedType, assemblyInfoCollections);
//AssemblyInvoker加载程序集和类型
_typeInvoker = new AssemblyInvoker(_globalInfo, callBackRelatedAssembly, callBackRelatedType);
_typeInvoker.LoadAssemblyAndType();
foreach (ISequenceGroup sequenceGroup in testProject.SequenceGroups)
{
SequenceGroupFindCallBack(sequenceGroup);
}
}
else
{
ISequenceGroup sequenceGroup = (ISequenceGroup)sequenceData;
IList <ITypeData> callBackRelatedType = GetCallBackRelatedType(sequenceGroup);
IList <IAssemblyInfo> callBackRelatedAssembly = GetCallBackRelatedAssembly(callBackRelatedType,
sequenceGroup.Assemblies);
//AssemblyInvoker加载程序集和类型
_typeInvoker = new AssemblyInvoker(_globalInfo, callBackRelatedAssembly, callBackRelatedType);
_typeInvoker.LoadAssemblyAndType();
SequenceGroupFindCallBack(sequenceGroup);
}
}
public VariableMapper(SlaveContext context)
{
ISequenceFlowContainer sequenceData = context.Sequence;
this._variables = new Dictionary <string, object>(512);
this._keyVariables = new HashSet <string>();
this._syncVariables = new HashSet <string>();
this._context = context;
_fullTraceVariables = new List <string>(Constants.DefaultRuntimeSize);
if (context.SequenceType == RunnerType.TestProject)
{
ITestProject testProject = (ITestProject)sequenceData;
AddVariables(testProject.Variables, false);
AddVariables(testProject.SetUp.Variables, false);
AddVariables(testProject.TearDown.Variables, false);
}
else
{
bool addSessionVarToSyncSet = ExecutionModel.ParallelExecution == context.ExecutionModel;
ISequenceGroup sequenceGroup = (ISequenceGroup)sequenceData;
AddVariables(sequenceGroup.Variables, addSessionVarToSyncSet);
AddVariables(sequenceGroup.SetUp.Variables, false);
AddVariables(sequenceGroup.TearDown.Variables, false);
foreach (ISequence sequence in sequenceGroup.Sequences)
{
AddVariables(sequence.Variables, false);
}
}
this._keyVarLock = new SpinLock(false);
this._syncVarLock = new ReaderWriterLockSlim();
}
public ExpressionElement(IExpressionData value)
{
this._type = ParameterType.Expression;
this._value = string.Empty;
this._expression = value;
this._parent = null;
}
private void InitializeSubStep(ISequenceFlowContainer parent)
{
ISequenceStep sequence = parent as ISequenceStep;
this.Parent = parent;
ModuleUtils.SetElementName(this, sequence.SubSteps);
}
public void Initialize(ISequenceFlowContainer parent)
{
ISequenceStep sequenceStep = parent as ISequenceStep;
if (null != sequenceStep.SubSteps && sequenceStep.SubSteps.Count > 0)
{
this.SubStepParameters = new SequenceStepParameterCollection();
foreach (ISequenceStep subStep in sequenceStep.SubSteps)
{
SequenceStepParameter stepParameter = new SequenceStepParameter();
stepParameter.Initialize(subStep);
this.SubStepParameters.Add(stepParameter);
}
}
else
{
this.SubStepParameters = null;
}
IFunctionData functionData = sequenceStep.Function;
if (functionData?.Parameters != null && functionData.Parameters.Count > 0)
{
this.Parameters = functionData.Parameters;
}
else
{
this.Parameters = null;
}
if (null != functionData)
{
this.Return = functionData.Return;
this.Instance = functionData.Instance;
}
}
public ExpressionElement()
{
this._type = ParameterType.NotAvailable;
this._value = string.Empty;
this._expression = null;
this._parent = null;
}
private static void ValidateParent(IVariableCollection variables, ISequenceFlowContainer parent)
{
foreach (IVariable variable in variables)
{
variable.Parent = parent;
}
}
//todo I18n
public void RemoveSequenceStep(ISequenceFlowContainer parent, ISequenceStep step)
{
bool removed = false;
if (parent is ISequence)
{
removed = ((ISequence)parent).Steps.Remove(step);
}
else if (parent is ISequenceStep)
{
ISequenceStep parentStep = (ISequenceStep)parent;
if (parentStep.StepType == SequenceStepType.TryFinallyBlock ||
parentStep.StepType == SequenceStepType.SequenceCall)
{
I18N i18N = I18N.GetInstance(Constants.I18nName);
throw new TestflowDataException(ModuleErrorCode.InvalidEditOperation,
i18N.GetStr("InvalidOperation"));
}
removed = (parentStep).SubSteps.Remove(step);
}
else
{
throw new TestflowDataException(ModuleErrorCode.InvalidEditOperation, "Parent needs to be Sequence or SequenceStep");
}
//判断成功remove与否
if (removed)
{
ContextSequenceGroupModify();
}
else
{
throw new TestflowDataException(ModuleErrorCode.TargetNotExist, $"Step {step.Name} could not be found in parent {parent.Name}");
}
}
public void Initialize(ISequenceFlowContainer flowContainer)
{
ISequenceGroup sequenceGroup = flowContainer as ISequenceGroup;
this.Info.Hash = sequenceGroup.Info.Hash;
this.Info.Modified = true;
this.Info.ModifiedTime = DateTime.Now;
this.Info.Path = sequenceGroup.Info.SequenceParamFile;
this.Info.Version = sequenceGroup.Info.Version;
this.VariableValues = new VariableInitValueCollection();
foreach (IVariable variable in sequenceGroup.Variables)
{
VariableInitValue variableInitValue = new VariableInitValue()
{
Name = variable.Name
};
variableInitValue.Initialize(variable);
this.VariableValues.Add(variableInitValue);
}
this.SetUpParameters = new SequenceParameter();
this.SetUpParameters.Initialize(sequenceGroup.SetUp);
this.SequenceParameters = new SequenceParameterCollection();
foreach (ISequence sequence in sequenceGroup.Sequences)
{
SequenceParameter parameter = new SequenceParameter();
parameter.Initialize(sequence);
SequenceParameters.Add(parameter);
}
this.TearDownParameters = new SequenceParameter();
this.TearDownParameters.Initialize(sequenceGroup.TearDown);
}
public SessionTaskEntity(SlaveContext context)
{
this._context = context;
ISequenceFlowContainer sequenceData = _context.Sequence;
switch (context.SequenceType)
{
case RunnerType.TestProject:
ITestProject testProject = (ITestProject)sequenceData;
_setUp = new SequenceTaskEntity(testProject.SetUp, _context);
_tearDown = new SequenceTaskEntity(testProject.TearDown, _context);
_sequenceEntities = new List <SequenceTaskEntity>(1);
break;
case RunnerType.SequenceGroup:
ISequenceGroup sequenceGroup = (ISequenceGroup)sequenceData;
_setUp = new SequenceTaskEntity(sequenceGroup.SetUp, _context);
_tearDown = new SequenceTaskEntity(sequenceGroup.TearDown, _context);
_sequenceEntities = new List <SequenceTaskEntity>(sequenceGroup.Sequences.Count);
foreach (ISequence sequence in sequenceGroup.Sequences)
{
_sequenceEntities.Add(new SequenceTaskEntity(sequence, _context));
}
break;
default:
throw new InvalidOperationException();
}
}
/// <summary>
/// 初始化变量和参数的类型数据
/// </summary>
public bool VerifyVariableType(ISequenceFlowContainer flowContainer, IVariable variable, TypeDataCollection typeDatas)
{
if (flowContainer is ITestProject)
{
ITestProject testProject = flowContainer as ITestProject;
return(VerifyVariableInSequence(testProject.SetUp, variable, typeDatas) ||
VerifyVariableInSequence(testProject.TearDown, variable, typeDatas));
}
else if (flowContainer is ISequenceGroup)
{
ISequenceGroup sequenceGroup = flowContainer as ISequenceGroup;
if (VerifyVariableInSequence(sequenceGroup.SetUp, variable, typeDatas) ||
VerifyVariableInSequence(sequenceGroup.TearDown, variable, typeDatas))
{
return(true);
}
return(sequenceGroup.Sequences.Any(sequence => VerifyVariableInSequence(sequence, variable, typeDatas)));
}
else if (flowContainer is ISequence)
{
return(VerifyVariableInSequence(flowContainer as ISequence, variable, typeDatas));
}
else if (flowContainer is ISequenceStep)
{
return(VerifyVariableInSequenceStep(flowContainer as ISequenceStep, variable, typeDatas));
}
return(false);
}
public StateManageContext(ModuleGlobalInfo globalInfo, ISequenceFlowContainer sequenceData)
{
this.GlobalInfo = globalInfo;
this.RuntimeHash = globalInfo.RuntimeHash;
this.EventDispatcher = new EventDispatcher();
this.DatabaseProxy = new PersistenceProxy(globalInfo);
this.TestGenerationInfo = new TestGenerationInfo(sequenceData);
this.TestResults = new TestProjectResults(sequenceData);
this.TestInstance = new TestInstanceData()
{
Name = GlobalInfo.ConfigData.GetProperty <string>("TestName"),
Description = GlobalInfo.ConfigData.GetProperty <string>("TestDescription"),
TestProjectName = sequenceData.Name,
TestProjectDescription = sequenceData.Description,
RuntimeHash = globalInfo.RuntimeHash,
StartGenTime = DateTime.MaxValue,
EndGenTime = DateTime.MaxValue,
StartTime = DateTime.MaxValue,
EndTime = DateTime.MinValue,
ElapsedTime = 0
};
this._eventStatusIndex = -1;
this._dataStatusIndex = -1;
this._perfStatusIndex = -1;
}
public ExpressionElement(ParameterType type, string value)
{
this._type = type;
this._value = value;
this._expression = null;
this._parent = null;
}
public static string GetRuntimeVariableString(WatchDataObject watchDataObj, ISequenceFlowContainer sequenceData)
{
const char delim = '.';
string[] watchElem = watchDataObj.WatchData.Split(delim);
string variableName = watchElem[0];
int sequenceIndex = watchDataObj.Sequence;
IVariable variable = null;
if (sequenceData is ITestProject)
{
ITestProject testProject = sequenceData as ITestProject;
if (watchDataObj.Session == CommonConst.TestGroupSession)
{
variable = GetVariableByNameAndSequence(testProject, sequenceIndex, variableName);
}
else
{
variable = GetVariableByNameAndSequence(testProject.SequenceGroups[watchDataObj.Session],
sequenceIndex, variableName);
}
}
else if (sequenceData is ISequenceGroup)
{
ISequenceGroup sequenceGroup = sequenceData as ISequenceGroup;
variable = GetVariableByNameAndSequence(sequenceGroup, sequenceIndex, variableName);
}
if (null == variable)
{
return(null);
}
watchElem[0] = CoreUtils.GetRuntimeVariableName(watchDataObj.Session, variable);
return(string.Join(delim.ToString(), watchElem));
}
public static string WatchDataToString(IDictionary <string, string> watchData, int session,
ISequenceFlowContainer sequence)
{
if (null == watchData || watchData.Count == 0)
{
return(string.Empty);
}
Dictionary <string, string> sequenceWatchData = new Dictionary <string, string>(watchData.Count);
string varNameRegexStr = CoreUtils.GetVariableNameRegex(sequence, session);
Regex varNameRegex = new Regex(varNameRegexStr);
foreach (KeyValuePair <string, string> keyValuePair in watchData)
{
if (varNameRegex.IsMatch(keyValuePair.Key))
{
sequenceWatchData.Add(keyValuePair.Key, keyValuePair.Value);
}
}
JsonSerializerSettings settings = new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Include
};
return(JsonConvert.SerializeObject(sequenceWatchData, settings));
}
// 获取序列可用的所有变量名称模式，会包含上级序列的变量模式
public static string GetVariableNameRegex(ISequenceFlowContainer sequenceData, int session)
{
string regex;
if (sequenceData is ITestProject || sequenceData is ISequenceGroup)
{
const string rootRegexFormat = @"^{0}\{1}[^\{1}]+";
regex = string.Format(rootRegexFormat, session, VarNameDelim);
}
else if (sequenceData is ISequence)
{
ISequence sequence = (ISequence)sequenceData;
const string sequenceVarRegexFormat = @"^{0}\{2}({1}\{2})?[^\{2}]+$";
regex = string.Format(sequenceVarRegexFormat, session, sequence.Index, VarNameDelim);
}
else
{
do
{
sequenceData = sequenceData.Parent;
} while (sequenceData is ISequenceStep);
ISequence sequence = (ISequence)sequenceData;
const string sequenceVarRegexFormat = @"^{0}\{2}({1}\{2})?[^\{2}]+$";
regex = string.Format(sequenceVarRegexFormat, session, sequence.Index, VarNameDelim);
}
return(regex);
}
public void Initialize(ISequenceFlowContainer parent)
{
if (!ModuleUtils.IsValidName(this.Name))
{
this.Name = string.Format(Constants.TestProjectNameFormat, 1);
}
this.SequenceGroupLocations = new SequenceGroupLocationInfoCollection();
}
public void Initialize(ISequenceFlowContainer parent)
{
this._parent = parent;
if (null != parent && Type == ParameterType.Expression)
{
Expression?.Initialize(parent);
}
}
public IVariable AddVariable(ISequenceFlowContainer parent, string variableName, string value, int index)
{
IVariable variable = _sequenceManager.CreateVarialbe();
variable.Name = variableName;
variable.Value = value;
return(AddVariable(parent, variable, index));
}
public ISequenceStep AddSequenceStep(ISequenceFlowContainer parent, string name, string description, int index)
{
ISequenceStep sequenceStep = _sequenceManager.CreateSequenceStep(true);
sequenceStep.Name = name;
sequenceStep.Description = description;
return(AddSequenceStep(parent, sequenceStep, index));
}
//public static ISequenceGroup GetSequenceGroup(int sessionID, ITestProject testProject)
//{
// if (null == testProject)
// {
// return null;
// }
// return testProject.SequenceGroups.ElementAt(sessionID);
//}
internal static void EngineStartThread(ISequenceFlowContainer sequence)
{
Thread engineThread = new Thread(() => ModuleUtils.EngineStart(sequence))
{
IsBackground = true
};
engineThread.Start();
}
private static void ValidateParent(ISequence sequence, ISequenceFlowContainer parent)
{
sequence.Parent = parent;
ValidateParent(sequence.Variables, sequence);
foreach (ISequenceStep step in sequence.Steps)
{
ValidateParent(step, sequence);
}
}
public void Initialize(ISequenceFlowContainer parent)
{
SequenceGroup sequenceGroup = parent as SequenceGroup;
this.Description = string.Empty;
this.Parent = parent;
this.Variables = new VariableCollection();
this.Steps = new SequenceStepCollection();
ModuleUtils.SetElementName(this, sequenceGroup.Sequences);
}
