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().SequenceEqual(eb.Cast()); + return Equals(a, b); + } + + private static string Render(object? value) => + value is IEnumerable e && value is not string + ? "[" + string.Join(", ", e.Cast()) + "]" + : value?.ToString() ?? "null"; +} diff --git a/tests/Server/ZB.MOM.WW.OtOpcUa.Security.Tests/OtOpcUaLdapAuthServiceLoggingTests.cs b/tests/Server/ZB.MOM.WW.OtOpcUa.Security.Tests/OtOpcUaLdapAuthServiceLoggingTests.cs new file mode 100644 index 000000000..ba8c5e3b0 --- /dev/null +++ b/tests/Server/ZB.MOM.WW.OtOpcUa.Security.Tests/OtOpcUaLdapAuthServiceLoggingTests.cs @@ -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; + +/// +/// lmxopcua#913 — the production used to build the shared +/// library service with no logger, and the library logs only through _logger?., so failover +/// hops, the sticky preference moved 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 +/// FallbackServers reaches the library. +/// +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(); + await using var sp = services.BuildServiceProvider(); + + var sut = sp.GetRequiredService(); + 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"); + } +}