Files
scadaproj/ZB.MOM.WW.Auth/tests/ZB.MOM.WW.Auth.Ldap.Tests/LdapGroupLookupTests.cs
T
Joseph Doherty f5ef0efedd feat(auth): 0.5.0 passwordless group lookup ILdapGroupLookup (ScadaBridge#46)
ILdapGroupLookup.GetUserGroupsAsync(username, ct) re-reads a known user's
groups with the service account: same extraction, canonicalisation, endpoint
walk (FallbackServers), timeouts and TLS policy as AuthenticateAsync, via one
shared WalkEndpoints<T>. Explicit statuses: Found, UserNotFound, UserDisabled
(AD userAccountControl), AmbiguousUser, DirectoryUnavailable, NotSupported
(BindMode=User / no service account / foreign ILdapAuthService),
ProviderDisabled. AddZbLdapAuth registers it as the same singleton.

0.5.0 is the first published version carrying 0.4.2-0.4.4; scadaproj#51 was
live-verified against the NAM AD (24/24, identity check mutation-proven).

Claude-Session: https://claude.ai/code/session_01GT67ACmpMR7b9LGRPLijMi
2026-11-12 20:11:16 -05:00

343 lines
13 KiB
C#

using ZB.MOM.WW.Auth.Abstractions.Ldap;
namespace ZB.MOM.WW.Auth.Ldap.Tests;
/// <summary>
/// 0.5.0 passwordless group lookup (<see cref="ILdapGroupLookup"/>): statuses, parity with
/// <see cref="LdapAuthService.AuthenticateAsync"/>'s group set, the shared failover walk, and the
/// configurations that cannot search without a password.
/// </summary>
public class LdapGroupLookupTests
{
private static LdapOptions Opts(params string[] fallbacks) => new()
{
Enabled = true,
Server = "dc1",
Port = 636,
Transport = LdapTransport.Ldaps,
SearchBase = "dc=x",
ServiceAccountDn = "cn=svc,dc=x",
ServiceAccountPassword = "svcpw",
UserNameAttribute = "sAMAccountName",
DisplayNameAttribute = "displayName",
FallbackServers = fallbacks,
};
private static FakeLdapConnection Alice(string? userAccountControl = null)
{
var extra = new Dictionary<string, string[]> { ["sAMAccountName"] = new[] { "Alice" } };
if (userAccountControl is not null)
extra["userAccountControl"] = new[] { userAccountControl };
return new FakeLdapConnection().WithUserEntry(
"cn=Alice,ou=people,dc=x",
new[] { "cn=Operators,ou=g,dc=x", @"cn=Eng\,ineers,ou=g,dc=x" },
displayName: "Alice Smith",
extraAttributes: extra);
}
// ---- the happy path and parity with AuthenticateAsync ----
[Fact]
public async Task Found_ReturnsCanonicalNameDisplayNameAndGroups_WithServiceAccountOnly()
{
var fake = Alice();
var svc = new LdapAuthService(Opts(), new FakeLdapConnectionFactory(fake));
var result = await svc.GetUserGroupsAsync(" alice ", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.Found, result.Status);
Assert.True(result.IsFound);
Assert.Equal("Alice", result.Username); // directory spelling, not the typed one
Assert.Equal("Alice Smith", result.DisplayName);
Assert.Equal(new[] { "Operators", "Eng,ineers" }, result.Groups);
// Exactly one bind, as the service account — never a bind as the user.
Assert.Equal(new[] { "cn=svc,dc=x" }, fake.BoundDns);
Assert.Equal(1, fake.BindAttempts);
Assert.Contains("search:(sAMAccountName=alice)", fake.Calls);
Assert.Contains("userAccountControl", fake.SearchAttributes!);
}
[Fact]
public async Task Found_MatchesTheGroupSetAuthenticateAsyncReturns()
{
var lookup = await new LdapAuthService(Opts(), new FakeLdapConnectionFactory(Alice()))
.GetUserGroupsAsync("alice", CancellationToken.None);
var login = await new LdapAuthService(Opts(), new FakeLdapConnectionFactory(Alice()))
.AuthenticateAsync("alice", "pw", CancellationToken.None);
Assert.True(login.Succeeded);
Assert.Equal(login.Groups, lookup.Groups);
Assert.Equal(login.Username, lookup.Username);
Assert.Equal(login.DisplayName, lookup.DisplayName);
}
[Fact]
public async Task Found_WithZeroGroups_IsFoundWithAnEmptySet()
{
var fake = new FakeLdapConnection().WithUserEntry("cn=bob,dc=x", Array.Empty<string>());
var svc = new LdapAuthService(Opts(), new FakeLdapConnectionFactory(fake));
var result = await svc.GetUserGroupsAsync("bob", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.Found, result.Status);
Assert.Empty(result.Groups);
}
// ---- directory answers ----
[Fact]
public async Task NoEntry_IsUserNotFound()
{
var svc = new LdapAuthService(Opts(), new FakeLdapConnectionFactory(new FakeLdapConnection().WithNoMatch()));
var result = await svc.GetUserGroupsAsync("ghost", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.UserNotFound, result.Status);
Assert.Empty(result.Groups);
Assert.Equal("", result.Username);
}
[Fact]
public async Task TwoEntries_IsAmbiguousUser()
{
var svc = new LdapAuthService(Opts(), new FakeLdapConnectionFactory(new FakeLdapConnection().WithDuplicateMatch()));
var result = await svc.GetUserGroupsAsync("dup", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.AmbiguousUser, result.Status);
Assert.Empty(result.Groups);
}
[Theory]
[InlineData("514")] // NORMAL_ACCOUNT | ACCOUNTDISABLE
[InlineData("66050")] // + DONT_EXPIRE_PASSWORD
[InlineData("2")]
public async Task AccountDisableFlag_IsUserDisabled_AndReturnsNoGroups(string uac)
{
var svc = new LdapAuthService(Opts(), new FakeLdapConnectionFactory(Alice(uac)));
var result = await svc.GetUserGroupsAsync("alice", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.UserDisabled, result.Status);
Assert.Empty(result.Groups);
}
[Theory]
[InlineData("512")] // NORMAL_ACCOUNT
[InlineData("66048")] // + DONT_EXPIRE_PASSWORD
[InlineData("garbage")] // unparseable is "not disabled", never a fault
public async Task EnabledOrUnparseableAccountControl_IsFound(string uac)
{
var svc = new LdapAuthService(Opts(), new FakeLdapConnectionFactory(Alice(uac)));
var result = await svc.GetUserGroupsAsync("alice", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.Found, result.Status);
}
// ---- system-side faults and failover ----
[Fact]
public async Task ConnectFailure_OnOnlyEndpoint_IsDirectoryUnavailable()
{
var svc = new LdapAuthService(Opts(), new FakeLdapConnectionFactory(new FakeLdapConnection().ThrowOnConnect()));
var result = await svc.GetUserGroupsAsync("alice", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.DirectoryUnavailable, result.Status);
}
[Fact]
public async Task ServiceBindFailure_IsDirectoryUnavailable_NotUserNotFound()
{
var svc = new LdapAuthService(Opts(), new FakeLdapConnectionFactory(Alice().ThrowOnServiceBind()));
var result = await svc.GetUserGroupsAsync("alice", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.DirectoryUnavailable, result.Status);
}
[Fact]
public async Task SearchFailure_IsDirectoryUnavailable()
{
var svc = new LdapAuthService(Opts(), new FakeLdapConnectionFactory(Alice().ThrowOnSearch()));
var result = await svc.GetUserGroupsAsync("alice", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.DirectoryUnavailable, result.Status);
}
[Fact]
public async Task ConnectFailure_FailsOverToFallback_AndFindsTheUser()
{
var factory = new SequenceLdapConnectionFactory(new FakeLdapConnection().ThrowOnConnect(), Alice());
var svc = new LdapAuthService(Opts("dc2:3894"), factory);
var result = await svc.GetUserGroupsAsync("alice", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.Found, result.Status);
Assert.Equal(2, factory.Created.Count);
Assert.Equal(("dc2", 3894), (factory.Created[1].ConnectArgs!.Value.Host, factory.Created[1].ConnectArgs!.Value.Port));
}
[Fact]
public async Task SearchFailure_FailsOverToFallback()
{
var factory = new SequenceLdapConnectionFactory(Alice().ThrowOnSearch(), Alice());
var svc = new LdapAuthService(Opts("dc2"), factory);
var result = await svc.GetUserGroupsAsync("alice", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.Found, result.Status);
Assert.Equal(2, factory.Created.Count);
}
[Fact]
public async Task UserNotFound_IsFinal_AndDoesNotFailOver()
{
var factory = new SequenceLdapConnectionFactory(new FakeLdapConnection(), Alice());
var svc = new LdapAuthService(Opts("dc2"), factory);
var result = await svc.GetUserGroupsAsync("alice", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.UserNotFound, result.Status);
Assert.Single(factory.Created);
}
[Fact]
public async Task AllEndpointsDown_IsDirectoryUnavailable_AfterTryingEach()
{
var factory = new SequenceLdapConnectionFactory(
new FakeLdapConnection().ThrowOnConnect(), new FakeLdapConnection().ThrowOnServiceBind());
var svc = new LdapAuthService(Opts("dc2"), factory);
var result = await svc.GetUserGroupsAsync("alice", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.DirectoryUnavailable, result.Status);
Assert.Equal(2, factory.Created.Count);
}
[Fact]
public async Task StickyPreference_IsSharedWithAuthentication()
{
// A lookup that fails over to dc2 makes dc2 preferred for the next sign-in too.
var factory = new SequenceLdapConnectionFactory(
new FakeLdapConnection().ThrowOnConnect(), Alice(), Alice());
var svc = new LdapAuthService(Opts("dc2"), factory);
await svc.GetUserGroupsAsync("alice", CancellationToken.None);
var login = await svc.AuthenticateAsync("alice", "pw", CancellationToken.None);
Assert.True(login.Succeeded);
Assert.Equal(3, factory.Created.Count);
Assert.Equal("dc2", factory.Created[2].ConnectArgs!.Value.Host);
}
[Fact]
public async Task UsesConfiguredTransportTimeoutAndCertificatePolicy()
{
System.Net.Security.RemoteCertificateValidationCallback callback = (_, _, _, _) => true;
var fake = Alice();
var options = Opts() with { Transport = LdapTransport.StartTls, ConnectionTimeoutMs = 1234, ServerCertificateValidationCallback = callback };
var svc = new LdapAuthService(options, new FakeLdapConnectionFactory(fake));
await svc.GetUserGroupsAsync("alice", CancellationToken.None);
Assert.Equal(LdapTransport.StartTls, fake.ConnectArgs!.Value.Transport);
Assert.Equal(1234, fake.ConnectArgs!.Value.TimeoutMs);
Assert.Same(callback, fake.ConnectCertCallback);
}
// ---- configurations that cannot look up ----
[Fact]
public async Task UserBindMode_IsNotSupported_WithoutTouchingTheNetwork()
{
var fake = Alice();
var options = Opts() with { BindMode = LdapBindMode.User, UserBindTemplate = @"X\{0}", ServiceAccountDn = "" };
var svc = new LdapAuthService(options, new FakeLdapConnectionFactory(fake));
var result = await svc.GetUserGroupsAsync("alice", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.NotSupported, result.Status);
Assert.Empty(fake.Calls);
}
[Fact]
public async Task UserBindMode_IsNotSupported_EvenWithAServiceAccountConfigured()
{
var fake = Alice();
var options = Opts() with { BindMode = LdapBindMode.User, UserBindTemplate = @"X\{0}" };
var svc = new LdapAuthService(options, new FakeLdapConnectionFactory(fake));
var result = await svc.GetUserGroupsAsync("alice", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.NotSupported, result.Status);
Assert.Empty(fake.Calls);
}
[Fact]
public async Task BlankServiceAccount_IsNotSupported_NeverAnAnonymousBind()
{
var fake = Alice();
var svc = new LdapAuthService(Opts() with { ServiceAccountDn = " " }, new FakeLdapConnectionFactory(fake));
var result = await svc.GetUserGroupsAsync("alice", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.NotSupported, result.Status);
Assert.Empty(fake.Calls);
}
[Fact]
public async Task DisabledProvider_IsProviderDisabled_WithoutTouchingTheNetwork()
{
var fake = Alice();
var svc = new LdapAuthService(Opts() with { Enabled = false }, new FakeLdapConnectionFactory(fake));
var result = await svc.GetUserGroupsAsync("alice", CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.ProviderDisabled, result.Status);
Assert.Empty(fake.Calls);
}
[Theory]
[InlineData(null)]
[InlineData("")]
[InlineData(" ")]
public async Task BlankUsername_IsUserNotFound_WithoutTouchingTheNetwork(string? username)
{
var fake = Alice();
var svc = new LdapAuthService(Opts(), new FakeLdapConnectionFactory(fake));
var result = await svc.GetUserGroupsAsync(username!, CancellationToken.None);
Assert.Equal(LdapGroupLookupStatus.UserNotFound, result.Status);
Assert.Empty(fake.Calls);
}
[Fact]
public async Task FilterMetacharacters_AreEscaped()
{
var fake = new FakeLdapConnection();
var svc = new LdapAuthService(Opts(), new FakeLdapConnectionFactory(fake));
await svc.GetUserGroupsAsync("*)(cn=*", CancellationToken.None);
Assert.Contains(@"search:(sAMAccountName=\2a\29\28cn=\2a)", fake.Calls);
}
[Fact]
public async Task CancelledToken_Throws()
{
var svc = new LdapAuthService(Opts(), new FakeLdapConnectionFactory(Alice()));
using var cts = new CancellationTokenSource();
cts.Cancel();
await Assert.ThrowsAnyAsync<OperationCanceledException>(() => svc.GetUserGroupsAsync("alice", cts.Token));
}
[Fact]
public void Of_RefusesFound()
=> Assert.Throws<ArgumentException>(() => LdapGroupLookupResult.Of(LdapGroupLookupStatus.Found));
}