Add test infra and test for #1390

src/Microsoft.Identity.Web/ClientInfo.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using Microsoft.Identity.Web.Util;
 
 namespace Microsoft.Identity.Web
 {

src/Microsoft.Identity.Web/TokenCacheProviders/TokenCacheExtensions.cs

@@ -21,7 +21,7 @@ namespace Microsoft.Identity.Web
  /// </summary>
  public static class TokenCacheExtensions
  {
- private static readonly IDictionary<MethodInfo, IServiceProvider> s_serviceProviderFromAction
+ private static readonly ConcurrentDictionary<MethodInfo, IServiceProvider> s_serviceProviderFromAction
  = new ConcurrentDictionary<MethodInfo, IServiceProvider>();
 
  /// <summary>
@@ -81,20 +81,23 @@ internal static IConfidentialClientApplication AddTokenCaches(
  throw new ArgumentNullException(nameof(initializeCaches));
  }
 
- // Maintain a dictionary of service providers per `initializeCaches` delegate.
- if (!s_serviceProviderFromAction.TryGetValue(initializeCaches.Method, out IServiceProvider? serviceProvider))
+ // try to reuse existing XYZ cache if AddXYZCache was called before, to simulate ASP.NET Core
+ var serviceProvider = s_serviceProviderFromAction.GetOrAdd(initializeCaches.Method, (m) =>
  {
- IHostBuilder hostBuilder = Host.CreateDefaultBuilder()
- .ConfigureLogging(logger => { })
- .ConfigureServices(services =>
- {
- initializeCaches(services);
- services.AddDataProtection();
- });
+ lock (s_serviceProviderFromAction)
+ {
+ IHostBuilder hostBuilder = Host.CreateDefaultBuilder()
+ .ConfigureLogging(logger => { })
+ .ConfigureServices(services =>
+ {
+ initializeCaches(services);
+ services.AddDataProtection();
+ });
 
- serviceProvider = hostBuilder.Build().Services;
- s_serviceProviderFromAction[initializeCaches.Method] = serviceProvider;
- }
+ IServiceProvider sp = hostBuilder.Build().Services;
+ return sp;
+ }
+ });
 
  IMsalTokenCacheProvider msalTokenCacheProvider = serviceProvider.GetRequiredService<IMsalTokenCacheProvider>();
  msalTokenCacheProvider.Initialize(confidentialClientApp.UserTokenCache);

src/Microsoft.Identity.Web/Base64UrlHelpers.cs → src/Microsoft.Identity.Web/Util/Base64UrlHelpers.cs

@@ -2,10 +2,9 @@
 // Licensed under the MIT License.
 
 using System;
-using System.Globalization;
 using System.Text;
 
-namespace Microsoft.Identity.Web
+namespace Microsoft.Identity.Web.Util
 {
  internal static class Base64UrlHelpers
  {

tests/Microsoft.Identity.Web.Test.Common/Microsoft.Identity.Web.Test.Common.csproj

@@ -17,6 +17,7 @@
  <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
  </PackageReference>
  <PackageReference Include="NSubstitute" Version="4.2.2" />
+ <PackageReference Include="xunit.assert" Version="2.4.1" /> 
  <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.164">
  <PrivateAssets>all</PrivateAssets>
  <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

tests/Microsoft.Identity.Web.Test.Common/Mocks/MockHttpClientFactory.cs

@@ -0,0 +1,59 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Runtime.InteropServices;
+using Microsoft.Identity.Client;
+using Xunit;
+
+namespace Microsoft.Identity.Web.Test.Common.Mocks
+{
+ public class MockHttpClientFactory : IMsalHttpClientFactory, IDisposable
+ {
+ /// <inheritdoc />
+ public void Dispose()
+ {
+ // This ensures we only check the mock queue on dispose when we're not in the middle of an
+ // exception flow. Otherwise, any early assertion will cause this to likely fail
+ // even though it's not the root cause.
+#pragma warning disable CS0618 // Type or member is obsolete - this is non-production code so it's fine
+ if (Marshal.GetExceptionCode() == 0)
+#pragma warning restore CS0618 // Type or member is obsolete
+ {
+ string remainingMocks = string.Join(
+ " ",
+ _httpMessageHandlerQueue.Select(
+ h => (h as MockHttpMessageHandler)?.ExpectedUrl ?? string.Empty));
+
+ Assert.Empty(_httpMessageHandlerQueue);
+ }
+ }
+
+ public MockHttpMessageHandler AddMockHandler(MockHttpMessageHandler handler)
+ {
+ _httpMessageHandlerQueue.Enqueue(handler);
+ return handler;
+ }
+
+ private Queue<HttpMessageHandler> _httpMessageHandlerQueue = new Queue<HttpMessageHandler>();
+
+ public HttpClient GetHttpClient()
+ {
+ HttpMessageHandler messageHandler;
+
+ Assert.NotEmpty(_httpMessageHandlerQueue);
+ messageHandler = _httpMessageHandlerQueue.Dequeue();
+
+ var httpClient = new HttpClient(messageHandler);
+
+ httpClient.DefaultRequestHeaders.Accept.Clear();
+ httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+
+ return httpClient;
+ }
+ }
+}

tests/Microsoft.Identity.Web.Test.Common/Mocks/MockHttpCreator.cs

@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System.Net;
+using System.Net.Http;
+using Microsoft.Identity.Web.Test.Common;
+using Microsoft.Identity.Web.Util;
+
+namespace Microsoft.Identity.Web.Test.Common.Mocks
+{
+ public static class MockHttpCreator
+ {
+ private static HttpResponseMessage CreateSuccessfulClientCredentialTokenResponseMessage(string token = "header.payload.signature", string expiry = "3599")
+ {
+ return CreateSuccessResponseMessage(
+ "{\"token_type\":\"Bearer\",\"expires_in\":\"" + expiry + "\",\"client_info\":\"" + CreateClientInfo() + "\",\"access_token\":\"" + token + "\"}");
+ }
+
+ public static HttpResponseMessage CreateSuccessResponseMessage(string successResponse)
+ {
+ HttpResponseMessage responseMessage = new HttpResponseMessage(HttpStatusCode.OK);
+ HttpContent content =
+ new StringContent(successResponse);
+ responseMessage.Content = content;
+ return responseMessage;
+ }
+
+ private static string CreateClientInfo(string uid = TestConstants.Uid, string utid = TestConstants.Utid)
+ {
+ return Base64UrlHelpers.Encode("{\"uid\":\"" + uid + "\",\"utid\":\"" + utid + "\"}");
+ }
+
+ public static MockHttpMessageHandler CreateInstanceDiscoveryMockHandler(
+ string discoveryEndpoint = "https://login.microsoftonline.com/common/discovery/instance",
+ string content = TestConstants.DiscoveryJsonResponse)
+ {
+ return new MockHttpMessageHandler()
+ {
+ ExpectedUrl = discoveryEndpoint,
+ ExpectedMethod = HttpMethod.Get,
+ ResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
+ {
+ Content = new StringContent(content),
+ },
+ };
+ }
+
+ public static MockHttpMessageHandler CreateClientCredentialTokenHandler(
+ string token = "header.payload.signature", string expiresIn = "3599")
+ {
+ var handler = new MockHttpMessageHandler()
+ {
+ ExpectedMethod = HttpMethod.Post,
+ ResponseMessage = CreateSuccessfulClientCredentialTokenResponseMessage(token, expiresIn),
+ };
+
+ return handler;
+ }
+ }
+}

tests/Microsoft.Identity.Web.Test.Common/Mocks/MockHttpMessageHandler.cs

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Microsoft.Identity.Web.Test.Common.Mocks
+{
+ public class MockHttpMessageHandler : HttpMessageHandler
+ {
+ public HttpResponseMessage ResponseMessage { get; set; }
+ public string ExpectedUrl { get; set; }
+
+ public HttpMethod ExpectedMethod { get; set; }
+
+ public Exception ExceptionToThrow { get; set; }
+
+ /// <summary>
+ /// Once the http message is executed, this property holds the request message
+ /// </summary>
+ public HttpRequestMessage ActualRequestMessage { get; private set; }
+
+ protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+ {
+ ActualRequestMessage = request;
+
+ if (ExceptionToThrow != null)
+ {
+ throw ExceptionToThrow;
+ }
+
+ var uri = request.RequestUri;
+ if (!string.IsNullOrEmpty(ExpectedUrl))
+ {
+ Assert.Equal(
+ ExpectedUrl,
+ uri.AbsoluteUri.Split(
+ new[]
+ {
+ '?',
+ })[0]);
+ }
+
+ Assert.Equal(ExpectedMethod, request.Method);
+
+ if (request.Method != HttpMethod.Get && request.Content != null)
+ {
+ string postData = request.Content.ReadAsStringAsync().Result;
+ }
+
+ return new TaskFactory().StartNew(() => ResponseMessage, cancellationToken);
+ }
+ }
+}

tests/Microsoft.Identity.Web.Test.Common/TestConstants.cs

@@ -169,5 +169,42 @@ public static class TestConstants
  public const string ActualIssuer = "actualIssuer";
  public const string SecurityToken = "securityToken";
  public const string ValidationParameters = "validationParameters";
+
+ public const string DiscoveryJsonResponse = @"{
+ ""tenant_discovery_endpoint"":""https://login.microsoftonline.com/tenant/.well-known/openid-configuration"",
+ ""api-version"":""1.1"",
+ ""metadata"":[
+ {
+ ""preferred_network"":""login.microsoftonline.com"",
+ ""preferred_cache"":""login.windows.net"",
+ ""aliases"":[
+ ""login.microsoftonline.com"", 
+ ""login.windows.net"",
+ ""login.microsoft.com"",
+ ""sts.windows.net""]},
+ {
+ ""preferred_network"":""login.partner.microsoftonline.cn"",
+ ""preferred_cache"":""login.partner.microsoftonline.cn"",
+ ""aliases"":[
+ ""login.partner.microsoftonline.cn"",
+ ""login.chinacloudapi.cn""]},
+ {
+ ""preferred_network"":""login.microsoftonline.de"",
+ ""preferred_cache"":""login.microsoftonline.de"",
+ ""aliases"":[
+ ""login.microsoftonline.de""]},
+ {
+ ""preferred_network"":""login.microsoftonline.us"",
+ ""preferred_cache"":""login.microsoftonline.us"",
+ ""aliases"":[
+ ""login.microsoftonline.us"",
+ ""login.usgovcloudapi.net""]},
+ {
+ ""preferred_network"":""login-us.microsoftonline.com"",
+ ""preferred_cache"":""login-us.microsoftonline.com"",
+ ""aliases"":[
+ ""login-us.microsoftonline.com""]}
+ ]
+ }";
  }
 }

tests/Microsoft.Identity.Web.Test/Base64UrlHelpersTests.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Text;
+using Microsoft.Identity.Web.Util;
 using Xunit;
 
 namespace Microsoft.Identity.Web.Test

tests/Microsoft.Identity.Web.Test/CacheExtensionsTests.cs

@@ -2,9 +2,12 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using Microsoft.Identity.Client;
 using Microsoft.Identity.Web.Test.Common;
+using Microsoft.Identity.Web.Test.Common.Mocks;
 using Xunit;
 
 namespace Microsoft.Identity.Web.Test
@@ -23,6 +26,81 @@ public void InMemoryCacheExtensionsTests()
  Assert.NotNull(_confidentialApp.AppTokenCache);
  }
 
+ [Fact]
+ // bug: https://github.com/AzureAD/microsoft-identity-web/issues/1390
+ public async Task InMemoryCacheExtensionsAgainTestsAsync()
+ {
+ AuthenticationResult result;
+ result = await CreateAppAndGetTokenAsync(CacheType.InMemory).ConfigureAwait(false);
+ Assert.Equal(TokenSource.IdentityProvider, result.AuthenticationResultMetadata.TokenSource);
+
+ result = await CreateAppAndGetTokenAsync(CacheType.InMemory, false, false).ConfigureAwait(false);
+ Assert.Equal(TokenSource.Cache, result.AuthenticationResultMetadata.TokenSource);
+
+ result = await CreateAppAndGetTokenAsync(CacheType.DistributedInMemory, true, false).ConfigureAwait(false);
+ Assert.Equal(TokenSource.IdentityProvider, result.AuthenticationResultMetadata.TokenSource);
+
+ result = await CreateAppAndGetTokenAsync(CacheType.DistributedInMemory, false, false).ConfigureAwait(false);
+ Assert.Equal(TokenSource.Cache, result.AuthenticationResultMetadata.TokenSource);
+ }
+
+ private enum CacheType
+ {
+ InMemory,
+ DistributedInMemory,
+ }
+
+ private static async Task<AuthenticationResult> CreateAppAndGetTokenAsync(
+ CacheType cacheType,
+ bool addTokenMock = true,
+ bool addInstanceMock = true)
+ {
+ using (MockHttpClientFactory mockHttp = new MockHttpClientFactory())
+ using (var discoveryHandler = MockHttpCreator.CreateInstanceDiscoveryMockHandler())
+ using (var tokenHandler = MockHttpCreator.CreateClientCredentialTokenHandler())
+ {
+
+ if (addInstanceMock)
+ {
+ mockHttp.AddMockHandler(discoveryHandler);
+ }
+
+ // for when the token is requested from ESTS
+ if (addTokenMock)
+ {
+ mockHttp.AddMockHandler(tokenHandler);
+ }
+
+ var confidentialApp = ConfidentialClientApplicationBuilder
+ .Create(TestConstants.ClientId)
+ .WithAuthority(TestConstants.AuthorityCommonTenant)
+ .WithHttpClientFactory(mockHttp)
+ .WithClientSecret(TestConstants.ClientSecret)
+ .Build();
+
+ switch (cacheType)
+ {
+ case CacheType.InMemory:
+ confidentialApp.AddInMemoryTokenCache();
+ break;
+
+ case CacheType.DistributedInMemory:
+ confidentialApp.AddDistributedTokenCache(services =>
+ {
+ services.AddDistributedMemoryCache();
+ services.AddLogging(configure => configure.AddConsole())
+ .Configure<LoggerFilterOptions>(options => options.MinLevel = Microsoft.Extensions.Logging.LogLevel.Warning);
+ });
+ break;
+ }
+
+ var result = await confidentialApp.AcquireTokenForClient(new[] { TestConstants.s_scopeForApp })
+ .ExecuteAsync().ConfigureAwait(false);
+
+ return result;
+ }
+ }
+
  [Fact]
  public void InMemoryCacheExtensions_NoCca_ThrowsException_Tests()
  {