RocketChat/Rocket.Chat

import { MeteorError } from '@rocket.chat/core-services';
import { License, MockedLicenseBuilder } from '@rocket.chat/license';

import { validateUserRoles } from './validateUserRoles';

beforeEach(async () => {
    const license = new MockedLicenseBuilder();
    await License.setWorkspaceUrl('http://localhost:3000');
    License.setLicenseLimitCounter('activeUsers', () => 0);
    License.setLicenseLimitCounter('guestUsers', () => 0);
    License.setLicenseLimitCounter('roomsPerGuest', async () => 0);
    License.setLicenseLimitCounter('privateApps', () => 0);
    License.setLicenseLimitCounter('marketplaceApps', () => 0);
    License.setLicenseLimitCounter('monthlyActiveContacts', async () => 0);

    License.setLicenseLimitCounter('activeUsers', () => 1);

    license
        .withLimits('activeUsers', [
            {
                max: 1,
                behavior: 'prevent_action',
            },
        ])
        .withLimits('guestUsers', [
            {
                max: 1,
                behavior: 'prevent_action',
            },
        ]);

    await License.setLicense(await license.sign());
});

describe('Operating after activeUsers Limits', () => {
    beforeEach(async () => {
        License.setLicenseLimitCounter('activeUsers', () => 1);
    });

    describe('Adding a new user', () => {
        it('should  throw error when user is active as undefined', async () => {
            const user = {
                roles: ['user'],
            };

            await expect(validateUserRoles(user)).rejects.toThrow(MeteorError);
        });

        it('should not throw error when user is not active', async () => {
            const user = {
                active: false,
                type: 'user',
            };

            await expect(validateUserRoles(user)).resolves.not.toThrow();
        });

        it('should not throw error when user is an app', async () => {
            const user = {
                active: true,
                type: 'app',
            };

            await expect(validateUserRoles(user)).resolves.not.toThrow();
        });

        it('should not throw error when user is a bot', async () => {
            const user = {
                active: true,
                type: 'bot',
            };

            await expect(validateUserRoles(user)).resolves.not.toThrow();
        });

        it('should not throw error when user is a guest', async () => {
            const user = {
                active: true,
                type: 'user',
                roles: ['guest'],
            };

            await expect(validateUserRoles(user)).resolves.not.toThrow();
        });

        it('should throw error when user is active', async () => {
            const user = {
                active: true,
                type: 'user',
            };
            await expect(validateUserRoles(user)).rejects.toThrow(MeteorError);
        });
    });

    describe('Editing an existing user', () => {
        beforeEach(async () => {
            License.setLicenseLimitCounter('guestUsers', () => 1);
        });
        afterEach(async () => {
            License.setLicenseLimitCounter('guestUsers', () => 0);
        });

        it('should throw an error when we try to activate a user', async () => {
            const user = {
                active: true,
                type: 'user',
            };
            const currentUser = {
                active: false,
                type: 'user',
            };
            await expect(validateUserRoles(user, currentUser)).rejects.toThrow(MeteorError);
        });

        it('should not throw an error when we try to deactivate a user', async () => {
            const user = {
                active: false,
                type: 'user',
            };
            const currentUser = {
                active: true,
                type: 'user',
            };
            await expect(validateUserRoles(user, currentUser)).resolves.not.toThrow();
        });

        it('should not throw an error when we try to change an active user', async () => {
            const user = {
                active: true,
                type: 'user',
            };
            const currentUser = {
                active: true,
                type: 'user',
            };
            await expect(validateUserRoles(user, currentUser)).resolves.not.toThrow();
        });

        it('should throw an error when we try to convert a bot to a user', async () => {
            const user = {
                active: true,
                type: 'user',
            };
            const currentUser = {
                active: true,
                type: 'bot',
            };
            await expect(validateUserRoles(user, currentUser)).rejects.toThrow(MeteorError);
        });
    });
});

describe('Operating after guestUsers Limits', () => {
    beforeEach(async () => {
        License.setLicenseLimitCounter('guestUsers', () => 1);
    });

    it('should throw an error when we try to convert an user to guest', async () => {
        const user = {
            active: true,
            type: 'user',
            roles: ['guest'],
        };
        const currentUser = {
            active: true,
            type: 'user',
        };
        await expect(validateUserRoles(user, currentUser)).rejects.toThrow(MeteorError);
    });

    it('should  throw an error when we try to convert app to guest', async () => {
        const user = {
            active: true,
            type: 'user',
            roles: ['guest'],
        };
        const currentUser = {
            active: true,
            type: 'app',
        };
        await expect(validateUserRoles(user, currentUser)).rejects.toThrow(MeteorError);
    });

    it('should not throw an error when we try to edit a guest', async () => {
        const user = {
            active: true,
            type: 'user',
            roles: ['guest'],
        };
        const currentUser = {
            active: true,
            type: 'user',
            roles: ['guest'],
        };
        await expect(validateUserRoles(user, currentUser)).resolves.not.toThrow();
    });
});

describe('Operating under activeUsers Limits', () => {
    beforeEach(async () => {
        License.setLicenseLimitCounter('activeUsers', () => 0);
    });

    describe('Adding a new user', () => {
        it('should not throw an error validating a regular user', async () => {
            const user = {
                active: true,
                type: 'user',
            };
            await expect(validateUserRoles(user)).resolves.not.toThrow();
        });
    });

    describe('Editing an existing user', () => {
        it('should not throw an error when we try to activate a user', async () => {
            const user = {
                active: true,
                type: 'user',
            };
            const currentUser = {
                active: false,
                type: 'user',
            };
            await expect(validateUserRoles(user, currentUser)).resolves.not.toThrow();
        });

        it('should not throw an error when we try to convert a guest to a user', async () => {
            const user = {
                active: true,
                type: 'user',
            };
            const currentUser = {
                active: true,
                type: 'user',
                roles: ['guest'],
            };
            await expect(validateUserRoles(user, currentUser)).resolves.not.toThrow();
        });
        it('should not throw an error when we try to convert a bot to a user', async () => {
            const user = {
                active: true,
                type: 'user',
            };
            const currentUser = {
                active: true,
                type: 'bot',
            };
            await expect(validateUserRoles(user, currentUser)).resolves.not.toThrow();
        });
        it('should not throw an error when we try to convert an app to a user', async () => {
            const user = {
                active: true,
                type: 'user',
            };
            const currentUser = {
                active: true,
                type: 'app',
            };
            await expect(validateUserRoles(user, currentUser)).resolves.not.toThrow();
        });
    });
});