public void EmailIsValidFormat_ValidEmail_Succeeds()
 {
     var mockSvc = new MockUserAccountService();
     var acct = new MockUserAccount();
     var result = UserAccountValidation.EmailIsValidFormat.Validate(mockSvc.Object, acct.Object, "[email protected]");
     Assert.IsNull(result);
 }

 public void EmailIsValidFormat_InValidEmail_Fails()
 {
     var mockSvc = new MockUserAccountService();
     var acct = new MockUserAccount();
     var result = UserAccountValidation.EmailIsValidFormat.Validate(mockSvc.Object, acct.Object, "test");
     Assert.IsNotNull(result);
 }

        public void UsernameMustNotAlreadyExist_UsernameExistsInService_Fails()
        {
            var mockSvc = new MockUserAccountService();
            var acct1 = new MockUserAccount(mockSvc.SecuritySettings.DefaultTenant, "u1", "p1", "[email protected]");
            mockSvc.MockUserAccounts(acct1);

            var acct2 = new MockUserAccount(mockSvc.SecuritySettings.DefaultTenant, "u1", "p1", "[email protected]");
            var result = UserAccountValidation.UsernameMustNotAlreadyExist.Validate(mockSvc.Object, acct2.Object, acct2.Object.Username);
            Assert.IsNotNull(result);
        }

        public void EmailMustNotAlreadyExist_EmailDoesNotExistsInService_Succeeds()
        {
            var mockSvc = new MockUserAccountService();
            var acct1 = new MockUserAccount(mockSvc.SecuritySettings.DefaultTenant, "u1", "p1", "[email protected]");
            mockSvc.MockUserAccounts(acct1);

            var acct2 = new MockUserAccount(mockSvc.SecuritySettings.DefaultTenant, "u1", "p1", "[email protected]");
            var result = UserAccountValidation.EmailMustNotAlreadyExist.Validate(mockSvc.Object, acct2.Object, acct2.Object.Email);
            Assert.IsNull(result);
        }

 public void MultiTenantEnabled_NullTenant_ReturnsEmptyResults()
 {
     SecuritySettings.Instance.MultiTenant = true;
     var sub = new MockUserAccountService();
     sub.MockUserAccounts(
         new UserAccount { Tenant = "a" },
         new UserAccount { Tenant = "a" },
         new UserAccount { Tenant = "b" });
     var result = sub.Object.GetAll(null);
     Assert.AreEqual(0, result.Count());
 }

 public void CallsAllValidators()
 {
     bool wasCalled = false;
     var sub = new MockUserAccountService();
     sub.Configuration.RegisterUsernameValidator(
         new DelegateValidator((svc, ua, val) =>
         {
             wasCalled = true;
             return null;
         }));
     sub.Object.ValidateUsername(new MockUserAccount().Object, "foo");
     Assert.IsTrue(wasCalled);
 }

            public void AllowAccountDeletionDisabled_AccountIsNotVerified_CallsRemoveOnRepo()
            {
                var sub = new MockUserAccountService();
                sub.SecuritySettings.AllowAccountDeletion = false;

                var account = new MockUserAccount();
                account.Object.IsAccountVerified = false;
                sub.Object.DeleteAccount(account.Object);

                sub.UserAccountRepository.Verify(x => x.Remove(account.Object));
            }

            public void AllowAccountDeletion_CallsRemoveOnRepo()
            {
                var sub = new MockUserAccountService();
                sub.SecuritySettings.AllowAccountDeletion = true;

                var account = new MockUserAccount();
                sub.Object.DeleteAccount(account.Object);

                sub.UserAccountRepository.Verify(x => x.Remove(account.Object));
            }

 public void AccountFound_DeleteAccountCalled()
 {
     var sub = new MockUserAccountService();
     var account = new MockUserAccount();
     sub.Mock.Setup(x => x.GetByUsername(It.IsAny<string>(), It.IsAny<string>())).Returns(account.Object);
     var result = sub.Object.DeleteAccount("user");
     sub.Mock.Verify(x => x.DeleteAccount(account.Object));
 }

 public void VerifyAccountReturnsFalse_ReturnsFalse()
 {
     var sub = new MockUserAccountService();
     var account = new MockUserAccount();
     sub.Mock.Setup(x => x.GetByVerificationKey(It.IsAny<string>())).Returns(account.Object);
     account.Setup(x => x.VerifyAccount(It.IsAny<string>())).Returns(false);
     Assert.IsFalse(sub.Object.VerifyAccount("key"));
 }

 public void ValidAccount_ReturnsAccount()
 {
     var sub = new MockUserAccountService();
     var result = sub.Object.CreateAccount("user", "pass", "[email protected]");
     Assert.IsNotNull(result);
     Assert.AreEqual("user", result.Username);
     Assert.AreEqual("[email protected]", result.Email);
 }

 public void NullPassword_ReturnsFail()
 {
     var sub = new MockUserAccountService();
     Assert.IsFalse(sub.Object.Authenticate("user", null));
 }

            public void MultiTenantEnabled_NullTenantParam_ReturnsFail()
            {
                var sub = new MockUserAccountService();
                sub.SecuritySettings.MultiTenant = true;

                Assert.IsFalse(sub.Object.Authenticate(null, "user", "pass"));
            }

 public void NoTenantParam_PassesNullTenant()
 {
     var sub = new MockUserAccountService();
     sub.Object.DeleteAccount("user");
     sub.Mock.Verify(x => x.DeleteAccount(null, "user"));
 }

            public void KeysMatch_DeleteAccountCalled()
            {
                var sub = new MockUserAccountService();
                var account = new MockUserAccount();
                account.Object.VerificationPurpose = VerificationKeyPurpose.VerifyAccount;
                sub.Mock.Setup(x => x.GetByVerificationKey(It.IsAny<string>())).Returns(account.Object);
                account.Object.VerificationPurpose = VerificationKeyPurpose.VerifyAccount;
                account.Object.VerificationKey = "key";

                sub.Object.CancelNewAccount("key");

                sub.Mock.Verify(x => x.DeleteAccount(account.Object));
            }

            public void ValidatorFailure_Throws()
            {
                var mockVal = new Mock<IValidator>();
                mockVal.Setup(x => x.Validate(It.IsAny<UserAccountService>(), It.IsAny<UserAccount>(), It.IsAny<String>())).Returns(new ValidationResult("error"));
                var sub = new MockUserAccountService();
                sub.Configuration.RegisterUsernameValidator(mockVal.Object);

                sub.Object.ValidateUsername(new MockUserAccount().Object, "foo");
            }

            public void KeysDontMatch_ReturnsFalse()
            {
                var sub = new MockUserAccountService();
                var account = new MockUserAccount();
                account.Object.VerificationPurpose = VerificationKeyPurpose.VerifyAccount;
                sub.Mock.Setup(x => x.GetByVerificationKey(It.IsAny<string>())).Returns(account.Object);
                account.Object.VerificationKey = "key1";

                Assert.IsFalse(sub.Object.CancelNewAccount("key2"));
            }

            public void AccountVerified_ReturnsFalse()
            {
                var sub = new MockUserAccountService();
                var account = new MockUserAccount();
                sub.Mock.Setup(x => x.GetByVerificationKey(It.IsAny<string>())).Returns(account.Object);
                account.Object.IsAccountVerified = true;

                Assert.IsFalse(sub.Object.CancelNewAccount("key"));
            }

 public void InvalidKey_ReturnsFalse()
 {
     var sub = new MockUserAccountService();
     sub.Mock.Setup(x => x.GetByVerificationKey(It.IsAny<string>())).Returns((UserAccount)null);
     Assert.IsFalse(sub.Object.CancelNewAccount("key"));
 }

            public void AllowAccountDeletionDisabled_AccountIsVerified_CallsCloseOnAccount()
            {
                var sub = new MockUserAccountService();
                sub.SecuritySettings.AllowAccountDeletion = false;

                var account = new MockUserAccount();
                account.Object.IsLoginAllowed = true;
                account.Object.IsAccountVerified = true;
                sub.Object.DeleteAccount(account.Object);

                sub.UserAccountRepository.Verify(x => x.Remove(It.IsAny<UserAccount>()), Times.Never());
                account.Verify(x => x.CloseAccount());
                sub.UserAccountRepository.Verify(x => x.Update(account.Object));
            }