private void CreateAdalCache(ICoreLogger logger, ILegacyCachePersistence legacyCachePersistence, string scopes) { var key = new AdalTokenCacheKey( MsalTestConstants.AuthorityHomeTenant, scopes, MsalTestConstants.ClientId, MsalTestConstants.TokenSubjectTypeUser, MsalTestConstants.UniqueId, MsalTestConstants.User.Username); var wrapper = new AdalResultWrapper() { Result = new AdalResult(null, null, DateTimeOffset.MinValue) { UserInfo = new AdalUserInfo() { UniqueId = MsalTestConstants.UniqueId, DisplayableId = MsalTestConstants.User.Username } }, RefreshToken = MsalTestConstants.ClientSecret, RawClientInfo = MsalTestConstants.RawClientId, ResourceInResponse = scopes }; IDictionary <AdalTokenCacheKey, AdalResultWrapper> dictionary = AdalCacheOperations.Deserialize(logger, legacyCachePersistence.LoadCache()); dictionary[key] = wrapper; legacyCachePersistence.WriteCache(AdalCacheOperations.Serialize(logger, dictionary)); }
public async Task DoNotSaveRefreshTokenInAdalCacheForMsalB2CAuthorityTestAsync() { var appConfig = new ApplicationConfiguration() { ClientId = TestConstants.ClientId, RedirectUri = TestConstants.RedirectUri, AuthorityInfo = AuthorityInfo.FromAuthorityUri(TestConstants.B2CAuthority, false) }; var serviceBundle = ServiceBundle.Create(appConfig); ITokenCacheInternal cache = new TokenCache(serviceBundle); MsalTokenResponse response = TestConstants.CreateMsalTokenResponse(); var requestParams = CreateAuthenticationRequestParameters(serviceBundle, authority: Authority.CreateAuthority(serviceBundle, TestConstants.B2CAuthority)); requestParams.TenantUpdatedCanonicalAuthority = TestConstants.AuthorityTestTenant; AddHostToInstanceCache(serviceBundle, TestConstants.ProductionPrefNetworkEnvironment); await cache.SaveTokenResponseAsync(requestParams, response).ConfigureAwait(false); Assert.AreEqual(1, cache.Accessor.GetAllRefreshTokens().Count()); Assert.AreEqual(1, cache.Accessor.GetAllAccessTokens().Count()); IDictionary <AdalTokenCacheKey, AdalResultWrapper> dictionary = AdalCacheOperations.Deserialize(serviceBundle.DefaultLogger, cache.LegacyPersistence.LoadCache()); cache.LegacyPersistence.WriteCache(AdalCacheOperations.Serialize(serviceBundle.DefaultLogger, dictionary)); // ADAL cache is empty because B2C scenario is only for MSAL Assert.AreEqual(0, dictionary.Count); }
void ITokenCacheInternal.ClearAdalCache() { IDictionary <AdalTokenCacheKey, AdalResultWrapper> dictionary = AdalCacheOperations.Deserialize(Logger, LegacyCachePersistence.LoadCache()); dictionary.Clear(); LegacyCachePersistence.WriteCache(AdalCacheOperations.Serialize(Logger, dictionary)); }
private async Task ValidateCacheEntitiesEnvironmentAsync(ITokenCacheInternal cache, string expectedEnvironment) { ICoreLogger logger = Substitute.For<ICoreLogger>(); IEnumerable<Client.Cache.Items.MsalAccessTokenCacheItem> accessTokens = await cache.GetAllAccessTokensAsync(true).ConfigureAwait(false); foreach (Client.Cache.Items.MsalAccessTokenCacheItem at in accessTokens) { Assert.AreEqual(expectedEnvironment, at.Environment); } IEnumerable<Client.Cache.Items.MsalRefreshTokenCacheItem> refreshTokens = await cache.GetAllRefreshTokensAsync(true).ConfigureAwait(false); foreach (Client.Cache.Items.MsalRefreshTokenCacheItem rt in refreshTokens) { Assert.AreEqual(expectedEnvironment, rt.Environment); } IEnumerable<Client.Cache.Items.MsalIdTokenCacheItem> idTokens = await cache.GetAllIdTokensAsync(true).ConfigureAwait(false); foreach (Client.Cache.Items.MsalIdTokenCacheItem id in idTokens) { Assert.AreEqual(expectedEnvironment, id.Environment); } IEnumerable<Client.Cache.Items.MsalAccountCacheItem> accounts = await cache.GetAllAccountsAsync().ConfigureAwait(false); foreach (Client.Cache.Items.MsalAccountCacheItem account in accounts) { Assert.AreEqual(expectedEnvironment, account.Environment); } IDictionary<AdalTokenCacheKey, AdalResultWrapper> adalCache = AdalCacheOperations.Deserialize(logger, cache.LegacyPersistence.LoadCache()); foreach (KeyValuePair<AdalTokenCacheKey, AdalResultWrapper> kvp in adalCache) { Assert.AreEqual(expectedEnvironment, new Uri(kvp.Key.Authority).Host); } }
private void AssertCacheEntryCount(int expectedEntryCount) { IDictionary <AdalTokenCacheKey, AdalResultWrapper> cache = AdalCacheOperations.Deserialize(_legacyCachePersistence.LoadCache()); Assert.AreEqual(expectedEntryCount, cache.Count); }
public void RemoveAdalUser_RemovesUserNoClientInfo_And_NoDisplayName() { // Arrange PopulateLegacyCache(_legacyCachePersistence); IDictionary <AdalTokenCacheKey, AdalResultWrapper> adalCacheBeforeDelete = AdalCacheOperations.Deserialize(_legacyCachePersistence.LoadCache()); Assert.AreEqual(6, adalCacheBeforeDelete.Count); // Act - nothing happens and a message is logged CacheFallbackOperations.RemoveAdalUser( _legacyCachePersistence, CoreTestConstants.ClientId, "", ""); // Assert AssertCacheEntryCount(6); MsalLogger.Default.Received().Error(Arg.Is <string>(CoreErrorMessages.InternalErrorCacheEmptyUsername)); }
private void ValidateCacheEntitiesEnvironment(TokenCache cache, string expectedEnvironment) { var requestContext = new RequestContext(null, new MsalLogger(Guid.NewGuid(), null)); ICollection <MsalAccessTokenCacheItem> accessTokens = cache.GetAllAccessTokensForClient(requestContext); foreach (var at in accessTokens) { Assert.AreEqual(expectedEnvironment, at.Environment); } ICollection <MsalRefreshTokenCacheItem> refreshTokens = cache.GetAllRefreshTokensForClient(requestContext); foreach (var rt in refreshTokens) { Assert.AreEqual(expectedEnvironment, rt.Environment); } ICollection <MsalIdTokenCacheItem> idTokens = cache.GetAllIdTokensForClient(requestContext); foreach (var id in idTokens) { Assert.AreEqual(expectedEnvironment, id.Environment); } ICollection <MsalAccountCacheItem> accounts = cache.GetAllAccounts(requestContext); foreach (var account in accounts) { Assert.AreEqual(expectedEnvironment, account.Environment); } IDictionary <AdalTokenCacheKey, AdalResultWrapper> adalCache = AdalCacheOperations.Deserialize(cache.LegacyCachePersistence.LoadCache()); foreach (KeyValuePair <AdalTokenCacheKey, AdalResultWrapper> kvp in adalCache) { Assert.AreEqual(expectedEnvironment, new Uri(kvp.Key.Authority).Host); } }
private async Task ValidateCacheEntitiesEnvironmentAsync(ITokenCacheInternal cache, string expectedEnvironment) { var requestContext = RequestContext.CreateForTest(); var accessTokens = await cache.GetAllAccessTokensAsync(true).ConfigureAwait(false); foreach (var at in accessTokens) { Assert.AreEqual(expectedEnvironment, at.Environment); } var refreshTokens = await cache.GetAllRefreshTokensAsync(true).ConfigureAwait(false); foreach (var rt in refreshTokens) { Assert.AreEqual(expectedEnvironment, rt.Environment); } var idTokens = await cache.GetAllIdTokensAsync(true).ConfigureAwait(false); foreach (var id in idTokens) { Assert.AreEqual(expectedEnvironment, id.Environment); } var accounts = await cache.GetAllAccountsAsync().ConfigureAwait(false); foreach (var account in accounts) { Assert.AreEqual(expectedEnvironment, account.Environment); } IDictionary <AdalTokenCacheKey, AdalResultWrapper> adalCache = AdalCacheOperations.Deserialize(requestContext.Logger, cache.LegacyPersistence.LoadCache()); foreach (KeyValuePair <AdalTokenCacheKey, AdalResultWrapper> kvp in adalCache) { Assert.AreEqual(expectedEnvironment, new Uri(kvp.Key.Authority).Host); } }
public void UnifiedCache_MsalStoresToAndReadRtFromAdalCache() { using (var httpManager = new MockHttpManager()) { httpManager.AddInstanceDiscoveryMockHandler(); var app = PublicClientApplicationBuilder.Create(MsalTestConstants.ClientId) .WithAuthority(new Uri(ClientApplicationBase.DefaultAuthority), true) .WithHttpManager(httpManager) .WithTelemetry(new TraceTelemetryConfig()) .WithUserTokenLegacyCachePersistenceForTest( new TestLegacyCachePersistance()) .BuildConcrete(); MsalMockHelpers.ConfigureMockWebUI( app.ServiceBundle.PlatformProxy, AuthorizationResult.FromUri(app.AppConfig.RedirectUri + "?code=some-code")); httpManager.AddMockHandlerForTenantEndpointDiscovery(MsalTestConstants.AuthorityCommonTenant); httpManager.AddSuccessTokenResponseMockHandlerForPost(ClientApplicationBase.DefaultAuthority); AuthenticationResult result = app.AcquireTokenInteractive(MsalTestConstants.Scope).ExecuteAsync(CancellationToken.None).Result; Assert.IsNotNull(result); // make sure Msal stored RT in Adal cache IDictionary <AdalTokenCacheKey, AdalResultWrapper> adalCacheDictionary = AdalCacheOperations.Deserialize(app.ServiceBundle.DefaultLogger, app.UserTokenCacheInternal.LegacyPersistence.LoadCache()); Assert.IsTrue(adalCacheDictionary.Count == 1); var requestContext = new RequestContext(app.ServiceBundle, Guid.NewGuid()); var accounts = app.UserTokenCacheInternal.GetAccountsAsync( MsalTestConstants.AuthorityCommonTenant, requestContext).Result; foreach (IAccount account in accounts) { app.UserTokenCacheInternal.RemoveMsalAccountWithNoLocks(account, requestContext); } httpManager.AddMockHandler( new MockHttpMessageHandler() { ExpectedMethod = HttpMethod.Post, ExpectedPostData = new Dictionary <string, string>() { { "grant_type", "refresh_token" } }, ResponseMessage = MockHelpers.CreateSuccessTokenResponseMessage( MsalTestConstants.UniqueId, MsalTestConstants.DisplayableId, MsalTestConstants.Scope.ToArray()) }); // Using RT from Adal cache for silent call AuthenticationResult result1 = app .AcquireTokenSilent(MsalTestConstants.Scope, result.Account) .WithAuthority(MsalTestConstants.AuthorityCommonTenant) .WithForceRefresh(false) .ExecuteAsync(CancellationToken.None) .Result; Assert.IsNotNull(result1); } }
public void UnifiedCache_MsalStoresToAndReadRtFromAdalCache() { using (var mocks = new MockHttpAndServiceBundle()) { var httpManager = mocks.HttpManager; httpManager.AddInstanceDiscoveryMockHandler(); var app = PublicClientApplicationBuilder.Create(TestConstants.ClientId) .WithAuthority(new Uri(ClientApplicationBase.DefaultAuthority), true) .WithHttpManager(httpManager) .WithTelemetry(new TraceTelemetryConfig()) .WithUserTokenLegacyCachePersistenceForTest( new TestLegacyCachePersistance()) .BuildConcrete(); app.ServiceBundle.ConfigureMockWebUI( AuthorizationResult.FromUri(app.AppConfig.RedirectUri + "?code=some-code")); HttpResponseMessage response = MockHelpers.CreateSuccessTokenResponseMessageWithUid( TestConstants.Uid, TestConstants.Utid, "*****@*****.**"); httpManager.AddResponseMockHandlerForPost(response); AuthenticationResult result = app.AcquireTokenInteractive(TestConstants.s_scope).ExecuteAsync(CancellationToken.None).Result; Assert.IsNotNull(result); // make sure Msal stored RT in Adal cache IDictionary <AdalTokenCacheKey, AdalResultWrapper> adalCacheDictionary = AdalCacheOperations.Deserialize(app.ServiceBundle.ApplicationLogger, app.UserTokenCacheInternal.LegacyPersistence.LoadCache()); Assert.IsTrue(adalCacheDictionary.Count == 1); var requestContext = new RequestContext(app.ServiceBundle, Guid.NewGuid()); var authority = Microsoft.Identity.Client.Instance.Authority.CreateAuthorityForRequestAsync( requestContext, null).Result; AuthenticationRequestParameters reqParams = new AuthenticationRequestParameters( mocks.ServiceBundle, app.UserTokenCacheInternal, new Client.ApiConfig.Parameters.AcquireTokenCommonParameters(), requestContext, authority); var accounts = app.UserTokenCacheInternal.GetAccountsAsync(reqParams).Result; foreach (IAccount account in accounts) { app.UserTokenCacheInternal.RemoveMsalAccountWithNoLocks(account, requestContext); } Assert.AreEqual(0, httpManager.QueueSize); httpManager.AddMockHandler( new MockHttpMessageHandler() { ExpectedMethod = HttpMethod.Post, ExpectedPostData = new Dictionary <string, string>() { { "grant_type", "refresh_token" } }, ResponseMessage = MockHelpers.CreateSuccessTokenResponseMessage( TestConstants.UniqueId, TestConstants.DisplayableId, TestConstants.s_scope.ToArray()) }); // Using RT from Adal cache for silent call AuthenticationResult result1 = app .AcquireTokenSilent(TestConstants.s_scope, result.Account) .WithAuthority(TestConstants.AuthorityCommonTenant) .WithForceRefresh(false) .ExecuteAsync(CancellationToken.None) .Result; Assert.IsNotNull(result1); } }
public void UnifiedCache_MsalStoresToAndReadRtFromAdalCache() { using (var httpManager = new MockHttpManager()) { var serviceBundle = ServiceBundle.CreateWithCustomHttpManager(httpManager); httpManager.AddInstanceDiscoveryMockHandler(); PublicClientApplication app = new PublicClientApplication( serviceBundle, MsalTestConstants.ClientId, ClientApplicationBase.DefaultAuthority) { UserTokenCache = { LegacyCachePersistence = new TestLegacyCachePersistance() } }; MsalMockHelpers.ConfigureMockWebUI(new AuthorizationResult(AuthorizationStatus.Success, app.RedirectUri + "?code=some-code")); httpManager.AddMockHandlerForTenantEndpointDiscovery(MsalTestConstants.AuthorityHomeTenant); httpManager.AddSuccessTokenResponseMockHandlerForPost(); AuthenticationResult result = app.AcquireTokenAsync(MsalTestConstants.Scope).Result; Assert.IsNotNull(result); // make sure Msal stored RT in Adal cache IDictionary <AdalTokenCacheKey, AdalResultWrapper> adalCacheDictionary = AdalCacheOperations.Deserialize(app.UserTokenCache.LegacyCachePersistence.LoadCache()); Assert.IsTrue(adalCacheDictionary.Count == 1); var requestContext = new RequestContext(null, new MsalLogger(Guid.Empty, null)); var accounts = app.UserTokenCache.GetAccounts(MsalTestConstants.AuthorityCommonTenant, false, requestContext); foreach (IAccount account in accounts) { app.UserTokenCache.RemoveMsalAccount(account, requestContext); } httpManager.AddMockHandler( new MockHttpMessageHandler() { Method = HttpMethod.Post, PostData = new Dictionary <string, string>() { { "grant_type", "refresh_token" } }, ResponseMessage = MockHelpers.CreateSuccessTokenResponseMessage( MsalTestConstants.UniqueId, MsalTestConstants.DisplayableId, MsalTestConstants.Scope.ToArray()) }); // Using RT from Adal cache for silent call AuthenticationResult result1 = app.AcquireTokenSilentAsync( MsalTestConstants.Scope, result.Account, MsalTestConstants.AuthorityCommonTenant, false).Result; Assert.IsNotNull(result1); } }