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