446 lines
19 KiB
C#
446 lines
19 KiB
C#
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.EntityFrameworkCore.Diagnostics;
|
|
using Microsoft.Extensions.Configuration;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using ScadaLink.Commons.Entities.Scripts;
|
|
using ScadaLink.Commons.Entities.Templates;
|
|
using ScadaLink.Commons.Interfaces.Repositories;
|
|
using ScadaLink.Commons.Interfaces.Services;
|
|
using ScadaLink.Commons.Interfaces.Transport;
|
|
using ScadaLink.Commons.Types.Transport;
|
|
using ScadaLink.ConfigurationDatabase;
|
|
using ScadaLink.ConfigurationDatabase.Repositories;
|
|
using ScadaLink.ConfigurationDatabase.Services;
|
|
using ScadaLink.Transport;
|
|
using ScadaLink.Transport.Import;
|
|
|
|
namespace ScadaLink.Transport.IntegrationTests.Import;
|
|
|
|
/// <summary>
|
|
/// Integration tests for <see cref="BundleImporter.ApplyAsync"/>. Reuses the
|
|
/// in-memory host pattern from <see cref="BundleImporterPreviewTests"/> and
|
|
/// <c>BundleExporterTests</c>: real repositories, real EF in-memory provider,
|
|
/// real Transport pipeline.
|
|
/// <para>
|
|
/// In-memory EF caveat: <see cref="DbContext.Database.BeginTransactionAsync"/>
|
|
/// is a no-op on this provider, so the rollback test depends on ApplyAsync's
|
|
/// implementation deferring <c>SaveChangesAsync</c> to a single call just
|
|
/// before <c>CommitAsync</c>. The implementation enforces that contract +
|
|
/// calls <c>ChangeTracker.Clear()</c> on the catch path to defend against
|
|
/// in-memory bleed-through; the rollback test asserts via row counts that the
|
|
/// invariant holds.
|
|
/// </para>
|
|
/// </summary>
|
|
public sealed class BundleImporterApplyTests : IDisposable
|
|
{
|
|
private readonly ServiceProvider _provider;
|
|
|
|
public BundleImporterApplyTests()
|
|
{
|
|
var services = new ServiceCollection();
|
|
services.AddSingleton<IConfiguration>(
|
|
new ConfigurationBuilder().AddInMemoryCollection().Build());
|
|
|
|
var dbName = $"BundleImporterApplyTests_{Guid.NewGuid()}";
|
|
// In-memory provider throws by default when BeginTransactionAsync is
|
|
// called (InMemoryEventId.TransactionIgnoredWarning is escalated to an
|
|
// exception). ApplyAsync legitimately opens a transaction for
|
|
// relational providers; downgrade the warning here so the in-memory
|
|
// run is a no-op and the rest of the apply runs through. See the
|
|
// ApplyAsync XML comment for the rollback-safety contract that makes
|
|
// this safe (single deferred SaveChangesAsync + ChangeTracker.Clear
|
|
// on catch).
|
|
services.AddDbContext<ScadaLinkDbContext>(opts => opts
|
|
.UseInMemoryDatabase(dbName)
|
|
.ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning)));
|
|
|
|
services.AddScoped<ITemplateEngineRepository, TemplateEngineRepository>();
|
|
services.AddScoped<IExternalSystemRepository, ExternalSystemRepository>();
|
|
services.AddScoped<INotificationRepository, NotificationRepository>();
|
|
services.AddScoped<IInboundApiRepository, InboundApiRepository>();
|
|
services.AddScoped<IAuditCorrelationContext, AuditCorrelationContext>();
|
|
services.AddScoped<IAuditService, AuditService>();
|
|
services.AddTransport();
|
|
|
|
_provider = services.BuildServiceProvider();
|
|
}
|
|
|
|
public void Dispose() => _provider.Dispose();
|
|
|
|
// ---- helpers ----
|
|
|
|
/// <summary>
|
|
/// Exports the entire seeded content as a bundle, then immediately loads it
|
|
/// via <see cref="IBundleImporter.LoadAsync"/> and returns the opened
|
|
/// session. Used by every test that needs a session to feed
|
|
/// <see cref="IBundleImporter.ApplyAsync"/>. Selection is "all templates +
|
|
/// all shared scripts" because the tests want the bundle to carry whatever
|
|
/// the test seeded.
|
|
/// </summary>
|
|
private async Task<Guid> ExportAndLoadAsync()
|
|
{
|
|
Stream bundleStream;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var exporter = scope.ServiceProvider.GetRequiredService<IBundleExporter>();
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
var templateIds = await ctx.Templates.Select(t => t.Id).ToListAsync();
|
|
var sharedScriptIds = await ctx.SharedScripts.Select(s => s.Id).ToListAsync();
|
|
var selection = new ExportSelection(
|
|
TemplateIds: templateIds,
|
|
SharedScriptIds: sharedScriptIds,
|
|
ExternalSystemIds: Array.Empty<int>(),
|
|
DatabaseConnectionIds: Array.Empty<int>(),
|
|
NotificationListIds: Array.Empty<int>(),
|
|
SmtpConfigurationIds: Array.Empty<int>(),
|
|
ApiKeyIds: Array.Empty<int>(),
|
|
ApiMethodIds: Array.Empty<int>(),
|
|
IncludeDependencies: false);
|
|
bundleStream = await exporter.ExportAsync(selection, user: "alice", sourceEnvironment: "dev",
|
|
passphrase: null, cancellationToken: CancellationToken.None);
|
|
}
|
|
|
|
using var ms = new MemoryStream();
|
|
await bundleStream.CopyToAsync(ms);
|
|
ms.Position = 0;
|
|
|
|
await using var loadScope = _provider.CreateAsyncScope();
|
|
var importer = loadScope.ServiceProvider.GetRequiredService<IBundleImporter>();
|
|
var session = await importer.LoadAsync(ms, passphrase: null);
|
|
return session.SessionId;
|
|
}
|
|
|
|
private async Task WipeContentAsync()
|
|
{
|
|
await using var scope = _provider.CreateAsyncScope();
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
ctx.Templates.RemoveRange(ctx.Templates);
|
|
ctx.SharedScripts.RemoveRange(ctx.SharedScripts);
|
|
ctx.TemplateFolders.RemoveRange(ctx.TemplateFolders);
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
|
|
// ---- tests ----
|
|
|
|
[Fact]
|
|
public async Task ApplyAsync_adds_new_artifacts_in_single_transaction()
|
|
{
|
|
// Arrange: seed → export → wipe → apply. The wipe ensures the import
|
|
// is exercising the Add path (the bundle's artifacts are absent from
|
|
// the target).
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
ctx.SharedScripts.Add(new SharedScript("HelperFn", "return 1;"));
|
|
ctx.Templates.Add(new Template("Pump") { Description = "fresh" });
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
var sessionId = await ExportAndLoadAsync();
|
|
await WipeContentAsync();
|
|
|
|
// Act
|
|
ImportResult result;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var importer = scope.ServiceProvider.GetRequiredService<IBundleImporter>();
|
|
var resolutions = new List<ImportResolution>
|
|
{
|
|
new("Template", "Pump", ResolutionAction.Add, null),
|
|
new("SharedScript", "HelperFn", ResolutionAction.Add, null),
|
|
};
|
|
result = await importer.ApplyAsync(sessionId, resolutions, user: "bob");
|
|
}
|
|
|
|
// Assert
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
Assert.Equal(1, await ctx.Templates.CountAsync(t => t.Name == "Pump"));
|
|
Assert.Equal(1, await ctx.SharedScripts.CountAsync(s => s.Name == "HelperFn"));
|
|
}
|
|
Assert.Equal(2, result.Added);
|
|
Assert.Equal(0, result.Overwritten);
|
|
Assert.Equal(0, result.Skipped);
|
|
Assert.NotEqual(Guid.Empty, result.BundleImportId);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ApplyAsync_overwrites_artifact_when_resolution_is_Overwrite()
|
|
{
|
|
// Arrange: seed Pump with Description=new, export, then mutate to
|
|
// Description=old. The bundle still carries "new". Overwrite must
|
|
// restore the description.
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
ctx.Templates.Add(new Template("Pump") { Description = "new" });
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
var sessionId = await ExportAndLoadAsync();
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
var t = await ctx.Templates.SingleAsync(x => x.Name == "Pump");
|
|
t.Description = "old";
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
|
|
// Act
|
|
ImportResult result;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var importer = scope.ServiceProvider.GetRequiredService<IBundleImporter>();
|
|
result = await importer.ApplyAsync(sessionId,
|
|
new List<ImportResolution> { new("Template", "Pump", ResolutionAction.Overwrite, null) },
|
|
user: "bob");
|
|
}
|
|
|
|
// Assert
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
var t = await ctx.Templates.SingleAsync(x => x.Name == "Pump");
|
|
Assert.Equal("new", t.Description);
|
|
}
|
|
Assert.Equal(1, result.Overwritten);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ApplyAsync_skips_artifact_when_resolution_is_Skip()
|
|
{
|
|
// Arrange: identical seed + bundle; Skip resolution should leave
|
|
// target unchanged and bump Skipped count.
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
ctx.Templates.Add(new Template("Pump") { Description = "stable" });
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
var sessionId = await ExportAndLoadAsync();
|
|
|
|
// Act
|
|
ImportResult result;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var importer = scope.ServiceProvider.GetRequiredService<IBundleImporter>();
|
|
result = await importer.ApplyAsync(sessionId,
|
|
new List<ImportResolution> { new("Template", "Pump", ResolutionAction.Skip, null) },
|
|
user: "bob");
|
|
}
|
|
|
|
// Assert
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
// Exactly one Pump still, with Description unchanged.
|
|
var t = await ctx.Templates.SingleAsync(x => x.Name == "Pump");
|
|
Assert.Equal("stable", t.Description);
|
|
}
|
|
Assert.Equal(1, result.Skipped);
|
|
Assert.Equal(0, result.Added);
|
|
Assert.Equal(0, result.Overwritten);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ApplyAsync_renames_artifact_when_resolution_is_Rename()
|
|
{
|
|
// Arrange: seed X, export, wipe so the Rename target Y doesn't
|
|
// collide. Apply Rename X→Y.
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
ctx.Templates.Add(new Template("X") { Description = "orig" });
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
var sessionId = await ExportAndLoadAsync();
|
|
await WipeContentAsync();
|
|
|
|
// Act
|
|
ImportResult result;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var importer = scope.ServiceProvider.GetRequiredService<IBundleImporter>();
|
|
result = await importer.ApplyAsync(sessionId,
|
|
new List<ImportResolution> { new("Template", "X", ResolutionAction.Rename, "Y") },
|
|
user: "bob");
|
|
}
|
|
|
|
// Assert
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
Assert.Equal(0, await ctx.Templates.CountAsync(t => t.Name == "X"));
|
|
Assert.Equal(1, await ctx.Templates.CountAsync(t => t.Name == "Y"));
|
|
}
|
|
Assert.Equal(1, result.Renamed);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ApplyAsync_rolls_back_all_changes_when_semantic_validation_fails()
|
|
{
|
|
// Arrange: seed a template whose script body calls MissingHelper().
|
|
// No SharedScript by that name exists in source or (after wipe) in the
|
|
// target, so semantic validation must reject the apply.
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
var t = new Template("BrokenPump") { Description = "broken" };
|
|
t.Scripts.Add(new TemplateScript("init", "var x = MissingHelper();"));
|
|
ctx.Templates.Add(t);
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
var sessionId = await ExportAndLoadAsync();
|
|
await WipeContentAsync();
|
|
|
|
// Act
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var importer = scope.ServiceProvider.GetRequiredService<IBundleImporter>();
|
|
await Assert.ThrowsAsync<SemanticValidationException>(() =>
|
|
importer.ApplyAsync(sessionId,
|
|
new List<ImportResolution> { new("Template", "BrokenPump", ResolutionAction.Add, null) },
|
|
user: "bob"));
|
|
}
|
|
|
|
// Assert — target still wiped (template not committed), AND a
|
|
// BundleImportFailed row exists.
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
Assert.Equal(0, await ctx.Templates.CountAsync());
|
|
Assert.True(await ctx.AuditLogEntries.AnyAsync(a => a.Action == "BundleImportFailed"));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ApplyAsync_writes_BundleImportId_on_every_emitted_audit_row()
|
|
{
|
|
// The correlation guarantee — every per-entity audit row emitted during
|
|
// ApplyAsync must carry the same BundleImportId as the returned result.
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
ctx.SharedScripts.Add(new SharedScript("HelperFn", "return 1;"));
|
|
ctx.Templates.Add(new Template("Pump") { Description = "fresh" });
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
var sessionId = await ExportAndLoadAsync();
|
|
await WipeContentAsync();
|
|
// Snapshot the audit-row ids before the apply so the assertion only
|
|
// looks at rows the apply itself emitted (the export wrote a
|
|
// BundleExported row too, with no BundleImportId — that's correct, it
|
|
// wasn't part of an import).
|
|
int beforeMaxId;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
beforeMaxId = await ctx.AuditLogEntries.MaxAsync(a => (int?)a.Id) ?? 0;
|
|
}
|
|
|
|
// Act
|
|
ImportResult result;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var importer = scope.ServiceProvider.GetRequiredService<IBundleImporter>();
|
|
result = await importer.ApplyAsync(sessionId,
|
|
new List<ImportResolution>
|
|
{
|
|
new("Template", "Pump", ResolutionAction.Add, null),
|
|
new("SharedScript", "HelperFn", ResolutionAction.Add, null),
|
|
},
|
|
user: "bob");
|
|
}
|
|
|
|
// Assert
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
var newRows = await ctx.AuditLogEntries.Where(a => a.Id > beforeMaxId).ToListAsync();
|
|
// We expect at least: TemplateCreated + SharedScriptCreated + BundleImported.
|
|
Assert.True(newRows.Count >= 3,
|
|
$"Expected at least 3 new audit rows, got {newRows.Count}.");
|
|
Assert.All(newRows, row =>
|
|
Assert.Equal(result.BundleImportId, row.BundleImportId));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ApplyAsync_writes_BundleImported_summary_row_inside_transaction()
|
|
{
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
ctx.Templates.Add(new Template("Pump") { Description = "fresh" });
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
var sessionId = await ExportAndLoadAsync();
|
|
await WipeContentAsync();
|
|
|
|
// Act
|
|
ImportResult result;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var importer = scope.ServiceProvider.GetRequiredService<IBundleImporter>();
|
|
result = await importer.ApplyAsync(sessionId,
|
|
new List<ImportResolution> { new("Template", "Pump", ResolutionAction.Add, null) },
|
|
user: "bob");
|
|
}
|
|
|
|
// Assert: BundleImported row exists, has the right SourceEnvironment in
|
|
// its AfterStateJson, and carries the BundleImportId from the result.
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
var row = await ctx.AuditLogEntries.SingleOrDefaultAsync(a => a.Action == "BundleImported");
|
|
Assert.NotNull(row);
|
|
Assert.Equal("Bundle", row!.EntityType);
|
|
Assert.Equal(result.BundleImportId, row.BundleImportId);
|
|
Assert.NotNull(row.AfterStateJson);
|
|
Assert.Contains("dev", row.AfterStateJson!, StringComparison.Ordinal);
|
|
// Summary block in payload.
|
|
Assert.Contains("Summary", row.AfterStateJson!, StringComparison.Ordinal);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ApplyAsync_writes_BundleImportFailed_outside_rolled_back_transaction()
|
|
{
|
|
// Paired with the rollback test — the failure row IS present even
|
|
// though every other write was rolled back, AND it carries
|
|
// BundleImportId == null (the rolled-back id is intentionally
|
|
// disowned from the failure record).
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
var t = new Template("BrokenPump") { Description = "broken" };
|
|
t.Scripts.Add(new TemplateScript("init", "var x = MissingHelper();"));
|
|
ctx.Templates.Add(t);
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
var sessionId = await ExportAndLoadAsync();
|
|
await WipeContentAsync();
|
|
|
|
// Act
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var importer = scope.ServiceProvider.GetRequiredService<IBundleImporter>();
|
|
await Assert.ThrowsAsync<SemanticValidationException>(() =>
|
|
importer.ApplyAsync(sessionId,
|
|
new List<ImportResolution> { new("Template", "BrokenPump", ResolutionAction.Add, null) },
|
|
user: "bob"));
|
|
}
|
|
|
|
// Assert
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaLinkDbContext>();
|
|
var row = await ctx.AuditLogEntries.SingleOrDefaultAsync(a => a.Action == "BundleImportFailed");
|
|
Assert.NotNull(row);
|
|
Assert.Equal("Bundle", row!.EntityType);
|
|
// Correlation MUST be null on the failure row — the rolled-back
|
|
// BundleImportId is intentionally disowned.
|
|
Assert.Null(row.BundleImportId);
|
|
}
|
|
}
|
|
}
|