Add HealthCheckResource_GetNotExisting_ReturnsOk test

devpro · devpro · commit 1d12e044abf5 · 2025-07-14T11:56:29.000+02:00
Replace FluentAssertions with AwesomeAssertions
Move files to libraries when not specific to project
diff --git a/Devpro.TerraformBackend.sln b/Devpro.TerraformBackend.sln
@@ -13,9 +13,9 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "0 - Solution Items", "0 - S
 		README.md = README.md
 	EndProjectSection
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "2 - Applications", "2 - Applications", "{6D13F54F-4547-49C7-8136-01BFB4BBEE1E}"
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "3 - Applications", "3 - Applications", "{6D13F54F-4547-49C7-8136-01BFB4BBEE1E}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "1 - Libraries", "1 - Libraries", "{E9839BEC-B050-43E9-8EFD-34659CC92D93}"
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "2 - Business", "2 - Business", "{E9839BEC-B050-43E9-8EFD-34659CC92D93}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WebApi", "src\WebApi\WebApi.csproj", "{5CD7A689-5ADB-4207-972E-6FA881AF1B1C}"
 EndProject
@@ -54,6 +54,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "pipelines", "pipelines", "{
 		.github\workflows\pkg.yaml = .github\workflows\pkg.yaml
 	EndProjectSection
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "1 - Framework", "1 - Framework", "{0C1E6968-B289-4378-84CF-B64E05E643A5}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -96,13 +98,13 @@ Global
 		{5CD7A689-5ADB-4207-972E-6FA881AF1B1C} = {6D13F54F-4547-49C7-8136-01BFB4BBEE1E}
 		{A5CAD112-C1E6-442B-BE0E-37C697030636} = {E9839BEC-B050-43E9-8EFD-34659CC92D93}
 		{0429A41A-2D3A-42D4-8736-5FC0F6F0FF0C} = {E9839BEC-B050-43E9-8EFD-34659CC92D93}
-		{49BF313A-4ED3-4BD2-9AEE-E44A5ED19C0C} = {E9839BEC-B050-43E9-8EFD-34659CC92D93}
+		{49BF313A-4ED3-4BD2-9AEE-E44A5ED19C0C} = {0C1E6968-B289-4378-84CF-B64E05E643A5}
 		{3C2E7F7E-1F8E-49D1-AD56-EC60BEB5299D} = {7B3738E0-6F86-4358-B55C-5AAD42B24F81}
-		{F23098F5-355B-46F0-BABE-3D6E23D8EED7} = {E9839BEC-B050-43E9-8EFD-34659CC92D93}
+		{F23098F5-355B-46F0-BABE-3D6E23D8EED7} = {0C1E6968-B289-4378-84CF-B64E05E643A5}
 		{001CB9EB-2F7E-4288-BA9B-1E01ED43B8FF} = {3C2E7F7E-1F8E-49D1-AD56-EC60BEB5299D}
 		{7F01D180-1A34-4377-B4E5-C852D8302CE7} = {7B3738E0-6F86-4358-B55C-5AAD42B24F81}
 		{B055FFAF-8261-43B1-866A-12E289D5D7DC} = {6D13F54F-4547-49C7-8136-01BFB4BBEE1E}
-		{19336002-C959-4E76-B112-861F93CF6423} = {E9839BEC-B050-43E9-8EFD-34659CC92D93}
+		{19336002-C959-4E76-B112-861F93CF6423} = {0C1E6968-B289-4378-84CF-B64E05E643A5}
 		{02EA681E-C7D8-13C7-8484-4AC65E1B71E8} = {7B3738E0-6F86-4358-B55C-5AAD42B24F81}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
diff --git a/src/Common.AspNetCore.WebApi/DependencyInjection/SwaggerServiceCollectionExtensions.cs b/src/Common.AspNetCore.WebApi/DependencyInjection/SwaggerServiceCollectionExtensions.cs
@@ -1,6 +1,8 @@
-﻿using Microsoft.OpenApi.Models;
+﻿using Devpro.Common.AspNetCore.WebApi.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.OpenApi.Models;
 
-namespace Devpro.TerraformBackend.WebApi.DependencyInjection;
+namespace Devpro.Common.AspNetCore.WebApi.DependencyInjection;
 
 public static class SwaggerServiceCollectionExtensions
 {
diff --git a/src/Common.AspNetCore/DependencyInjection/BehaviorServiceCollectionExtensions.cs b/src/Common.AspNetCore/DependencyInjection/BehaviorServiceCollectionExtensions.cs
@@ -1,15 +1,18 @@
-﻿using Microsoft.AspNetCore.Mvc;
+﻿using System.Linq;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 
-namespace Devpro.TerraformBackend.WebApi.DependencyInjection;
+namespace Devpro.Common.AspNetCore.DependencyInjection;
 
-internal static class BehaviorServiceCollectionExtensions
+public static class BehaviorServiceCollectionExtensions
 {
     /// <summary>
     /// Ensures that every time an invalid model state occurs in the API, a warning log is generated with the request path.
     /// </summary>
     /// <param name="services"></param>
     /// <returns></returns>
-    internal static IServiceCollection AddInvalidModelStateLog(this IServiceCollection services)
+    public static IServiceCollection AddInvalidModelStateLog(this IServiceCollection services)
     {
         services.PostConfigure<ApiBehaviorOptions>(options =>
         {
diff --git a/src/Common.AspNetCore/Formatters/RawRequestBodyFormatter.cs b/src/Common.AspNetCore/Formatters/RawRequestBodyFormatter.cs
@@ -4,7 +4,7 @@
 using Microsoft.AspNetCore.Mvc.Formatters;
 using Microsoft.Net.Http.Headers;
 
-namespace Devpro.Common.AspNetCore;
+namespace Devpro.Common.AspNetCore.Formatters;
 
 /// <summary>
 /// ASP.NET Core input formatter to manage raw request bodies.
diff --git a/src/Infrastructure.MongoDb/Repositories/StateRepository.cs b/src/Infrastructure.MongoDb/Repositories/StateRepository.cs
@@ -8,13 +8,9 @@
 
 namespace Devpro.TerraformBackend.Infrastructure.MongoDb.Repositories
 {
-    public class StateRepository : RepositoryBase, IStateRepository
+    public class StateRepository(IMongoClientFactory mongoClientFactory, ILogger<StateRepository> logger, MongoDbConfiguration configuration)
+        : RepositoryBase(mongoClientFactory, logger, configuration), IStateRepository
     {
-        public StateRepository(IMongoClientFactory mongoClientFactory, ILogger<StateRepository> logger, MongoDbConfiguration configuration)
-            : base(mongoClientFactory, logger, configuration)
-        {
-        }
-
         protected override string CollectionName => "tf_state";
 
         public async Task CreateAsync(string name, string jsonInput)
diff --git a/src/WebApi/Authentication/BasicAuthenticationHandler.cs b/src/WebApi/Authentication/BasicAuthenticationHandler.cs
@@ -12,31 +12,28 @@ public class BasicAuthenticationHandler(IOptionsMonitor<AuthenticationSchemeOpti
 {
     protected override Task<AuthenticateResult> HandleAuthenticateAsync()
     {
-        // raises an error if no authorization header
+        // checks authorization header
         if (!Request.Headers.ContainsKey("Authorization"))
         {
             return Task.FromResult(AuthenticateResult.Fail("Missing Authorization header"));
         }
 
         var authorizationHeader = Request.Headers.Authorization.ToString();
 
-        // raises an error if the authorization header is not Basic
+        // checks authorization header starts with Basic
         if (!authorizationHeader.StartsWith("Basic ", StringComparison.OrdinalIgnoreCase))
         {
             return Task.FromResult(AuthenticateResult.Fail("Authorization header does not start with 'Basic'"));
         }
 
-        // decrypts the authorization header and split out the client id/secret which is separated by the first ':'
+        // decrypts the authorization header and split out the client id/secret
         var authBase64Decoded = Encoding.UTF8.GetString(Convert.FromBase64String(authorizationHeader.Replace("Basic ", "", StringComparison.OrdinalIgnoreCase)));
         var authSplit = authBase64Decoded.Split([':'], 2);
-
-        // sends an error if no username and password
         if (authSplit.Length != 2)
         {
             return Task.FromResult(AuthenticateResult.Fail("Invalid Authorization header format"));
         }
 
-        // stores the client ID and secret
         var clientId = authSplit[0];
         var clientSecret = authSplit[1];
 
@@ -47,21 +44,18 @@ protected override Task<AuthenticateResult> HandleAuthenticateAsync()
             return Task.FromResult(AuthenticateResult.Fail(string.Format("The secret is incorrect for the client '{0}'", clientId)));
         }
 
-        // authenticates the client using basic authentication
         var client = new BasicAuthenticationClient
         {
             AuthenticationType = BasicAuthenticationDefaults.AuthenticationScheme,
             IsAuthenticated = true,
             Name = clientId
         };
 
-        // set the client ID as the name claim type
         var claimsPrincipal = new ClaimsPrincipal(new ClaimsIdentity(client,
         [
             new Claim(ClaimTypes.Name, clientId)
         ]));
 
-        // returns a success result
         return Task.FromResult(AuthenticateResult.Success(new AuthenticationTicket(claimsPrincipal, Scheme.Name)));
     }
 }
diff --git a/src/WebApi/ImplicitUsings.cs b/src/WebApi/ImplicitUsings.cs
@@ -1,5 +1,7 @@
-﻿global using Devpro.Common.AspNetCore;
+﻿global using Devpro.Common.AspNetCore.DependencyInjection;
+global using Devpro.Common.AspNetCore.Formatters;
 global using Devpro.Common.AspNetCore.WebApi.Builder;
 global using Devpro.Common.AspNetCore.WebApi.Configuration;
+global using Devpro.Common.AspNetCore.WebApi.DependencyInjection;
 global using Devpro.TerraformBackend.WebApi;
 global using Devpro.TerraformBackend.WebApi.DependencyInjection;
diff --git a/src/WebApi/Program.cs b/src/WebApi/Program.cs
@@ -9,7 +9,7 @@
 builder.Services.AddSwaggerGenWithBasicAuth(configuration);
 builder.Services.AddBasicAuthentication();
 builder.Services.AddHealthChecks();
-builder.Services.AddBehaviors();
+builder.Services.AddInvalidModelStateLog();
 
 // create the application and configures the HTTP request pipeline
 var app = builder.Build();
diff --git a/test/WebApi.IntegrationTests/Http/HttpResponseMessageExtensions.cs b/test/WebApi.IntegrationTests/Http/HttpResponseMessageExtensions.cs
@@ -0,0 +1,35 @@
+﻿using System.Net;
+
+namespace Devpro.TerraformBackend.WebApi.IntegrationTests.Http;
+
+internal static class HttpResponseMessageExtensions
+{
+    public static async Task<string?> CheckResponseAndGetContent(this HttpResponseMessage response, HttpStatusCode expectedStatusCode, string? expectedContentType, string? expectedContent)
+    {
+        response.StatusCode.Should().Be(expectedStatusCode);
+
+        if (expectedContentType == null)
+        {
+            response.Content.Headers.ContentType.Should().BeNull();
+        }
+        else
+        {
+            response.Content.Headers.ContentType.Should().NotBeNull();
+            response.Content.Headers.ContentType?.ToString().Should().Be(expectedContentType);
+        }
+
+        var result = await response.Content.ReadAsStringAsync();
+
+        if (expectedContent == null)
+        {
+            result.Should().BeNull();
+        }
+        else
+        {
+            result.Should().NotBeNull();
+            result.Should().Be(expectedContent);
+        }
+
+        return result;
+    }
+}
diff --git a/test/WebApi.IntegrationTests/ImplicitUsings.cs b/test/WebApi.IntegrationTests/ImplicitUsings.cs
@@ -0,0 +1,6 @@
+﻿global using System.Text;
+global using System.Text.Json;
+global using AwesomeAssertions;
+global using Bogus;
+global using Microsoft.AspNetCore.Mvc.Testing;
+global using Xunit;
diff --git a/test/WebApi.IntegrationTests/IntegrationTestBase.cs b/test/WebApi.IntegrationTests/IntegrationTestBase.cs
@@ -1,20 +1,36 @@
-﻿using System.Net.Http;
-using Bogus;
-using Microsoft.AspNetCore.Mvc.Testing;
-using Xunit;
+﻿using System.Net.Http.Headers;
 
 namespace Devpro.TerraformBackend.WebApi.IntegrationTests
 {
     /// <summary>
     /// See https://learn.microsoft.com/en-us/aspnet/core/test/integration-tests
     /// </summary>
-    public abstract class IntegrationTestBase(WebApplicationFactory<Program> factory) : IClassFixture<WebApplicationFactory<Program>>
+    public abstract class IntegrationTestBase(WebApplicationFactory<Program> factory)
+        : IClassFixture<WebApplicationFactory<Program>>
     {
         protected Faker Faker { get; } = new("en");
 
-        protected HttpClient CreateClient()
+        protected HttpClient CreateClient(bool isAuthorizationNeeded = false)
         {
-            return factory.CreateClient();
+            var client = factory.CreateClient();
+
+            if (isAuthorizationNeeded)
+            {
+                var authToken = Convert.ToBase64String(Encoding.ASCII.GetBytes(string.Format("{0}:{1}", "admin", "admin")));
+                client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", authToken);
+            }
+
+            return client;
+        }
+
+        protected StringContent GeneratePayload()
+        {
+            var dummy = new
+            {
+                Property1 = Faker.Random.String(),
+                Property2 = Faker.Random.Int()
+            };
+            return new StringContent(JsonSerializer.Serialize(dummy), Encoding.UTF8, "application/json");
         }
     }
 }
diff --git a/test/WebApi.IntegrationTests/Resources/HealthCheckResourceTest.cs b/test/WebApi.IntegrationTests/Resources/HealthCheckResourceTest.cs
@@ -1,7 +1,4 @@
-﻿using System.Threading.Tasks;
-using FluentAssertions;
-using Microsoft.AspNetCore.Mvc.Testing;
-using Xunit;
+﻿using Devpro.TerraformBackend.WebApi.IntegrationTests.Http;
 
 namespace Devpro.TerraformBackend.WebApi.IntegrationTests.Resources
 {
@@ -20,12 +17,7 @@ public async Task HealthCheckResource_Get_ReturnsOk()
             var response = await client.GetAsync("/health");
 
             // Assert
-            response.StatusCode.Should().Be(System.Net.HttpStatusCode.OK);
-            response.Content.Headers.ContentType.Should().NotBeNull();
-            response.Content.Headers.ContentType?.ToString().Should().Be("text/plain");
-            var result = await response.Content.ReadAsStringAsync();
-            result.Should().NotBeNull();
-            result.Should().Be("Healthy");
+            await response.CheckResponseAndGetContent(System.Net.HttpStatusCode.OK, "text/plain", "Healthy");
         }
     }
 }
diff --git a/test/WebApi.IntegrationTests/Resources/StateControllerResourceTest.cs b/test/WebApi.IntegrationTests/Resources/StateControllerResourceTest.cs
@@ -1,12 +1,4 @@
-﻿using System;
-using System.Net.Http;
-using System.Text;
-using System.Text.Json;
-using System.Threading.Tasks;
-using Bogus;
-using FluentAssertions;
-using Microsoft.AspNetCore.Mvc.Testing;
-using Xunit;
+﻿using Devpro.TerraformBackend.WebApi.IntegrationTests.Http;
 
 namespace Devpro.TerraformBackend.WebApi.IntegrationTests.Resources;
 
@@ -15,30 +7,34 @@ public class StateControllerResourceTest(WebApplicationFactory<Program> factory)
     : IntegrationTestBase(factory)
 {
     [Fact]
-    public async Task HealthCheckResource_Create_ReturnsOk()
+    public async Task HealthCheckResource_GetNotExisting_ReturnsOk()
     {
         // Arrange
-        var client = CreateClient();
-        var authToken = Convert.ToBase64String(Encoding.ASCII.GetBytes(string.Format("{0}:{1}", "admin", "admin")));
-        client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", authToken);
+        var client = CreateClient(true);
         var name = Faker.Random.Word();
         var lockId = Faker.Random.Guid().ToString();
-        var payload = new
-        {
-            Property1 = "Value1",
-            Property2 = 123
-        };
-        var content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
 
         // Act
-        var response = await client.PostAsync($"/state/{name}?ID={lockId}", content);
+        var response = await client.GetAsync($"/state/{name}?ID={lockId}");
 
         // Assert
-        response.StatusCode.Should().Be(System.Net.HttpStatusCode.Created);
-        response.Content.Headers.ContentType.Should().BeNull();
-        //TODO: test resource URL
-        var result = await response.Content.ReadAsStringAsync();
-        result.Should().NotBeNull();
-        result.ToString().Should().BeEmpty();
+        await response.CheckResponseAndGetContent(System.Net.HttpStatusCode.OK, "text/plain; charset=utf-8", string.Empty);
+    }
+
+    [Fact]
+    public async Task HealthCheckResource_CreateNew_ReturnsCreated()
+    {
+        // Arrange
+        var client = CreateClient(true);
+        var name = Faker.Random.Word();
+        var lockId = Faker.Random.Guid().ToString();
+        var payload = GeneratePayload();
+
+        // Act
+        var response = await client.PostAsync($"/state/{name}?ID={lockId}", payload);
+
+        // Assert
+        //TODO: test resource URL in response
+        await response.CheckResponseAndGetContent(System.Net.HttpStatusCode.Created, null, string.Empty);
     }
 }
diff --git a/test/WebApi.IntegrationTests/WebApi.IntegrationTests.csproj b/test/WebApi.IntegrationTests/WebApi.IntegrationTests.csproj
@@ -6,16 +6,17 @@
     <RootNamespace>Devpro.TerraformBackend.WebApi.IntegrationTests</RootNamespace>
     <ProjectGuid>{B055FFAF-8261-43B1-866A-12E289D5D7DC}</ProjectGuid>
     <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="AwesomeAssertions" Version="9.1.0" />
     <PackageReference Include="Bogus" Version="35.6.3" />
     <PackageReference Include="coverlet.collector" Version="6.0.4">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="FluentAssertions" Version="8.5.0" />
     <PackageReference Include="JunitXml.TestLogger" Version="6.1.0" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="8.0.18" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,8 @@`
`1`		`-using Microsoft.OpenApi.Models;`
	`1`	`+using Devpro.Common.AspNetCore.WebApi.Configuration;`
	`2`	`+using Microsoft.Extensions.DependencyInjection;`
	`3`	`+using Microsoft.OpenApi.Models;`
`2`	`4`
`3`		`-namespace Devpro.TerraformBackend.WebApi.DependencyInjection;`
	`5`	`+namespace Devpro.Common.AspNetCore.WebApi.DependencyInjection;`
`4`	`6`
`5`	`7`	`public static class SwaggerServiceCollectionExtensions`
`6`	`8`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,13 +8,9 @@`
`8`	`8`
`9`	`9`	`namespace Devpro.TerraformBackend.Infrastructure.MongoDb.Repositories`
`10`	`10`	`{`
`11`		`- public class StateRepository : RepositoryBase, IStateRepository`
	`11`	`+ public class StateRepository(IMongoClientFactory mongoClientFactory, ILogger<StateRepository> logger, MongoDbConfiguration configuration)`
	`12`	`+ : RepositoryBase(mongoClientFactory, logger, configuration), IStateRepository`
`12`	`13`	`{`
`13`		`- public StateRepository(IMongoClientFactory mongoClientFactory, ILogger<StateRepository> logger, MongoDbConfiguration configuration)`
`14`		`- : base(mongoClientFactory, logger, configuration)`
`15`		`- {`
`16`		`- }`
`17`		`-`
`18`	`14`	`protected override string CollectionName => "tf_state";`
`19`	`15`
`20`	`16`	`public async Task CreateAsync(string name, string jsonInput)`
Original file line number	Diff line number	Diff line change
`@@ -12,31 +12,28 @@ public class BasicAuthenticationHandler(IOptionsMonitor<AuthenticationSchemeOpti`
`12`	`12`	`{`
`13`	`13`	`protected override Task<AuthenticateResult> HandleAuthenticateAsync()`
`14`	`14`	`{`
`15`		`- // raises an error if no authorization header`
	`15`	`+ // checks authorization header`
`16`	`16`	`if (!Request.Headers.ContainsKey("Authorization"))`
`17`	`17`	`{`
`18`	`18`	`return Task.FromResult(AuthenticateResult.Fail("Missing Authorization header"));`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`var authorizationHeader = Request.Headers.Authorization.ToString();`
`22`	`22`
`23`		`- // raises an error if the authorization header is not Basic`
	`23`	`+ // checks authorization header starts with Basic`
`24`	`24`	`if (!authorizationHeader.StartsWith("Basic ", StringComparison.OrdinalIgnoreCase))`
`25`	`25`	`{`
`26`	`26`	`return Task.FromResult(AuthenticateResult.Fail("Authorization header does not start with 'Basic'"));`
`27`	`27`	`}`
`28`	`28`
`29`		`- // decrypts the authorization header and split out the client id/secret which is separated by the first ':'`
	`29`	`+ // decrypts the authorization header and split out the client id/secret`
`30`	`30`	`var authBase64Decoded = Encoding.UTF8.GetString(Convert.FromBase64String(authorizationHeader.Replace("Basic ", "", StringComparison.OrdinalIgnoreCase)));`
`31`	`31`	`var authSplit = authBase64Decoded.Split([':'], 2);`
`32`		`-`
`33`		`- // sends an error if no username and password`
`34`	`32`	`if (authSplit.Length != 2)`
`35`	`33`	`{`
`36`	`34`	`return Task.FromResult(AuthenticateResult.Fail("Invalid Authorization header format"));`
`37`	`35`	`}`
`38`	`36`
`39`		`- // stores the client ID and secret`
`40`	`37`	`var clientId = authSplit[0];`
`41`	`38`	`var clientSecret = authSplit[1];`
`42`	`39`
`@@ -47,21 +44,18 @@ protected override Task<AuthenticateResult> HandleAuthenticateAsync()`
`47`	`44`	`return Task.FromResult(AuthenticateResult.Fail(string.Format("The secret is incorrect for the client '{0}'", clientId)));`
`48`	`45`	`}`
`49`	`46`
`50`		`- // authenticates the client using basic authentication`
`51`	`47`	`var client = new BasicAuthenticationClient`
`52`	`48`	`{`
`53`	`49`	`AuthenticationType = BasicAuthenticationDefaults.AuthenticationScheme,`
`54`	`50`	`IsAuthenticated = true,`
`55`	`51`	`Name = clientId`
`56`	`52`	`};`
`57`	`53`
`58`		`- // set the client ID as the name claim type`
`59`	`54`	`var claimsPrincipal = new ClaimsPrincipal(new ClaimsIdentity(client,`
`60`	`55`	`[`
`61`	`56`	`new Claim(ClaimTypes.Name, clientId)`
`62`	`57`	`]));`
`63`	`58`
`64`		`- // returns a success result`
`65`	`59`	`return Task.FromResult(AuthenticateResult.Success(new AuthenticationTicket(claimsPrincipal, Scheme.Name)));`
`66`	`60`	`}`
`67`	`61`	`}`