Ghost/ghost/admin/tests/acceptance/team-test.js

/* jshint expr:true */
import {
  describe,
  it,
  beforeEach,
  afterEach
} from 'mocha';
import { expect } from 'chai';
import startApp from '../helpers/start-app';
import destroyApp from '../helpers/destroy-app';
import { invalidateSession, authenticateSession } from 'ghost-admin/tests/helpers/ember-simple-auth';
import { errorOverride, errorReset } from 'ghost-admin/tests/helpers/adapter-error';
import Mirage from 'ember-cli-mirage';
import $ from 'jquery';

describe('Acceptance: Team', function () {
    let application;

    beforeEach(function () {
        application = startApp();
    });

    afterEach(function () {
        destroyApp(application);
    });

    it('redirects to signin when not authenticated', function () {
        invalidateSession(application);
        visit('/team');

        andThen(function () {
            expect(currentURL()).to.equal('/signin');
        });
    });

    it('redirects correctly when authenticated as author', function () {
        let role = server.create('role', {name: 'Author'});
        let user = server.create('user', {roles: [role], slug: 'test-user'});

        server.create('user', {slug: 'no-access'});

        authenticateSession(application);
        visit('/team/no-access');

        andThen(() => {
            expect(currentURL(), 'currentURL').to.equal('/team/test-user');
        });
    });

    it('redirects correctly when authenticated as editor', function () {
        let role = server.create('role', {name: 'Editor'});
        let user = server.create('user', {roles: [role], slug: 'test-user'});

        server.create('user', {slug: 'no-access'});

        authenticateSession(application);
        visit('/team/no-access');

        andThen(() => {
            expect(currentURL(), 'currentURL').to.equal('/team');
        });
    });

    describe('when logged in', function () {
        let admin;

        beforeEach(function () {
            let role = server.create('role', {name: 'Administrator'});
            admin = server.create('user', {roles: [role]});

            server.loadFixtures();

            return authenticateSession(application);
        });

        it('it renders and navigates correctly', function () {
            let user1 = server.create('user');
            let user2 = server.create('user');

            visit('/team');

            andThen(() => {
                // doesn't do any redirecting
                expect(currentURL(), 'currentURL').to.equal('/team');

                // it has correct page title
                expect(document.title, 'page title').to.equal('Team - Test Blog');

                // it shows 3 users in list (includes currently logged in user)
                expect(find('.user-list .user-list-item').length, 'user list count')
                    .to.equal(3);

                click('.user-list-item:last');

                andThen(() => {
                    // url is correct
                    expect(currentURL(), 'url after clicking user').to.equal(`/team/${user2.slug}`);

                    // title is correct
                    expect(document.title, 'title after clicking user').to.equal('Team - User - Test Blog');

                    // view title should exist and be linkable and active
                    expect(find('.view-title a[href="/ghost/team"]').hasClass('active'), 'has linkable url back to team main page')
                        .to.be.true;
                });

                click('.view-title a');

                andThen(() => {
                    // url should be /team again
                    expect(currentURL(), 'url after clicking back').to.equal('/team');
                });
            });
        });

        describe('invite new user', function () {
            let emailInputField = '.fullscreen-modal input[name="email"]';

            // @TODO: Evaluate after the modal PR goes in
            it('modal loads correctly', function () {
                visit('/team');

                andThen(() => {
                    // url is correct
                    expect(currentURL(), 'currentURL').to.equal('/team');

                    // invite user button exists
                    expect(find('.view-actions .btn-green').html(), 'invite people button text')
                        .to.equal('Invite People');
                });

                click('.view-actions .btn-green');

                andThen(() => {
                    let roleOptions = find('#new-user-role select option');

                    function checkOwnerExists() {
                        for (let i in roleOptions) {
                            if (roleOptions[i].tagName === 'option' && roleOptions[i].text === 'Owner') {
                                return true;
                            }
                        }
                        return false;
                    }

                    function checkSelectedIsAuthor() {
                        for (let i in roleOptions) {
                            if (roleOptions[i].selected) {
                                return roleOptions[i].text === 'Author';
                            }
                        }
                        return false;
                    }

                    // should be 3 available roles
                    expect(roleOptions.length, 'number of available roles').to.equal(3);

                    expect(checkOwnerExists(), 'owner role isn\'t available').to.be.false;
                    expect(checkSelectedIsAuthor(), 'author role is selected initially').to.be.true;
                });
            });

            it('sends an invite correctly', function () {
                visit('/team');

                andThen(() => {
                    expect(find('.user-list.invited-users .user-list-item').length, 'number of invited users').to.equal(0);
                });

                click('.view-actions .btn-green');
                click(emailInputField);
                triggerEvent(emailInputField, 'blur');

                andThen(() => {
                    expect(find('.modal-body .form-group:first').hasClass('error'), 'email input has error status').to.be.true;
                    expect(find('.modal-body .form-group:first .response').text()).to.contain('Please enter an email.');
                });

                fillIn(emailInputField, 'test@example.com');
                click('.fullscreen-modal .btn-green');

                andThen(() => {
                    expect(find('.user-list.invited-users .user-list-item').length, 'number of invited users').to.equal(1);
                    expect(find('.user-list.invited-users .user-list-item:first .name').text(), 'name of invited user').to.equal('test@example.com');
                });

                click('.user-list.invited-users .user-list-item:first .user-list-item-aside .user-list-action:contains("Revoke")');

                andThen(() => {
                    expect(find('.user-list.invited-users .user-list-item').length, 'number of invited users').to.equal(0);
                });
            });

            it('fails sending an invite correctly', function () {
                server.create('user', {email: 'test1@example.com'});
                server.create('user', {email: 'test2@example.com', status: 'invited'});

                visit('/team');

                // check our users lists are what we expect
                andThen(() => {
                    expect(find('.user-list.invited-users .user-list-item').length, 'number of invited users')
                        .to.equal(1);
                    // number of active users is 2 because of the logged-in user
                    expect(find('.user-list.active-users .user-list-item').length, 'number of active users')
                        .to.equal(2);
                });

                // click the "invite new user" button to open the modal
                click('.view-actions .btn-green');

                // fill in and submit the invite user modal with an existing user
                fillIn(emailInputField, 'test1@example.com');
                click('.fullscreen-modal .btn-green');

                andThen(() => {
                    // check the inline-validation
                    expect(find('.fullscreen-modal .error .response').text().trim(), 'inviting existing user error')
                        .to.equal('A user with that email address already exists.');
                });

                // fill in and submit the invite user modal with an invited user
                fillIn(emailInputField, 'test2@example.com');
                click('.fullscreen-modal .btn-green');

                andThen(() => {
                    // check the inline-validation
                    expect(find('.fullscreen-modal .error .response').text().trim(), 'inviting invited user error')
                        .to.equal('A user with that email address was already invited.');

                    // ensure that there's been no change in our user lists
                    expect(find('.user-list.invited-users .user-list-item').length, 'number of invited users after failed invites')
                        .to.equal(1);
                    expect(find('.user-list.active-users .user-list-item').length, 'number of active users after failed invites')
                        .to.equal(2);
                });
            });
        });

        it('can delete users', function () {
            /* jscs:disable requireCamelCaseOrUpperCaseIdentifiers */
            let user1 = server.create('user');
            let user2 = server.create('user');
            let post1 = server.create('post', {author_id: user2.id});
            /* jscs:disable requireCamelCaseOrUpperCaseIdentifiers */

            visit('/team');
            click(`a.user-list-item:contains("${user1.name}")`);

            // user deletion displays modal
            click('button.delete');
            andThen(() => {
                expect(
                    find('.fullscreen-modal .modal-content:contains("delete this user")').length,
                    'user deletion modal displayed after button click'
                ).to.equal(1);

                // user has no posts so no warning about post deletion
                expect(
                    find('.fullscreen-modal .modal-content:contains("is the author of")').length,
                    'deleting user with no posts has no post count'
                ).to.equal(0);
            });

            // cancelling user deletion closes modal
            click('.fullscreen-modal button:contains("Cancel")');
            andThen(() => {
                expect(
                    find('.fullscreen-modal').length === 0,
                    'delete user modal is closed when cancelling'
                ).to.be.true;
            });

            // deleting a user with posts
            visit('/team');
            click(`a.user-list-item:contains("${user2.name}")`);

            click('button.delete');
            andThen(() => {
                // user has  posts so should warn about post deletion
                expect(
                    find('.fullscreen-modal .modal-content:contains("is the author of 1 post")').length,
                    'deleting user with posts has post count'
                ).to.equal(1);
            });

            click('.fullscreen-modal button:contains("Delete")');
            andThen(() => {
                // redirected to team page
                expect(currentURL()).to.equal('/team');

                // deleted user is not in list
                expect(
                    find(`.user-list-item .name:contains("${user2.name}")`).length,
                    'deleted user is not in user list after deletion'
                ).to.equal(0);
            });
        });

        describe('existing user', function () {
            let user;

            beforeEach(function () {
                user = server.create('user', {
                    slug: 'test-1',
                    name: 'Test User',
                    facebook: 'test',
                    twitter: '@test'
                });

                server.loadFixtures();
            });

            it('input fields reset and validate correctly', function () {
                // test user name
                visit('/team/test-1');

                andThen(() => {
                    expect(currentURL(), 'currentURL').to.equal('/team/test-1');
                    expect(find('.user-details-top .first-form-group input.user-name').val(), 'current user name').to.equal('Test User');
                });

                // test empty user name
                fillIn('.user-details-top .first-form-group input.user-name', '');
                triggerEvent('.user-details-top .first-form-group input.user-name', 'blur');

                andThen(() => {
                    expect(find('.user-details-top .first-form-group').hasClass('error'), 'username input is in error state with blank input').to.be.true;
                });

                // test too long user name
                fillIn('.user-details-top .first-form-group input.user-name', new Array(160).join('a'));
                triggerEvent('.user-details-top .first-form-group input.user-name', 'blur');

                andThen(() => {
                    expect(find('.user-details-top .first-form-group').hasClass('error'), 'username input is in error state with too long input').to.be.true;
                });

                // reset name field
                fillIn('.user-details-top .first-form-group input.user-name', 'Test User');

                andThen(() => {
                    expect(find('.user-details-bottom input[name="user"]').val(), 'slug value is default').to.equal('test-1');
                });

                fillIn('.user-details-bottom input[name="user"]', '');
                triggerEvent('.user-details-bottom input[name="user"]', 'blur');

                andThen(() => {
                    expect(find('.user-details-bottom input[name="user"]').val(), 'slug value is reset to original upon empty string').to.equal('test-1');
                });

                fillIn('.user-details-bottom input[name="user"]', 'white space');
                triggerEvent('.user-details-bottom input[name="user"]', 'blur');

                andThen(() => {
                    expect(find('.user-details-bottom input[name="user"]').val(), 'slug value is correctly dasherized').to.equal('white-space');
                });

                fillIn('.user-details-bottom input[name="email"]', 'thisisnotanemail');
                triggerEvent('.user-details-bottom input[name="email"]', 'blur');

                andThen(() => {
                    expect(find('.user-details-bottom .form-group:nth-of-type(2)').hasClass('error'), 'email input should be in error state with invalid email').to.be.true;
                });

                fillIn('.user-details-bottom input[name="email"]', 'test@example.com');
                fillIn('#user-location', new Array(160).join('a'));
                triggerEvent('#user-location', 'blur');

                andThen(() => {
                    expect(find('#user-location').closest('.form-group').hasClass('error'), 'location input should be in error state').to.be.true;
                });

                fillIn('#user-location', '');
                fillIn('#user-website', 'thisisntawebsite');
                triggerEvent('#user-website', 'blur');

                andThen(() => {
                    expect(find('#user-website').closest('.form-group').hasClass('error'), 'website input should be in error state').to.be.true;
                });

                // Testing Facebook input

                andThen(() => {
                    // displays initial value
                    expect(find('#user-facebook').val(), 'initial facebook value')
                        .to.equal('https://www.facebook.com/test');
                });

                triggerEvent('#user-facebook', 'focus');
                triggerEvent('#user-facebook', 'blur');

                andThen(() => {
                    // regression test: we still have a value after the input is
                    // focused and then blurred without any changes
                    expect(find('#user-facebook').val(), 'facebook value after blur with no change')
                        .to.equal('https://www.facebook.com/test');
                });

                fillIn('#user-facebook', '');
                fillIn('#user-facebook', ')(*&%^%)');
                triggerEvent('#user-facebook', 'blur');

                andThen(() => {
                    expect(find('#user-facebook').closest('.form-group').hasClass('error'), 'facebook input should be in error state').to.be.true;
                });

                fillIn('#user-facebook', '');
                fillIn('#user-facebook', 'pages/)(*&%^%)');
                triggerEvent('#user-facebook', 'blur');

                andThen(() => {
                    expect(find('#user-facebook').val()).to.be.equal('https://www.facebook.com/pages/)(*&%^%)');
                    expect(find('#user-facebook').closest('.form-group').hasClass('error'), 'facebook input should be in error state').to.be.false;
                });

                fillIn('#user-facebook', '');
                fillIn('#user-facebook', 'testing');
                triggerEvent('#user-facebook', 'blur');

                andThen(() => {
                    expect(find('#user-facebook').val()).to.be.equal('https://www.facebook.com/testing');
                    expect(find('#user-facebook').closest('.form-group').hasClass('error'), 'facebook input should be in error state').to.be.false;
                });

                fillIn('#user-facebook', '');
                fillIn('#user-facebook', 'somewebsite.com/pages/some-facebook-page/857469375913?ref=ts');
                triggerEvent('#user-facebook', 'blur');

                andThen(() => {
                    expect(find('#user-facebook').val()).to.be.equal('https://www.facebook.com/pages/some-facebook-page/857469375913?ref=ts');
                    expect(find('#user-facebook').closest('.form-group').hasClass('error'), 'facebook input should be in error state').to.be.false;
                });

                fillIn('#user-facebook', '');
                fillIn('#user-facebook', 'test');
                triggerEvent('#user-facebook', 'blur');

                andThen(() => {
                    expect(find('#user-facebook').closest('.form-group').hasClass('error'), 'facebook input should be in error state').to.be.true;
                });

                fillIn('#user-facebook', '');
                fillIn('#user-facebook', 'http://twitter.com/testuser');
                triggerEvent('#user-facebook', 'blur');

                andThen(() => {
                    expect(find('#user-facebook').val()).to.be.equal('https://www.facebook.com/testuser');
                    expect(find('#user-facebook').closest('.form-group').hasClass('error'), 'facebook input should be in error state').to.be.false;
                });

                fillIn('#user-facebook', '');
                fillIn('#user-facebook', 'facebook.com/testing');
                triggerEvent('#user-facebook', 'blur');

                andThen(() => {
                    expect(find('#user-facebook').val()).to.be.equal('https://www.facebook.com/testing');
                    expect(find('#user-facebook').closest('.form-group').hasClass('error'), 'facebook input should be in error state').to.be.false;
                });

                // Testing Twitter input

                andThen(() => {
                    // loads fixtures and performs transform
                    expect(find('#user-twitter').val(), 'initial twitter value')
                        .to.equal('https://twitter.com/test');
                });

                triggerEvent('#user-twitter', 'focus');
                triggerEvent('#user-twitter', 'blur');

                andThen(() => {
                    // regression test: we still have a value after the input is
                    // focused and then blurred without any changes
                    expect(find('#user-twitter').val(), 'twitter value after blur with no change')
                        .to.equal('https://twitter.com/test');
                });

                fillIn('#user-twitter', '');
                fillIn('#user-twitter', ')(*&%^%)');
                triggerEvent('#user-twitter', 'blur');

                andThen(() => {
                    expect(find('#user-twitter').closest('.form-group').hasClass('error'), 'twitter input should be in error state').to.be.true;
                });

                fillIn('#user-twitter', '');
                fillIn('#user-twitter', 'name');
                triggerEvent('#user-twitter', 'blur');

                andThen(() => {
                    expect(find('#user-twitter').val()).to.be.equal('https://twitter.com/name');
                    expect(find('#user-twitter').closest('.form-group').hasClass('error'), 'twitter input should be in error state').to.be.false;
                });

                fillIn('#user-twitter', '');
                fillIn('#user-twitter', 'http://github.com/user');
                triggerEvent('#user-twitter', 'blur');

                andThen(() => {
                    expect(find('#user-twitter').val()).to.be.equal('https://twitter.com/user');
                    expect(find('#user-twitter').closest('.form-group').hasClass('error'), 'twitter input should be in error state').to.be.false;
                });

                fillIn('#user-twitter', '');
                fillIn('#user-twitter', 'twitter.com/user');
                triggerEvent('#user-twitter', 'blur');

                andThen(() => {
                    expect(find('#user-twitter').val()).to.be.equal('https://twitter.com/user');
                    expect(find('#user-twitter').closest('.form-group').hasClass('error'), 'twitter input should be in error state').to.be.false;
                });

                fillIn('#user-website', '');
                fillIn('#user-bio', new Array(210).join('a'));
                triggerEvent('#user-bio', 'blur');

                andThen(() => {
                    expect(find('#user-bio').closest('.form-group').hasClass('error'), 'bio input should be in error state').to.be.true;
                });

                // password reset ------

                // button triggers validation
                click('.button-change-password');

                andThen(() => {
                    expect(
                        find('#user-password-new').closest('.form-group').hasClass('error'),
                        'new password has error class when blank'
                    ).to.be.true;

                    expect(
                        find('#user-password-new').siblings('.response').text(),
                        'new password error when blank'
                    ).to.match(/can't be blank/);
                });

                // typing in inputs clears validation
                fillIn('#user-password-new', 'password');
                triggerEvent('#user-password-new', 'input');

                andThen(() => {
                    expect(
                        find('#user-password-new').closest('.form-group').hasClass('error'),
                        'password validation is visible after typing'
                    ).to.be.false;
                });

                // enter key triggers action
                keyEvent('#user-password-new', 'keyup', 13);

                andThen(() => {
                    expect(
                        find('#user-new-password-verification').closest('.form-group').hasClass('error'),
                        'confirm password has error class when it doesn\'t match'
                    ).to.be.true;

                    expect(
                        find('#user-new-password-verification').siblings('.response').text(),
                        'confirm password error when it doesn\'t match'
                    ).to.match(/do not match/);
                });

                // submits with correct details
                fillIn('#user-new-password-verification', 'password');
                click('.button-change-password');

                andThen(() => {
                    // hits the endpoint
                    let [lastRequest] = server.pretender.handledRequests.slice(-1);
                    let params = $.deparam(lastRequest.requestBody);

                    expect(lastRequest.url, 'password request URL')
                        .to.match(/\/users\/password/);

                    /* jscs:disable requireCamelCaseOrUpperCaseIdentifiers */
                    expect(params.password[0].user_id).to.equal(user.id.toString());
                    expect(params.password[0].newPassword).to.equal('password');
                    expect(params.password[0].ne2Password).to.equal('password');
                    /* jscs:enable requireCamelCaseOrUpperCaseIdentifiers */

                    // clears the fields
                    expect(
                        find('#user-password-new').val(),
                        'password field after submit'
                    ).to.be.blank;

                    expect(
                        find('#user-new-password-verification').val(),
                        'password verification field after submit'
                    ).to.be.blank;

                    // displays a notification
                    expect(
                        find('.gh-notifications .gh-notification').length,
                        'password saved notification is displayed'
                    ).to.equal(1);
                });
            });
        });

        describe('own user', function () {
            beforeEach(function () {
                server.loadFixtures();
            });

            it('requires current password when changing password', function () {
                visit(`/team/${admin.slug}`);

                // test the "old password" field is validated
                click('.button-change-password');

                andThen(() => {
                    // old password has error
                    expect(
                        find('#user-password-old').closest('.form-group').hasClass('error'),
                        'old password has error class when blank'
                    ).to.be.true;

                    expect(
                        find('#user-password-old').siblings('.response').text(),
                        'old password error when blank'
                    ).to.match(/is required/);

                    // new password has error
                    expect(
                        find('#user-password-new').closest('.form-group').hasClass('error'),
                        'new password has error class when blank'
                    ).to.be.true;

                    expect(
                        find('#user-password-new').siblings('.response').text(),
                        'new password error when blank'
                    ).to.match(/can't be blank/);
                });

                // validation is cleared when typing
                fillIn('#user-password-old', 'password');
                triggerEvent('#user-password-old', 'input');

                andThen(() => {
                    expect(
                        find('#user-password-old').closest('.form-group').hasClass('error'),
                        'old password validation is in error state after typing'
                    ).to.be.false;
                });
            });
        });

        it('redirects to 404 when user does not exist', function () {
            server.get('/users/slug/unknown/', function () {
                return new Mirage.Response(404, {'Content-Type': 'application/json'}, {errors: [{message: 'User not found.', errorType: 'NotFoundError'}]});
            });

            errorOverride();

            visit('/team/unknown');

            andThen(() => {
                errorReset();
                expect(currentPath()).to.equal('error404');
                expect(currentURL()).to.equal('/team/unknown');
            });
        });
    });
});