public async Task RememberClientStoresUserId() { // Setup var user = new TestUser { UserName = "******" }; var manager = SetupUserManager(user); var context = new DefaultHttpContext(); var auth = MockAuth(context); MockLoggerFactory loggerFactory = new MockLoggerFactory(); var helper = SetupSignInManager(manager.Object, context, loggerFactory); auth.Setup(a => a.SignInAsync( context, IdentityConstants.TwoFactorRememberMeScheme, It.Is <ClaimsPrincipal>(i => i.FindFirstValue(ClaimTypes.Name) == user.Id && i.Identities.First().AuthenticationType == IdentityConstants.TwoFactorRememberMeScheme), It.Is <AuthenticationProperties>(v => v.IsPersistent == true))).Returns(Task.FromResult(0)).Verifiable(); // Act await helper.RememberTwoFactorClientAsync(user); // Assert manager.Verify(); auth.Verify(); }
public async Task PasswordSignInFailsWithWrongPassword() { // Setup var user = new TestUser { UserName = "******" }; var manager = SetupUserManager(user); manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable(); manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable(); manager.Setup(m => m.CheckPasswordAsync(user, "bogus")).ReturnsAsync(false).Verifiable(); var context = new Mock <HttpContext>(); MockLoggerFactory loggerFactory = new MockLoggerFactory(); var helper = SetupSignInManager(manager.Object, context.Object, loggerFactory); // Act var result = await helper.PasswordSignInAsync(user.UserName, "bogus", false, false); var checkResult = await helper.CheckPasswordSignInAsync(user, "bogus", false); // Assert Assert.False(result.Succeeded); Assert.False(checkResult.Succeeded); Assert.Contains($"User {user.Id} failed to provide the correct password.", loggerFactory.LogStore.ToString()); manager.Verify(); context.Verify(); }
public async Task CanExternalSignIn(bool isPersistent, bool supportsLockout) { // Setup var user = new TestUser { UserName = "******" }; const string loginProvider = "login"; const string providerKey = "fookey"; var manager = SetupUserManager(user); manager.Setup(m => m.SupportsUserLockout).Returns(supportsLockout).Verifiable(); if (supportsLockout) { manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable(); } manager.Setup(m => m.FindByLoginAsync(loginProvider, providerKey)).ReturnsAsync(user).Verifiable(); var context = new DefaultHttpContext(); var auth = MockAuth(context); MockLoggerFactory loggerFactory = new MockLoggerFactory(); var helper = SetupSignInManager(manager.Object, context, loggerFactory); SetupSignIn(context, auth, user.Id, isPersistent, loginProvider); // Act var result = await helper.ExternalLoginSignInAsync(loginProvider, providerKey, isPersistent); // Assert Assert.True(result.Succeeded); manager.Verify(); auth.Verify(); }
public async Task CheckPasswordSignInFailsWithWrongPasswordCanAccessFailedAndLockout() { // Setup var user = new TestUser { UserName = "******" }; var manager = SetupUserManager(user); var lockedout = false; manager.Setup(m => m.AccessFailedAsync(user)).Returns(() => { lockedout = true; return(Task.FromResult(IdentityResult.Success)); }).Verifiable(); manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable(); manager.Setup(m => m.IsLockedOutAsync(user)).Returns(() => Task.FromResult(lockedout)); manager.Setup(m => m.CheckPasswordAsync(user, "bogus")).ReturnsAsync(false).Verifiable(); var context = new Mock <HttpContext>(); MockLoggerFactory loggerFactory = new MockLoggerFactory(); var helper = SetupSignInManager(manager.Object, context.Object, loggerFactory); // Act var result = await helper.CheckPasswordSignInAsync(user, "bogus", true); // Assert Assert.False(result.Succeeded); Assert.True(result.IsLockedOut); manager.Verify(); }
public async Task CheckPasswordSignInReturnsLockedOutWhenLockedOut() { // Setup var user = new TestUser { UserName = "******" }; var manager = SetupUserManager(user); manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable(); manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(true).Verifiable(); var context = new Mock <HttpContext>(); var contextAccessor = new Mock <IHttpContextAccessor>(); contextAccessor.Setup(a => a.HttpContext).Returns(context.Object); var roleManager = MockHelpers.MockRoleManager <TestRole>(); var identityOptions = new IdentityOptions(); var options = new Mock <IOptions <IdentityOptions> >(); options.Setup(a => a.Value).Returns(identityOptions); var claimsFactory = new UserClaimsPrincipalFactory <TestUser, TestRole>(manager.Object, roleManager.Object, options.Object); var loggerFactory = new MockLoggerFactory(); var logger = loggerFactory.CreateLogger <SignInManager <TestUser> >(); var helper = new SignInManager <TestUser>(manager.Object, contextAccessor.Object, claimsFactory, options.Object, logger, new Mock <IAuthenticationSchemeProvider>().Object); // Act var result = await helper.CheckPasswordSignInAsync(user, "bogus", false); // Assert Assert.False(result.Succeeded); Assert.True(result.IsLockedOut); Assert.Contains($"User {user.Id} is currently locked out.", loggerFactory.LogStore.ToString()); manager.Verify(); }
public async Task CanRequireConfirmedPhoneNumberForPasswordSignIn(bool confirmed) { // Setup var user = new TestUser { UserName = "******" }; var manager = SetupUserManager(user); manager.Setup(m => m.IsPhoneNumberConfirmedAsync(user)).ReturnsAsync(confirmed).Verifiable(); var context = new DefaultHttpContext(); var auth = MockAuth(context); if (confirmed) { manager.Setup(m => m.CheckPasswordAsync(user, "password")).ReturnsAsync(true).Verifiable(); SetupSignIn(context, auth); } var identityOptions = new IdentityOptions(); identityOptions.SignIn.RequireConfirmedPhoneNumber = true; MockLoggerFactory loggerFactory = new MockLoggerFactory(); var helper = SetupSignInManager(manager.Object, context, loggerFactory, identityOptions); // Act var result = await helper.PasswordSignInAsync(user, "password", false, false); // Assert Assert.Equal(confirmed, result.Succeeded); Assert.NotEqual(confirmed, result.IsNotAllowed); Assert.Equal(confirmed, !loggerFactory.LogStore.ToString().Contains($"User {user.Id} cannot sign in without a confirmed phone number.")); manager.Verify(); auth.Verify(); }
public async Task CanPasswordSignIn(bool isPersistent) { // Setup var user = new TestUser { UserName = "******" }; var manager = SetupUserManager(user); manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable(); manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable(); manager.Setup(m => m.CheckPasswordAsync(user, "password")).ReturnsAsync(true).Verifiable(); var context = new DefaultHttpContext(); var auth = MockAuth(context); SetupSignIn(context, auth, user.Id, isPersistent); MockLoggerFactory loggerFactory = new MockLoggerFactory(); var helper = SetupSignInManager(manager.Object, context, loggerFactory); // Act var result = await helper.PasswordSignInAsync(user.UserName, "password", isPersistent, false); // Assert Assert.True(result.Succeeded); manager.Verify(); auth.Verify(); }
public async Task PasswordSignInWorksWithNonTwoFactorStore() { // Setup var user = new TestUser { UserName = "******" }; var manager = SetupUserManager(user); manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable(); manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable(); manager.Setup(m => m.CheckPasswordAsync(user, "password")).ReturnsAsync(true).Verifiable(); manager.Setup(m => m.ResetAccessFailedCountAsync(user)).ReturnsAsync(IdentityResult.Success).Verifiable(); var context = new DefaultHttpContext(); var auth = MockAuth(context); SetupSignIn(context, auth); MockLoggerFactory loggerFactory = new MockLoggerFactory(); var helper = SetupSignInManager(manager.Object, context, loggerFactory); // Act var result = await helper.PasswordSignInAsync(user.UserName, "password", false, false); // Assert Assert.True(result.Succeeded); manager.Verify(); auth.Verify(); }
private IRecipeService GetService() { var rep = new RecipeDbRepository.RecipeRepository(this.DbContext, new MockLoggerFactory <object>()); var mockFactory = new MockLoggerFactory <IngrediantService>(); IMapper mapper = new Mapper(new MapperConfiguration(m => m.AddProfile <AutoMapperServiceProfile>())); return(new RecipeService(rep, mapper, mockFactory)); }
public void CreateLoggerMustReturnILoggerWhenLoggerFactoryIsNotNull() { NamedLogger logger = new MockLoggerFactory(x => new NamedLogger { Name = x }).CreateLogger("42") as NamedLogger; Assert.NotNull(logger); Assert.Equal("42", logger.Name); }
private ISourceService GetService() { var baseSourceRep = new RecipeDbRepository.BaseSourceRepository(this.DbContext, new MockLoggerFactory <object>()); var webSourceRep = new RecipeDbRepository.WebSourceRepository(this.DbContext, new MockLoggerFactory <object>()); var cookbookSourceRep = new RecipeDbRepository.CookbookSourceRepository(this.DbContext, new MockLoggerFactory <object>()); var sourceRep = new RecipeSourceRepository(webSourceRep, baseSourceRep, cookbookSourceRep); var reciperep = new RecipeDbRepository.RecipeRepository(this.DbContext, new MockLoggerFactory <object>()); var mockFactory = new MockLoggerFactory <IngrediantService>(); IMapper mapper = new Mapper(new MapperConfiguration(m => m.AddProfile <AutoMapperServiceProfile>())); return(new SourceService(sourceRep, reciperep, mapper, mockFactory)); }
private static int Invoke(IFileSystem fileSystem, IProcessProxy processProxy, IConsole?console = null) { var command = new ValidateCommand() { Handler = new ValidateCommand.CommandHandler( MockEnvironmentProxy.Default, processProxy, fileSystem, MockLoggerFactory.CreateGenericLogger <ValidateCommand>()), }; return(command.Invoke("", console)); }
public void Invoke_CaughtUnexpectedException_LogsCritical(Exception exceptionToThrow) { var logger = MockLoggerFactory.CreateLogger(); Invoke(new ThrowExceptionCommandHandler(exceptionToThrow, logger)); Mock.Get(logger).Verify(x => x.Log( LogLevel.Critical, It.IsAny <EventId>(), It.IsAny <It.IsAnyType>(), exceptionToThrow, It.IsAny <Func <It.IsAnyType, Exception?, string> >())); }
public void MapsLevelsCorrectly(EventLevel eventLevel, LogLevel logLevel) { var loggerFactory = new MockLoggerFactory(); using (var forwarder = new EventSourceLogForwarder(loggerFactory)) { typeof(TestSource).GetMethod(eventLevel.ToString(), BindingFlags.Instance | BindingFlags.Public).Invoke(TestSource.Log, Array.Empty <object>()); } var logs = loggerFactory.Loggers["Test.source"].Logs; Assert.AreEqual(1, logs.Count); Assert.AreEqual(logLevel, logs[0].level); }
public void Test() { // Arrange var expectedResponse = "{\"searchDistance\":{\"metres\":1609.0},\"schools\":[{\"schoolId\":\"1A\",\"name\":\"SchoolName\",\"contactName\":\"ContactName\",\"address\":\"Address\",\"distance\":{\"metres\":1500.0},\"schoolType\":1}]}"; var requestUri = new Uri("http://localhost:5001/api/school/findschools"); var responseMessage = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(expectedResponse) }; var handler = new Mock <HttpClientHandler>(); handler.Protected() //.Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>()) .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.Is <HttpRequestMessage>(message => message.RequestUri.ToString().StartsWith(requestUri.ToString())), ItExpr.IsAny <CancellationToken>()) .Callback((HttpRequestMessage message, CancellationToken token) => Debug.WriteLine(message.RequestUri)) .ReturnsAsync(responseMessage); var httpClient = new HttpClient(handler.Object); httpClient.BaseAddress = new Uri("http://localhost:5001"); var httpClientFactory = new Mock <IHttpClientFactory>(); httpClientFactory.Setup(x => x.CreateClient(It.IsAny <string>())).Returns(httpClient); var loggerFactory = new MockLoggerFactory(); var sut = new SchoolFacade(httpClientFactory.Object, loggerFactory.Object); // Act var result = sut.FindSchoolsAsync("OL158RE", new SchoolExperienceBaseTypes.Distance { Miles = 1 }).Result; // Assert result.SearchDistance.Metres.Should().Be(1609); result.Schools.Count().Should().Be(1); var school = result.Schools.First(); school.SchoolId.Should().Be("1A"); school.Name.Should().Be("SchoolName"); school.Address.Should().Be("Address"); school.ContactName.Should().Be("ContactName"); school.Distance.Metres.Should().Be(1500); school.SchoolType.Should().Be(SchoolExperienceBaseTypes.SchoolType.Primary); }
private static BicepCliProxy CreateBicepCliProxy( IEnvironmentProxy?environmentProxy = null, IProcessProxy?processProxy = null, IFileSystem?fileSystem = null, ILogger?logger = null, IConsole?console = null) { environmentProxy ??= new MockEnvironmentProxy(); processProxy ??= StrictMock.Of <IProcessProxy>().Object; fileSystem ??= new MockFileSystem(); logger ??= MockLoggerFactory.CreateLogger(); console ??= new MockConsole(); return(new(environmentProxy, processProxy, fileSystem, logger, console)); }
public void Index_ReturnsAWinner() { var mockRepository = new MockRepository(); var mockLoggerFactory = new MockLoggerFactory(); var controller = new WichtelnController(mockRepository, mockLoggerFactory); var result = controller.Get(); var jsonResult = Assert.IsType <JsonResult>(result); Assert.NotNull(jsonResult); Assert.NotNull(jsonResult.Value); Assert.IsType <Winner>(jsonResult.Value); var theWinner = Assert.IsAssignableFrom <Winner>(jsonResult.Value); Assert.Equal("@writeline", theWinner.Who); }
public async Task ExternalSignInRequiresVerificationIfNotBypassed(bool bypass) { // Setup var user = new TestUser { UserName = "******" }; const string loginProvider = "login"; const string providerKey = "fookey"; var manager = SetupUserManager(user); manager.Setup(m => m.SupportsUserLockout).Returns(false).Verifiable(); manager.Setup(m => m.FindByLoginAsync(loginProvider, providerKey)).ReturnsAsync(user).Verifiable(); if (!bypass) { IList <string> providers = new List <string>(); providers.Add("PhoneNumber"); manager.Setup(m => m.GetValidTwoFactorProvidersAsync(user)).Returns(Task.FromResult(providers)).Verifiable(); manager.Setup(m => m.SupportsUserTwoFactor).Returns(true).Verifiable(); manager.Setup(m => m.GetTwoFactorEnabledAsync(user)).ReturnsAsync(true).Verifiable(); } var context = new DefaultHttpContext(); var auth = MockAuth(context); MockLoggerFactory loggerFactory = new MockLoggerFactory(); var helper = SetupSignInManager(manager.Object, context, loggerFactory); if (bypass) { SetupSignIn(context, auth, user.Id, false, loginProvider); } else { auth.Setup(a => a.SignInAsync(context, IdentityConstants.TwoFactorUserIdScheme, It.Is <ClaimsPrincipal>(id => id.FindFirstValue(ClaimTypes.Name) == user.Id), It.IsAny <AuthenticationProperties>())).Returns(Task.FromResult(0)).Verifiable(); } // Act var result = await helper.ExternalLoginSignInAsync(loginProvider, providerKey, isPersistent : false, bypassTwoFactor : bypass); // Assert Assert.Equal(bypass, result.Succeeded); Assert.Equal(!bypass, result.RequiresTwoFactor); manager.Verify(); auth.Verify(); }
public async Task SignOutCallsContextResponseSignOut() { // Setup var manager = MockHelpers.TestUserManager <TestUser>(); var context = new DefaultHttpContext(); var auth = MockAuth(context); var loggerFactory = new MockLoggerFactory(); auth.Setup(a => a.SignOutAsync(context, IdentityConstants.ApplicationScheme, It.IsAny <AuthenticationProperties>())).Returns(Task.FromResult(0)).Verifiable(); auth.Setup(a => a.SignOutAsync(context, IdentityConstants.TwoFactorUserIdScheme, It.IsAny <AuthenticationProperties>())).Returns(Task.FromResult(0)).Verifiable(); auth.Setup(a => a.SignOutAsync(context, IdentityConstants.ExternalScheme, It.IsAny <AuthenticationProperties>())).Returns(Task.FromResult(0)).Verifiable(); var helper = SetupSignInManager(manager, context, loggerFactory, manager.Options); // Act await helper.SignOutAsync(); // Assert auth.Verify(); }
public async Task PasswordSignInRequiresVerification(bool supportsLockout) { // Setup var user = new TestUser { UserName = "******" }; var manager = SetupUserManager(user); manager.Setup(m => m.SupportsUserLockout).Returns(supportsLockout).Verifiable(); if (supportsLockout) { manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable(); } IList <string> providers = new List <string>(); providers.Add("PhoneNumber"); manager.Setup(m => m.GetValidTwoFactorProvidersAsync(user)).Returns(Task.FromResult(providers)).Verifiable(); manager.Setup(m => m.SupportsUserTwoFactor).Returns(true).Verifiable(); manager.Setup(m => m.GetTwoFactorEnabledAsync(user)).ReturnsAsync(true).Verifiable(); manager.Setup(m => m.CheckPasswordAsync(user, "password")).ReturnsAsync(true).Verifiable(); manager.Setup(m => m.GetValidTwoFactorProvidersAsync(user)).ReturnsAsync(new string[1] { "Fake" }).Verifiable(); var context = new DefaultHttpContext(); MockLoggerFactory loggerFactory = new MockLoggerFactory(); var helper = SetupSignInManager(manager.Object, context, loggerFactory); var auth = MockAuth(context); auth.Setup(a => a.SignInAsync(context, IdentityConstants.TwoFactorUserIdScheme, It.Is <ClaimsPrincipal>(id => id.FindFirstValue(ClaimTypes.Name) == user.Id), It.IsAny <AuthenticationProperties>())).Returns(Task.FromResult(0)).Verifiable(); // Act var result = await helper.PasswordSignInAsync(user.UserName, "password", false, false); // Assert Assert.False(result.Succeeded); Assert.True(result.RequiresTwoFactor); manager.Verify(); auth.Verify(); }
public async Task PasswordSignInFailsWithUnknownUser() { // Setup var manager = MockHelpers.MockUserManager <TestUser>(); manager.Setup(m => m.FindByNameAsync("bogus")).ReturnsAsync(default(TestUser)).Verifiable(); var context = new Mock <HttpContext>(); MockLoggerFactory loggerFactory = new MockLoggerFactory(); var helper = SetupSignInManager(manager.Object, context.Object, loggerFactory); // Act var result = await helper.PasswordSignInAsync("bogus", "bogus", false, false); // Assert Assert.False(result.Succeeded); manager.Verify(); context.Verify(); }
public async Task CanResignIn(bool externalLogin) { // Setup var user = new TestUser { UserName = "******" }; var context = new DefaultHttpContext(); var services = new ServiceCollection(); var auth = MockAuth(context); var loginProvider = "loginprovider"; var id = new ClaimsIdentity(); if (externalLogin) { id.AddClaim(new Claim(ClaimTypes.AuthenticationMethod, loginProvider)); } // REVIEW: auth changes we lost the ability to mock is persistent //var properties = new AuthenticationProperties { IsPersistent = isPersistent }; var authResult = AuthenticateResult.NoResult(); auth.Setup(a => a.AuthenticateAsync(context, IdentityConstants.ApplicationScheme)).Returns(Task.FromResult(authResult)).Verifiable(); var manager = SetupUserManager(user); using (MockLoggerFactory loggerFactory = new MockLoggerFactory()) { var signInManager = MockSignInManager(manager.Object, context, loggerFactory); signInManager.CallBase = true; // need this magic! signInManager.Setup(s => s.SignInAsync(user, It.IsAny <AuthenticationProperties>(), null).Wait()); //s.SignInWithClaimsAsync(user, It.IsAny<AuthenticationProperties>(), It.IsAny<List<Claim>>())).Returns(Task.FromResult(0)).Verifiable(); // Act await signInManager.Object.RefreshSignInAsync(user); // Assert auth.Verify(); signInManager.Verify(); } }
public void OldLoggerFactoryTimingsForEnabledLogging(int iteration) { ResetCounts(); ILoggerFactory loggerFactory = new MockLoggerFactory(); IInternalLogger logger = loggerFactory.LoggerFor(this.GetType()); var stopwatch = Stopwatch.StartNew(); var iterationCount = 10000000; for (int i = 0; i < iterationCount; i++) { logger.Warn("message"); logger.WarnFormat("message with parameters {0}, {1}", "string", 5); } stopwatch.Stop(); Console.WriteLine( "{0} wrote {1:N0} characters to log in {2} ms", nameof(OldLoggerFactoryTimingsForEnabledLogging), GetCounts(), stopwatch.ElapsedMilliseconds); }
public async Task RememberBrowserSkipsTwoFactorVerificationSignIn(bool isPersistent) { // Setup var user = new TestUser { UserName = "******" }; var manager = SetupUserManager(user); manager.Setup(m => m.GetTwoFactorEnabledAsync(user)).ReturnsAsync(true).Verifiable(); IList <string> providers = new List <string>(); providers.Add("PhoneNumber"); manager.Setup(m => m.GetValidTwoFactorProvidersAsync(user)).Returns(Task.FromResult(providers)).Verifiable(); manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable(); manager.Setup(m => m.SupportsUserTwoFactor).Returns(true).Verifiable(); manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable(); manager.Setup(m => m.CheckPasswordAsync(user, "password")).ReturnsAsync(true).Verifiable(); var context = new DefaultHttpContext(); var auth = MockAuth(context); SetupSignIn(context, auth); var id = new ClaimsIdentity(IdentityConstants.TwoFactorRememberMeScheme); id.AddClaim(new Claim(ClaimTypes.Name, user.Id)); auth.Setup(a => a.AuthenticateAsync(It.IsAny <HttpContext>(), IdentityConstants.TwoFactorRememberMeScheme)) .ReturnsAsync(AuthenticateResult.Success(new AuthenticationTicket(new ClaimsPrincipal(id), null, IdentityConstants.TwoFactorRememberMeScheme))).Verifiable(); MockLoggerFactory loggerFactory = new MockLoggerFactory(); var helper = SetupSignInManager(manager.Object, context, loggerFactory); // Act var result = await helper.PasswordSignInAsync(user.UserName, "password", isPersistent, false); // Assert Assert.True(result.Succeeded); manager.Verify(); auth.Verify(); }
public void OldLoggerFactoryThunkedTimingsForDisabledLogging(int iteration) { ResetCounts(); ILoggerFactory loggerFactory = new MockLoggerFactory(); LoggerProvider.SetLoggersFactory(loggerFactory); INHibernateLogger logger2 = NHibernateLogger.For(this.GetType()); var stopwatch = Stopwatch.StartNew(); var iterationCount = 10000000; for (int i = 0; i < iterationCount; i++) { logger2.Debug("message"); logger2.Debug("message with parameters {0}, {1}", "string", 5); } stopwatch.Stop(); Console.WriteLine( "{0} wrote {1:N0} characters to log in {2} ms", nameof(OldLoggerFactoryThunkedTimingsForDisabledLogging), GetCounts(), stopwatch.ElapsedMilliseconds); }
public void ThenWarningShouldBeLogged() { MockLoggerFactory loggerFactory = (MockLoggerFactory)_ocelotServer.Host.Services.GetService <IOcelotLoggerFactory>(); loggerFactory.Verify(); }
public async Task OnValidatePrincipalTestSuccess(bool isPersistent) { var user = new TestUser { UserName = "******" }; var manager = SetupUserManager(user); manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable(); manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(true).Verifiable(); var context = new Mock <HttpContext>(); var contextAccessor = new Mock <IHttpContextAccessor>(); contextAccessor.Setup(a => a.HttpContext).Returns(context.Object); var roleManager = MockHelpers.MockRoleManager <TestRole>(); var options = new Mock <IOptions <IdentityOptions> >(); options.Setup(a => a.Value).Returns(new IdentityOptions()); var securityStampOptions = new Mock <IOptions <SecurityStampValidatorOptions> >(); securityStampOptions.Setup(a => a.Value).Returns(new SecurityStampValidatorOptions { ValidationInterval = TimeSpan.Zero }); var claimsFactory = new UserClaimsPrincipalFactory <TestUser, TestRole>(manager.Object, roleManager.Object, options.Object); var loggerFactory = new MockLoggerFactory(); var logger = loggerFactory.CreateLogger <SignInManager <TestUser> >(); var helper = new Mock <SignInManager <TestUser> >(manager.Object, contextAccessor.Object, claimsFactory, options.Object, logger, new Mock <IAuthenticationSchemeProvider>().Object, new Mock <IUserConfirmation <TestUser> >().Object); var properties = new AuthenticationProperties { IssuedUtc = DateTimeOffset.UtcNow.AddSeconds(-1), IsPersistent = isPersistent }; var id = new ClaimsIdentity(IdentityConstants.ApplicationScheme); id.AddClaim(new Claim(ClaimTypes.NameIdentifier, user.Id)); var principal = new ClaimsPrincipal(id); helper.Setup(s => s.ValidateSecurityStampAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(user).Verifiable(); helper.Setup(s => s.CreateUserPrincipalAsync(user)).ReturnsAsync(principal).Verifiable(); var logFactory = new MockLoggerFactory(); var services = new ServiceCollection(); services.AddSingleton <ILoggerFactory>(loggerFactory); services.AddSingleton(options.Object); services.AddSingleton(helper.Object); services.AddSingleton <ISecurityStampValidator>(new SecurityStampValidator <TestUser>(securityStampOptions.Object, helper.Object, new SystemClock())); context.Setup(c => c.RequestServices).Returns(services.BuildServiceProvider()); contextAccessor.Setup(a => a.HttpContext).Returns(context.Object); var ticket = new AuthenticationTicket(principal, properties, IdentityConstants.ApplicationScheme); var cookieContext = new CookieValidatePrincipalContext(context.Object, new AuthenticationSchemeBuilder(IdentityConstants.ApplicationScheme) { HandlerType = typeof(NoopHandler) }.Build(), new CookieAuthenticationOptions(), ticket); Assert.NotNull(cookieContext.Properties); Assert.NotNull(cookieContext.Options); Assert.NotNull(cookieContext.Principal); await SecurityStampValidator.ValidatePrincipalAsync(cookieContext); Assert.NotNull(cookieContext.Principal); helper.VerifyAll(); }
/// <summary> /// Public constructor /// </summary> public LoggerMock() { // Setup the mock MockLoggerFactory.Setup(x => x.CreateLogger(It.IsAny <string>())).Returns(MockLogger.Object); }
private static Mock <SignInManager <TestUser> > MockSignInManager(UserManager <TestUser> manager, HttpContext context, MockLoggerFactory factory, IdentityOptions identityOptions = null) { var contextAccessor = new Mock <IHttpContextAccessor>(); contextAccessor.Setup(a => a.HttpContext).Returns(context); var roleManager = MockHelpers.MockRoleManager <TestRole>(); identityOptions = identityOptions ?? new IdentityOptions(); var options = new Mock <IOptions <IdentityOptions> >(); options.Setup(a => a.Value).Returns(identityOptions); var claimsFactory = new UserClaimsPrincipalFactory <TestUser, TestRole>(manager, roleManager.Object, options.Object); var sm = new Mock <SignInManager <TestUser> >(manager, contextAccessor.Object, claimsFactory, options.Object, factory.CreateLogger <SignInManager <TestUser> >(), new Mock <IAuthenticationSchemeProvider>().Object, new Mock <IUserConfirmation <TestUser> >().Object); return(sm); }
public DiffValidatorTests() { this.fileSystem = MockFileSystemFactory.CreateFileSystemWithValidFiles(); this.latestMainArmTemplateFile = MainArmTemplateFile.ReadFromFileSystem(this.fileSystem); this.sut = new DiffValidator(this.fileSystem, MockLoggerFactory.CreateLogger(), this.latestMainArmTemplateFile); }