Joseph Doherty
429 lines
16 KiB
C#
429 lines
16 KiB
C#
using Microsoft.EntityFrameworkCore;
|
|
using Shouldly;
|
|
using Xunit;
|
|
using ZB.MOM.WW.OtOpcUa.AdminUI.Uns;
|
|
using ZB.MOM.WW.OtOpcUa.Configuration;
|
|
using ZB.MOM.WW.OtOpcUa.Configuration.Enums;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.AdminUI.Tests.Uns;
|
|
|
|
/// <summary>
|
|
/// Covers the B2 Wave-B service prelude added to <see cref="RawTreeService"/> — the tag CRUD/import path
|
|
/// (WP4 manual entry + WP5 CSV import) and the driver/device config + merged-probe projections (WP3
|
|
/// modals). Reuses the shared <see cref="RawTreeTestDb"/> InMemory fixture.
|
|
/// <para>
|
|
/// As with the WP1 suite, the EF InMemory provider does not enforce <c>RowVersion</c> tokens, so the
|
|
/// optimistic-concurrency failure is exercised via the "row vanished under a stale handle" path.
|
|
/// </para>
|
|
/// </summary>
|
|
[Trait("Category", "Unit")]
|
|
public sealed class RawTreeServiceWaveBTests
|
|
{
|
|
private static (RawTreeService Service, string DbName) Seeded()
|
|
{
|
|
var name = RawTreeTestDb.SeedFresh();
|
|
return (new RawTreeService(RawTreeTestDb.Factory(name)), name);
|
|
}
|
|
|
|
private static byte[] RowVersionOf(string dbName, Func<OtOpcUaConfigDbContext, byte[]> selector)
|
|
{
|
|
using var db = RawTreeTestDb.CreateNamed(dbName);
|
|
return selector(db);
|
|
}
|
|
|
|
private static RawTagInput Tag(string name, string dataType = "Float", string tagConfig = "{}") =>
|
|
new(name, dataType, TagAccessLevel.ReadWrite, WriteIdempotent: false, PollGroupId: null, tagConfig);
|
|
|
|
// -------------------------------------------------------------------------------- CreateTag (WP4)
|
|
|
|
[Fact]
|
|
public async Task CreateTag_under_group_succeeds_and_returns_new_id()
|
|
{
|
|
var (service, dbName) = Seeded();
|
|
|
|
var result = await service.CreateTagAsync(
|
|
RawTreeTestDb.FolderedDeviceId, RawTreeTestDb.RootGroupId, Tag("torque"));
|
|
|
|
result.Ok.ShouldBeTrue();
|
|
result.CreatedId.ShouldNotBeNull();
|
|
|
|
using var db = RawTreeTestDb.CreateNamed(dbName);
|
|
var tag = db.Tags.Single(t => t.TagId == result.CreatedId);
|
|
tag.Name.ShouldBe("torque");
|
|
tag.DeviceId.ShouldBe(RawTreeTestDb.FolderedDeviceId);
|
|
tag.TagGroupId.ShouldBe(RawTreeTestDb.RootGroupId);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CreateTag_collapses_whitespace_pollgroup_to_null()
|
|
{
|
|
var (service, dbName) = Seeded();
|
|
|
|
var result = await service.CreateTagAsync(
|
|
RawTreeTestDb.FolderedDeviceId, null,
|
|
new RawTagInput("flow", "Float", TagAccessLevel.Read, false, " ", "{}"));
|
|
|
|
result.Ok.ShouldBeTrue();
|
|
using var db = RawTreeTestDb.CreateNamed(dbName);
|
|
db.Tags.Single(t => t.TagId == result.CreatedId).PollGroupId.ShouldBeNull();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CreateTag_rejects_sibling_name_collision()
|
|
{
|
|
var (service, _) = Seeded();
|
|
|
|
// "speed" already exists under RootGroup.
|
|
var dup = await service.CreateTagAsync(RawTreeTestDb.FolderedDeviceId, RawTreeTestDb.RootGroupId, Tag("speed"));
|
|
|
|
dup.Ok.ShouldBeFalse();
|
|
dup.Error!.ShouldContain("already exists");
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CreateTag_rejects_malformed_tagconfig_json()
|
|
{
|
|
var (service, _) = Seeded();
|
|
|
|
var bad = await service.CreateTagAsync(
|
|
RawTreeTestDb.FolderedDeviceId, null, Tag("pressure", tagConfig: "{not json"));
|
|
|
|
bad.Ok.ShouldBeFalse();
|
|
bad.Error!.ShouldContain("JSON");
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CreateTag_rejects_invalid_name_segment()
|
|
{
|
|
var (service, _) = Seeded();
|
|
|
|
var bad = await service.CreateTagAsync(RawTreeTestDb.FolderedDeviceId, null, Tag("a/b"));
|
|
|
|
bad.Ok.ShouldBeFalse();
|
|
bad.Error!.ShouldContain("/");
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------- UpdateTag (WP4)
|
|
|
|
[Fact]
|
|
public async Task UpdateTag_edits_fields_last_write_wins()
|
|
{
|
|
var (service, dbName) = Seeded();
|
|
var rv = RowVersionOf(dbName, db => db.Tags.Single(t => t.TagId == RawTreeTestDb.PlainTagId).RowVersion);
|
|
|
|
var result = await service.UpdateTagAsync(
|
|
RawTreeTestDb.PlainTagId,
|
|
new RawTagInput("running", "Boolean", TagAccessLevel.ReadWrite, true, "pg1", "{\"scale\":2}"),
|
|
rv);
|
|
|
|
result.Ok.ShouldBeTrue();
|
|
using var db = RawTreeTestDb.CreateNamed(dbName);
|
|
var tag = db.Tags.Single(t => t.TagId == RawTreeTestDb.PlainTagId);
|
|
tag.Name.ShouldBe("running");
|
|
tag.AccessLevel.ShouldBe(TagAccessLevel.ReadWrite);
|
|
tag.WriteIdempotent.ShouldBeTrue();
|
|
tag.PollGroupId.ShouldBe("pg1");
|
|
tag.TagConfig.ShouldContain("scale");
|
|
// Identity location preserved.
|
|
tag.DeviceId.ShouldBe(RawTreeTestDb.FolderedDeviceId);
|
|
tag.TagGroupId.ShouldBe(RawTreeTestDb.RootGroupId);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task UpdateTag_rejects_rename_collision_excluding_self()
|
|
{
|
|
var (service, dbName) = Seeded();
|
|
// Rename "state" (PlainTag) to "speed" — a sibling under the same group ⇒ collision.
|
|
var rv = RowVersionOf(dbName, db => db.Tags.Single(t => t.TagId == RawTreeTestDb.PlainTagId).RowVersion);
|
|
|
|
var result = await service.UpdateTagAsync(RawTreeTestDb.PlainTagId, Tag("speed"), rv);
|
|
|
|
result.Ok.ShouldBeFalse();
|
|
result.Error!.ShouldContain("already exists");
|
|
}
|
|
|
|
[Fact]
|
|
public async Task UpdateTag_allows_renaming_to_same_name_excluding_self()
|
|
{
|
|
var (service, dbName) = Seeded();
|
|
var rv = RowVersionOf(dbName, db => db.Tags.Single(t => t.TagId == RawTreeTestDb.PlainTagId).RowVersion);
|
|
|
|
// Keeping its own name "state" must not trip the excl-self uniqueness check.
|
|
var result = await service.UpdateTagAsync(RawTreeTestDb.PlainTagId, Tag("state", "Boolean"), rv);
|
|
|
|
result.Ok.ShouldBeTrue();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task UpdateTag_fails_when_row_vanished_concurrently()
|
|
{
|
|
var (service, dbName) = Seeded();
|
|
var rv = RowVersionOf(dbName, db => db.Tags.Single(t => t.TagId == RawTreeTestDb.PlainTagId).RowVersion);
|
|
|
|
using (var db = RawTreeTestDb.CreateNamed(dbName))
|
|
{
|
|
db.Tags.Remove(db.Tags.Single(t => t.TagId == RawTreeTestDb.PlainTagId));
|
|
db.SaveChanges();
|
|
}
|
|
|
|
var result = await service.UpdateTagAsync(RawTreeTestDb.PlainTagId, Tag("whatever", "Boolean"), rv);
|
|
|
|
result.Ok.ShouldBeFalse();
|
|
result.Error.ShouldNotBeNull();
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------ ImportTags (WP5)
|
|
|
|
[Fact]
|
|
public async Task ImportTags_autocreates_nested_groups_and_reuses_them()
|
|
{
|
|
var (service, dbName) = Seeded();
|
|
|
|
var rows = new[]
|
|
{
|
|
new RawTagImportRow("Line/A", Tag("t1")),
|
|
new RawTagImportRow("Line/A", Tag("t2")), // reuses Line + Line/A
|
|
new RawTagImportRow("Line/B", Tag("t3")), // reuses Line, new B
|
|
};
|
|
|
|
var result = await service.ImportTagsAsync(RawTreeTestDb.RootDeviceId, rows);
|
|
|
|
result.Errors.ShouldBeEmpty();
|
|
result.Inserted.ShouldBe(3);
|
|
|
|
using var db = RawTreeTestDb.CreateNamed(dbName);
|
|
var line = db.TagGroups.Single(g => g.DeviceId == RawTreeTestDb.RootDeviceId && g.ParentTagGroupId == null && g.Name == "Line");
|
|
var groupA = db.TagGroups.Single(g => g.ParentTagGroupId == line.TagGroupId && g.Name == "A");
|
|
var groupB = db.TagGroups.Single(g => g.ParentTagGroupId == line.TagGroupId && g.Name == "B");
|
|
db.Tags.Count(t => t.TagGroupId == groupA.TagGroupId).ShouldBe(2); // Line/A reused, not duplicated
|
|
db.Tags.Count(t => t.TagGroupId == groupB.TagGroupId).ShouldBe(1);
|
|
// Exactly one "Line" group created despite three references.
|
|
db.TagGroups.Count(g => g.DeviceId == RawTreeTestDb.RootDeviceId && g.Name == "Line").ShouldBe(1);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ImportTags_places_tag_at_device_root_when_path_blank()
|
|
{
|
|
var (service, dbName) = Seeded();
|
|
|
|
var result = await service.ImportTagsAsync(
|
|
RawTreeTestDb.RootDeviceId, new[] { new RawTagImportRow(null, Tag("rootTag")) });
|
|
|
|
result.Inserted.ShouldBe(1);
|
|
using var db = RawTreeTestDb.CreateNamed(dbName);
|
|
db.Tags.Single(t => t.Name == "rootTag").TagGroupId.ShouldBeNull();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ImportTags_all_or_nothing_on_a_bad_row_inserts_nothing()
|
|
{
|
|
var (service, dbName) = Seeded();
|
|
|
|
var rows = new[]
|
|
{
|
|
new RawTagImportRow("Grp", Tag("good1")),
|
|
new RawTagImportRow("Grp", Tag("bad", tagConfig: "{oops")), // malformed JSON ⇒ error
|
|
new RawTagImportRow("Grp", Tag("good2")),
|
|
};
|
|
|
|
var result = await service.ImportTagsAsync(RawTreeTestDb.RootDeviceId, rows);
|
|
|
|
result.Inserted.ShouldBe(0);
|
|
result.Errors.ShouldNotBeEmpty();
|
|
result.Errors[0].ShouldContain("Row 2");
|
|
|
|
// Nothing committed — not the two good tags, not the auto-created group.
|
|
using var db = RawTreeTestDb.CreateNamed(dbName);
|
|
db.Tags.Any(t => t.Name == "good1" || t.Name == "good2").ShouldBeFalse();
|
|
db.TagGroups.Any(g => g.DeviceId == RawTreeTestDb.RootDeviceId && g.Name == "Grp").ShouldBeFalse();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ImportTags_detects_intra_batch_duplicate()
|
|
{
|
|
var (service, _) = Seeded();
|
|
|
|
var rows = new[]
|
|
{
|
|
new RawTagImportRow("Grp", Tag("dup")),
|
|
new RawTagImportRow("Grp", Tag("dup")), // same path + name within the batch
|
|
};
|
|
|
|
var result = await service.ImportTagsAsync(RawTreeTestDb.RootDeviceId, rows);
|
|
|
|
result.Inserted.ShouldBe(0);
|
|
result.Errors.ShouldContain(e => e.Contains("Row 2") && e.Contains("already exists"));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ImportTags_detects_collision_with_existing_tag()
|
|
{
|
|
var (service, _) = Seeded();
|
|
|
|
// "temperature" already sits at the device root of RootDevice.
|
|
var result = await service.ImportTagsAsync(
|
|
RawTreeTestDb.RootDeviceId, new[] { new RawTagImportRow(null, Tag("temperature")) });
|
|
|
|
result.Inserted.ShouldBe(0);
|
|
result.Errors.ShouldContain(e => e.Contains("already exists"));
|
|
}
|
|
|
|
// ----------------------------------------------------------------------- Driver config (WP3)
|
|
|
|
[Fact]
|
|
public async Task LoadDriverForEdit_projects_fields()
|
|
{
|
|
var (service, _) = Seeded();
|
|
|
|
var dto = await service.LoadDriverForEditAsync(RawTreeTestDb.FolderedDriverId);
|
|
|
|
dto.ShouldNotBeNull();
|
|
dto!.Name.ShouldBe("modbus-1");
|
|
dto.DriverType.ShouldBe("Modbus");
|
|
dto.DriverConfig.ShouldBe("{}");
|
|
}
|
|
|
|
[Fact]
|
|
public async Task LoadDriverForEdit_returns_null_when_missing()
|
|
{
|
|
var (service, _) = Seeded();
|
|
(await service.LoadDriverForEditAsync("DRV-nope")).ShouldBeNull();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task UpdateDriver_edits_name_and_config_preserving_type()
|
|
{
|
|
var (service, dbName) = Seeded();
|
|
var rv = RowVersionOf(dbName, db => db.DriverInstances.Single(d => d.DriverInstanceId == RawTreeTestDb.FolderedDriverId).RowVersion);
|
|
|
|
var result = await service.UpdateDriverAsync(
|
|
RawTreeTestDb.FolderedDriverId, "modbus-main", "{\"Host\":\"10.0.0.1\"}", "{\"x\":1}", rv);
|
|
|
|
result.Ok.ShouldBeTrue();
|
|
using var db = RawTreeTestDb.CreateNamed(dbName);
|
|
var drv = db.DriverInstances.Single(d => d.DriverInstanceId == RawTreeTestDb.FolderedDriverId);
|
|
drv.Name.ShouldBe("modbus-main");
|
|
drv.DriverConfig.ShouldContain("Host");
|
|
drv.ResilienceConfig.ShouldBe("{\"x\":1}");
|
|
drv.DriverType.ShouldBe("Modbus"); // immutable
|
|
}
|
|
|
|
[Fact]
|
|
public async Task UpdateDriver_rejects_sibling_name_collision()
|
|
{
|
|
var (service, dbName) = Seeded();
|
|
// Two cluster-root vs foldered drivers differ in scope; create a sibling in the same folder to collide.
|
|
await service.CreateDriverAsync(RawTreeTestDb.ClusterId, RawTreeTestDb.RootFolderId, "modbus-2", "Modbus", "{}");
|
|
var rv = RowVersionOf(dbName, db => db.DriverInstances.Single(d => d.DriverInstanceId == RawTreeTestDb.FolderedDriverId).RowVersion);
|
|
|
|
var result = await service.UpdateDriverAsync(RawTreeTestDb.FolderedDriverId, "modbus-2", "{}", null, rv);
|
|
|
|
result.Ok.ShouldBeFalse();
|
|
result.Error!.ShouldContain("already exists");
|
|
}
|
|
|
|
[Fact]
|
|
public async Task UpdateDriver_fails_when_row_vanished_concurrently()
|
|
{
|
|
var (service, dbName) = Seeded();
|
|
var rv = RowVersionOf(dbName, db => db.DriverInstances.Single(d => d.DriverInstanceId == RawTreeTestDb.FolderedDriverId).RowVersion);
|
|
|
|
using (var db = RawTreeTestDb.CreateNamed(dbName))
|
|
{
|
|
db.Devices.RemoveRange(db.Devices.Where(d => d.DriverInstanceId == RawTreeTestDb.FolderedDriverId));
|
|
db.Tags.RemoveRange(db.Tags.Where(t => t.DeviceId == RawTreeTestDb.FolderedDeviceId));
|
|
db.TagGroups.RemoveRange(db.TagGroups.Where(g => g.DeviceId == RawTreeTestDb.FolderedDeviceId));
|
|
db.DriverInstances.Remove(db.DriverInstances.Single(d => d.DriverInstanceId == RawTreeTestDb.FolderedDriverId));
|
|
db.SaveChanges();
|
|
}
|
|
|
|
var result = await service.UpdateDriverAsync(RawTreeTestDb.FolderedDriverId, "x", "{}", null, rv);
|
|
|
|
result.Ok.ShouldBeFalse();
|
|
result.Error.ShouldNotBeNull();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------- Device config (WP3)
|
|
|
|
[Fact]
|
|
public async Task LoadDeviceForEdit_projects_fields_with_driver_type_join()
|
|
{
|
|
var (service, _) = Seeded();
|
|
|
|
var dto = await service.LoadDeviceForEditAsync(RawTreeTestDb.FolderedDeviceId);
|
|
|
|
dto.ShouldNotBeNull();
|
|
dto!.Name.ShouldBe("Device1");
|
|
dto.DriverInstanceId.ShouldBe(RawTreeTestDb.FolderedDriverId);
|
|
dto.Enabled.ShouldBeTrue();
|
|
dto.DriverType.ShouldBe("Modbus"); // joined from the parent driver
|
|
}
|
|
|
|
[Fact]
|
|
public async Task LoadDeviceForEdit_returns_null_when_missing()
|
|
{
|
|
var (service, _) = Seeded();
|
|
(await service.LoadDeviceForEditAsync("DEV-nope")).ShouldBeNull();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task UpdateDevice_edits_name_config_and_enabled()
|
|
{
|
|
var (service, dbName) = Seeded();
|
|
var rv = RowVersionOf(dbName, db => db.Devices.Single(d => d.DeviceId == RawTreeTestDb.FolderedDeviceId).RowVersion);
|
|
|
|
var result = await service.UpdateDeviceAsync(
|
|
RawTreeTestDb.FolderedDeviceId, "PLC-A", "{\"Host\":\"10.0.0.9\",\"Port\":502}", enabled: false, rv);
|
|
|
|
result.Ok.ShouldBeTrue();
|
|
using var db = RawTreeTestDb.CreateNamed(dbName);
|
|
var dev = db.Devices.Single(d => d.DeviceId == RawTreeTestDb.FolderedDeviceId);
|
|
dev.Name.ShouldBe("PLC-A");
|
|
dev.DeviceConfig.ShouldContain("Host");
|
|
dev.Enabled.ShouldBeFalse();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task UpdateDevice_rejects_sibling_name_collision()
|
|
{
|
|
var (service, dbName) = Seeded();
|
|
await service.CreateDeviceAsync(RawTreeTestDb.FolderedDriverId, "Device2", "{}");
|
|
var rv = RowVersionOf(dbName, db => db.Devices.Single(d => d.DeviceId == RawTreeTestDb.FolderedDeviceId).RowVersion);
|
|
|
|
var result = await service.UpdateDeviceAsync(RawTreeTestDb.FolderedDeviceId, "Device2", "{}", true, rv);
|
|
|
|
result.Ok.ShouldBeFalse();
|
|
result.Error!.ShouldContain("already exists");
|
|
}
|
|
|
|
// ------------------------------------------------------------- Merged probe config (Test connect)
|
|
|
|
[Fact]
|
|
public async Task LoadMergedProbeConfig_merges_deviceconfig_endpoint_up()
|
|
{
|
|
var (service, dbName) = Seeded();
|
|
// Put an endpoint on the device config (endpoint lives in DeviceConfig in v3).
|
|
using (var db = RawTreeTestDb.CreateNamed(dbName))
|
|
{
|
|
var dev = db.Devices.Single(d => d.DeviceId == RawTreeTestDb.FolderedDeviceId);
|
|
dev.DeviceConfig = "{\"Host\":\"10.1.2.3\",\"Port\":5020}";
|
|
db.SaveChanges();
|
|
}
|
|
|
|
var probe = await service.LoadMergedProbeConfigAsync(RawTreeTestDb.FolderedDeviceId);
|
|
|
|
probe.ShouldNotBeNull();
|
|
probe!.Value.DriverType.ShouldBe("Modbus");
|
|
// Endpoint key from DeviceConfig appears merged up at the top level of the probe config.
|
|
probe.Value.MergedConfigJson.ShouldContain("Host");
|
|
probe.Value.MergedConfigJson.ShouldContain("10.1.2.3");
|
|
}
|
|
|
|
[Fact]
|
|
public async Task LoadMergedProbeConfig_returns_null_for_unknown_device()
|
|
{
|
|
var (service, _) = Seeded();
|
|
(await service.LoadMergedProbeConfigAsync("DEV-nope")).ShouldBeNull();
|
|
}
|
|
}
|