/* * Licensed under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0) * See https://github.com/openiddict/openiddict-core for more information concerning * the license and the contributors participating to this project. */ using System.Collections.Immutable; using System.Net; using System.Net.Http.Headers; using System.Security.Claims; using System.Text; using System.Text.Encodings.Web; using System.Text.Json; using Microsoft.AspNetCore.Authentication; using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Routing; using Microsoft.AspNetCore.TestHost; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Options; using Microsoft.IdentityModel.Tokens; using Moq; using Xunit; namespace OpenIddict.Server.AspNetCore.IntegrationTests; public class OpenIddictServerAspNetCoreAdminApiTests { private const string Policy = "openiddict-admin"; [Fact] public void MapOpenIddictAdminApi_ThrowsAnExceptionForNullOrEmptyPolicy() { // Arrange var endpoints = Mock.Of(); // Act and assert Assert.Throws(() => endpoints.MapOpenIddictAdminApi(policy: null!)); Assert.Throws(() => endpoints.MapOpenIddictAdminApi(policy: string.Empty)); } [Fact] public async Task AdminApi_RejectsUnauthenticatedRequests() { // Arrange var manager = new Mock(); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: null); // Act var response = await client.GetAsync("/openiddict/admin/applications"); // Assert Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); manager.VerifyNoOtherCalls(); } [Fact] public async Task AdminApi_RejectsRequestsNotSatisfyingThePolicy() { // Arrange var manager = new Mock(); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "user"); // Act var response = await client.DeleteAsync("/openiddict/admin/applications/1"); // Assert Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode); manager.VerifyNoOtherCalls(); } [Fact] public async Task AdminApi_UsesTheConfiguredPrefix() { // Arrange var manager = new Mock(); manager.Setup(mock => mock.ListAsync(It.IsAny(), It.IsAny(), It.IsAny())) .Returns(EnumerateAsync()); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object), prefix: "/management"); using var client = CreateClient(host, role: "admin"); // Act var response = await client.GetAsync("/management/applications"); var fallback = await client.GetAsync("/openiddict/admin/applications"); // Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal("[]", await response.Content.ReadAsStringAsync()); Assert.Equal(HttpStatusCode.NotFound, fallback.StatusCode); } [Fact] public async Task ListApplications_ReturnsApplicationsWithoutClientSecrets() { // Arrange var application = new object(); var manager = new Mock(); manager.Setup(mock => mock.ListAsync(5, 10, It.IsAny())) .Returns(EnumerateAsync(application)); manager.Setup(mock => mock.GetIdAsync(application, It.IsAny())) .ReturnsAsync("1"); manager.Setup(mock => mock.PopulateAsync(It.IsAny(), application, It.IsAny())) .Callback((OpenIddictApplicationDescriptor descriptor, object _, CancellationToken _) => { descriptor.ClientId = "Fabrikam"; descriptor.ClientSecret = "hashed-secret"; descriptor.ClientType = ClientTypes.Confidential; descriptor.Permissions.Add(Permissions.Endpoints.Token); descriptor.RedirectUris.Add(new Uri("https://fabrikam.com/callback")); descriptor.Settings["setting"] = "value"; }) .Returns(ValueTask.CompletedTask); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.GetAsync("/openiddict/admin/applications?count=5&offset=10"); // Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Contains("no-store", response.Headers.CacheControl?.ToString(), StringComparison.Ordinal); using var document = JsonDocument.Parse(await response.Content.ReadAsStringAsync()); var item = Assert.Single(document.RootElement.EnumerateArray()); Assert.Equal("1", item.GetProperty("id").GetString()); Assert.Equal("Fabrikam", item.GetProperty("client_id").GetString()); Assert.Equal(ClientTypes.Confidential, item.GetProperty("client_type").GetString()); Assert.Equal(Permissions.Endpoints.Token, Assert.Single(item.GetProperty("permissions").EnumerateArray()).GetString()); Assert.Equal("https://fabrikam.com/callback", Assert.Single(item.GetProperty("redirect_uris").EnumerateArray()).GetString()); Assert.Equal("value", item.GetProperty("settings").GetProperty("setting").GetString()); Assert.False(item.TryGetProperty("client_secret", out _)); Assert.DoesNotContain("hashed-secret", await response.Content.ReadAsStringAsync(), StringComparison.Ordinal); } [Theory] [InlineData("count=0")] [InlineData("count=1001")] [InlineData("count=abc")] [InlineData("offset=-1")] public async Task ListApplications_RejectsInvalidPaginationParameters(string query) { // Arrange var manager = new Mock(); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.GetAsync("/openiddict/admin/applications?" + query); // Assert Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); using var document = JsonDocument.Parse(await response.Content.ReadAsStringAsync()); Assert.Equal(Errors.InvalidRequest, document.RootElement.GetProperty("error").GetString()); manager.VerifyNoOtherCalls(); } [Fact] public async Task AdminApi_ThrowsAnExceptionWhenCoreServicesAreMissing() { // Arrange using var host = await CreateHostAsync(services => { }); using var client = CreateClient(host, role: "admin"); // Act and assert var exception = await Assert.ThrowsAsync(() => client.GetAsync("/openiddict/admin/applications")); Assert.Equal(SR.GetResourceString(SR.ID0564), exception.Message); } [Fact] public async Task GetApplication_ReturnsJsonWebKeySetWithoutPrivateKeyParameters() { // Arrange var application = new object(); var manager = new Mock(); manager.Setup(mock => mock.FindByIdAsync("1", It.IsAny())) .ReturnsAsync(application); manager.Setup(mock => mock.PopulateAsync(It.IsAny(), application, It.IsAny())) .Callback((OpenIddictApplicationDescriptor descriptor, object _, CancellationToken _) => descriptor.JsonWebKeySet = JsonWebKeySet.Create(""" { "keys": [ { "kty": "RSA", "kid": "key-1", "use": "sig", "n": "bW9kdWx1cw", "e": "AQAB", "d": "cHJpdmF0ZS1leHBvbmVudA", "p": "cHJpbWUtMQ", "q": "cHJpbWUtMg", "dp": "ZXhwb25lbnQtMQ", "dq": "ZXhwb25lbnQtMg", "qi": "Y29lZmZpY2llbnQ" }, { "kty": "oct", "kid": "key-2", "k": "c3ltbWV0cmljLXNlY3JldA" } ] } """)) .Returns(ValueTask.CompletedTask); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.GetAsync("/openiddict/admin/applications/1"); // Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); var content = await response.Content.ReadAsStringAsync(); using var document = JsonDocument.Parse(content); var keys = document.RootElement.GetProperty("json_web_key_set").GetProperty("keys").EnumerateArray().ToArray(); Assert.Equal(2, keys.Length); Assert.Equal("key-1", keys[0].GetProperty("kid").GetString()); Assert.Equal("bW9kdWx1cw", keys[0].GetProperty("n").GetString()); Assert.Equal("AQAB", keys[0].GetProperty("e").GetString()); Assert.Equal("key-2", keys[1].GetProperty("kid").GetString()); foreach (var parameter in (string[]) ["d", "p", "q", "dp", "dq", "qi", "k"]) { Assert.All(keys, key => Assert.False(key.TryGetProperty(parameter, out _))); } Assert.DoesNotContain("cHJpdmF0ZS1leHBvbmVudA", content, StringComparison.Ordinal); Assert.DoesNotContain("c3ltbWV0cmljLXNlY3JldA", content, StringComparison.Ordinal); } [Fact] public async Task GetApplication_ReturnsNotFoundForUnknownApplications() { // Arrange var manager = new Mock(); manager.Setup(mock => mock.FindByIdAsync("unknown", It.IsAny())) .ReturnsAsync(value: null); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.GetAsync("/openiddict/admin/applications/unknown"); // Assert Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); } [Fact] public async Task CreateApplication_CreatesApplicationFromDescriptor() { // Arrange var application = new object(); OpenIddictApplicationDescriptor? created = null; var manager = new Mock(); manager.Setup(mock => mock.CreateAsync(It.IsAny(), It.IsAny())) .Callback((OpenIddictApplicationDescriptor descriptor, CancellationToken _) => created = descriptor) .ReturnsAsync(application); manager.Setup(mock => mock.GetIdAsync(application, It.IsAny())) .ReturnsAsync("42"); manager.Setup(mock => mock.PopulateAsync(It.IsAny(), application, It.IsAny())) .Callback((OpenIddictApplicationDescriptor descriptor, object _, CancellationToken _) => descriptor.ClientId = created!.ClientId) .Returns(ValueTask.CompletedTask); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.PostAsync("/openiddict/admin/applications", JsonContent(""" { "client_id": "Fabrikam", "client_secret": "7Fjfp0ZBr1KtDRbnfVdmIw", "client_type": "confidential", "display_name": "Fabrikam", "display_names": { "fr-FR": "Fabrikam (FR)" }, "permissions": [ "ept:token", "gt:client_credentials" ], "redirect_uris": [ "https://fabrikam.com/callback" ], "requirements": [ "ft:pkce" ], "settings": { "tkn_lft:act": "00:10:00" }, "properties": { "custom": { "value": 42 } } } """)); // Assert Assert.Equal(HttpStatusCode.Created, response.StatusCode); Assert.Equal("/openiddict/admin/applications/42", response.Headers.Location?.OriginalString); Assert.NotNull(created); Assert.Equal("Fabrikam", created.ClientId); Assert.Equal("7Fjfp0ZBr1KtDRbnfVdmIw", created.ClientSecret); Assert.Equal(ClientTypes.Confidential, created.ClientType); Assert.Equal("Fabrikam (FR)", created.DisplayNames[System.Globalization.CultureInfo.GetCultureInfo("fr-FR")]); Assert.True(created.Permissions.SetEquals(["ept:token", "gt:client_credentials"])); Assert.Equal(new Uri("https://fabrikam.com/callback"), Assert.Single(created.RedirectUris)); Assert.Equal("ft:pkce", Assert.Single(created.Requirements)); Assert.Equal("00:10:00", created.Settings["tkn_lft:act"]); Assert.Equal(42, created.Properties["custom"].GetProperty("value").GetInt32()); using var document = JsonDocument.Parse(await response.Content.ReadAsStringAsync()); Assert.Equal("42", document.RootElement.GetProperty("id").GetString()); Assert.Equal("Fabrikam", document.RootElement.GetProperty("client_id").GetString()); } [Fact] public async Task CreateApplication_RejectsNonJsonRequests() { // Arrange var manager = new Mock(); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.PostAsync("/openiddict/admin/applications", new FormUrlEncodedContent([new KeyValuePair("client_id", "Fabrikam")])); // Assert Assert.Equal(HttpStatusCode.UnsupportedMediaType, response.StatusCode); manager.VerifyNoOtherCalls(); } [Theory] [InlineData("""{ "unknown": "value" }""", "unknown")] [InlineData("""{ "client_id": 42 }""", "client_id")] [InlineData("""{ "redirect_uris": [ "/relative" ] }""", "redirect_uris")] [InlineData("""{ "display_names": { "@@@": "value" } }""", "display_names")] [InlineData("""{ "permissions": "ept:token" }""", "permissions")] public async Task CreateApplication_RejectsInvalidProperties(string payload, string property) { // Arrange var manager = new Mock(); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.PostAsync("/openiddict/admin/applications", JsonContent(payload)); // Assert Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); using var document = JsonDocument.Parse(await response.Content.ReadAsStringAsync()); Assert.Equal(SR.FormatID2242(property), document.RootElement.GetProperty("error_description").GetString()); manager.VerifyNoOtherCalls(); } [Fact] public async Task CreateApplication_ReturnsValidationErrors() { // Arrange var manager = new Mock(); manager.Setup(mock => mock.CreateAsync(It.IsAny(), It.IsAny())) .ThrowsAsync(new OpenIddictExceptions.ValidationException("Invalid application.", [new System.ComponentModel.DataAnnotations.ValidationResult("The client identifier cannot be null or empty.")])); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.PostAsync("/openiddict/admin/applications", JsonContent("{}")); // Assert Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); using var document = JsonDocument.Parse(await response.Content.ReadAsStringAsync()); Assert.Equal("The client identifier cannot be null or empty.", Assert.Single(document.RootElement.GetProperty("errors").EnumerateArray()).GetString()); } [Fact] public async Task UpdateApplication_MergesTheSpecifiedProperties() { // Arrange var application = new object(); OpenIddictApplicationDescriptor? updated = null; var manager = new Mock(); manager.Setup(mock => mock.FindByIdAsync("1", It.IsAny())) .ReturnsAsync(application); manager.Setup(mock => mock.GetIdAsync(application, It.IsAny())) .ReturnsAsync("1"); manager.Setup(mock => mock.PopulateAsync(It.IsAny(), application, It.IsAny())) .Callback((OpenIddictApplicationDescriptor descriptor, object _, CancellationToken _) => { descriptor.ClientId = "Fabrikam"; descriptor.DisplayName = "Old name"; descriptor.Permissions.Add(Permissions.Endpoints.Token); }) .Returns(ValueTask.CompletedTask); manager.Setup(mock => mock.UpdateAsync(application, It.IsAny(), It.IsAny())) .Callback((object _, OpenIddictApplicationDescriptor descriptor, CancellationToken _) => updated = descriptor) .Returns(ValueTask.CompletedTask); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.PatchAsync("/openiddict/admin/applications/1", JsonContent("""{ "display_name": "New name" }""")); // Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.NotNull(updated); Assert.Equal("Fabrikam", updated.ClientId); Assert.Equal("New name", updated.DisplayName); Assert.Equal(Permissions.Endpoints.Token, Assert.Single(updated.Permissions)); } [Fact] public async Task DeleteApplication_DeletesTheApplication() { // Arrange var application = new object(); var manager = new Mock(); manager.Setup(mock => mock.FindByIdAsync("1", It.IsAny())) .ReturnsAsync(application); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.DeleteAsync("/openiddict/admin/applications/1"); // Assert Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); manager.Verify(mock => mock.DeleteAsync(application, It.IsAny()), Times.Once()); } [Fact] public async Task DeleteApplication_ReturnsConflictForConcurrencyExceptions() { // Arrange var application = new object(); var manager = new Mock(); manager.Setup(mock => mock.FindByIdAsync("1", It.IsAny())) .ReturnsAsync(application); manager.Setup(mock => mock.DeleteAsync(application, It.IsAny())) .Returns(ValueTask.FromException(new OpenIddictExceptions.ConcurrencyException("Concurrency failure."))); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.DeleteAsync("/openiddict/admin/applications/1"); // Assert Assert.Equal(HttpStatusCode.Conflict, response.StatusCode); } [Fact] public async Task CreateScope_CreatesScopeFromDescriptor() { // Arrange var scope = new object(); OpenIddictScopeDescriptor? created = null; var manager = new Mock(); manager.Setup(mock => mock.CreateAsync(It.IsAny(), It.IsAny())) .Callback((OpenIddictScopeDescriptor descriptor, CancellationToken _) => created = descriptor) .ReturnsAsync(scope); manager.Setup(mock => mock.GetIdAsync(scope, It.IsAny())) .ReturnsAsync("s1"); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.PostAsync("/openiddict/admin/scopes", JsonContent("""{ "name": "api", "display_name": "API", "resources": [ "resource_server" ] }""")); // Assert Assert.Equal(HttpStatusCode.Created, response.StatusCode); Assert.NotNull(created); Assert.Equal("api", created.Name); Assert.Equal("API", created.DisplayName); Assert.Equal("resource_server", Assert.Single(created.Resources)); } [Fact] public async Task ListTokens_UsesFiltersWhenSpecified() { // Arrange var tokens = new[] { new object(), new object(), new object() }; var manager = new Mock(); manager.Setup(mock => mock.FindAsync(It.Is<(string? Subject, string? ApplicationId, string? Status, string? Type)>(query => string.Equals(query.Subject, "Bob", StringComparison.Ordinal) && string.Equals(query.ApplicationId, "app", StringComparison.Ordinal) && string.Equals(query.Status, Statuses.Valid, StringComparison.Ordinal) && query.Type == null), It.IsAny())) .Returns(EnumerateAsync(tokens)); manager.Setup(mock => mock.GetIdAsync(tokens[1], It.IsAny())) .ReturnsAsync("t2"); manager.Setup(mock => mock.PopulateAsync(It.IsAny(), tokens[1], It.IsAny())) .Callback((OpenIddictTokenDescriptor descriptor, object _, CancellationToken _) => { descriptor.Payload = "sensitive-payload"; descriptor.ReferenceId = "sensitive-reference"; descriptor.Subject = "Bob"; }) .Returns(ValueTask.CompletedTask); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.GetAsync("/openiddict/admin/tokens?subject=Bob&application_id=app&status=valid&count=1&offset=1"); // Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); var content = await response.Content.ReadAsStringAsync(); using var document = JsonDocument.Parse(content); var item = Assert.Single(document.RootElement.EnumerateArray()); Assert.Equal("t2", item.GetProperty("id").GetString()); Assert.Equal("Bob", item.GetProperty("subject").GetString()); Assert.DoesNotContain("sensitive", content, StringComparison.Ordinal); manager.Verify(mock => mock.ListAsync(It.IsAny(), It.IsAny(), It.IsAny()), Times.Never()); } [Fact] public async Task RevokeToken_RevokesTheToken() { // Arrange var token = new object(); var manager = new Mock(); manager.Setup(mock => mock.FindByIdAsync("t1", It.IsAny())) .ReturnsAsync(token); manager.Setup(mock => mock.TryRevokeAsync(token, It.IsAny())) .ReturnsAsync(true); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.PostAsync("/openiddict/admin/tokens/t1/revoke", JsonContent(string.Empty)); var form = await client.PostAsync("/openiddict/admin/tokens/t1/revoke", new StringContent(string.Empty)); // Assert Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); Assert.Equal(HttpStatusCode.UnsupportedMediaType, form.StatusCode); manager.Verify(mock => mock.TryRevokeAsync(token, It.IsAny()), Times.Once()); } [Fact] public async Task RevokeAuthorization_RevokesTheAssociatedTokens() { // Arrange var authorization = new object(); var manager = new Mock(); manager.Setup(mock => mock.FindByIdAsync("a1", It.IsAny())) .ReturnsAsync(authorization); manager.Setup(mock => mock.GetIdAsync(authorization, It.IsAny())) .ReturnsAsync("a1"); manager.Setup(mock => mock.TryRevokeAsync(authorization, It.IsAny())) .ReturnsAsync(true); var tokens = new Mock(); tokens.Setup(mock => mock.RevokeByAuthorizationIdAsync("a1", It.IsAny())) .ReturnsAsync(2); using var host = await CreateHostAsync(services => services .AddSingleton(manager.Object) .AddSingleton(tokens.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.PostAsync("/openiddict/admin/authorizations/a1/revoke", JsonContent("{}")); // Assert Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); manager.Verify(mock => mock.TryRevokeAsync(authorization, It.IsAny()), Times.Once()); tokens.Verify(mock => mock.RevokeByAuthorizationIdAsync("a1", It.IsAny()), Times.Once()); } [Fact] public async Task RevokeAuthorization_ReturnsConflictWhenRevocationFails() { // Arrange var authorization = new object(); var manager = new Mock(); manager.Setup(mock => mock.FindByIdAsync("a1", It.IsAny())) .ReturnsAsync(authorization); manager.Setup(mock => mock.TryRevokeAsync(authorization, It.IsAny())) .ReturnsAsync(false); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.PostAsync("/openiddict/admin/authorizations/a1/revoke", JsonContent("{}")); // Assert Assert.Equal(HttpStatusCode.Conflict, response.StatusCode); } [Fact] public async Task ListKeys_DoesNotReturnKeyMaterial() { // Arrange var key = new object(); var manager = new Mock(); manager.Setup(mock => mock.ListAsync(It.IsAny(), It.IsAny(), It.IsAny())) .Returns(EnumerateAsync(key)); manager.Setup(mock => mock.GetIdAsync(key, It.IsAny())) .ReturnsAsync("k1"); manager.Setup(mock => mock.PopulateAsync(It.IsAny(), key, It.IsAny())) .Callback((OpenIddictKeyDescriptor descriptor, object _, CancellationToken _) => { descriptor.Algorithm = SecurityAlgorithms.RsaSha256; descriptor.KeyId = "kid"; descriptor.Payload = "protected-key-material"; descriptor.Status = Statuses.Valid; }) .Returns(ValueTask.CompletedTask); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.GetAsync("/openiddict/admin/keys"); // Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); var content = await response.Content.ReadAsStringAsync(); using var document = JsonDocument.Parse(content); var item = Assert.Single(document.RootElement.EnumerateArray()); Assert.Equal("kid", item.GetProperty("key_id").GetString()); Assert.Equal(Statuses.Valid, item.GetProperty("status").GetString()); Assert.DoesNotContain("protected-key-material", content, StringComparison.Ordinal); } [Fact] public async Task RevokeKey_RevokesTheKey() { // Arrange var key = new object(); var manager = new Mock(); manager.Setup(mock => mock.FindByIdAsync("k1", It.IsAny())) .ReturnsAsync(key); manager.Setup(mock => mock.TryRevokeAsync(key, It.IsAny())) .ReturnsAsync(true); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.PostAsync("/openiddict/admin/keys/k1/revoke", JsonContent("{}")); // Assert Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); manager.Verify(mock => mock.TryRevokeAsync(key, It.IsAny()), Times.Once()); } [Fact] public async Task ListSessions_FiltersSessionsBySubjectAndLoginIdentifier() { // Arrange var session = new object(); var manager = new Mock(); manager.Setup(mock => mock.FindAsync(It.Is<(string?, string?, string?, string?, string?)>(query => query.Item1 == "Bob" && query.Item2 == "login"), It.IsAny())) .Returns(EnumerateAsync(session)); manager.Setup(mock => mock.GetIdAsync(session, It.IsAny())) .ReturnsAsync("s1"); manager.Setup(mock => mock.PopulateAsync(It.IsAny(), session, It.IsAny())) .Callback((OpenIddictSessionDescriptor descriptor, object _, CancellationToken _) => { descriptor.ApplicationId = "a1"; descriptor.ExpirationDate = new DateTimeOffset(2030, 1, 1, 0, 0, 0, TimeSpan.Zero); descriptor.LoginId = "login"; descriptor.Principal = new ClaimsPrincipal(new ClaimsIdentity([new Claim("secret", "value")])); descriptor.Status = Statuses.Valid; descriptor.Subject = "Bob"; }) .Returns(ValueTask.CompletedTask); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.GetAsync("/openiddict/admin/sessions?subject=Bob&login_id=login"); var content = await response.Content.ReadAsStringAsync(); // Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); using var document = JsonDocument.Parse(content); var item = Assert.Single(document.RootElement.EnumerateArray()); Assert.Equal("s1", item.GetProperty("id").GetString()); Assert.Equal("a1", item.GetProperty("application_id").GetString()); Assert.Equal("login", item.GetProperty("login_id").GetString()); Assert.Equal("Bob", item.GetProperty("subject").GetString()); Assert.Equal(Statuses.Valid, item.GetProperty("status").GetString()); Assert.NotEqual(JsonValueKind.Null, item.GetProperty("expiration_date").ValueKind); Assert.DoesNotContain("secret", content, StringComparison.Ordinal); } [Fact] public async Task GetSession_ReturnsNotFoundForUnknownSession() { // Arrange var manager = new Mock(); using var host = await CreateHostAsync(services => services.AddSingleton(manager.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.GetAsync("/openiddict/admin/sessions/unknown"); // Assert Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); } [Fact] public async Task TerminateSession_TerminatesTheSession() { // Arrange var service = new Mock(Mock.Of()); service.Setup(mock => mock.TerminateSessionAsync("s1", It.IsAny())) .ReturnsAsync(new OpenIddictServerSessionTerminationResult { SessionIds = ["s1", "s2"], NotifiedParticipants = [ new OpenIddictServerLogoutParticipant { ApplicationId = "a1", ClientId = "Fabrikam", SessionId = "s1" } ] }); using var host = await CreateHostAsync(services => services.AddSingleton(service.Object)); using var client = CreateClient(host, role: "admin"); // Act var response = await client.PostAsync("/openiddict/admin/sessions/s1/terminate", JsonContent(string.Empty)); var unknown = await client.PostAsync("/openiddict/admin/sessions/unknown/terminate", JsonContent(string.Empty)); // Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.NotFound, unknown.StatusCode); using var document = JsonDocument.Parse(await response.Content.ReadAsStringAsync()); Assert.Equal("s1 s2", string.Join(' ', document.RootElement.GetProperty("session_ids").EnumerateArray().Select(static value => value.GetString()))); Assert.Equal("Fabrikam", Assert.Single(document.RootElement.GetProperty("notified_clients").EnumerateArray()).GetString()); service.Verify(mock => mock.TerminateSessionAsync("s1", It.IsAny()), Times.Once()); } [Theory] [InlineData(false)] [InlineData(true)] public async Task TerminateSession_UsesTheServerServiceAndReportsConfigurationErrors(bool issuer) { // Arrange var session = new object(); var application = new object(); var sessions = new Mock(); sessions.Setup(mock => mock.FindByIdAsync("s1", It.IsAny())).ReturnsAsync(session); sessions.Setup(mock => mock.GetIdAsync(session, It.IsAny())).ReturnsAsync("s1"); sessions.Setup(mock => mock.HasStatusAsync(session, Statuses.Valid, It.IsAny())).ReturnsAsync(true); sessions.Setup(mock => mock.GetSubjectAsync(session, It.IsAny())).ReturnsAsync("Bob"); sessions.Setup(mock => mock.GetApplicationIdAsync(session, It.IsAny())).ReturnsAsync("a1"); sessions.Setup(mock => mock.TryRevokeAsync(session, It.IsAny())).ReturnsAsync(true); var applications = new Mock(); applications.Setup(mock => mock.FindByIdAsync("a1", It.IsAny())).ReturnsAsync(application); applications.Setup(mock => mock.GetClientIdAsync(application, It.IsAny())).ReturnsAsync("Fabrikam"); applications.Setup(mock => mock.GetSettingsAsync(application, It.IsAny())) .ReturnsAsync(ImmutableDictionary.CreateRange(StringComparer.Ordinal, [ KeyValuePair.Create(Settings.Logout.FrontchannelLogoutUri, "https://fabrikam.com/logout")])); using var host = await CreateHostAsync(services => { services.AddSingleton(sessions.Object); services.AddSingleton(applications.Object); services.AddSingleton(Mock.Of()); services.AddOpenIddict() .AddServer(options => { options.SetTokenEndpointUris("connect/token") .AllowClientCredentialsFlow() .EnableFrontchannelLogout(); if (issuer) { options.SetIssuer(new Uri("https://www.contoso.com/", UriKind.Absolute)); } options.AddEphemeralEncryptionKey() .AddEphemeralSigningKey(); }); }); using var client = CreateClient(host, role: "admin"); // Act var response = await client.PostAsync("/openiddict/admin/sessions/s1/terminate", JsonContent(string.Empty)); var content = await response.Content.ReadAsStringAsync(); // Assert if (issuer) { Assert.Equal(HttpStatusCode.OK, response.StatusCode); using var document = JsonDocument.Parse(content); Assert.Equal("s1", Assert.Single(document.RootElement.GetProperty("session_ids").EnumerateArray()).GetString()); Assert.StartsWith("https://fabrikam.com/logout?", Assert.Single( document.RootElement.GetProperty("frontchannel_logout_uris").EnumerateArray()).GetString(), StringComparison.Ordinal); } else { Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); Assert.Contains("SetIssuer", content, StringComparison.Ordinal); } } private static StringContent JsonContent(string payload) => new(payload, Encoding.UTF8, "application/json"); private static HttpClient CreateClient(IHost host, string? role) { var client = host.GetTestServer().CreateClient(); if (!string.IsNullOrEmpty(role)) { client.DefaultRequestHeaders.Add(TestAuthenticationHandler.HeaderName, role); } return client; } private static async Task CreateHostAsync(Action configuration, string prefix = OpenIddictServerAspNetCoreDefaults.AdminApiRoutePrefix) { var host = new HostBuilder() .ConfigureWebHost(builder => { builder.UseTestServer(); builder.ConfigureServices(services => { services.AddLogging(options => options.SetMinimumLevel(LogLevel.Warning)); services.AddRouting(); services.AddAuthentication(TestAuthenticationHandler.SchemeName) .AddScheme(TestAuthenticationHandler.SchemeName, options => { }); services.AddAuthorizationBuilder() .AddPolicy(Policy, policy => policy.RequireRole("admin")); configuration(services); }); builder.Configure(app => { app.UseRouting(); app.UseAuthentication(); app.UseAuthorization(); app.UseEndpoints(endpoints => endpoints.MapOpenIddictAdminApi(Policy, prefix)); }); }) .Build(); await host.StartAsync(); return host; } private static async IAsyncEnumerable EnumerateAsync(params object[] items) { foreach (var item in items) { yield return item; } await Task.CompletedTask; } private sealed class TestAuthenticationHandler(IOptionsMonitor options, ILoggerFactory logger, UrlEncoder encoder) : AuthenticationHandler(options, logger, encoder) { public const string HeaderName = "X-Test-Role"; public const string SchemeName = "Test"; protected override Task HandleAuthenticateAsync() { if (!Request.Headers.TryGetValue(HeaderName, out var role) || string.IsNullOrEmpty(role)) { return Task.FromResult(AuthenticateResult.NoResult()); } var identity = new ClaimsIdentity(SchemeName); identity.AddClaim(new Claim(ClaimTypes.Name, "admin")); identity.AddClaim(new Claim(ClaimTypes.Role, role.ToString())); return Task.FromResult(AuthenticateResult.Success( new AuthenticationTicket(new ClaimsPrincipal(identity), SchemeName))); } } }