public void Error_WorkflowDuplicateDuplicateEntryPoints() { // Verify that we detect duplicate entrypoint methods // with explicit names. Assert.Throws <WorkflowTypeException>(() => StubManager.NewWorkflowStub <IDuplicateEntryPointsWorkflow>(client)); }
public void Error_WorkflowNonTaskEntryPoint() { // Workflow entry points methods need to return a Task. Assert.Throws <WorkflowTypeException>(() => StubManager.NewWorkflowStub <IErrorNonTaskEntryPointWorkflow1>(client)); Assert.Throws <WorkflowTypeException>(() => StubManager.NewWorkflowStub <IErrorNonTaskEntryPointWorkflow2>(client)); }
/// <summary> /// Creates a typed workflow stub that can be used to start as well as /// query and signal the workflow via the type-safe interface methods. /// </summary> /// <typeparam name="TWorkflowInterface">Identifies the workflow interface.</typeparam> /// <param name="options">Optionally specifies the workflow options.</param> /// <param name="workflowTypeName"> /// Optionally specifies the workflow type name by overriding the fully /// qualified <typeparamref name="TWorkflowInterface"/> type name or the name /// specified by a <see cref="WorkflowAttribute"/>. /// </param> /// <returns>The dynamically generated stub that implements the workflow methods defined by <typeparamref name="TWorkflowInterface"/>.</returns> /// <remarks> /// <para> /// Unlike activity stubs, a workflow stub may only be used to launch a single /// workflow. You'll need to create a new stub for each workflow you wish to /// invoke and then the first method called on a workflow stub must be /// the one of the methods tagged by <see cref="WorkflowMethodAttribute"/>. /// </para> /// <note> /// <para> /// .NET and Java workflows can implement multiple workflow method using attributes /// and annotations to assign unique names to each. Each workflow method is actually /// registered with Cadence as a distinct workflow type. Workflow methods with a blank /// or <c>null</c> name will simply be registered using the workflow type name. /// </para> /// <para> /// Workflow methods with a name will be registered using a combination of the workflow /// type name and the method name, using <b>"::"</b> as the separator, like: /// </para> /// <code> /// WORKFLOW-TYPENAME::METHOD-NAME /// </code> /// </note> /// </remarks> public TWorkflowInterface NewWorkflowStub <TWorkflowInterface>(WorkflowOptions options = null, string workflowTypeName = null) where TWorkflowInterface : class { CadenceHelper.ValidateWorkflowInterface(typeof(TWorkflowInterface)); EnsureNotDisposed(); return(StubManager.NewWorkflowStub <TWorkflowInterface>(this, options: options, workflowTypeName: workflowTypeName)); }
public void Generate_WorkflowResultWithOptions() { var stub = StubManager.NewWorkflowStub <IWorkflowEntryResultWithArgs>(client, options: new WorkflowOptions() { TaskList = "my-tasklist", Domain = "my-domain" }); Assert.NotNull(stub); }
public void Generate_WorkflowResultWithOptions() { var stub = StubManager.NewWorkflowStub <IWorkflowEntryResultWithArgs>(client, options: new StartWorkflowOptions() { TaskQueue = "my-taskqueue", Namespace = "my-namespace" }); Assert.NotNull(stub); }
/// <summary> /// Creates a typed workflow stub connected to a known workflow execution /// using IDs. This can be used to signal and query the workflow via the /// type-safe interface methods. /// </summary> /// <typeparam name="TWorkflowInterface">Identifies the workflow interface.</typeparam> /// <param name="workflowId">Specifies the workflow ID.</param> /// <param name="runId">Optionally specifies the workflow's run ID.</param> /// <param name="domain">Optionally specifies a domain that </param> /// <returns>The dynamically generated stub that implements the workflow methods defined by <typeparamref name="TWorkflowInterface"/>.</returns> /// <remarks> /// Unlike activity stubs, a workflow stub may only be used to launch a single /// workflow. You'll need to create a new stub for each workflow you wish to /// invoke and then the first method called on a workflow stub must be /// the one of the methods tagged by <see cref="WorkflowMethodAttribute"/>. /// </remarks> public TWorkflowInterface NewWorkflowStub <TWorkflowInterface>(string workflowId, string runId = null, string domain = null) where TWorkflowInterface : class { Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(workflowId), nameof(workflowId)); CadenceHelper.ValidateWorkflowInterface(typeof(TWorkflowInterface)); EnsureNotDisposed(); return(StubManager.NewWorkflowStub <TWorkflowInterface>(this, workflowId, runId, domain)); }
/// <summary> /// Creates a typed workflow stub connected to a known workflow execution /// using a <see cref="WorkflowExecution"/>. This can be used to signal and /// query the workflow via the type-safe interface methods. /// </summary> /// <typeparam name="TWorkflowInterface">Identifies the workflow interface.</typeparam> /// <param name="execution">Specifies the <see cref="WorkflowExecution"/>.</param> /// <returns>The dynamically generated stub that implements the workflow methods defined by <typeparamref name="TWorkflowInterface"/>.</returns> /// <remarks> /// Unlike activity stubs, a workflow stub may only be used to launch a single /// workflow. You'll need to create a new stub for each workflow you wish to /// invoke and then the first method called on a workflow stub must be /// the one of the methods tagged by <see cref="WorkflowMethodAttribute"/>. /// </remarks> public TWorkflowInterface NewWorkflowStub <TWorkflowInterface>(WorkflowExecution execution) where TWorkflowInterface : class { Covenant.Requires <ArgumentNullException>(execution != null, nameof(execution)); Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(execution.WorkflowId), nameof(execution.WorkflowId)); Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(execution.RunId), nameof(execution.RunId)); CadenceHelper.ValidateWorkflowInterface(typeof(TWorkflowInterface)); EnsureNotDisposed(); return(StubManager.NewWorkflowStub <TWorkflowInterface>(this, execution.WorkflowId, execution.RunId)); }
public void Error_WorkflowNoEntryPoint() { // Workflows need to have at least one entry point. Assert.Throws <WorkflowTypeException>(() => StubManager.NewWorkflowStub <IErrorNoEntryPointWorkflow>(client)); }
public void Error_WorkflowGenericsNotAllowed() { // We don't support workflow interfaces with generic parameters. Assert.Throws <WorkflowTypeException>(() => StubManager.NewWorkflowStub <IErrorGenericWorkflow <int> >(client)); }
public void Error_WorkflowDuplicateQueries() { // Verify that we detect duplicate query names. Assert.Throws <WorkflowTypeException>(() => StubManager.NewWorkflowStub <IErrorDuplicateQueriesWorkflow>(client)); }
public void Error_WorkflowNonTaskQuery() { // Workflow query methods need to return a Task. Assert.Throws <WorkflowTypeException>(() => StubManager.NewWorkflowStub <IErrorNonTaskQueryWorkflow>(client)); }
public void Generate_WorkflowResultWithArgs() { var stub = StubManager.NewWorkflowStub <IWorkflowEntryResultWithArgs>(client); Assert.NotNull(stub); }
public void Generate_WorkflowMultiMethods() { var stub = StubManager.NewWorkflowStub <IWorkflowMultiMethods>(client); Assert.NotNull(stub); }
public void Generate_WorkflowQueryVoidWithArgs() { var stub = StubManager.NewWorkflowStub <IWorkflowQueryVoidWithArgs>(client); Assert.NotNull(stub); }
public void Generate_WorkflowSignalNoArgs() { var stub = StubManager.NewWorkflowStub <IWorkflowSignalNoArgs>(client); Assert.NotNull(stub); }
public void Error_WorkflowNullClient() { // A non-NULL client is required. Assert.Throws <ArgumentNullException>(() => StubManager.NewWorkflowStub <IErrorNoEntryPointWorkflow>(null)); }
public void Error_WorkflowNotInterface() { // Only workflow interfaces are allowed. Assert.Throws <WorkflowTypeException>(() => StubManager.NewWorkflowStub <IErrorNotInterfaceWorkflow>(client)); }
public void Error_WorkflowNotPublic() { // Workflow interfaces must be public. Assert.Throws <WorkflowTypeException>(() => StubManager.NewWorkflowStub <IErrorNotPublicWorkflow>(client)); }