protected override void Context()
        {
            Username = "******";

            base.Context();

            AccountService.Stub(
                x => x.DeleteAccount(Arg<string>.Is.Equal(Username), Arg<DeleteAccountRequest>.Is.Anything))
                .Return(new DeleteAccountResponse{Success = true,});

            _accountReturnedFromQuickSearch = Builder<Account>.CreateNew().Build();
            _responseFromQuickSearch = new SearchAccountsResponse
                                           {
                                               Accounts = new List<Account>
                                                              {
                                                                  _accountReturnedFromQuickSearch,
                                                              },
                                                              Success = true,
                                           };

            AccountService.Stub(
                x => x.QuickSearchAccounts(Arg<string>.Is.Equal(Username), Arg<QuickSearchAccountsRequest>.Is.Anything))
                .Return(_responseFromQuickSearch);

            _expectedViewModel = new AccountManagementViewModel(new List<string> {"User deleted successfully"});
            _expectedViewModel.AddAccount(new AccountViewModel
                                              {
                                                  Id = _accountReturnedFromQuickSearch.Id,
                                                  EmailAddress = _accountReturnedFromQuickSearch.EmailAddress,
                                                  FirstName = _accountReturnedFromQuickSearch.FirstName,
                                                  LastName = _accountReturnedFromQuickSearch.LastName,
                                                  UserName = _accountReturnedFromQuickSearch.Username,
                                                  Role = _accountReturnedFromQuickSearch.Role.ToString(),
                                              });
        }
 protected override void BecauseOf()
 {
     try
     {
         _result = AccountService.GetAccount(Username, Password);
     }
     catch (Exception exception)
     {
         _exception = exception;
     }
 }
        protected override void Context()
        {
            base.Context();

            CryptographyService.Stub(x => x.Encrypt(Arg<string>.Is.Equal(Password)))
                .Return(EncryptedPassword);

            _accountReturnedFromService = Builder<Account>.CreateNew().Build();
            _accountReturnedFromService.MustChangePassword = false;

            AccountRepository.Stub(x => x.Get(Arg<string>.Is.Equal(Username), Arg<string>.Is.Equal(EncryptedPassword)))
                .Return(_accountReturnedFromService);
        }
        protected override void Context()
        {
            base.Context();

            AccountRepository.Stub(x => x.Get(Arg<int>.Is.Equal(AccountId)))
                .Return(new Account
                            {
                                EmailAddress = "some email address",
                                FirstName = "Bob",
                                LastName = "Newhart",
                                Role = Role.Employee,
                                Username = "******",
                            });
            _expectedAccount = new Account
                                   {
                                       EmailAddress = "some email address",
                                       FirstName = "Bob",
                                       LastName = "Newhart",
                                       Role = Role.Employee,
                                       Username = "******",
                                   };
        }
        protected override void Context()
        {
            Username = "******";
            base.Context();

            _accountReturnedFromAccountService = new Account
            {
                MustChangePassword = true,
                Username = Username,
                Role = Role.Administrator,
            };

            AccountService.Stub(x => x.GetAccount(Arg<string>.Is.Equal(Username), Arg<string>.Is.Equal(Password)))
                .Return(_accountReturnedFromAccountService);

            WebAuthenticationService.Stub(
                x =>
                x.CreateAuthCookie(Arg<string>.Is.Equal(Username),
                                   Arg<string>.Is.Equal(_accountReturnedFromAccountService.Role.ToString()),
                                   Arg<bool>.Is.Anything))
                .WhenCalled(x => _usernamePassedToWebAuthenticationService = x.Arguments[0].ToString())
                .Return(new HttpCookie("some name", "some value"));
        }
 public void AddUser(Account user)
 {
     _users.Add(user);
 }
 protected override void BecauseOf()
 {
     _result = AccountService.GetAccount(AccountId);
 }
 public void AddUser(Account account)
 {
     _users.Add(account);
 }
 protected override void BecauseOf()
 {
     _result = AccountService.GetAccount(Username, Password);
 }