diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.Host/Configuration/LdapOptionsValidator.cs b/src/Server/ZB.MOM.WW.OtOpcUa.Host/Configuration/LdapOptionsValidator.cs
index f24b690ce..d9d7777a4 100644
--- a/src/Server/ZB.MOM.WW.OtOpcUa.Host/Configuration/LdapOptionsValidator.cs
+++ b/src/Server/ZB.MOM.WW.OtOpcUa.Host/Configuration/LdapOptionsValidator.cs
@@ -1,5 +1,6 @@
using ZB.MOM.WW.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.Configuration;
@@ -9,9 +10,13 @@ namespace ZB.MOM.WW.OtOpcUa.Host.Configuration;
/// ZB.MOM.WW.Configuration. When LDAP login
/// is enabled, Server and SearchBase must be set and Port must be a valid
/// TCP port; when disabled — or when DevStubMode bypasses the real bind — all checks are
-/// skipped. ServiceAccountDn/Password are
-/// intentionally not required — an empty pair selects the direct-bind path (see
-/// ). Failure messages use "Ldap:" as a
+/// skipped. ServiceAccountDn/Password are intentionally not required: there is no
+/// direct-bind path (an empty DN binds anonymously in the shared library), but DEV boots on the
+/// code defaults with an empty DN and every node validates LDAP, so requiring it would stop DEV
+/// and QA booting (lmxopcua#913, NAM cutover plan review B2). Of the shared library's own
+/// ZB.MOM.WW.Auth.Ldap.LdapOptionsValidator — which OtOpcUa does NOT run — only the
+/// FallbackServers parse rule and the BindMode=User → UserBindTemplate rule
+/// are ported here. Failure messages use "Ldap:" as a
/// human-readable field prefix — not the literal bound section path, which is
/// Security:Ldap (see ).
///
@@ -55,5 +60,74 @@ public sealed class LdapOptionsValidator : OptionsValidatorBase
// session activation, and no remaining LDAP consumer runs on that path.
builder.RequireThat(options.ConnectionTimeoutMs > 0,
"Ldap:ConnectionTimeoutMs must be > 0.");
+
+ // Ported from the shared library's validator (lmxopcua#913). The library walks fallback
+ // endpoints on a system-side failure and silently skips an entry it cannot parse, so a
+ // typo'd backup DC would only surface during the primary outage it exists to survive.
+ foreach (var entry in options.FallbackServers ?? [])
+ {
+ builder.RequireThat(TryParseEndpoint(entry, out var error),
+ $"Ldap:FallbackServers contains an invalid entry — {error}. " +
+ "Each entry must be \"host\" or \"host:port\" (port 1–65535).");
+ }
+
+ // Ported from the shared library's validator (lmxopcua#913): in User mode the template IS the
+ // bind identity, so without exactly one {0} every login would bind as one fixed name (or with
+ // the user spliced in twice). The ServiceAccountDn-required branch is deliberately NOT ported.
+ if (options.BindMode == LdapBindMode.User)
+ {
+ builder.RequireThat(CountPlaceholders(options.UserBindTemplate) == 1,
+ "Ldap:UserBindTemplate must contain {0} exactly once when Ldap:BindMode is User — " +
+ "e.g. \"EXAMPLE\\{0}\".");
+ }
+ }
+
+ ///
+ /// Mirrors the shared library's internal LdapEndpointParser.TryParse (0.4.1): "host"
+ /// or "host:port", surrounding whitespace tolerated, no IPv6 literals, port 1–65535.
+ ///
+ /// The configured fallback entry.
+ /// A human-readable reason on failure; empty on success.
+ /// when the entry parses.
+ internal static bool TryParseEndpoint(string? entry, out string error)
+ {
+ error = string.Empty;
+ if (string.IsNullOrWhiteSpace(entry))
+ {
+ error = "entry is empty or whitespace";
+ return false;
+ }
+
+ var trimmed = entry.Trim();
+ var parts = trimmed.Split(':');
+ if (parts.Length > 2)
+ {
+ error = $"entry \"{trimmed}\" contains more than one ':' (IPv6 literals are not supported — use a DNS name)";
+ return false;
+ }
+
+ if (parts[0].Trim().Length == 0)
+ {
+ error = $"entry \"{trimmed}\" has an empty host";
+ return false;
+ }
+
+ if (parts.Length == 2 && (!int.TryParse(parts[1].Trim(), out var port) || port is < 1 or > 65535))
+ {
+ error = $"entry \"{trimmed}\" has an invalid port (must be 1–65535)";
+ return false;
+ }
+
+ return true;
+ }
+
+ private static int CountPlaceholders(string? template)
+ {
+ if (string.IsNullOrEmpty(template)) return 0;
+ var count = 0;
+ for (var i = template.IndexOf("{0}", StringComparison.Ordinal); i >= 0;
+ i = template.IndexOf("{0}", i + 3, StringComparison.Ordinal))
+ count++;
+ return count;
}
}
diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.Security/Ldap/LdapOptions.cs b/src/Server/ZB.MOM.WW.OtOpcUa.Security/Ldap/LdapOptions.cs
index d5ebb39f8..3e37dbccf 100644
--- a/src/Server/ZB.MOM.WW.OtOpcUa.Security/Ldap/LdapOptions.cs
+++ b/src/Server/ZB.MOM.WW.OtOpcUa.Security/Ldap/LdapOptions.cs
@@ -5,9 +5,11 @@ namespace ZB.MOM.WW.OtOpcUa.Security.Ldap;
///
/// LDAP + role-mapping configuration for the Admin UI. Bound from appsettings.json
-/// Security:Ldap section. Defaults point at the shared GLAuth dev instance on the
-/// Linux Docker host (10.100.0.35:3893) — see docs/security.md §"LDAP bind
-/// flow" and CLAUDE.md §"LDAP Authentication" for setup details.
+/// Security:Ldap section. The code defaults are localhost:3893, plaintext
+/// () and search base dc=zb,dc=local — the GLAuth
+/// shape; the shipped overlays and service environment point it at a real directory. See
+/// docs/security.md §"LDAP bind flow" and docs/Configuration.md
+/// §"Security:Ldap" for setup details.
///
///
/// Carries both the wire fields the shared ZB.MOM.WW.Auth.Ldap directory client needs
@@ -54,8 +56,11 @@ public sealed class LdapOptions
public string SearchBase { get; set; } = "dc=zb,dc=local";
///
- /// Service-account DN used for search-then-bind. When empty, a direct-bind with
- /// cn={user},{SearchBase} is attempted.
+ /// Service-account DN used for search-then-bind in
+ /// mode. There is no direct-bind fallback: when empty, the shared library binds with an empty
+ /// DN (an anonymous bind), which works against GLAuth's anonymous search but not against
+ /// Active Directory. Not required at startup (DEV boots on the empty default — lmxopcua#913);
+ /// unused in mode.
///
public string ServiceAccountDn { get; set; } = string.Empty;
@@ -100,9 +105,46 @@ public sealed class LdapOptions
///
public int ConnectionTimeoutMs { get; set; } = 10_000;
+ ///
+ /// Ordered fallback LDAP endpoints (e.g. a second domain controller), tried when the primary
+ /// fails system-side (connect/TLS, service-account bind, or search). Each entry is
+ /// "host" (adopts ) or "host:port"; validated at startup.
+ /// Empty (the default) disables failover. Endpoint preference is sticky. Projected into the
+ /// library's .
+ ///
+ public List FallbackServers { get; set; } = [];
+
+ ///
+ /// Selects the authentication flow: (default —
+ /// bind as the service account, search for the user, re-bind as the user) or
+ /// (bind as the signing-in user via
+ /// ; no service account). Projected into the library's
+ /// .
+ ///
+ public LdapBindMode BindMode { get; set; } = LdapBindMode.ServiceAccount;
+
+ ///
+ /// only: the simple-bind identity with {0} replaced by
+ /// the normalised login name — prefer the down-level form DOMAIN\{0}. Must contain
+ /// {0} exactly once when is
+ /// (validated at startup).
+ ///
+ public string UserBindTemplate { get; set; } = string.Empty;
+
+ ///
+ /// only: when true (default) a login typed as
+ /// DOMAIN\name or name@suffix is reduced to name; when false such
+ /// input is refused. Has no effect in mode — there,
+ /// users type the bare login name (sAMAccountName on AD).
+ ///
+ public bool AcceptDomainQualifiedNames { get; set; } = true;
+
///
/// Projects the wire fields onto the shared ZB.MOM.WW.Auth.Ldap
- /// the directory client consumes. App-only concerns
+ /// the directory client consumes. Every settable library property
+ /// must be mapped here or allow-listed in LdapOptionsProjectionCompletenessTests — a
+ /// dropped property (as FallbackServers/BindMode once were, lmxopcua#913) is
+ /// silently ignored config. App-only concerns
/// (, ) have no library counterpart and are
/// handled by the app wrapper around the library service; is carried
/// through so the library's own feature gate stays consistent with the app master switch.
@@ -122,5 +164,11 @@ public sealed class LdapOptions
DisplayNameAttribute = DisplayNameAttribute,
GroupAttribute = GroupAttribute,
ConnectionTimeoutMs = ConnectionTimeoutMs,
+ FallbackServers = [.. FallbackServers],
+ BindMode = BindMode,
+ UserBindTemplate = UserBindTemplate,
+ AcceptDomainQualifiedNames = AcceptDomainQualifiedNames,
+ // ServerCertificateValidationCallback is intentionally NOT mapped: it is a code-only seam
+ // in the library (not config-bindable). The completeness test allow-lists it.
};
}
diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.Security/Ldap/OtOpcUaLdapAuthService.cs b/src/Server/ZB.MOM.WW.OtOpcUa.Security/Ldap/OtOpcUaLdapAuthService.cs
index 6ddf8bb50..43affb873 100644
--- a/src/Server/ZB.MOM.WW.OtOpcUa.Security/Ldap/OtOpcUaLdapAuthService.cs
+++ b/src/Server/ZB.MOM.WW.OtOpcUa.Security/Ldap/OtOpcUaLdapAuthService.cs
@@ -44,8 +44,16 @@ public sealed class OtOpcUaLdapAuthService : ILdapAuthService
///
/// The app LDAP options (wire fields + app-only concerns).
/// The logger.
- public OtOpcUaLdapAuthService(IOptions options, ILogger logger)
- : this(options.Value, new LibLdapAuthService(options.Value.ToLibraryOptions()), logger)
+ ///
+ /// The shared library service's own logger. Without it the library is silent: no
+ /// per-endpoint failover Warning, no LDAP sticky preference moved to … line, no
+ /// system-side stage diagnostics (lmxopcua#913).
+ ///
+ public OtOpcUaLdapAuthService(
+ IOptions options,
+ ILogger logger,
+ ILogger libraryLogger)
+ : this(options.Value, new LibLdapAuthService(options.Value.ToLibraryOptions(), libraryLogger), logger)
{
}
diff --git a/tests/Server/ZB.MOM.WW.OtOpcUa.Host.IntegrationTests/LdapOptionsValidatorNamCutoverTests.cs b/tests/Server/ZB.MOM.WW.OtOpcUa.Host.IntegrationTests/LdapOptionsValidatorNamCutoverTests.cs
new file mode 100644
index 000000000..58d72aef9
--- /dev/null
+++ b/tests/Server/ZB.MOM.WW.OtOpcUa.Host.IntegrationTests/LdapOptionsValidatorNamCutoverTests.cs
@@ -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;
+
+///
+/// lmxopcua#913 — OtOpcUa's own ports ONLY two rules from the
+/// shared library's validator (which OtOpcUa does not run): every FallbackServers entry
+/// parses as host[:port], and BindMode=User needs a UserBindTemplate with
+/// {0} exactly once. The library's ServiceAccountDn-required rule is deliberately NOT
+/// ported: DEV boots on the code defaults with an empty DN (NAM cutover plan, review B2).
+///
+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,
+ };
+
+ ///
+ /// Review B2: today's DEV shape — Enabled=true, Server=localhost,
+ /// ServiceAccountDn="", Transport=Ldaps — must keep passing.
+ ///
+ [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);
+ }
+
+ /// The same DEV shape boots through the host's real registration path
+ /// (AddValidatedOptions + ValidateOnStart) when bound from configuration.
+ [Fact]
+ public void Dev_shaped_config_survives_AddValidatedOptions()
+ {
+ var configuration = new ConfigurationBuilder()
+ .AddInMemoryCollection(new Dictionary
+ {
+ ["Security:Ldap:Enabled"] = "true",
+ ["Security:Ldap:Server"] = "localhost",
+ ["Security:Ldap:ServiceAccountDn"] = "",
+ ["Security:Ldap:Transport"] = "Ldaps",
+ })
+ .Build();
+ var services = new ServiceCollection();
+ services.AddValidatedOptions(configuration, LdapOptions.SectionName);
+ using var sp = services.BuildServiceProvider();
+
+ Should.NotThrow(() => sp.GetRequiredService>().Value);
+ }
+
+ /// Two well-formed fallback DCs (bare host and host:port) pass.
+ [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();
+ }
+
+ /// Each malformed fallback entry fails with a field-naming message.
+ [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"));
+ }
+
+ /// User mode with exactly one placeholder passes — and needs no ServiceAccountDn.
+ [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();
+ }
+
+ /// User mode with zero or two placeholders fails.
+ [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"));
+ }
+
+ /// ServiceAccount mode ignores the template rule (the template is User-only).
+ [Fact]
+ public void ServiceAccount_mode_ignores_an_empty_template()
+ {
+ var options = Valid();
+ options.BindMode = LdapBindMode.ServiceAccount;
+ options.UserBindTemplate = "";
+
+ Sut.Validate(null, options).Succeeded.ShouldBeTrue();
+ }
+
+ /// The ported rules follow the existing gate: disabled or DevStub configs skip them.
+ [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();
+ }
+
+ ///
+ /// Binding test: Security:Ldap:FallbackServers:0 and the other three lmxopcua#913 keys
+ /// reach the LIBRARY options, from JSON and from Security__Ldap__… environment variables.
+ ///
+ [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
+ {
+ ["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();
+ 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();
+ }
+ }
+}
diff --git a/tests/Server/ZB.MOM.WW.OtOpcUa.Security.Tests/LdapOptionsProjectionCompletenessTests.cs b/tests/Server/ZB.MOM.WW.OtOpcUa.Security.Tests/LdapOptionsProjectionCompletenessTests.cs
new file mode 100644
index 000000000..a18cb8a23
--- /dev/null
+++ b/tests/Server/ZB.MOM.WW.OtOpcUa.Security.Tests/LdapOptionsProjectionCompletenessTests.cs
@@ -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;
+
+///
+/// lmxopcua#913 — once silently dropped
+/// FallbackServers, BindMode, UserBindTemplate and
+/// AcceptDomainQualifiedNames, so the AdminUI had no DC failover and the config keys were
+/// ignored without error. This guard reflects over the shared library's
+/// in BOTH directions:
+///
+/// every settable library property is either projected by ToLibraryOptions()
+/// (a non-default value set on OtOpcUa's options arrives in the library options) or is
+/// named in ; and
+/// every entry still exists on the library type (no
+/// stale allow-list).
+///
+/// A library upgrade that adds a property therefore fails here until it is mapped or allow-listed.
+///
+public sealed class LdapOptionsProjectionCompletenessTests
+{
+ /// Library properties deliberately not projected, each with its reason.
+ private static readonly IReadOnlyDictionary IntentionallyUnmapped =
+ new Dictionary(StringComparer.Ordinal)
+ {
+ [nameof(LibLdapOptions.ServerCertificateValidationCallback)] =
+ "code-only TLS hook in the library; not bindable from configuration",
+ };
+
+ ///
+ /// 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.
+ ///
+ private static readonly IReadOnlyDictionary NonDefaultValues =
+ new Dictionary(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 { "dc2.example.test", "dc3.example.test:6361" },
+ };
+
+ private static IEnumerable LibrarySettableProperties() =>
+ typeof(LibLdapOptions)
+ .GetProperties(BindingFlags.Public | BindingFlags.Instance)
+ .Where(p => p.SetMethod is { IsPublic: true }); // init-only setters are public SetMethods
+
+ /// Every allow-listed name still exists on the library type (no stale entries).
+ [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");
+ }
+
+ ///
+ /// 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).
+ ///
+ [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");
+ }
+
+ ///
+ /// 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.
+ ///
+ [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)}");
+ }
+ }
+
+ /// The projected list is a copy: mutating OtOpcUa's list afterwards does not reach it.
+ [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"]);
+ }
+
+ /// OtOpcUa's defaults for the four lmxopcua#913 properties equal the library's.
+ [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