public async Task AcquireTokenSilent_LoginHint_MultipleAccountsAsync()
{
var receiver = new MyReceiver();
using (var httpManager = new MockHttpManager())
{
PublicClientApplication app = PublicClientApplicationBuilder.Create(TestConstants.ClientId)
.WithAuthority(new Uri(TestConstants.AuthorityTestTenant), true)
.WithHttpManager(httpManager)
.WithTelemetry(receiver.HandleTelemetryEvents)
.BuildConcrete();
var tokenCacheHelper = new TokenCacheHelper();
var cacheAccess = app.UserTokenCache.RecordAccess();
tokenCacheHelper.PopulateCache(app.UserTokenCacheInternal.Accessor, "uid1", "utid");
tokenCacheHelper.PopulateCache(app.UserTokenCacheInternal.Accessor, "uid2", "utid");
var exception = await AssertException.TaskThrowsAsync <MsalUiRequiredException>(async() => await app.AcquireTokenSilent(
TestConstants.s_scope.ToArray(),
TestConstants.DisplayableId)
.WithAuthority(app.Authority, false)
.ExecuteAsync().ConfigureAwait(false)).ConfigureAwait(false);
Assert.AreEqual(MsalError.MultipleAccountsForLoginHint, exception.ErrorCode);
Assert.AreEqual(UiRequiredExceptionClassification.AcquireTokenSilentFailed, exception.Classification);
cacheAccess.AssertAccessCounts(1, 0);
}
}
public async Task AcquireTokenSilentScopeAndEmptyCacheTestAsync()
{
var receiver = new MyReceiver();
PublicClientApplication app = PublicClientApplicationBuilder.Create(TestConstants.ClientId)
.WithAuthority(new Uri(ClientApplicationBase.DefaultAuthority), true)
.WithTelemetry(receiver.HandleTelemetryEvents)
.BuildConcrete();
try
{
AuthenticationResult result = await app
.AcquireTokenSilent(
TestConstants.s_scope.ToArray(),
new Account(TestConstants.s_userIdentifier, TestConstants.DisplayableId, null))
.ExecuteAsync(CancellationToken.None)
.ConfigureAwait(false);
}
catch (MsalUiRequiredException exc)
{
Assert.AreEqual(MsalError.NoTokensFoundError, exc.ErrorCode);
Assert.AreEqual(UiRequiredExceptionClassification.AcquireTokenSilentFailed, exc.Classification);
}
Assert.IsNotNull(
receiver.EventsReceived.Find(
anEvent => // Expect finding such an event
anEvent[EventBase.EventNameKey].EndsWith("api_event") &&
anEvent[MsalTelemetryBlobEventNames.ApiIdConstStrKey] == "1007" &&
anEvent[ApiEvent.WasSuccessfulKey] == "false" &&
anEvent[ApiEvent.ApiErrorCodeKey] == "no_tokens_found"));
}
public void Initialize()
{
TestCommon.ResetStateAndInitMsal();
_myReceiver = new MyReceiver();
_telemetryManager = new TelemetryManager(_myReceiver);
Logger.PiiLoggingEnabled = false;
}
public async Task ConfidentialClientUsingCertificateTelemetryTestAsync()
{
var receiver = new MyReceiver();
using (var httpManager = new MockHttpManager())
{
httpManager.AddInstanceDiscoveryMockHandler();
var cert = new X509Certificate2(ResourceHelper.GetTestResourceRelativePath("valid.crtfile"));
var app = CreateConfidentialClient(httpManager, cert, 1, receiver.HandleTelemetryEvents);
var result = await app.AcquireTokenForClient(MsalTestConstants.Scope.ToArray()).ExecuteAsync(CancellationToken.None).ConfigureAwait(false);
Assert.IsNotNull(
receiver.EventsReceived.Find(
anEvent => // Expect finding such an event
anEvent[EventBase.EventNameKey].EndsWith("http_event") &&
anEvent[HttpEvent.ResponseCodeKey] == "200" && anEvent[HttpEvent.HttpPathKey]
.Contains(
EventBase
.TenantPlaceHolder) // The tenant info is expected to be replaced by a holder
));
Assert.IsNotNull(
receiver.EventsReceived.Find(
anEvent => // Expect finding such an event
anEvent[EventBase.EventNameKey].EndsWith("api_event") &&
anEvent[ApiEvent.WasSuccessfulKey] == "true" && anEvent[MsalTelemetryBlobEventNames.ApiIdConstStrKey] == "1004"));
}
}
private void RunAcquireTokenSilentCacheOnlyTest(string authority, bool expectNetworkDiscovery)
{
var receiver = new MyReceiver();
using (MockHttpAndServiceBundle testHarness = base.CreateTestHarness())
{
PublicClientApplication app = PublicClientApplicationBuilder.Create(TestConstants.ClientId)
.WithAuthority(authority, true)
.WithHttpManager(testHarness.HttpManager)
.WithTelemetry(receiver.HandleTelemetryEvents)
.BuildConcrete();
var tokenCacheHelper = new TokenCacheHelper();
tokenCacheHelper.PopulateCache(app.UserTokenCacheInternal.Accessor);
app.UserTokenCacheInternal.Accessor.DeleteAccessToken(new MsalAccessTokenCacheKey(
TestConstants.ProductionPrefNetworkEnvironment,
TestConstants.Utid,
TestConstants.s_userIdentifier,
TestConstants.ClientId,
TestConstants.ScopeForAnotherResourceStr,
TestConstants.Bearer));
if (expectNetworkDiscovery)
{
string host = new Uri(authority).Host;
string discoveryHost = KnownMetadataProvider.IsKnownEnvironment(host)
? host
: AadAuthority.DefaultTrustedHost;
string discoveryEndpoint = $"https://{discoveryHost}/common/discovery/instance";
var jsonResponse = TestConstants.DiscoveryJsonResponse.Replace("login.microsoft.com", host);
testHarness.HttpManager.AddMockHandler(
MockHelpers.CreateInstanceDiscoveryMockHandler(discoveryEndpoint, jsonResponse));
}
Task <AuthenticationResult> task = app
.AcquireTokenSilent(
TestConstants.s_scope.ToArray(),
new Account(TestConstants.s_userIdentifier, TestConstants.DisplayableId, null))
.WithAuthority(app.Authority, false)
.WithForceRefresh(false)
.ExecuteAsync(CancellationToken.None);
AuthenticationResult result = task.Result;
Assert.IsNotNull(result);
Assert.AreEqual(TestConstants.DisplayableId, result.Account.Username);
Assert.AreEqual(TestConstants.s_scope.AsSingleString(), result.Scopes.AsSingleString());
Assert.AreEqual(2, app.UserTokenCacheInternal.Accessor.GetAllAccessTokens().Count());
Assert.AreEqual(1, app.UserTokenCacheInternal.Accessor.GetAllRefreshTokens().Count());
Assert.IsNotNull(receiver.EventsReceived.Find(anEvent => // Expect finding such an event
anEvent[EventBase.EventNameKey].EndsWith("api_event") && anEvent[ApiEvent.WasSuccessfulKey] == "true" &&
anEvent[MsalTelemetryBlobEventNames.ApiIdConstStrKey] == "1007"));
}
}
private static void RunWithMockHttp(Action <MockHttpManager, IServiceBundle, MyReceiver> action)
{
using (var httpManager = new MockHttpManager())
{
var receiver = new MyReceiver();
var serviceBundle = ServiceBundle.CreateWithCustomHttpManager(httpManager, receiver);
action(httpManager, serviceBundle, receiver);
}
}
private static async Task RunWithMockHttpAsync(Func <MockHttpManager, IServiceBundle, MyReceiver, Task> action)
{
using (var httpManager = new MockHttpManager())
{
var receiver = new MyReceiver();
var serviceBundle = ServiceBundle.CreateWithCustomHttpManager(httpManager, receiver);
await action(httpManager, serviceBundle, receiver).ConfigureAwait(false);
}
}
public void Initialize()
{
TestCommon.ResetInternalStaticCaches();
_myReceiver = new MyReceiver();
_serviceBundle = TestCommon.CreateServiceBundleWithCustomHttpManager(null, clientId: ClientId);
_logger = _serviceBundle.DefaultLogger;
_platformProxy = _serviceBundle.PlatformProxy;
_crypto = _platformProxy.CryptographyManager;
_telemetryManager = new TelemetryManager(_serviceBundle.Config, _platformProxy, _myReceiver.HandleTelemetryEvents);
}
public void TelemetryPublicApiSample()
{
var telemetry = Telemetry.GetInstance();
var receiver = new MyReceiver();
telemetry.RegisterReceiver(receiver.HandleTelemetryEvents);
// Or you can use a one-liner:
Telemetry.GetInstance().RegisterReceiver(new MyReceiver().HandleTelemetryEvents);
}
public async Task ForceRefreshParameterTrueTestAsync()
{
var receiver = new MyReceiver();
using (var httpManager = new MockHttpManager())
{
httpManager.AddInstanceDiscoveryMockHandler();
var app = ConfidentialClientApplicationBuilder
.Create(MsalTestConstants.ClientId)
.WithAuthority(new Uri(MsalTestConstants.AuthorityTestTenant), true)
.WithRedirectUri(MsalTestConstants.RedirectUri)
.WithClientSecret(MsalTestConstants.ClientSecret)
.WithHttpManager(httpManager)
.WithTelemetry(receiver.HandleTelemetryEvents)
.BuildConcrete();
_tokenCacheHelper.PopulateCache(app.AppTokenCacheInternal.Accessor);
httpManager.AddMockHandlerForTenantEndpointDiscovery(app.Authority);
// add mock response for successful token retrieval
const string TokenRetrievedFromNetCall = "token retrieved from network call";
httpManager.AddMockHandler(
new MockHttpMessageHandler
{
ExpectedMethod = HttpMethod.Post,
ResponseMessage =
MockHelpers.CreateSuccessfulClientCredentialTokenResponseMessage(TokenRetrievedFromNetCall)
});
var result = await app
.AcquireTokenForClient(MsalTestConstants.Scope)
.WithForceRefresh(true)
.ExecuteAsync(CancellationToken.None)
.ConfigureAwait(false);
Assert.AreEqual(TokenRetrievedFromNetCall, result.AccessToken);
// make sure token in Cache was updated
var accessTokens = await app.AppTokenCacheInternal.GetAllAccessTokensAsync(true).ConfigureAwait(false);
var accessTokenInCache = accessTokens
.Where(item => ScopeHelper.ScopeContains(item.ScopeSet, MsalTestConstants.Scope))
.ToList().FirstOrDefault();
Assert.AreEqual(TokenRetrievedFromNetCall, accessTokenInCache.Secret);
Assert.IsNotNull(
receiver.EventsReceived.Find(
anEvent => // Expect finding such an event
anEvent[EventBase.EventNameKey].EndsWith("api_event") &&
anEvent[ApiEvent.WasSuccessfulKey] == "true" && anEvent[MsalTelemetryBlobEventNames.ApiIdConstStrKey] == "1004"));
}
}
public void AcquireTokenSilentCacheOnlyLookupTest()
{
var receiver = new MyReceiver();
using (var httpManager = new MockHttpManager())
{
PublicClientApplication app = PublicClientApplicationBuilder.Create(MsalTestConstants.ClientId)
.WithAuthority(new Uri(MsalTestConstants.AuthorityTestTenant), true)
.WithHttpManager(httpManager)
.WithTelemetry(receiver.HandleTelemetryEvents)
.BuildConcrete();
_tokenCacheHelper.PopulateCache(app.UserTokenCacheInternal.Accessor);
app.UserTokenCacheInternal.Accessor.DeleteAccessToken(new MsalAccessTokenCacheKey(
MsalTestConstants.ProductionPrefNetworkEnvironment,
MsalTestConstants.Utid,
MsalTestConstants.UserIdentifier,
MsalTestConstants.ClientId,
MsalTestConstants.ScopeForAnotherResourceStr));
httpManager.AddInstanceDiscoveryMockHandler();
Task <AuthenticationResult> task = app
.AcquireTokenSilent(
MsalTestConstants.Scope.ToArray(),
new Account(MsalTestConstants.UserIdentifier, MsalTestConstants.DisplayableId, null))
.WithAuthority(app.Authority, false)
.WithForceRefresh(false)
.ExecuteAsync(CancellationToken.None);
AuthenticationResult result = task.Result;
Assert.IsNotNull(result);
Assert.AreEqual(MsalTestConstants.DisplayableId, result.Account.Username);
Assert.AreEqual(MsalTestConstants.Scope.AsSingleString(), result.Scopes.AsSingleString());
Assert.AreEqual(2, app.UserTokenCacheInternal.Accessor.GetAllAccessTokens().Count());
Assert.AreEqual(1, app.UserTokenCacheInternal.Accessor.GetAllRefreshTokens().Count());
Assert.IsNotNull(receiver.EventsReceived.Find(anEvent => // Expect finding such an event
anEvent[EventBase.EventNameKey].EndsWith("api_event") && anEvent[ApiEvent.WasSuccessfulKey] == "true" &&
anEvent[MsalTelemetryBlobEventNames.ApiIdConstStrKey] == "31"));
}
}
public void TelemetrySkipEventsIfApiEventWasSuccessful()
{
var myReceiver = new MyReceiver
{
OnlySendFailureTelemetry = true
};
var telemetryManager = new TelemetryManager(myReceiver);
var telemetry = (ITelemetry)telemetryManager;
var reqId = telemetryManager.GenerateNewRequestId();
try
{
var e1 = new ApiEvent(new MsalLogger(Guid.NewGuid(), null))
{
Authority = new Uri("https://login.microsoftonline.com"), AuthorityType = "Aad"
};
telemetry.StartEvent(reqId, e1);
// do some stuff...
e1.WasSuccessful = true;
telemetry.StopEvent(reqId, e1);
var e2 = new UiEvent()
{
UserCancelled = false
};
telemetry.StartEvent(reqId, e2);
telemetry.StopEvent(reqId, e2);
var e3 = new UiEvent()
{
AccessDenied = false
};
telemetry.StartEvent(reqId, e3);
telemetry.StopEvent(reqId, e3);
}
finally
{
telemetry.Flush(reqId, ClientId);
}
Assert.AreEqual(0, myReceiver.EventsReceived.Count);
reqId = telemetryManager.GenerateNewRequestId();
try
{
var e1 = new ApiEvent(new MsalLogger(Guid.NewGuid(), null))
{
Authority = new Uri("https://login.microsoftonline.com"), AuthorityType = "Aad"
};
telemetry.StartEvent(reqId, e1);
// do some stuff...
e1.WasSuccessful = false; // mimic an unsuccessful event, so that this batch should be dispatched
telemetry.StopEvent(reqId, e1);
var e2 = new UiEvent()
{
UserCancelled = true
};
telemetry.StartEvent(reqId, e2);
telemetry.StopEvent(reqId, e2);
var e3 = new UiEvent()
{
AccessDenied = true
};
telemetry.StartEvent(reqId, e3);
telemetry.StopEvent(reqId, e3);
}
finally
{
telemetry.Flush(reqId, ClientId);
}
Assert.IsTrue(myReceiver.EventsReceived.Count > 0);
}
