public void User_Cache_Should_Return_Data_If_User_In_Storage_And_Logged_In()
{
var Logger = serviceProvider.GetService <ILoggerFactory>().CreateLogger <UserCaching>();
var loggeUserId = Guid.NewGuid().ToString();
var UsrMgr = BuildUserManager <AspNetUser>();
var cache = serviceProvider.GetService <IMemoryCache>();
var httpAccessor = serviceProvider.GetService <IHttpContextAccessor>();
var user = new AspNetUser()
{
UserName = "******",
Email = "*****@*****.**",
Id = loggeUserId
};
UsrMgr.CreateAsync(user);//saving in db
httpAccessor.HttpContext.User = new ClaimsPrincipal(new
ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.UserName),
new Claim(ClaimTypes.NameIdentifier, user.Id)
}, "SomeAuthTYpe"));
var signInManager = new FakeSignInManager(httpAccessor);
UserCaching r = new UserCaching(signInManager, httpAccessor, cache, UsrMgr, Logger);
var cachedUsr = r.SetLoggedOnUserInCache().Result;
Assert.NotNull(cachedUsr);
Assert.Equal(user.Id, cachedUsr.Id);
}
public void RegisterUser_FirstUser_LocalRedirect()
{
// Arrange
FakeUserManager fakeUserManager = new FakeUserManager();
fakeUserManager.SetUsers(new List <ApplicationUser>(new ApplicationUser[] {}).AsQueryable());
FakeSignInManager fakeSignInManager = new FakeSignInManager();
RegisterModel registerModel = new RegisterModel(fakeUserManager, fakeSignInManager, new FakeLogger <LoginModel>(), null);
registerModel.PageContext = new PageContext();
registerModel.Input = new RegisterModel.InputModel
{
Email = "*****@*****.**",
Password = "******",
};
// Act
IActionResult result = registerModel.OnPostAsync().Result;
// Assert
Assert.IsType(typeof(LocalRedirectResult), result);
}
public void SetUp()
{
_factory = new InMemorySqlLiteContextFactory();
_mockSignManager = new FakeSignInManager();
_mockUserManager = new FakeUserManager();
_uut = new IdentityUserRepository(_mockUserManager, _mockSignManager);
}
public ManageControllerTests(ITestOutputHelper output)
{
_output = output;
_fakeUserManager = new FakeUserManager();
_fakeSignInManager = new FakeSignInManager();
_mockSmsSender = new Mock <ISmsSender>();
_sut = new ManageController(_fakeUserManager, _fakeSignInManager, _mockSmsSender.Object);
}
public async Task TestLoginAccount(string email, string password)
{
using (var db = new AppDbContext(Utilities.Utilities.TestAppDbContext()))
{
var signInManagerMock = new Mock <FakeSignInManager>();
signInManagerMock.Setup(fsim => fsim.PasswordSignInAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>()))
.ReturnsAsync(Microsoft.AspNetCore.Identity.SignInResult.Success);
// Arrange
//---* FOR USAGE OF User.Identity *---//
//Create test user
var fakeIdentity = new GenericIdentity("*****@*****.**");
var principal = new ClaimsPrincipal(fakeIdentity);
var httpContext = new DefaultHttpContext()
{
User = principal
};
//need these as well for the page context
var modelState = new ModelStateDictionary();
var actionContext = new ActionContext(httpContext, new RouteData(), new PageActionDescriptor(), modelState);
var modelMetadataProvider = new EmptyModelMetadataProvider();
var viewData = new ViewDataDictionary(modelMetadataProvider, modelState);
// need page context for the page model
var pageContext = new PageContext(actionContext)
{
ViewData = viewData
};
LoginModel loginModel = new LoginModel(
signInManagerMock.Object
)
{
PageContext = pageContext
};
var inputModel = new LoginModel.InputModel();
inputModel.Email = email;
inputModel.Password = password;
loginModel.Input = inputModel;
// Act
await loginModel.OnPostAsync("Index");
var um = new FakeSignInManager();
var loginResult = um.IsSignedIn(loginModel.User);
// Assert
Assert.True(
loginResult
);
}
}
private SignInManager <User> GetSignInManager(UserManager <User> userManager)
{
IdentityOptions identityOptions = new IdentityOptions
{
SignIn = new SignInOptions
{
RequireConfirmedEmail = false,
RequireConfirmedPhoneNumber = false
},
User = new UserOptions
{
RequireUniqueEmail = true
},
Lockout = new LockoutOptions
{
AllowedForNewUsers = true
}
};
Mock <IOptions <IdentityOptions> > mockIdentityOptions = new Mock <IOptions <IdentityOptions> >();
mockIdentityOptions.Setup(a => a.Value).Returns(identityOptions);
Mock <IHttpContextAccessor> mockHttpContext = new Mock <IHttpContextAccessor>();
mockHttpContext
.Setup(a => a.HttpContext)
.Returns(new DefaultHttpContext());
Mock <IUserClaimsPrincipalFactory <User> > mockUserClaimsPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >();
mockUserClaimsPrincipalFactory
.Setup(a => a.CreateAsync(It.IsAny <User>()))
.Returns(Task.FromResult(new ClaimsPrincipal()));
Mock <ILogger <SignInManager <User> > > mockLogger = new Mock <ILogger <SignInManager <User> > >();
AuthenticationOptions authenticationOptions = new AuthenticationOptions
{
};
Mock <IOptions <AuthenticationOptions> > mockAuthOptions = new Mock <IOptions <AuthenticationOptions> >();
mockAuthOptions.Setup(a => a.Value).Returns(authenticationOptions);
AuthenticationSchemeProvider authenticationSchemeProvider = new AuthenticationSchemeProvider(mockAuthOptions.Object);
Mock <IUserConfirmation <User> > mockUserConfirmation = new Mock <IUserConfirmation <User> >();
mockUserConfirmation.Setup(a => a.IsConfirmedAsync(It.IsAny <UserManager <User> >(), It.IsAny <User>())).Returns(Task.FromResult(true));
FakeSignInManager signInManager = new FakeSignInManager(
userManager,
mockHttpContext.Object,
mockUserClaimsPrincipalFactory.Object,
mockIdentityOptions.Object,
mockLogger.Object,
authenticationSchemeProvider,
mockUserConfirmation.Object
);
return(signInManager);
}
public void Setup()
{
_signInManager = new FakeSignInManager();
_jwtGenerator = Substitute.For <IJwtGenerator>();
_identityConfiguration = new IdentityConfiguration()
{
LockoutExpiryInMinutes = 10
};
_handler = new Login.Handler(_signInManager, _jwtGenerator, _identityConfiguration);
}
public APITestBase() : base()
{
_userManager = new FakeUserManager(_context);
_signInManager = new FakeSignInManager(_userManager);
_courseService = new CourseService(_context);
_studentService = new StudentService(_context);
_enrollService = new EnrollService(_context);
_facultyService = new FacultyService(_context);
_wishlistService = new WishlistService(_context);
}
public TokenControllerTests(ITestOutputHelper output)
{
_fakeSignInManager = new FakeSignInManager();
_fakeUserManager = new FakeUserManager();
var config = new ConfigurationBuilder()
.SetBasePath(Path.GetFullPath(@"..\..\..\..\ContosoUniversity.Web"))
.AddJsonFile("appsettings.development.json")
.Build();
_sut = new TokenController(_fakeSignInManager, _fakeUserManager, config);
}
public AccountControllerTests(ITestOutputHelper output)
{
_output = output;
_fakeUserManager = new FakeUserManager();
_fakeSignInManager = new FakeSignInManager();
_mockUrlHelperAdaptor = new Mock <IUrlHelperAdaptor>();
_mockEmailSender = new Mock <IEmailSender>();
_mockSmsSender = new Mock <ISmsSender>();
_sut = new AccountController(_fakeUserManager, _fakeSignInManager, _mockEmailSender.Object, _mockSmsSender.Object, _mockUrlHelperAdaptor.Object);
}
public void LogoutTest()
{
UserManager <AppUser> um = new FakeUserManager();
SignInManager <AppUser> sim = new FakeSignInManager();
Mock <IUnitOfWork> uow = new Mock <IUnitOfWork>();
RoleManager <IdentityRole> rm = new FakeRoleManager();
AuthController AC = new AuthController(um, sim, uow.Object, rm);
var result = AC.Logout().Result;
result.Should().NotBeNull();
}
public void HelpAction_ReturnsViewResult()
{
var userServiceMock = this.SetupMockUsersService();
var userManagerFake = new FakeUserManager();
var userSignInFake = new FakeSignInManager();
var viewModelMock = new Mock <UserViewModel>();
var controller = new UserController(userServiceMock.Object, userManagerFake, userSignInFake);
var result = controller.Help();
Assert.IsInstanceOfType(result, typeof(ViewResult));
}
public void MyMoviesAction_ReturnsViewResult()
{
var userServiceMock = this.SetupMockUsersService();
var userManagerFake = new FakeUserManager();
var userSignInFake = new FakeSignInManager();
var viewModelMock = new Mock <UserMoviesViewModel>();
var controller = new UserController(userServiceMock.Object, userManagerFake, userSignInFake);
var result = controller.MyMovies(It.IsAny <string>()) as ViewResult;
Assert.IsInstanceOfType(result.Model, typeof(UserMoviesViewModel));
}
public void LoginTest()
{
UserManager <AppUser> um = new FakeUserManager();
SignInManager <AppUser> sim = new FakeSignInManager();
Mock <IUnitOfWork> uow = new Mock <IUnitOfWork>();
RoleManager <IdentityRole> rm = new FakeRoleManager();
AuthController AC = new AuthController(um, sim, uow.Object, rm);
var result = AC.Login("https://google.com.ua") as ViewResult;
result.Should().NotBeNull();
var result2 = AC.Login(fakelvm, "https://google.com.ua");
result2.Should().NotBeNull();
}
public void DepositGetAction_ReturnsViewResult()
{
var userServiceMock = this.SetupMockUsersService();
var userManagerFake = new Mock <FakeUserManager>();
var claimPrincipleMock = new Mock <ClaimsPrincipal>();
userManagerFake.Setup(um => um.GetUserId(claimPrincipleMock.Object));
var userSignInFake = new FakeSignInManager();
var viewModelMock = new Mock <UserDepositViewModel>();
var controller = new UserController(userServiceMock.Object, userManagerFake.Object, userSignInFake);
var result = controller.Deposit(It.IsAny <string>()) as ViewResult;
Assert.IsInstanceOfType(result.Model, typeof(UserDepositViewModel));
}
public void RegisterTest()
{
UserManager <AppUser> um = new FakeUserManager();
SignInManager <AppUser> sim = new FakeSignInManager();
Mock <IUnitOfWork> uow = new Mock <IUnitOfWork>();
RoleManager <IdentityRole> rm = new FakeRoleManager();
AuthController AC = new AuthController(um, sim, uow.Object, rm);
var result = AC.Register() as ViewResult;
result.Should().NotBeNull();
var result2 = AC.Register(fakeRVM).Result;
result2.Should().NotBeNull();
fakeRVM.Name = "another";
result2 = AC.Register(fakeRVM).Result;
result2.Should().NotBeNull();
}
public async Task User_Cache_Should_Return_Null_If_User_Not_Found_In_Storage()
{
var loggedUserId = Guid.NewGuid().ToString();
var Logger = serviceProvider.GetService <ILoggerFactory>().CreateLogger <UserCaching>();
var UsrMgr = BuildUserManager <AspNetUser>();
var cache = serviceProvider.GetService <IMemoryCache>();
var httpAccessor = serviceProvider.GetService <IHttpContextAccessor>();
//that use was once logged in but then got deleted somehow
httpAccessor.HttpContext.User = new ClaimsPrincipal(new
ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, "a-deleted-user"),
new Claim(ClaimTypes.NameIdentifier, "not-t-be-found")
}, "SomeAuthTYpe"));
var signInManager = new FakeSignInManager(httpAccessor);
UserCaching r = new UserCaching(signInManager, httpAccessor, cache, UsrMgr, Logger);
Assert.Null(await r.SetLoggedOnUserInCache());
}
public async Task TestBaseMock_Ok()
{
var mockLogger = new Mock <ILogger <UserService> >();
var dbcontext = TestHelpers.DbContext();
var context = TestHelpers.Context(Guid.NewGuid(), "Admin", new string[] { UserRol.AdminRol });
var userManager = new FakeUserManager(new UserStore <UserApp, UserRol, ApiDbContext, Guid>(dbcontext));
var roleManager = new FakeRoleManager(new RoleStore <UserRol, ApiDbContext, Guid>(dbcontext));
var signManager = new FakeSignInManager(userManager, roleManager, TestHelpers.Options(), context.Object);
ApiDbContext.SeedData(userManager, roleManager);
var userservice = new UserService(GetIConfigurationRoot(), userManager, signManager, _mockRepo.Object, context.Object, mockLogger.Object);
LoginController login = new LoginController(userservice);
// Probamos a loguearnos, que como tenemos generado el falso usuario dara el Ok
var loginResult = await login.Authenticate(new LoginRequest
{
Username = "******",
Password = "******"
});
// Assert
Assert.IsType <OkObjectResult>(loginResult);
UserController controller = new UserController(userservice);
// Probamos a añadir el usuario, que como esta moqueado dará el Ok tambien
var result = await controller.Post(new UserAPI
{
Username = "******",
Password = "******"
});
Assert.IsAssignableFrom <ObjectResult>(result);
var objectResponse = result as ObjectResult;
Assert.Equal(200, objectResponse.StatusCode);
}
public async Task Should_remove_key_and_data_on_clear_logged_on_user()
{
var Logger = serviceProvider.GetService <ILoggerFactory>().CreateLogger <UserCaching>();
var loggeUserId = Guid.NewGuid().ToString();
var UsrMgr = BuildUserManager <AspNetUser>();
var cache = serviceProvider.GetService <IMemoryCache>();
var httpAccessor = serviceProvider.GetService <IHttpContextAccessor>();
var user = new AspNetUser()
{
UserName = "******",
Email = "*****@*****.**",
Id = loggeUserId
};
await UsrMgr.CreateAsync(user);//saving in db
httpAccessor.HttpContext.User = new ClaimsPrincipal(new
ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.UserName),
new Claim(ClaimTypes.NameIdentifier, user.Id)
}, "SomeAuthTYpe"));
var signInManager = new FakeSignInManager(httpAccessor);
UserCaching r = new UserCaching(signInManager, httpAccessor, cache, UsrMgr, Logger);
await r.SetLoggedOnUserInCache();
var cachedUsr = await r.GetLoggedOnUser();
Assert.NotNull(cachedUsr);
Assert.Equal(user.Id, cachedUsr.Id);
r.ClearLoggedOnUser();
//cachedUsr = await r.GetLoggedOnUser();
//Assert.Null(cachedUsr);
var keyIsNUll = cache.Get(r.GetUserCacheKey(cachedUsr.Id));
Assert.Null(keyIsNUll);
}
private void InitAllMocks(FakeSignInManager s = null)
{
IDentityDataPreparation i = new IDentityDataPreparation();
if (s == null)
{
var context = new Mock <HttpContext>();
var contextAccessor = new Mock <IHttpContextAccessor>();
contextAccessor.Setup(x => x.HttpContext).Returns(context.Object);
signInManager = new FakeSignInManager(contextAccessor.Object);
}
else
{
signInManager = s;
}
planReader = new Mock <IPlansReader>();
userCaching = new Mock <IUserCaching>();
emailer = new Mock <IShopifyEventsEmailer>();
shopifyApi = new Mock <IShopifyApi>();
config = new Mock <IConfiguration>();
webMsg = new Mock <IWebMessenger>();
repo = new Mock <IDbRepository <AspNetUser> >();
}
public void User_Cache_Should_Return_Null_If_User_NOT_Logged_In()
{
var Logger = serviceProvider.GetService <ILoggerFactory>().CreateLogger <UserCaching>();
var loggeUserId = Guid.NewGuid().ToString();
var UsrMgr = BuildUserManager <AspNetUser>();
var cache = serviceProvider.GetService <IMemoryCache>();
var httpAccessor = serviceProvider.GetService <IHttpContextAccessor>();
var user = new AspNetUser()
{
UserName = "******",
Email = "*****@*****.**",
Id = loggeUserId
};
UsrMgr.CreateAsync(user);//saving in db
httpAccessor.HttpContext.User = null;
var signInManager = new FakeSignInManager(httpAccessor);
UserCaching r = new UserCaching(signInManager, httpAccessor, cache, UsrMgr, Logger);
var cachedUsr = r.SetLoggedOnUserInCache().Result;
Assert.Null(cachedUsr);
}
