mattermost-webapp/utils/utils.test.jsx

// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.
import {GeneralTypes} from 'mattermost-redux/action_types';

import * as Utils from 'utils/utils.jsx';
import store from 'stores/redux_store.jsx';

describe('Utils.getDisplayNameByUser', () => {
    afterEach(() => {
        store.dispatch({
            type: GeneralTypes.CLIENT_CONFIG_RESET,
            data: {},
        });
    });

    const userA = {username: 'a_user', nickname: 'a_nickname', first_name: 'a_first_name', last_name: ''};
    const userB = {username: 'b_user', nickname: 'b_nickname', first_name: '', last_name: 'b_last_name'};
    const userC = {username: 'c_user', nickname: '', first_name: 'c_first_name', last_name: 'c_last_name'};
    const userD = {username: 'd_user', nickname: 'd_nickname', first_name: 'd_first_name', last_name: 'd_last_name'};
    const userE = {username: 'e_user', nickname: '', first_name: 'e_first_name', last_name: 'e_last_name'};
    const userF = {username: 'f_user', nickname: 'f_nickname', first_name: 'f_first_name', last_name: 'f_last_name'};
    const userG = {username: 'g_user', nickname: '', first_name: 'g_first_name', last_name: 'g_last_name'};
    const userH = {username: 'h_user', nickname: 'h_nickname', first_name: '', last_name: 'h_last_name'};
    const userI = {username: 'i_user', nickname: 'i_nickname', first_name: 'i_first_name', last_name: ''};
    const userJ = {username: 'j_user', nickname: '', first_name: 'j_first_name', last_name: ''};

    test('Show display name of user with TeammateNameDisplay set to username', () => {
        store.dispatch({
            type: GeneralTypes.CLIENT_CONFIG_RECEIVED,
            data: {
                TeammateNameDisplay: 'username',
            },
        });

        [userA, userB, userC, userD, userE, userF, userG, userH, userI, userJ].forEach((user) => {
            expect(Utils.getDisplayNameByUser(user)).toEqual(user.username);
        });
    });

    test('Show display name of user with TeammateNameDisplay set to nickname_full_name', () => {
        store.dispatch({
            type: GeneralTypes.CLIENT_CONFIG_RECEIVED,
            data: {
                TeammateNameDisplay: 'nickname_full_name',
            },
        });

        for (const data of [
            {user: userA, result: userA.nickname},
            {user: userB, result: userB.nickname},
            {user: userC, result: `${userC.first_name} ${userC.last_name}`},
            {user: userD, result: userD.nickname},
            {user: userE, result: `${userE.first_name} ${userE.last_name}`},
            {user: userF, result: userF.nickname},
            {user: userG, result: `${userG.first_name} ${userG.last_name}`},
            {user: userH, result: userH.nickname},
            {user: userI, result: userI.nickname},
            {user: userJ, result: userJ.first_name},
        ]) {
            expect(Utils.getDisplayNameByUser(data.user)).toEqual(data.result);
        }
    });

    test('Show display name of user with TeammateNameDisplay set to username', () => {
        store.dispatch({
            type: GeneralTypes.CLIENT_CONFIG_RECEIVED,
            data: {
                TeammateNameDisplay: 'full_name',
            },
        });

        for (const data of [
            {user: userA, result: userA.first_name},
            {user: userB, result: userB.last_name},
            {user: userC, result: `${userC.first_name} ${userC.last_name}`},
            {user: userD, result: `${userD.first_name} ${userD.last_name}`},
            {user: userE, result: `${userE.first_name} ${userE.last_name}`},
            {user: userF, result: `${userF.first_name} ${userF.last_name}`},
            {user: userG, result: `${userG.first_name} ${userG.last_name}`},
            {user: userH, result: userH.last_name},
            {user: userI, result: userI.first_name},
            {user: userJ, result: userJ.first_name},
        ]) {
            expect(Utils.getDisplayNameByUser(data.user)).toEqual(data.result);
        }
    });
});

describe('Utils.sortUsersByStatusAndDisplayName', () => {
    afterEach(() => {
        store.dispatch({
            type: GeneralTypes.CLIENT_CONFIG_RESET,
            data: {},
        });
    });

    const userA = {id: 'a', username: 'a_user', nickname: 'ja_nickname', first_name: 'a_first_name', last_name: 'ja_last_name'};
    const userB = {id: 'b', username: 'b_user', nickname: 'ib_nickname', first_name: 'a_first_name', last_name: 'ib_last_name'};
    const userC = {id: 'c', username: 'c_user', nickname: 'hc_nickname', first_name: 'a_first_name', last_name: 'hc_last_name'};
    const userD = {id: 'd', username: 'd_user', nickname: 'gd_nickname', first_name: 'a_first_name', last_name: 'gd_last_name'};
    const userE = {id: 'e', username: 'e_user', nickname: 'fe_nickname', first_name: 'b_first_name', last_name: 'fe_last_name'};
    const userF = {id: 'f', username: 'f_user', nickname: 'ef_nickname', first_name: 'b_first_name', last_name: 'ef_last_name'};
    const userG = {id: 'g', username: 'g_user', nickname: 'dg_nickname', first_name: 'b_first_name', last_name: 'dg_last_name'};
    const userH = {id: 'h', username: 'h_user', nickname: 'ch_nickname', first_name: 'c_first_name', last_name: 'ch_last_name'};
    const userI = {id: 'i', username: 'i_user', nickname: 'bi_nickname', first_name: 'c_first_name', last_name: 'bi_last_name'};
    const userJ = {id: 'j', username: 'j_user', nickname: 'aj_nickname', first_name: 'c_first_name', last_name: 'aj_last_name'};
    const statusesByUserId = {
        a: 'dnd',
        b: 'away',
        c: 'offline',
        d: 'online',
        e: 'online',
        f: 'online',
        g: 'dnd',
        h: 'away',
        i: 'offline',
        j: 'online',
    };

    test('Users sort by status and displayname, TeammateNameDisplay set to username', () => {
        store.dispatch({
            type: GeneralTypes.CLIENT_CONFIG_RECEIVED,
            data: {
                TeammateNameDisplay: 'username',
            },
        });

        for (const data of [
            {
                users: [userF, userA, userB, userC, userD, userE],
                result: [userD, userE, userF, userB, userA, userC],
            },
            {
                users: [userJ, userI, userH, userG, userF, userE],
                result: [userE, userF, userJ, userH, userG, userI],
            },
            {
                users: [userJ, userF, userE, userD],
                result: [userD, userE, userF, userJ],
            },
        ]) {
            const sortedUsers = Utils.sortUsersByStatusAndDisplayName(data.users, statusesByUserId);
            for (let i = 0; i < sortedUsers.length; i++) {
                expect(sortedUsers[i]).toEqual(data.result[i]);
            }
        }
    });

    test('Users sort by status and displayname, TeammateNameDisplay set to nickname_full_name', () => {
        store.dispatch({
            type: GeneralTypes.CLIENT_CONFIG_RECEIVED,
            data: {
                TeammateNameDisplay: 'nickname_full_name',
            },
        });

        for (const data of [
            {
                users: [userF, userA, userB, userC, userD, userE],
                result: [userF, userE, userD, userB, userA, userC],
            },
            {
                users: [userJ, userI, userH, userG, userF, userE],
                result: [userJ, userF, userE, userH, userG, userI],
            },
            {
                users: [userJ, userF, userE, userD],
                result: [userJ, userF, userE, userD],
            },
        ]) {
            const sortedUsers = Utils.sortUsersByStatusAndDisplayName(data.users, statusesByUserId);
            for (let i = 0; i < sortedUsers.length; i++) {
                expect(sortedUsers[i]).toEqual(data.result[i]);
            }
        }
    });

    test('Users sort by status and displayname, TeammateNameDisplay set to full_name', () => {
        store.dispatch({
            type: GeneralTypes.CLIENT_CONFIG_RECEIVED,
            data: {
                TeammateNameDisplay: 'full_name',
            },
        });

        for (const data of [
            {
                users: [userF, userA, userB, userC, userD, userE],
                result: [userD, userF, userE, userB, userA, userC],
            },
            {
                users: [userJ, userI, userH, userG, userF, userE],
                result: [userF, userE, userJ, userH, userG, userI],
            },
            {
                users: [userJ, userF, userE, userD],
                result: [userD, userF, userE, userJ],
            },
        ]) {
            const sortedUsers = Utils.sortUsersByStatusAndDisplayName(data.users, statusesByUserId);
            for (let i = 0; i < sortedUsers.length; i++) {
                expect(sortedUsers[i]).toEqual(data.result[i]);
            }
        }
    });
});

describe('Utils.isValidPassword', () => {
    test('Minimum length enforced', () => {
        for (const data of [
            {
                password: 'tooshort',
                config: {
                    minimumLength: 10,
                    requireLowercase: false,
                    requireUppercase: false,
                    requireNumber: false,
                    requireSymbol: false,
                },
                valid: false,
            },
            {
                password: 'longenoughpassword',
                config: {
                    minimumLength: 10,
                    requireLowercase: false,
                    requireUppercase: false,
                    requireNumber: false,
                    requireSymbol: false,
                },
                valid: true,
            },
        ]) {
            const {valid} = Utils.isValidPassword(data.password, data.config);
            expect(data.valid).toEqual(valid);
        }
    });

    test('Require lowercase enforced', () => {
        for (const data of [
            {
                password: 'UPPERCASE',
                config: {
                    minimumLength: 5,
                    requireLowercase: true,
                    requireUppercase: false,
                    requireNumber: false,
                    requireSymbol: false,
                },
                valid: false,
            },
            {
                password: 'SOMELowercase',
                config: {
                    minimumLength: 5,
                    requireLowercase: true,
                    requireUppercase: false,
                    requireNumber: false,
                    requireSymbol: false,
                },
                valid: true,
            },
        ]) {
            const {valid} = Utils.isValidPassword(data.password, data.config);
            expect(data.valid).toEqual(valid);
        }
    });

    test('Require uppercase enforced', () => {
        for (const data of [
            {
                password: 'lowercase',
                config: {
                    minimumLength: 5,
                    requireLowercase: false,
                    requireUppercase: true,
                    requireNumber: false,
                    requireSymbol: false,
                },
                valid: false,
            },
            {
                password: 'SOMEUppercase',
                config: {
                    minimumLength: 5,
                    requireLowercase: false,
                    requireUppercase: true,
                    requireNumber: false,
                    requireSymbol: false,
                },
                valid: true,
            },
        ]) {
            const {valid} = Utils.isValidPassword(data.password, data.config);
            expect(data.valid).toEqual(valid);
        }
    });

    test('Require number enforced', () => {
        for (const data of [
            {
                password: 'NoNumbers',
                config: {
                    minimumLength: 5,
                    requireLowercase: true,
                    requireUppercase: true,
                    requireNumber: true,
                    requireSymbol: false,
                },
                valid: false,
            },
            {
                password: 'S0m3Numb3rs',
                config: {
                    minimumLength: 5,
                    requireLowercase: true,
                    requireUppercase: true,
                    requireNumber: true,
                    requireSymbol: false,
                },
                valid: true,
            },
        ]) {
            const {valid} = Utils.isValidPassword(data.password, data.config);
            expect(data.valid).toEqual(valid);
        }
    });

    test('Require symbol enforced', () => {
        for (const data of [
            {
                password: 'N0Symb0ls',
                config: {
                    minimumLength: 5,
                    requireLowercase: true,
                    requireUppercase: true,
                    requireNumber: true,
                    requireSymbol: true,
                },
                valid: false,
            },
            {
                password: 'S0m3Symb0!s',
                config: {
                    minimumLength: 5,
                    requireLowercase: true,
                    requireUppercase: true,
                    requireNumber: true,
                    requireSymbol: true,
                },
                valid: true,
            },
        ]) {
            const {valid} = Utils.isValidPassword(data.password, data.config);
            expect(data.valid).toEqual(valid);
        }
    });
});

describe('Utils.isKeyPressed', () => {
    test('Key match is used over keyCode if it exists', () => {
        for (const data of [
            {
                event: new KeyboardEvent('keydown', {key: '/', keyCode: 55}),
                key: ['/', 191, 'Slash'],
                valid: true,
            },
            {
                event: new KeyboardEvent('keydown', {key: 'ù', keyCode: 191}),
                key: ['/', 191, 'Slash'],
                valid: true,
            },
        ]) {
            expect(Utils.isKeyPressed(data.event, data.key)).toEqual(data.valid);
        }
    });

    test('Key match works for both uppercase and lower case', () => {
        for (const data of [
            {
                event: new KeyboardEvent('keydown', {key: 'A', keyCode: 65, code: 'KeyA'}),
                key: ['a', 65, 'KeyA'],
                valid: true,
            },
            {
                event: new KeyboardEvent('keydown', {key: 'a', keyCode: 65, code: 'KeyA'}),
                key: ['a', 65, 'KeyA'],
                valid: true,
            },
        ]) {
            expect(Utils.isKeyPressed(data.event, data.key)).toEqual(data.valid);
        }
    });

    test('KeyCode is used for dead letter keys', () => {
        for (const data of [
            {
                event: new KeyboardEvent('keydown', {key: 'Dead', keyCode: 222}),
                key: ['', 222],
                valid: true,
            },
            {
                event: new KeyboardEvent('keydown', {key: 'Dead', keyCode: 222}),
                key: ['not-used-field', 222],
                valid: true,
            },
            {
                event: new KeyboardEvent('keydown', {key: 'Dead', keyCode: 222}),
                key: [null, 222],
                valid: true,
            },
            {
                event: new KeyboardEvent('keydown', {key: 'Dead', keyCode: 222}),
                key: [null, 223],
                valid: false,
            },
        ]) {
            expect(Utils.isKeyPressed(data.event, data.key)).toEqual(data.valid);
        }
    });

    test('KeyCode is used for unidentified keys', () => {
        for (const data of [
            {
                event: new KeyboardEvent('keydown', {key: 'Unidentified', keyCode: 2220, code: 'Unidentified'}),
                key: ['', 2220],
                valid: true,
            },
            {
                event: new KeyboardEvent('keydown', {key: 'Unidentified', keyCode: 2220, code: 'Unidentified'}),
                key: ['not-used-field', 2220],
                valid: true,
            },
            {
                event: new KeyboardEvent('keydown', {key: 'Unidentified', keyCode: 2220, code: 'Unidentified'}),
                key: [null, 2220],
                valid: true,
            },
            {
                event: new KeyboardEvent('keydown', {key: 'Unidentified', keyCode: 2220, code: 'Unidentified'}),
                key: [null, 2221],
                valid: false,
            },
        ]) {
            expect(Utils.isKeyPressed(data.event, data.key)).toEqual(data.valid);
        }
    });

    test('KeyCode is used for undefined keys', () => {
        for (const data of [
            {
                event: {keyCode: 2221},
                key: ['', 2221],
                valid: true,
            },
            {
                event: {keyCode: 2221},
                key: ['not-used-field', 2221],
                valid: true,
            },
            {
                event: {keyCode: 2221},
                key: [null, 2221],
                valid: true,
            },
            {
                event: {keyCode: 2221},
                key: [null, 2222],
                valid: false,
            },
        ]) {
            expect(Utils.isKeyPressed(data.event, data.key)).toEqual(data.valid);
        }
    });

    test('keyCode is used for determining if it exists', () => {
        for (const data of [
            {
                event: {key: 'a', keyCode: 65},
                key: ['k', 65],
                valid: true,
            },
            {
                event: {key: 'b', keyCode: 66},
                key: ['y', 66],
                valid: true,
            },
        ]) {
            expect(Utils.isKeyPressed(data.event, data.key)).toEqual(data.valid);
        }
    });

    test('key should be tested as fallback for different layout of english keyboards', () => {
        //key will be k for keyboards like dvorak but code will be keyV as `v` is pressed
        const event = {key: 'k', code: 'KeyV'};
        const key = ['k', 2221];
        expect(Utils.isKeyPressed(event, key)).toEqual(true);
    });
});

describe('Utils.localizeMessage', () => {
    const originalGetState = store.getState;

    afterAll(() => {
        store.getState = originalGetState;
    });

    const entities = {
        general: {
            config: {},
        },
        users: {
            currentUserId: 'abcd',
            profiles: {
                abcd: {
                    locale: 'fr',
                },
            },
        },
    };

    describe('with translations', () => {
        beforeAll(() => {
            store.getState = () => ({
                entities,
                views: {
                    i18n: {
                        translations: {
                            fr: {
                                'test.hello_world': 'Bonjour tout le monde!',
                            },
                        },
                    },
                },
            });
        });

        test('with translations', () => {
            expect(Utils.localizeMessage('test.hello_world', 'Hello, World!')).toEqual('Bonjour tout le monde!');
        });

        test('with missing string in translations', () => {
            expect(Utils.localizeMessage('test.hello_world2', 'Hello, World 2!')).toEqual('Hello, World 2!');
        });

        test('with missing string in translations and no default', () => {
            expect(Utils.localizeMessage('test.hello_world2')).toEqual('test.hello_world2');
        });
    });

    describe('without translations', () => {
        beforeAll(() => {
            store.getState = () => ({
                entities,
                views: {
                    i18n: {
                        translations: {},
                    },
                },
            });
        });

        test('without translations', () => {
            expect(Utils.localizeMessage('test.hello_world', 'Hello, World!')).toEqual('Hello, World!');
        });

        test('without translations and no default', () => {
            expect(Utils.localizeMessage('test.hello_world')).toEqual('test.hello_world');
        });
    });
});

describe('Utils.isDevMode', () => {
    const originalGetState = store.getState;

    afterAll(() => {
        store.getState = originalGetState;
    });

    describe('dev mode off', () => {
        beforeAll(() => {
            store.getState = () => ({
                entities: {
                    general: {
                        config: {},
                    },
                },
            });
        });

        test('with missing EnableDeveloper field', () => {
            expect(Utils.isDevMode()).toEqual(false);
        });

        test('with EnableDeveloper field set to false', () => {
            store.getState = () => ({
                entities: {
                    general: {
                        config: {
                            EnableDeveloper: 'false',
                        },
                    },
                },
            });
            expect(Utils.isDevMode()).toEqual(false);
        });

        test('with EnableDeveloper field set to false bool', () => {
            store.getState = () => ({
                entities: {
                    general: {
                        config: {
                            EnableDeveloper: false,
                        },
                    },
                },
            });
            expect(Utils.isDevMode()).toEqual(false);
        });

        test('with EnableDeveloper field set to true bool', () => {
            store.getState = () => ({
                entities: {
                    general: {
                        config: {
                            EnableDeveloper: true,
                        },
                    },
                },
            });
            expect(Utils.isDevMode()).toEqual(false);
        });

        test('with EnableDeveloper field set to null', () => {
            store.getState = () => ({
                entities: {
                    general: {
                        config: {
                            EnableDeveloper: null,
                        },
                    },
                },
            });
            expect(Utils.isDevMode()).toEqual(false);
        });
    });

    describe('dev mode on', () => {
        beforeAll(() => {
            store.getState = () => ({
                entities: {
                    general: {
                        config: {},
                    },
                },
            });
        });

        test('with EnableDeveloper field set to true text', () => {
            store.getState = () => ({
                entities: {
                    general: {
                        config: {
                            EnableDeveloper: 'true',
                        },
                    },
                },
            });
            expect(Utils.isDevMode()).toEqual(true);
        });
    });
});

describe('Utils.enableDevModeFeatures', () => {
    const cleanUp = () => {
        delete Map.prototype.length;
        delete Set.prototype.length;
    };

    beforeEach(cleanUp);
    afterEach(cleanUp);

    describe('with DevModeFeatures', () => {
        beforeEach(cleanUp);
        afterEach(cleanUp);

        test('invoke Map.Length', () => {
            Utils.enableDevModeFeatures();
            expect(() => new Map().length).toThrow(Error);
        });

        test('invoke Set.Length', () => {
            Utils.enableDevModeFeatures();
            expect(() => new Set().length).toThrow(Error);
        });
    });

    describe('without DevModeFeatures', () => {
        test('invoke Map.Length', () => {
            expect(new Map().length).toEqual(undefined);
        });

        test('invoke Set.Length', () => {
            expect(new Set().length).toEqual(undefined);
        });
    });
});