Start simpler test framework

Author: vuplea

src/Test/Directory.Build.props

@@ -1,6 +1,7 @@
 <Project>
   <PropertyGroup>
     <TargetFrameworks>net6.0;net6.0-windows</TargetFrameworks>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <Import Project="$(SolutionDir)Directory.Build.props" />
   <ItemGroup>

src/Test/WorkflowApplicationTestExtensions/NoPersistAsyncActivity.cs

@@ -0,0 +1,42 @@
+using System.Activities;
+using System.Activities.Hosting;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace WorkflowApplicationTestExtensions
+{
+    /// <summary>
+    /// Activity that induces Idle for a few milliseconds but not PersistableIdle.
+    /// This is similar to UiPath asynchronous in-process activities.
+    /// </summary>
+    public class NoPersistAsyncActivity : NativeActivity
+    {
+        private readonly Variable<NoPersistHandle> _noPersist = new();
+
+        protected override bool CanInduceIdle => true;
+
+        protected override void CacheMetadata(NativeActivityMetadata metadata)
+        {
+            metadata.AddImplementationVariable(_noPersist);
+            metadata.AddDefaultExtensionProvider(() => new BookmarkResumer());
+            base.CacheMetadata(metadata);
+        }
+
+        protected override void Execute(NativeActivityContext context)
+        {
+            _noPersist.Get(context).Enter(context);
+            context.GetExtension<BookmarkResumer>().ResumeSoon(context.CreateBookmark());
+        }
+    }
+
+    public class BookmarkResumer : IWorkflowInstanceExtension
+    {
+        private WorkflowInstanceProxy _instance;
+        public IEnumerable<object> GetAdditionalExtensions() => [];
+        public void SetInstance(WorkflowInstanceProxy instance) => _instance = instance;
+        public void ResumeSoon(Bookmark bookmark) => Task.Delay(10).ContinueWith(_ =>
+        {
+            _instance.BeginResumeBookmark(bookmark, null, null, null);
+        });
+    }
+}

src/Test/WorkflowApplicationTestExtensions/SuspendingWrapper.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Activities;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.ExceptionServices;
+
+namespace WorkflowApplicationTestExtensions
+{
+    /// <summary>
+    /// Wrapper over one/multiple sequential activities.
+    /// Between scheduling the activity/activities, it induces persistence Idle
+    /// by creating bookmarks.
+    /// The idea is to induce unload/load as much as possible to test persistence
+    /// serialization/deserialization.
+    /// </summary>
+    public class SuspendingWrapper : NativeActivity
+    {
+        private readonly Variable<int> _nextIndexToExecute = new();
+        public List<Activity> Activities { get; }
+        protected override bool CanInduceIdle => true;
+
+        public SuspendingWrapper(IEnumerable<Activity> activities)
+        {
+            Activities = activities.ToList();
+        }
+
+        public SuspendingWrapper(Activity activity) : this([activity])
+        {
+        }
+
+        public SuspendingWrapper() : this([])
+        {
+        }
+
+        protected override void CacheMetadata(NativeActivityMetadata metadata)
+        {
+            metadata.AddImplementationVariable(_nextIndexToExecute);
+            base.CacheMetadata(metadata);
+        }
+
+        protected override void Execute(NativeActivityContext context) => ExecuteNext(context);
+
+        private void OnChildCompleted(NativeActivityContext context, ActivityInstance completedInstance) =>
+            ExecuteNext(context);
+
+        private void OnChildFaulted(NativeActivityFaultContext faultContext, Exception propagatedException, ActivityInstance propagatedFrom) =>
+            ExceptionDispatchInfo.Capture(propagatedException).Throw();
+
+        private void ExecuteNext(NativeActivityContext context) =>
+            context.CreateBookmark(
+                $"{WorkflowApplicationTestExtensions.AutoResumedBookmarkNamePrefix}{Guid.NewGuid()}",
+                AfterResume);
+
+        private void AfterResume(NativeActivityContext context, Bookmark bookmark, object value)
+        {
+            var nextIndex = _nextIndexToExecute.Get(context);
+            if (nextIndex == Activities.Count)
+            {
+                return;
+            }
+            _nextIndexToExecute.Set(context, nextIndex + 1);
+            context.ScheduleActivity(Activities[nextIndex], OnChildCompleted, OnChildFaulted);
+        }
+    }
+}

src/Test/WorkflowApplicationTestExtensions/WorkflowApplicationTestExtensions.cs

@@ -0,0 +1,96 @@
+using JsonFileInstanceStore;
+using System;
+using System.Activities;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using StringToObject = System.Collections.Generic.IDictionary<string, object>;
+
+namespace WorkflowApplicationTestExtensions
+{
+    public static class WorkflowApplicationTestExtensions
+    {
+        public const string AutoResumedBookmarkNamePrefix = "AutoResumedBookmark_";
+
+        public record WorkflowApplicationResult(StringToObject Outputs, int PersistenceCount);
+
+        /// <summary>
+        /// Simple API to wait for the workflow to complete or propagate to the caller any error.
+        /// Also, when PersistableIdle, will automatically Unload, Load, resume some bookmarks
+        /// (those named "AutoResumedBookmark_...") and continue execution.
+        /// </summary>
+        public static WorkflowApplicationResult RunUntilCompletion(this WorkflowApplication application)
+        {
+            var persistenceCount = 0;
+            var output = new TaskCompletionSource<WorkflowApplicationResult>();
+            application.Completed += (WorkflowApplicationCompletedEventArgs args) =>
+            {
+                if (args.TerminationException is { } ex)
+                {
+                    output.TrySetException(ex);
+                }
+                if (args.CompletionState == ActivityInstanceState.Canceled)
+                {
+                    throw new OperationCanceledException("Workflow canceled.");
+                }
+                output.TrySetResult(new(args.Outputs, persistenceCount));
+            };
+
+            application.Aborted += args => output.TrySetException(args.Reason);
+
+            application.InstanceStore = new FileInstanceStore(Environment.CurrentDirectory);
+            application.PersistableIdle += (WorkflowApplicationIdleEventArgs args) =>
+            {
+                Debug.WriteLine("PersistableIdle");
+                var bookmarks = args.Bookmarks;
+                Task.Delay(100).ContinueWith(_ =>
+                {
+                    try
+                    {
+                        if (++persistenceCount > 100)
+                        {
+                            throw new Exception("Persisting too many times, aborting test.");
+                        }
+                        application = CloneWorkflowApplication(application);
+                        application.Load(args.InstanceId);
+                        foreach (var bookmark in bookmarks)
+                        {
+                            application.ResumeBookmark(new Bookmark(bookmark.BookmarkName), null);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        output.TrySetException(ex);
+                    }
+                });
+                return PersistableIdleAction.Unload;
+            };
+
+            application.BeginRun(null, null);
+
+            try
+            {
+                output.Task.Wait(TimeSpan.FromSeconds(15));
+            }
+            catch (Exception ex) when (ex is not OperationCanceledException)
+            {
+            }
+            return output.Task.GetAwaiter().GetResult();
+        }
+
+        private static WorkflowApplication CloneWorkflowApplication(WorkflowApplication application)
+        {
+            var clone = new WorkflowApplication(application.WorkflowDefinition, application.DefinitionIdentity)
+            {
+                Aborted = application.Aborted,
+                Completed = application.Completed,
+                PersistableIdle = application.PersistableIdle,
+                InstanceStore = application.InstanceStore,
+            };
+            foreach (var extension in application.Extensions.GetAllSingletonExtensions())
+            {
+                clone.Extensions.Add(extension);
+            }
+            return clone;
+        }
+    }
+}

src/Test/WorkflowApplicationTestExtensions/WorkflowApplicationTestExtensions.csproj

@@ -0,0 +1,5 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <ItemGroup>
+    <ProjectReference Include="..\JsonFileInstanceStore\JsonFileInstanceStore.csproj" />
+  </ItemGroup>
+</Project>

src/Test/WorkflowApplicationTestExtensions/WorkflowApplicationTestSamples.cs

@@ -0,0 +1,54 @@
+using Shouldly;
+using System;
+using System.Activities;
+using System.Activities.Statements;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace WorkflowApplicationTestExtensions
+{
+    public class WorkflowApplicationTestSamples
+    {
+        [Fact]
+        public void RunUntilCompletion_Outputs()
+        {
+            var app = new WorkflowApplication(new DynamicActivity
+            {
+                Properties = { new DynamicActivityProperty { Name = "result", Type = typeof(OutArgument<string>) } },
+                Implementation = () => new Assign<string> { To = new Reference<string>("result"), Value = "value" }
+            });
+            app.RunUntilCompletion().Outputs["result"].ShouldBe("value");
+        }
+
+        [Fact]
+        public void RunUntilCompletion_Faulted()
+        {
+            var app = new WorkflowApplication(new Throw { Exception = new InArgument<Exception>(_ => new ArgumentException()) });
+            Should.Throw<ArgumentException>(app.RunUntilCompletion);
+        }
+
+        [Fact]
+        public void RunUntilCompletion_Aborted()
+        {
+            var app = new WorkflowApplication(new Delay { Duration = TimeSpan.MaxValue });
+            Task.Delay(10).ContinueWith(_ => app.Abort());
+            Should.Throw<WorkflowApplicationAbortedException>(app.RunUntilCompletion);
+        }
+
+        [Fact]
+        public void RunUntilCompletion_AutomaticPersistence()
+        {
+            var app = new WorkflowApplication(new SuspendingWrapper
+            {
+                Activities =
+                {
+                    new WriteLine(),
+                    new NoPersistAsyncActivity(),
+                    new WriteLine()
+                }
+            });
+            var result = app.RunUntilCompletion();
+            result.PersistenceCount.ShouldBe(4);
+        }
+    }
+}

src/UiPath.Workflow.Runtime/ActivityContext.cs

@@ -86,7 +86,11 @@ public WorkflowDataContext DataContext
         }
     }
 
-    internal bool IsDisposed => _isDisposed;
+    internal bool IsDisposed => _isDisposed;
+
+    public void AddAutomationTrackerId() => CurrentInstance.AddAutomationTrackerId();
+
+    public string GetAutomationTrackerId() => CurrentInstance.GetAutomationTrackerId();
 
     public T GetExtension<T>()
         where T : class

src/UiPath.Workflow.Runtime/ActivityInstance.cs

@@ -402,7 +402,16 @@ internal string OwnerName
     }
 
     [DataMember(EmitDefaultValue = false)]
-    public Version ImplementationVersion { get; internal set; }
+    public Version ImplementationVersion { get; internal set; }
+
+    public void AddAutomationTrackerId()
+    {
+        var properties = new ExecutionProperties(null, this, PropertyManager);
+        var existing = properties.Find("BPOId") as string;
+        properties.Add("BPOId", (existing + "-" + Guid.NewGuid().ToString("N")).Trim('-'), true, false);
+    }
+
+    public string GetAutomationTrackerId() => PropertyManager?.GetPropertyAtCurrentScope("BPOId") as string;
 
     internal static ActivityInstance CreateCompletedInstance(Activity activity)
     {

src/UiPath.Workflow.Runtime/Hosting/WorkflowInstanceExtensionManager.cs

@@ -90,7 +90,7 @@ public virtual void Add<T>(Func<T> extensionCreationFunction) where T : class
         ExtensionProviders.Add(new KeyValuePair<Type, WorkflowInstanceExtensionProvider>(typeof(T), new WorkflowInstanceExtensionProvider<T>(extensionCreationFunction)));
     }
 
-    internal List<object> GetAllSingletonExtensions() => _allSingletonExtensions;
+    public List<object> GetAllSingletonExtensions() => _allSingletonExtensions;
 
     internal void AddAllExtensionTypes(HashSet<Type> extensionTypes)
     {

src/UiPath.Workflow.Runtime/Statements/Parallel.cs

@@ -3,7 +3,9 @@
 
 using System.Activities.Runtime.Collections;
 using System.Collections.ObjectModel;
+using System.Reflection;
 using System.Windows.Markup;
+using static System.Activities.XD;
 
 #if DYNAMICUPDATE
 using System.Activities.DynamicUpdate;
@@ -129,7 +131,8 @@ protected override void Execute(NativeActivityContext context)
 
             for (int i = Branches.Count - 1; i >= 0; i--)
             {
-                context.ScheduleActivity(Branches[i], onBranchComplete);
+                var instance = context.ScheduleActivity(Branches[i], onBranchComplete);
+                instance.AddAutomationTrackerId();
             }
         }
     }