Add tests, update filter construction

Signed-off-by: Hal Spang <halspang@microsoft.com>

Author: halspang

src/Worker/Core/DependencyInjection/DurableTaskWorkerBuilderExtensions.cs

@@ -154,12 +154,12 @@ public static IDurableTaskWorkerBuilder UseWorkItemFilters(this IDurableTaskWork
         }
         else
         {
-            // Auto-generate the filters from registered orchestrations, activities, and entitites.
+            // Auto-generate the filters from registered orchestrations, activities, and entities.
             builder.Services.AddSingleton(provider =>
             {
                 DurableTaskRegistry registry = provider.GetRequiredService<IOptionsMonitor<DurableTaskRegistry>>().Get(builder.Name);
                 DurableTaskWorkerOptions? options = provider.GetOptions<DurableTaskWorkerOptions>(builder.Name);
-                return new DurableTaskWorkerWorkItemFilters(registry, options);
+                return DurableTaskWorkerWorkItemFilters.FromDurableTaskRegistry(registry, options);
             });
         }
 

src/Worker/Core/DurableTaskWorkerWorkItemFilters.cs

@@ -11,76 +11,49 @@ namespace Microsoft.DurableTask.Worker;
 public class DurableTaskWorkerWorkItemFilters
 {
     /// <summary>
-    /// Initializes a new instance of the <see cref="DurableTaskWorkerWorkItemFilters"/> class.
+    /// Gets or initializes the orchestration filters.
     /// </summary>
-    public DurableTaskWorkerWorkItemFilters()
-    {
-        this.Orchestrations = [];
-        this.Activities = [];
-        this.Entities = [];
-    }
+    public IReadOnlyList<OrchestrationFilter> Orchestrations { get; init; } = [];
+
+    /// <summary>
+    /// Gets or initializes the activity filters.
+    /// </summary>
+    public IReadOnlyList<ActivityFilter> Activities { get; init; } = [];
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="DurableTaskWorkerWorkItemFilters"/> class.
+    /// Gets or initializes the entity filters.
+    /// </summary>
+    public IReadOnlyList<EntityFilter> Entities { get; init; } = [];
+
+    /// <summary>
+    /// Creates a new instance of the <see cref="DurableTaskWorkerWorkItemFilters"/> class.
     /// </summary>
     /// <param name="registry"><see cref="DurableTaskRegistry"/> to construct the filter from.</param>
     /// <param name="workerOptions"><see cref="DurableTaskWorkerOptions"/> that optionally provides versioning information.</param>
-    internal DurableTaskWorkerWorkItemFilters(DurableTaskRegistry registry, DurableTaskWorkerOptions? workerOptions)
+    /// <returns>A new instance of <see cref="DurableTaskWorkerWorkItemFilters"/> constructed from the provided registry.</returns>
+    internal static DurableTaskWorkerWorkItemFilters FromDurableTaskRegistry(DurableTaskRegistry registry, DurableTaskWorkerOptions? workerOptions)
     {
-        List<OrchestrationFilter> orchestrationActions = new();
-        foreach (var orchestration in registry.Orchestrators)
+        // TODO: Support multiple versions per orchestration/activity. For now, grab the worker version from the options.
+        return new DurableTaskWorkerWorkItemFilters
         {
-            orchestrationActions.Add(new OrchestrationFilter
+            Orchestrations = registry.Orchestrators.Select(orchestration => new OrchestrationFilter
             {
                 Name = orchestration.Key,
-
-                // TODO: Support multiple orchestration versions, for now, utilize the Worker's version.
                 Versions = workerOptions?.Versioning != null ? [workerOptions.Versioning.DefaultVersion] : [],
-            });
-        }
-
-        this.Orchestrations = orchestrationActions;
-        List<ActivityFilter> activityActions = new();
-        foreach (var activity in registry.Activities)
-        {
-            activityActions.Add(new ActivityFilter
+            }).ToList(),
+            Activities = registry.Activities.Select(activity => new ActivityFilter
             {
                 Name = activity.Key,
-
-                // TODO: Support multiple activity versions, for now, utilize the Worker's version.
                 Versions = workerOptions?.Versioning != null ? [workerOptions.Versioning.DefaultVersion] : [],
-            });
-        }
-
-        this.Activities = activityActions;
-        List<EntityFilter> entityActions = new();
-        foreach (var entity in registry.Entities)
-        {
-            entityActions.Add(new EntityFilter
+            }).ToList(),
+            Entities = registry.Entities.Select(entity => new EntityFilter
             {
                 // Entity names are normalized to lowercase in the backend.
                 Name = entity.Key.ToString().ToLowerInvariant(),
-            });
-        }
-
-        this.Entities = entityActions;
+            }).ToList(),
+        };
     }
 
-    /// <summary>
-    /// Gets or initializes the orchestration filters.
-    /// </summary>
-    public IReadOnlyList<OrchestrationFilter> Orchestrations { get; init; }
-
-    /// <summary>
-    /// Gets or initializes the activity filters.
-    /// </summary>
-    public IReadOnlyList<ActivityFilter> Activities { get; init; }
-
-    /// <summary>
-    /// Gets or initializes the entity filters.
-    /// </summary>
-    public IReadOnlyList<EntityFilter> Entities { get; init; }
-
     /// <summary>
     /// Struct specifying an orchestration filter.
     /// </summary>
@@ -94,7 +67,7 @@ public struct OrchestrationFilter
         /// <summary>
         /// Gets or initializes the versions of the orchestration to filter.
         /// </summary>
-        public List<string> Versions { get; init; }
+        public IReadOnlyList<string> Versions { get; init; }
     }
 
     /// <summary>
@@ -110,7 +83,7 @@ public struct ActivityFilter
         /// <summary>
         /// Gets or initializes the versions of the activity to filter.
         /// </summary>
-        public List<string> Versions { get; init; }
+        public IReadOnlyList<string> Versions { get; init; }
     }
 
     /// <summary>

src/Worker/Grpc/GrpcDurableTaskWorker.Processor.cs

@@ -256,7 +256,7 @@ async ValueTask<OrchestrationRuntimeState> BuildRuntimeStateAsync(
                     MaxConcurrentEntityWorkItems =
                         workerOptions.Concurrency.MaximumConcurrentEntityWorkItems,
                     Capabilities = { this.worker.grpcOptions.Capabilities },
-                    WorkItemFilters = this.worker?.workItemFilters?.ToGrpcWorkItemFilters(),
+                    WorkItemFilters = this.worker.workItemFilters?.ToGrpcWorkItemFilters(),
                 },
                 cancellationToken: cancellation);
         }

src/Worker/Grpc/Internal/DurableTaskWorkerWorkItemFiltersExtension.cs

@@ -8,7 +8,7 @@ namespace Microsoft.DurableTask.Worker.Grpc.Internal;
 /// <summary>
 /// Extension for <see cref="DurableTaskWorkerWorkItemFilters"/> to convert to gRPC types.
 /// </summary>
-public static class DurableTaskWorkerWorkItemFiltersExtensions
+public static class DurableTaskWorkerWorkItemFiltersExtension
 {
     /// <summary>
     /// Converts a <see cref="DurableTaskWorkerWorkItemFilters"/> to a gRPC <see cref="P.WorkItemFilters"/>.
@@ -17,6 +17,7 @@ public static class DurableTaskWorkerWorkItemFiltersExtensions
     /// <returns>A gRPC <see cref="P.WorkItemFilters"/>.</returns>
     public static P.WorkItemFilters ToGrpcWorkItemFilters(this DurableTaskWorkerWorkItemFilters workItemFilter)
     {
+        Check.NotNull(workItemFilter);
         var grpcWorkItemFilters = new P.WorkItemFilters();
         foreach (var orchestrationFilter in workItemFilter.Orchestrations)
         {
@@ -30,21 +31,21 @@ public static P.WorkItemFilters ToGrpcWorkItemFilters(this DurableTaskWorkerWork
 
         foreach (var activityFilter in workItemFilter.Activities)
         {
-            var grpcActivityAction = new P.ActivityFilter
+            var grpcActivityFilter = new P.ActivityFilter
             {
                 Name = activityFilter.Name,
             };
-            grpcActivityAction.Versions.AddRange(activityFilter.Versions);
-            grpcWorkItemFilters.Activities.Add(grpcActivityAction);
+            grpcActivityFilter.Versions.AddRange(activityFilter.Versions);
+            grpcWorkItemFilters.Activities.Add(grpcActivityFilter);
         }
 
         foreach (var entityFilter in workItemFilter.Entities)
         {
-            var grpcEntityAction = new P.EntityFilter
+            var grpcEntityFilter = new P.EntityFilter
             {
                 Name = entityFilter.Name,
             };
-            grpcWorkItemFilters.Entities.Add(grpcEntityAction);
+            grpcWorkItemFilters.Entities.Add(grpcEntityFilter);
         }
 
         return grpcWorkItemFilters;