private async void FakeProgressButton_Click(object sender, RoutedEventArgs e) { await MockHelpers.ShowFakeProgressDialog(2000); }
public async void Post_User_LockedOut() { // Arrange var controller = MockAccountController(MockHelpers.MockSignInManager <ApplicationUser>(SignInResult.LockedOut), MockHelpers.MockUserManager(User)); // Act var result = await controller.VerifyCode(VerifyCodeViewModel) as ViewResult; //assert Assert.NotNull(result); Assert.Equal("Lockout", result?.ViewName); }
public async void Invalid() { // Arrange var controller = MockAccountController(MockHelpers.MockSignInManager <ApplicationUser>(SignInResult.Failed), MockHelpers.MockUserManager(User)); // Act var result = await controller.Login(new LoginViewModel { Email = "Failed", Password = "******", RememberMe = true }, "retrunurl"); //assert Assert.Equal("Invalid login attempt.", controller.ModelState.Values.Select(m => m.Errors[0].ErrorMessage).First()); }
public async void Post_RegisteredUser_nullToken() { // Arrange var controller = MockAccountController(MockHelpers.MockSignInManager(User), MockHelpers.MockUserManager(User)); // Act var result = await controller.SendCode(SendCodeViewModel) as ViewResult; //assert Assert.NotNull(result); Assert.Equal("Error", result?.ViewName); }
public async void AnonymousUser() { // Arrange var controller = MockAccountController(MockHelpers.MockSignInManager <ApplicationUser>(), MockHelpers.MockUserManager <ApplicationUser>()); // Act var result = await controller.VerifyCode("Email", true, "returnurl") as ViewResult; //assert Assert.NotNull(result); Assert.Equal("Error", result?.ViewName); }
public async void Callback_ExternalSuccess_LocalSuccess_LocalUrl() { // Arrange var signInResult = SignInResult.Success; var controller = MockAccountController( MockHelpers.MockSignInManager <ApplicationUser>(SignInResult.Success, SignInResult.Success, MockHelpers.DefaultInfo())); // Act var result = await controller.ExternalLoginCallback("localUrl", null) as RedirectResult; //assert Assert.Equal("localUrl", result.Url); }
public async void UserFound_CodeValid() { // Arrange var signInResult = SignInResult.Success; var controller = MockAccountController(MockHelpers.MockSignInManager <ApplicationUser>(), MockHelpers.MockUserManager(User, IdentityResult.Success)); // Act var result = await controller.ConfirmEmail("userId", "code") as ViewResult; //assert Assert.Equal("ConfirmEmail", result?.ViewName); }
public void SuccessfulValidationUsingOnPremiseDrsTest() { using (var harness = CreateTestHarness()) { // add mock response for on-premise DRS request harness.HttpManager.AddMockHandler( new MockHttpMessageHandler { ExpectedMethod = HttpMethod.Get, ExpectedUrl = "https://enterpriseregistration.fabrikam.com/enrollmentserver/contract", ExpectedQueryParams = new Dictionary <string, string> { { "api-version", "1.0" } }, ResponseMessage = MockHelpers.CreateSuccessResponseMessage( ResourceHelper.GetTestResourceRelativePath(File.ReadAllText("drs-response.json"))) }); // add mock response for on-premise webfinger request harness.HttpManager.AddMockHandler( new MockHttpMessageHandler { ExpectedMethod = HttpMethod.Get, ExpectedUrl = "https://fs.fabrikam.com/adfs/.well-known/webfinger", ExpectedQueryParams = new Dictionary <string, string> { { "resource", "https://fs.contoso.com" }, { "rel", "http://schemas.microsoft.com/rel/trusted-realm" } }, ResponseMessage = MockHelpers.CreateSuccessWebFingerResponseMessage() }); // add mock response for tenant endpoint discovery harness.HttpManager.AddMockHandler( new MockHttpMessageHandler { ExpectedMethod = HttpMethod.Get, ExpectedUrl = "https://fs.contoso.com/adfs/.well-known/openid-configuration", ResponseMessage = MockHelpers.CreateSuccessResponseMessage( ResourceHelper.GetTestResourceRelativePath(File.ReadAllText("OpenidConfiguration-OnPremise.json"))) }); Authority instance = Authority.CreateAuthority(TestConstants.OnPremiseAuthority); Assert.IsNotNull(instance); Assert.AreEqual(instance.AuthorityInfo.AuthorityType, AuthorityType.Adfs); var endpoints = harness.ServiceBundle.AuthorityEndpointResolutionManager.ResolveEndpointsAsync( instance.AuthorityInfo, TestConstants.FabrikamDisplayableId, new RequestContext(harness.ServiceBundle, Guid.NewGuid())) .GetAwaiter().GetResult(); Assert.AreEqual("https://fs.contoso.com/adfs/oauth2/authorize/", endpoints.AuthorizationEndpoint); Assert.AreEqual("https://fs.contoso.com/adfs/oauth2/token/", endpoints.TokenEndpoint); Assert.AreEqual("https://fs.contoso.com/adfs", endpoints.SelfSignedJwtAudience); // attempt to do authority validation again. NO network call should be made instance = Authority.CreateAuthority(TestConstants.OnPremiseAuthority); Assert.IsNotNull(instance); Assert.AreEqual(instance.AuthorityInfo.AuthorityType, AuthorityType.Adfs); endpoints = harness.ServiceBundle.AuthorityEndpointResolutionManager.ResolveEndpointsAsync( instance.AuthorityInfo, TestConstants.FabrikamDisplayableId, new RequestContext(harness.ServiceBundle, Guid.NewGuid())) .GetAwaiter().GetResult(); Assert.AreEqual("https://fs.contoso.com/adfs/oauth2/authorize/", endpoints.AuthorizationEndpoint); Assert.AreEqual("https://fs.contoso.com/adfs/oauth2/token/", endpoints.TokenEndpoint); Assert.AreEqual("https://fs.contoso.com/adfs", endpoints.SelfSignedJwtAudience); } }
public void SuccessfulValidationUsingOnPremiseDrsTest() { //add mock response for on-premise DRS request HttpMessageHandlerFactory.AddMockHandler(new MockHttpMessageHandler { Method = HttpMethod.Get, Url = "https://enterpriseregistration.fabrikam.com/enrollmentserver/contract", QueryParams = new Dictionary <string, string> { { "api-version", "1.0" } }, ResponseMessage = MockHelpers.CreateSuccessResponseMessage(File.ReadAllText("drs-response.json")) }); //add mock response for on-premise webfinger request HttpMessageHandlerFactory.AddMockHandler(new MockHttpMessageHandler { Method = HttpMethod.Get, Url = "https://fs.fabrikam.com/adfs/.well-known/webfinger", QueryParams = new Dictionary <string, string> { { "resource", "https://fs.contoso.com" }, { "rel", "http://schemas.microsoft.com/rel/trusted-realm" } }, ResponseMessage = MockHelpers.CreateSuccessWebFingerResponseMessage() }); //add mock response for tenant endpoint discovery HttpMessageHandlerFactory.AddMockHandler(new MockHttpMessageHandler { Method = HttpMethod.Get, Url = "https://fs.contoso.com/adfs/.well-known/openid-configuration", ResponseMessage = MockHelpers.CreateSuccessResponseMessage(File.ReadAllText("OpenidConfiguration-OnPremise.json")) }); Authority instance = Authority.CreateAuthority(TestConstants.OnPremiseAuthority, true); Assert.IsNotNull(instance); Assert.AreEqual(instance.AuthorityType, AuthorityType.Adfs); Task.Run(async() => { await instance.ResolveEndpointsAsync(TestConstants.FabrikamDisplayableId, new RequestContext(Guid.NewGuid(), null)); }).GetAwaiter().GetResult(); Assert.AreEqual("https://fs.contoso.com/adfs/oauth2/authorize/", instance.AuthorizationEndpoint); Assert.AreEqual("https://fs.contoso.com/adfs/oauth2/token/", instance.TokenEndpoint); Assert.AreEqual("https://fs.contoso.com/adfs", instance.SelfSignedJwtAudience); Assert.AreEqual(0, HttpMessageHandlerFactory.MockCount); Assert.AreEqual(1, Authority.ValidatedAuthorities.Count); //attempt to do authority validation again. NO network call should be made instance = Authority.CreateAuthority(TestConstants.OnPremiseAuthority, true); Assert.IsNotNull(instance); Assert.AreEqual(instance.AuthorityType, AuthorityType.Adfs); Task.Run(async() => { await instance.ResolveEndpointsAsync(TestConstants.FabrikamDisplayableId, new RequestContext(Guid.NewGuid(), null)); }).GetAwaiter().GetResult(); Assert.AreEqual("https://fs.contoso.com/adfs/oauth2/authorize/", instance.AuthorizationEndpoint); Assert.AreEqual("https://fs.contoso.com/adfs/oauth2/token/", instance.TokenEndpoint); Assert.AreEqual("https://fs.contoso.com/adfs", instance.SelfSignedJwtAudience); }
private AuthenticationRequestParameters CreateAuthenticationParametersAndSetupMocks( MockHttpAndServiceBundle harness, int numAuthorizationPendingResults, out HashSet <string> expectedScopes, bool isAdfs = false) { var cache = new TokenCache(harness.ServiceBundle, false); var parameters = harness.CreateAuthenticationRequestParameters( isAdfs ? TestConstants.OnPremiseAuthority : TestConstants.AuthorityHomeTenant, null, cache, null, extraQueryParameters: TestConstants.ExtraQueryParameters, claims: TestConstants.Claims); if (isAdfs) { harness.HttpManager.AddMockHandler(new MockHttpMessageHandler { ExpectedMethod = HttpMethod.Get, ResponseMessage = MockHelpers.CreateAdfsOpenIdConfigurationResponse(TestConstants.OnPremiseAuthority) }); } else { TestCommon.MockInstanceDiscoveryAndOpenIdRequest(harness.HttpManager); } expectedScopes = new HashSet <string>(); expectedScopes.UnionWith(TestConstants.s_scope); expectedScopes.Add(OAuth2Value.ScopeOfflineAccess); expectedScopes.Add(OAuth2Value.ScopeProfile); expectedScopes.Add(OAuth2Value.ScopeOpenId); // Mock Handler for device code request harness.HttpManager.AddMockHandler( new MockHttpMessageHandler { ExpectedMethod = HttpMethod.Post, ExpectedPostData = new Dictionary <string, string>() { { OAuth2Parameter.ClientId, TestConstants.ClientId }, { OAuth2Parameter.Scope, expectedScopes.AsSingleString() }, { OAuth2Parameter.Claims, TestConstants.Claims } }, ResponseMessage = isAdfs ? CreateAdfsDeviceCodeResponseSuccessMessage() : CreateDeviceCodeResponseSuccessMessage(), ExpectedQueryParams = TestConstants.ExtraQueryParameters, }); for (int i = 0; i < numAuthorizationPendingResults; i++) { harness.HttpManager.AddMockHandler( new MockHttpMessageHandler { ExpectedMethod = HttpMethod.Post, ExpectedUrl = isAdfs ? "https://fs.contoso.com/adfs/oauth2/token" : "https://login.microsoftonline.com/home/oauth2/v2.0/token", ResponseMessage = MockHelpers.CreateFailureMessage( HttpStatusCode.Forbidden, "{\"error\":\"authorization_pending\"," + "\"error_description\":\"AADSTS70016: Pending end-user authorization." + "\\r\\nTrace ID: f6c2c73f-a21d-474e-a71f-d8b121a58205\\r\\nCorrelation ID: " + "36fe3e82-442f-4418-b9f4-9f4b9295831d\\r\\nTimestamp: 2015-09-24 19:51:51Z\"," + "\"error_codes\":[70016],\"timestamp\":\"2015-09-24 19:51:51Z\",\"trace_id\":" + "\"f6c2c73f-a21d-474e-a71f-d8b121a58205\",\"correlation_id\":" + "\"36fe3e82-442f-4418-b9f4-9f4b9295831d\"}") }); } if (numAuthorizationPendingResults > 0) { // Mock Handler for devicecode->token exchange request harness.HttpManager.AddMockHandler( new MockHttpMessageHandler { ExpectedMethod = HttpMethod.Post, ExpectedPostData = new Dictionary <string, string>() { { OAuth2Parameter.ClientId, TestConstants.ClientId }, { OAuth2Parameter.Scope, expectedScopes.AsSingleString() } }, ResponseMessage = isAdfs ? MockHelpers.CreateAdfsSuccessTokenResponseMessage() : MockHelpers.CreateSuccessTokenResponseMessage() }); } return(parameters); }
private HttpResponseMessage CreateAdfsDeviceCodeResponseSuccessMessage() { return(MockHelpers.CreateSuccessResponseMessage(ExpectedAdfsResponseMessage)); }
public void TestGetAccounts() { var tokenCacheHelper = new TokenCacheHelper(); using (var httpManager = new MockHttpManager()) { PublicClientApplication app = PublicClientApplicationBuilder.Create(MsalTestConstants.ClientId) .WithHttpManager(httpManager) .WithTelemetry(new TraceTelemetryConfig()) .BuildConcrete(); IEnumerable <IAccount> accounts = app.GetAccountsAsync().Result; Assert.IsNotNull(accounts); Assert.IsFalse(accounts.Any()); tokenCacheHelper.PopulateCache(app.UserTokenCacheInternal.Accessor); accounts = app.GetAccountsAsync().Result; Assert.IsNotNull(accounts); Assert.AreEqual(1, accounts.Count()); var atItem = new MsalAccessTokenCacheItem( MsalTestConstants.ProductionPrefCacheEnvironment, MsalTestConstants.ClientId, MsalTestConstants.Scope.AsSingleString(), MsalTestConstants.Utid, null, new DateTimeOffset(DateTime.UtcNow + TimeSpan.FromSeconds(3600)), new DateTimeOffset(DateTime.UtcNow + TimeSpan.FromSeconds(7200)), MockHelpers.CreateClientInfo()); atItem.Secret = atItem.GetKey().ToString(); app.UserTokenCacheInternal.Accessor.SaveAccessToken(atItem); // another cache entry for different uid. user count should be 2. MsalRefreshTokenCacheItem rtItem = new MsalRefreshTokenCacheItem( MsalTestConstants.ProductionPrefCacheEnvironment, MsalTestConstants.ClientId, "someRT", MockHelpers.CreateClientInfo("uId1", "uTId1")); app.UserTokenCacheInternal.Accessor.SaveRefreshToken(rtItem); MsalIdTokenCacheItem idTokenCacheItem = new MsalIdTokenCacheItem( MsalTestConstants.ProductionPrefCacheEnvironment, MsalTestConstants.ClientId, MockHelpers.CreateIdToken(MsalTestConstants.UniqueId, MsalTestConstants.DisplayableId), MockHelpers.CreateClientInfo("uId1", "uTId1"), "uTId1"); app.UserTokenCacheInternal.Accessor.SaveIdToken(idTokenCacheItem); MsalAccountCacheItem accountCacheItem = new MsalAccountCacheItem( MsalTestConstants.ProductionPrefCacheEnvironment, null, MockHelpers.CreateClientInfo("uId1", "uTId1"), null, null, "uTId1", null, null); app.UserTokenCacheInternal.Accessor.SaveAccount(accountCacheItem); Assert.AreEqual(2, app.UserTokenCacheInternal.Accessor.GetAllRefreshTokens().Count()); accounts = app.GetAccountsAsync().Result; Assert.IsNotNull(accounts); Assert.AreEqual(2, accounts.Count()); // scoped by env // another cache entry for different environment. user count should still be 2. Sovereign cloud user must not be returned rtItem = new MsalRefreshTokenCacheItem( MsalTestConstants.SovereignNetworkEnvironment, MsalTestConstants.ClientId, "someRT", MockHelpers.CreateClientInfo(MsalTestConstants.Uid + "more1", MsalTestConstants.Utid)); app.UserTokenCacheInternal.Accessor.SaveRefreshToken(rtItem); Assert.AreEqual(3, app.UserTokenCacheInternal.Accessor.GetAllRefreshTokens().Count()); accounts = app.GetAccountsAsync().Result; Assert.IsNotNull(accounts); Assert.AreEqual(2, accounts.Count()); } }
public void UnifiedCache_MsalStoresToAndReadRtFromAdalCache() { using (var httpManager = new MockHttpManager()) { httpManager.AddInstanceDiscoveryMockHandler(); var app = PublicClientApplicationBuilder.Create(TestConstants.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(TestConstants.AuthorityCommonTenant); httpManager.AddSuccessTokenResponseMockHandlerForPost(ClientApplicationBase.DefaultAuthority); 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.DefaultLogger, app.UserTokenCacheInternal.LegacyPersistence.LoadCache()); Assert.IsTrue(adalCacheDictionary.Count == 1); var requestContext = new RequestContext(app.ServiceBundle, Guid.NewGuid()); var accounts = app.UserTokenCacheInternal.GetAccountsAsync( TestConstants.AuthorityCommonTenant, requestContext).Result; foreach (IAccount account in accounts) { app.UserTokenCacheInternal.RemoveMsalAccountWithNoLocks(account, requestContext); } Assert.AreEqual(0, httpManager.QueueSize); httpManager.AddMockHandlerForTenantEndpointDiscovery(TestConstants.AuthorityUtidTenant); 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 async Task AuthorityMigrationTestAsync() { // make sure that for all network calls "preferred_cache" environment is used // (it is taken from metadata in instance discovery response), // except very first network call - instance discovery using (var harness = base.CreateTestHarness()) { var httpManager = harness.HttpManager; var authorityUri = new Uri( string.Format( CultureInfo.InvariantCulture, "https://{0}/common", TestConstants.ProductionNotPrefEnvironmentAlias)); httpManager.AddInstanceDiscoveryMockHandler(authorityUri.AbsoluteUri); PublicClientApplication app = PublicClientApplicationBuilder .Create(TestConstants.ClientId) .WithAuthority(authorityUri, true) .WithHttpManager(httpManager) .WithUserTokenLegacyCachePersistenceForTest(new TestLegacyCachePersistance()) .WithTelemetry(new TraceTelemetryConfig()) .WithDebugLoggingCallback() .BuildConcrete(); // mock webUi authorization MsalMockHelpers.ConfigureMockWebUI( app.ServiceBundle.PlatformProxy, AuthorizationResult.FromUri(app.AppConfig.RedirectUri + "?code=some-code"), null, TestConstants.ProductionPrefNetworkEnvironment); // mock token request httpManager.AddMockHandler(new MockHttpMessageHandler { ExpectedUrl = string.Format(CultureInfo.InvariantCulture, "https://{0}/common/oauth2/v2.0/token", TestConstants.ProductionPrefNetworkEnvironment), ExpectedMethod = HttpMethod.Post, ResponseMessage = MockHelpers.CreateSuccessTokenResponseMessage() }); AuthenticationResult result = app.AcquireTokenInteractive(TestConstants.s_scope).ExecuteAsync(CancellationToken.None).Result; // make sure that all cache entities are stored with "preferred_cache" environment // (it is taken from metadata in instance discovery response) await ValidateCacheEntitiesEnvironmentAsync(app.UserTokenCacheInternal, TestConstants.ProductionPrefCacheEnvironment).ConfigureAwait(false); // silent request targeting at, should return at from cache for any environment alias foreach (var envAlias in TestConstants.s_prodEnvAliases) { result = await app .AcquireTokenSilent( TestConstants.s_scope, app.GetAccountsAsync().Result.First()) .WithAuthority(string.Format(CultureInfo.InvariantCulture, "https://{0}/{1}/", envAlias, TestConstants.Utid)) .WithForceRefresh(false) .ExecuteAsync(CancellationToken.None) .ConfigureAwait(false); Assert.IsNotNull(result); } // silent request targeting rt should find rt in cache for authority with any environment alias foreach (var envAlias in TestConstants.s_prodEnvAliases) { result = null; httpManager.AddMockHandler(new MockHttpMessageHandler() { ExpectedUrl = string.Format(CultureInfo.InvariantCulture, "https://{0}/{1}/oauth2/v2.0/token", TestConstants.ProductionPrefNetworkEnvironment, TestConstants.Utid), ExpectedMethod = HttpMethod.Post, ExpectedPostData = new Dictionary<string, string>() { {"grant_type", "refresh_token"} }, // return not retriable status code ResponseMessage = MockHelpers.CreateInvalidGrantTokenResponseMessage() }); try { result = await app .AcquireTokenSilent( TestConstants.s_scopeForAnotherResource, (await app.GetAccountsAsync().ConfigureAwait(false)).First()) .WithAuthority(string.Format(CultureInfo.InvariantCulture, "https://{0}/{1}/", envAlias, TestConstants.Utid)) .WithForceRefresh(false) .ExecuteAsync(CancellationToken.None).ConfigureAwait(false); } catch (MsalUiRequiredException) { } Assert.IsNull(result); } } }
public async void Callback_ExternalSucces_LocalLockedOut() { // Arrange var controller = MockAccountController( MockHelpers.MockSignInManager <ApplicationUser>(SignInResult.Failed, SignInResult.LockedOut, MockHelpers.DefaultInfo()), MockHelpers.MockUserManager(User)); //var controller = MockAccountController(SignInResult.Failed, SignInResult.LockedOut, nullInfo: false, EmailAddress: "RegisterUserEmail"); // Act var result = await controller.ExternalLoginCallback("returnurl", null) as ViewResult; //assert Assert.Equal("Lockout", result?.ViewName); }
public async Task ValidateKeyExpirationAsync() { using (var harness = CreateTestHarness()) { harness.HttpManager.AddInstanceDiscoveryMockHandler(); PoPAuthenticationConfiguration popConfig = new PoPAuthenticationConfiguration(new Uri("https://www.contoso.com/path1/path2?queryParam1=a&queryParam2=b")); popConfig.HttpMethod = HttpMethod.Get; var app = ConfidentialClientApplicationBuilder.Create(TestConstants.ClientId) .WithHttpManager(harness.HttpManager) .WithExperimentalFeatures() .WithClientSecret("some-secret") .BuildConcrete(); TokenCacheHelper.PopulateCache(app.AppTokenCacheInternal.Accessor); harness.HttpManager.AddSuccessTokenResponseMockHandlerForPost( authority: TestConstants.AuthorityCommonTenant, responseMessage: MockHelpers.CreateSuccessfulClientCredentialTokenResponseMessage(token: $"header.{Guid.NewGuid()}.signature", tokenType: "pop")); harness.HttpManager.AddSuccessTokenResponseMockHandlerForPost( authority: TestConstants.AuthorityCommonTenant, responseMessage: MockHelpers.CreateSuccessfulClientCredentialTokenResponseMessage(token: $"header.{Guid.NewGuid()}.signature", tokenType: "pop")); Guid correlationId = Guid.NewGuid(); TestTimeService testClock = new TestTimeService(); PoPProviderFactory.TimeService = testClock; var result = await app.AcquireTokenForClient(TestConstants.s_scope) .WithProofOfPossession(popConfig) .ExecuteAsync(CancellationToken.None) .ConfigureAwait(false); var initialToken = result.AccessToken; //Advance time 7 hours. Should still be the same key and token testClock.MoveToFuture(TimeSpan.FromHours(7)); PoPProviderFactory.TimeService = testClock; result = await app.AcquireTokenForClient(TestConstants.s_scope) .WithProofOfPossession(popConfig) .ExecuteAsync(CancellationToken.None) .ConfigureAwait(false); Assert.AreEqual(GetAccessTokenFromPopToken(result.AccessToken), GetAccessTokenFromPopToken(initialToken)); Assert.AreEqual(GetModulusFromPopToken(result.AccessToken), GetModulusFromPopToken(initialToken)); Assert.IsTrue(result.AuthenticationResultMetadata.TokenSource == TokenSource.Cache); //Advance time 2 hours. Should be a different key testClock.MoveToFuture(TimeSpan.FromHours(2)); PoPProviderFactory.TimeService = testClock; result = await app.AcquireTokenForClient(TestConstants.s_scope) .WithProofOfPossession(popConfig) .ExecuteAsync(CancellationToken.None) .ConfigureAwait(false); Assert.AreNotEqual(GetModulusFromPopToken(result.AccessToken), GetModulusFromPopToken(initialToken)); Assert.AreNotEqual(GetAccessTokenFromPopToken(result.AccessToken), GetAccessTokenFromPopToken(initialToken)); Assert.IsTrue(result.AuthenticationResultMetadata.TokenSource == TokenSource.IdentityProvider); } }
public async void Callback_ExternalSucces_LocalTwoFactorRequired() { // Arrange var controller = MockAccountController( MockHelpers.MockSignInManager <ApplicationUser>(SignInResult.Failed, SignInResult.TwoFactorRequired, MockHelpers.DefaultInfo()), MockHelpers.MockUserManager(User)); // Act var result = await controller.ExternalLoginCallback("returnurl", null) as RedirectToActionResult; //assert Assert.Equal("SendCode", result.ActionName); }
public async void GetUserWhitEmptyModelShoulThrowExeption() { var options = new DbContextOptionsBuilder <EClinicDbContext>() .UseInMemoryDatabase(databaseName: "Appointment_CreateAppointment") .Options; var dbContext = new EClinicDbContext(options); //var mockUserStore = new Mock<IUserStore<EClinicUser>>(); //var mockRoleManager = new Mock<IUserRoleStore<EClinicUser>>(); //var userManager = new UserManager<EClinicUser>(mockUserStore.Object, null, null, null, null, null, null, null, null); var userManager = MockHelpers.MockUserManager <EClinicUser>().Object; var examService = new Mock <ExamService>(dbContext).Object; var appointmentService = new Mock <AppointmentService>(dbContext).Object; var usersService = new Mock <UsersService>(dbContext, userManager, examService).Object; AutoMapperConfig.RegisterMappings(typeof(SetingViewModel).GetTypeInfo().Assembly); var AdminUserToAdd = new EClinicUser { Email = "*****@*****.**", FirstName = "Ivo", MiddleName = "Peshov", LastName = "Petrov", UserName = "******", NormalizedEmail = "*****@*****.**", NormalizedUserName = "******", Address = "Nqkyde Tam 35", Age = 25, SecurityStamp = Guid.NewGuid().ToString(), CreatedOn = DateTime.UtcNow, }; var userToAdd = new EClinicUser { Email = "*****@*****.**", FirstName = "Petyr", MiddleName = "Peshov", LastName = "Petrov", UserName = "******", NormalizedEmail = "*****@*****.**", NormalizedUserName = "******", Address = "I tuk i tam", Age = 30, SecurityStamp = Guid.NewGuid().ToString(), CreatedOn = DateTime.UtcNow, }; dbContext.Users.Add(AdminUserToAdd); dbContext.Users.Add(userToAdd); dbContext.SaveChanges(); var date = new DateTime(2019, 08, 03, 09, 00, 00); await appointmentService.CreateAppointment("*****@*****.**", "*****@*****.**", date); var exam = new CreateExamInputModel() { Condition = "good", DoctorUserName = "******", Diagnose = "adss", PatientUserName = "******", Prescription = "sdfsdd" }; await examService.CreateExam(exam); dbContext.Appointments.Where(x => true).ToList(); await Assert.ThrowsAsync <ArgumentException>(async() => await usersService.GetUser("")); }
public async void UserNotFound() { // Arrange var signInResult = SignInResult.Success; var controller = MockAccountController(MockHelpers.MockSignInManager <ApplicationUser>(), MockHelpers.MockUserManager <ApplicationUser>()); // Act var result = await controller.ConfirmEmail("userIdInvalid", "codeInvalid") as ViewResult; //assert Assert.Equal("Error", result?.ViewName); }
public async void NotAllowed() { // Arrange var signInResult = SignInResult.NotAllowed; var controller = MockAccountController(MockHelpers.MockSignInManager <ApplicationUser>(signInResult), MockHelpers.MockUserManager(User)); // Act var result = await controller.Login(new LoginViewModel { Email = nameof(signInResult), Password = nameof(signInResult), RememberMe = true }, "retrunurl"); //assert Assert.Equal("Email or phonenumber not confirmed", controller.ModelState.Values.Select(m => m.Errors[0].ErrorMessage).Last()); }
public async void Post_AnonymousUser() { // Arrange var controller = MockAccountController(MockHelpers.MockSignInManager <ApplicationUser>(), MockHelpers.MockUserManager <ApplicationUser>()); // Act var result = await controller.SendCode(SendCodeViewModel) as ViewResult; //assert Assert.NotNull(result); Assert.Equal("Error", result?.ViewName); }
public async void Lockout() { // Arrange var signInResult = SignInResult.LockedOut; var controller = MockAccountController(MockHelpers.MockSignInManager <ApplicationUser>(signInResult), MockHelpers.MockUserManager(User)); // Act var result = await controller.Login(new LoginViewModel { Email = nameof(signInResult), Password = nameof(signInResult), RememberMe = true }, "retrunurl") as ViewResult; //assert Assert.Equal("Lockout", result?.ViewName); }
public async void Post_RegisteredUser_RealToken() { // Arrange var controller = MockAccountController(MockHelpers.MockSignInManager(User), MockHelpers.MockUserManager(User, "realToken")); // Act var result = await controller.SendCode(SendCodeViewModel) as RedirectToActionResult; //assert Assert.NotNull(result); Assert.Equal(nameof(AccountController.VerifyCode), result?.ActionName); }
public async void TwoFactor() { // Arrange var signInResult = SignInResult.TwoFactorRequired; var controller = MockAccountController(MockHelpers.MockSignInManager <ApplicationUser>(signInResult), MockHelpers.MockUserManager(User)); // Act var result = await controller.Login(new LoginViewModel { Email = nameof(signInResult), Password = nameof(signInResult), RememberMe = true }, "retrunurl") as RedirectToActionResult; //assert Assert.Equal("SendCode", result.ActionName); }
public async void RegisteredUser() { // Arrange var controller = MockAccountController(MockHelpers.MockSignInManager(User), MockHelpers.MockUserManager(User)); // Act var result = await controller.VerifyCode("Email", true, "returnurl") as ViewResult; //assert Assert.NotNull(result); Assert.NotNull(controller.ViewData.Model); Assert.Equal(nameof(AccountController.VerifyCode), result?.ViewName ?? nameof(AccountController.VerifyCode)); }
public async void Success_RemoteUrl() { // Arrange var signInResult = SignInResult.Success; var controller = MockAccountController(MockHelpers.MockSignInManager <ApplicationUser>(signInResult), MockHelpers.MockUserManager(User)); // Act var result = await controller.Login(new LoginViewModel { Email = nameof(signInResult), Password = nameof(signInResult), RememberMe = true }, "remoteUrl") as RedirectToActionResult; //assert Assert.Equal(nameof(HomeController), result.ControllerName + "Controller"); }
public async void Post_User_Success() { // Arrange var controller = MockAccountController(MockHelpers.MockSignInManager <ApplicationUser>(SignInResult.Success), MockHelpers.MockUserManager(User)); // Act var result = await controller.VerifyCode(VerifyCodeViewModel) as RedirectResult; //assert Assert.NotNull(result); Assert.Equal("localUrl", result?.Url); }
public async void Callback_ExternalSucces_LocalNotAllowed() { // Arrange var controller = MockAccountController( MockHelpers.MockSignInManager <ApplicationUser>(SignInResult.Failed, SignInResult.NotAllowed, MockHelpers.DefaultInfo()), MockHelpers.MockUserManager(User)); //var controller = MockAccountController(SignInResult.Failed, SignInResult.NotAllowed, nullInfo: false, EmailAddress: "RegisterUserEmail"); // Act var result = await controller.ExternalLoginCallback("returnurl", null) as RedirectToActionResult; //assert Assert.Equal("Login", result.ActionName); Assert.Equal("returnurl", result.RouteValues["returnurl"]); Assert.True(controller.ModelState.Values.Select(m => m.Errors[0].ErrorMessage).Last().Contains("Confirmation")); }
public async Task WhenOrdering_Then_ReturnResultsInCorrectOrder(string sortBy, string direction, string expected) { var userSession = MockHelpers.GetUserSession(true, false, true); var match1 = "Mock Title1"; var match2 = "Mock Title2"; var occs = new GetOccupationsWithMatchingSkillsResponse { MatchingOccupations = new List <GetOccupationsWithMatchingSkillsResponse.MatchedOccupation>() }; occs.MatchingOccupations.Add(new GetOccupationsWithMatchingSkillsResponse.MatchedOccupation { JobProfileTitle = match1, JobProfileUri = "http://mockjoburl", LastModified = DateTime.UtcNow, TotalOccupationEssentialSkills = 12, MatchingEssentialSkills = 8, TotalOccupationOptionalSkills = 4, MatchingOptionalSkills = 2, Uri = "MatchUri", } ); occs.MatchingOccupations.Add(new GetOccupationsWithMatchingSkillsResponse.MatchedOccupation { JobProfileTitle = match2, JobProfileUri = "http://mockjoburl", LastModified = DateTime.UtcNow, TotalOccupationEssentialSkills = 12, MatchingEssentialSkills = 6, TotalOccupationOptionalSkills = 4, MatchingOptionalSkills = 2, Uri = "MatchUri", } ); var handlerMock = MockHelpers.GetMockMessageHandler(JsonConvert.SerializeObject(occs)); var restClient = new RestClient(handlerMock.Object); _serviceTaxonomy = new ServiceTaxonomyRepository(restClient); var pageSettings = Options.Create(new PageSettings() { PageSize = 10 }); var controller = new MatchesController(_compositeSettings, _sessionService, pageSettings, _dysacSettigs, _serviceTaxSettings, _serviceTaxonomy); controller.ControllerContext = new ControllerContext { HttpContext = new DefaultHttpContext() }; controller.HttpContext.Request.Query = new QueryCollection(new Dictionary <string, StringValues>() { { "page", "1" }, { "sortBy", sortBy }, { "direction", direction } }); _sessionService.GetUserSession() .ReturnsForAnyArgs(userSession); var result = await controller.Body() as ViewResult; result.Should().NotBeNull(); result.Should().BeOfType <ViewResult>(); result.ViewData.Model.As <MatchesCompositeViewModel>().CareerMatches.First().JobProfile.Title.Should() .Be(expected); }
private async void FakeADButton_Click(object sender, RoutedEventArgs e) { await MockHelpers.ShowFakeActiveDirectoryDialog(); }