public async Task FindByNameAsyncAsyncTest()
        {
            var database = CreateDatabase();

            var store = new UserStore<ApplicationUser>(database);
            var user = new ApplicationUser() { UserName = "******" };
            await store.CreateAsync(user);
            var userFromDb = await store.FindByNameAsync("testuser");
            Assert.IsTrue(userFromDb.Id.Length > 0);
            Assert.AreEqual(user.Id, userFromDb.Id);
            await store.DeleteAsync(user);
        }
        public async Task CreateAsyncTest()
        {
            var database = CreateDatabase();
            
            var store = new UserStore<ApplicationUser>(database);
            var user = new ApplicationUser() { UserName = "******" };
            await store.CreateAsync(user);
            Assert.IsTrue(user.Id.Length > 0);
            var userFromDb = await store.FindByIdAsync(user.Id);
            
            Assert.IsNotNull(userFromDb);
            Assert.AreEqual("TestUser", userFromDb.UserName);

            database.GetCollection<ApplicationUser>("users").Remove(Query<ApplicationUser>.EQ(u => u.Id, user.Id));
        }
        public async Task UpdateAsyncAsyncTest()
        {
            var database = CreateDatabase();

            var store = new UserStore<ApplicationUser>(database);
            var user = new ApplicationUser() { UserName = "******" };
            await store.CreateAsync(user);
            var id = user.Id;
            Assert.IsTrue(id.Length > 0);

            user.PasswordHash = "testhash";
            user.UserName = "******";

            await store.UpdateAsync(user);
            Assert.AreEqual(id, user.Id);

            var updatedUser = await store.FindByIdAsync(id);
            Assert.AreEqual("testhash", updatedUser.PasswordHash);
            Assert.AreEqual("modified user name", updatedUser.UserName);
            await store.DeleteAsync(user);
        }
        public async Task<ActionResult> Register(RegisterViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = new ApplicationUser() { UserName = model.UserName };
                var result = await UserManager.CreateAsync(user, model.Password);
                if (result.Succeeded)
                {
                    await SignInAsync(user, isPersistent: false);
                    return RedirectToAction("Index", "Home");
                }
                else
                {
                    AddErrors(result);
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }
 private async Task SignInAsync(ApplicationUser user, bool isPersistent)
 {
     AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie);
     var identity = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
     AuthenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = isPersistent }, identity);
 }
        public async Task<ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
        {
            if (User.Identity.IsAuthenticated)
            {
                return RedirectToAction("Manage");
            }

            if (ModelState.IsValid)
            {
                // Get the information about the user from the external login provider
                var info = await AuthenticationManager.GetExternalLoginInfoAsync();
                if (info == null)
                {
                    return View("ExternalLoginFailure");
                }
                var user = new ApplicationUser() { UserName = model.UserName };
                var result = await UserManager.CreateAsync(user);
                if (result.Succeeded)
                {
                    result = await UserManager.AddLoginAsync(user.Id, info.Login);
                    if (result.Succeeded)
                    {
                        await SignInAsync(user, isPersistent: false);
                        return RedirectToLocal(returnUrl);
                    }
                }
                AddErrors(result);
            }

            ViewBag.ReturnUrl = returnUrl;
            return View(model);
        }