Complete Identifier and Add New Tests

mckaragoz · mckaragoz · commit 77a11bc74381 · 2026-02-27T21:19:58.000+03:00
diff --git a/samples/blazor-server/CodeBeam.UltimateAuth.Sample.BlazorServer/Components/Dialogs/IdentifierDialog.razor b/samples/blazor-server/CodeBeam.UltimateAuth.Sample.BlazorServer/Components/Dialogs/IdentifierDialog.razor
@@ -54,11 +54,12 @@
             </PagerContent>
         </MudDataGrid>
 
-        <MudExpansionPanels>
+        <MudExpansionPanels Class="mt-2">
             <MudExpansionPanel Text="Add New Identifier" Expanded="false">
-                <MudStack Spacing="2">
+                <MudStack Row="true" Wrap="Wrap.Wrap" Spacing="2">
                     <MudSelectExtended @bind-Value="_newIdentifierType" ItemCollection="@(Enum.GetValues<UserIdentifierType>())" Variant="Variant.Outlined" Label="Type" />
                     <MudTextField @bind-Value="_newIdentifierValue" Variant="Variant.Outlined" Label="Value" />
+                    <MudSwitchM3 @bind-Value="_newIdentifierPrimary" Label="Primary" Color="Color.Primary" />
                     <MudButton Color="Color.Primary" OnClick="AddNewIdentifier">Add</MudButton>
                 </MudStack>
             </MudExpansionPanel>
@@ -75,6 +76,7 @@
 @code {
     private UserIdentifierType _newIdentifierType;
     private string? _newIdentifierValue;
+    private bool _newIdentifierPrimary;
 
     [CascadingParameter]
     private IMudDialogInstance MudDialog { get; set; } = default!;
@@ -113,9 +115,11 @@
         }
         else
         {
-            Snackbar.Add("Failed to update identifier", Severity.Error);
+            Snackbar.Add(result?.Problem?.Detail ?? result?.Problem?.Title ?? "Failed to update identifier", Severity.Error);
         }
 
+        var getResult = await UAuthClient.Identifiers.GetMyIdentifiersAsync();
+        _identifiers = getResult.Value?.ToList() ?? new List<UserIdentifierDto>();
         return DataGridEditFormAction.Close;
     }
 
@@ -130,7 +134,8 @@
         AddUserIdentifierRequest request = new()
         {
             Type = _newIdentifierType,
-            Value = _newIdentifierValue
+            Value = _newIdentifierValue,
+            IsPrimary = _newIdentifierPrimary
         };
 
         var result = await UAuthClient.Identifiers.AddSelfAsync(request);
diff --git a/src/CodeBeam.UltimateAuth.Server/Extensions/ServiceCollectionExtensions.cs b/src/CodeBeam.UltimateAuth.Server/Extensions/ServiceCollectionExtensions.cs
@@ -208,7 +208,7 @@ private static IServiceCollection AddUltimateAuthServerInternal(this IServiceCol
         services.TryAddScoped<IRefreshResponsePolicy, RefreshResponsePolicy>();
         services.TryAddSingleton<IAuthStore, InMemoryAuthStore>();
         services.TryAddScoped<ICurrentUser, HttpContextCurrentUser>();
-        services.TryAddScoped<IIdentifierNormalizer, IdentifierNormalizer>();
+        services.TryAddSingleton<IIdentifierNormalizer, IdentifierNormalizer>();
 
         services.TryAddScoped<IHubCapabilities, HubCapabilities>();
 
diff --git a/src/users/CodeBeam.UltimateAuth.Users.InMemory/Infrastructure/InMemoryUserSeedContributor.cs b/src/users/CodeBeam.UltimateAuth.Users.InMemory/Infrastructure/InMemoryUserSeedContributor.cs
@@ -41,8 +41,7 @@ public async Task SeedAsync(TenantKey tenant, CancellationToken ct = default)
         await SeedUserAsync(tenant, _ids.GetUserUserId(), "Standard User", "user", "user@ultimateauth.com", "9876543210", ct);
     }
 
-    private async Task SeedUserAsync(TenantKey tenant, UserKey userKey, string displayName, string primaryUsername,
-        string primaryEmail, string primaryPhone, CancellationToken ct)
+    private async Task SeedUserAsync(TenantKey tenant, UserKey userKey, string displayName, string username, string email, string phone, CancellationToken ct)
     {
         if (await _lifecycle.ExistsAsync(tenant, userKey, ct))
             return;
@@ -65,19 +64,23 @@ await _profiles.CreateAsync(tenant,
                 CreatedAt = _clock.UtcNow
             }, ct);
 
-        await _identifiers.CreateAsync(tenant,
-            new UserIdentifier
-            {
-                Id = Guid.NewGuid(),
-                Tenant = tenant,
-                UserKey = userKey,
-                Type = UserIdentifierType.Username,
-                Value = primaryUsername,
-                NormalizedValue = _identifierNormalizer.Normalize(UserIdentifierType.Username, primaryUsername).Normalized,
-                IsPrimary = true,
-                IsVerified = true,
-                CreatedAt = _clock.UtcNow
-            }, ct);
+        var usernameIdentifier = new UserIdentifier
+        {
+            Id = Guid.NewGuid(),
+            Tenant = tenant,
+            UserKey = userKey,
+            Type = UserIdentifierType.Username,
+            Value = username,
+            NormalizedValue = _identifierNormalizer
+                .Normalize(UserIdentifierType.Username, username)
+                .Normalized,
+            IsPrimary = true,
+            IsVerified = true,
+            CreatedAt = _clock.UtcNow
+        };
+
+        await _identifiers.CreateAsync(tenant, usernameIdentifier, ct);
+        await _identifiers.SetPrimaryAsync(usernameIdentifier.Id, _clock.UtcNow, ct);
 
         await _identifiers.CreateAsync(tenant,
             new UserIdentifier
@@ -86,8 +89,10 @@ await _identifiers.CreateAsync(tenant,
                 Tenant = tenant,
                 UserKey = userKey,
                 Type = UserIdentifierType.Email,
-                Value = primaryEmail,
-                NormalizedValue = _identifierNormalizer.Normalize(UserIdentifierType.Username, primaryEmail).Normalized,
+                Value = email,
+                NormalizedValue = _identifierNormalizer
+                    .Normalize(UserIdentifierType.Email, email)
+                    .Normalized,
                 IsPrimary = true,
                 IsVerified = true,
                 CreatedAt = _clock.UtcNow
@@ -100,8 +105,10 @@ await _identifiers.CreateAsync(tenant,
                 Tenant = tenant,
                 UserKey = userKey,
                 Type = UserIdentifierType.Phone,
-                Value = primaryPhone,
-                NormalizedValue = _identifierNormalizer.Normalize(UserIdentifierType.Username, primaryPhone).Normalized,
+                Value = phone,
+                NormalizedValue = _identifierNormalizer
+                    .Normalize(UserIdentifierType.Phone, phone)
+                    .Normalized,
                 IsPrimary = true,
                 IsVerified = true,
                 CreatedAt = _clock.UtcNow
diff --git a/src/users/CodeBeam.UltimateAuth.Users.InMemory/Stores/InMemoryUserIdentifierStore.cs b/src/users/CodeBeam.UltimateAuth.Users.InMemory/Stores/InMemoryUserIdentifierStore.cs
@@ -91,6 +91,20 @@ public Task CreateAsync(TenantKey tenant, UserIdentifier identifier, Cancellatio
 
         identifier.Tenant = tenant;
 
+        if (identifier.IsPrimary)
+        {
+            foreach (var existing in _store.Values.Where(x =>
+                         x.Tenant == tenant &&
+                         x.UserKey == identifier.UserKey &&
+                         x.Type == identifier.Type &&
+                         x.IsPrimary &&
+                         !x.IsDeleted))
+            {
+                existing.IsPrimary = false;
+                existing.UpdatedAt = identifier.CreatedAt;
+            }
+        }
+
         _store[identifier.Id] = identifier;
 
         return Task.CompletedTask;
diff --git a/src/users/CodeBeam.UltimateAuth.Users.Reference/Services/UserApplicationService.cs b/src/users/CodeBeam.UltimateAuth.Users.Reference/Services/UserApplicationService.cs
@@ -228,7 +228,11 @@ public async Task<IReadOnlyList<UserIdentifierDto>> GetIdentifiersByUserAsync(Ac
     {
         var command = new GetUserIdentifierCommand(async innerCt =>
         {
-            var identifier = await _identifierStore.GetAsync(context.ResourceTenant, type, value, innerCt);
+            var normalized = _identifierNormalizer.Normalize(type, value);
+            if (!normalized.IsValid)
+                return null;
+
+            var identifier = await _identifierStore.GetAsync(context.ResourceTenant, type, normalized.Normalized, innerCt);
             return identifier is null ? null : UserIdentifierMapper.ToDto(identifier);
         });
 
@@ -243,7 +247,9 @@ public async Task<bool> UserIdentifierExistsAsync(AccessContext context, UserIde
             if (!normalized.IsValid)
                 return false;
 
-            var result = await _identifierStore.ExistsAsync(new IdentifierExistenceQuery(context.ResourceTenant, type, normalized.Normalized, scope), innerCt);
+            UserKey? userKey = scope == IdentifierExistenceScope.WithinUser ? context.GetTargetUserKey() : null;
+
+            var result = await _identifierStore.ExistsAsync(new IdentifierExistenceQuery(context.ResourceTenant, type, normalized.Normalized, scope, userKey), innerCt);
             return result.Exists;
         });
 
@@ -338,6 +344,19 @@ public async Task UpdateUserIdentifierAsync(AccessContext context, UpdateUserIde
             if (string.Equals(identifier.NormalizedValue, normalized.Normalized, StringComparison.Ordinal))
                 throw new UAuthIdentifierValidationException("identifier_value_unchanged");
 
+            var withinUserResult = await _identifierStore.ExistsAsync(
+                new IdentifierExistenceQuery(
+                    identifier.Tenant,
+                    identifier.Type,
+                    normalized.Normalized,
+                    IdentifierExistenceScope.WithinUser,
+                    UserKey: identifier.UserKey,
+                    ExcludeIdentifierId: identifier.Id),
+                innerCt);
+
+            if (withinUserResult.Exists)
+                throw new UAuthIdentifierConflictException("identifier_already_exists_for_user");
+
             var mustBeUnique = _options.LoginIdentifiers.EnforceGlobalUniquenessForAllIdentifiers ||
                 (identifier.IsPrimary && _options.LoginIdentifiers.AllowedTypes.Contains(identifier.Type));
 
@@ -360,7 +379,7 @@ public async Task UpdateUserIdentifierAsync(AccessContext context, UpdateUserIde
                     throw new UAuthIdentifierConflictException("identifier_already_exists");
             }
 
-            await _identifierStore.UpdateValueAsync(identifier.Id, request.NewValue, normalized.Normalized, resetVerification: true, _clock.UtcNow, innerCt);
+            await _identifierStore.UpdateValueAsync(identifier.Id, request.NewValue, normalized.Normalized, _clock.UtcNow, innerCt);
         });
 
         await _accessOrchestrator.ExecuteAsync(context, command, ct);
@@ -381,30 +400,13 @@ public async Task SetPrimaryUserIdentifierAsync(AccessContext context, SetPrimar
 
             EnsureVerificationRequirements(identifier.Type, identifier.IsVerified);
 
-            //var identifiers = await _identifierStore.GetByUserAsync(identifier.Tenant, identifier.UserKey, innerCt);
-            //var activeIdentifiers = identifiers.Where(i => !i.IsDeleted).ToList();
-
             var result = await _identifierStore.ExistsAsync(
                 new IdentifierExistenceQuery(identifier.Tenant, identifier.Type, identifier.NormalizedValue, IdentifierExistenceScope.TenantPrimaryOnly, ExcludeIdentifierId: identifier.Id), innerCt);
 
             if (result.Exists)
                 throw new UAuthIdentifierConflictException("identifier_already_exists");
 
-            //var userIdentifiers =
-            //await _identifierStore.GetByUserAsync(identifier.Tenant, identifier.UserKey, innerCt);
-
-            //var existingPrimaryOfSameType = userIdentifiers
-            //    .FirstOrDefault(i =>
-            //        !i.IsDeleted &&
-            //        i.Type == identifier.Type &&
-            //        i.IsPrimary);
-
-            //if (existingPrimaryOfSameType is not null)
-            //{
-            //    await _identifierStore.UnsetPrimaryAsync(existingPrimaryOfSameType.Id, innerCt);
-            //}
-
-            await _identifierStore.SetPrimaryAsync(request.IdentifierId, innerCt);
+            await _identifierStore.SetPrimaryAsync(request.IdentifierId, _clock.UtcNow, innerCt);
         });
 
         await _accessOrchestrator.ExecuteAsync(context, command, ct);
@@ -439,7 +441,7 @@ public async Task UnsetPrimaryUserIdentifierAsync(AccessContext context, UnsetPr
                 throw new UAuthIdentifierConflictException("cannot_unset_last_login_identifier");
             }
 
-            await _identifierStore.UnsetPrimaryAsync(request.IdentifierId, innerCt);
+            await _identifierStore.UnsetPrimaryAsync(request.IdentifierId, _clock.UtcNow, innerCt);
         });
 
         await _accessOrchestrator.ExecuteAsync(context, command, ct);
diff --git a/tests/CodeBeam.UltimateAuth.Tests.Unit/Helpers/TestAccessContext.cs b/tests/CodeBeam.UltimateAuth.Tests.Unit/Helpers/TestAccessContext.cs
@@ -1,4 +1,5 @@
 ﻿using CodeBeam.UltimateAuth.Core.Contracts;
+using CodeBeam.UltimateAuth.Core.Domain;
 using CodeBeam.UltimateAuth.Core.MultiTenancy;
 
 namespace CodeBeam.UltimateAuth.Tests.Unit.Helpers;
@@ -19,4 +20,21 @@ public static AccessContext WithAction(string action)
             attributes: EmptyAttributes.Instance
         );
     }
+
+    public static AccessContext ForUser(UserKey userKey, string action, TenantKey? tenant = null)
+    {
+        var t = tenant ?? TenantKey.Single;
+
+        return new AccessContext(
+            actorUserKey: userKey,
+            actorTenant: t,
+            isAuthenticated: true,
+            isSystemActor: false,
+            resource: "identifier",
+            targetUserKey: userKey,
+            resourceTenant: t,
+            action: action,
+            attributes: EmptyAttributes.Instance
+        );
+    }
 }
diff --git a/tests/CodeBeam.UltimateAuth.Tests.Unit/Helpers/TestAuthRuntime.cs b/tests/CodeBeam.UltimateAuth.Tests.Unit/Helpers/TestAuthRuntime.cs
@@ -67,4 +67,10 @@ public ValueTask<AuthFlowContext> CreateLoginFlowAsync(TenantKey? tenant = null)
         var httpContext = TestHttpContext.Create(tenant);
         return Services.GetRequiredService<IAuthFlowContextFactory>().CreateAsync(httpContext, AuthFlowType.Login);
     }
+
+    public IUserApplicationService GetUserApplicationService()
+    {
+        var scope = Services.CreateScope();
+        return scope.ServiceProvider.GetRequiredService<IUserApplicationService>();
+    }
 }
diff --git a/tests/CodeBeam.UltimateAuth.Tests.Unit/Users/UserIdentifierApplicationServiceTests.cs b/tests/CodeBeam.UltimateAuth.Tests.Unit/Users/UserIdentifierApplicationServiceTests.cs

Original file line number	Diff line number	Diff line change
`@@ -67,4 +67,10 @@ public ValueTask<AuthFlowContext> CreateLoginFlowAsync(TenantKey? tenant = null)`
`67`	`67`	`var httpContext = TestHttpContext.Create(tenant);`
`68`	`68`	`return Services.GetRequiredService<IAuthFlowContextFactory>().CreateAsync(httpContext, AuthFlowType.Login);`
`69`	`69`	`}`
	`70`	`+`
	`71`	`+ public IUserApplicationService GetUserApplicationService()`
	`72`	`+ {`
	`73`	`+ var scope = Services.CreateScope();`
	`74`	`+ return scope.ServiceProvider.GetRequiredService<IUserApplicationService>();`
	`75`	`+ }`
`70`	`76`	`}`