fix(security): pass FallbackServers/BindMode/UserBindTemplate/AcceptDomainQualifiedNames to the LDAP library, inject its logger (#913)
- LdapOptions gains the four properties (library defaults) and ToLibraryOptions()
projects them; before this the AdminUI had no DC failover and the keys were
silently ignored.
- OtOpcUaLdapAuthService builds the library service with ILogger<LdapAuthService>
from DI, so failover Warnings, the sticky-preference line and stage diagnostics
reach the log.
- LdapOptionsValidator ports only the library's FallbackServers parse rule and the
BindMode=User -> UserBindTemplate {0}-exactly-once rule. ServiceAccountDn is NOT
required: DEV boots on the empty default (plan review B2).
- Fix stale comments: no direct-bind path exists; code default server is localhost.
- Tests: two-way reflection completeness guard over the library LdapOptions
(allow-list: ServerCertificateValidationCallback), JSON + env binding of the new
keys, validator rules, DEV-shaped boot, and a DI-built service against two closed
loopback ports proving library Warnings for primary AND fallback reach the log.
Claude-Session: https://claude.ai/code/session_01GT67AFKC45MBz1wPZnVbX8
This commit is contained in:
+221
@@ -0,0 +1,221 @@
|
||||
using Microsoft.Extensions.Configuration;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Options;
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
using ZB.MOM.WW.Configuration;
|
||||
using ZB.MOM.WW.OtOpcUa.Host.Configuration;
|
||||
using ZB.MOM.WW.OtOpcUa.Security.Ldap;
|
||||
using LdapBindMode = ZB.MOM.WW.Auth.Abstractions.Ldap.LdapBindMode;
|
||||
using LdapTransport = ZB.MOM.WW.Auth.Abstractions.Ldap.LdapTransport;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Host.IntegrationTests;
|
||||
|
||||
/// <summary>
|
||||
/// lmxopcua#913 — OtOpcUa's own <see cref="LdapOptionsValidator"/> ports ONLY two rules from the
|
||||
/// shared library's validator (which OtOpcUa does not run): every <c>FallbackServers</c> entry
|
||||
/// parses as <c>host[:port]</c>, and <c>BindMode=User</c> needs a <c>UserBindTemplate</c> with
|
||||
/// <c>{0}</c> exactly once. The library's <c>ServiceAccountDn</c>-required rule is deliberately NOT
|
||||
/// ported: DEV boots on the code defaults with an empty DN (NAM cutover plan, review B2).
|
||||
/// </summary>
|
||||
public sealed class LdapOptionsValidatorNamCutoverTests
|
||||
{
|
||||
private static readonly LdapOptionsValidator Sut = new();
|
||||
|
||||
private static LdapOptions Valid() => new()
|
||||
{
|
||||
Enabled = true,
|
||||
Server = "dc1.example.test",
|
||||
Port = 636,
|
||||
SearchBase = "dc=example,dc=test",
|
||||
Transport = LdapTransport.Ldaps,
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// Review B2: today's DEV shape — <c>Enabled=true</c>, <c>Server=localhost</c>,
|
||||
/// <c>ServiceAccountDn=""</c>, <c>Transport=Ldaps</c> — must keep passing.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void Dev_shaped_config_with_empty_ServiceAccountDn_passes()
|
||||
{
|
||||
var options = new LdapOptions
|
||||
{
|
||||
Enabled = true,
|
||||
Server = "localhost",
|
||||
ServiceAccountDn = "",
|
||||
Transport = LdapTransport.Ldaps,
|
||||
};
|
||||
|
||||
var result = Sut.Validate(null, options);
|
||||
result.Succeeded.ShouldBeTrue(result.FailureMessage);
|
||||
}
|
||||
|
||||
/// <summary>The same DEV shape boots through the host's real registration path
|
||||
/// (<c>AddValidatedOptions</c> + <c>ValidateOnStart</c>) when bound from configuration.</summary>
|
||||
[Fact]
|
||||
public void Dev_shaped_config_survives_AddValidatedOptions()
|
||||
{
|
||||
var configuration = new ConfigurationBuilder()
|
||||
.AddInMemoryCollection(new Dictionary<string, string?>
|
||||
{
|
||||
["Security:Ldap:Enabled"] = "true",
|
||||
["Security:Ldap:Server"] = "localhost",
|
||||
["Security:Ldap:ServiceAccountDn"] = "",
|
||||
["Security:Ldap:Transport"] = "Ldaps",
|
||||
})
|
||||
.Build();
|
||||
var services = new ServiceCollection();
|
||||
services.AddValidatedOptions<LdapOptions, LdapOptionsValidator>(configuration, LdapOptions.SectionName);
|
||||
using var sp = services.BuildServiceProvider();
|
||||
|
||||
Should.NotThrow(() => sp.GetRequiredService<IOptions<LdapOptions>>().Value);
|
||||
}
|
||||
|
||||
/// <summary>Two well-formed fallback DCs (bare host and host:port) pass.</summary>
|
||||
[Fact]
|
||||
public void Wellformed_fallback_servers_pass()
|
||||
{
|
||||
var options = Valid();
|
||||
options.FallbackServers = ["dc2.example.test", " dc3.example.test:3269 "];
|
||||
|
||||
Sut.Validate(null, options).Succeeded.ShouldBeTrue();
|
||||
}
|
||||
|
||||
/// <summary>Each malformed fallback entry fails with a field-naming message.</summary>
|
||||
[Theory]
|
||||
[InlineData("")]
|
||||
[InlineData(" ")]
|
||||
[InlineData(":636")]
|
||||
[InlineData("dc2:0")]
|
||||
[InlineData("dc2:65536")]
|
||||
[InlineData("dc2:ldaps")]
|
||||
[InlineData("fe80::1")]
|
||||
public void Malformed_fallback_server_fails(string entry)
|
||||
{
|
||||
var options = Valid();
|
||||
options.FallbackServers = ["dc2.example.test", entry];
|
||||
|
||||
var result = Sut.Validate(null, options);
|
||||
|
||||
result.Failed.ShouldBeTrue();
|
||||
result.Failures.ShouldContain(f => f.StartsWith("Ldap:FallbackServers contains an invalid entry"));
|
||||
}
|
||||
|
||||
/// <summary>User mode with exactly one placeholder passes — and needs no ServiceAccountDn.</summary>
|
||||
[Theory]
|
||||
[InlineData("NAM\\{0}")]
|
||||
[InlineData("{0}@example.test")]
|
||||
public void User_mode_with_one_placeholder_passes(string template)
|
||||
{
|
||||
var options = Valid();
|
||||
options.BindMode = LdapBindMode.User;
|
||||
options.UserBindTemplate = template;
|
||||
|
||||
Sut.Validate(null, options).Succeeded.ShouldBeTrue();
|
||||
}
|
||||
|
||||
/// <summary>User mode with zero or two placeholders fails.</summary>
|
||||
[Theory]
|
||||
[InlineData("")]
|
||||
[InlineData("NAM\\svc")]
|
||||
[InlineData("{0}\\{0}")]
|
||||
public void User_mode_without_exactly_one_placeholder_fails(string template)
|
||||
{
|
||||
var options = Valid();
|
||||
options.BindMode = LdapBindMode.User;
|
||||
options.UserBindTemplate = template;
|
||||
|
||||
var result = Sut.Validate(null, options);
|
||||
|
||||
result.Failed.ShouldBeTrue();
|
||||
result.Failures.ShouldContain(f => f.StartsWith("Ldap:UserBindTemplate must contain {0} exactly once"));
|
||||
}
|
||||
|
||||
/// <summary>ServiceAccount mode ignores the template rule (the template is User-only).</summary>
|
||||
[Fact]
|
||||
public void ServiceAccount_mode_ignores_an_empty_template()
|
||||
{
|
||||
var options = Valid();
|
||||
options.BindMode = LdapBindMode.ServiceAccount;
|
||||
options.UserBindTemplate = "";
|
||||
|
||||
Sut.Validate(null, options).Succeeded.ShouldBeTrue();
|
||||
}
|
||||
|
||||
/// <summary>The ported rules follow the existing gate: disabled or DevStub configs skip them.</summary>
|
||||
[Theory]
|
||||
[InlineData(false, false)]
|
||||
[InlineData(true, true)]
|
||||
public void Disabled_or_devstub_skips_the_ported_rules(bool enabled, bool devStub)
|
||||
{
|
||||
var options = Valid();
|
||||
options.Enabled = enabled;
|
||||
options.DevStubMode = devStub;
|
||||
options.FallbackServers = ["dc2:notaport"];
|
||||
options.BindMode = LdapBindMode.User;
|
||||
options.UserBindTemplate = "";
|
||||
|
||||
Sut.Validate(null, options).Succeeded.ShouldBeTrue();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Binding test: <c>Security:Ldap:FallbackServers:0</c> and the other three lmxopcua#913 keys
|
||||
/// reach the LIBRARY options, from JSON and from <c>Security__Ldap__…</c> environment variables.
|
||||
/// </summary>
|
||||
[Theory]
|
||||
[InlineData("json")]
|
||||
[InlineData("env")]
|
||||
public void New_keys_bind_and_reach_the_library_options(string source)
|
||||
{
|
||||
var builder = new ConfigurationBuilder();
|
||||
if (source == "json")
|
||||
{
|
||||
var json = """
|
||||
{"Security":{"Ldap":{
|
||||
"FallbackServers":["dc2.example.test","dc3.example.test:3269"],
|
||||
"BindMode":"User",
|
||||
"UserBindTemplate":"NAM\\{0}",
|
||||
"AcceptDomainQualifiedNames":false
|
||||
}}}
|
||||
""";
|
||||
builder.AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(json)));
|
||||
}
|
||||
else
|
||||
{
|
||||
var prefix = $"OTOPCUA913_{Guid.NewGuid():N}_";
|
||||
var vars = new Dictionary<string, string>
|
||||
{
|
||||
["Security__Ldap__FallbackServers__0"] = "dc2.example.test",
|
||||
["Security__Ldap__FallbackServers__1"] = "dc3.example.test:3269",
|
||||
["Security__Ldap__BindMode"] = "User",
|
||||
["Security__Ldap__UserBindTemplate"] = "NAM\\{0}",
|
||||
["Security__Ldap__AcceptDomainQualifiedNames"] = "false",
|
||||
};
|
||||
foreach (var (k, v) in vars) Environment.SetEnvironmentVariable(prefix + k, v);
|
||||
try
|
||||
{
|
||||
builder.AddEnvironmentVariables(prefix);
|
||||
AssertBound(builder.Build());
|
||||
return;
|
||||
}
|
||||
finally
|
||||
{
|
||||
foreach (var k in vars.Keys) Environment.SetEnvironmentVariable(prefix + k, null);
|
||||
}
|
||||
}
|
||||
|
||||
AssertBound(builder.Build());
|
||||
|
||||
static void AssertBound(IConfiguration configuration)
|
||||
{
|
||||
var app = configuration.GetSection(LdapOptions.SectionName).Get<LdapOptions>();
|
||||
app.ShouldNotBeNull();
|
||||
var lib = app.ToLibraryOptions();
|
||||
|
||||
lib.FallbackServers.ShouldBe(["dc2.example.test", "dc3.example.test:3269"]);
|
||||
lib.BindMode.ShouldBe(LdapBindMode.User);
|
||||
lib.UserBindTemplate.ShouldBe("NAM\\{0}");
|
||||
lib.AcceptDomainQualifiedNames.ShouldBeFalse();
|
||||
}
|
||||
}
|
||||
}
|
||||
+167
@@ -0,0 +1,167 @@
|
||||
using System.Collections;
|
||||
using System.Reflection;
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
using ZB.MOM.WW.OtOpcUa.Security.Ldap;
|
||||
using LdapBindMode = ZB.MOM.WW.Auth.Abstractions.Ldap.LdapBindMode;
|
||||
using LdapTransport = ZB.MOM.WW.Auth.Abstractions.Ldap.LdapTransport;
|
||||
using LibLdapOptions = ZB.MOM.WW.Auth.Abstractions.Ldap.LdapOptions;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Security.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// lmxopcua#913 — <see cref="LdapOptions.ToLibraryOptions"/> once silently dropped
|
||||
/// <c>FallbackServers</c>, <c>BindMode</c>, <c>UserBindTemplate</c> and
|
||||
/// <c>AcceptDomainQualifiedNames</c>, so the AdminUI had no DC failover and the config keys were
|
||||
/// ignored without error. This guard reflects over the shared library's
|
||||
/// <see cref="LibLdapOptions"/> in BOTH directions:
|
||||
/// <list type="number">
|
||||
/// <item>every settable library property is either projected by <c>ToLibraryOptions()</c>
|
||||
/// (a non-default value set on OtOpcUa's options arrives in the library options) or is
|
||||
/// named in <see cref="IntentionallyUnmapped"/>; and</item>
|
||||
/// <item>every <see cref="IntentionallyUnmapped"/> entry still exists on the library type (no
|
||||
/// stale allow-list).</item>
|
||||
/// </list>
|
||||
/// A library upgrade that adds a property therefore fails here until it is mapped or allow-listed.
|
||||
/// </summary>
|
||||
public sealed class LdapOptionsProjectionCompletenessTests
|
||||
{
|
||||
/// <summary>Library properties deliberately not projected, each with its reason.</summary>
|
||||
private static readonly IReadOnlyDictionary<string, string> IntentionallyUnmapped =
|
||||
new Dictionary<string, string>(StringComparer.Ordinal)
|
||||
{
|
||||
[nameof(LibLdapOptions.ServerCertificateValidationCallback)] =
|
||||
"code-only TLS hook in the library; not bindable from configuration",
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// A non-default value per library property, set on OtOpcUa's same-named option. Every value
|
||||
/// differs from BOTH the library default and OtOpcUa's default, so an unmapped property cannot
|
||||
/// pass by coincidence.
|
||||
/// </summary>
|
||||
private static readonly IReadOnlyDictionary<string, object> NonDefaultValues =
|
||||
new Dictionary<string, object>(StringComparer.Ordinal)
|
||||
{
|
||||
[nameof(LibLdapOptions.Enabled)] = false,
|
||||
[nameof(LibLdapOptions.Server)] = "dc1.example.test",
|
||||
[nameof(LibLdapOptions.Port)] = 6360,
|
||||
[nameof(LibLdapOptions.Transport)] = LdapTransport.StartTls,
|
||||
[nameof(LibLdapOptions.AllowInsecure)] = true,
|
||||
[nameof(LibLdapOptions.SearchBase)] = "dc=example,dc=test",
|
||||
[nameof(LibLdapOptions.ServiceAccountDn)] = "cn=svc,dc=example,dc=test",
|
||||
[nameof(LibLdapOptions.ServiceAccountPassword)] = "s3cret",
|
||||
[nameof(LibLdapOptions.UserNameAttribute)] = "sAMAccountName",
|
||||
[nameof(LibLdapOptions.DisplayNameAttribute)] = "displayName",
|
||||
[nameof(LibLdapOptions.GroupAttribute)] = "memberOfX",
|
||||
[nameof(LibLdapOptions.ConnectionTimeoutMs)] = 4321,
|
||||
[nameof(LibLdapOptions.BindMode)] = LdapBindMode.User,
|
||||
[nameof(LibLdapOptions.UserBindTemplate)] = "EXAMPLE\\{0}",
|
||||
[nameof(LibLdapOptions.AcceptDomainQualifiedNames)] = false,
|
||||
[nameof(LibLdapOptions.FallbackServers)] = new List<string> { "dc2.example.test", "dc3.example.test:6361" },
|
||||
};
|
||||
|
||||
private static IEnumerable<PropertyInfo> LibrarySettableProperties() =>
|
||||
typeof(LibLdapOptions)
|
||||
.GetProperties(BindingFlags.Public | BindingFlags.Instance)
|
||||
.Where(p => p.SetMethod is { IsPublic: true }); // init-only setters are public SetMethods
|
||||
|
||||
/// <summary>Every allow-listed name still exists on the library type (no stale entries).</summary>
|
||||
[Fact]
|
||||
public void Allow_list_has_no_stale_entries()
|
||||
{
|
||||
var names = LibrarySettableProperties().Select(p => p.Name).ToHashSet(StringComparer.Ordinal);
|
||||
foreach (var unmapped in IntentionallyUnmapped.Keys)
|
||||
names.ShouldContain(unmapped, $"allow-listed '{unmapped}' no longer exists on the library LdapOptions");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Every library property is allow-listed or has a test value AND a same-named OtOpcUa option,
|
||||
/// and no property is both (a mapped property must not hide behind the allow-list).
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void Every_library_property_is_mapped_or_allow_listed()
|
||||
{
|
||||
foreach (var lib in LibrarySettableProperties())
|
||||
{
|
||||
var allowListed = IntentionallyUnmapped.ContainsKey(lib.Name);
|
||||
var hasValue = NonDefaultValues.ContainsKey(lib.Name);
|
||||
(allowListed ^ hasValue).ShouldBeTrue(
|
||||
$"library LdapOptions.{lib.Name} must be either projected by ToLibraryOptions() (add a " +
|
||||
"non-default value to NonDefaultValues) or allow-listed with a reason — exactly one");
|
||||
if (allowListed) continue;
|
||||
|
||||
typeof(LdapOptions).GetProperty(lib.Name, BindingFlags.Public | BindingFlags.Instance)
|
||||
.ShouldNotBeNull($"OtOpcUa LdapOptions has no '{lib.Name}' property to bind it from configuration");
|
||||
}
|
||||
|
||||
// Reverse direction for the test data itself: no value for a property the library dropped.
|
||||
var libNames = LibrarySettableProperties().Select(p => p.Name).ToHashSet(StringComparer.Ordinal);
|
||||
foreach (var key in NonDefaultValues.Keys)
|
||||
libNames.ShouldContain(key, $"NonDefaultValues has '{key}', which the library LdapOptions no longer has");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Setting each non-default value on OtOpcUa's options makes it arrive in the projected library
|
||||
/// options — compared by content for lists — and each value really differs from the library
|
||||
/// default, so the assertion could fail.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ToLibraryOptions_projects_every_mapped_property()
|
||||
{
|
||||
var app = new LdapOptions();
|
||||
foreach (var (name, value) in NonDefaultValues)
|
||||
typeof(LdapOptions).GetProperty(name)!.SetValue(app, value);
|
||||
|
||||
var projected = app.ToLibraryOptions();
|
||||
var libDefaults = new LibLdapOptions();
|
||||
|
||||
foreach (var (name, expected) in NonDefaultValues)
|
||||
{
|
||||
var prop = typeof(LibLdapOptions).GetProperty(name)!;
|
||||
var actual = prop.GetValue(projected);
|
||||
var libDefault = prop.GetValue(libDefaults);
|
||||
|
||||
ValuesEqual(libDefault, expected).ShouldBeFalse(
|
||||
$"test value for {name} equals the library default, so it cannot prove the mapping");
|
||||
ValuesEqual(actual, expected).ShouldBeTrue(
|
||||
$"ToLibraryOptions() did not carry {name}: expected {Render(expected)}, got {Render(actual)}");
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>The projected list is a copy: mutating OtOpcUa's list afterwards does not reach it.</summary>
|
||||
[Fact]
|
||||
public void FallbackServers_projection_is_a_snapshot()
|
||||
{
|
||||
var app = new LdapOptions { FallbackServers = ["dc2"] };
|
||||
var projected = app.ToLibraryOptions();
|
||||
app.FallbackServers.Add("dc3");
|
||||
|
||||
projected.FallbackServers.ShouldBe(["dc2"]);
|
||||
}
|
||||
|
||||
/// <summary>OtOpcUa's defaults for the four lmxopcua#913 properties equal the library's.</summary>
|
||||
[Fact]
|
||||
public void New_properties_default_to_the_library_defaults()
|
||||
{
|
||||
var app = new LdapOptions();
|
||||
var lib = new LibLdapOptions();
|
||||
|
||||
app.FallbackServers.ShouldBeEmpty();
|
||||
lib.FallbackServers.ShouldBeEmpty();
|
||||
app.BindMode.ShouldBe(lib.BindMode);
|
||||
app.UserBindTemplate.ShouldBe(lib.UserBindTemplate);
|
||||
app.AcceptDomainQualifiedNames.ShouldBe(lib.AcceptDomainQualifiedNames);
|
||||
}
|
||||
|
||||
private static bool ValuesEqual(object? a, object? b)
|
||||
{
|
||||
if (a is IEnumerable ea && a is not string && b is IEnumerable eb && b is not string)
|
||||
return ea.Cast<object?>().SequenceEqual(eb.Cast<object?>());
|
||||
return Equals(a, b);
|
||||
}
|
||||
|
||||
private static string Render(object? value) =>
|
||||
value is IEnumerable e && value is not string
|
||||
? "[" + string.Join(", ", e.Cast<object?>()) + "]"
|
||||
: value?.ToString() ?? "null";
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Microsoft.Extensions.Options;
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
using ZB.MOM.WW.OtOpcUa.Security.Ldap;
|
||||
using LdapTransport = ZB.MOM.WW.Auth.Abstractions.Ldap.LdapTransport;
|
||||
using LibLdapAuthService = ZB.MOM.WW.Auth.Ldap.LdapAuthService;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Security.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// lmxopcua#913 — the production <see cref="OtOpcUaLdapAuthService"/> used to build the shared
|
||||
/// library service with no logger, and the library logs only through <c>_logger?.</c>, so failover
|
||||
/// hops, the <c>sticky preference moved</c> line and the stage diagnostics never reached the log.
|
||||
/// This resolves the service through DI (the real constructor) against two CLOSED loopback ports —
|
||||
/// no directory is contacted — and asserts the library's per-endpoint Warning appears for BOTH the
|
||||
/// primary and the configured fallback: that proves the library logger is injected AND that
|
||||
/// <c>FallbackServers</c> reaches the library.
|
||||
/// </summary>
|
||||
public sealed class OtOpcUaLdapAuthServiceLoggingTests
|
||||
{
|
||||
private static int ClosedLoopbackPort()
|
||||
{
|
||||
var listener = new TcpListener(IPAddress.Loopback, 0);
|
||||
listener.Start();
|
||||
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
|
||||
listener.Stop();
|
||||
return port;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Library_failover_warnings_reach_the_host_log_for_primary_and_fallback()
|
||||
{
|
||||
var primaryPort = ClosedLoopbackPort();
|
||||
var fallbackPort = ClosedLoopbackPort();
|
||||
var logs = new CapturingLoggerProvider();
|
||||
|
||||
var services = new ServiceCollection();
|
||||
services.AddLogging(l => l.AddProvider(logs).SetMinimumLevel(LogLevel.Trace));
|
||||
services.AddSingleton(Options.Create(new LdapOptions
|
||||
{
|
||||
Enabled = true,
|
||||
Server = "127.0.0.1",
|
||||
Port = primaryPort,
|
||||
Transport = LdapTransport.None,
|
||||
AllowInsecure = true,
|
||||
SearchBase = "dc=zb,dc=local",
|
||||
ConnectionTimeoutMs = 2000,
|
||||
FallbackServers = [$"127.0.0.1:{fallbackPort}"],
|
||||
}));
|
||||
services.AddSingleton<OtOpcUaLdapAuthService>();
|
||||
await using var sp = services.BuildServiceProvider();
|
||||
|
||||
var sut = sp.GetRequiredService<OtOpcUaLdapAuthService>();
|
||||
var result = await sut.AuthenticateAsync("alice", "pw", TestContext.Current.CancellationToken);
|
||||
|
||||
result.Success.ShouldBeFalse();
|
||||
result.IsSystemFailure.ShouldBeTrue("both endpoints are unreachable — a system-side failure");
|
||||
|
||||
var libraryWarnings = logs.Entries
|
||||
.Where(e => e.Category == typeof(LibLdapAuthService).FullName && e.Level == LogLevel.Warning)
|
||||
.Select(e => e.Message)
|
||||
.ToList();
|
||||
libraryWarnings.ShouldContain(m => m.Contains($"127.0.0.1:{primaryPort}") && m.Contains("failed system-side"),
|
||||
"the library's own Warning for the primary endpoint must reach the host log");
|
||||
libraryWarnings.ShouldContain(m => m.Contains($"127.0.0.1:{fallbackPort}") && m.Contains("failed system-side"),
|
||||
"the fallback endpoint must be tried (FallbackServers projected) and its failure logged");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user