Joseph Doherty
7848a3fe7c
- Preview matches template folders, shared scripts, external systems, SMTP (by Host) and SMS (by AccountSid) with the #93 ToNameLookup comparer (OrdinalIgnoreCase, first wins, never throws), matching SQL Server's case-insensitive collation, so a differently-cased target row is reported as a conflict instead of New. - Apply-side in-memory lookups do the same: ApplyTemplateFoldersAsync, the template folder-id map, ResolveFolderParentEdgesAsync, ApplySmtpConfigsAsync and ApplySmsConfigsAsync. An Overwrite now updates the existing row instead of adding a duplicate (folder names are only unique per parent, so the old ToDictionary could also throw). - New ITemplateEngineRepository.GetBaseTemplatesWithChildrenAsync filters IsDerived in SQL. Preview and the Overwrite load in ApplyTemplatesAsync use it, so a derived slot template that shares a bundled name is never the import target. GetTemplatesWithChildrenAsync is unchanged for the id-keyed callers (export closure, rewire passes), which can need derived rows. Claude-Session: https://claude.ai/code/session_01GT67AEHd2Acv1YPwGfXEoV
334 lines
16 KiB
C#
334 lines
16 KiB
C#
using System.Collections.Concurrent;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.EntityFrameworkCore.Diagnostics;
|
|
using Microsoft.Extensions.Configuration;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Entities.ExternalSystems;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Entities.InboundApi;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Notifications;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Scripts;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Services;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Transport;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Types.Templates;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Types.Transport;
|
|
using ZB.MOM.WW.ScadaBridge.ConfigurationDatabase;
|
|
using ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Repositories;
|
|
using ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Services;
|
|
using ZB.MOM.WW.ScadaBridge.Transport.Import;
|
|
|
|
namespace ZB.MOM.WW.ScadaBridge.Transport.IntegrationTests.Import;
|
|
|
|
/// <summary>
|
|
/// ScadaBridge#93: preview looked database connections, notification lists and API
|
|
/// methods up one name at a time, and re-keyed template by-name results with an
|
|
/// ordinal comparer although SQL Server matches names case-insensitively.
|
|
/// </summary>
|
|
public sealed class ImportNameLookupTests : IDisposable
|
|
{
|
|
private readonly ServiceProvider _provider;
|
|
private readonly ConcurrentDictionary<string, int> _calls = new(StringComparer.Ordinal);
|
|
|
|
/// <summary>Initializes the test class with counting repositories over an in-memory database.</summary>
|
|
public ImportNameLookupTests()
|
|
{
|
|
var services = new ServiceCollection();
|
|
services.AddSingleton<Microsoft.AspNetCore.DataProtection.IDataProtectionProvider>(
|
|
new Microsoft.AspNetCore.DataProtection.EphemeralDataProtectionProvider());
|
|
services.AddSingleton<IConfiguration>(new ConfigurationBuilder().AddInMemoryCollection().Build());
|
|
var dbName = $"ImportNameLookupTests_{Guid.NewGuid()}";
|
|
services.AddDbContext<ScadaBridgeDbContext>(opts => opts
|
|
.UseInMemoryDatabase(dbName)
|
|
.ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning)));
|
|
services.AddSingleton<ITemplateGraphWatermark, TemplateGraphWatermark>();
|
|
services.AddScoped<ITemplateEngineRepository, TemplateEngineRepository>();
|
|
services.AddScoped<IExternalSystemRepository>(sp =>
|
|
ImportRoundTripBudgetTests.CountingProxy<IExternalSystemRepository>.Wrap(
|
|
new ExternalSystemRepository(sp.GetRequiredService<ScadaBridgeDbContext>()), _calls));
|
|
services.AddScoped<INotificationRepository>(sp =>
|
|
ImportRoundTripBudgetTests.CountingProxy<INotificationRepository>.Wrap(
|
|
new NotificationRepository(sp.GetRequiredService<ScadaBridgeDbContext>()), _calls));
|
|
services.AddScoped<IInboundApiRepository>(sp =>
|
|
ImportRoundTripBudgetTests.CountingProxy<IInboundApiRepository>.Wrap(
|
|
new InboundApiRepository(sp.GetRequiredService<ScadaBridgeDbContext>()), _calls));
|
|
services.AddScoped<ISiteRepository, SiteRepository>();
|
|
services.AddScoped<IAuditCorrelationContext, AuditCorrelationContext>();
|
|
services.AddScoped<IAuditService, AuditService>();
|
|
services.AddTransport();
|
|
_provider = services.BuildServiceProvider();
|
|
}
|
|
|
|
/// <summary>Releases the resources used by this instance.</summary>
|
|
public void Dispose() => _provider.Dispose();
|
|
|
|
private int Calls(string method) => _calls.TryGetValue(method, out var n) ? n : 0;
|
|
|
|
/// <summary>
|
|
/// Preview of a bundle with several database connections, notification lists and
|
|
/// API methods must read each library once (no per-name query) and must match the
|
|
/// target's rows case-insensitively, as SQL Server's collation does.
|
|
/// </summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task Preview_batches_name_lookups_and_matches_case_insensitively()
|
|
{
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
for (var i = 0; i < 4; i++)
|
|
{
|
|
ctx.DatabaseConnectionDefinitions.Add(new DatabaseConnectionDefinition($"db-{i}", "Server=s;Database=d;"));
|
|
ctx.NotificationLists.Add(new NotificationList($"list-{i}"));
|
|
ctx.ApiMethods.Add(new ApiMethod($"Method{i}", "return 1;"));
|
|
}
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
|
|
Stream bundle;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
bundle = await scope.ServiceProvider.GetRequiredService<IBundleExporter>().ExportAsync(
|
|
new ExportSelection(
|
|
TemplateIds: Array.Empty<int>(),
|
|
SharedScriptIds: Array.Empty<int>(),
|
|
ExternalSystemIds: Array.Empty<int>(),
|
|
DatabaseConnectionIds: await ctx.DatabaseConnectionDefinitions.Select(x => x.Id).ToListAsync(),
|
|
NotificationListIds: await ctx.NotificationLists.Select(x => x.Id).ToListAsync(),
|
|
SmtpConfigurationIds: Array.Empty<int>(),
|
|
ApiMethodIds: await ctx.ApiMethods.Select(x => x.Id).ToListAsync(),
|
|
IncludeDependencies: false),
|
|
user: "alice", sourceEnvironment: "dev", passphrase: null,
|
|
cancellationToken: CancellationToken.None);
|
|
}
|
|
|
|
Guid sessionId;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
sessionId = (await scope.ServiceProvider.GetRequiredService<IBundleImporter>()
|
|
.LoadAsync(bundle, passphrase: null)).SessionId;
|
|
}
|
|
|
|
// The target environment spells two of the names with different casing; the
|
|
// production collation treats them as the SAME row.
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
(await ctx.DatabaseConnectionDefinitions.SingleAsync(x => x.Name == "db-1")).Name = "DB-1";
|
|
(await ctx.NotificationLists.SingleAsync(x => x.Name == "list-2")).Name = "LIST-2";
|
|
(await ctx.ApiMethods.SingleAsync(x => x.Name == "Method3")).Name = "METHOD3";
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
_calls.Clear();
|
|
|
|
ImportPreview preview;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
preview = await scope.ServiceProvider.GetRequiredService<IBundleImporter>().PreviewAsync(sessionId);
|
|
}
|
|
|
|
Assert.Equal(0, Calls(nameof(IExternalSystemRepository.GetDatabaseConnectionByNameAsync)));
|
|
Assert.Equal(0, Calls(nameof(INotificationRepository.GetListByNameAsync)));
|
|
Assert.Equal(0, Calls(nameof(IInboundApiRepository.GetMethodByNameAsync)));
|
|
Assert.Equal(1, Calls(nameof(IExternalSystemRepository.GetAllDatabaseConnectionsAsync)));
|
|
Assert.Equal(1, Calls(nameof(INotificationRepository.GetAllNotificationListsAsync)));
|
|
Assert.Equal(1, Calls(nameof(IInboundApiRepository.GetAllApiMethodsAsync)));
|
|
|
|
foreach (var item in preview.Items.Where(i =>
|
|
i.EntityType is "DatabaseConnection" or "NotificationList" or "ApiMethod"))
|
|
{
|
|
Assert.NotEqual(ConflictKind.New, item.Kind);
|
|
}
|
|
Assert.Equal(12, preview.Items.Count(i =>
|
|
i.EntityType is "DatabaseConnection" or "NotificationList" or "ApiMethod"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Two rows whose names differ only in case (possible for derived templates, which
|
|
/// the filtered unique index on Name does not cover) must not throw, and a base
|
|
/// template wins over a derived one.
|
|
/// </summary>
|
|
[Fact]
|
|
public void Template_lookup_tolerates_names_differing_only_in_case()
|
|
{
|
|
var derived = new Template("Pump") { Id = 1, IsDerived = true };
|
|
var other = new Template("pump") { Id = 2, IsDerived = true };
|
|
var baseT = new Template("PUMP") { Id = 3, IsDerived = false };
|
|
|
|
var lookup = BundleImporter.ToTemplateLookup(new[] { derived, other, baseT });
|
|
|
|
Assert.Single(lookup);
|
|
Assert.Same(baseT, lookup["pump"]);
|
|
|
|
var onlyDerived = BundleImporter.ToTemplateLookup(new[] { derived, other });
|
|
Assert.Same(derived, onlyDerived["PUMP"]);
|
|
}
|
|
|
|
/// <summary>A lookup built from by-name rows never throws on duplicate case variants.</summary>
|
|
[Fact]
|
|
public void Name_lookup_is_case_insensitive_and_first_wins()
|
|
{
|
|
var a = new NotificationList("List");
|
|
var b = new NotificationList("LIST");
|
|
var lookup = BundleImporter.ToNameLookup(new[] { a, b }, x => x.Name);
|
|
Assert.Same(a, lookup["list"]);
|
|
}
|
|
// ---- ScadaBridge#95: the remaining libraries + derived templates ------------------
|
|
|
|
private async Task<Guid> ExportAndLoadAsync(Func<ScadaBridgeDbContext, Task<ExportSelection>> select)
|
|
{
|
|
Stream bundle;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
bundle = await scope.ServiceProvider.GetRequiredService<IBundleExporter>().ExportAsync(
|
|
await select(ctx), user: "alice", sourceEnvironment: "dev", passphrase: null,
|
|
cancellationToken: CancellationToken.None);
|
|
}
|
|
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
return (await scope.ServiceProvider.GetRequiredService<IBundleImporter>()
|
|
.LoadAsync(bundle, passphrase: null)).SessionId;
|
|
}
|
|
}
|
|
|
|
private async Task<ImportPreview> PreviewAsync(Guid sessionId)
|
|
{
|
|
await using var scope = _provider.CreateAsyncScope();
|
|
return await scope.ServiceProvider.GetRequiredService<IBundleImporter>().PreviewAsync(sessionId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Folders, shared scripts, external systems, SMTP and SMS configurations whose target
|
|
/// spelling differs only in case are the SAME rows under SQL Server's collation: preview
|
|
/// must report them as conflicts (not New), and an Overwrite must update them in place
|
|
/// instead of adding a second row.
|
|
/// </summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task Preview_and_apply_match_the_remaining_libraries_case_insensitively()
|
|
{
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
var folder = new TemplateFolder("pumps");
|
|
ctx.TemplateFolders.Add(folder);
|
|
await ctx.SaveChangesAsync();
|
|
ctx.Templates.Add(new Template("Pump") { FolderId = folder.Id });
|
|
ctx.SharedScripts.Add(new SharedScript("Helper", "return 1;"));
|
|
ctx.ExternalSystemDefinitions.Add(new ExternalSystemDefinition("Erp", "http://erp", "None"));
|
|
ctx.SmtpConfigurations.Add(new SmtpConfiguration("mail.local", "None", "a@b.c"));
|
|
ctx.SmsConfigurations.Add(new SmsConfiguration("AC123"));
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
|
|
var sessionId = await ExportAndLoadAsync(async ctx => new ExportSelection(
|
|
TemplateIds: await ctx.Templates.Select(x => x.Id).ToListAsync(),
|
|
SharedScriptIds: await ctx.SharedScripts.Select(x => x.Id).ToListAsync(),
|
|
ExternalSystemIds: await ctx.ExternalSystemDefinitions.Select(x => x.Id).ToListAsync(),
|
|
DatabaseConnectionIds: Array.Empty<int>(),
|
|
NotificationListIds: Array.Empty<int>(),
|
|
SmtpConfigurationIds: await ctx.SmtpConfigurations.Select(x => x.Id).ToListAsync(),
|
|
ApiMethodIds: Array.Empty<int>(),
|
|
IncludeDependencies: false,
|
|
SmsConfigurationIds: await ctx.SmsConfigurations.Select(x => x.Id).ToListAsync()));
|
|
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
(await ctx.TemplateFolders.SingleAsync()).Name = "PUMPS";
|
|
(await ctx.SharedScripts.SingleAsync()).Name = "HELPER";
|
|
(await ctx.ExternalSystemDefinitions.SingleAsync()).Name = "ERP";
|
|
(await ctx.SmtpConfigurations.SingleAsync()).Host = "MAIL.LOCAL";
|
|
(await ctx.SmsConfigurations.SingleAsync()).AccountSid = "ac123";
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
|
|
var preview = await PreviewAsync(sessionId);
|
|
string[] types = ["TemplateFolder", "SharedScript", "ExternalSystem", "SmtpConfiguration", "SmsConfiguration"];
|
|
foreach (var type in types)
|
|
{
|
|
var item = Assert.Single(preview.Items, i => i.EntityType == type);
|
|
Assert.NotEqual(ConflictKind.New, item.Kind);
|
|
}
|
|
|
|
var resolutions = preview.Items
|
|
.Where(i => i.EntityType is "TemplateFolder" or "SmtpConfiguration" or "SmsConfiguration")
|
|
.Select(i => new ImportResolution(i.EntityType, i.Name, ResolutionAction.Overwrite, null))
|
|
.Concat(preview.Items
|
|
.Where(i => i.EntityType is not ("TemplateFolder" or "SmtpConfiguration" or "SmsConfiguration"))
|
|
.Select(i => new ImportResolution(i.EntityType, i.Name, ResolutionAction.Skip, null)))
|
|
.ToList();
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
await scope.ServiceProvider.GetRequiredService<IBundleImporter>()
|
|
.ApplyAsync(sessionId, resolutions, user: "bob");
|
|
}
|
|
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
Assert.Equal(1, await ctx.TemplateFolders.CountAsync());
|
|
Assert.Equal(1, await ctx.SmtpConfigurations.CountAsync());
|
|
Assert.Equal(1, await ctx.SmsConfigurations.CountAsync());
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A derived template carries its composition slot name; a bundled template of that name
|
|
/// targets a BASE template, so a target whose only row of that name is derived must see
|
|
/// the bundled template as New, and applying it must add a base template rather than
|
|
/// overwrite the derived one.
|
|
/// </summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task A_derived_template_sharing_the_bundled_name_is_not_the_import_target()
|
|
{
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
ctx.Templates.Add(new Template("Motor"));
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
|
|
var sessionId = await ExportAndLoadAsync(async ctx => new ExportSelection(
|
|
TemplateIds: await ctx.Templates.Select(x => x.Id).ToListAsync(),
|
|
SharedScriptIds: Array.Empty<int>(),
|
|
ExternalSystemIds: Array.Empty<int>(),
|
|
DatabaseConnectionIds: Array.Empty<int>(),
|
|
NotificationListIds: Array.Empty<int>(),
|
|
SmtpConfigurationIds: Array.Empty<int>(),
|
|
ApiMethodIds: Array.Empty<int>(),
|
|
IncludeDependencies: false));
|
|
|
|
// The target's only "Motor" is a derived slot template.
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
(await ctx.Templates.SingleAsync()).IsDerived = true;
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
|
|
var preview = await PreviewAsync(sessionId);
|
|
Assert.Equal(ConflictKind.New, Assert.Single(preview.Items, i => i.EntityType == "Template").Kind);
|
|
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
await scope.ServiceProvider.GetRequiredService<IBundleImporter>().ApplyAsync(
|
|
sessionId,
|
|
[new ImportResolution("Template", "Motor", ResolutionAction.Overwrite, null)],
|
|
user: "bob");
|
|
}
|
|
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
var motors = await ctx.Templates.Where(t => t.Name == "Motor").ToListAsync();
|
|
Assert.Equal(2, motors.Count);
|
|
Assert.Single(motors, t => !t.IsDerived);
|
|
}
|
|
}
|
|
}
|