Add Dapr.IntegrationTest.Actors integration test project and fix actor HTTP endpoint configuration

all.sln

@@ -251,6 +251,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Dapr.IntegrationTest.Messag
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Dapr.IntegrationTest.Cryptography", "test\Dapr.IntegrationTest.Cryptography\Dapr.IntegrationTest.Cryptography.csproj", "{7B14879F-156B-417E-ACA3-0B5A69CC2F39}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Dapr.IntegrationTest.Actors", "test\Dapr.IntegrationTest.Actors\Dapr.IntegrationTest.Actors.csproj", "{A1B2C3D4-E5F6-7890-ABCD-EF1234567890}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -669,6 +671,10 @@ Global
 		{7B14879F-156B-417E-ACA3-0B5A69CC2F39}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{7B14879F-156B-417E-ACA3-0B5A69CC2F39}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{7B14879F-156B-417E-ACA3-0B5A69CC2F39}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A1B2C3D4-E5F6-7890-ABCD-EF1234567890}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -791,6 +797,7 @@ Global
 		{97CAEE0B-4020-4A86-97DA-9900FDF4DFC6} = {8462B106-175A-423A-BA94-BE0D39D0BD8E}
 		{01A20A89-53A1-4D5B-B563-89E157718474} = {8462B106-175A-423A-BA94-BE0D39D0BD8E}
 		{7B14879F-156B-417E-ACA3-0B5A69CC2F39} = {8462B106-175A-423A-BA94-BE0D39D0BD8E}
+		{A1B2C3D4-E5F6-7890-ABCD-EF1234567890} = {8462B106-175A-423A-BA94-BE0D39D0BD8E}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {65220BF2-EAE1-4CB2-AA58-EBE80768CB40}

src/Dapr.Actors.AspNetCore/ActorsServiceCollectionExtensions.cs

@@ -107,6 +107,6 @@ private static void ConfigureActorOptions(IServiceProvider serviceProvider, Acto
             : DaprDefaults.GetDefaultDaprApiToken(configuration);
         options.HttpEndpoint = !string.IsNullOrWhiteSpace(options.HttpEndpoint)
             ? options.HttpEndpoint
-            : DaprDefaults.GetDefaultHttpEndpoint();
+            : DaprDefaults.GetDefaultHttpEndpoint(configuration);
     }
 }

src/Dapr.Testcontainers/Common/DaprHarnessBuilder.cs

@@ -113,20 +113,12 @@ public CryptographyHarness BuildCryptography(string keysDir) =>
     /// <summary>
     /// Builds a PubSub harness.
     /// </summary>
-    /// <param name="componentsDir">The path to the Dapr resources.</param>
-	public PubSubHarness BuildPubSub(string componentsDir) => new(_componentsDirectory, _startApp, _options, _environment);
+	public PubSubHarness BuildPubSub() => new(_componentsDirectory, _startApp, _options, _environment);
 
- //    /// <summary>
- //    /// Builds a state management harness.
- //    /// </summary>
- //    /// <param name="componentsDir">The path to the Dapr resources.</param>
-	// public StateManagementHarness BuildStateManagement(string componentsDir) => new(_componentsDirectory, _startApp, _options, _environment);
- //
- //    /// <summary>
- //    /// Builds an actor harness.
- //    /// </summary>
- //    /// <param name="componentsDir">The path to the Dapr resources.</param>
-	// public ActorHarness BuildActors(string componentsDir) => new(_componentsDirectory, _startApp, _options, _environment);
+    /// <summary>
+    /// Builds an actor harness.
+    /// </summary>
+    public ActorHarness BuildActors() => new(_componentsDirectory, _startApp, _options, _environment);
 
     /// <summary>
     /// Creates a test application builder for the specified harness.

src/Dapr.Testcontainers/Containers/Dapr/DaprdContainer.cs

@@ -71,6 +71,7 @@ public sealed class DaprdContainer : IAsyncStartable
     /// <param name="daprHttpPort">The host HTTP port to bind to.</param>
     /// <param name="daprGrpcPort">The host gRPC port to bind to.</param>
     /// <param name="logDirectory">The directory to write container logs to.</param>
+    /// <param name="configFilePath">The path inside the container of an optional Dapr configuration YAML file.</param>
     public DaprdContainer(
         string appId, 
         string componentsHostFolder, 
@@ -80,7 +81,8 @@ public DaprdContainer(
         HostPortPair? schedulerHostAndPort = null,
         int? daprHttpPort = null,
         int? daprGrpcPort = null,
-        string? logDirectory = null
+        string? logDirectory = null,
+        string? configFilePath = null
         )
     {
         _requestedHttpPort = daprHttpPort;
@@ -101,6 +103,12 @@ public DaprdContainer(
 				"-resources-path", componentsPath
 			};
 
+        if (configFilePath is not null)
+        {
+            cmd.Add("-config");
+            cmd.Add(configFilePath);
+        }
+
 		if (placementHostAndPort is not null)
 		{
 			cmd.Add("-placement-host-address");

src/Dapr.Testcontainers/Harnesses/ActorHarness.cs

@@ -12,11 +12,11 @@
 //  ------------------------------------------------------------------------
 
 using System;
+using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using Dapr.Testcontainers.Common.Options;
 using Dapr.Testcontainers.Containers;
-using Dapr.Testcontainers.Containers.Dapr;
 
 namespace Dapr.Testcontainers.Harnesses;
 
@@ -26,45 +26,74 @@ namespace Dapr.Testcontainers.Harnesses;
 public sealed class ActorHarness : BaseHarness
 {
     private readonly RedisContainer _redis;
-	private readonly DaprPlacementContainer _placement;
-	private readonly DaprSchedulerContainer _schedueler;
-    private readonly string componentsDir;
+    private readonly bool _isSelfHostedRedis;
 
     /// <summary>
     /// Provides an implementation harness for Dapr's actor building block.
     /// </summary>
     /// <param name="componentsDir">The directory to Dapr components.</param>
     /// <param name="startApp">The test app to validate in the harness.</param>
-    /// <param name="options">The dapr runtime options.</param>
-    /// <param name="environment">The isolated environment instance.</param>
-    public ActorHarness(string componentsDir, Func<int, Task>? startApp, DaprRuntimeOptions options, DaprTestEnvironment? environment = null) : base(componentsDir, startApp, options, environment)
+    /// <param name="options">The Dapr runtime options.</param>
+    /// <param name="environment">
+    /// An optional shared <see cref="DaprTestEnvironment"/>. When provided the harness reuses
+    /// its Redis, Placement, and Scheduler services instead of starting its own.
+    /// </param>
+    public ActorHarness(string componentsDir, Func<int, Task>? startApp, DaprRuntimeOptions options, DaprTestEnvironment? environment = null)
+        : base(componentsDir, startApp, options, environment)
     {
-        this.componentsDir = componentsDir;
-        _placement = new DaprPlacementContainer(options, Network, ContainerLogsDirectory);
-        _schedueler = new DaprSchedulerContainer(options, Network, ContainerLogsDirectory);
-        _redis = new RedisContainer(Network, ContainerLogsDirectory);
+        _redis = environment?.RedisContainer ?? new RedisContainer(Network, ContainerLogsDirectory);
+        _isSelfHostedRedis = environment?.RedisContainer is null;
     }
 
     /// <inheritdoc />
-	protected override async Task OnInitializeAsync(CancellationToken cancellationToken)
-	{
-		// Start infrastructure
-		await _redis.StartAsync(cancellationToken);
-        await _placement.StartAsync(cancellationToken);
-        await _schedueler.StartAsync(cancellationToken);
-
-		// Emit component YAMLs pointing to Redis
-		RedisContainer.Yaml.WriteStateStoreYamlToFolder(componentsDir, redisHost: $"{_redis.NetworkAlias}:{RedisContainer.ContainerPort}");
+    protected override async Task OnInitializeAsync(CancellationToken cancellationToken)
+    {
+        // Only start Redis if it is not provided by a shared environment.
+        if (_isSelfHostedRedis)
+        {
+            await _redis.StartAsync(cancellationToken);
+        }
+
+        // Write the state-store component YAML that points to the Redis instance.
+        RedisContainer.Yaml.WriteStateStoreYamlToFolder(
+            ComponentsDirectory,
+            redisHost: $"{_redis.NetworkAlias}:{RedisContainer.ContainerPort}");
+
+        // Write a Dapr configuration file that enables the ActorStateTTL feature.
+        WriteActorConfigYaml(ComponentsDirectory);
+        DaprConfigFilePath = "/components/actor-config.yaml";
 
-        DaprPlacementExternalPort = _placement.ExternalPort;
-        DaprSchedulerExternalPort = _schedueler.ExternalPort;
+        // Forward placement and scheduler coordinates from the environment.
+        DaprPlacementExternalPort = Environment.PlacementExternalPort;
+        DaprPlacementAlias = Environment.PlacementAlias;
+        DaprSchedulerExternalPort = Environment.SchedulerExternalPort;
+        DaprSchedulerAlias = Environment.SchedulerAlias;
     }
-
+
+    private static void WriteActorConfigYaml(string componentsDirectory)
+    {
+        const string yaml = """
+            apiVersion: dapr.io/v1alpha1
+            kind: Configuration
+            metadata:
+              name: actorConfig
+            spec:
+              features:
+                - name: "ActorStateTTL"
+                  enabled: true
+            """;
+        Directory.CreateDirectory(componentsDirectory);
+        File.WriteAllText(
+            Path.Combine(componentsDirectory, "actor-config.yaml"),
+            yaml);
+    }
+
     /// <inheritdoc />
-	protected override async ValueTask OnDisposeAsync()
-	{
-		await _redis.DisposeAsync();
-		await _placement.DisposeAsync();
-		await _schedueler.DisposeAsync();
-	}
+    protected override async ValueTask OnDisposeAsync()
+    {
+        if (_isSelfHostedRedis)
+        {
+            await _redis.DisposeAsync();
+        }
+    }
 }

src/Dapr.Testcontainers/Harnesses/BaseHarness.cs

@@ -160,6 +160,13 @@ public void SetAppPort(int appPort)
     /// </summary>
     protected string? DaprSchedulerAlias { get; set; }
 
+    /// <summary>
+    /// The path inside the Dapr sidecar container of an optional Dapr configuration YAML file.
+    /// Set this in <see cref="OnInitializeAsync"/> before the base class creates the sidecar.
+    /// When set, daprd is started with <c>-config &lt;path&gt;</c>.
+    /// </summary>
+    protected string? DaprConfigFilePath { get; set; }
+
     /// <summary>
     /// Pre-assigns the Dapr ports to use. This is useful when the app starts before the Dapr container.
     /// </summary>
@@ -222,7 +229,8 @@ DaprSchedulerExternalPort is null || DaprSchedulerAlias is null
                 ? null : new HostPortPair(DaprSchedulerAlias, DaprSchedulerContainer.InternalPort),
             _daprHttpPortOverride,
             _daprGrpcPortOverride,
-            _logDirectory);
+            _logDirectory,
+            DaprConfigFilePath);
 
         var daprdTask = Task.Run(async () =>
         {

src/Dapr.Testcontainers/Harnesses/WorkflowHarness.cs

@@ -60,5 +60,11 @@ protected override async Task OnInitializeAsync(CancellationToken cancellationTo
     }
 
     /// <inheritdoc />
-	protected override ValueTask OnDisposeAsync() => ValueTask.CompletedTask;
+	protected override async ValueTask OnDisposeAsync()
+    {
+        if (_isSelfHostedRedis)
+        {
+            await _redis.DisposeAsync();
+        }
+    }
 }

test/Dapr.Actors.AspNetCore.IntegrationTest/ActivationTests.cs

@@ -12,6 +12,7 @@
 // ------------------------------------------------------------------------
 
 using System;
+using System.Linq;
 using System.Net.Http;
 using System.Text.Json;
 using System.Threading.Tasks;
@@ -45,6 +46,44 @@ public async Task CanActivateActorWithDependencyInjection()
         await DeactivateActor(httpClient, "A");
     }
 
+    [Fact]
+    public async Task InvokeMethod_UnregisteredActorType_ReturnsNonSuccessResponse()
+    {
+        await using var factory = new AppWebApplicationFactory();
+        var httpClient = factory.CreateClient(new Microsoft.AspNetCore.Mvc.Testing.WebApplicationFactoryClientOptions { HandleCookies = false });
+
+        var request = new HttpRequestMessage(HttpMethod.Put,
+            "http://localhost/actors/NoSuchActorType/someId/method/SomeMethod");
+        var response = await httpClient.SendAsync(request, TestContext.Current.CancellationToken);
+
+        Assert.False(response.IsSuccessStatusCode,
+            $"Expected a non-success status code for an unregistered actor type, but got {response.StatusCode}");
+    }
+
+    [Fact]
+    public async Task ConcurrentIncrement_SameActorId_RetainsConsistentState()
+    {
+        await using var factory = new AppWebApplicationFactory();
+        var httpClient = factory.CreateClient(new Microsoft.AspNetCore.Mvc.Testing.WebApplicationFactoryClientOptions { HandleCookies = false });
+
+        const string actorId = "concurrent-actor";
+        const int concurrency = 5;
+
+        // Fire `concurrency` increments at the same actor ID in parallel.
+        var tasks = Enumerable.Range(0, concurrency)
+            .Select(_ => IncrementCounterAsync(httpClient, actorId))
+            .ToArray();
+
+        var results = await Task.WhenAll(tasks);
+
+        // Each call should have received a distinct integer from 0 to concurrency-1, proving
+        // that the actor serialised the concurrent requests and no two calls returned the same value.
+        var distinct = results.Select(int.Parse).OrderBy(x => x).ToArray();
+        Assert.Equal(Enumerable.Range(0, concurrency).ToArray(), distinct);
+
+        await DeactivateActor(httpClient, actorId);
+    }
+
     private async Task<string> IncrementCounterAsync(HttpClient httpClient, string actorId)
     {
         const string actorTypeName = nameof(DependencyInjectionActor);

test/Dapr.Actors.AspNetCore.Test/ActorHostingTest.cs

@@ -11,10 +11,13 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Text.Json;
 using Dapr.Actors.Client;
 using Dapr.Actors.Runtime;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 
@@ -107,4 +110,75 @@ public TestActor2(ActorHost host)
         {
         }
     }
+}
+
+/// <summary>
+/// Tests for AddActors — verifying HttpEndpoint and DaprApiToken options are propagated to the
+/// resolved <see cref="IActorProxyFactory"/>.
+/// </summary>
+public class ActorServiceCollectionExtensionsOptionsTests
+{
+    [Fact]
+    public void AddActors_HttpEndpoint_IsReflectedInProxyFactory()
+    {
+        const string endpoint = "http://my-custom-dapr:3501";
+
+        var services = new ServiceCollection();
+        services.AddLogging();
+        services.AddOptions();
+        services.AddActors(options =>
+        {
+            options.HttpEndpoint = endpoint;
+        });
+
+        var factory = (ActorProxyFactory)services.BuildServiceProvider().GetRequiredService<IActorProxyFactory>();
+        Assert.Equal(endpoint, factory.DefaultOptions.HttpEndpoint);
+    }
+
+    [Fact]
+    public void AddActors_DaprApiToken_IsReflectedInProxyFactory()
+    {
+        const string token = "super-secret-token";
+
+        var services = new ServiceCollection();
+        services.AddLogging();
+        services.AddOptions();
+        services.AddActors(options =>
+        {
+            options.DaprApiToken = token;
+        });
+
+        var factory = (ActorProxyFactory)services.BuildServiceProvider().GetRequiredService<IActorProxyFactory>();
+        Assert.Equal(token, factory.DefaultOptions.DaprApiToken);
+    }
+
+    [Fact]
+    public void AddActors_HttpEndpointFromConfiguration_IsReflectedInProxyFactory()
+    {
+        // Verify that when no explicit HttpEndpoint is set, AddActors falls back to
+        // the DAPR_HTTP_ENDPOINT key in IConfiguration (e.g. in-memory config, not env var).
+        const string endpoint = "http://dapr-from-config:3502";
+
+        var services = new ServiceCollection();
+        services.AddLogging();
+        services.AddOptions();
+
+        // Populate IConfiguration with the endpoint — simulates what DaprTestApplicationBuilder does.
+        services.AddSingleton<IConfiguration>(
+            new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    { "DAPR_HTTP_ENDPOINT", endpoint }
+                })
+                .Build());
+
+        services.AddActors(options =>
+        {
+            // HttpEndpoint is intentionally NOT set; the fallback should read from IConfiguration.
+        });
+
+        var factory = (ActorProxyFactory)services.BuildServiceProvider().GetRequiredService<IActorProxyFactory>();
+        // GetDefaultHttpEndpoint normalizes the URL and may append a trailing slash.
+        Assert.StartsWith(endpoint, factory.DefaultOptions.HttpEndpoint, StringComparison.Ordinal);
+    }
 }