public void SerializesCustomProperties() { var originalInnerException = new AssertException("User Message"); var originalException = new AfterTestException(originalInnerException); var deserializedException = SerializationUtility.SerializeAndDeserialize(originalException); var deserializedInnerException = Assert.Single(deserializedException.AfterExceptions); Assert.Equal(originalInnerException.Message, deserializedInnerException.Message); var deserializedAssertException = Assert.IsType<AssertException>(deserializedInnerException); Assert.Equal(originalInnerException.UserMessage, deserializedAssertException.UserMessage); }
void TraceRidges(BinaryMap binary, Dictionary <Point, SkeletonBuilder.Minutia> minutiaePoints) { Dictionary <Point, SkeletonBuilder.Ridge> leads = new Dictionary <Point, SkeletonBuilder.Ridge>(); foreach (Point minutiaPoint in minutiaePoints.Keys) { foreach (Point startRelative in Neighborhood.CornerNeighbors) { Point start = Calc.Add(minutiaPoint, startRelative); if (binary.GetBitSafe(start, false) && !minutiaePoints.ContainsKey(start) && !leads.ContainsKey(start)) { SkeletonBuilder.Ridge ridge = new SkeletonBuilder.Ridge(); ridge.Points.Add(minutiaPoint); ridge.Points.Add(start); Point previous = minutiaPoint; Point current = start; do { Point next = new Point(); foreach (Point nextRelative in Neighborhood.CornerNeighbors) { next = Calc.Add(current, nextRelative); if (binary.GetBitSafe(next, false) && next != previous) { break; } } AssertException.Check(next != new Point()); previous = current; current = next; ridge.Points.Add(current); } while (!minutiaePoints.ContainsKey(current)); Point end = current; ridge.Start = minutiaePoints[minutiaPoint]; ridge.End = minutiaePoints[end]; leads[ridge.Points[1]] = ridge; leads[ridge.Reversed.Points[1]] = ridge; } } } }
public async Task MexEndpointFailsToResolveTestAsync() { using (var httpManager = new MockHttpManager()) { httpManager.AddInstanceDiscoveryMockHandler(); AddMockHandlerDefaultUserRealmDiscovery(httpManager); // MEX httpManager.AddMockHandler( new MockHttpMessageHandler { ExpectedUrl = "https://msft.sts.microsoft.com/adfs/services/trust/mex", ExpectedMethod = HttpMethod.Get, ResponseMessage = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent( File.ReadAllText(ResourceHelper.GetTestResourceRelativePath("TestMex.xml")) .Replace("<wsp:All>", " ")) } }); PublicClientApplication app = PublicClientApplicationBuilder.Create(TestConstants.ClientId) .WithAuthority(AadAuthorityAudience.AzureAdMultipleOrgs) .WithHttpManager(httpManager) .WithTelemetry(new TraceTelemetryConfig()) .BuildConcrete(); // Call acquire token, Mex parser fails MsalClientException result = await AssertException.TaskThrowsAsync <MsalClientException>( async() => await app.AcquireTokenByUsernamePassword( TestConstants.s_scope, TestConstants.s_user.Username, _secureString).ExecuteAsync(CancellationToken.None).ConfigureAwait(false)).ConfigureAwait(false); // Check exception message Assert.AreEqual(MsalErrorMessage.ParsingMetadataDocumentFailed, result.Message); Assert.AreEqual("parsing_ws_metadata_exchange_failed", result.ErrorCode); // There should be no cached entries. Assert.AreEqual(0, app.UserTokenCacheInternal.Accessor.GetAllAccessTokens().Count()); } }
public async Task AcquireTokenByIntegratedWindowsAuthInvalidClientTestAsync() { IDictionary <string, string> extraQueryParamsAndClaims = TestConstants.ExtraQueryParameters.ToDictionary(e => e.Key, e => e.Value); extraQueryParamsAndClaims.Add(OAuth2Parameter.Claims, TestConstants.Claims); using (var httpManager = new MockHttpManager()) { httpManager.AddInstanceDiscoveryMockHandler(); MockHttpMessageHandler realmDiscoveryHandler = AddMockHandlerDefaultUserRealmDiscovery(httpManager); AddMockHandlerMex(httpManager); AddMockHandlerWsTrustWindowsTransport(httpManager); httpManager.AddMockHandler( new MockHttpMessageHandler { ExpectedUrl = "https://login.microsoftonline.com/common/oauth2/v2.0/token", ExpectedMethod = HttpMethod.Post, ResponseMessage = MockHelpers.CreateInvalidClientResponseMessage() }); PublicClientApplication app = PublicClientApplicationBuilder.Create(TestConstants.ClientId) .WithAuthority(new Uri(ClientApplicationBase.DefaultAuthority), true) .WithHttpManager(httpManager) .WithExtraQueryParameters(TestConstants.ExtraQueryParameters) .WithTelemetry(new TraceTelemetryConfig()) .BuildConcrete(); MsalServiceException result = await AssertException.TaskThrowsAsync <MsalServiceException>( async() => await app.AcquireTokenByIntegratedWindowsAuth(TestConstants.s_scope) .WithClaims(TestConstants.Claims) .WithUsername(TestConstants.s_user.Username) .ExecuteAsync().ConfigureAwait(false)).ConfigureAwait(false); // Check inner exception Assert.AreEqual(MsalError.InvalidClient, result.ErrorCode); // There should be no cached entries. Assert.AreEqual(0, app.UserTokenCacheInternal.Accessor.GetAllAccessTokens().Count()); } }
public async Task PopWhenBrokerIsNotAvailableTest_Async() { //MSAL should not fall back to using the browser if the broker is not available when using POP // Arrange using (var harness = CreateTestHarness()) { harness.HttpManager.AddInstanceDiscoveryMockHandler(); var mockBroker = Substitute.For <IBroker>(); mockBroker.IsBrokerInstalledAndInvokable(AuthorityType.Aad).Returns(false); mockBroker.IsPopSupported.Returns(true); var pca = PublicClientApplicationBuilder.Create(TestConstants.ClientId) .WithExperimentalFeatures(true) .WithBrokerPreview() .WithTestBroker(mockBroker) .WithHttpManager(harness.HttpManager) .BuildConcrete(); pca.ServiceBundle.Config.BrokerCreatorFunc = (x, y, z) => mockBroker; pca.ServiceBundle.ConfigureMockWebUI(); harness.HttpManager.AddMockHandler( new MockHttpMessageHandler { ExpectedMethod = HttpMethod.Post, ResponseMessage = MockHelpers.CreateSuccessTokenResponseMessage( "user.read", MockHelpers.CreateIdToken(TestConstants.UniqueId, TestConstants.DisplayableId), MockHelpers.CreateClientInfo(TestConstants.Uid, TestConstants.Utid)) }); // Act var exception = await AssertException.TaskThrowsAsync <MsalClientException>(async() => { await pca.AcquireTokenInteractive(TestConstants.s_graphScopes) .WithProofOfPossession(TestConstants.Nonce, HttpMethod.Get, new Uri(TestConstants.AuthorityCommonTenant)) .ExecuteAsync() .ConfigureAwait(false); }).ConfigureAwait(false); Assert.AreEqual(MsalError.BrokerApplicationRequired, exception.ErrorCode); Assert.AreEqual(MsalErrorMessage.CannotInvokeBrokerForPop, exception.Message); } }
public async Task AcquireTokenSilent_Account_NoHomeAccountIDAsync() { using (var httpManager = new MockHttpManager()) { PublicClientApplication app = PublicClientApplicationBuilder.Create(TestConstants.ClientId) .WithAuthority(new Uri(TestConstants.AuthorityTestTenant), true) .WithHttpManager(httpManager) .BuildConcrete(); TokenCacheHelper.PopulateCache(app.UserTokenCacheInternal.Accessor); var exception = await AssertException.TaskThrowsAsync <MsalUiRequiredException>(() => app.AcquireTokenSilent( TestConstants.s_scope.ToArray(), new Account(null, null, null)) .ExecuteAsync()).ConfigureAwait(false); Assert.AreEqual(MsalError.NoTokensFoundError, exception.ErrorCode); Assert.AreEqual(UiRequiredExceptionClassification.AcquireTokenSilentFailed, exception.Classification); } }
public async Task PopWhenBrokerIsNotEnabledForATS_Async() { // Arrange var pca = PublicClientApplicationBuilder .Create(TestConstants.ClientId) .WithExperimentalFeatures() .BuildConcrete(); // Act MsalClientException ex = await AssertException.TaskThrowsAsync <MsalClientException>(async() => await pca.AcquireTokenSilent(TestConstants.s_graphScopes, TestConstants.LocalAccountId) .WithProofOfPossession(TestConstants.Nonce, HttpMethod.Get, new Uri(TestConstants.AuthorityCommonTenant)) .ExecuteAsync() .ConfigureAwait(false)) .ConfigureAwait(false); Assert.AreEqual(MsalError.BrokerRequiredForPop, ex.ErrorCode); Assert.AreEqual(MsalErrorMessage.BrokerRequiredForPop, ex.Message); }
public void NullArgsTest() { using (var harness = CreateTestHarness()) { Uri uri = new Uri("https://www.contoso.com/path1/path2?queryParam1=a&queryParam2=b"); HttpMethod method = HttpMethod.Post; HttpRequestMessage httpRequest = new HttpRequestMessage(method, uri); var popCryptoProvider = Substitute.For <IPoPCryptoProvider>(); PoPAuthenticationConfiguration config = null; AssertException.Throws <ArgumentNullException>(() => new PopAuthenticationScheme(config, harness.ServiceBundle)); config = new PoPAuthenticationConfiguration(uri); config.PopCryptoProvider = new InMemoryCryptoProvider(); AssertException.Throws <ArgumentNullException>(() => new PopAuthenticationScheme(config, null)); AssertException.Throws <ArgumentNullException>(() => new PoPAuthenticationConfiguration((HttpRequestMessage)null)); AssertException.Throws <ArgumentNullException>(() => new PoPAuthenticationConfiguration((Uri)null)); } }
public void AdalClaimsChallengeExceptionThrownWithAcquireTokenClientCredentialUserAssertionWhenClaimsChallengeRequiredTestAsync() { var context = new AuthenticationContext(TestConstants.DefaultAuthorityCommonTenant, new TokenCache()); var credential = new ClientCredential(TestConstants.DefaultClientId, TestConstants.DefaultClientSecret); string accessToken = "some-access-token"; HttpMessageHandlerFactory.AddMockHandler(new MockHttpMessageHandler() { Method = HttpMethod.Post, ResponseMessage = new HttpResponseMessage(HttpStatusCode.BadRequest) { Content = new StringContent(responseContent) } }); var result = AssertException.TaskThrows <AdalClaimChallengeException>(() => context.AcquireTokenAsync(TestConstants.DefaultResource, credential, new UserAssertion(accessToken))); Assert.AreEqual(claims.Replace("\\", ""), result.Claims); }
public async Task HttpRequestExceptionIsNotSuppressedAsync() { using (var httpManager = new MockHttpManager()) { httpManager.AddInstanceDiscoveryMockHandler(); var app = ConfidentialClientApplicationBuilder.Create(MsalTestConstants.ClientId) .WithAuthority(new Uri(ClientApplicationBase.DefaultAuthority), true) .WithRedirectUri(MsalTestConstants.RedirectUri) .WithClientSecret(MsalTestConstants.ClientSecret) .WithHttpManager(httpManager) .BuildConcrete(); // add mock response bigger than 1MB for Http Client httpManager.AddFailingRequest(new InvalidOperationException()); await AssertException.TaskThrowsAsync <InvalidOperationException>( () => app.AcquireTokenForClient(MsalTestConstants.Scope.ToArray()).ExecuteAsync(CancellationToken.None)).ConfigureAwait(false); } }
public void TestCreateSameName() { var ownerId = Guid.NewGuid(); var search = new JobAdSearch { Criteria = CreateCriteria(0), Name = SearchName, }; _jobAdSearchesCommand.CreateJobAdSearch(ownerId, search); // Create another. search = new JobAdSearch { Criteria = CreateCriteria(0), Name = SearchName, }; AssertException.Thrown <ValidationErrorsException>(() => _jobAdSearchesCommand.CreateJobAdSearch(ownerId, search), "A 'LinkMe.Framework.Utility.Validation.DuplicateValidationError' error has occurred for the Name property."); }
public void ArgNull() { AssertException.Throws <ArgumentNullException>(() => new MsalRefreshTokenCacheKey("", "clientId", "uid", "1")); AssertException.Throws <ArgumentNullException>(() => new MsalRefreshTokenCacheKey(null, "clientId", "uid", "1")); AssertException.Throws <ArgumentNullException>(() => new MsalRefreshTokenCacheKey(null, "clientId", "uid", "1")); AssertException.Throws <ArgumentNullException>(() => new MsalRefreshTokenCacheKey("env", null, "uid", "1")); AssertException.Throws <ArgumentNullException>(() => new MsalIdTokenCacheKey("", "tid", "uid", "cid")); AssertException.Throws <ArgumentNullException>(() => new MsalIdTokenCacheKey(null, "tid", "uid", "cid")); AssertException.Throws <ArgumentNullException>(() => new MsalIdTokenCacheKey("env", "tid", "uid", "")); AssertException.Throws <ArgumentNullException>(() => new MsalIdTokenCacheKey("env", "tid", "uid", null)); AssertException.Throws <ArgumentNullException>(() => new MsalAccessTokenCacheKey("", "tid", "uid", "cid", "scopes")); AssertException.Throws <ArgumentNullException>(() => new MsalAccessTokenCacheKey(null, "tid", "uid", "cid", "scopes")); AssertException.Throws <ArgumentNullException>(() => new MsalAccessTokenCacheKey("env", "tid", "uid", "", "scopes")); AssertException.Throws <ArgumentNullException>(() => new MsalAccessTokenCacheKey("env", "tid", "uid", null, "scopes")); AssertException.Throws <ArgumentNullException>(() => new MsalAccountCacheKey("", "tid", "uid", "localid", "aad")); AssertException.Throws <ArgumentNullException>(() => new MsalAccountCacheKey(null, "tid", "uid", "localid", "msa")); }
public async Task AcquireTokenSilent_LoginHint_NoAccountAsync() { using (var httpManager = new MockHttpManager()) { PublicClientApplication app = PublicClientApplicationBuilder.Create(MsalTestConstants.ClientId) .WithAuthority(new Uri(MsalTestConstants.AuthorityTestTenant), true) .WithHttpManager(httpManager) .WithTelemetry(new TraceTelemetryConfig()) .BuildConcrete(); _tokenCacheHelper.PopulateCache(app.UserTokenCacheInternal.Accessor); var exception = await AssertException.TaskThrowsAsync <MsalUiRequiredException>(() => app.AcquireTokenSilent( MsalTestConstants.Scope.ToArray(), "*****@*****.**") .WithAuthority(app.Authority, false) .ExecuteAsync()).ConfigureAwait(false); Assert.AreEqual(MsalError.NoAccountForLoginHint, exception.ErrorCode); } }
public void AdalClaimsChallengeExceptionThrownWithClientAssertionWhenClaimsChallengeRequiredTestAsync() { var certificate = new X509Certificate2("valid_cert.pfx", TestConstants.DefaultPassword); var clientAssertion = new ClientAssertionCertificate(TestConstants.DefaultClientId, certificate); var context = new AuthenticationContext(TestConstants.DefaultAuthorityCommonTenant, new TokenCache()); HttpMessageHandlerFactory.AddMockHandler(new MockHttpMessageHandler() { Method = HttpMethod.Post, ResponseMessage = new HttpResponseMessage(HttpStatusCode.BadRequest) { Content = new StringContent(responseContent) } }); var result = AssertException.TaskThrows <AdalClaimChallengeException>(() => context.AcquireTokenAsync(TestConstants.DefaultResource, clientAssertion)); Assert.AreEqual(claims.Replace("\\", ""), result.Claims); }
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 <MsalClientException>(() => msalPublicClient .AcquireTokenByUsernamePassword(s_scopes, labResponse.User.Upn, securePassword) .ExecuteAsync(CancellationToken.None)) .ConfigureAwait(false); Assert.AreEqual(MsalError.RopcDoesNotSupportMsaAccounts, result.ErrorCode); Assert.AreEqual(MsalErrorMessage.RopcDoesNotSupportMsaAccounts, result.Message); }
public void TestPluginSelection() { var ex = AssertException.Throws <MsalClientException>( () => _wamBroker.IsMsaRequestAsync(Authority.CreateAuthority(TestConstants.B2CAuthority), null, false).GetAwaiter().GetResult()); Assert.AreEqual(MsalError.WamNoB2C, ex.ErrorCode); Assert.IsFalse( _wamBroker.IsMsaRequestAsync(Authority.CreateAuthority(TestConstants.ADFSAuthority), null, false).Result, "ADFS authorities should be handled by AAD plugin"); Assert.IsTrue( _wamBroker.IsMsaRequestAsync(Authority.CreateAuthority(TestConstants.AuthorityCommonTenant), TestConstants.MsaTenantId, false).Result, "Common authority - look at account tenant ID to determine plugin"); Assert.IsFalse( _wamBroker.IsMsaRequestAsync(Authority.CreateAuthority(TestConstants.AuthorityCommonTenant), TestConstants.TenantId, false).Result, "Common authority - look at account tenant ID to determine plugin"); Assert.IsFalse( _wamBroker.IsMsaRequestAsync(Authority.CreateAuthority(TestConstants.AuthorityOrganizationsTenant), TestConstants.TenantId, false).Result, "Organizations authority - AAD plugin unless MSA-pt"); Assert.IsFalse( _wamBroker.IsMsaRequestAsync(Authority.CreateAuthority(TestConstants.AuthorityOrganizationsTenant), TestConstants.TenantId, true).Result, "Organizations authority with MSA-pt - based on home account id"); Assert.IsTrue( _wamBroker.IsMsaRequestAsync(Authority.CreateAuthority(TestConstants.AuthorityOrganizationsTenant), TestConstants.MsaTenantId, true).Result, "Organizations authority with MSA-pt - based on home account id"); Assert.IsTrue( _wamBroker.IsMsaRequestAsync(Authority.CreateAuthority(TestConstants.AuthorityConsumersTenant), TestConstants.TenantId, false).Result, "Consumer authority - msa plugin"); Assert.IsFalse( _wamBroker.IsMsaRequestAsync(Authority.CreateAuthority(TestConstants.AuthorityGuidTenant), TestConstants.TenantId, true).Result, "Tenanted authorities - AAD plugin"); }
public void ConcurrentDictionary_TestIDictionary_Negative() { IDictionary dictionary = new ConcurrentDictionary <string, int>(); AssertException.Throws <ArgumentNullException>( () => dictionary.Add(null, 1)); // "TestIDictionary: FAILED. Add didn't throw ANE when null key is passed"); AssertException.Throws <ArgumentException>( () => dictionary.Add(1, 1)); // "TestIDictionary: FAILED. Add didn't throw AE when incorrect key type is passed"); AssertException.Throws <ArgumentException>( () => dictionary.Add("1", "1")); // "TestIDictionary: FAILED. Add didn't throw AE when incorrect value type is passed"); AssertException.Throws <ArgumentNullException>( () => dictionary.Contains(null)); // "TestIDictionary: FAILED. Contain didn't throw ANE when null key is passed"); //Test Remove AssertException.Throws <ArgumentNullException>( () => dictionary.Remove(null)); // "TestIDictionary: FAILED. Remove didn't throw ANE when null key is passed"); //Test this[] AssertException.Throws <ArgumentNullException>( () => { object val = dictionary[null]; }); // "TestIDictionary: FAILED. this[] getter didn't throw ANE when null key is passed"); AssertException.Throws <ArgumentNullException>( () => dictionary[null] = 0); // "TestIDictionary: FAILED. this[] setter didn't throw ANE when null key is passed"); AssertException.Throws <ArgumentException>( () => dictionary[1] = 0); // "TestIDictionary: FAILED. this[] setter didn't throw AE when invalid key type is passed"); AssertException.Throws <ArgumentException>( () => dictionary["1"] = "0"); // "TestIDictionary: FAILED. this[] setter didn't throw AE when invalid value type is passed"); }
public void PreArgProc_MissingArguments() { // 0. Setup TestLogger logger; // 1. Null logger AssertException.Expects <ArgumentNullException>(() => ArgumentProcessor.TryProcessArgs(null, null)); using (EnvironmentVariableScope scope = new EnvironmentVariableScope()) { CreateRunnerFilesInScope(scope); // 2. All required arguments missing logger = CheckProcessingFails(/* no command line args */); logger.AssertSingleErrorExists("/key:"); // we expect errors with info about the missing required parameters, which should include the primary alias logger.AssertSingleErrorExists("/name:"); logger.AssertSingleErrorExists("/version:"); logger.AssertErrorDoesNotExist("/runner:"); logger.AssertErrorsLogged(3); // 3. Some required arguments missing logger = CheckProcessingFails("/k:key", "/v:version"); logger.AssertErrorDoesNotExist("/key:"); logger.AssertErrorDoesNotExist("/version:"); logger.AssertErrorDoesNotExist("/runner:"); logger.AssertSingleErrorExists("/name:"); logger.AssertErrorsLogged(1); // 4. Argument is present but has no value logger = CheckProcessingFails("/key:k1", "/name:n1", "/version:"); logger.AssertErrorDoesNotExist("/key:"); logger.AssertErrorDoesNotExist("/name:"); logger.AssertErrorDoesNotExist("/runner:"); logger.AssertSingleErrorExists("/version:"); logger.AssertErrorsLogged(1); } }
public void BrokerInteractiveRequestTest() { string CanonicalizedAuthority = AuthorityInfo.CanonicalizeAuthorityUri(CoreHelpers.UrlDecode(MsalTestConstants.AuthorityTestTenant)); using (var harness = CreateTestHarness()) { // Arrange var parameters = harness.CreateAuthenticationRequestParameters( MsalTestConstants.AuthorityTestTenant, null, null, null, MsalTestConstants.ExtraQueryParams); // Act BrokerFactory brokerFactory = new BrokerFactory(); BrokerInteractiveRequest brokerInteractiveRequest = new BrokerInteractiveRequest(parameters, null, null, null, brokerFactory.Create(harness.ServiceBundle)); Assert.AreEqual(false, brokerInteractiveRequest.Broker.CanInvokeBroker(null)); AssertException.TaskThrowsAsync <PlatformNotSupportedException>(() => brokerInteractiveRequest.Broker.AcquireTokenUsingBrokerAsync(new Dictionary <string, string>())).ConfigureAwait(false); } }
public void Should_call_task_exception_only_on_failing_theories() { var exception1 = new AssertException("Broken1"); var method = testClass.AddMethod("TestMethod1", parameters => { var value = (int)parameters[0]; if (value == 12) { throw exception1; } }, new[] { Parameter.Create <int>("value") }, new TheoryAttribute(), new InlineDataAttribute(12), new InlineDataAttribute(33)); Run(); var theoryTasks = method.TheoryTasks; Messages.OfEquivalentTask(theoryTasks[0]).AssertTaskException(exception1); Messages.OfEquivalentTask(theoryTasks[1]).AssertTaskFinishedSuccessfully(); }
public void ClientIdMustBeAGuid() { var ex = AssertException.Throws <MsalClientException>( () => PublicClientApplicationBuilder.Create("http://my.app") .WithAuthority(TestConstants.AadAuthorityWithTestTenantId) .Build()); Assert.AreEqual(MsalError.ClientIdMustBeAGuid, ex.ErrorCode); ex = AssertException.Throws <MsalClientException>( () => PublicClientApplicationBuilder.Create("http://my.app") .WithAuthority(TestConstants.B2CAuthority) .Build()); Assert.AreEqual(MsalError.ClientIdMustBeAGuid, ex.ErrorCode); // ADFS does not have this constraint PublicClientApplicationBuilder.Create("http://my.app") .WithAuthority(new Uri(TestConstants.ADFSAuthority)) .Build(); }
public void Manifest_InvalidCharsInName_Throws() { // Arrange JarManifestBuilder builder = new JarManifestBuilder(); string[] invalidNames = { "", // empty null, "%", "1234!", "a b", // whitespace "1\r\n2" // more whitespace }; // Act and assert foreach (string name in invalidNames) { AssertException.Expect <ArgumentException>(() => builder.SetProperty(name, "valid.property")); } }
public void InnerExceptionIncludedWithAdalClaimsChallengeExceptionTestAsync() { var context = new AuthenticationContext(TestConstants.DefaultAuthorityCommonTenant, new TokenCache()); var credential = new ClientCredential(TestConstants.DefaultClientId, TestConstants.DefaultClientSecret); HttpMessageHandlerFactory.AddMockHandler(new MockHttpMessageHandler(TestConstants.GetTokenEndpoint(TestConstants.DefaultAuthorityCommonTenant)) { Method = HttpMethod.Post, ResponseMessage = new HttpResponseMessage(HttpStatusCode.BadRequest) { Content = new StringContent(responseContent) } }); var result = AssertException.TaskThrows <AdalClaimChallengeException>(() => context.AcquireTokenAsync(TestConstants.DefaultResource, credential)); // Check inner exception Assert.AreEqual("Response status code does not indicate success: 400 (BadRequest).", result.InnerException.Message); Assert.AreEqual(responseContent + ": Unknown error", result.InnerException.InnerException.Message); }
private static async Task RunAfterAccessFailureAsync( IPublicClientApplication pca, Func <Task> operationThatTouchesCache) { bool beforeAccessCalled = false; bool afterAccessCalled = false; pca.UserTokenCache.SetBeforeAccess(args => { beforeAccessCalled = true; throw new InvalidOperationException(); }); pca.UserTokenCache.SetAfterAccess(args => { afterAccessCalled = true; }); await AssertException.TaskThrowsAsync <InvalidOperationException>( operationThatTouchesCache).ConfigureAwait(false); Assert.IsTrue(beforeAccessCalled); Assert.IsTrue(afterAccessCalled); }
public void CapabilitiesFaultTest() { RunTest(() => { MessageSpoiler spoiler = new MessageSpoiler(); Dictionary <string, string> namespaces = new Dictionary <string, string>(); namespaces.Add("s", "http://www.w3.org/2003/05/soap-envelope"); namespaces.Add("onvif", "http://www.onvif.org/ver10/device/wsdl"); Dictionary <string, string> replacements = new Dictionary <string, string>(); replacements.Add("/s:Envelope/s:Body/onvif:GetCapabilities/onvif:Category", "XYZ"); spoiler.Namespaces = namespaces; spoiler.NodesToReplace = replacements; SetBreakingBehaviour(spoiler); bool fault = false; try { GetCapabilities(new CapabilityCategory[] { CapabilityCategory.All }); } catch (FaultException exception) { fault = true; SaveStepFault(exception); StepPassed(); } if (!fault) { string reason = "No SOAP fault returned from the DUT"; AssertException ex = new AssertException(reason); StepFailed(ex); throw ex; } }); }
public async Task AcquireTokenByIntegratedWindowsAuthTest_ManagedUser_DiscoveryFailed_ThrowsExceptionAsync() { // Arrange using (var httpManager = new MockHttpManager()) { httpManager.AddInstanceDiscoveryMockHandler(); httpManager.AddMockHandler( new MockHttpMessageHandler { ExpectedMethod = HttpMethod.Get, ResponseMessage = new HttpResponseMessage(HttpStatusCode.NotFound) { Content = new StringContent( "{\"ver\":\"1.0\"," + "\"account_type\":\"Managed\"," + "\"domain_name\":\"some_domain.onmicrosoft.com\"," + "\"cloud_audience_urn\":\"urn:federation:MicrosoftOnline\"," + "\"cloud_instance_name\":\"login.microsoftonline.com\"}") } }); PublicClientApplication app = PublicClientApplicationBuilder.Create(TestConstants.ClientId) .WithAuthority(new Uri(ClientApplicationBase.DefaultAuthority), true) .WithHttpManager(httpManager) .BuildConcrete(); // Act MsalServiceException exception = await AssertException.TaskThrowsAsync <MsalServiceException>( async() => await app .AcquireTokenByIntegratedWindowsAuth(TestConstants.s_scope) .WithUsername(TestConstants.s_user.Username) .ExecuteAsync(CancellationToken.None) .ConfigureAwait(false)).ConfigureAwait(false); // Assert Assert.AreEqual(MsalError.UserRealmDiscoveryFailed, exception.ErrorCode); Assert.AreEqual(HttpStatusCode.NotFound, (HttpStatusCode)exception.StatusCode); } }
private async Task <PublicClientApplication> SetupAndAcquireOnceAsync( MockHttpAndServiceBundle httpManagerAndBundle, int httpStatusCode, int?retryAfterInSeconds, TokenResponseType tokenResponseType) { Trace.WriteLine("1. Setup test"); var httpManager = httpManagerAndBundle.HttpManager; PublicClientApplication app = PublicClientApplicationBuilder.Create(TestConstants.ClientId) .WithHttpManager(httpManager) .BuildConcrete(); new TokenCacheHelper().PopulateCache(app.UserTokenCacheInternal.Accessor, expiredAccessTokens: true); var tokenResponse = httpManager.AddAllMocks(tokenResponseType); UpdateStatusCodeAndHeaders(tokenResponse.ResponseMessage, httpStatusCode, retryAfterInSeconds); if (httpStatusCode >= 500 && httpStatusCode < 600 && !retryAfterInSeconds.HasValue) { var response2 = httpManager.AddTokenResponse( tokenResponseType, s_throttlingHeader); UpdateStatusCodeAndHeaders(response2.ResponseMessage, httpStatusCode, retryAfterInSeconds); } var account = (await app.GetAccountsAsync().ConfigureAwait(false)).Single(); Trace.WriteLine("2. First failing call "); var ex = await AssertException.TaskThrowsAsync <MsalServiceException>( () => app.AcquireTokenSilent(TestConstants.s_scope, account).ExecuteAsync(), allowDerived : true) .ConfigureAwait(false); Assert.AreEqual(0, httpManager.QueueSize, "No more requests expected"); Assert.AreEqual(httpStatusCode, ex.StatusCode); Assert.AreEqual(tokenResponseType == TokenResponseType.InvalidGrant, ex is MsalUiRequiredException); return(app); }
public async Task FederatedUsernamePasswordCommonAuthorityTestAsync() { using (var httpManager = new MockHttpManager()) { httpManager.AddInstanceDiscoveryMockHandler(); httpManager.AddMockHandlerForTenantEndpointDiscovery(TestConstants.AuthorityCommonTenant); AddMockHandlerDefaultUserRealmDiscovery(httpManager); AddMockHandlerMex(httpManager); AddMockHandlerWsTrustUserName(httpManager); // AAD httpManager.AddMockHandler( new MockHttpMessageHandler { ExpectedUrl = "https://login.microsoftonline.com/common/oauth2/v2.0/token", ExpectedMethod = HttpMethod.Post, ResponseMessage = MockHelpers.CreateInvalidRequestTokenResponseMessage() }); PublicClientApplication app = PublicClientApplicationBuilder.Create(TestConstants.ClientId) .WithAuthority(new Uri(ClientApplicationBase.DefaultAuthority), true) .WithHttpManager(httpManager) .WithTelemetry(new TraceTelemetryConfig()) .BuildConcrete(); // Call acquire token MsalServiceException result = await AssertException.TaskThrowsAsync <MsalServiceException>( async() => await app.AcquireTokenByUsernamePassword( TestConstants.s_scope, TestConstants.s_user.Username, _secureString).ExecuteAsync(CancellationToken.None).ConfigureAwait(false)).ConfigureAwait(false); // Check inner exception Assert.AreEqual(MsalError.InvalidRequest, result.ErrorCode); // There should be no cached entries. Assert.AreEqual(0, app.UserTokenCacheInternal.Accessor.GetAllAccessTokens().Count()); } }
private async Task <(MockHttpMessageHandler MockHttpHandler, Guid Correlationid)> RunSilentFlowWithTokenErrorAsync(AcquireTokenSilentParameterBuilder request, string errorCode) { _app.UserTokenCacheInternal.Accessor.ClearAccessTokens(); var correlationId = Guid.NewGuid(); var tokenRequest = _harness.HttpManager.AddFailureTokenEndpointResponse( errorCode, TestConstants.AuthorityUtidTenant, correlationId.ToString()); var ex = await AssertException.TaskThrowsAsync <MsalServiceException>( () => request.WithCorrelationId(correlationId).ExecuteAsync(), allowDerived : true) .ConfigureAwait(false); Assert.AreEqual( correlationId, Guid.Parse(ex.CorrelationId), "Test error - Exception correlation ID does not match WithCorrelationId value"); return(tokenRequest, correlationId); }
public async Task FailingTest_SeleniumFailureAsync() { var pca = PublicClientApplicationBuilder .Create("1d18b3b0-251b-4714-a02a-9956cec86c2d") .WithRedirectUri(SeleniumWebUI.FindFreeLocalhostRedirectUri()) .Build(); // This should fail after a few seconds var seleniumLogic = new SeleniumWebUI((driver) => { Trace.WriteLine("Looking for an element that does not exist"); driver.FindElement(By.Id("i_hope_this_element_does_not_exist")); }, TestContext); // The exception propagated to the test should be Selenium exception, // the test should not wait for the TCP listener to time out await AssertException.TaskThrowsAsync <NoSuchElementException>(() => pca .AcquireTokenInteractive(s_scopes) .WithCustomWebUi(seleniumLogic) .ExecuteAsync(CancellationToken.None)) .ConfigureAwait(false); }
public async Task AcquireTokenByIntegratedWindowsAuthTest_UnknownUserAsync() { // Arrange using (var httpManager = new MockHttpManager()) { httpManager.AddInstanceDiscoveryMockHandler(); httpManager.AddMockHandlerForTenantEndpointDiscovery(TestConstants.AuthorityCommonTenant); // user realm discovery - unknown user type httpManager.AddMockHandler( new MockHttpMessageHandler { ExpectedMethod = HttpMethod.Get, ResponseMessage = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent( "{\"ver\":\"1.0\"," + "\"account_type\":\"Bogus\"}") } }); PublicClientApplication app = PublicClientApplicationBuilder.Create(TestConstants.ClientId) .WithAuthority(new Uri(ClientApplicationBase.DefaultAuthority), true) .WithHttpManager(httpManager) .WithTelemetry(new TraceTelemetryConfig()) .BuildConcrete(); // Act MsalClientException exception = await AssertException.TaskThrowsAsync <MsalClientException>( async() => await app .AcquireTokenByIntegratedWindowsAuth(TestConstants.s_scope) .WithUsername(TestConstants.s_user.Username) .ExecuteAsync(CancellationToken.None) .ConfigureAwait(false)).ConfigureAwait(false); // Assert Assert.AreEqual(MsalError.UnknownUserType, exception.ErrorCode); } }
public void Should_call_task_exception_only_on_failing_theories() { var exception1 = new AssertException("Broken1"); var method = testClass.AddMethod("TestMethod1", parameters => { var value = (int) parameters[0]; if (value == 12) throw exception1; }, new[] {Parameter.Create<int>("value")}, new TheoryAttribute(), new InlineDataAttribute(12), new InlineDataAttribute(33)); Run(); var theoryTasks = method.TheoryTasks; Messages.OfEquivalentTask(theoryTasks[0]).AssertTaskException(exception1); Messages.OfEquivalentTask(theoryTasks[1]).AssertTaskFinishedSuccessfully(); }
public void UserMessageIsTheMessage() { AssertException ex = new AssertException("UserMessage"); Assert.Equal(ex.UserMessage, ex.Message); }
public void PreservesUserMessage() { AssertException ex = new AssertException("UserMessage"); Assert.Equal("UserMessage", ex.UserMessage); }