cloudron-box/src/test/users-test.js

/* global it:false */
/* global describe:false */
/* global before:false */
/* global after:false */

'use strict';

const BoxError = require('../boxerror.js'),
    common = require('./common.js'),
    expect = require('expect.js'),
    fs = require('fs'),
    paths = require('../paths.js'),
    safe = require('safetydance'),
    users = require('../users.js'),
    _ = require('underscore');

describe('User', function () {
    const { domainSetup, cleanup, ADMIN, AUDIT_SOURCE } = common;

    async function cleanupUsers() {
        for (const u of await users.getAll()) {
            await users.del(u, AUDIT_SOURCE);
        }
    }

    async function createOwner() {
        await cleanupUsers();

        const id = await users.add(ADMIN.email, ADMIN, AUDIT_SOURCE);
        ADMIN.id = id;
    }

    before(domainSetup);
    after(cleanup);

    function checkUser(a, b) {
        expect(a.creationTime).to.be.a(Date);
        expect(a.resetTokenCreationTime).to.be.a(Date);

        const fields = [ 'id', 'username', 'email', 'fallbackEmail', 'role', 'displayName', 'source', 'permissions', 'active' ];

        expect(_.pick(a, fields)).to.be.eql(_.pick(b, fields));
    }

    describe('add', function () {
        it('fails due to short password', async function () {
            const user = Object.assign({}, ADMIN, { password: 'Fo$%23' });
            const [error] = await safe(users.add(user.email, user, AUDIT_SOURCE));
            expect(error.reason).to.equal(BoxError.BAD_FIELD);
        });

        it('fails due to reserved username', async function () {
            const user = Object.assign({}, ADMIN, { username: 'admin' });
            const [error] = await safe(users.add(user.email, user, AUDIT_SOURCE));
            expect(error.reason).to.equal(BoxError.BAD_FIELD);
        });

        it('fails due to invalid username', async function () {
            const user = Object.assign({}, ADMIN, { username: 'moo+daemon' });
            const [error] = await safe(users.add(user.email, user, AUDIT_SOURCE));
            expect(error.reason).to.equal(BoxError.BAD_FIELD);
        });

        it('fails due to empty username', async function () {
            const user = Object.assign({}, ADMIN, { username: '' });
            const [error] = await safe(users.add(user.email, user, AUDIT_SOURCE));
            expect(error.reason).to.equal(BoxError.BAD_FIELD);
        });

        it('fails due to long username', async function () {
            const user = Object.assign({}, ADMIN, { username: new Array(257).fill('Z').join('') });
            const [error] = await safe(users.add(user.email, user, AUDIT_SOURCE));
            expect(error.reason).to.equal(BoxError.BAD_FIELD);
        });

        it('fails due to reserved app pattern', async function () {
            const user = Object.assign({}, ADMIN, { username: 'maybe.app' });
            const [error] = await safe(users.add(user.email, user, AUDIT_SOURCE));
            expect(error.reason).to.equal(BoxError.BAD_FIELD);
        });

        it('fails because password is empty', async function () {
            const user = Object.assign({}, ADMIN, { password: '' });
            const [error] = await safe(users.add(user.email, user, AUDIT_SOURCE));
            expect(error.reason).to.equal(BoxError.BAD_FIELD);
        });

        it('can add user', async function () {
            const id = await users.add(ADMIN.email, ADMIN, AUDIT_SOURCE);
            ADMIN.id = id;
        });

        it('cannot add user with same email again', async function () {
            const [error] = await safe(users.add(ADMIN.email, ADMIN, AUDIT_SOURCE));
            expect(error.reason).to.be(BoxError.ALREADY_EXISTS);
            expect(error.message).to.equal('email already exists');
        });

        it('cannot add user with same username again', async function () {
            const [error] = await safe(users.add('somethingelse@not.taken', ADMIN, AUDIT_SOURCE));
            expect(error.reason).to.be(BoxError.ALREADY_EXISTS);
            expect(error.message).to.equal('username already exists');
        });
    });

    describe('get', function () {
        it('can get by user id', async function () {
            const result = await users.get(ADMIN.id);
            checkUser(result, ADMIN);
        });

        it('cannot get by bad user id', async function () {
            const result = await users.get('random');
            expect(result).to.be(null);
        });

        it('can get by user name', async function () {
            const result = await users.getByUsername(ADMIN.username);
            checkUser(result, ADMIN);
        });

        it('can get by email', async function () {
            const result = await users.getByEmail(ADMIN.email);
            checkUser(result, ADMIN);
        });
    });

    // describe('user', function () {


    //     it('getByResetToken fails for empty resetToken', function (done) {
    //         userdb.getByResetToken('', function (error, user) {
    //             expect(error).to.be.ok();
    //             expect(error.reason).to.be(BoxError.NOT_FOUND);
    //             expect(user).to.not.be.ok();
    //             done();
    //         });
    //     });

    //     it('getByResetToken fails for invalid resetToken', function (done) {
    //         userdb.getByResetToken('invalid', function (error, user) {
    //             expect(error).to.be.ok();
    //             expect(error.reason).to.be(BoxError.NOT_FOUND);
    //             expect(user).to.not.be.ok();
    //             done();
    //         });
    //     });

    //     it('can get by resetToken', function (done) {
    //         userdb.getByResetToken(USER_0.resetToken, function (error, user) {
    //             expect(error).to.not.be.ok();

    //             validateUser(user, USER_0);

    //             done();
    //         });
    //     });

    //     it('can get all with group ids', function (done) {
    //         userdb.getAllWithGroupIds(function (error, all) {
    //             expect(error).to.not.be.ok();
    //             expect(all.length).to.equal(3);

    //             var userCopy;

    //             userCopy = _.extend({}, USER_0);
    //             userCopy.groupIds = [ ];
    //             validateUser(all[0], userCopy);

    //             userCopy = _.extend({}, USER_1);
    //             userCopy.groupIds = [ ];
    //             validateUser(all[1], userCopy);

    //             userCopy = _.extend({}, USER_2);
    //             userCopy.groupIds = [ ];
    //             validateUser(all[2], userCopy);

    //             done();
    //         });
    //     });

    //     it('can get all with group ids paged', function (done) {
    //         userdb.getAllWithGroupIdsPaged(null, 1, 2, function (error, all) {
    //             expect(error).to.not.be.ok();
    //             expect(all.length).to.equal(2);

    //             var userCopy;

    //             userCopy = _.extend({}, USER_0);
    //             userCopy.groupIds = [];
    //             validateUser(all[0], userCopy);

    //             userCopy = _.extend({}, USER_1);
    //             userCopy.groupIds = [];
    //             validateUser(all[1], userCopy);

    //             userdb.getAllWithGroupIdsPaged(null, 2, 2, function (error, all) {
    //                 expect(error).to.not.be.ok();
    //                 expect(all.length).to.equal(1);

    //                 var userCopy;

    //                 userCopy = _.extend({}, USER_2);
    //                 userCopy.groupIds = [];
    //                 validateUser(all[0], userCopy);

    //                 done();
    //             });
    //         });
    //     });

    //     it('can get all with group ids paged and search', function (done) {
    //         userdb.getAllWithGroupIdsPaged('id1', 1, 2, function (error, all) {
    //             expect(error).to.not.be.ok();
    //             expect(all.length).to.equal(1);

    //             var userCopy;

    //             userCopy = _.extend({}, USER_1);
    //             userCopy.groupIds = [];
    //             validateUser(all[0], userCopy);

    //             done();
    //         });
    //     });

    //     it('can get all admins', function (done) {
    //         userdb.getByRole('owner', function (error) {
    //             expect(error).to.be.ok();
    //             expect(error.reason).to.be(BoxError.NOT_FOUND);
    //             done();
    //         });
    //     });

    //     it('counts the users', function (done) {
    //         userdb.count(function (error, count) {
    //             expect(error).to.not.be.ok();
    //             expect(count).to.equal(3);
    //             done();
    //         });
    //     });

    //     it('can get all users', function (done) {
    //         userdb.getByRole('user', function (error, all) {
    //             expect(error).to.not.be.ok();
    //             expect(all.length).to.equal(3);
    //             done();
    //         });
    //     });

    //     it('can update the user', function (done) {
    //         userdb.update(USER_0.id, { email: 'some@thing.com', displayName: 'Heiter' }, function (error) {
    //             expect(error).to.not.be.ok();
    //             userdb.get(USER_0.id, function (error, user) {
    //                 expect(user.email).to.equal('some@thing.com');
    //                 expect(user.displayName).to.equal('Heiter');
    //                 done();
    //             });
    //         });
    //     });

    //     it('can update the user with already existing email', function (done) {
    //         userdb.update(USER_0.id, { email: USER_2.email }, function (error) {
    //             expect(error).to.be.ok();
    //             expect(error.reason).to.be(BoxError.ALREADY_EXISTS);
    //             expect(error.message).to.equal('email already exists');
    //             done();
    //         });
    //     });

    //     it('can update the user with already existing username', function (done) {
    //         userdb.update(USER_0.id, { username: USER_2.username }, function (error) {
    //             expect(error).to.be.ok();
    //             expect(error.reason).to.be(BoxError.ALREADY_EXISTS);
    //             expect(error.message).to.equal('username already exists');
    //             done();
    //         });
    //     });

    //     it('cannot update with null field', function () {
    //         expect(function () {
    //             userdb.update(USER_0.id, { email: null }, function () {});
    //         }).to.throwError();
    //     });
    // });

    describe('getOwner', function() {
        before(cleanupUsers);

        it('fails because there is no owner', async function () {
            const owner = await users.getOwner();
            expect(owner).to.be(null);
        });

        it('getOwner succeeds', async function () {
            const id = await users.add(ADMIN.email, ADMIN, AUDIT_SOURCE);
            ADMIN.id = id;
            const owner = await users.getOwner();
            checkUser(owner, ADMIN);
        });

        it('getSuperadmins succeeds', async function () {
            const results = await users.getSuperadmins();
            expect(results.length).to.be(1);
            checkUser(results[0], ADMIN);
        });

        it('getAdmins succeeds', async function () {
            const results = await users.getAdmins();
            expect(results.length).to.be(1);
            checkUser(results[0], ADMIN);
        });
    });

    describe('verify', function () {
        before(createOwner);

        it('fails due to non existing user', async function () {
            const [error] = await safe(users.verify('somerandomid', 'somepassword', users.AP_WEBADMIN));
            expect(error.reason).to.equal(BoxError.NOT_FOUND);
        });

        it('fails due to empty password', async function () {
            const [error] = await safe(users.verify(ADMIN.id, '', users.AP_WEBADMIN));
            expect(error.reason).to.equal(BoxError.INVALID_CREDENTIALS);
        });

        it('fails due to wrong password', async function () {
            const [error] = await safe(users.verify(ADMIN.id, ADMIN.password+'x', users.AP_WEBADMIN));
            expect(error.reason).to.equal(BoxError.INVALID_CREDENTIALS);
        });

        it('succeeds', async function () {
            const result = await users.verify(ADMIN.id, ADMIN.password, users.AP_WEBADMIN);
            expect(result).to.be.ok();
            expect(result.appPassword).to.not.be.ok();
            expect(result.ghost).to.not.be.ok();
        });

        it('fails for ghost if not enabled', async function () {
            const [error] = await safe(users.verify(ADMIN.id, 'foobar', users.AP_WEBADMIN));
            expect(error.reason).to.equal(BoxError.INVALID_CREDENTIALS);
        });

        it('fails for ghost with wrong password', async function () {
            let ghost = { };
            ghost[ADMIN.username] = 'testpassword';
            await fs.promises.writeFile(paths.GHOST_USER_FILE, JSON.stringify(ghost), 'utf8');

            const [error] = await safe(users.verify(ADMIN.id, 'foobar', users.AP_WEBADMIN));
            await fs.promises.unlink(paths.GHOST_USER_FILE);

            expect(error.reason).to.equal(BoxError.INVALID_CREDENTIALS);
        });

        it('succeeds for ghost', async function () {
            let ghost = { };
            ghost[ADMIN.username] = 'testpassword';
            await fs.promises.writeFile(paths.GHOST_USER_FILE, JSON.stringify(ghost), 'utf8');

            const result = await users.verify(ADMIN.id, 'testpassword', users.AP_WEBADMIN);
            if (fs.existsSync(paths.GHOST_USER_FILE)) throw new Error('Ghost file exists after verification');

            expect(result.id).to.equal(ADMIN.id);
            expect(result.ghost).to.be(true);
        });

        it('succeeds for normal user password when ghost file exists', async function () {
            let ghost = { };
            ghost[ADMIN.username] = 'testpassword';
            fs.writeFileSync(paths.GHOST_USER_FILE, JSON.stringify(ghost), 'utf8');

            const result = await users.verify(ADMIN.id, ADMIN.password, users.AP_WEBADMIN);
            if (!fs.existsSync(paths.GHOST_USER_FILE)) throw new Error('Ghost file went way without verification');

            expect(result.id).to.equal(ADMIN.id);
            expect(result.ghost).to.not.be.ok();
        });
    });

    describe('verifyWithUsername', function () {
        before(createOwner);

        it('fails due to non existing username', async function () {
            const [error] = await safe(users.verifyWithUsername('someusername', 'somepass', users.AP_WEBADMIN));
            expect(error.reason).to.equal(BoxError.NOT_FOUND);
        });

        it('fails due to empty password', async function () {
            const [error] = await safe(users.verifyWithUsername(ADMIN.username, '', users.AP_WEBADMIN));
            expect(error.reason).to.equal(BoxError.INVALID_CREDENTIALS);
        });

        it('fails due to wrong password', async function () {
            const [error] = await safe(users.verifyWithUsername(ADMIN.username, 'somepass', users.AP_WEBADMIN));
            expect(error.reason).to.equal(BoxError.INVALID_CREDENTIALS);
        });

        it('succeeds', async function () {
            const result = await users.verifyWithUsername(ADMIN.username, ADMIN.password, users.AP_WEBADMIN);
            expect(result.id).to.equal(ADMIN.id);
        });

        it('succeeds for different username case', async function () {
            const result = await users.verifyWithUsername(ADMIN.username.toUpperCase(), ADMIN.password, users.AP_WEBADMIN);
            expect(result.id).to.equal(ADMIN.id);
        });

        it('fails for ghost with wrong password', async function () {
            let ghost = { };
            ghost[ADMIN.username] = 'testpassword';

            fs.writeFileSync(paths.GHOST_USER_FILE, JSON.stringify(ghost), 'utf8');

            const [error] = await safe(users.verifyWithUsername(ADMIN.username, 'foobar', users.AP_WEBADMIN));
            if (!fs.existsSync(paths.GHOST_USER_FILE)) throw new Error('Ghost file went way without verification');
            fs.unlinkSync(paths.GHOST_USER_FILE);

            console.log(error);
            expect(error.reason).to.equal(BoxError.INVALID_CREDENTIALS);
        });

        it('succeeds for ghost', async function () {
            let ghost = { };
            ghost[ADMIN.username] = 'testpassword';

            fs.writeFileSync(paths.GHOST_USER_FILE, JSON.stringify(ghost), 'utf8');

            const result = await users.verifyWithUsername(ADMIN.username, 'testpassword', users.AP_WEBADMIN);
            if (fs.existsSync(paths.GHOST_USER_FILE)) throw new Error('Ghost file still around!');
            expect(result.id).to.equal(ADMIN.id);
            expect(result.ghost).to.be(true);
        });
    });

    describe('verifyWithEmail', function () {
        before(createOwner);

        it('fails due to non existing user', async function () {
            const [error] = await safe(users.verifyWithEmail('bad@email.com', ADMIN.password, users.AP_WEBADMIN));
            expect(error.reason).to.equal(BoxError.NOT_FOUND);
        });

        it('fails due to empty password', async function () {
            const [error] = await safe(users.verifyWithEmail(ADMIN.email, '', users.AP_WEBADMIN));
            expect(error.reason).to.equal(BoxError.INVALID_CREDENTIALS);
        });

        it('fails due to wrong password', async function () {
            const [error] = await safe(users.verifyWithEmail(ADMIN.email, 'badpassword', users.AP_WEBADMIN));
            expect(error.reason).to.equal(BoxError.INVALID_CREDENTIALS);
        });

        it('succeeds', async function () {
            const result = await users.verifyWithEmail(ADMIN.email, ADMIN.password, users.AP_WEBADMIN);
            expect(result.id).to.be(ADMIN.id);
        });

        it('succeeds for different email case', async function () {
            const result = await users.verifyWithEmail(ADMIN.email.toUpperCase(), ADMIN.password, users.AP_WEBADMIN);
            expect(result.id).to.be(ADMIN.id);
        });

        it('fails for ghost with wrong password', async function () {
            let ghost = { };
            ghost[ADMIN.username] = 'testpassword';

            fs.writeFileSync(paths.GHOST_USER_FILE, JSON.stringify(ghost), 'utf8');

            const [error] = await safe(users.verifyWithEmail(ADMIN.email, 'foobar', users.AP_WEBADMIN));
            if (!fs.existsSync(paths.GHOST_USER_FILE)) throw new Error('Ghost file not found after failed login!');
            fs.unlinkSync(paths.GHOST_USER_FILE);

            expect(error.reason).to.equal(BoxError.INVALID_CREDENTIALS);
        });

        it('succeeds for ghost', async function () {
            let ghost = { };
            ghost[ADMIN.username] = 'testpassword';

            fs.writeFileSync(paths.GHOST_USER_FILE, JSON.stringify(ghost), 'utf8');

            const result = await users.verifyWithEmail(ADMIN.email, 'testpassword', users.AP_WEBADMIN);
            if (fs.existsSync(paths.GHOST_USER_FILE)) throw new Error('Ghost file still around!');

            expect(result.id).to.equal(ADMIN.id);
            expect(result.ghost).to.equal(true);
        });
    });

    // describe('active', function () {
    //     before(createOwner);
    //     after(cleanupUsers);

    //     it('verify fails for inactive user', function (done) {
    //         users.update(userObject, { active: false }, AUDIT_SOURCE, function (error) {
    //             expect(error).to.not.be.ok();

    //             users.verify(userObject.id, PASSWORD, users.AP_WEBADMIN, function (error) {
    //                 expect(error).to.be.ok();
    //                 expect(error.reason).to.equal(BoxError.NOT_FOUND);

    //                 done();
    //             });
    //         });
    //     });

    //     it('verify succeeds for inactive user', function (done) {
    //         users.update(userObject, { active: true }, AUDIT_SOURCE, function (error) {
    //             expect(error).to.not.be.ok();

    //             users.verify(userObject.id, PASSWORD, users.AP_WEBADMIN, function (error) {
    //                 expect(error).to.not.be.ok();

    //                 done();
    //             });
    //         });
    //     });
    // });

    // describe('retrieving', function () {
    //     before(createOwner);
    //     after(cleanupUsers);

    //     it('fails due to non existing user', function (done) {
    //         users.get('some non existing username', function (error, result) {
    //             expect(error).to.be.ok();
    //             expect(result).to.not.be.ok();

    //             done();
    //         });
    //     });

    //     it('succeeds', function (done) {
    //         users.get(userObject.id, function (error, result) {
    //             expect(error).to.not.be.ok();
    //             expect(result).to.be.ok();
    //             expect(result.id).to.equal(userObject.id);
    //             expect(result.email).to.equal(EMAIL.toLowerCase());
    //             expect(result.fallbackEmail).to.equal(EMAIL.toLowerCase());
    //             expect(result.username).to.equal(USERNAME.toLowerCase());
    //             expect(result.displayName).to.equal(DISPLAY_NAME);

    //             done();
    //         });
    //     });
    // });

    // describe('update', function () {
    //     before(createOwner);
    //     after(cleanupUsers);

    //     it('fails due to unknown userid', function (done) {
    //         var data = { username: USERNAME_NEW, email: EMAIL_NEW, displayName: DISPLAY_NAME_NEW };
    //         users.update(_.extend({}, userObject, { id: 'random' }), data, AUDIT_SOURCE, function (error) {
    //             expect(error).to.be.a(BoxError);
    //             expect(error.reason).to.equal(BoxError.NOT_FOUND);

    //             done();
    //         });
    //     });

    //     it('fails due to invalid email', function (done) {
    //         var data = { username: USERNAME_NEW, email: 'brokenemailaddress', displayName: DISPLAY_NAME_NEW };
    //         users.update(userObject, data, AUDIT_SOURCE, function (error) {
    //             expect(error).to.be.a(BoxError);
    //             expect(error.reason).to.equal(BoxError.BAD_FIELD);

    //             done();
    //         });
    //     });

    //     it('succeeds', function (done) {
    //         var data = { username: USERNAME_NEW, email: EMAIL_NEW, displayName: DISPLAY_NAME_NEW };

    //         users.update(userObject, data, AUDIT_SOURCE, function (error) {
    //             expect(error).to.not.be.ok();

    //             users.get(userObject.id, function (error, result) {
    //                 expect(error).to.not.be.ok();
    //                 expect(result).to.be.ok();
    //                 expect(result.email).to.equal(EMAIL_NEW.toLowerCase());
    //                 expect(result.username).to.equal(USERNAME_NEW.toLowerCase());
    //                 expect(result.displayName).to.equal(DISPLAY_NAME_NEW);

    //                 done();
    //             });
    //         });
    //     });

    //     it('succeeds with same data', function (done) {
    //         var data = { username: USERNAME_NEW, email: EMAIL_NEW, displayName: DISPLAY_NAME_NEW };

    //         users.update(userObject, data, AUDIT_SOURCE, function (error) {
    //             expect(error).to.not.be.ok();

    //             users.get(userObject.id, function (error, result) {
    //                 expect(error).to.not.be.ok();
    //                 expect(result).to.be.ok();
    //                 expect(result.email).to.equal(EMAIL_NEW.toLowerCase());
    //                 expect(result.username).to.equal(USERNAME_NEW.toLowerCase());
    //                 expect(result.displayName).to.equal(DISPLAY_NAME_NEW);

    //                 done();
    //             });
    //         });
    //     });
    // });

    // describe('get admins', function () {
    //     before(createOwner);
    //     after(cleanupUsers);

    //     it('succeeds for one admins', function (done) {
    //         users.getAdmins(function (error, admins) {
    //             expect(error).to.eql(null);
    //             expect(admins.length).to.equal(1);
    //             expect(admins[0].username).to.equal(USERNAME.toLowerCase());
    //             done();
    //         });
    //     });

    //     it('succeeds for two admins', function (done) {
    //         var user1 = {
    //             username: 'seconduser',
    //             password: 'Adfasdkjf#$%43',
    //             email: 'some@thi.ng',
    //             role: users.ROLE_ADMIN
    //         };

    //         users.create(user1.username, user1.password, user1.email, DISPLAY_NAME, { role: users.ROLE_ADMIN }, AUDIT_SOURCE, function (error, result) {
    //             expect(error).to.not.be.ok();
    //             expect(result).to.be.ok();

    //             user1.id = result.id;

    //             users.update(user1, { role: users.ROLE_ADMIN }, AUDIT_SOURCE, function (error) {
    //                 expect(error).to.eql(null);

    //                 users.getAdmins(function (error, admins) {
    //                     expect(error).to.eql(null);
    //                     expect(admins.length).to.equal(2);
    //                     expect(admins[0].username).to.equal(USERNAME.toLowerCase());
    //                     expect(admins[1].username).to.equal(user1.username.toLowerCase());

    //                     done();
    //                 });
    //             });
    //         });
    //     });
    // });

    // describe('activated', function () {
    //     after(cleanupUsers);

    //     it('succeeds with no users', function (done) {
    //         users.isActivated(function (error, activated) {
    //             expect(error).to.not.be.ok();
    //             expect(activated).to.be(false);
    //             done();
    //         });
    //     });

    //     it('create users', function (done) {
    //         createOwner(done);
    //     });

    //     it('succeeds with users', function (done) {
    //         users.isActivated(function (error, activated) {
    //             expect(error).to.not.be.ok();
    //             expect(activated).to.be(true);
    //             done();
    //         });
    //     });
    // });

    // describe('set password', function () {
    //     before(createOwner);
    //     after(cleanupUsers);

    //     it('fails due to unknown user', function (done) {
    //         users.setPassword(_.extend({}, userObject, { id: 'doesnotexist' }), NEW_PASSWORD, function (error) {
    //             expect(error).to.be.ok();
    //             done();
    //         });
    //     });

    //     it('fails due to empty password', function (done) {
    //         users.setPassword(userObject, '', function (error) {
    //             expect(error).to.be.ok();
    //             done();
    //         });
    //     });

    //     it('fails due to invalid password', function (done) {
    //         users.setPassword(userObject, 'foobar', function (error) {
    //             expect(error).to.be.ok();
    //             done();
    //         });
    //     });

    //     it('succeeds', function (done) {
    //         users.setPassword(userObject, NEW_PASSWORD, function (error) {
    //             expect(error).to.not.be.ok();
    //             done();
    //         });
    //     });

    //     it('actually changed the password (unable to login with old pasword)', function (done) {
    //         users.verify(userObject.id, PASSWORD, users.AP_WEBADMIN, function (error, result) {
    //             expect(error).to.be.ok();
    //             expect(result).to.not.be.ok();
    //             expect(error.reason).to.equal(BoxError.INVALID_CREDENTIALS);
    //             done();
    //         });
    //     });

    //     it('actually changed the password (login with new password)', function (done) {
    //         users.verify(userObject.id, NEW_PASSWORD, users.AP_WEBADMIN, function (error, result) {
    //             expect(error).to.not.be.ok();
    //             expect(result).to.be.ok();
    //             done();
    //         });
    //     });
    // });

    // describe('sendPasswordResetByIdentifier', function () {
    //     before(createOwner);
    //     after(cleanupUsers);

    //     it('fails due to unkown email', function (done) {
    //         users.sendPasswordResetByIdentifier('unknown@mail.com', function (error) {
    //             expect(error).to.be.an(BoxError);
    //             expect(error.reason).to.eql(BoxError.NOT_FOUND);
    //             done();
    //         });
    //     });

    //     it('fails due to unkown username', function (done) {
    //         users.sendPasswordResetByIdentifier('unknown', function (error) {
    //             expect(error).to.be.an(BoxError);
    //             expect(error.reason).to.eql(BoxError.NOT_FOUND);
    //             done();
    //         });
    //     });

    //     it('succeeds with email', function (done) {
    //         users.sendPasswordResetByIdentifier(EMAIL, function (error) {
    //             expect(error).to.not.be.ok();
    //             checkMails(1, done);
    //         });
    //     });

    //     it('succeeds with username', function (done) {
    //         users.sendPasswordResetByIdentifier(USERNAME, function (error) {
    //             expect(error).to.not.be.ok();
    //             checkMails(1, done);
    //         });
    //     });
    // });

    // describe('invite', function () {
    //     before(createOwner);
    //     after(cleanupUsers);

    //     it('fails as expected', function (done) {
    //         users.sendInvite(userObject, { }, function (error) {
    //             expect(error).to.be.ok(); // have to create resetToken first
    //             done();
    //         });
    //     });

    //     it('can create token', function (done) {
    //         users.createInvite(userObject, function (error, resetToken) {
    //             expect(error).to.be(null);
    //             expect(resetToken).to.be.ok();
    //             done();
    //         });
    //     });

    //     it('send invite', function (done) {
    //         users.sendInvite(userObject, { }, function (error) {
    //             expect(error).to.be(null);
    //             checkMails(1, done);
    //         });
    //     });
    // });

    // describe('remove', function () {
    //     before(createOwner);
    //     after(cleanupUsers);

    //     it('fails for unknown user', async function () {
    //         const [error] = await safe(users.del(_.extend({}, userObject, { id: 'unknown' }), AUDIT_SOURCE));
    //         expect(error.reason).to.be(BoxError.NOT_FOUND);
    //     });

    //     it('can remove valid user', async function () {
    //         await users.del(userObject, AUDIT_SOURCE);
    //     });

    //     it('can re-create user after user was removed', createOwner);
    // });
});