249 lines
10 KiB
C#
249 lines
10 KiB
C#
using Akka.Actor;
|
|
using Akka.TestKit.Xunit2;
|
|
using Microsoft.Extensions.Logging.Abstractions;
|
|
using ScadaLink.Commons.Messages.Deployment;
|
|
using ScadaLink.Commons.Types.Enums;
|
|
using ScadaLink.Commons.Types.Flattening;
|
|
using ScadaLink.SiteRuntime.Actors;
|
|
using ScadaLink.SiteRuntime.Persistence;
|
|
using ScadaLink.SiteRuntime.Scripts;
|
|
using System.Text.Json;
|
|
|
|
namespace ScadaLink.SiteRuntime.Tests.Actors;
|
|
|
|
/// <summary>
|
|
/// Regression tests for the Medium-severity DeploymentManagerActor findings:
|
|
/// SiteRuntime-005 (Success reported before persistence completes) and
|
|
/// SiteRuntime-008 (blocking shared-script load on the actor thread).
|
|
/// </summary>
|
|
public class DeploymentManagerMediumFindingsTests : TestKit, IDisposable
|
|
{
|
|
private readonly ScriptCompilationService _compilationService;
|
|
private readonly SharedScriptLibrary _sharedScriptLibrary;
|
|
private readonly string _dbFile;
|
|
|
|
public DeploymentManagerMediumFindingsTests()
|
|
{
|
|
_dbFile = Path.Combine(Path.GetTempPath(), $"dm-medium-test-{Guid.NewGuid():N}.db");
|
|
_compilationService = new ScriptCompilationService(
|
|
NullLogger<ScriptCompilationService>.Instance);
|
|
_sharedScriptLibrary = new SharedScriptLibrary(
|
|
_compilationService, NullLogger<SharedScriptLibrary>.Instance);
|
|
}
|
|
|
|
void IDisposable.Dispose()
|
|
{
|
|
Shutdown();
|
|
try { File.Delete(_dbFile); } catch { /* cleanup */ }
|
|
}
|
|
|
|
private SiteStorageService NewStorage(string connectionString)
|
|
=> new(connectionString, NullLogger<SiteStorageService>.Instance);
|
|
|
|
private IActorRef CreateDeploymentManager(SiteStorageService storage, IActorRef? dclManager = null)
|
|
{
|
|
return ActorOf(Props.Create(() => new DeploymentManagerActor(
|
|
storage,
|
|
_compilationService,
|
|
_sharedScriptLibrary,
|
|
null,
|
|
new SiteRuntimeOptions(),
|
|
NullLogger<DeploymentManagerActor>.Instance,
|
|
dclManager,
|
|
null,
|
|
null,
|
|
null)));
|
|
}
|
|
|
|
private static string MakeConfigJsonWithConnection(
|
|
string instanceName, string endpoint, int failoverRetryCount)
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = instanceName,
|
|
Attributes =
|
|
[
|
|
new ResolvedAttribute { CanonicalName = "TestAttr", Value = "1", DataType = "Int32" }
|
|
],
|
|
Connections = new Dictionary<string, ConnectionConfig>
|
|
{
|
|
["Conn1"] = new ConnectionConfig
|
|
{
|
|
Protocol = "Custom",
|
|
ConfigurationJson = $"{{\"endpoint\":\"{endpoint}\"}}",
|
|
FailoverRetryCount = failoverRetryCount
|
|
}
|
|
}
|
|
};
|
|
return JsonSerializer.Serialize(config);
|
|
}
|
|
|
|
private static string MakeConfigJson(string instanceName)
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = instanceName,
|
|
Attributes =
|
|
[
|
|
new ResolvedAttribute { CanonicalName = "TestAttr", Value = "1", DataType = "Int32" }
|
|
]
|
|
};
|
|
return JsonSerializer.Serialize(config);
|
|
}
|
|
|
|
/// <summary>
|
|
/// SiteRuntime-005: when SQLite persistence of the deployed config fails, the
|
|
/// Deployment Manager must report <see cref="DeploymentStatus.Failed"/> to central,
|
|
/// not <see cref="DeploymentStatus.Success"/>. Reporting Success on a persistence
|
|
/// failure silently loses the deployment on the next restart/failover.
|
|
/// </summary>
|
|
[Fact]
|
|
public async Task Deploy_PersistenceFailure_ReportsFailedNotSuccess()
|
|
{
|
|
// A connection string pointing at an unwritable path makes every storage
|
|
// write throw, so StoreDeployedConfigAsync fails.
|
|
var badPath = Path.Combine(
|
|
Path.GetTempPath(), $"no-such-dir-{Guid.NewGuid():N}", "site.db");
|
|
var storage = NewStorage($"Data Source={badPath}");
|
|
|
|
var actor = CreateDeploymentManager(storage);
|
|
await Task.Delay(500); // empty startup
|
|
|
|
actor.Tell(new DeployInstanceCommand(
|
|
"dep-fail", "FailPump", "h1", MakeConfigJson("FailPump"), "admin", DateTimeOffset.UtcNow));
|
|
|
|
var response = ExpectMsg<DeploymentStatusResponse>(TimeSpan.FromSeconds(10));
|
|
Assert.Equal("FailPump", response.InstanceUniqueName);
|
|
Assert.Equal(DeploymentStatus.Failed, response.Status);
|
|
Assert.False(string.IsNullOrEmpty(response.ErrorMessage));
|
|
}
|
|
|
|
/// <summary>
|
|
/// SiteRuntime-005: a successful deployment must still report
|
|
/// <see cref="DeploymentStatus.Success"/>, and only after the config row is
|
|
/// committed to SQLite (so a restart re-creates the instance).
|
|
/// </summary>
|
|
[Fact]
|
|
public async Task Deploy_Success_ReportsSuccessAndPersistsConfig()
|
|
{
|
|
var storage = NewStorage($"Data Source={_dbFile}");
|
|
await storage.InitializeAsync();
|
|
|
|
var actor = CreateDeploymentManager(storage);
|
|
await Task.Delay(500);
|
|
|
|
actor.Tell(new DeployInstanceCommand(
|
|
"dep-ok", "OkPump", "h1", MakeConfigJson("OkPump"), "admin", DateTimeOffset.UtcNow));
|
|
|
|
var response = ExpectMsg<DeploymentStatusResponse>(TimeSpan.FromSeconds(10));
|
|
Assert.Equal(DeploymentStatus.Success, response.Status);
|
|
|
|
// By the time Success is reported, the config must be durable.
|
|
var configs = await storage.GetAllDeployedConfigsAsync();
|
|
Assert.Contains(configs, c => c.InstanceUniqueName == "OkPump");
|
|
}
|
|
|
|
/// <summary>
|
|
/// SiteRuntime-010: when a redeployment changes a connection's configuration
|
|
/// (here the failover retry count and endpoint), the Deployment Manager must
|
|
/// re-issue a <see cref="ScadaLink.Commons.Messages.DataConnection.CreateConnectionCommand"/>
|
|
/// so the DCL adopts the new configuration rather than keeping the stale one.
|
|
/// </summary>
|
|
[Fact]
|
|
public async Task EnsureDclConnections_ConnectionConfigChanged_ReissuesCreateCommand()
|
|
{
|
|
var storage = NewStorage($"Data Source={_dbFile}");
|
|
await storage.InitializeAsync();
|
|
|
|
var dcl = CreateTestProbe();
|
|
var actor = CreateDeploymentManager(storage, dcl.Ref);
|
|
await Task.Delay(500);
|
|
|
|
// Initial deploy with one connection.
|
|
actor.Tell(new DeployInstanceCommand(
|
|
"dep-c1", "ConnPump", "h1",
|
|
MakeConfigJsonWithConnection("ConnPump", "opc.tcp://host-a:4840", 3),
|
|
"admin", DateTimeOffset.UtcNow));
|
|
var firstCreate = dcl.ExpectMsg<ScadaLink.Commons.Messages.DataConnection.CreateConnectionCommand>(
|
|
TimeSpan.FromSeconds(5));
|
|
Assert.Equal("Conn1", firstCreate.ConnectionName);
|
|
Assert.Equal(3, firstCreate.FailoverRetryCount);
|
|
ExpectMsg<DeploymentStatusResponse>(TimeSpan.FromSeconds(5));
|
|
await Task.Delay(500);
|
|
|
|
// Redeploy with a CHANGED connection configuration.
|
|
actor.Tell(new DeployInstanceCommand(
|
|
"dep-c2", "ConnPump", "h2",
|
|
MakeConfigJsonWithConnection("ConnPump", "opc.tcp://host-b:4840", 7),
|
|
"admin", DateTimeOffset.UtcNow));
|
|
|
|
// The DCL must receive a fresh create command reflecting the new config.
|
|
var secondCreate = dcl.ExpectMsg<ScadaLink.Commons.Messages.DataConnection.CreateConnectionCommand>(
|
|
TimeSpan.FromSeconds(10));
|
|
Assert.Equal("Conn1", secondCreate.ConnectionName);
|
|
Assert.Equal(7, secondCreate.FailoverRetryCount);
|
|
}
|
|
|
|
/// <summary>
|
|
/// SiteRuntime-010: an unchanged connection configuration must still be skipped —
|
|
/// re-sending an identical create command on every deploy is wasteful.
|
|
/// </summary>
|
|
[Fact]
|
|
public async Task EnsureDclConnections_UnchangedConfig_DoesNotReissueCreateCommand()
|
|
{
|
|
var storage = NewStorage($"Data Source={_dbFile}");
|
|
await storage.InitializeAsync();
|
|
|
|
var dcl = CreateTestProbe();
|
|
var actor = CreateDeploymentManager(storage, dcl.Ref);
|
|
await Task.Delay(500);
|
|
|
|
var json = MakeConfigJsonWithConnection("StablePump", "opc.tcp://host-a:4840", 3);
|
|
actor.Tell(new DeployInstanceCommand(
|
|
"dep-s1", "StablePump", "h1", json, "admin", DateTimeOffset.UtcNow));
|
|
dcl.ExpectMsg<ScadaLink.Commons.Messages.DataConnection.CreateConnectionCommand>(
|
|
TimeSpan.FromSeconds(5));
|
|
ExpectMsg<DeploymentStatusResponse>(TimeSpan.FromSeconds(5));
|
|
await Task.Delay(500);
|
|
|
|
// Redeploy with the IDENTICAL connection configuration.
|
|
actor.Tell(new DeployInstanceCommand(
|
|
"dep-s2", "StablePump", "h2", json, "admin", DateTimeOffset.UtcNow));
|
|
ExpectMsg<DeploymentStatusResponse>(TimeSpan.FromSeconds(10));
|
|
|
|
// No further create command for an unchanged connection.
|
|
dcl.ExpectNoMsg(TimeSpan.FromMilliseconds(800));
|
|
}
|
|
|
|
/// <summary>
|
|
/// SiteRuntime-008: startup must not block the Deployment Manager mailbox on a
|
|
/// synchronous shared-script load. With shared scripts present, the actor must
|
|
/// still load deployed configs, create Instance Actors, and remain responsive.
|
|
/// </summary>
|
|
[Fact]
|
|
public async Task Startup_WithSharedScripts_LoadsConfigsAndStaysResponsive()
|
|
{
|
|
var storage = NewStorage($"Data Source={_dbFile}");
|
|
await storage.InitializeAsync();
|
|
|
|
// Several shared scripts to compile during startup.
|
|
for (var i = 0; i < 5; i++)
|
|
{
|
|
await storage.StoreSharedScriptAsync(
|
|
$"Shared{i}", "return 1 + 1;", null, null);
|
|
}
|
|
|
|
await storage.StoreDeployedConfigAsync(
|
|
"StartupPump", MakeConfigJson("StartupPump"), "d1", "h1", true);
|
|
|
|
var actor = CreateDeploymentManager(storage);
|
|
await Task.Delay(2000);
|
|
|
|
// The instance loaded at startup must be operable — proves startup completed
|
|
// and the actor processed messages after the shared-script load.
|
|
actor.Tell(new DeploymentStateQueryRequest("corr-1", "StartupPump", DateTimeOffset.UtcNow));
|
|
var response = ExpectMsg<DeploymentStateQueryResponse>(TimeSpan.FromSeconds(5));
|
|
Assert.True(response.IsDeployed);
|
|
}
|
|
}
|