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();
}
