mongodb-dynamic-api 2.4.0 → 2.4.2

package/test/dynamic-api-for-root.e2e-spec.js

@@ -1041,6 +1041,532 @@ describe('DynamicApiModule forRoot (e2e)', () => {
                     expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
                 });
             });
+            describe('useAuth with validation options', () => {
+                let UserEntity = class UserEntity extends src_1.BaseEntity {
+                };
+                __decorate([
+                    (0, mongoose_1.Prop)({ type: String, required: true }),
+                    (0, class_validator_1.IsEmail)(),
+                    __metadata("design:type", String)
+                ], UserEntity.prototype, "email", void 0);
+                __decorate([
+                    (0, mongoose_1.Prop)({ type: String, required: true }),
+                    (0, class_validator_1.IsStrongPassword)({
+                        minLength: 6,
+                        minLowercase: 1,
+                        minUppercase: 1,
+                        minNumbers: 1,
+                        minSymbols: 1,
+                    }),
+                    __metadata("design:type", String)
+                ], UserEntity.prototype, "password", void 0);
+                UserEntity = __decorate([
+                    (0, mongoose_1.Schema)({ collection: 'users' })
+                ], UserEntity);
+                beforeEach(async () => {
+                    await initModule({
+                        useAuth: {
+                            userEntity: UserEntity,
+                            validationPipeOptions: {
+                                whitelist: true,
+                                forbidNonWhitelisted: true,
+                                transform: true,
+                            },
+                        },
+                        webSocket: true,
+                    }, undefined, async (_) => {
+                        _.useWebSocketAdapter(new socket_adapter_1.SocketAdapter(_));
+                    });
+                    e2e_setup_1.handleSocketResponse.mockReset();
+                });
+                describe('EVENT auth-register', () => {
+                    it('should throw a ws exception if payload contains non whitelisted property', async () => {
+                        await e2e_setup_1.server.emit('auth-register', { email: 'unit@test.co', password: 'Test-2', role: 'ADMIN' });
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: ['property role should not exist'],
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                    it('should throw a ws exception if validation fails', async () => {
+                        await e2e_setup_1.server.emit('auth-register', { email: 'unit.test.co', password: 'test-2' });
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: [
+                                'email must be an email',
+                                'password is not strong enough',
+                            ],
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                    it('should create a new user and emit access token if the validation was successful', async () => {
+                        await e2e_setup_1.server.emit('auth-register', { email: 'unit@test.co', password: 'Test-2' });
+                        expect(e2e_setup_1.handleSocketException).not.toHaveBeenCalled();
+                        expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledWith({
+                            accessToken: expect.any(String),
+                        });
+                    });
+                });
+                describe('EVENT auth-login', () => {
+                    beforeEach(async () => {
+                        await e2e_setup_1.server.emit('auth-register', { email: 'unit@test.co', password: 'Test-2' });
+                        e2e_setup_1.handleSocketResponse.mockReset();
+                    });
+                    it('should throw a ws exception if payload contains non whitelisted property', async () => {
+                        await e2e_setup_1.server.emit('auth-login', { email: 'unit@test.co', password: 'Test-2', role: 'ADMIN' });
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: ['property role should not exist'],
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                    it('should throw a ws exception if email is missing', async () => {
+                        await e2e_setup_1.server.emit('auth-login', { password: 'Test-2' });
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: ['email must be an email'],
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                    it('should throw a ws exception if password is missing', async () => {
+                        await e2e_setup_1.server.emit('auth-login', { email: 'unit@test.co' });
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: ['password is not strong enough'],
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                    it('should emit access token if the validation was successful', async () => {
+                        await e2e_setup_1.server.emit('auth-login', { email: 'unit@test.co', password: 'Test-2' });
+                        expect(e2e_setup_1.handleSocketException).not.toHaveBeenCalled();
+                        expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledWith({
+                            accessToken: expect.any(String),
+                        });
+                    });
+                });
+            });
+            describe('EVENT auth-register with register options', () => {
+                let User = class User extends src_1.BaseEntity {
+                    constructor() {
+                        super(...arguments);
+                        this.role = 'user';
+                    }
+                };
+                __decorate([
+                    (0, mongoose_1.Prop)({ type: String, required: true }),
+                    __metadata("design:type", String)
+                ], User.prototype, "email", void 0);
+                __decorate([
+                    (0, mongoose_1.Prop)({ type: String, required: true }),
+                    __metadata("design:type", String)
+                ], User.prototype, "password", void 0);
+                __decorate([
+                    (0, mongoose_1.Prop)({ type: String, default: 'user' }),
+                    __metadata("design:type", String)
+                ], User.prototype, "role", void 0);
+                __decorate([
+                    (0, mongoose_1.Prop)({ type: Boolean, default: false }),
+                    __metadata("design:type", Boolean)
+                ], User.prototype, "isVerified", void 0);
+                User = __decorate([
+                    (0, mongoose_1.Schema)({ collection: 'users' })
+                ], User);
+                const admin = { email: 'admin@test.co', password: 'admin', role: 'admin', isVerified: true };
+                const user = { email: 'user@test.co', password: 'user' };
+                beforeEach(async () => {
+                    const bcryptService = new src_1.BcryptService();
+                    const fixtures = async (_) => {
+                        const model = await (0, utils_1.getModelFromEntity)(User);
+                        await model.insertMany([
+                            { ...admin, password: await bcryptService.hashPassword(admin.password) },
+                            { ...user, password: await bcryptService.hashPassword(user.password) },
+                        ]);
+                    };
+                    await initModule({
+                        useAuth: {
+                            userEntity: User,
+                            register: {
+                                protected: true,
+                                abilityPredicate: (user) => user.isVerified,
+                                additionalFields: ['role'],
+                                callback: async (user, { updateOneDocument }) => {
+                                    if (user.role !== 'admin') {
+                                        return;
+                                    }
+                                    await updateOneDocument(User, { _id: user.id }, { $set: { isVerified: true } });
+                                },
+                            },
+                            login: {
+                                additionalFields: ['role', 'isVerified'],
+                            },
+                        },
+                        webSocket: true,
+                    }, fixtures, async (_) => {
+                        _.useWebSocketAdapter(new socket_adapter_1.SocketAdapter(_));
+                    });
+                });
+                describe('protected', () => {
+                    it('should throw a ws exception if user is not logged in and protected is true', async () => {
+                        await e2e_setup_1.server.emit('auth-register', { email: 'unit@test.co', password: 'test' });
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: 'Unauthorized',
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                });
+                describe('abilityPredicate', () => {
+                    it('should not create a new user if user is not verified', async () => {
+                        const { email, password } = user;
+                        const { accessToken } = await e2e_setup_1.server.emit('auth-login', { email, password });
+                        e2e_setup_1.handleSocketResponse.mockReset();
+                        await e2e_setup_1.server.emit('auth-register', { email: 'unit@test.co', password: 'test' }, {
+                            accessToken,
+                        });
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: 'Access denied',
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                    it('should create a new user and return access token if user is verified', async () => {
+                        const { email, password } = admin;
+                        const { accessToken } = await e2e_setup_1.server.emit('auth-login', { email, password });
+                        e2e_setup_1.handleSocketResponse.mockReset();
+                        await e2e_setup_1.server.emit('auth-register', { email: 'unit@test.co', password: 'test' }, {
+                            accessToken,
+                        });
+                        expect(e2e_setup_1.handleSocketException).not.toHaveBeenCalled();
+                        expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledWith({ accessToken: expect.any(String) });
+                    });
+                });
+                describe('additionalFields', () => {
+                    it('should allow to register a new user with additional fields', async () => {
+                        const { email, password } = admin;
+                        const { accessToken } = await e2e_setup_1.server.emit('auth-login', { email, password });
+                        e2e_setup_1.handleSocketResponse.mockReset();
+                        await e2e_setup_1.server.emit('auth-register', { email: 'client@test.co', password: 'client', role: 'client' }, {
+                            accessToken,
+                        });
+                        expect(e2e_setup_1.handleSocketException).not.toHaveBeenCalled();
+                        expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledWith({ accessToken: expect.any(String) });
+                    });
+                });
+                describe('callback', () => {
+                    let adminAccessToken;
+                    beforeEach(async () => {
+                        const { email, password } = admin;
+                        const { accessToken } = await e2e_setup_1.server.emit('auth-login', { email, password });
+                        adminAccessToken = accessToken;
+                        e2e_setup_1.handleSocketResponse.mockReset();
+                    });
+                    it('should not set isVerified to true if role is not admin', async () => {
+                        const { accessToken: clientAccessToken } = await e2e_setup_1.server.emit('auth-register', { email: 'client@test.co', password: 'client', role: 'client' }, {
+                            accessToken: adminAccessToken,
+                        });
+                        e2e_setup_1.handleSocketResponse.mockReset();
+                        const body = await e2e_setup_1.server.emit('auth-get-account', undefined, { accessToken: clientAccessToken });
+                        expect(e2e_setup_1.handleSocketException).not.toHaveBeenCalled();
+                        expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledTimes(1);
+                        expect(body).toHaveProperty('isVerified', false);
+                    });
+                    it('should set isVerified to true if role is admin', async () => {
+                        const { accessToken: admin2AccessToken } = await e2e_setup_1.server.emit('auth-register', { email: 'admin2@test.co', password: 'admin2', role: 'admin' }, {
+                            accessToken: adminAccessToken,
+                        });
+                        e2e_setup_1.handleSocketResponse.mockReset();
+                        const body = await e2e_setup_1.server.emit('auth-get-account', undefined, { accessToken: admin2AccessToken });
+                        expect(e2e_setup_1.handleSocketException).not.toHaveBeenCalled();
+                        expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledTimes(1);
+                        expect(body).toHaveProperty('isVerified', true);
+                    });
+                });
+            });
+            describe('EVENT auth-login with login options', () => {
+                let User = class User extends src_1.BaseEntity {
+                    constructor() {
+                        super(...arguments);
+                        this.role = 'user';
+                    }
+                };
+                __decorate([
+                    (0, mongoose_1.Prop)({ type: String, required: true }),
+                    __metadata("design:type", String)
+                ], User.prototype, "username", void 0);
+                __decorate([
+                    (0, mongoose_1.Prop)({ type: String, required: true }),
+                    __metadata("design:type", String)
+                ], User.prototype, "pass", void 0);
+                __decorate([
+                    (0, mongoose_1.Prop)({ type: String, default: 'user' }),
+                    __metadata("design:type", String)
+                ], User.prototype, "role", void 0);
+                __decorate([
+                    (0, mongoose_1.Prop)({ type: Boolean, default: false }),
+                    __metadata("design:type", Boolean)
+                ], User.prototype, "isVerified", void 0);
+                User = __decorate([
+                    (0, mongoose_1.Schema)({ collection: 'users' })
+                ], User);
+                const admin = { username: 'admin', pass: 'admin', role: 'admin', isVerified: true };
+                const user = { username: 'user', pass: 'user' };
+                const client = { username: 'client', pass: 'client', role: 'client', isVerified: true };
+                beforeEach(async () => {
+                    const bcryptService = new src_1.BcryptService();
+                    const fixtures = async (_) => {
+                        const model = await (0, utils_1.getModelFromEntity)(User);
+                        await model.insertMany([
+                            { ...admin, pass: await bcryptService.hashPassword(admin.pass) },
+                            { ...user, pass: await bcryptService.hashPassword(user.pass) },
+                            { ...client, pass: await bcryptService.hashPassword(client.pass) },
+                        ]);
+                    };
+                    await initModule({
+                        useAuth: {
+                            userEntity: User,
+                            login: {
+                                loginField: 'username',
+                                passwordField: 'pass',
+                                additionalFields: ['role', 'isVerified'],
+                                abilityPredicate: (user) => user.role === 'admin' || user.role === 'user',
+                                callback: async (user) => {
+                                    if (user.isVerified) {
+                                        return;
+                                    }
+                                    throw new common_1.UnauthorizedException(`Hello ${user.username}, you must verify your account first!`);
+                                },
+                            },
+                        },
+                        webSocket: true,
+                    }, fixtures, async (_) => {
+                        _.useWebSocketAdapter(new socket_adapter_1.SocketAdapter(_));
+                    });
+                });
+                describe('loginField', () => {
+                    it('should throw a ws exception if loginField is missing', async () => {
+                        await e2e_setup_1.server.emit('auth-login', { pass: 'test' });
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: 'Unauthorized',
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                });
+                describe('passwordField', () => {
+                    it('should throw an unauthorized exception if passwordField is missing', async () => {
+                        await e2e_setup_1.server.emit('auth-login', { username: 'unit' });
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: 'Unauthorized',
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                });
+                describe('abilityPredicate', () => {
+                    it('should throw a ws exception if user role is not admin or user', async () => {
+                        const { username, pass } = client;
+                        await e2e_setup_1.server.emit('auth-login', { username, pass });
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: 'Access denied',
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                });
+                describe('callback', () => {
+                    it('should throw a ws exception if user is not verified', async () => {
+                        const { username, pass } = user;
+                        await e2e_setup_1.server.emit('auth-login', { username, pass });
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: 'Hello user, you must verify your account first!',
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                });
+                describe('additionalFields', () => {
+                    it('should return additional fields', async () => {
+                        const { username, pass } = admin;
+                        const { accessToken } = await e2e_setup_1.server.emit('auth-login', { username, pass });
+                        e2e_setup_1.handleSocketResponse.mockReset();
+                        await e2e_setup_1.server.emit('auth-get-account', undefined, { accessToken });
+                        expect(e2e_setup_1.handleSocketException).not.toHaveBeenCalled();
+                        expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledWith({ id: expect.any(String), username: 'admin', role: 'admin', isVerified: true });
+                    });
+                });
+            });
+            describe('useAuth with resetPassword options', () => {
+                let User = class User extends src_1.BaseEntity {
+                };
+                __decorate([
+                    (0, mongoose_1.Prop)({ type: String, required: true }),
+                    __metadata("design:type", String)
+                ], User.prototype, "email", void 0);
+                __decorate([
+                    (0, mongoose_1.Prop)({ type: String, required: true }),
+                    __metadata("design:type", String)
+                ], User.prototype, "password", void 0);
+                __decorate([
+                    (0, mongoose_1.Prop)({ type: Boolean, default: false }),
+                    __metadata("design:type", Boolean)
+                ], User.prototype, "isVerified", void 0);
+                __decorate([
+                    (0, mongoose_1.Prop)({ type: String }),
+                    __metadata("design:type", String)
+                ], User.prototype, "resetPasswordToken", void 0);
+                User = __decorate([
+                    (0, mongoose_1.Schema)({ collection: 'users' })
+                ], User);
+                let model;
+                let user;
+                let client;
+                let app;
+                beforeEach(async () => {
+                    user = { email: 'user@test.co', password: 'user', isVerified: true };
+                    client = { email: 'client@test.co', password: 'client' };
+                    const bcryptService = new src_1.BcryptService();
+                    const fixtures = async (_) => {
+                        model = await (0, utils_1.getModelFromEntity)(User);
+                        await model.insertMany([
+                            { ...user, password: await bcryptService.hashPassword(user.password) },
+                            { ...client, password: await bcryptService.hashPassword(client.password) },
+                        ]);
+                    };
+                    app = await initModule({
+                        useAuth: {
+                            userEntity: User,
+                            resetPassword: {
+                                emailField: 'email',
+                                expirationInMinutes: 1,
+                                resetPasswordCallback: async ({ resetPasswordToken }, { updateUserByEmail }) => {
+                                    await updateUserByEmail({ $set: { resetPasswordToken } });
+                                },
+                                changePasswordAbilityPredicate: (user) => user.isVerified && !!user.resetPasswordToken,
+                                changePasswordCallback: async (user, { updateOneDocument }) => {
+                                    await updateOneDocument(User, { _id: user.id }, { $unset: { resetPasswordToken: 1 } });
+                                },
+                            },
+                        },
+                        webSocket: true,
+                    }, fixtures, async (_) => {
+                        _.useWebSocketAdapter(new socket_adapter_1.SocketAdapter(_));
+                    });
+                });
+                describe('EVENT auth-reset-password', () => {
+                    it('should throw a ws exception if email is missing if no validation options are provided', async () => {
+                        await e2e_setup_1.server.emit('auth-reset-password', {});
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: 'Invalid or missing argument',
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                    it('should not throw a ws exception if email is invalid if no validation options are provided', async () => {
+                        await e2e_setup_1.server.emit('auth-reset-password', { email: 'unit.test.co' });
+                        expect(e2e_setup_1.handleSocketException).not.toHaveBeenCalled();
+                        expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledTimes(1);
+                    });
+                    it('should not throw a ws exception if email is not found', async () => {
+                        await e2e_setup_1.server.emit('auth-reset-password', { email: 'invalid@test.co' });
+                        expect(e2e_setup_1.handleSocketException).not.toHaveBeenCalled();
+                        expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledTimes(1);
+                    });
+                    describe('resetPasswordCallback', () => {
+                        it('should set resetPasswordToken if email is valid', async () => {
+                            const { email } = user;
+                            const { resetPasswordToken: resetPasswordTokenBeforeUpdate } = (await model.findOne({ email }).lean().exec());
+                            await e2e_setup_1.server.emit('auth-reset-password', { email });
+                            const { resetPasswordToken: resetPasswordTokenAfterUpdate } = (await model.findOne({ email }).lean().exec());
+                            expect(e2e_setup_1.handleSocketException).not.toHaveBeenCalled();
+                            expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledTimes(1);
+                            expect(resetPasswordTokenBeforeUpdate).toStrictEqual(undefined);
+                            expect(resetPasswordTokenAfterUpdate).toStrictEqual(expect.any(String));
+                        });
+                    });
+                });
+                describe('EVENT auth-change-password', () => {
+                    it('should throw a ws exception if resetPasswordToken is missing', async () => {
+                        await e2e_setup_1.server.emit('auth-change-password', { newPassword: 'test' });
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: 'Invalid or missing argument',
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                    it('should throw a ws exception if newPassword is missing', async () => {
+                        await e2e_setup_1.server.emit('auth-change-password', { resetPasswordToken: 'resetPasswordToken' });
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: 'Invalid or missing argument',
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                    it('should throw a ws exception if resetPasswordToken is invalid', async () => {
+                        await e2e_setup_1.server.emit('auth-change-password', { resetPasswordToken: 'test', newPassword: 'newPassword' });
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: 'Invalid reset password token. Please redo the reset password process.',
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                    it('should throw a ws exception if resetPasswordToken is expired', async () => {
+                        const jwtService = app.get(jwt_1.JwtService);
+                        const expiredResetPasswordToken = jwtService.sign({ email: user.email }, { expiresIn: 1 });
+                        await (0, utils_1.wait)(500);
+                        await e2e_setup_1.server.emit('auth-change-password', { resetPasswordToken: expiredResetPasswordToken, newPassword: 'newPassword' });
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                        expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                            message: 'Time to reset password has expired. Please redo the reset password process.',
+                        });
+                        expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                    });
+                    describe('changePasswordAbilityPredicate', () => {
+                        let resetPasswordToken;
+                        beforeEach(async () => {
+                            await e2e_setup_1.server.emit('auth-reset-password', { email: client.email });
+                            e2e_setup_1.handleSocketResponse.mockReset();
+                            const { resetPasswordToken: token } = (await model.findOne({ email: client.email }).lean().exec());
+                            resetPasswordToken = token;
+                        });
+                        it('should throw a ws exception if user is not allowed to change password', async () => {
+                            await e2e_setup_1.server.emit('auth-change-password', { resetPasswordToken, newPassword: 'newPassword' });
+                            expect(e2e_setup_1.handleSocketException).toHaveBeenCalledTimes(1);
+                            expect(e2e_setup_1.handleSocketException).toHaveBeenCalledWith({
+                                message: 'You are not allowed to change your password.',
+                            });
+                            expect(e2e_setup_1.handleSocketResponse).not.toHaveBeenCalled();
+                        });
+                    });
+                    describe('changePasswordCallback', () => {
+                        let resetPasswordToken;
+                        beforeEach(async () => {
+                            await e2e_setup_1.server.emit('auth-reset-password', { email: user.email });
+                            e2e_setup_1.handleSocketResponse.mockReset();
+                            const { resetPasswordToken: token } = (await model.findOne({ email: user.email }).lean().exec());
+                            resetPasswordToken = token;
+                        });
+                        it('should change password and unset resetPasswordToken if resetPasswordToken is valid', async () => {
+                            const newPassword = 'newPassword';
+                            const bcryptService = app.get(src_1.BcryptService);
+                            const { password: passwordBeforeUpdate } = (await model.findOne({ email: user.email }).lean().exec());
+                            await e2e_setup_1.server.emit('auth-change-password', { resetPasswordToken, newPassword });
+                            const { password: passwordAfterUpdate, resetPasswordToken: tokenAfterUpdate } = (await model.findOne({ email: user.email }).lean().exec());
+                            const isPreviousPassword = await bcryptService.comparePassword(user.password, passwordBeforeUpdate);
+                            expect(isPreviousPassword).toBe(true);
+                            const isNewPassword = await bcryptService.comparePassword(newPassword, passwordAfterUpdate);
+                            expect(isNewPassword).toBe(true);
+                            expect(tokenAfterUpdate).toStrictEqual(undefined);
+                            expect(e2e_setup_1.handleSocketException).not.toHaveBeenCalled();
+                            expect(e2e_setup_1.handleSocketResponse).toHaveBeenCalledTimes(1);
+                        });
+                    });
+                });
+            });
         });
     });
 });