示例#1
0
        public async Task Interactive_MsaUser_Async()
        {
            // Arrange
            LabResponse labResponse = await LabUserHelper.GetMsaUserAsync().ConfigureAwait(false);

            await RunTestForUserAsync(labResponse).ConfigureAwait(false);
        }
        [Ignore] // Failing sporadically https://identitydivision.visualstudio.com/Engineering/_workitems/edit/1045664
        public async Task SilentAuth_MsaUser_ForceRefresh_Async()
        {
            var labResponse = await LabUserHelper.GetMsaUserAsync().ConfigureAwait(false);

            pca = PublicClientApplicationBuilder
                  .Create(LabApiConstants.MSAOutlookAccountClientID)
                  .WithTestLogging()
                  .WithAuthority(AadAuthorityAudience.PersonalMicrosoftAccount)
                  .Build();

            Trace.WriteLine("Part 1 - Acquire a token with device code with msa user");
            AuthenticationResult authResult = await pca.AcquireTokenWithDeviceCode(s_scopes, deviceCodeResult =>
            {
                SeleniumExtensions.PerformDeviceCodeLogin(
                    deviceCodeResult,
                    labResponse.User,
                    TestContext,
                    false);

                return(Task.FromResult(0));
            }).ExecuteAsync()
                                              .ConfigureAwait(false);

            await ValidateAuthResultAsync(authResult, labResponse).ConfigureAwait(false);
        }
        public async Task MultiUserCacheCompatabilityTestAsync()
        {
            // Arrange

            //Acquire AT for default lab account
            LabResponse labResponseDefault = await LabUserHelper.GetDefaultUserAsync().ConfigureAwait(false);

            AuthenticationResult defaultAccountResult = await RunTestForUserAsync(labResponseDefault).ConfigureAwait(false);

            //Acquire AT for ADFS 2019 account
            LabResponse labResponseFederated = await LabUserHelper.GetAdfsUserAsync(FederationProvider.ADFSv2019, true).ConfigureAwait(false);

            var federatedAccountResult = await RunTestForUserAsync(labResponseFederated, false).ConfigureAwait(false);

            //Acquire AT for MSA account
            LabResponse labResponseMsa = await LabUserHelper.GetMsaUserAsync().ConfigureAwait(false);

            labResponseMsa.App.AppId = LabApiConstants.MSAOutlookAccountClientID;
            var msaAccountResult = await RunTestForUserAsync(labResponseMsa).ConfigureAwait(false);

            PublicClientApplication pca = PublicClientApplicationBuilder.Create(labResponseDefault.App.AppId).BuildConcrete();

            AuthenticationResult authResult = await pca.AcquireTokenSilent(new[] { CoreUiTestConstants.DefaultScope }, defaultAccountResult.Account)
                                              .ExecuteAsync()
                                              .ConfigureAwait(false);

            Assert.IsNotNull(authResult);
            Assert.IsNotNull(authResult.AccessToken);
            Assert.IsNotNull(authResult.IdToken);
            TestCommon.ValidateNoKerberosTicketFromAuthenticationResult(authResult);

            pca = PublicClientApplicationBuilder.Create(labResponseFederated.App.AppId).BuildConcrete();

            authResult = await pca.AcquireTokenSilent(new[] { CoreUiTestConstants.DefaultScope }, federatedAccountResult.Account)
                         .ExecuteAsync()
                         .ConfigureAwait(false);

            Assert.IsNotNull(authResult);
            Assert.IsNotNull(authResult.AccessToken);
            Assert.IsNull(authResult.IdToken);
            TestCommon.ValidateNoKerberosTicketFromAuthenticationResult(authResult);

            pca = PublicClientApplicationBuilder.Create(LabApiConstants.MSAOutlookAccountClientID).BuildConcrete();

            authResult = await pca.AcquireTokenSilent(new[] { CoreUiTestConstants.DefaultScope }, msaAccountResult.Account)
                         .ExecuteAsync()
                         .ConfigureAwait(false);

            Assert.IsNotNull(authResult);
            Assert.IsNotNull(authResult.AccessToken);
            Assert.IsNull(authResult.IdToken);
            TestCommon.ValidateNoKerberosTicketFromAuthenticationResult(authResult);
        }
示例#4
0
        public async Task ROPC_MSA_Async()
        {
            var labResponse = await LabUserHelper.GetMsaUserAsync().ConfigureAwait(false);

            SecureString securePassword = new NetworkCredential("", labResponse.User.GetOrFetchPassword()).SecurePassword;

            var msalPublicClient = PublicClientApplicationBuilder.Create(labResponse.App.AppId).WithAuthority(Authority).Build();

            var result = await AssertException.TaskThrowsAsync <MsalServiceException>(() =>
                                                                                      msalPublicClient
                                                                                      .AcquireTokenByUsernamePassword(s_scopes, labResponse.User.Upn, securePassword)
                                                                                      .ExecuteAsync(CancellationToken.None))
                         .ConfigureAwait(false);
        }
示例#5
0
        [Timeout(2 * 60 * 1000)] // 2 min timeout
        public async Task DeviceCodeFlowMsaTestAsync()
        {
            LabResponse labResponse = await LabUserHelper.GetMsaUserAsync().ConfigureAwait(false);

            await AcquireTokenWithDeviceCodeFlowAsync(labResponse, "msa user").ConfigureAwait(false);
        }