예제 #1
0
        public async Task TEST_DELETE_USER_THAT_DOESNT_EXIST()
        {
            string randomUsername = GenerateRandomUsername();

            Business.DeleteUserReadOnly deleter = null;

            var isAsyncComplete = false;
            var hasError        = false;

            EnqueueConditional(() => isAsyncComplete);
            await Setup();

            try
            {
                deleter = await Business.DeleteUserReadOnly.CreateNewAsync(randomUsername);
            }
            catch (Csla.DataPortalException dpex)
            {
                //WE EXPECT AN EXCEPTION OF TYPE USER NOT FOUND. OTHERWISE,
                //WE NEED TO RETHROW THE EXCEPTION.
                if (!TestsHelper.IsUserNotFoundException(dpex))
                {
                    throw dpex;
                }
            }
            catch
            {
                //HAS ERROR REFERS TO THE METHOD HAS A PROBLEM.
                //IT DOES NOT MEAN THAT WE HAVE AN EXCEPTION, BECAUSE
                //WE ARE INDEED EXPECTING AN EXCEPTION.
                hasError = true;
            }
            finally
            {
                EnqueueCallback(
                    () => Assert.IsFalse(hasError),
                    () => Assert.IsNull(deleter),
                    () => Teardown()
                    );

                EnqueueTestComplete();

                isAsyncComplete = true;
            }
        }
예제 #2
0
        public async Task TEST_LOGIN_ADMIN_ADD_USER_DELETE_USER_LOGOUT()
        {
            var newUserLoginWasSuccessful = false;
            //var newUserIsInUserRole = false;
            //ASSUME DELETED USER LOGIN IS SUCCESSFUL
            var deletedUserLoginWasSuccessful = true;

            Business.NewUserCreator     creator = null;
            Business.DeleteUserReadOnly deleter = null;

            var isAsyncComplete = false;
            var hasError        = false;

            EnqueueConditional(() => isAsyncComplete);
            await Setup();

            try
            {
                //LOGIN AS THE ADMIN
                await UserPrincipal.LoginAsync(_TestValidUsernameAdmin, _TestValidPasswordAdmin);

                //CREATE THE USER
                var testNewUsername     = "******";
                var testNewUserPassword = "******";
                var criteria            = new Csla.Security.UsernameCriteria(testNewUsername, testNewUserPassword);
                creator = await Business.NewUserCreator.CreateNewAsync(criteria);

                //LOGOUT ADMIN
                UserPrincipal.Logout();

                //LOGIN AS THE NEW USER
                await UserPrincipal.LoginAsync(testNewUsername, testNewUserPassword);

                //CONFIRM LOGIN
                newUserLoginWasSuccessful = Common.CommonHelper.CurrentUserIsAuthenticated();

                //LOGOUT NEW USER
                UserPrincipal.Logout();

                //LOG BACK IN AS ADMIN
                await UserPrincipal.LoginAsync(_TestValidUsernameAdmin, _TestValidPasswordAdmin);

                //DELETE THE USER
                deleter = await Business.DeleteUserReadOnly.CreateNewAsync(testNewUsername);

                //LOGOUT ADMIN AGAIN
                UserPrincipal.Logout();

                //TRY TO LOG THE DELETED USER BACK IN, BUT SHOULD FAIL (BUT NOT THROW EXCEPTION)
                await UserPrincipal.LoginAsync(testNewUsername, testNewUserPassword);

                //THIS SHOULD BE FALSE.
                deletedUserLoginWasSuccessful = Common.CommonHelper.CurrentUserIsAuthenticated();

                EnqueueTestComplete();
            }
            catch
            {
                hasError = true;
            }
            finally
            {
                var adminRole = DataAccess.SeedData.Ton.AdminRoleText;
                EnqueueCallback(
                    () => Assert.IsFalse(hasError),
                    () => Assert.IsTrue(Csla.ApplicationContext.User.IsInRole(adminRole)),
                    () => Assert.IsTrue(creator.WasSuccessful),
                    () => Assert.IsTrue(deleter.WasSuccessful),
                    () => Assert.IsFalse(deletedUserLoginWasSuccessful),
                    () => Assert.IsFalse(Common.CommonHelper.CurrentUserIsAuthenticated())
                    );

                EnqueueTestComplete();
                Teardown();
                isAsyncComplete = true;
            }
        }