Joseph Doherty
372 lines
14 KiB
C#
372 lines
14 KiB
C#
using Grpc.Core;
|
|
using ZB.MOM.WW.GalaxyRepository;
|
|
using ZB.MOM.WW.GalaxyRepository.Grpc;
|
|
|
|
namespace ZB.MOM.WW.GalaxyRepository.Tests;
|
|
|
|
/// <summary>
|
|
/// Direct coverage for <see cref="GalaxyBrowseProjector"/>. Validates parent
|
|
/// resolution (gobject id / tag name / contained path), paging across siblings,
|
|
/// filter parity with <see cref="GalaxyHierarchyProjector"/>, the
|
|
/// <c>child_has_children</c> hint, browse-subtree constraints, and the
|
|
/// attribute-skeleton mode.
|
|
/// </summary>
|
|
public sealed class GalaxyBrowseProjectorTests
|
|
{
|
|
/// <summary>Verifies that an empty parent oneof returns the root area.</summary>
|
|
[Fact]
|
|
public void Project_NoParent_ReturnsRootArea()
|
|
{
|
|
GalaxyHierarchyCacheEntry entry = CreateEntry();
|
|
|
|
GalaxyBrowseChildrenResult result = GalaxyBrowseProjector.ProjectChildren(
|
|
entry,
|
|
new BrowseChildrenRequest(),
|
|
browseSubtreeGlobs: null,
|
|
offset: 0,
|
|
pageSize: 10);
|
|
|
|
Assert.Single(result.Children);
|
|
Assert.Equal("Plant", result.Children[0].TagName);
|
|
Assert.True(result.ChildHasChildren[0]);
|
|
}
|
|
|
|
/// <summary>Verifies that resolving the parent by gobject id returns sorted direct children.</summary>
|
|
[Fact]
|
|
public void Project_ByParentGobjectId_ReturnsDirectChildren()
|
|
{
|
|
GalaxyHierarchyCacheEntry entry = CreateEntry();
|
|
|
|
GalaxyBrowseChildrenResult result = GalaxyBrowseProjector.ProjectChildren(
|
|
entry,
|
|
new BrowseChildrenRequest { ParentGobjectId = 1 },
|
|
browseSubtreeGlobs: null,
|
|
offset: 0,
|
|
pageSize: 10);
|
|
|
|
string[] names = result.Children.Select(child => child.TagName).ToArray();
|
|
Assert.Equal(new[] { "Plant.Line_A", "Plant.Mixer_001", "Plant.Mixer_002", "Plant.Pump_001" }, names);
|
|
Assert.Equal(new[] { true, false, false, false }, result.ChildHasChildren.ToArray());
|
|
Assert.Equal(4, result.TotalChildCount);
|
|
}
|
|
|
|
/// <summary>Verifies that resolving the parent by tag name returns the same direct children.</summary>
|
|
[Fact]
|
|
public void Project_ByParentTagName_ResolvesParent()
|
|
{
|
|
GalaxyHierarchyCacheEntry entry = CreateEntry();
|
|
|
|
GalaxyBrowseChildrenResult result = GalaxyBrowseProjector.ProjectChildren(
|
|
entry,
|
|
new BrowseChildrenRequest { ParentTagName = "Plant" },
|
|
browseSubtreeGlobs: null,
|
|
offset: 0,
|
|
pageSize: 10);
|
|
|
|
string[] names = result.Children.Select(child => child.TagName).ToArray();
|
|
Assert.Equal(new[] { "Plant.Line_A", "Plant.Mixer_001", "Plant.Mixer_002", "Plant.Pump_001" }, names);
|
|
}
|
|
|
|
/// <summary>Verifies that resolving the parent by contained path returns the same direct children.</summary>
|
|
[Fact]
|
|
public void Project_ByParentContainedPath_ResolvesParent()
|
|
{
|
|
GalaxyHierarchyCacheEntry entry = CreateEntry();
|
|
|
|
GalaxyBrowseChildrenResult result = GalaxyBrowseProjector.ProjectChildren(
|
|
entry,
|
|
new BrowseChildrenRequest { ParentContainedPath = "Plant" },
|
|
browseSubtreeGlobs: null,
|
|
offset: 0,
|
|
pageSize: 10);
|
|
|
|
string[] names = result.Children.Select(child => child.TagName).ToArray();
|
|
Assert.Equal(new[] { "Plant.Line_A", "Plant.Mixer_001", "Plant.Mixer_002", "Plant.Pump_001" }, names);
|
|
}
|
|
|
|
/// <summary>Verifies that an unknown parent gobject id throws an RpcException with StatusCode.NotFound.</summary>
|
|
[Fact]
|
|
public void Project_UnknownParent_ThrowsNotFound()
|
|
{
|
|
GalaxyHierarchyCacheEntry entry = CreateEntry();
|
|
|
|
RpcException exception = Assert.Throws<RpcException>(() => GalaxyBrowseProjector.ProjectChildren(
|
|
entry,
|
|
new BrowseChildrenRequest { ParentGobjectId = 999 },
|
|
browseSubtreeGlobs: null,
|
|
offset: 0,
|
|
pageSize: 10));
|
|
|
|
Assert.Equal(StatusCode.NotFound, exception.StatusCode);
|
|
}
|
|
|
|
/// <summary>Verifies that paging across siblings returns every sibling exactly once.</summary>
|
|
[Fact]
|
|
public void Project_PagedAcrossSiblings_ReturnsEverySiblingOnce()
|
|
{
|
|
GalaxyHierarchyCacheEntry entry = CreateEntry();
|
|
|
|
GalaxyBrowseChildrenResult first = GalaxyBrowseProjector.ProjectChildren(
|
|
entry,
|
|
new BrowseChildrenRequest { ParentGobjectId = 1 },
|
|
browseSubtreeGlobs: null,
|
|
offset: 0,
|
|
pageSize: 2);
|
|
GalaxyBrowseChildrenResult second = GalaxyBrowseProjector.ProjectChildren(
|
|
entry,
|
|
new BrowseChildrenRequest { ParentGobjectId = 1 },
|
|
browseSubtreeGlobs: null,
|
|
offset: 2,
|
|
pageSize: 2);
|
|
|
|
List<string> collected = first.Children
|
|
.Concat(second.Children)
|
|
.Select(child => child.TagName)
|
|
.ToList();
|
|
Assert.Equal(4, collected.Count);
|
|
Assert.Equal(collected.Count, collected.Distinct(StringComparer.Ordinal).Count());
|
|
Assert.Equal(
|
|
new HashSet<string>(StringComparer.Ordinal)
|
|
{
|
|
"Plant.Line_A",
|
|
"Plant.Mixer_001",
|
|
"Plant.Mixer_002",
|
|
"Plant.Pump_001",
|
|
},
|
|
new HashSet<string>(collected, StringComparer.Ordinal));
|
|
}
|
|
|
|
/// <summary>Verifies that a tag-name glob filters direct children and clears the has-children hint.</summary>
|
|
[Fact]
|
|
public void Project_TagNameGlobFiltersChildren_AndUpdatesHasChildren()
|
|
{
|
|
GalaxyHierarchyCacheEntry entry = CreateEntry();
|
|
|
|
GalaxyBrowseChildrenResult result = GalaxyBrowseProjector.ProjectChildren(
|
|
entry,
|
|
new BrowseChildrenRequest
|
|
{
|
|
ParentGobjectId = 1,
|
|
TagNameGlob = "*Mixer*",
|
|
},
|
|
browseSubtreeGlobs: null,
|
|
offset: 0,
|
|
pageSize: 10);
|
|
|
|
string[] names = result.Children.Select(child => child.TagName).ToArray();
|
|
Assert.Equal(new[] { "Plant.Mixer_001", "Plant.Mixer_002" }, names);
|
|
Assert.Equal(new[] { false, false }, result.ChildHasChildren.ToArray());
|
|
}
|
|
|
|
/// <summary>Verifies that historized-only filtering also drives the has-children hint via descendants.</summary>
|
|
[Fact]
|
|
public void Project_HistorizedOnlyFiltersDescendants_HasChildrenReflectsFilter()
|
|
{
|
|
GalaxyHierarchyCacheEntry entry = CreateEntry();
|
|
|
|
GalaxyBrowseChildrenResult result = GalaxyBrowseProjector.ProjectChildren(
|
|
entry,
|
|
new BrowseChildrenRequest
|
|
{
|
|
ParentGobjectId = 1,
|
|
HistorizedOnly = true,
|
|
},
|
|
browseSubtreeGlobs: null,
|
|
offset: 0,
|
|
pageSize: 10);
|
|
|
|
// Line_A itself has no historized attributes, but its descendant Sensor_A1 does,
|
|
// so the subtree match keeps Line_A in the result with has-children = true.
|
|
// Mixer_001/Mixer_002/Pump_001 have no historized attributes themselves and
|
|
// no historized descendants -> filtered out entirely.
|
|
Assert.Single(result.Children);
|
|
Assert.Equal("Plant.Line_A", result.Children[0].TagName);
|
|
Assert.Equal(new[] { true }, result.ChildHasChildren.ToArray());
|
|
}
|
|
|
|
/// <summary>Verifies that <c>IncludeAttributes=false</c> returns object skeletons.</summary>
|
|
[Fact]
|
|
public void Project_IncludeAttributesFalse_ReturnsSkeletons()
|
|
{
|
|
GalaxyHierarchyCacheEntry entry = CreateEntry();
|
|
|
|
GalaxyBrowseChildrenResult result = GalaxyBrowseProjector.ProjectChildren(
|
|
entry,
|
|
new BrowseChildrenRequest
|
|
{
|
|
ParentGobjectId = 1,
|
|
IncludeAttributes = false,
|
|
},
|
|
browseSubtreeGlobs: null,
|
|
offset: 0,
|
|
pageSize: 10);
|
|
|
|
GalaxyObject mixer = result.Children.Single(child => child.TagName == "Plant.Mixer_001");
|
|
Assert.Empty(mixer.Attributes);
|
|
}
|
|
|
|
/// <summary>Verifies that browse-subtree globs constrain the returned children.</summary>
|
|
[Fact]
|
|
public void Project_BrowseSubtrees_ExcludesChildrenOutsideAllowedGlobs()
|
|
{
|
|
GalaxyHierarchyCacheEntry entry = CreateEntry();
|
|
|
|
GalaxyBrowseChildrenResult result = GalaxyBrowseProjector.ProjectChildren(
|
|
entry,
|
|
new BrowseChildrenRequest { ParentGobjectId = 1 },
|
|
browseSubtreeGlobs: new[] { "Plant/Line_*" },
|
|
offset: 0,
|
|
pageSize: 10);
|
|
|
|
Assert.Single(result.Children);
|
|
Assert.Equal("Plant.Line_A", result.Children[0].TagName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifies <see cref="GalaxyBrowseProjector"/> terminates when the Galaxy data
|
|
/// contains a cyclic parent chain (A→B→C→A). Without the visited-id guard in
|
|
/// <c>HasMatchingDescendant</c>, the depth-first walk would loop forever; the
|
|
/// 5-second xUnit timeout asserts termination.
|
|
/// </summary>
|
|
[Fact(Timeout = 5000)]
|
|
public async Task Project_CyclicDescendants_DoesNotInfiniteLoop()
|
|
{
|
|
await Task.Yield();
|
|
// Construct a 3-node cycle: A(10)→B(11)→C(12)→A. Each node's ParentGobjectId
|
|
// points to the next, so GalaxyHierarchyIndex.ChildrenByParent has
|
|
// [12] = [A], [10] = [B], [11] = [C].
|
|
// None of them are historized, so HistorizedOnly=true forces the projector to
|
|
// call HasMatchingDescendant on every direct child, exercising the cycle walk.
|
|
GalaxyObject a = new()
|
|
{
|
|
GobjectId = 10,
|
|
ParentGobjectId = 12,
|
|
ContainedName = "A",
|
|
BrowseName = "A",
|
|
TagName = "A",
|
|
};
|
|
GalaxyObject b = new()
|
|
{
|
|
GobjectId = 11,
|
|
ParentGobjectId = 10,
|
|
ContainedName = "B",
|
|
BrowseName = "B",
|
|
TagName = "B",
|
|
};
|
|
GalaxyObject c = new()
|
|
{
|
|
GobjectId = 12,
|
|
ParentGobjectId = 11,
|
|
ContainedName = "C",
|
|
BrowseName = "C",
|
|
TagName = "C",
|
|
};
|
|
|
|
IReadOnlyList<GalaxyObject> objects = new[] { a, b, c };
|
|
GalaxyHierarchyCacheEntry entry = GalaxyHierarchyCacheEntry.Empty with
|
|
{
|
|
Status = GalaxyCacheStatus.Healthy,
|
|
Sequence = 1,
|
|
LastSuccessAt = DateTimeOffset.UtcNow,
|
|
Objects = objects,
|
|
Index = GalaxyHierarchyIndex.Build(objects),
|
|
ObjectCount = objects.Count,
|
|
};
|
|
|
|
// Browse children of A (id=10). Its direct child B fails HistorizedOnly, so the
|
|
// projector falls back to HasMatchingDescendant(B), which walks B→C→A→B…
|
|
// without the visited-id guard. With the guard, the walk terminates and returns
|
|
// an empty page (no historized descendants exist anywhere in the cycle).
|
|
GalaxyBrowseChildrenResult result = GalaxyBrowseProjector.ProjectChildren(
|
|
entry,
|
|
new BrowseChildrenRequest { ParentGobjectId = 10, HistorizedOnly = true },
|
|
browseSubtreeGlobs: null,
|
|
offset: 0,
|
|
pageSize: 10);
|
|
|
|
Assert.Empty(result.Children);
|
|
Assert.Equal(0, result.TotalChildCount);
|
|
}
|
|
|
|
private static GalaxyHierarchyCacheEntry CreateEntry()
|
|
{
|
|
IReadOnlyList<GalaxyObject> objects = CreateObjects();
|
|
return GalaxyHierarchyCacheEntry.Empty with
|
|
{
|
|
Status = GalaxyCacheStatus.Healthy,
|
|
Sequence = 1,
|
|
LastSuccessAt = DateTimeOffset.UtcNow,
|
|
Objects = objects,
|
|
Index = GalaxyHierarchyIndex.Build(objects),
|
|
ObjectCount = objects.Count,
|
|
};
|
|
}
|
|
|
|
private static IReadOnlyList<GalaxyObject> CreateObjects()
|
|
{
|
|
GalaxyObject plant = new()
|
|
{
|
|
GobjectId = 1,
|
|
ParentGobjectId = 0,
|
|
IsArea = true,
|
|
ContainedName = "Plant",
|
|
BrowseName = "Plant",
|
|
TagName = "Plant",
|
|
};
|
|
GalaxyObject mixer001 = new()
|
|
{
|
|
GobjectId = 2,
|
|
ParentGobjectId = 1,
|
|
ContainedName = "Mixer_001",
|
|
BrowseName = "Mixer_001",
|
|
TagName = "Plant.Mixer_001",
|
|
};
|
|
mixer001.Attributes.Add(new GalaxyAttribute
|
|
{
|
|
AttributeName = "Speed",
|
|
FullTagReference = "Plant.Mixer_001.Speed",
|
|
});
|
|
GalaxyObject mixer002 = new()
|
|
{
|
|
GobjectId = 3,
|
|
ParentGobjectId = 1,
|
|
ContainedName = "Mixer_002",
|
|
BrowseName = "Mixer_002",
|
|
TagName = "Plant.Mixer_002",
|
|
};
|
|
GalaxyObject lineA = new()
|
|
{
|
|
GobjectId = 4,
|
|
ParentGobjectId = 1,
|
|
IsArea = true,
|
|
ContainedName = "Line_A",
|
|
BrowseName = "Line_A",
|
|
TagName = "Plant.Line_A",
|
|
};
|
|
GalaxyObject sensorA1 = new()
|
|
{
|
|
GobjectId = 5,
|
|
ParentGobjectId = 4,
|
|
ContainedName = "Sensor_A1",
|
|
BrowseName = "Sensor_A1",
|
|
TagName = "Plant.Line_A.Sensor_A1",
|
|
};
|
|
sensorA1.Attributes.Add(new GalaxyAttribute
|
|
{
|
|
AttributeName = "Value",
|
|
FullTagReference = "Plant.Line_A.Sensor_A1.Value",
|
|
IsHistorized = true,
|
|
});
|
|
GalaxyObject pump001 = new()
|
|
{
|
|
GobjectId = 6,
|
|
ParentGobjectId = 1,
|
|
ContainedName = "Pump_001",
|
|
BrowseName = "Pump_001",
|
|
TagName = "Plant.Pump_001",
|
|
};
|
|
|
|
return new[] { plant, mixer001, mixer002, lineA, sensorA1, pump001 };
|
|
}
|
|
}
|