public CreatePostTransactionScript(
     AuthenticationService authenticationService,
     PostToPostDTOMapper postToPostDtoMapper)
 {
     _authenticationService = authenticationService;
     _postToPostDtoMapper = postToPostDtoMapper;
 }

        public void IsValidTest_只有驗證Authentication合法或非法()
        {
            //arrange
            //IProfile profile = MockRepository.GenerateStub<IProfile>();
            //profile.Stub(x => x.GetPassword("Joey")).Return("91");

            IProfile profile = Substitute.For<IProfile>();
            profile.GetPassword("Joey").Returns("91");

            //IToken token = MockRepository.GenerateStub<IToken>();
            //token.Stub(x => x.GetRandom("Joey")).Return("abc");
            IToken token = Substitute.For<IToken>();
            token.GetRandom("Joey").Returns("abc");

            //ILog log = MockRepository.GenerateStub<ILog>();
            ILog log = Substitute.For<ILog>();

            AuthenticationService target = new AuthenticationService(profile, token, log);
            string account = "Joey";
            string password = "wrong password";
            // 正確的 password 應為 "91abc"

            //act
            bool actual;
            actual = target.IsValid(account, password);

            // assert
            Assert.IsFalse(actual);
        }

        public void OneTimeSetup()
        {
            _passwordHasher = Substitute.For<IPasswordHasher>();
            _passwordHasher.ComputeHash("somestring", new byte[4]).ReturnsForAnyArgs("hashedPassword");

            _authService = new AuthenticationService(Session, _passwordHasher);
        }

        public AuthenticationRegistry(IAuthenticationProvider facebookProvider,
                                      IAuthenticationProvider googleProvider,
                                      IAuthenticationProvider twitterProvider)
        {
            var authenticationService = new AuthenticationService();

            if (facebookProvider != null)
            {
                authenticationService.AddProvider(facebookProvider);
            }

            if (googleProvider != null)
            {
                authenticationService.AddProvider(googleProvider);
            }

            if (twitterProvider != null)
            {
                authenticationService.AddProvider(twitterProvider);
            }

            For<IAuthenticationService>()
                .Use(authenticationService)
                .Named("Authentication Service.");
        }

        public void wrong_email_address_cannot_log_in()
        {
            _authService = new AuthenticationService(Session, _passwordHasher);
            var result = _authService.Login("invalidAddress", "SomePassword");

            Assert.AreEqual(LoginResult.unsuccessful, result);
        }

 public void should_add_and_successfully_authenticate_the_first_user()
 {
     var userRepository = new MemoryRepository<User>();
     var authenticationService = new AuthenticationService(userRepository, new UserCreateService(userRepository));
     authenticationService.Authenticate(Username, Password);
     userRepository.Count().ShouldEqual(1);
 }

 public UpdateCommentTransactionScript(
     AuthenticationService authenticationService,
     CommentToCommentDTOMapper commentToCommentDtoMapper)
 {
     _authenticationService = authenticationService;
     _commentToCommentDtoMapper = commentToCommentDtoMapper;
 }

 public LoginController(
     UserAccountService userService, 
     AuthenticationService authSvc)
 {
     this.userAccountService = userService;
     this.authSvc = authSvc;
 }

        public void Create_New_User_Test()
        {
            var user = new User()
            {
                FirstName = "Joe",
                LastName = "Henss",
                UserName = "joehenss",
                Password = Hasher.Hash("password"),
                PasswordSecurityQuestion = "Mother's maiden name",
                PasswordSecurityAnswer = "Hamilton"
            };

            var authenticationProvider = new AuthenticationService();
            var saveUserRequest = new SaveUserRequest() { User = user };

            var saveUserResponse = authenticationProvider.SaveUser(saveUserRequest);

            Assert.IsNotNull(saveUserResponse);
            Assert.AreEqual(ResponseStatus.Success, saveUserResponse.Status);

            var authenticateUserRequest = new AuthenticationRequest()
            {
                UserName = user.UserName,
                Password = user.Password
            };

            var authenticationResponse = authenticationProvider.AuthenticateUser(authenticateUserRequest);

            Assert.IsNotNull(authenticationResponse);
            Assert.AreEqual(ResponseStatus.Success, authenticationResponse.Status);
        }

 public GetPostsTransactionScript(
     AuthenticationService authenticationService,
     PostToBriefPostDTOMapper postToBriefPostDtoMapper)
 {
     _authenticationService = authenticationService;
     _postToBriefPostDtoMapper = postToBriefPostDtoMapper;
 }

 public void should_successfully_authenticate_with_correct_credentials()
 {
     var authenticationService = new AuthenticationService(_userRepository, new UserCreateService(_userRepository));
     var result = authenticationService.Authenticate(Username, Password);
     result.ShouldNotBeNull();
     result.Username.ToString().ShouldEqual(Username);
     result.IsAdministrator.ShouldBeTrue();
 }

 public SessionService(AuthenticationService authenticationService,
     IGitterApiService gitterApiService,
     IPasswordStorageService passwordStorageService)
 {
     _authenticationService = authenticationService;
     _gitterApiService = gitterApiService;
     _passwordStorageService = passwordStorageService;
 }

 public ServiceAdapter()
 {
     authServ = new AuthenticationService();
     proServ = new ProfileService();
     dbcServ = new DaybookClientService();
     authServ.CookieContainer = new System.Net.CookieContainer();
     Instance = this;
 }

        public void LogIn()
        {
            AuthenticationService authenticationService = new AuthenticationService(new UserRepository());

            var result = authenticationService.LogIn("rodrigo.cruz", "1234");

            Assert.AreEqual(false, result);
        }

 protected SecuredRemoteServiceBase(
     Configuration configuration,
     ConfigurationService configurationService,
     AuthenticationService authenticationService)
     : base(configuration, configurationService)
 {
     AuthenticationService = authenticationService;
 }

        public void TestAuthentication()
        {
            AuthenticationService service = new AuthenticationService();
            bool result = service.validate("guest", Encrypt("123456"));
            Assert.IsTrue(result);

            result = service.validate("guest", Encrypt("34545"));
            Assert.IsFalse(result);
        }

 public void RetrieveAuthenticateUserByUserIdAsync()
 {
     AuthenticationService authentication = new AuthenticationService();
     AuthenticateDetail userAccount = new AuthenticateDetail();
     userAccount.UserId = "0112";
     userAccount.Password = "55555";
     var task = authentication.RetrieveAuthenticateUserByUserIdAsync(userAccount);
     Console.WriteLine("completed");
 }

 public GetUserDetailsTransactionScript(
     AuthenticationService authenticationService,
     PostToBriefPostDTOMapper postToBriefPostDtoMapper,
     CommentToCommentDTOMapper commentToCommentDtoMapper)
 {
     _authenticationService = authenticationService;
     _postToBriefPostDtoMapper = postToBriefPostDtoMapper;
     _commentToCommentDtoMapper = commentToCommentDtoMapper;
 }

        public void IsAdmin_WhenIdentityIsNull_IsAdminIsFalse()
        {
            //Arrange
            var service = new AuthenticationService();
            var applicationContext = Mock.Create<IApplicationContextService>();
            Mock.Arrange(() => applicationContext.Identity).Returns(() => null);
            service.ApplicationContextService = applicationContext;

            //Assert
            Assert.IsFalse(service.IsAdmin);
        }

            public void GivenANullIAuthenticationServiceSettings_CheckCallback_ThrowsAnException()
            {
                // Arrange.
                var querystringParams = new NameValueCollection {{"a", "b"}};
                var authenticationService = new AuthenticationService();

                // Act and Assert.
                var result = Assert.Throws<ArgumentNullException>(
                    () => authenticationService.GetAuthenticatedClient(null, querystringParams));

                Assert.NotNull(result);
                Assert.Equal("Value cannot be null.\r\nParameter name: authenticationServiceSettings", result.Message);
            }