diff --git a/test/messaging.js b/test/messaging.js
index 7cabd94cb2..5064a156b0 100644
--- a/test/messaging.js
+++ b/test/messaging.js
@@ -2,7 +2,7 @@
 
 const assert = require('assert');
 const async = require('async');
-const request = require('request');
+const request = require('request-promise-native');
 const nconf = require('nconf');
 const util = require('util');
 
@@ -15,49 +15,81 @@ const Groups = require('../src/groups');
 const Messaging = require('../src/messaging');
 const helpers = require('./helpers');
 const socketModules = require('../src/socket.io/modules');
+const utils = require('../public/src/utils');
+const translator = require('../src/translator');
 
 describe('Messaging Library', () => {
-	let fooUid; // the admin
-	let bazUid; // the user with chat restriction enabled
-	let herpUid;
+	const mocks = {
+		users: {
+			foo: {}, // the admin
+			baz: {}, // the user with chat restriction enabled
+			herp: {},
+		},
+	};
 	let roomId;
 
-	before((done) => {
-		// Create 3 users: 1 admin, 2 regular
-		async.series([
-			async.apply(User.create, { username: 'foo', password: 'barbar' }), // admin
-			async.apply(User.create, { username: 'baz', password: 'quuxquux' }), // restricted user
-			async.apply(User.create, { username: 'herp', password: 'derpderp' }), // regular user
-		], (err, uids) => {
-			if (err) {
-				return done(err);
-			}
+	let chatMessageDelay;
 
-			fooUid = uids[0];
-			bazUid = uids[1];
-			herpUid = uids[2];
+	const callv3API = async (method, path, body, user) => {
+		const options = {
+			method,
+			body,
+			json: true,
+			jar: mocks.users[user].jar,
+			resolveWithFullResponse: true,
+			simple: false,
+		};
 
-			async.parallel([
-				async.apply(Groups.join, 'administrators', fooUid),
-				async.apply(User.setSetting, bazUid, 'restrictChat', '1'),
-			], done);
-		});
+		if (method !== 'get') {
+			options.headers = {
+				'x-csrf-token': mocks.users[user].csrf,
+			};
+		}
+
+		return request(`${nconf.get('url')}/api/v3${path}`, options);
+	};
+
+	before(async () => {
+		// Create 3 users: 1 admin, 2 regular
+		({
+			foo: mocks.users.foo.uid,
+			baz: mocks.users.baz.uid,
+			herp: mocks.users.herp.uid,
+		} = await utils.promiseParallel({
+			foo: User.create({ username: 'foo', password: 'barbar' }), // admin
+			baz: User.create({ username: 'baz', password: 'quuxquux' }), // restricted user
+			herp: User.create({ username: 'herp', password: 'derpderp' }), // a regular user
+		}));
+
+		await Groups.join('administrators', mocks.users.foo.uid);
+		await User.setSetting(mocks.users.baz.uid, 'restrictChat', '1');
+
+		({ jar: mocks.users.foo.jar, csrf_token: mocks.users.foo.csrf } = await util.promisify(helpers.loginUser)('foo', 'barbar'));
+		({ jar: mocks.users.baz.jar, csrf_token: mocks.users.baz.csrf } = await util.promisify(helpers.loginUser)('baz', 'quuxquux'));
+		({ jar: mocks.users.herp.jar, csrf_token: mocks.users.herp.csrf } = await util.promisify(helpers.loginUser)('herp', 'derpderp'));
+
+		chatMessageDelay = meta.config.chatMessageDelay;
+		meta.config.chatMessageDelay = 0;
+	});
+
+	after(() => {
+		meta.configs.chatMessageDelay = chatMessageDelay;
 	});
 
 	describe('.canMessage()', () => {
 		it('should allow messages to be sent to an unrestricted user', (done) => {
-			Messaging.canMessageUser(bazUid, herpUid, (err) => {
+			Messaging.canMessageUser(mocks.users.baz.uid, mocks.users.herp.uid, (err) => {
 				assert.ifError(err);
 				done();
 			});
 		});
 
 		it('should NOT allow messages to be sent to a restricted user', (done) => {
-			User.setSetting(bazUid, 'restrictChat', '1', (err) => {
+			User.setSetting(mocks.users.baz.uid, 'restrictChat', '1', (err) => {
 				assert.ifError(err);
-				Messaging.canMessageUser(herpUid, bazUid, (err) => {
+				Messaging.canMessageUser(mocks.users.herp.uid, mocks.users.baz.uid, (err) => {
 					assert.strictEqual(err.message, '[[error:chat-restricted]]');
-					socketModules.chats.addUserToRoom({ uid: herpUid }, { roomId: 1, username: 'baz' }, (err) => {
+					socketModules.chats.addUserToRoom({ uid: mocks.users.herp.uid }, { roomId: 1, username: 'baz' }, (err) => {
 						assert.equal(err.message, '[[error:chat-restricted]]');
 						done();
 					});
@@ -66,15 +98,15 @@ describe('Messaging Library', () => {
 		});
 
 		it('should always allow admins through', (done) => {
-			Messaging.canMessageUser(fooUid, bazUid, (err) => {
+			Messaging.canMessageUser(mocks.users.foo.uid, mocks.users.baz.uid, (err) => {
 				assert.ifError(err);
 				done();
 			});
 		});
 
 		it('should allow messages to be sent to a restricted user if restricted user follows sender', (done) => {
-			User.follow(bazUid, herpUid, () => {
-				Messaging.canMessageUser(herpUid, bazUid, (err) => {
+			User.follow(mocks.users.baz.uid, mocks.users.herp.uid, () => {
+				Messaging.canMessageUser(mocks.users.herp.uid, mocks.users.baz.uid, (err) => {
 					assert.ifError(err);
 					done();
 				});
@@ -84,57 +116,66 @@ describe('Messaging Library', () => {
 
 	describe('rooms', () => {
 		it('should fail to create a new chat room with invalid data', (done) => {
-			socketModules.chats.newRoom({ uid: fooUid }, null, (err) => {
+			socketModules.chats.newRoom({ uid: mocks.users.foo.uid }, null, (err) => {
 				assert.equal(err.message, '[[error:invalid-data]]');
 				done();
 			});
 		});
 
-		it('should return rate limit error on second try', (done) => {
-			const socketMock = { uid: fooUid };
+		it('should return rate limit error on second try', async () => {
 			const oldValue = meta.config.chatMessageDelay;
 			meta.config.chatMessageDelay = 1000;
-			socketModules.chats.newRoom(socketMock, { touid: bazUid }, (err) => {
-				assert.ifError(err);
-				socketModules.chats.newRoom(socketMock, { touid: bazUid }, (err) => {
-					assert.equal(err.message, '[[error:too-many-messages]]');
-					meta.configs.chatMessageDelay = oldValue;
-					done();
-				});
-			});
+
+			await callv3API('post', '/chats', {
+				uids: [mocks.users.baz.uid],
+			}, 'foo');
+
+			const { statusCode, body } = await callv3API('post', `/chats`, {
+				uids: [mocks.users.baz.uid],
+			}, 'foo');
+
+			assert.equal(statusCode, 400);
+			assert.equal(body.status.code, 'bad-request');
+			assert.equal(body.status.message, await translator.translate('[[error:too-many-messages]]'));
+			meta.config.chatMessageDelay = oldValue;
 		});
 
-		it('should create a new chat room', (done) => {
-			socketModules.chats.newRoom({ uid: fooUid }, { touid: bazUid }, (err, _roomId) => {
-				roomId = _roomId;
-				assert.ifError(err);
-				assert(roomId);
-				socketModules.chats.canMessage({ uid: fooUid }, _roomId, (err) => {
-					assert.ifError(err);
-					done();
-				});
-			});
+		it('should create a new chat room', async () => {
+			await User.setSetting(mocks.users.baz.uid, 'restrictChat', '0');
+			const { body } = await callv3API('post', `/chats`, {
+				uids: [mocks.users.baz.uid],
+			}, 'foo');
+			await User.setSetting(mocks.users.baz.uid, 'restrictChat', '1');
+
+			roomId = body.response.roomId;
+			assert(roomId);
+
+			await util.promisify(socketModules.chats.canMessage)({ uid: mocks.users.foo.uid }, roomId);
 		});
 
 		it('should send a user-join system message when a chat room is created', (done) => {
-			socketModules.chats.getMessages({ uid: fooUid }, { uid: fooUid, roomId: roomId, start: 0 }, (err, messages) => {
-				assert.ifError(err);
-				assert.equal(messages.length, 2);
-				assert.strictEqual(messages[0].system, true);
-				assert.strictEqual(messages[0].content, 'user-join');
-				socketModules.chats.edit({ uid: fooUid }, { roomId: roomId, mid: messages[0].messageId, message: 'test' }, (err) => {
-					assert.equal(err.message, '[[error:cant-edit-chat-message]]');
-					done();
-				});
-			});
+			socketModules.chats.getMessages(
+				{ uid: mocks.users.foo.uid },
+				{ uid: mocks.users.foo.uid, roomId: roomId, start: 0 },
+				(err, messages) => {
+					assert.ifError(err);
+					assert.equal(messages.length, 2);
+					assert.strictEqual(messages[0].system, true);
+					assert.strictEqual(messages[0].content, 'user-join');
+					socketModules.chats.edit({ uid: mocks.users.foo.uid }, { roomId: roomId, mid: messages[0].messageId, message: 'test' }, (err) => {
+						assert.equal(err.message, '[[error:cant-edit-chat-message]]');
+						done();
+					});
+				}
+			);
 		});
 
 		it('should fail to add user to room with invalid data', (done) => {
-			socketModules.chats.addUserToRoom({ uid: fooUid }, null, (err) => {
+			socketModules.chats.addUserToRoom({ uid: mocks.users.foo.uid }, null, (err) => {
 				assert.equal(err.message, '[[error:invalid-data]]');
-				socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: null }, (err) => {
+				socketModules.chats.addUserToRoom({ uid: mocks.users.foo.uid }, { roomId: null }, (err) => {
 					assert.equal(err.message, '[[error:invalid-data]]');
-					socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: roomId, username: null }, (err) => {
+					socketModules.chats.addUserToRoom({ uid: mocks.users.foo.uid }, { roomId: roomId, username: null }, (err) => {
 						assert.equal(err.message, '[[error:invalid-data]]');
 						done();
 					});
@@ -143,9 +184,9 @@ describe('Messaging Library', () => {
 		});
 
 		it('should add a user to room', (done) => {
-			socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: roomId, username: 'herp' }, (err) => {
+			socketModules.chats.addUserToRoom({ uid: mocks.users.foo.uid }, { roomId: roomId, username: 'herp' }, (err) => {
 				assert.ifError(err);
-				Messaging.isUserInRoom(herpUid, roomId, (err, isInRoom) => {
+				Messaging.isUserInRoom(mocks.users.herp.uid, roomId, (err, isInRoom) => {
 					assert.ifError(err);
 					assert(isInRoom);
 					done();
@@ -154,8 +195,9 @@ describe('Messaging Library', () => {
 		});
 
 		it('should get users in room', async () => {
-			const data = await socketModules.chats.getUsersInRoom({ uid: fooUid }, { roomId: roomId });
-			assert(Array.isArray(data) && data.length === 3);
+			const data = await socketModules.chats.getUsersInRoom({ uid: mocks.users.foo.uid }, { roomId: roomId });
+			assert(Array.isArray(data));
+			assert.strictEqual(data.length, 3);
 		});
 
 		it('should throw error if user is not in room', async () => {
@@ -168,7 +210,7 @@ describe('Messaging Library', () => {
 
 		it('should fail to add users to room if max is reached', (done) => {
 			meta.config.maximumUsersInChatRoom = 2;
-			socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: roomId, username: 'test' }, (err) => {
+			socketModules.chats.addUserToRoom({ uid: mocks.users.foo.uid }, { roomId: roomId, username: 'test' }, (err) => {
 				assert.equal(err.message, '[[error:cant-add-more-users-to-chat-room]]');
 				meta.config.maximumUsersInChatRoom = 0;
 				done();
@@ -176,14 +218,14 @@ describe('Messaging Library', () => {
 		});
 
 		it('should fail to add users to room if user does not exist', (done) => {
-			socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: roomId, username: 'doesnotexist' }, (err) => {
+			socketModules.chats.addUserToRoom({ uid: mocks.users.foo.uid }, { roomId: roomId, username: 'doesnotexist' }, (err) => {
 				assert.equal(err.message, '[[error:no-user]]');
 				done();
 			});
 		});
 
 		it('should fail to add self to room', (done) => {
-			socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: roomId, username: 'foo' }, (err) => {
+			socketModules.chats.addUserToRoom({ uid: mocks.users.foo.uid }, { roomId: roomId, username: 'foo' }, (err) => {
 				assert.equal(err.message, '[[error:cant-chat-with-yourself]]');
 				done();
 			});
@@ -192,7 +234,7 @@ describe('Messaging Library', () => {
 		it('should fail to leave room with invalid data', (done) => {
 			socketModules.chats.leave({ uid: null }, roomId, (err) => {
 				assert.equal(err.message, '[[error:invalid-data]]');
-				socketModules.chats.leave({ uid: fooUid }, null, (err) => {
+				socketModules.chats.leave({ uid: mocks.users.foo.uid }, null, (err) => {
 					assert.equal(err.message, '[[error:invalid-data]]');
 					done();
 				});
@@ -200,14 +242,14 @@ describe('Messaging Library', () => {
 		});
 
 		it('should leave the chat room', (done) => {
-			socketModules.chats.leave({ uid: bazUid }, roomId, (err) => {
+			socketModules.chats.leave({ uid: mocks.users.baz.uid }, roomId, (err) => {
 				assert.ifError(err);
-				Messaging.isUserInRoom(bazUid, roomId, (err, isUserInRoom) => {
+				Messaging.isUserInRoom(mocks.users.baz.uid, roomId, (err, isUserInRoom) => {
 					assert.ifError(err);
 					assert.equal(isUserInRoom, false);
 					Messaging.getRoomData(roomId, (err, data) => {
 						assert.ifError(err);
-						assert.equal(data.owner, fooUid);
+						assert.equal(data.owner, mocks.users.foo.uid);
 						done();
 					});
 				});
@@ -215,21 +257,25 @@ describe('Messaging Library', () => {
 		});
 
 		it('should send a user-leave system message when a user leaves the chat room', (done) => {
-			socketModules.chats.getMessages({ uid: fooUid }, { uid: fooUid, roomId: roomId, start: 0 }, (err, messages) => {
-				assert.ifError(err);
-				assert.equal(messages.length, 4);
-				const message = messages.pop();
-				assert.strictEqual(message.system, true);
-				assert.strictEqual(message.content, 'user-leave');
-				done();
-			});
+			socketModules.chats.getMessages(
+				{ uid: mocks.users.foo.uid },
+				{ uid: mocks.users.foo.uid, roomId: roomId, start: 0 },
+				(err, messages) => {
+					assert.ifError(err);
+					assert.equal(messages.length, 4);
+					const message = messages.pop();
+					assert.strictEqual(message.system, true);
+					assert.strictEqual(message.content, 'user-leave');
+					done();
+				}
+			);
 		});
 
 		it('should send not a user-leave system message when a user tries to leave a room they are not in', async () => {
-			await socketModules.chats.leave({ uid: bazUid }, roomId);
+			await socketModules.chats.leave({ uid: mocks.users.baz.uid }, roomId);
 			const messages = await socketModules.chats.getMessages(
-				{ uid: fooUid },
-				{ uid: fooUid, roomId: roomId, start: 0 }
+				{ uid: mocks.users.foo.uid },
+				{ uid: mocks.users.foo.uid, roomId: roomId, start: 0 }
 			);
 			assert.equal(messages.length, 4);
 			const message = messages.pop();
@@ -237,47 +283,43 @@ describe('Messaging Library', () => {
 			assert.strictEqual(message.content, 'user-leave');
 		});
 
-		it('should change owner when owner leaves room', (done) => {
-			socketModules.chats.newRoom({ uid: herpUid }, { touid: fooUid }, (err, roomId) => {
-				assert.ifError(err);
-				socketModules.chats.addUserToRoom({ uid: herpUid }, { roomId: roomId, username: 'baz' }, (err) => {
-					assert.ifError(err);
-					socketModules.chats.leave({ uid: herpUid }, roomId, (err) => {
-						assert.ifError(err);
-						Messaging.getRoomData(roomId, (err, data) => {
-							assert.ifError(err);
-							assert.equal(data.owner, fooUid);
-							done();
-						});
-					});
-				});
-			});
+		it('should change owner when owner leaves room', async () => {
+			const { body } = await callv3API('post', '/chats', {
+				uids: [mocks.users.foo.uid],
+			}, 'herp');
+
+			await util.promisify(socketModules.chats.addUserToRoom)({ uid: mocks.users.herp.uid }, { roomId: body.response.roomId, username: 'baz' });
+			await util.promisify(socketModules.chats.leave)({ uid: mocks.users.herp.uid }, body.response.roomId);
+
+			const data = await Messaging.getRoomData(body.response.roomId);
+			assert.equal(data.owner, mocks.users.foo.uid);
 		});
 
-		it('should change owner if owner is deleted', (done) => {
-			User.create({ username: 'deleted_chat_user' }, (err, sender) => {
-				assert.ifError(err);
-				User.create({ username: 'receiver' }, (err, receiver) => {
-					assert.ifError(err);
-					socketModules.chats.newRoom({ uid: sender }, { touid: receiver }, (err, roomId) => {
-						assert.ifError(err);
-						User.deleteAccount(sender, (err) => {
-							assert.ifError(err);
-							Messaging.getRoomData(roomId, (err, data) => {
-								assert.ifError(err);
-								assert.equal(data.owner, receiver);
-								done();
-							});
-						});
-					});
-				});
+		it('should change owner if owner is deleted', async () => {
+			const sender = await User.create({ username: 'deleted_chat_user', password: 'barbar' });
+			const { jar: senderJar, csrf_token: senderCsrf } = await util.promisify(helpers.loginUser)('deleted_chat_user', 'barbar');
+
+			const receiver = await User.create({ username: 'receiver' });
+			const { response } = await request(`${nconf.get('url')}/api/v3/chats`, {
+				method: 'post',
+				json: true,
+				jar: senderJar,
+				body: {
+					uids: [receiver],
+				},
+				headers: {
+					'x-csrf-token': senderCsrf,
+				},
 			});
+			await User.deleteAccount(sender);
+			const data = await Messaging.getRoomData(response.roomId);
+			assert.equal(data.owner, receiver);
 		});
 
 		it('should fail to remove user from room', (done) => {
-			socketModules.chats.removeUserFromRoom({ uid: fooUid }, null, (err) => {
+			socketModules.chats.removeUserFromRoom({ uid: mocks.users.foo.uid }, null, (err) => {
 				assert.equal(err.message, '[[error:invalid-data]]');
-				socketModules.chats.removeUserFromRoom({ uid: fooUid }, {}, (err) => {
+				socketModules.chats.removeUserFromRoom({ uid: mocks.users.foo.uid }, {}, (err) => {
 					assert.equal(err.message, '[[error:invalid-data]]');
 					done();
 				});
@@ -285,40 +327,43 @@ describe('Messaging Library', () => {
 		});
 
 		it('should fail to remove user from room if user does not exist', (done) => {
-			socketModules.chats.removeUserFromRoom({ uid: fooUid }, { roomId: roomId, uid: 99 }, (err) => {
+			socketModules.chats.removeUserFromRoom({ uid: mocks.users.foo.uid }, { roomId: roomId, uid: 99 }, (err) => {
 				assert.equal('[[error:no-user]]', err.message);
 				done();
 			});
 		});
 
-		it('should remove user from room', (done) => {
-			socketModules.chats.newRoom({ uid: fooUid }, { touid: herpUid }, (err, roomId) => {
-				assert.ifError(err);
-				Messaging.isUserInRoom(herpUid, roomId, (err, isInRoom) => {
-					assert.ifError(err);
-					assert(isInRoom);
-					socketModules.chats.removeUserFromRoom({ uid: fooUid }, { roomId: roomId, uid: herpUid }, (err) => {
-						assert.equal(err.message, '[[error:cant-remove-last-user]]');
-						socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: roomId, username: 'baz' }, (err) => {
-							assert.ifError(err);
-							socketModules.chats.removeUserFromRoom({ uid: fooUid }, { roomId: roomId, uid: herpUid }, (err) => {
-								assert.ifError(err);
-								Messaging.isUserInRoom(herpUid, roomId, (err, isInRoom) => {
-									assert.ifError(err);
-									assert(!isInRoom);
-									done();
-								});
-							});
-						});
-					});
-				});
-			});
+		it('should remove user from room', async () => {
+			const { body } = await callv3API('post', `/chats`, {
+				uids: [mocks.users.herp.uid],
+			}, 'foo');
+			const { roomId } = body.response;
+
+			let isInRoom = await Messaging.isUserInRoom(mocks.users.herp.uid, roomId);
+			assert(isInRoom);
+
+			try {
+				await util.promisify(
+					socketModules.chats.removeUserFromRoom
+				)({ uid: mocks.users.foo.uid }, { roomId: roomId, uid: mocks.users.herp.uid });
+			} catch (err) {
+				assert.equal(err.message, '[[error:cant-remove-last-user]]');
+			}
+
+			await util.promisify(
+				socketModules.chats.addUserToRoom
+			)({ uid: mocks.users.foo.uid }, { roomId: roomId, username: 'baz' });
+			await util.promisify(
+				socketModules.chats.removeUserFromRoom
+			)({ uid: mocks.users.foo.uid }, { roomId: roomId, uid: mocks.users.herp.uid });
+			isInRoom = await Messaging.isUserInRoom(mocks.users.herp.uid, roomId);
+			assert(!isInRoom);
 		});
 
 		it('should fail to send a message to room with invalid data', (done) => {
-			socketModules.chats.send({ uid: fooUid }, null, (err) => {
+			socketModules.chats.send({ uid: mocks.users.foo.uid }, null, (err) => {
 				assert.equal(err.message, '[[error:invalid-data]]');
-				socketModules.chats.send({ uid: fooUid }, { roomId: null }, (err) => {
+				socketModules.chats.send({ uid: mocks.users.foo.uid }, { roomId: null }, (err) => {
 					assert.equal(err.message, '[[error:invalid-data]]');
 					socketModules.chats.send({ uid: null }, { roomId: 1 }, (err) => {
 						assert.equal(err.message, '[[error:invalid-data]]');
@@ -328,103 +373,98 @@ describe('Messaging Library', () => {
 			});
 		});
 
-		it('should fail to send chat if content is empty', (done) => {
-			socketModules.chats.send({ uid: fooUid }, { roomId: roomId, message: ' ' }, (err) => {
-				assert.equal(err.message, '[[error:invalid-chat-message]]');
-				done();
-			});
+		it('should fail to send chat if content is empty', async () => {
+			const { body } = await callv3API('post', `/chats/${roomId}`, {
+				message: ' ',
+			}, 'foo');
+			const { status, response } = body;
+
+			assert.deepStrictEqual(response, {});
+			assert.equal(status.message, await translator.translate('[[error:invalid-chat-message]]'));
 		});
 
-		it('should send a message to a room', (done) => {
-			socketModules.chats.send({ uid: fooUid }, { roomId: roomId, message: 'first chat message' }, (err, messageData) => {
-				assert.ifError(err);
-				assert(messageData);
-				assert.equal(messageData.content, 'first chat message');
-				assert(messageData.fromUser);
-				assert(messageData.roomId, roomId);
-				socketModules.chats.getRaw({ uid: fooUid }, { mid: messageData.mid }, (err, raw) => {
-					assert.ifError(err);
-					assert.equal(raw, 'first chat message');
-					setTimeout(done, 300);
-				});
-			});
+		it('should send a message to a room', async () => {
+			const { body } = await callv3API('post', `/chats/${roomId}`, { roomId: roomId, message: 'first chat message' }, 'foo');
+			const messageData = body.response;
+			assert(messageData);
+			assert.equal(messageData.content, 'first chat message');
+			assert(messageData.fromUser);
+			assert(messageData.roomId, roomId);
+			const raw =
+				await util.promisify(socketModules.chats.getRaw)({ uid: mocks.users.foo.uid }, { mid: messageData.mid });
+			assert.equal(raw, 'first chat message');
 		});
 
-		it('should fail to send second message due to rate limit', (done) => {
-			const socketMock = { uid: fooUid };
+		it('should fail to send second message due to rate limit', async () => {
+			const socketMock = { uid: mocks.users.foo.uid };
 			const oldValue = meta.config.chatMessageDelay;
 			meta.config.chatMessageDelay = 1000;
-			socketModules.chats.send(socketMock, { roomId: roomId, message: 'first chat message' }, (err) => {
-				assert.ifError(err);
-				socketModules.chats.send(socketMock, { roomId: roomId, message: 'first chat message' }, (err) => {
-					assert.equal(err.message, '[[error:too-many-messages]]');
-					meta.config.chatMessageDelay = oldValue;
-					done();
-				});
-			});
+
+			await callv3API('post', `/chats/${roomId}`, { roomId: roomId, message: 'first chat message' }, 'foo');
+			const { body } = await callv3API('post', `/chats/${roomId}`, { roomId: roomId, message: 'first chat message' }, 'foo');
+			const { status } = body;
+			assert.equal(status.message, await translator.translate('[[error:too-many-messages]]'));
+			meta.config.chatMessageDelay = oldValue;
 		});
 
 		it('should return invalid-data error', (done) => {
-			socketModules.chats.getRaw({ uid: fooUid }, null, (err) => {
+			socketModules.chats.getRaw({ uid: mocks.users.foo.uid }, null, (err) => {
 				assert.equal(err.message, '[[error:invalid-data]]');
-				socketModules.chats.getRaw({ uid: fooUid }, {}, (err) => {
+				socketModules.chats.getRaw({ uid: mocks.users.foo.uid }, {}, (err) => {
 					assert.equal(err.message, '[[error:invalid-data]]');
 					done();
 				});
 			});
 		});
 
-		it('should return not allowed error if mid is not in room', (done) => {
-			let myRoomId;
-			User.create({ username: 'dummy' }, (err, uid) => {
-				assert.ifError(err);
-				socketModules.chats.newRoom({ uid: bazUid }, { touid: uid }, (err, _roomId) => {
-					myRoomId = _roomId;
-					assert.ifError(err);
-					assert(myRoomId);
-					socketModules.chats.getRaw({ uid: bazUid }, { mid: 200 }, (err) => {
-						assert(err);
-						assert.equal(err.message, '[[error:not-allowed]]');
-						socketModules.chats.send({ uid: bazUid }, { roomId: myRoomId, message: 'admin will see this' }, (err, message) => {
-							assert.ifError(err);
-							socketModules.chats.getRaw({ uid: fooUid }, { mid: message.mid }, (err, raw) => {
-								assert.ifError(err);
-								assert.equal(raw, 'admin will see this');
-								done();
-							});
-						});
-					});
-				});
-			});
+		it('should return not allowed error if mid is not in room', async () => {
+			const uids = await User.create({ username: 'dummy' });
+			let { body } = await callv3API('post', '/chats', { uids: [uids] }, 'baz');
+			const myRoomId = body.response.roomId;
+			assert(myRoomId);
+
+			try {
+				await util.promisify(socketModules.chats.getRaw)({ uid: mocks.users.baz.uid }, { mid: 200 });
+			} catch (err) {
+				assert(err);
+				assert.equal(err.message, '[[error:not-allowed]]');
+			}
+
+			({ body } = await callv3API('post', `/chats/${myRoomId}`, { roomId: myRoomId, message: 'admin will see this' }, 'baz'));
+			const message = body.response;
+			const raw = await util.promisify(socketModules.chats.getRaw)({ uid: mocks.users.foo.uid }, { mid: message.mid });
+			assert.equal(raw, 'admin will see this');
 		});
 
 
 		it('should notify offline users of message', async () => {
 			meta.config.notificationSendDelay = 0.1;
 
-			const roomId = await socketModules.chats.newRoom({ uid: fooUid }, { touid: bazUid });
+			const { body } = await callv3API('post', '/chats', { uids: [mocks.users.baz.uid] }, 'foo');
+			const { roomId } = body.response;
 			assert(roomId);
-			await socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: roomId, username: 'herp' });
-			await db.sortedSetAdd('users:online', Date.now() - ((meta.config.onlineCutoff * 60000) + 50000), herpUid);
-			await socketModules.chats.send({ uid: fooUid }, { roomId: roomId, message: 'second chat message **bold** text' });
 
+			await socketModules.chats.addUserToRoom({ uid: mocks.users.foo.uid }, { roomId: roomId, username: 'herp' });
+			await db.sortedSetAdd('users:online', Date.now() - ((meta.config.onlineCutoff * 60000) + 50000), mocks.users.herp.uid);
+
+			await callv3API('post', `/chats/${roomId}`, { roomId: roomId, message: 'second chat message **bold** text' }, 'foo');
 			await sleep(3000);
-			const data = await User.notifications.get(herpUid);
+			const data = await User.notifications.get(mocks.users.herp.uid);
 			assert(data.unread[0]);
 			const notification = data.unread[0];
 			assert.strictEqual(notification.bodyShort, '[[notifications:new_message_from, foo]]');
-			assert.strictEqual(notification.nid, `chat_${fooUid}_${roomId}`);
+			assert.strictEqual(notification.nid, `chat_${mocks.users.foo.uid}_${roomId}`);
 			assert.strictEqual(notification.path, `${nconf.get('relative_path')}/chats/${roomId}`);
 		});
 
 		it('should fail to get messages from room with invalid data', (done) => {
 			socketModules.chats.getMessages({ uid: null }, null, (err) => {
 				assert.equal(err.message, '[[error:invalid-data]]');
-				socketModules.chats.getMessages({ uid: fooUid }, null, (err) => {
+				socketModules.chats.getMessages({ uid: mocks.users.foo.uid }, null, (err) => {
 					assert.equal(err.message, '[[error:invalid-data]]');
-					socketModules.chats.getMessages({ uid: fooUid }, { uid: null }, (err) => {
+					socketModules.chats.getMessages({ uid: mocks.users.foo.uid }, { uid: null }, (err) => {
 						assert.equal(err.message, '[[error:invalid-data]]');
-						socketModules.chats.getMessages({ uid: fooUid }, { uid: 1, roomId: null }, (err) => {
+						socketModules.chats.getMessages({ uid: mocks.users.foo.uid }, { uid: 1, roomId: null }, (err) => {
 							assert.equal(err.message, '[[error:invalid-data]]');
 							done();
 						});
@@ -434,15 +474,18 @@ describe('Messaging Library', () => {
 		});
 
 		it('should get messages from room', (done) => {
-			socketModules.chats.getMessages({ uid: fooUid }, {
-				uid: fooUid,
+			socketModules.chats.getMessages({ uid: mocks.users.foo.uid }, {
+				uid: mocks.users.foo.uid,
 				roomId: roomId,
 				start: 0,
 			}, (err, messages) => {
 				assert.ifError(err);
 				assert(Array.isArray(messages));
-				assert.equal(messages[4].roomId, roomId);
-				assert.equal(messages[4].fromuid, fooUid);
+
+				// Filter out system messages
+				messages = messages.filter(message => !message.system);
+				assert.equal(messages[0].roomId, roomId);
+				assert.equal(messages[0].fromuid, mocks.users.foo.uid);
 				done();
 			});
 		});
@@ -450,7 +493,7 @@ describe('Messaging Library', () => {
 		it('should fail to mark read with invalid data', (done) => {
 			socketModules.chats.markRead({ uid: null }, roomId, (err) => {
 				assert.equal(err.message, '[[error:invalid-data]]');
-				socketModules.chats.markRead({ uid: fooUid }, null, (err) => {
+				socketModules.chats.markRead({ uid: mocks.users.foo.uid }, null, (err) => {
 					assert.equal(err.message, '[[error:invalid-data]]');
 					done();
 				});
@@ -458,32 +501,32 @@ describe('Messaging Library', () => {
 		});
 
 		it('should not error if user is not in room', (done) => {
-			socketModules.chats.markRead({ uid: herpUid }, 10, (err) => {
+			socketModules.chats.markRead({ uid: mocks.users.herp.uid }, 10, (err) => {
 				assert.ifError(err);
 				done();
 			});
 		});
 
 		it('should mark room read', (done) => {
-			socketModules.chats.markRead({ uid: fooUid }, roomId, (err) => {
+			socketModules.chats.markRead({ uid: mocks.users.foo.uid }, roomId, (err) => {
 				assert.ifError(err);
 				done();
 			});
 		});
 
 		it('should mark all rooms read', (done) => {
-			socketModules.chats.markAllRead({ uid: fooUid }, {}, (err) => {
+			socketModules.chats.markAllRead({ uid: mocks.users.foo.uid }, {}, (err) => {
 				assert.ifError(err);
 				done();
 			});
 		});
 
 		it('should fail to rename room with invalid data', (done) => {
-			socketModules.chats.renameRoom({ uid: fooUid }, null, (err) => {
+			socketModules.chats.renameRoom({ uid: mocks.users.foo.uid }, null, (err) => {
 				assert.equal(err.message, '[[error:invalid-data]]');
-				socketModules.chats.renameRoom({ uid: fooUid }, { roomId: null }, (err) => {
+				socketModules.chats.renameRoom({ uid: mocks.users.foo.uid }, { roomId: null }, (err) => {
 					assert.equal(err.message, '[[error:invalid-data]]');
-					socketModules.chats.renameRoom({ uid: fooUid }, { roomId: roomId, newName: null }, (err) => {
+					socketModules.chats.renameRoom({ uid: mocks.users.foo.uid }, { roomId: roomId, newName: null }, (err) => {
 						assert.equal(err.message, '[[error:invalid-data]]');
 						done();
 					});
@@ -492,26 +535,30 @@ describe('Messaging Library', () => {
 		});
 
 		it('should rename room', (done) => {
-			socketModules.chats.renameRoom({ uid: fooUid }, { roomId: roomId, newName: 'new room name' }, (err) => {
+			socketModules.chats.renameRoom({ uid: mocks.users.foo.uid }, { roomId: roomId, newName: 'new room name' }, (err) => {
 				assert.ifError(err);
 				done();
 			});
 		});
 
 		it('should send a room-rename system message when a room is renamed', (done) => {
-			socketModules.chats.getMessages({ uid: fooUid }, { uid: fooUid, roomId: roomId, start: 0 }, (err, messages) => {
-				assert.ifError(err);
-				const message = messages.pop();
-				assert.strictEqual(message.system, true);
-				assert.strictEqual(message.content, 'room-rename, new room name');
-				done();
-			});
+			socketModules.chats.getMessages(
+				{ uid: mocks.users.foo.uid },
+				{ uid: mocks.users.foo.uid, roomId: roomId, start: 0 },
+				(err, messages) => {
+					assert.ifError(err);
+					const message = messages.pop();
+					assert.strictEqual(message.system, true);
+					assert.strictEqual(message.content, 'room-rename, new room name');
+					done();
+				}
+			);
 		});
 
 		it('should fail to load room with invalid-data', (done) => {
-			socketModules.chats.loadRoom({ uid: fooUid }, null, (err) => {
+			socketModules.chats.loadRoom({ uid: mocks.users.foo.uid }, null, (err) => {
 				assert.equal(err.message, '[[error:invalid-data]]');
-				socketModules.chats.loadRoom({ uid: fooUid }, { roomId: null }, (err) => {
+				socketModules.chats.loadRoom({ uid: mocks.users.foo.uid }, { roomId: null }, (err) => {
 					assert.equal(err.message, '[[error:invalid-data]]');
 					done();
 				});
@@ -526,7 +573,7 @@ describe('Messaging Library', () => {
 		});
 
 		it('should load chat room', (done) => {
-			socketModules.chats.loadRoom({ uid: fooUid }, { roomId: roomId }, (err, data) => {
+			socketModules.chats.loadRoom({ uid: mocks.users.foo.uid }, { roomId: roomId }, (err, data) => {
 				assert.ifError(err);
 				assert(data);
 				assert.equal(data.roomName, 'new room name');
@@ -535,9 +582,9 @@ describe('Messaging Library', () => {
 		});
 
 		it('should return true if user is dnd', (done) => {
-			db.setObjectField(`user:${herpUid}`, 'status', 'dnd', (err) => {
+			db.setObjectField(`user:${mocks.users.herp.uid}`, 'status', 'dnd', (err) => {
 				assert.ifError(err);
-				socketModules.chats.isDnD({ uid: fooUid }, herpUid, (err, isDnD) => {
+				socketModules.chats.isDnD({ uid: mocks.users.foo.uid }, mocks.users.herp.uid, (err, isDnD) => {
 					assert.ifError(err);
 					assert(isDnD);
 					done();
@@ -546,11 +593,11 @@ describe('Messaging Library', () => {
 		});
 
 		it('should fail to load recent chats with invalid data', (done) => {
-			socketModules.chats.getRecentChats({ uid: fooUid }, null, (err) => {
+			socketModules.chats.getRecentChats({ uid: mocks.users.foo.uid }, null, (err) => {
 				assert.equal(err.message, '[[error:invalid-data]]');
-				socketModules.chats.getRecentChats({ uid: fooUid }, { after: null }, (err) => {
+				socketModules.chats.getRecentChats({ uid: mocks.users.foo.uid }, { after: null }, (err) => {
 					assert.equal(err.message, '[[error:invalid-data]]');
-					socketModules.chats.getRecentChats({ uid: fooUid }, { after: 0, uid: null }, (err) => {
+					socketModules.chats.getRecentChats({ uid: mocks.users.foo.uid }, { after: 0, uid: null }, (err) => {
 						assert.equal(err.message, '[[error:invalid-data]]');
 						done();
 					});
@@ -559,28 +606,31 @@ describe('Messaging Library', () => {
 		});
 
 		it('should load recent chats of user', (done) => {
-			socketModules.chats.getRecentChats({ uid: fooUid }, { after: 0, uid: fooUid }, (err, data) => {
-				assert.ifError(err);
-				assert(Array.isArray(data.rooms));
-				done();
-			});
-		});
-
-		it('should escape teaser', (done) => {
-			socketModules.chats.send({ uid: fooUid }, { roomId: roomId, message: '<svg/onload=alert(document.location);' }, (err) => {
-				assert.ifError(err);
-				socketModules.chats.getRecentChats({ uid: fooUid }, { after: 0, uid: fooUid }, (err, data) => {
+			socketModules.chats.getRecentChats(
+				{ uid: mocks.users.foo.uid },
+				{ after: 0, uid: mocks.users.foo.uid },
+				(err, data) => {
 					assert.ifError(err);
-					assert.equal(data.rooms[0].teaser.content, '&lt;svg&#x2F;onload=alert(document.location);');
+					assert(Array.isArray(data.rooms));
 					done();
-				});
-			});
+				}
+			);
+		});
+
+		it('should escape teaser', async () => {
+			await callv3API('post', `/chats/${roomId}`, { roomId: roomId, message: '<svg/onload=alert(document.location);' }, 'foo');
+			const data = await util.promisify(socketModules.chats.getRecentChats)(
+				{ uid: mocks.users.foo.uid },
+				{ after: 0, uid: mocks.users.foo.uid }
+			);
+
+			assert.equal(data.rooms[0].teaser.content, '&lt;svg&#x2F;onload=alert(document.location);');
 		});
 
 		it('should fail to check if user has private chat with invalid data', (done) => {
 			socketModules.chats.hasPrivateChat({ uid: null }, null, (err) => {
 				assert.equal(err.message, '[[error:invalid-data]]');
-				socketModules.chats.hasPrivateChat({ uid: fooUid }, null, (err) => {
+				socketModules.chats.hasPrivateChat({ uid: mocks.users.foo.uid }, null, (err) => {
 					assert.equal(err.message, '[[error:invalid-data]]');
 					done();
 				});
@@ -588,7 +638,7 @@ describe('Messaging Library', () => {
 		});
 
 		it('should check if user has private chat with another uid', (done) => {
-			socketModules.chats.hasPrivateChat({ uid: fooUid }, herpUid, (err, roomId) => {
+			socketModules.chats.hasPrivateChat({ uid: mocks.users.foo.uid }, mocks.users.herp.uid, (err, roomId) => {
 				assert.ifError(err);
 				assert(roomId);
 				done();
@@ -601,21 +651,23 @@ describe('Messaging Library', () => {
 		let mid;
 		let mid2;
 		before(async () => {
-			await socketModules.chats.addUserToRoom({ uid: fooUid }, { roomId: roomId, username: 'baz' });
-			mid = (await socketModules.chats.send({ uid: fooUid }, { roomId: roomId, message: 'first chat message' })).mid;
-			mid2 = (await socketModules.chats.send({ uid: bazUid }, { roomId: roomId, message: 'second chat message' })).mid;
+			await socketModules.chats.addUserToRoom({ uid: mocks.users.foo.uid }, { roomId: roomId, username: 'baz' });
+			let { body } = await callv3API('post', `/chats/${roomId}`, { roomId: roomId, message: 'first chat message' }, 'foo');
+			mid = body.response.mid;
+			({ body } = await callv3API('post', `/chats/${roomId}`, { roomId: roomId, message: 'second chat message' }, 'baz'));
+			mid2 = body.response.mid;
 		});
 
 		after(async () => {
-			await socketModules.chats.leave({ uid: bazUid }, roomId);
+			await socketModules.chats.leave({ uid: mocks.users.baz.uid }, roomId);
 		});
 
 		it('should fail to edit message with invalid data', (done) => {
-			socketModules.chats.edit({ uid: fooUid }, null, (err) => {
+			socketModules.chats.edit({ uid: mocks.users.foo.uid }, null, (err) => {
 				assert.equal(err.message, '[[error:invalid-data]]');
-				socketModules.chats.edit({ uid: fooUid }, { roomId: null }, (err) => {
+				socketModules.chats.edit({ uid: mocks.users.foo.uid }, { roomId: null }, (err) => {
 					assert.equal(err.message, '[[error:invalid-data]]');
-					socketModules.chats.edit({ uid: fooUid }, { roomId: 1, message: null }, (err) => {
+					socketModules.chats.edit({ uid: mocks.users.foo.uid }, { roomId: 1, message: null }, (err) => {
 						assert.equal(err.message, '[[error:invalid-data]]');
 						done();
 					});
@@ -624,23 +676,23 @@ describe('Messaging Library', () => {
 		});
 
 		it('should fail to edit message if new content is empty string', (done) => {
-			socketModules.chats.edit({ uid: fooUid }, { mid: mid, roomId: roomId, message: ' ' }, (err) => {
+			socketModules.chats.edit({ uid: mocks.users.foo.uid }, { mid: mid, roomId: roomId, message: ' ' }, (err) => {
 				assert.equal(err.message, '[[error:invalid-chat-message]]');
 				done();
 			});
 		});
 
 		it('should fail to edit message if not own message', (done) => {
-			socketModules.chats.edit({ uid: herpUid }, { mid: mid, roomId: roomId, message: 'message edited' }, (err) => {
+			socketModules.chats.edit({ uid: mocks.users.herp.uid }, { mid: mid, roomId: roomId, message: 'message edited' }, (err) => {
 				assert.equal(err.message, '[[error:cant-edit-chat-message]]');
 				done();
 			});
 		});
 
 		it('should edit message', (done) => {
-			socketModules.chats.edit({ uid: fooUid }, { mid: mid, roomId: roomId, message: 'message edited' }, (err) => {
+			socketModules.chats.edit({ uid: mocks.users.foo.uid }, { mid: mid, roomId: roomId, message: 'message edited' }, (err) => {
 				assert.ifError(err);
-				socketModules.chats.getRaw({ uid: fooUid }, { mid: mid }, (err, raw) => {
+				socketModules.chats.getRaw({ uid: mocks.users.foo.uid }, { mid: mid }, (err, raw) => {
 					assert.ifError(err);
 					assert.equal(raw, 'message edited');
 					done();
@@ -649,11 +701,11 @@ describe('Messaging Library', () => {
 		});
 
 		it('should fail to delete message with invalid data', (done) => {
-			socketModules.chats.delete({ uid: fooUid }, null, (err) => {
+			socketModules.chats.delete({ uid: mocks.users.foo.uid }, null, (err) => {
 				assert.equal(err.message, '[[error:invalid-data]]');
-				socketModules.chats.delete({ uid: fooUid }, { roomId: null }, (err) => {
+				socketModules.chats.delete({ uid: mocks.users.foo.uid }, { roomId: null }, (err) => {
 					assert.equal(err.message, '[[error:invalid-data]]');
-					socketModules.chats.delete({ uid: fooUid }, { roomId: 1, messageId: null }, (err) => {
+					socketModules.chats.delete({ uid: mocks.users.foo.uid }, { roomId: 1, messageId: null }, (err) => {
 						assert.equal(err.message, '[[error:invalid-data]]');
 						done();
 					});
@@ -662,14 +714,14 @@ describe('Messaging Library', () => {
 		});
 
 		it('should fail to delete message if not owner', (done) => {
-			socketModules.chats.delete({ uid: herpUid }, { messageId: mid, roomId: roomId }, (err) => {
+			socketModules.chats.delete({ uid: mocks.users.herp.uid }, { messageId: mid, roomId: roomId }, (err) => {
 				assert.equal(err.message, '[[error:cant-delete-chat-message]]');
 				done();
 			});
 		});
 
 		it('should mark the message as deleted', (done) => {
-			socketModules.chats.delete({ uid: fooUid }, { messageId: mid, roomId: roomId }, (err) => {
+			socketModules.chats.delete({ uid: mocks.users.foo.uid }, { messageId: mid, roomId: roomId }, (err) => {
 				assert.ifError(err);
 				db.getObjectField(`message:${mid}`, 'deleted', (err, value) => {
 					assert.ifError(err);
@@ -680,39 +732,47 @@ describe('Messaging Library', () => {
 		});
 
 		it('should show deleted message to original users', (done) => {
-			socketModules.chats.getMessages({ uid: fooUid }, { uid: fooUid, roomId: roomId, start: 0 }, (err, messages) => {
-				assert.ifError(err);
+			socketModules.chats.getMessages(
+				{ uid: mocks.users.foo.uid },
+				{ uid: mocks.users.foo.uid, roomId: roomId, start: 0 },
+				(err, messages) => {
+					assert.ifError(err);
 
-				// Reduce messages to their mids
-				const mids = messages.reduce((mids, cur) => {
-					mids.push(cur.messageId);
-					return mids;
-				}, []);
+					// Reduce messages to their mids
+					const mids = messages.reduce((mids, cur) => {
+						mids.push(cur.messageId);
+						return mids;
+					}, []);
 
-				assert(mids.includes(mid));
-				done();
-			});
+					assert(mids.includes(mid));
+					done();
+				}
+			);
 		});
 
 		it('should not show deleted message to other users', (done) => {
-			socketModules.chats.getMessages({ uid: herpUid }, { uid: herpUid, roomId: roomId, start: 0 }, (err, messages) => {
-				assert.ifError(err);
-				messages.forEach((msg) => {
-					assert(!msg.deleted || msg.content === '[[modules:chat.message-deleted]]', msg.content);
-				});
-				done();
-			});
+			socketModules.chats.getMessages(
+				{ uid: mocks.users.herp.uid },
+				{ uid: mocks.users.herp.uid, roomId: roomId, start: 0 },
+				(err, messages) => {
+					assert.ifError(err);
+					messages.forEach((msg) => {
+						assert(!msg.deleted || msg.content === '[[modules:chat.message-deleted]]', msg.content);
+					});
+					done();
+				}
+			);
 		});
 
 		it('should error out if a message is deleted again', (done) => {
-			socketModules.chats.delete({ uid: fooUid }, { messageId: mid, roomId: roomId }, (err) => {
+			socketModules.chats.delete({ uid: mocks.users.foo.uid }, { messageId: mid, roomId: roomId }, (err) => {
 				assert.strictEqual('[[error:chat-deleted-already]]', err.message);
 				done();
 			});
 		});
 
 		it('should restore the message', (done) => {
-			socketModules.chats.restore({ uid: fooUid }, { messageId: mid, roomId: roomId }, (err) => {
+			socketModules.chats.restore({ uid: mocks.users.foo.uid }, { messageId: mid, roomId: roomId }, (err) => {
 				assert.ifError(err);
 				db.getObjectField(`message:${mid}`, 'deleted', (err, value) => {
 					assert.ifError(err);
@@ -723,7 +783,7 @@ describe('Messaging Library', () => {
 		});
 
 		it('should error out if a message is restored again', (done) => {
-			socketModules.chats.restore({ uid: fooUid }, { messageId: mid, roomId: roomId }, (err) => {
+			socketModules.chats.restore({ uid: mocks.users.foo.uid }, { messageId: mid, roomId: roomId }, (err) => {
 				assert.strictEqual('[[error:chat-restored-already]]', err.message);
 				done();
 			});
@@ -740,54 +800,59 @@ describe('Messaging Library', () => {
 
 			it('should error out for regular users', async () => {
 				try {
-					await socketModules.chats.delete({ uid: bazUid }, { messageId: mid2, roomId: roomId });
+					await socketModules.chats.delete({ uid: mocks.users.baz.uid }, { messageId: mid2, roomId: roomId });
 				} catch (err) {
 					assert.strictEqual('[[error:chat-message-editing-disabled]]', err.message);
 				}
 			});
 
 			it('should succeed for administrators', async () => {
-				await socketModules.chats.delete({ uid: fooUid }, { messageId: mid2, roomId: roomId });
-				await socketModules.chats.restore({ uid: fooUid }, { messageId: mid2, roomId: roomId });
+				await socketModules.chats.delete({ uid: mocks.users.foo.uid }, { messageId: mid2, roomId: roomId });
+				await socketModules.chats.restore({ uid: mocks.users.foo.uid }, { messageId: mid2, roomId: roomId });
 			});
 
 			it('should succeed for global moderators', async () => {
-				await Groups.join(['Global Moderators'], bazUid);
+				await Groups.join(['Global Moderators'], mocks.users.baz.uid);
 
-				await socketModules.chats.delete({ uid: fooUid }, { messageId: mid2, roomId: roomId });
-				await socketModules.chats.restore({ uid: fooUid }, { messageId: mid2, roomId: roomId });
+				await socketModules.chats.delete({ uid: mocks.users.foo.uid }, { messageId: mid2, roomId: roomId });
+				await socketModules.chats.restore({ uid: mocks.users.foo.uid }, { messageId: mid2, roomId: roomId });
 
-				await Groups.leave(['Global Moderators'], bazUid);
+				await Groups.leave(['Global Moderators'], mocks.users.baz.uid);
 			});
 		});
 	});
 
 	describe('controller', () => {
-		it('should 404 if chat is disabled', (done) => {
+		it('should 404 if chat is disabled', async () => {
 			meta.config.disableChat = 1;
-			request(`${nconf.get('url')}/user/baz/chats`, (err, response) => {
-				assert.ifError(err);
-				assert.equal(response.statusCode, 404);
-				done();
+			const response = await request(`${nconf.get('url')}/user/baz/chats`, {
+				resolveWithFullResponse: true,
+				simple: false,
 			});
+
+			assert.equal(response.statusCode, 404);
 		});
 
-		it('should 500 for guest with no privilege error', (done) => {
+		it('should 500 for guest with no privilege error', async () => {
 			meta.config.disableChat = 0;
-			request(`${nconf.get('url')}/api/user/baz/chats`, { json: true }, (err, response, body) => {
-				assert.ifError(err);
-				assert.equal(response.statusCode, 500);
-				assert.equal(body.error, '[[error:no-privileges]]');
-				done();
+			const response = await request(`${nconf.get('url')}/api/user/baz/chats`, {
+				resolveWithFullResponse: true,
+				simple: false,
+				json: true,
 			});
+			const { body } = response;
+
+			assert.equal(response.statusCode, 500);
+			assert.equal(body.error, '[[error:no-privileges]]');
 		});
 
-		it('should 404 for non-existent user', (done) => {
-			request(`${nconf.get('url')}/user/doesntexist/chats`, (err, response) => {
-				assert.ifError(err);
-				assert.equal(response.statusCode, 404);
-				done();
+		it('should 404 for non-existent user', async () => {
+			const response = await request(`${nconf.get('url')}/user/doesntexist/chats`, {
+				resolveWithFullResponse: true,
+				simple: false,
 			});
+
+			assert.equal(response.statusCode, 404);
 		});
 	});
 
@@ -797,46 +862,59 @@ describe('Messaging Library', () => {
 			({ jar } = await helpers.loginUser('herp', 'derpderp'));
 		});
 
-		it('should return chats page data', (done) => {
-			request(`${nconf.get('url')}/api/user/herp/chats`, { json: true, jar: jar }, (err, response, body) => {
-				assert.ifError(err);
-				assert.equal(response.statusCode, 200);
-				assert(Array.isArray(body.rooms));
-				assert.equal(body.rooms.length, 2);
-				assert.equal(body.title, '[[pages:chats]]');
-				done();
+		it('should return chats page data', async () => {
+			const response = await request(`${nconf.get('url')}/api/user/herp/chats`, {
+				resolveWithFullResponse: true,
+				simple: false,
+				json: true,
+				jar,
 			});
+			const { body } = response;
+
+			assert.equal(response.statusCode, 200);
+			assert(Array.isArray(body.rooms));
+			assert.equal(body.rooms.length, 2);
+			assert.equal(body.title, '[[pages:chats]]');
 		});
 
-		it('should return room data', (done) => {
-			request(`${nconf.get('url')}/api/user/herp/chats/${roomId}`, { json: true, jar: jar }, (err, response, body) => {
-				assert.ifError(err);
-				assert.equal(response.statusCode, 200);
-				assert.equal(body.roomId, roomId);
-				assert.equal(body.isOwner, false);
-				done();
+		it('should return room data', async () => {
+			const response = await request(`${nconf.get('url')}/api/user/herp/chats/${roomId}`, {
+				resolveWithFullResponse: true,
+				simple: false,
+				json: true,
+				jar,
 			});
+			const { body } = response;
+
+			assert.equal(response.statusCode, 200);
+			assert.equal(body.roomId, roomId);
+			assert.equal(body.isOwner, false);
 		});
 
-		it('should redirect to chats page', (done) => {
-			request(`${nconf.get('url')}/api/chats`, { jar: jar, json: true }, (err, res, body) => {
-				assert.ifError(err);
-				assert.equal(res.statusCode, 200);
-				assert.equal(res.headers['x-redirect'], '/user/herp/chats');
-				assert.equal(body, '/user/herp/chats');
-				done();
+		it('should redirect to chats page', async () => {
+			const res = await request(`${nconf.get('url')}/api/chats`, {
+				resolveWithFullResponse: true,
+				simple: false,
+				jar,
+				json: true,
 			});
+			const { body } = res;
+
+			assert.equal(res.statusCode, 200);
+			assert.equal(res.headers['x-redirect'], '/user/herp/chats');
+			assert.equal(body, '/user/herp/chats');
 		});
 
-		it('should return 404 if user is not in room', (done) => {
-			helpers.loginUser('baz', 'quuxquux', (err, data) => {
-				assert.ifError(err);
-				request(`${nconf.get('url')}/api/user/baz/chats/${roomId}`, { json: true, jar: data.jar }, (err, response) => {
-					assert.ifError(err);
-					assert.equal(response.statusCode, 404);
-					done();
-				});
+		it('should return 404 if user is not in room', async () => {
+			const data = await util.promisify(helpers.loginUser)('baz', 'quuxquux');
+			const response = await request(`${nconf.get('url')}/api/user/baz/chats/${roomId}`, {
+				resolveWithFullResponse: true,
+				simple: false,
+				json: true,
+				jar: data.jar,
 			});
+
+			assert.equal(response.statusCode, 404);
 		});
 	});
 });