Joseph Doherty
927 lines
44 KiB
C#
927 lines
44 KiB
C#
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.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.Enums;
|
|
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;
|
|
using ZB.MOM.WW.ScadaBridge.Transport.Import;
|
|
using ZB.MOM.WW.ScadaBridge.Transport.Serialization;
|
|
|
|
namespace ZB.MOM.WW.ScadaBridge.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<ScadaBridgeDbContext>(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<ScadaBridgeDbContext>();
|
|
var templateIds = await ctx.Templates.Select(t => t.Id).ToListAsync();
|
|
var sharedScriptIds = await ctx.SharedScripts.Select(s => s.Id).ToListAsync();
|
|
var externalSystemIds = await ctx.ExternalSystemDefinitions.Select(e => e.Id).ToListAsync();
|
|
var selection = new ExportSelection(
|
|
TemplateIds: templateIds,
|
|
SharedScriptIds: sharedScriptIds,
|
|
ExternalSystemIds: externalSystemIds,
|
|
DatabaseConnectionIds: Array.Empty<int>(),
|
|
NotificationListIds: Array.Empty<int>(),
|
|
SmtpConfigurationIds: 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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
// 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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
Assert.Equal(0, await ctx.Templates.CountAsync());
|
|
Assert.True(await ctx.AuditLogEntries.AnyAsync(a => a.Action == "BundleImportFailed"));
|
|
}
|
|
|
|
// T-007: a failed apply used to keep the BundleSession (and its decrypted
|
|
// secrets) in the in-memory store for the full 30-minute TTL. The session
|
|
// must now be removed immediately so the plaintext is released.
|
|
var sessionStore = _provider.GetRequiredService<IBundleSessionStore>();
|
|
Assert.Null(sessionStore.Get(sessionId));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ApplyAsync_removes_session_on_success_path_too()
|
|
{
|
|
// T-007: companion to the failed-apply test — the success path must also
|
|
// remove the session (it was already doing so before T-007, but the new
|
|
// test asserts the contract explicitly so a future refactor cannot
|
|
// accidentally leave plaintext in the store).
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
ctx.Templates.Add(new Template("PumpForT007") { Description = "fresh" });
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
var sessionId = await ExportAndLoadAsync();
|
|
await WipeContentAsync();
|
|
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var importer = scope.ServiceProvider.GetRequiredService<IBundleImporter>();
|
|
await importer.ApplyAsync(sessionId,
|
|
new List<ImportResolution> { new("Template", "PumpForT007", ResolutionAction.Add, null) },
|
|
user: "alice");
|
|
}
|
|
|
|
var sessionStore = _provider.GetRequiredService<IBundleSessionStore>();
|
|
Assert.Null(sessionStore.Get(sessionId));
|
|
}
|
|
|
|
[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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
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<ScadaBridgeDbContext>();
|
|
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);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ApplyAsync_Overwrite_synchronises_attributes_alarms_and_scripts_to_bundle()
|
|
{
|
|
// T-001 regression. The Overwrite branch used to write only Description
|
|
// / FolderId on the existing template; the bundle's Attributes / Alarms
|
|
// / Scripts collections were silently dropped on the floor. This test
|
|
// seeds a template with one shape, exports it, mutates the target to a
|
|
// divergent shape, then asserts that Overwrite restores every child
|
|
// collection AND emits per-field audit rows.
|
|
//
|
|
// Bundle shape (exported from "Pump"):
|
|
// Attributes: [SetPoint (Float, 50.0), Pressure (Float, 100.0)]
|
|
// Alarms: [HiAlarm (PriorityLevel=1)]
|
|
// Scripts: [Init (Code="return 1;")]
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
var t = new Template("Pump") { Description = "from-bundle" };
|
|
t.Attributes.Add(new TemplateAttribute("SetPoint") { DataType = DataType.Float, Value = "50.0" });
|
|
t.Attributes.Add(new TemplateAttribute("Pressure") { DataType = DataType.Float, Value = "100.0" });
|
|
t.Alarms.Add(new TemplateAlarm("HiAlarm") { PriorityLevel = 1, TriggerType = AlarmTriggerType.ValueMatch });
|
|
t.Scripts.Add(new TemplateScript("Init", "return 1;"));
|
|
ctx.Templates.Add(t);
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
|
|
var sessionId = await ExportAndLoadAsync();
|
|
|
|
// Mutate the target so every child collection diverges from the bundle.
|
|
// Attributes: SetPoint value mutated, Pressure DELETED, NewAttr ADDED
|
|
// Alarms: HiAlarm PriorityLevel mutated, ExtraAlarm ADDED
|
|
// Scripts: Init code mutated, ExtraScript ADDED
|
|
// Description also mutated so the scalar field still flips.
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
var pump = await ctx.Templates
|
|
.Include(t => t.Attributes)
|
|
.Include(t => t.Alarms)
|
|
.Include(t => t.Scripts)
|
|
.SingleAsync(t => t.Name == "Pump");
|
|
pump.Description = "target-mutated";
|
|
var setPoint = pump.Attributes.Single(a => a.Name == "SetPoint");
|
|
setPoint.Value = "999.0"; // mutated
|
|
var pressure = pump.Attributes.Single(a => a.Name == "Pressure");
|
|
pump.Attributes.Remove(pressure);
|
|
ctx.TemplateAttributes.Remove(pressure);
|
|
pump.Attributes.Add(new TemplateAttribute("NewAttr")
|
|
{
|
|
DataType = DataType.String,
|
|
Value = "should-be-deleted-by-overwrite",
|
|
});
|
|
var hiAlarm = pump.Alarms.Single(a => a.Name == "HiAlarm");
|
|
hiAlarm.PriorityLevel = 99; // mutated
|
|
pump.Alarms.Add(new TemplateAlarm("ExtraAlarm")
|
|
{
|
|
PriorityLevel = 5,
|
|
TriggerType = AlarmTriggerType.RangeViolation,
|
|
});
|
|
var initScript = pump.Scripts.Single(s => s.Name == "Init");
|
|
initScript.Code = "return 999;"; // mutated
|
|
pump.Scripts.Add(new TemplateScript("ExtraScript", "return 0;"));
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
|
|
// Capture the audit baseline so we can scope assertions to rows
|
|
// emitted by THIS apply.
|
|
int beforeMaxAuditId;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
beforeMaxAuditId = await ctx.AuditLogEntries.MaxAsync(a => (int?)a.Id) ?? 0;
|
|
}
|
|
|
|
// Act — apply Overwrite.
|
|
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 — children mirror the bundle.
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
var pump = await ctx.Templates
|
|
.Include(t => t.Attributes)
|
|
.Include(t => t.Alarms)
|
|
.Include(t => t.Scripts)
|
|
.SingleAsync(t => t.Name == "Pump");
|
|
|
|
Assert.Equal("from-bundle", pump.Description);
|
|
|
|
// Attributes — exactly { SetPoint, Pressure }, values restored.
|
|
Assert.Equal(2, pump.Attributes.Count);
|
|
var setPoint = pump.Attributes.Single(a => a.Name == "SetPoint");
|
|
Assert.Equal("50.0", setPoint.Value);
|
|
Assert.Equal(DataType.Float, setPoint.DataType);
|
|
var pressure = pump.Attributes.Single(a => a.Name == "Pressure");
|
|
Assert.Equal("100.0", pressure.Value);
|
|
Assert.DoesNotContain(pump.Attributes, a => a.Name == "NewAttr");
|
|
|
|
// Alarms — exactly { HiAlarm }, PriorityLevel restored.
|
|
Assert.Single(pump.Alarms);
|
|
var hi = pump.Alarms.Single();
|
|
Assert.Equal("HiAlarm", hi.Name);
|
|
Assert.Equal(1, hi.PriorityLevel);
|
|
Assert.DoesNotContain(pump.Alarms, a => a.Name == "ExtraAlarm");
|
|
|
|
// Scripts — exactly { Init }, code restored.
|
|
Assert.Single(pump.Scripts);
|
|
var init = pump.Scripts.Single();
|
|
Assert.Equal("Init", init.Name);
|
|
Assert.Equal("return 1;", init.Code);
|
|
Assert.DoesNotContain(pump.Scripts, s => s.Name == "ExtraScript");
|
|
|
|
// Per-field audit rows — design doc enumerates Added / Updated /
|
|
// Deleted shapes; all of these should appear, all stamped with
|
|
// the BundleImportId from the result.
|
|
var newRows = await ctx.AuditLogEntries
|
|
.Where(a => a.Id > beforeMaxAuditId)
|
|
.ToListAsync();
|
|
Assert.All(newRows, r => Assert.Equal(result.BundleImportId, r.BundleImportId));
|
|
|
|
// Attribute audit events.
|
|
Assert.Contains(newRows, r => r.Action == "TemplateAttributeUpdated" && r.EntityName == "Pump.SetPoint");
|
|
Assert.Contains(newRows, r => r.Action == "TemplateAttributeAdded" && r.EntityName == "Pump.Pressure");
|
|
Assert.Contains(newRows, r => r.Action == "TemplateAttributeDeleted" && r.EntityName == "Pump.NewAttr");
|
|
|
|
// Alarm audit events.
|
|
Assert.Contains(newRows, r => r.Action == "TemplateAlarmUpdated" && r.EntityName == "Pump.HiAlarm");
|
|
Assert.Contains(newRows, r => r.Action == "TemplateAlarmDeleted" && r.EntityName == "Pump.ExtraAlarm");
|
|
|
|
// Script audit events.
|
|
Assert.Contains(newRows, r => r.Action == "TemplateScriptUpdated" && r.EntityName == "Pump.Init");
|
|
Assert.Contains(newRows, r => r.Action == "TemplateScriptDeleted" && r.EntityName == "Pump.ExtraScript");
|
|
}
|
|
Assert.Equal(1, result.Overwritten);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ApplyAsync_Overwrite_synchronises_external_system_methods_to_bundle()
|
|
{
|
|
// T-002 regression. The ExternalSystem Overwrite branch used to write
|
|
// only EndpointUrl / AuthType / AuthConfiguration on the existing
|
|
// definition; the bundle's Methods collection was silently dropped on
|
|
// the floor. This test seeds an external system with one method
|
|
// shape, exports it, mutates the target's methods to diverge, then
|
|
// asserts that Overwrite restores every method AND emits per-field
|
|
// audit rows.
|
|
//
|
|
// Bundle shape (exported from "Erp"):
|
|
// Methods: [
|
|
// GetUser (GET /users/{id}, param=A, return=R),
|
|
// PostJob (POST /jobs, param=B, return=S),
|
|
// ]
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
var sys = new ExternalSystemDefinition("Erp", "https://erp.example", "ApiKey");
|
|
ctx.ExternalSystemDefinitions.Add(sys);
|
|
await ctx.SaveChangesAsync();
|
|
ctx.ExternalSystemMethods.Add(new ExternalSystemMethod("GetUser", "GET", "/users/{id}")
|
|
{
|
|
ExternalSystemDefinitionId = sys.Id,
|
|
ParameterDefinitions = "A",
|
|
ReturnDefinition = "R",
|
|
});
|
|
ctx.ExternalSystemMethods.Add(new ExternalSystemMethod("PostJob", "POST", "/jobs")
|
|
{
|
|
ExternalSystemDefinitionId = sys.Id,
|
|
ParameterDefinitions = "B",
|
|
ReturnDefinition = "S",
|
|
});
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
|
|
var sessionId = await ExportAndLoadAsync();
|
|
|
|
// Mutate the target so the methods diverge from the bundle:
|
|
// GetUser — Path mutated (UPDATE expected on Overwrite)
|
|
// PostJob — DELETED (ADD expected on Overwrite to restore)
|
|
// ExtraOp — ADDED (DELETE expected on Overwrite to remove)
|
|
// EndpointUrl / AuthType also mutated so the scalar update still fires.
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
var sys = await ctx.ExternalSystemDefinitions.SingleAsync(e => e.Name == "Erp");
|
|
sys.EndpointUrl = "https://wrong.example";
|
|
sys.AuthType = "Basic";
|
|
var getUser = await ctx.ExternalSystemMethods
|
|
.SingleAsync(m => m.ExternalSystemDefinitionId == sys.Id && m.Name == "GetUser");
|
|
getUser.Path = "/wrong/path";
|
|
var postJob = await ctx.ExternalSystemMethods
|
|
.SingleAsync(m => m.ExternalSystemDefinitionId == sys.Id && m.Name == "PostJob");
|
|
ctx.ExternalSystemMethods.Remove(postJob);
|
|
ctx.ExternalSystemMethods.Add(new ExternalSystemMethod("ExtraOp", "DELETE", "/extra")
|
|
{
|
|
ExternalSystemDefinitionId = sys.Id,
|
|
ParameterDefinitions = "X",
|
|
ReturnDefinition = "Y",
|
|
});
|
|
await ctx.SaveChangesAsync();
|
|
}
|
|
|
|
// Capture the audit baseline so we can scope assertions to rows
|
|
// emitted by THIS apply.
|
|
int beforeMaxAuditId;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
beforeMaxAuditId = await ctx.AuditLogEntries.MaxAsync(a => (int?)a.Id) ?? 0;
|
|
}
|
|
|
|
// Act — apply Overwrite on the external system.
|
|
ImportResult result;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var importer = scope.ServiceProvider.GetRequiredService<IBundleImporter>();
|
|
result = await importer.ApplyAsync(sessionId,
|
|
new List<ImportResolution> { new("ExternalSystem", "Erp", ResolutionAction.Overwrite, null) },
|
|
user: "bob");
|
|
}
|
|
|
|
// Assert — methods mirror the bundle exactly.
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var ctx = scope.ServiceProvider.GetRequiredService<ScadaBridgeDbContext>();
|
|
var sys = await ctx.ExternalSystemDefinitions.SingleAsync(e => e.Name == "Erp");
|
|
Assert.Equal("https://erp.example", sys.EndpointUrl);
|
|
|
|
var methods = await ctx.ExternalSystemMethods
|
|
.Where(m => m.ExternalSystemDefinitionId == sys.Id)
|
|
.ToListAsync();
|
|
Assert.Equal(2, methods.Count);
|
|
|
|
var getUser = methods.Single(m => m.Name == "GetUser");
|
|
Assert.Equal("GET", getUser.HttpMethod);
|
|
Assert.Equal("/users/{id}", getUser.Path);
|
|
Assert.Equal("A", getUser.ParameterDefinitions);
|
|
Assert.Equal("R", getUser.ReturnDefinition);
|
|
|
|
var postJob = methods.Single(m => m.Name == "PostJob");
|
|
Assert.Equal("POST", postJob.HttpMethod);
|
|
Assert.Equal("/jobs", postJob.Path);
|
|
Assert.Equal("B", postJob.ParameterDefinitions);
|
|
Assert.Equal("S", postJob.ReturnDefinition);
|
|
|
|
Assert.DoesNotContain(methods, m => m.Name == "ExtraOp");
|
|
|
|
// Per-field audit rows — design doc enumerates Added / Updated /
|
|
// Deleted shapes; all of these should appear, all stamped with
|
|
// the BundleImportId from the result.
|
|
var newRows = await ctx.AuditLogEntries
|
|
.Where(a => a.Id > beforeMaxAuditId)
|
|
.ToListAsync();
|
|
Assert.All(newRows, r => Assert.Equal(result.BundleImportId, r.BundleImportId));
|
|
|
|
Assert.Contains(newRows, r => r.Action == "ExternalSystemMethodUpdated" && r.EntityName == "Erp.GetUser");
|
|
Assert.Contains(newRows, r => r.Action == "ExternalSystemMethodAdded" && r.EntityName == "Erp.PostJob");
|
|
Assert.Contains(newRows, r => r.Action == "ExternalSystemMethodDeleted" && r.EntityName == "Erp.ExtraOp");
|
|
}
|
|
Assert.Equal(1, result.Overwritten);
|
|
}
|
|
|
|
// ─────────────────────────────────────────────────────────────────────
|
|
// Re-arch C4 backward-compat: a LEGACY (pre-C4) bundle still carries an
|
|
// ApiKeys section. The importer must ignore those keys gracefully — it must
|
|
// NOT fail to parse, must NOT create any ApiKey rows, and must surface the
|
|
// ignored-key count on the result (so the operator knows to re-issue keys).
|
|
// ─────────────────────────────────────────────────────────────────────
|
|
[Fact]
|
|
public async Task ApplyAsync_ignores_legacy_api_keys_in_bundle_without_failing()
|
|
{
|
|
// Arrange: hand-pack a legacy bundle whose content JSON contains an
|
|
// ApiKeys array plus one API method. New exports never emit ApiKeys, so
|
|
// we build the BundleContentDto directly with a populated (non-null)
|
|
// legacy ApiKeys list to faithfully simulate a pre-C4 file.
|
|
var legacyContent = new BundleContentDto(
|
|
TemplateFolders: Array.Empty<TemplateFolderDto>(),
|
|
Templates: Array.Empty<TemplateDto>(),
|
|
SharedScripts: Array.Empty<SharedScriptDto>(),
|
|
ExternalSystems: Array.Empty<ExternalSystemDto>(),
|
|
DatabaseConnections: Array.Empty<DatabaseConnectionDto>(),
|
|
NotificationLists: Array.Empty<NotificationListDto>(),
|
|
SmtpConfigs: Array.Empty<SmtpConfigDto>(),
|
|
ApiMethods: new[]
|
|
{
|
|
new ApiMethodDto("CreateOrder", "return 1;",
|
|
ParameterDefinitions: null, ReturnDefinition: null, TimeoutSeconds: 30),
|
|
},
|
|
ApiKeys: new[]
|
|
{
|
|
new ApiKeyDto("legacy-key-a", "hash-a", IsEnabled: true, Secrets: null),
|
|
new ApiKeyDto("legacy-key-b", "hash-b", IsEnabled: false, Secrets: null),
|
|
});
|
|
|
|
Guid sessionId;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var serializer = scope.ServiceProvider.GetRequiredService<BundleSerializer>();
|
|
var manifestBuilder = scope.ServiceProvider.GetRequiredService<ManifestBuilder>();
|
|
var importer = scope.ServiceProvider.GetRequiredService<IBundleImporter>();
|
|
|
|
var contentBytes = serializer.SerializeContentBytes(legacyContent);
|
|
|
|
// Sanity: the packed content really does carry an ApiKeys section, so
|
|
// the test is exercising the legacy-ignore path rather than a no-op.
|
|
var contentJson = System.Text.Encoding.UTF8.GetString(contentBytes);
|
|
Assert.Contains("legacy-key-a", contentJson);
|
|
|
|
var manifest = manifestBuilder.Build(
|
|
sourceEnvironment: "legacy-env",
|
|
exportedBy: "alice",
|
|
scadaBridgeVersion: "0.9.0",
|
|
encryption: null,
|
|
summary: new BundleSummary(0, 0, 0, 0, 0, 0, 0, 1),
|
|
contents: Array.Empty<ManifestContentEntry>(),
|
|
contentBytes: contentBytes);
|
|
await using var packed = serializer.Pack(legacyContent, manifest, passphrase: null, encryptor: null);
|
|
|
|
using var ms = new MemoryStream();
|
|
await packed.CopyToAsync(ms);
|
|
ms.Position = 0;
|
|
var session = await importer.LoadAsync(ms, passphrase: null);
|
|
sessionId = session.SessionId;
|
|
}
|
|
|
|
// Act — apply with a resolution only for the method; the keys carry no
|
|
// resolutions (the preview never surfaces them) and must be ignored.
|
|
ImportResult result;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var importer = scope.ServiceProvider.GetRequiredService<IBundleImporter>();
|
|
result = await importer.ApplyAsync(sessionId,
|
|
new List<ImportResolution> { new("ApiMethod", "CreateOrder", ResolutionAction.Add, null) },
|
|
user: "bob");
|
|
}
|
|
|
|
// Assert — the method WAS created, the ignored count is surfaced, and the
|
|
// import did not fault. Auth re-arch (C5): the SQL Server ApiKey store was
|
|
// retired, so "no keys created" is now structural — the importer has no key
|
|
// sink at all; the legacy ApiKeys section is counted (ApiKeysIgnored) and
|
|
// discarded.
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var inboundRepo = scope.ServiceProvider.GetRequiredService<IInboundApiRepository>();
|
|
var methods = await inboundRepo.GetAllApiMethodsAsync();
|
|
Assert.Single(methods);
|
|
Assert.Equal("CreateOrder", methods[0].Name);
|
|
}
|
|
|
|
Assert.Equal(2, result.ApiKeysIgnored);
|
|
Assert.Equal(1, result.Added); // the API method
|
|
Assert.NotEqual(Guid.Empty, result.BundleImportId);
|
|
}
|
|
|
|
// ─────────────────────────────────────────────────────────────────────
|
|
// Fix I-3: PreviewAsync must also tolerate a legacy bundle that carries
|
|
// an ApiKeys section without surfacing those keys as importable preview
|
|
// rows. Mirror the ApplyAsync_ignores_legacy_api_keys_in_bundle_without_failing
|
|
// setup: hand-pack a legacy bundle with a populated ApiKeys section plus
|
|
// one ApiMethod, then assert that PreviewAsync completes without fault,
|
|
// surfaces no ApiKey/key preview items, and DOES surface the ApiMethod
|
|
// preview item.
|
|
// ─────────────────────────────────────────────────────────────────────
|
|
[Fact]
|
|
public async Task PreviewAsync_on_legacy_bundle_does_not_surface_key_items()
|
|
{
|
|
// Arrange: hand-pack a legacy bundle whose content JSON contains an
|
|
// ApiKeys array plus one API method. New exports never emit ApiKeys,
|
|
// so we build the BundleContentDto directly with a populated (non-null)
|
|
// legacy ApiKeys list to faithfully simulate a pre-C4 file.
|
|
var legacyContent = new BundleContentDto(
|
|
TemplateFolders: Array.Empty<TemplateFolderDto>(),
|
|
Templates: Array.Empty<TemplateDto>(),
|
|
SharedScripts: Array.Empty<SharedScriptDto>(),
|
|
ExternalSystems: Array.Empty<ExternalSystemDto>(),
|
|
DatabaseConnections: Array.Empty<DatabaseConnectionDto>(),
|
|
NotificationLists: Array.Empty<NotificationListDto>(),
|
|
SmtpConfigs: Array.Empty<SmtpConfigDto>(),
|
|
ApiMethods: new[]
|
|
{
|
|
new ApiMethodDto("GetStatus", "return 0;",
|
|
ParameterDefinitions: null, ReturnDefinition: null, TimeoutSeconds: 30),
|
|
},
|
|
ApiKeys: new[]
|
|
{
|
|
new ApiKeyDto("legacy-key-x", "hash-x", IsEnabled: true, Secrets: null),
|
|
});
|
|
|
|
Guid sessionId;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var serializer = scope.ServiceProvider.GetRequiredService<BundleSerializer>();
|
|
var manifestBuilder = scope.ServiceProvider.GetRequiredService<ManifestBuilder>();
|
|
var importer = scope.ServiceProvider.GetRequiredService<IBundleImporter>();
|
|
|
|
var contentBytes = serializer.SerializeContentBytes(legacyContent);
|
|
|
|
// Sanity: the packed content really does carry an ApiKeys section,
|
|
// so the test is exercising the legacy-ignore path rather than a no-op.
|
|
var contentJson = System.Text.Encoding.UTF8.GetString(contentBytes);
|
|
Assert.Contains("legacy-key-x", contentJson);
|
|
|
|
var manifest = manifestBuilder.Build(
|
|
sourceEnvironment: "legacy-env",
|
|
exportedBy: "alice",
|
|
scadaBridgeVersion: "0.9.0",
|
|
encryption: null,
|
|
summary: new BundleSummary(0, 0, 0, 0, 0, 0, 0, 1),
|
|
contents: Array.Empty<ManifestContentEntry>(),
|
|
contentBytes: contentBytes);
|
|
await using var packed = serializer.Pack(legacyContent, manifest, passphrase: null, encryptor: null);
|
|
|
|
using var ms = new MemoryStream();
|
|
await packed.CopyToAsync(ms);
|
|
ms.Position = 0;
|
|
var session = await importer.LoadAsync(ms, passphrase: null);
|
|
sessionId = session.SessionId;
|
|
}
|
|
|
|
// Act — call PreviewAsync; must not throw.
|
|
ImportPreview preview;
|
|
await using (var scope = _provider.CreateAsyncScope())
|
|
{
|
|
var importer = scope.ServiceProvider.GetRequiredService<IBundleImporter>();
|
|
preview = await importer.PreviewAsync(sessionId);
|
|
}
|
|
|
|
// Assert — no ApiKey preview rows surfaced (keys are not transported).
|
|
Assert.DoesNotContain(preview.Items, item =>
|
|
item.EntityType.Contains("Key", StringComparison.OrdinalIgnoreCase) ||
|
|
item.Name.Contains("legacy-key", StringComparison.OrdinalIgnoreCase));
|
|
|
|
// The one ApiMethod IS surfaced as a New item (method does not exist in
|
|
// the target DB, so ConflictKind.New is expected).
|
|
Assert.Contains(preview.Items, item =>
|
|
item.EntityType == "ApiMethod" && item.Name == "GetStatus");
|
|
}
|
|
}
|