public MethodExecutor(Activity invokingActivity, Type targetType, InArgument targetObject, Collection<Argument> parameters, RuntimeArgument returnObject) { Fx.Assert(invokingActivity != null, "Must provide invokingActivity"); Fx.Assert(targetType != null || (targetObject != null), "Must provide targetType or targetObject"); Fx.Assert(parameters != null, "Must provide parameters"); // returnObject is optional this.invokingActivity = invokingActivity; this.targetType = targetType; this.targetObject = targetObject; this.parameters = parameters; this.returnObject = returnObject; }
public CompensationParticipant(Variable<long> compensationId) : base() { this.compensationId = compensationId; this.currentCompensationToken = new Variable<CompensationToken>(); DefaultCompensation = new DefaultCompensation() { Target = new InArgument<CompensationToken>(this.currentCompensationToken), }; DefaultConfirmation = new DefaultConfirmation() { Target = new InArgument<CompensationToken>(this.currentCompensationToken), }; }
public ExpressionEvaluatorWithBody() { _expressionResult = new InArgument <T>(); }
public void DsfWebGetActivity_Execute_WithValidTextResponse_ShouldSetVariables() { //------------Setup for test-------------------------- const string response = "{\"Location\": \"Paris\",\"Time\": \"May 29, 2013 - 09:00 AM EDT / 2013.05.29 1300 UTC\"," + "\"Wind\": \"from the NW (320 degrees) at 10 MPH (9 KT) (direction variable):0\"," + "\"Visibility\": \"greater than 7 mile(s):0\"," + "\"Temperature\": \"59 F (15 C)\"," + "\"DewPoint\": \"41 F (5 C)\"," + "\"RelativeHumidity\": \"51%\"," + "\"Pressure\": \"29.65 in. Hg (1004 hPa)\"," + "\"Status\": \"Success\"" + "}"; var environment = new ExecutionEnvironment(); environment.Assign("[[City]]", "PMB", 0); environment.Assign("[[CountryName]]", "South Africa", 0); var dsfWebGetActivity = new TestDsfWebGetActivity(); dsfWebGetActivity.ResourceCatalog = new Mock <IResourceCatalog>().Object; var serviceInputs = new List <IServiceInput> { new ServiceInput("CityName", "[[City]]"), new ServiceInput("Country", "[[CountryName]]") }; var serviceOutputs = new List <IServiceOutputMapping> { new ServiceOutputMapping("Response", "[[Response]]", "") }; dsfWebGetActivity.Inputs = serviceInputs; dsfWebGetActivity.Outputs = serviceOutputs; var serviceXml = XmlResource.Fetch("WebService"); var service = new WebService(serviceXml) { RequestResponse = response }; dsfWebGetActivity.OutputDescription = service.GetOutputDescription(); dsfWebGetActivity.ResponseFromWeb = response; var dataObjectMock = new Mock <IDSFDataObject>(); dataObjectMock.Setup(o => o.Environment).Returns(environment); dataObjectMock.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object); dsfWebGetActivity.ResourceID = InArgument <Guid> .FromValue(Guid.Empty); dsfWebGetActivity.QueryString = ""; dsfWebGetActivity.SourceId = Guid.Empty; dsfWebGetActivity.Headers = new List <INameValue>(); dsfWebGetActivity.OutputDescription = new OutputDescription(); dsfWebGetActivity.OutputDescription.DataSourceShapes.Add(new DataSourceShape() { Paths = new List <IPath>() { new StringPath() { ActualPath = "[[Response]]", OutputExpression = "[[Response]]" } } }); //------------Execute Test--------------------------- dsfWebGetActivity.Execute(dataObjectMock.Object, 0); //------------Assert Results------------------------- Assert.IsNotNull(dsfWebGetActivity.OutputDescription); Assert.AreEqual(response, ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[Response]]", 0))); }
void SetHandle(object value) { InArgument handle = (InArgument)(value is ModelItem ? ((ModelItem)value).GetCurrentValue() : value); this.ReflectedObject.Properties[HandleProperty].SetValue(handle); }
public AsyncWaitCallbackMethodExecutor(AsyncWaitCallbackMethodExecutor copy, Type targetType, InArgument targetObject, Collection <Argument> parameters, RuntimeArgument returnObject) : base(copy.invokingActivity, targetType, targetObject, parameters, returnObject) { this.asyncMethod = copy.asyncMethod; this.asyncFunc = copy.asyncFunc; }
public AsyncPatternMethodExecutor(CodeActivityMetadata metadata, MethodInfo beginMethod, MethodInfo endMethod, Activity invokingActivity, Type targetType, InArgument targetObject, Collection <Argument> parameters, RuntimeArgument returnObject, MruCache <MethodInfo, Func <object, object[], object> > funcCache, ReaderWriterLockSlim locker) : base(invokingActivity, targetType, targetObject, parameters, returnObject) { Fx.Assert(beginMethod != null && endMethod != null, "Must provide beginMethod and endMethod"); this.beginMethod = beginMethod; this.endMethod = endMethod; this.beginFunc = MethodCallExpressionHelper.GetFunc(metadata, beginMethod, funcCache, locker); this.endFunc = MethodCallExpressionHelper.GetFunc(metadata, endMethod, funcCache, locker); }
/// <summary>Assigns a value to the specified <see cref="T:System.Activities.InArgument`1" />.</summary> /// <param name="context"></param> /// <param name="argument">The argument to receive the new value.</param> /// <param name="value">The new value of the argument.</param> /// <typeparam name="T">The type of the argument.</typeparam> public static void SetValue <T>(this IExtendedWorkflowContext context, InArgument <T> argument, T value) { context.CodeActivityContext.SetValue(argument, value); }
public AsyncPatternMethodExecutor(CodeActivityMetadata metadata, MethodInfo beginMethod, MethodInfo endMethod, Activity invokingActivity, Type targetType, InArgument targetObject, Collection<Argument> parameters, RuntimeArgument returnObject, MruCache<MethodInfo, Func<object, object[], object>> funcCache, ReaderWriterLockSlim locker) : base(invokingActivity, targetType, targetObject, parameters, returnObject) { Fx.Assert(beginMethod != null && endMethod != null, "Must provide beginMethod and endMethod"); this.beginMethod = beginMethod; this.endMethod = endMethod; this.beginFunc = MethodCallExpressionHelper.GetFunc(metadata, beginMethod, funcCache, locker); this.endFunc = MethodCallExpressionHelper.GetFunc(metadata, endMethod, funcCache, locker); }
public void DsfWebDeleteActivity_Execute_WithValidXmlEscaped_ShouldSetVariables() { //------------Setup for test-------------------------- const string response = "<CurrentWeather>" + "<Location><Paris></Location>" + "<Time>May 29, 2013 - 09:00 AM EDT / 2013.05.29 1300 UTC</Time>" + "<Wind>from the NW (320 degrees) at 10 MPH (9 KT) (direction variable):0</Wind>" + "<Visibility><greater than 7 mile(s):0></Visibility>" + "<Temperature> 59 F (15 C)</Temperature>" + "<DewPoint> 41 F (5 C)</DewPoint>" + "<RelativeHumidity> 51%</RelativeHumidity>" + "<Pressure> 29.65 in. Hg (1004 hPa)</Pressure>" + "<Status>Success</Status>" + "</CurrentWeather>"; var environment = new ExecutionEnvironment(); environment.Assign("[[City]]", "PMB", 0); environment.Assign("[[CountryName]]", "South Africa", 0); var dsfWebDeleteActivity = CreateTestDeleteActivity(); var serviceInputs = new List <IServiceInput> { new ServiceInput("CityName", "[[City]]"), new ServiceInput("Country", "[[CountryName]]") }; var serviceOutputs = new List <IServiceOutputMapping> { new ServiceOutputMapping("Location", "[[weather().Location]]", "weather") , new ServiceOutputMapping("Time", "[[weather().Time]]", "weather") , new ServiceOutputMapping("Wind", "[[weather().Wind]]", "weather") , new ServiceOutputMapping("Visibility", "[[Visibility]]", "") }; dsfWebDeleteActivity.Inputs = serviceInputs; dsfWebDeleteActivity.Outputs = serviceOutputs; var serviceXml = XmlResource.Fetch("WebService"); var service = new WebService(serviceXml) { RequestResponse = response }; dsfWebDeleteActivity.OutputDescription = service.GetOutputDescription(); dsfWebDeleteActivity.ResponseFromWeb = response; var dataObjectMock = new Mock <IDSFDataObject>(); dataObjectMock.Setup(o => o.Environment).Returns(environment); dataObjectMock.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object); dsfWebDeleteActivity.ResourceID = InArgument <Guid> .FromValue(Guid.Empty); dsfWebDeleteActivity.QueryString = ""; //dsfWebPostActivity.PostData = ""; dsfWebDeleteActivity.SourceId = Guid.Empty; dsfWebDeleteActivity.Headers = new List <INameValue>(); //------------Execute Test--------------------------- dsfWebDeleteActivity.Execute(dataObjectMock.Object, 0); //------------Assert Results------------------------- Assert.IsNotNull(dsfWebDeleteActivity.OutputDescription); var visibility = ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[Visibility]]", 0)); Assert.AreEqual("<greater than 7 mile(s):0>", visibility); var location = ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[weather().Location]]", 0)); Assert.AreEqual("<Paris>", location); var time = ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[weather().Time]]", 0)); Assert.AreEqual("May 29, 2013 - 09:00 AM EDT / 2013.05.29 1300 UTC", time); var wind = ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[weather().Wind]]", 0)); Assert.AreEqual("from the NW (320 degrees) at 10 MPH (9 KT) (direction variable):0", wind); }
/// <summary> /// Returns an <see cref="Activity"/> that invokes the action with the specified arguments. /// </summary> /// <typeparam name="TArg"></typeparam> /// <param name="action"></param> /// <param name="arg"></param> /// <param name="displayName"></param> /// <returns></returns> public static InvokeAction <TArg> InvokeDelegate <TArg>(ActivityAction <TArg> action, InArgument <TArg> arg, string displayName = null) { if (action == null) { throw new ArgumentNullException(nameof(action)); } return(new InvokeAction <TArg>() { DisplayName = displayName, Action = action, Argument = arg, }); }
public static T? GetArgumentLiteralValue<T>(this InArgument<T> inArgument) where T : struct { return (inArgument?.Expression as Literal<T>)?.Value; }
public static string GetArgumentLiteralValue(this InArgument<string> inArgument) { return (inArgument?.Expression as Literal<string>)?.Value; }
/// <summary>Gets the value of the specified <see cref="T:System.Activities.InArgument`1" />.</summary> /// <param name="context"></param> /// <param name="argument">The argument to inspect.</param> /// <typeparam name="T">The type of the argument.</typeparam> /// <returns>The value of the argument.</returns> public static T GetValue <T>(this IExtendedWorkflowContext context, InArgument <T> argument) { return(context.CodeActivityContext.GetValue(argument)); }
public static T Get <T>(this InArgument <T> arg, IExtendedWorkflowContext context) { return(arg.Get(context.CodeActivityContext)); }
/// <summary> /// 初始化 /// </summary> /// <param name="flowNodeIndex">对应的索引</param> /// <param name="actioners"></param> public Human(int flowNodeIndex, Activity<string[]> actioners) : base(flowNodeIndex) { this.Actioners = new InArgument<string[]>(actioners); }
public Increment() { Value = new VisualBasicValue <int>("1"); }
public AsyncWaitCallbackMethodExecutor(CodeActivityMetadata metadata, MethodInfo asyncMethod, Activity invokingActivity, Type targetType, InArgument targetObject, Collection<Argument> parameters, RuntimeArgument returnObject, MruCache<MethodInfo, Func<object, object[], object>> funcCache, ReaderWriterLockSlim locker) : base(invokingActivity, targetType, targetObject, parameters, returnObject) { Fx.Assert(asyncMethod != null, "Must provide asyncMethod"); this.asyncMethod = asyncMethod; this.asyncFunc = MethodCallExpressionHelper.GetFunc(metadata, asyncMethod, funcCache, locker); }
public GetExecutionListActivity() { DisplayName = "企业/自然人失信人信息查询"; Skip = new InArgument <int>(0); }
protected GetMailActivity() { Top = new InArgument <int>(30); }
public static T GetValueOrDefault <T>(this AsyncCodeActivityContext context, InArgument <T> arg, T defaultValue = default(T)) { return(arg.Expression != null ? arg.Get(context) // User provided a value : defaultValue); // Field was left blank }
public AsyncPatternMethodExecutor(AsyncPatternMethodExecutor copy, Type targetType, InArgument targetObject, Collection <Argument> parameters, RuntimeArgument returnObject) : base(copy.invokingActivity, targetType, targetObject, parameters, returnObject) { this.beginMethod = copy.beginMethod; this.endMethod = copy.endMethod; this.beginFunc = copy.beginFunc; this.endFunc = copy.endFunc; }
/// <summary> /// Computes the bitwise logic AND of two values. /// </summary> /// <typeparam name="TLeft"></typeparam> /// <typeparam name="TRight" /// <typeparam name="TResult"></typeparam> /// <param name="left"></param> /// <param name="right"></param> /// <param name="displayName"></param> /// <returns></returns> public static And <TLeft, TRight, TResult> And <TLeft, TRight, TResult>(InArgument <TLeft> left, InArgument <TRight> right, string displayName = null) { if (left == null) { throw new ArgumentNullException(nameof(left)); } if (right == null) { throw new ArgumentNullException(nameof(right)); } return(new And <TLeft, TRight, TResult>() { DisplayName = displayName, Left = left, Right = right, }); }
private static Activity HandleBinaryExpression <TLeft, TRight, TResult>(BinaryOperator op, TestExpression left, TestExpression right) { Activity we = null; InArgument <TLeft> leftArgument = (InArgument <TLeft>)TestExpression.GetInArgumentFromExpectedNode <TLeft>(left); leftArgument.EvaluationOrder = 0; InArgument <TRight> rightArgument = (InArgument <TRight>)TestExpression.GetInArgumentFromExpectedNode <TRight>(right); rightArgument.EvaluationOrder = 1; switch (op) { case BinaryOperator.Add: we = new Add <TLeft, TRight, TResult>() { Checked = false, Left = leftArgument, Right = rightArgument }; break; case BinaryOperator.And: we = new And <TLeft, TRight, TResult>() { Left = leftArgument, Right = rightArgument }; break; case BinaryOperator.AndAlso: we = new AndAlso() { Left = TestExpression.GetWorkflowElementFromExpectedNode <bool>(left), Right = TestExpression.GetWorkflowElementFromExpectedNode <bool>(right) }; break; case BinaryOperator.CheckedAdd: we = new Add <TLeft, TRight, TResult>() { Checked = true, Left = leftArgument, Right = rightArgument }; break; case BinaryOperator.CheckedMultiply: we = new Multiply <TLeft, TRight, TResult>() { Checked = true, Left = leftArgument, Right = rightArgument }; break; case BinaryOperator.CheckedSubtract: we = new Subtract <TLeft, TRight, TResult>() { Checked = true, Left = leftArgument, Right = rightArgument }; break; case BinaryOperator.Divide: we = new Divide <TLeft, TRight, TResult>() { Left = leftArgument, Right = rightArgument }; break; case BinaryOperator.Equal: we = new Equal <TLeft, TRight, TResult>() { Left = leftArgument, Right = rightArgument }; break; case BinaryOperator.GreaterThan: we = new GreaterThan <TLeft, TRight, TResult>() { Left = leftArgument, Right = rightArgument }; break; case BinaryOperator.GreaterThanOrEqual: we = new GreaterThanOrEqual <TLeft, TRight, TResult>() { Left = leftArgument, Right = rightArgument }; break; case BinaryOperator.LessThan: we = new LessThan <TLeft, TRight, TResult>() { Left = leftArgument, Right = rightArgument }; break; case BinaryOperator.LessThanOrEqual: we = new LessThanOrEqual <TLeft, TRight, TResult>() { Left = leftArgument, Right = rightArgument }; break; case BinaryOperator.Or: we = new Or <TLeft, TRight, TResult>() { Left = leftArgument, Right = rightArgument }; break; case BinaryOperator.Multiply: we = new Multiply <TLeft, TRight, TResult>() { Checked = false, Left = leftArgument, Right = rightArgument }; break; case BinaryOperator.NotEqual: we = new NotEqual <TLeft, TRight, TResult>() { Left = leftArgument, Right = rightArgument }; break; case BinaryOperator.OrElse: we = new OrElse() { Left = TestExpression.GetWorkflowElementFromExpectedNode <bool>(left), Right = TestExpression.GetWorkflowElementFromExpectedNode <bool>(right) }; break; case BinaryOperator.Subtract: we = new Subtract <TLeft, TRight, TResult>() { Checked = false, Left = leftArgument, Right = rightArgument }; break; default: throw new NotSupportedException(string.Format("Operator: {0} is unsupported", op.ToString())); } return(we); }
public If(InArgument <bool> condition) : this() { this.Condition = condition ?? throw FxTrace.Exception.ArgumentNull(nameof(condition)); }
public static WebRequestDataDto CreateRequestDataDto(WebRequestMethod requestMethod, InArgument <string> type, string displayName) => new WebRequestDataDto() { WebRequestMethod = requestMethod, DisplayName = displayName, Type = type };
public static TArgument TakeValue <TArgument>(this InArgument <TArgument> param) { return(param.Value); }
public CallMessageStateless() { VersionDate = new InArgument <string>("2020-04-01"); }
public void WebPostActivity_Execute_WithInValidWebResponse_ShouldError() { //------------Setup for test-------------------------- const string response = "{\"Location\": \"Paris\",\"Time\": \"May 29, 2013 - 09:00 AM EDT / 2013.05.29 1300 UTC\"," + "\"Wind\": \"from the NW (320 degrees) at 10 MPH (9 KT) (direction variable):0\"," + "\"Visibility\": \"greater than 7 mile(s):0\"," + "\"Temperature\": \"59 F (15 C)\"," + "\"DewPoint\": \"41 F (5 C)\"," + "\"RelativeHumidity\": \"51%\"," + "\"Pressure\": \"29.65 in. Hg (1004 hPa)\"," + "\"Status\": \"Success\"" + "}"; const string invalidResponse = "{\"Location\" \"Paris\",\"Time\": \"May 29, 2013 - 09:00 AM EDT / 2013.05.29 1300 UTC\"," + "\"Wind\": \"from the NW (320 degrees) at 10 MPH (9 KT) (direction variable):0\"," + "\"Visibility\": \"greater than 7 mile(s):0\"," + "\"Temperature\": \"59 F (15 C)\"," + "\"DewPoint\": \"41 F (5 C)\"," + "\"RelativeHumidity\": \"51%\"," + "\"Pressure\": \"29.65 in. Hg (1004 hPa)\"," + "\"Status\": \"Success\"" + ""; var environment = new ExecutionEnvironment(); environment.Assign("[[City]]", "PMB", 0); environment.Assign("[[CountryName]]", "South Africa", 0); var webPostActivity = new TestWebPostActivity { ResourceCatalog = new Mock <IResourceCatalog>().Object, }; var serviceInputs = new List <IServiceInput> { new ServiceInput("CityName", "[[City]]"), new ServiceInput("Country", "[[CountryName]]") }; var serviceOutputs = new List <IServiceOutputMapping> { new ServiceOutputMapping("Location", "[[weather().Location]]", "weather"), new ServiceOutputMapping("Time", "[[weather().Time]]", "weather"), new ServiceOutputMapping("Wind", "[[weather().Wind]]", "weather"), new ServiceOutputMapping("Visibility", "[[Visibility]]", "") }; webPostActivity.Inputs = serviceInputs; webPostActivity.Outputs = serviceOutputs; var serviceXml = XmlResource.Fetch("WebService"); var service = new WebService(serviceXml) { RequestResponse = response }; webPostActivity.OutputDescription = service.GetOutputDescription(); webPostActivity.ResponseFromWeb = invalidResponse; var dataObjectMock = new Mock <IDSFDataObject>(); dataObjectMock.Setup(o => o.Environment).Returns(environment); dataObjectMock.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object); webPostActivity.ResourceID = InArgument <Guid> .FromValue(Guid.Empty); webPostActivity.QueryString = ""; webPostActivity.PostData = ""; webPostActivity.SourceId = Guid.Empty; webPostActivity.Headers = new List <INameValue>(); //------------Execute Test--------------------------- webPostActivity.Execute(dataObjectMock.Object, 0); //------------Assert Results------------------------- Assert.IsNotNull(webPostActivity.OutputDescription); Assert.AreEqual(1, environment.Errors.Count); StringAssert.Contains(environment.Errors.ToList()[0], "Invalid character after parsing property name"); }
public void WebPostActivity_GetDebugInputs_GivenMockEnvironment_ShouldAddDebugInputItems() { //---------------Set up test pack------------------- const string response = "{\"Location\": \"Paris\",\"Time\": \"May 29, 2013 - 09:00 AM EDT / 2013.05.29 1300 UTC\"," + "\"Wind\": \"from the NW (320 degrees) at 10 MPH (9 KT) (direction variable):0\"," + "\"Visibility\": \"greater than 7 mile(s):0\"," + "\"Temperature\": \"59 F (15 C)\"," + "\"DewPoint\": \"41 F (5 C)\"," + "\"RelativeHumidity\": \"51%\"," + "\"Pressure\": \"29.65 in. Hg (1004 hPa)\"," + "\"Status\": \"Success\"" + "}"; var environment = new ExecutionEnvironment(); environment.Assign("[[City]]", "PMB", 0); environment.Assign("[[CountryName]]", "South Africa", 0); environment.Assign("[[Post]]", "Some data", 0); var webPostActivity = new TestWebPostActivity { Headers = new List <INameValue> { new NameValue("Header 1", "[[City]]") }, QueryString = "http://www.testing.com/[[CountryName]]", PostData = "This is post:[[Post]]" }; var serviceOutputs = new List <IServiceOutputMapping> { new ServiceOutputMapping("Location", "[[weather().Location]]", "weather"), new ServiceOutputMapping("Time", "[[weather().Time]]", "weather"), new ServiceOutputMapping("Wind", "[[weather().Wind]]", "weather"), new ServiceOutputMapping("Visibility", "[[Visibility]]", "") }; webPostActivity.Outputs = serviceOutputs; var serviceXml = XmlResource.Fetch("WebService"); var service = new WebService(serviceXml) { RequestResponse = response }; webPostActivity.OutputDescription = service.GetOutputDescription(); webPostActivity.ResponseFromWeb = response; var dataObjectMock = new Mock <IDSFDataObject>(); dataObjectMock.Setup(o => o.Environment).Returns(environment); dataObjectMock.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object); webPostActivity.ResourceID = InArgument <Guid> .FromValue(Guid.Empty); var cat = new Mock <IResourceCatalog>(); var src = new WebSource { Address = "www.example.com" }; cat.Setup(a => a.GetResource <WebSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(src); webPostActivity.ResourceCatalog = cat.Object; //---------------Assert Precondition---------------- Assert.IsNotNull(environment); Assert.IsNotNull(webPostActivity); //---------------Execute Test ---------------------- var debugInputs = webPostActivity.GetDebugInputs(environment, 0); //---------------Test Result ----------------------- Assert.IsNotNull(debugInputs); Assert.AreEqual(4, debugInputs.Count); }
public void WebPostActivity_ExecutionImpl_ResponseManager_PushResponseIntoEnvironment_GivenJsonResponse_MappedToRecodSet_ShouldSucess() { //-----------------------Arrange------------------------- const string json = "{\"Messanger\":\"jSon response from the request\"}"; var response = Convert.ToBase64String(json.ToBytesArray()); const string mappingFrom = "mapFrom"; const string recordSet = "recset"; const string mapTo = "mapTo"; const string variableNameMappingTo = "[[recset().mapTo]]"; var environment = new ExecutionEnvironment(); var mockEsbChannel = new Mock <IEsbChannel>(); var mockDSFDataObject = new Mock <IDSFDataObject>(); var mockExecutionEnvironment = new Mock <IExecutionEnvironment>(); var errorResultTO = new ErrorResultTO(); using (var service = new WebService(XmlResource.Fetch("WebService")) { RequestResponse = response }) { mockDSFDataObject.Setup(o => o.Environment).Returns(environment); mockDSFDataObject.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object); var dsfWebGetActivity = new TestWebPostActivity { OutputDescription = service.GetOutputDescription(), ResourceID = InArgument <Guid> .FromValue(Guid.Empty), QueryString = "test Query", Headers = new List <INameValue>(), ResponseFromWeb = response, IsObject = false, Outputs = new List <IServiceOutputMapping> { { new ServiceOutputMapping { MappedFrom = mappingFrom, MappedTo = mapTo, RecordSetName = recordSet } } } }; //-----------------------Act----------------------------- dsfWebGetActivity.TestExecutionImpl(mockEsbChannel.Object, mockDSFDataObject.Object, "Test Inputs", "Test Outputs", out errorResultTO, 0); //-----------------------Assert-------------------------- Assert.IsFalse(errorResultTO.HasErrors()); //assert first DataSourceShapes var resourceManager = dsfWebGetActivity.ResponseManager; var outputDescription = resourceManager.OutputDescription; var dataShapes = outputDescription.DataSourceShapes; var paths = dataShapes.First().Paths; Assert.IsNotNull(outputDescription); Assert.AreEqual("Messanger", paths.First().ActualPath); Assert.AreEqual("Messanger", paths.First().DisplayPath); Assert.AreEqual(variableNameMappingTo, paths.First().OutputExpression); Assert.AreEqual("jSon response from the request", paths.First().SampleData); //assert execution environment var envirVariable = environment.Eval(recordSet, 0); var ress = envirVariable as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult; Assert.IsNotNull(envirVariable); Assert.IsFalse(ress.Item.IsNothing, "Item should contain the recset mapped to the messanger key"); } }
/// <summary> /// 初始化 /// </summary> /// <param name="actioners"></param> public Human(Activity<string[]> actioners) : base() { this.Actioners = new InArgument<string[]>(actioners); }
public XmlParseDynamicValue(InArgument <string> source, OutArgument <DynamicValue> result) { this.Source = source; base.Result = result; }
public SyncMethodExecutor(SyncMethodExecutor copy, Type targetType, InArgument targetObject, Collection<Argument> parameters, RuntimeArgument returnObject) : base(copy.invokingActivity, targetType, targetObject, parameters, returnObject) { this.syncMethod = copy.syncMethod; this.func = copy.func; }
public AsyncPatternMethodExecutor(MethodInfo beginMethod, MethodInfo endMethod, Activity invokingActivity, Type targetType, InArgument targetObject, Collection <Argument> parameters, RuntimeArgument returnObject) : base(invokingActivity, targetType, targetObject, parameters, returnObject) { this.beginMethod = beginMethod; this.endMethod = endMethod; }
public AsyncPatternMethodExecutor(AsyncPatternMethodExecutor copy, Type targetType, InArgument targetObject, Collection<Argument> parameters, RuntimeArgument returnObject) : base(copy.invokingActivity, targetType, targetObject, parameters, returnObject) { this.beginMethod = copy.beginMethod; this.endMethod = copy.endMethod; this.beginFunc = copy.beginFunc; this.endFunc = copy.endFunc; }
public SyncMethodExecutor(MethodInfo syncMethod, Activity invokingActivity, Type targetType, InArgument targetObject, Collection <Argument> parameters, RuntimeArgument returnObject) : base(invokingActivity, targetType, targetObject, parameters, returnObject) { this.syncMethod = syncMethod; }
public AsyncWaitCallbackMethodExecutor(AsyncWaitCallbackMethodExecutor copy, Type targetType, InArgument targetObject, Collection<Argument> parameters, RuntimeArgument returnObject) : base(copy.invokingActivity, targetType, targetObject, parameters, returnObject) { this.asyncMethod = copy.asyncMethod; this.asyncFunc = copy.asyncFunc; }
protected ModelItem ArgumentToModelItem(InArgument arg, EditingContext editingContext) { return(arg != null?ModelFactory.CreateItem(editingContext, arg) : null); }