System chat messages (#7771)

* fix: removed duplicate checkContent call in addMessage

addMessage is called in one place (sendMessage), and the checks
are already contained there. addMessage is the lower level call
and so should be called only from within core itself.

* feat: #7330 chat system messages for join, leave, rename

* fix: add back content checking in .addMessage();

* fix: tests, and added .addSystemMessage() method

Tests were relying on message indices that changed due to the
new system messages.

* feat: add tests for system chat messages

* refactor: rewrite half of src/messaging/rooms.js, fix tests

* feat: #7743 messaging/room.js

* fix: tests for messaging/room.js, #7743

* fix: trying to fix tests

* fix: omg :rage2:

public/language/en-GB/modules.json

@@ -35,6 +35,10 @@
 	"chat.show-ip": "Show IP",
 	"chat.owner": "Room Owner",
 
+	"chat.system.user-join": "%1 has joined the room",
+	"chat.system.user-leave": "%1 has left the room",
+	"chat.system.room-rename": "%2 has renamed this room: %1",
+
 	"composer.compose": "Compose",
 	"composer.show_preview": "Show Preview",
 	"composer.hide_preview": "Hide Preview",

public/src/client/chats/messages.js

@@ -94,11 +94,19 @@ define('forum/chats/messages', ['components', 'sounds', 'translator', 'benchpres
 
 
 	messages.parseMessage = function (data, callback) {
-		Benchpress.parse('partials/chats/message' + (Array.isArray(data) ? 's' : ''), {
-			messages: data,
-		}, function (html) {
+		function done(html) {
 			translator.translate(html, callback);
-		});
+		}
+
+		if (Array.isArray(data)) {
+			Benchpress.parse('partials/chats/message' + (Array.isArray(data) ? 's' : ''), {
+				messages: data,
+			}, done);
+		} else {
+			Benchpress.parse('partials/chats/' + (data.system ? 'system-message' : 'message'), {
+				messages: data,
+			}, done);
+		}
 	};
 
 

src/messaging/create.js

@@ -53,6 +53,7 @@ module.exports = function (Messaging) {
 		var mid;
 		var message;
 		var isNewSet;
+		const timestamp = data.timestamp || new Date().getTime();
 
 		async.waterfall([
 			function (next) {
@@ -65,10 +66,11 @@ module.exports = function (Messaging) {
 				mid = _mid;
 				message = {
 					content: String(data.content),
-					timestamp: data.timestamp,
+					timestamp: timestamp,
 					fromuid: data.uid,
 					roomId: data.roomId,
 					deleted: 0,
+					system: data.system || 0,
 				};
 				if (data.ip) {
 					message.ip = data.ip;
@@ -80,7 +82,7 @@ module.exports = function (Messaging) {
 				db.setObject('message:' + mid, message, next);
 			},
 			function (next) {
-				Messaging.isNewSet(data.uid, data.roomId, data.timestamp, next);
+				Messaging.isNewSet(data.uid, data.roomId, timestamp, next);
 			},
 			function (_isNewSet, next) {
 				isNewSet = _isNewSet;
@@ -91,8 +93,8 @@ module.exports = function (Messaging) {
 			},
 			function (uids, next) {
 				async.parallel([
-					async.apply(Messaging.addRoomToUsers, data.roomId, uids, data.timestamp),
-					async.apply(Messaging.addMessageToUsers, data.roomId, uids, mid, data.timestamp),
+					async.apply(Messaging.addRoomToUsers, data.roomId, uids, timestamp),
+					async.apply(Messaging.addMessageToUsers, data.roomId, uids, mid, timestamp),
 					async.apply(Messaging.markUnread, uids, data.roomId),
 				], next);
 			},
@@ -115,6 +117,16 @@ module.exports = function (Messaging) {
 		], callback);
 	};
 
+	Messaging.addSystemMessage = async (content, uid, roomId) => {
+		const message = await Messaging.addMessage({
+			content: content,
+			uid: uid,
+			roomId: roomId,
+			system: 1,
+		});
+		Messaging.notifyUsersInRoom(uid, roomId, message);
+	};
+
 	Messaging.addRoomToUsers = function (roomId, uids, timestamp, callback) {
 		if (!uids.length) {
 			return callback();

src/messaging/data.js

@@ -7,7 +7,7 @@ var user = require('../user');
 var utils = require('../utils');
 var plugins = require('../plugins');
 
-const intFields = ['timestamp', 'edited', 'fromuid', 'roomId', 'deleted'];
+const intFields = ['timestamp', 'edited', 'fromuid', 'roomId', 'deleted', 'system'];
 
 module.exports = function (Messaging) {
 	Messaging.newMessageCutoff = 1000 * 60 * 3;
@@ -86,9 +86,14 @@ module.exports = function (Messaging) {
 					message.newSet = false;
 					message.roomId = String(message.roomId || roomId);
 					message.deleted = !!message.deleted;
+					message.system = !!message.system;
 				});
 
 				async.map(messages, function (message, next) {
+					if (message.system) {
+						return setImmediate(next, null, message);
+					}
+
 					Messaging.parse(message.content, message.fromuid, uid, roomId, isNew, function (err, result) {
 						if (err) {
 							return next(err);

src/messaging/index.js

@@ -259,11 +259,11 @@ Messaging.getLatestUndeletedMessage = function (uid, roomId, callback) {
 						done = true;
 						return next();
 					}
-					Messaging.getMessageField(mids[0], 'deleted', _next);
+					Messaging.getMessageFields(mids[0], ['deleted', 'system'], _next);
 				},
-				function (deleted, _next) {
-					done = !deleted;
-					if (!deleted) {
+				function (states, _next) {
+					done = !states.deleted && !states.system;
+					if (done) {
 						latestMid = mids[0];
 					}
 					index += 1;

src/messaging/rooms.js

@@ -1,6 +1,5 @@
 'use strict';
 
-var async = require('async');
 var validator = require('validator');
 
 var db = require('../database');
@@ -10,34 +9,23 @@ var privileges = require('../privileges');
 var meta = require('../meta');
 
 module.exports = function (Messaging) {
-	Messaging.getRoomData = function (roomId, callback) {
-		async.waterfall([
-			function (next) {
-				db.getObject('chat:room:' + roomId, next);
-			},
-			function (data, next) {
-				if (!data) {
-					return callback(new Error('[[error:no-chat-room]]'));
-				}
-				modifyRoomData([data]);
-				next(null, data);
-			},
-		], callback);
+	Messaging.getRoomData = async (roomId) => {
+		const data = await db.getObject('chat:room:' + roomId);
+		if (!data) {
+			throw new Error('[[error:no-chat-room]]');
+		}
+
+		modifyRoomData([data]);
+		return data;
 	};
 
-	Messaging.getRoomsData = function (roomIds, callback) {
-		var keys = roomIds.map(function (roomId) {
+	Messaging.getRoomsData = async (roomIds) => {
+		const roomData = await db.getObjects(roomIds.map(function (roomId) {
 			return 'chat:room:' + roomId;
-		});
-		async.waterfall([
-			function (next) {
-				db.getObjects(keys, next);
-			},
-			function (roomData, next) {
-				modifyRoomData(roomData);
-				next(null, roomData);
-			},
-		], callback);
+		}));
+
+		modifyRoomData(roomData);
+		return roomData;
 	};
 
 	function modifyRoomData(rooms) {
@@ -52,284 +40,204 @@ module.exports = function (Messaging) {
 		});
 	}
 
-	Messaging.newRoom = function (uid, toUids, callback) {
-		var roomId;
-		var now = Date.now();
-		async.waterfall([
-			function (next) {
-				db.incrObjectField('global', 'nextChatRoomId', next);
-			},
-			function (_roomId, next) {
-				roomId = _roomId;
-				var room = {
-					owner: uid,
-					roomId: roomId,
-				};
-				db.setObject('chat:room:' + roomId, room, next);
-			},
-			function (next) {
-				db.sortedSetAdd('chat:room:' + roomId + ':uids', now, uid, next);
-			},
-			function (next) {
-				Messaging.addUsersToRoom(uid, toUids, roomId, next);
-			},
-			function (next) {
-				Messaging.addRoomToUsers(roomId, [uid].concat(toUids), now, next);
-			},
-			function (next) {
-				next(null, roomId);
-			},
-		], callback);
-	};
+	Messaging.newRoom = async (uid, toUids) => {
+		const now = Date.now();
+		const roomId = await db.incrObjectField('global', 'nextChatRoomId');
+		const room = {
+			owner: uid,
+			roomId: roomId,
+		};
 
-	Messaging.isUserInRoom = function (uid, roomId, callback) {
-		async.waterfall([
-			function (next) {
-				db.isSortedSetMember('chat:room:' + roomId + ':uids', uid, next);
-			},
-			function (inRoom, next) {
-				plugins.fireHook('filter:messaging.isUserInRoom', { uid: uid, roomId: roomId, inRoom: inRoom }, next);
-			},
-			function (data, next) {
-				next(null, data.inRoom);
-			},
-		], callback);
-	};
+		await Promise.all([
+			db.setObject('chat:room:' + roomId, room),
+			db.sortedSetAdd('chat:room:' + roomId + ':uids', now, uid),
+		]);
+		await Promise.all([
+			Messaging.addUsersToRoom(uid, toUids, roomId),
+			Messaging.addRoomToUsers(roomId, [uid].concat(toUids), now),
+		]);
 
-	Messaging.roomExists = function (roomId, callback) {
-		db.exists('chat:room:' + roomId + ':uids', callback);
+		return roomId;
 	};
 
-	Messaging.getUserCountInRoom = function (roomId, callback) {
-		db.sortedSetCard('chat:room:' + roomId + ':uids', callback);
+	Messaging.isUserInRoom = async (uid, roomId) => {
+		const inRoom = db.isSortedSetMember('chat:room:' + roomId + ':uids', uid);
+		const data = await plugins.fireHook('filter:messaging.isUserInRoom', { uid: uid, roomId: roomId, inRoom: inRoom });
+		return data.inRoom;
 	};
 
-	Messaging.isRoomOwner = function (uid, roomId, callback) {
-		async.waterfall([
-			function (next) {
-				db.getObjectField('chat:room:' + roomId, 'owner', next);
-			},
-			function (owner, next) {
-				next(null, parseInt(uid, 10) === parseInt(owner, 10));
-			},
-		], callback);
+	Messaging.roomExists = async roomId => db.exists('chat:room:' + roomId + ':uids');
+
+	Messaging.getUserCountInRoom = async roomId => db.sortedSetCard('chat:room:' + roomId + ':uids');
+
+	Messaging.isRoomOwner = async (uid, roomId) => {
+		const owner = await db.getObjectField('chat:room:' + roomId, 'owner');
+		return parseInt(uid, 10) === parseInt(owner, 10);
 	};
 
-	Messaging.addUsersToRoom = function (uid, uids, roomId, callback) {
-		async.waterfall([
-			function (next) {
-				Messaging.isUserInRoom(uid, roomId, next);
-			},
-			function (inRoom, next) {
-				if (!inRoom) {
-					return next(new Error('[[error:cant-add-users-to-chat-room]]'));
-				}
-				const now = Date.now();
-				const timestamps = uids.map(() => now);
-				db.sortedSetAdd('chat:room:' + roomId + ':uids', timestamps, uids, next);
-			},
-			function (next) {
-				async.parallel({
-					userCount: async.apply(db.sortedSetCard, 'chat:room:' + roomId + ':uids'),
-					roomData: async.apply(db.getObject, 'chat:room:' + roomId),
-				}, next);
-			},
-			function (results, next) {
-				if (!results.roomData.hasOwnProperty('groupChat') && results.userCount > 2) {
-					return db.setObjectField('chat:room:' + roomId, 'groupChat', 1, next);
-				}
-				next();
-			},
-		], callback);
+	Messaging.addUsersToRoom = async function (uid, uids, roomId) {
+		const now = Date.now();
+		const timestamps = uids.map(() => now);
+		const inRoom = await Messaging.isUserInRoom(uid, roomId);
+		if (!inRoom) {
+			throw new Error('[[error:cant-add-users-to-chat-room]]');
+		}
+
+		await db.sortedSetAdd('chat:room:' + roomId + ':uids', timestamps, uids);
+		const [userCount, roomData] = await Promise.all([
+			db.sortedSetCard('chat:room:' + roomId + ':uids'),
+			db.getObject('chat:room:' + roomId),
+		]);
+
+		if (!roomData.hasOwnProperty('groupChat') && userCount > 2) {
+			await db.setObjectField('chat:room:' + roomId, 'groupChat', 1);
+		}
+
+		await Promise.all(uids.map(uid => Messaging.addSystemMessage('user-join', uid, roomId)));
 	};
 
-	Messaging.removeUsersFromRoom = function (uid, uids, roomId, callback) {
-		async.waterfall([
-			function (next) {
-				async.parallel({
-					isOwner: async.apply(Messaging.isRoomOwner, uid, roomId),
-					userCount: async.apply(Messaging.getUserCountInRoom, roomId),
-				}, next);
-			},
-			function (results, next) {
-				if (!results.isOwner) {
-					return next(new Error('[[error:cant-remove-users-from-chat-room]]'));
-				}
-				if (results.userCount === 2) {
-					return next(new Error('[[error:cant-remove-last-user]]'));
-				}
-				Messaging.leaveRoom(uids, roomId, next);
-			},
-		], callback);
+	Messaging.removeUsersFromRoom = async (uid, uids, roomId) => {
+		const [isOwner, userCount] = await Promise.all([
+			Messaging.isRoomOwner(uid, roomId),
+			Messaging.getUserCountInRoom(roomId),
+		]);
+
+		if (!isOwner) {
+			throw new Error('[[error:cant-remove-users-from-chat-room]]');
+		}
+		if (userCount === 2) {
+			throw new Error('[[error:cant-remove-last-user]]');
+		}
+
+		await Messaging.leaveRoom(uids, roomId);
 	};
 
-	Messaging.leaveRoom = function (uids, roomId, callback) {
-		async.waterfall([
-			function (next) {
-				db.sortedSetRemove('chat:room:' + roomId + ':uids', uids, next);
-			},
-			function (next) {
-				var keys = uids.map(function (uid) {
-					return 'uid:' + uid + ':chat:rooms';
-				});
-				keys = keys.concat(uids.map(function (uid) {
-					return 'uid:' + uid + ':chat:rooms:unread';
-				}));
-				db.sortedSetsRemove(keys, roomId, next);
-			},
-			function (next) {
-				updateOwner(roomId, next);
-			},
-		], callback);
+	Messaging.leaveRoom = async (uids, roomId) => {
+		const keys = uids
+			.map(function (uid) {
+				return 'uid:' + uid + ':chat:rooms';
+			})
+			.concat(uids.map(function (uid) {
+				return 'uid:' + uid + ':chat:rooms:unread';
+			}));
+
+		await Promise.all([
+			db.sortedSetRemove('chat:room:' + roomId + ':uids', uids),
+			db.sortedSetsRemove(keys, roomId),
+		]);
+
+		await Promise.all(uids.map(uid => Messaging.addSystemMessage('user-leave', uid, roomId)));
+		await updateOwner(roomId);
 	};
 
-	Messaging.leaveRooms = function (uid, roomIds, callback) {
-		async.waterfall([
-			function (next) {
-				const roomKeys = roomIds.map(roomId => 'chat:room:' + roomId + ':uids');
-				db.sortedSetsRemove(roomKeys, uid, next);
-			},
-			function (next) {
-				db.sortedSetRemove([
-					'uid:' + uid + ':chat:rooms',
-					'uid:' + uid + ':chat:rooms:unread',
-				], roomIds, next);
-			},
-			function (next) {
-				async.eachSeries(roomIds, updateOwner, next);
-			},
-		], callback);
+	Messaging.leaveRooms = async (uid, roomIds) => {
+		const roomKeys = roomIds.map(roomId => 'chat:room:' + roomId + ':uids');
+		await Promise.all([
+			db.sortedSetsRemove(roomKeys, uid),
+			db.sortedSetRemove([
+				'uid:' + uid + ':chat:rooms',
+				'uid:' + uid + ':chat:rooms:unread',
+			], roomIds),
+		]);
+
+		await Promise.all(
+			roomIds.map(roomId => updateOwner(roomId))
+				.concat(roomIds.map(roomId => Messaging.addSystemMessage('user-leave', uid, roomId)))
+		);
 	};
 
-	function updateOwner(roomId, callback) {
-		async.waterfall([
-			function (next) {
-				db.getSortedSetRange('chat:room:' + roomId + ':uids', 0, 0, next);
-			},
-			function (uids, next) {
-				var newOwner = uids[0] || 0;
-				db.setObjectField('chat:room:' + roomId, 'owner', newOwner, next);
-			},
-		], callback);
+	async function updateOwner(roomId) {
+		const uids = await db.getSortedSetRange('chat:room:' + roomId + ':uids', 0, 0);
+		const newOwner = uids[0] || 0;
+		await db.setObjectField('chat:room:' + roomId, 'owner', newOwner);
 	}
 
-	Messaging.getUidsInRoom = function (roomId, start, stop, callback) {
-		db.getSortedSetRevRange('chat:room:' + roomId + ':uids', start, stop, callback);
-	};
+	Messaging.getUidsInRoom = async (roomId, start, stop) => db.getSortedSetRevRange('chat:room:' + roomId + ':uids', start, stop);
+
+	Messaging.getUsersInRoom = async (roomId, start, stop) => {
+		const uids = await Messaging.getUidsInRoom(roomId, start, stop);
+		const [users, ownerId] = await Promise.all([
+			user.getUsersFields(uids, ['uid', 'username', 'picture', 'status']),
+			db.getObjectField('chat:room:' + roomId, 'owner'),
+		]);
 
-	Messaging.getUsersInRoom = function (roomId, start, stop, callback) {
-		async.waterfall([
-			function (next) {
-				Messaging.getUidsInRoom(roomId, start, stop, next);
-			},
-			function (uids, next) {
-				user.getUsersFields(uids, ['uid', 'username', 'picture', 'status'], next);
-			},
-			function (users, next) {
-				db.getObjectField('chat:room:' + roomId, 'owner', function (err, ownerId) {
-					next(err, users.map(function (user) {
-						user.isOwner = parseInt(user.uid, 10) === parseInt(ownerId, 10);
-						return user;
-					}));
-				});
-			},
-		], callback);
+		return users.map(function (user) {
+			user.isOwner = parseInt(user.uid, 10) === parseInt(ownerId, 10);
+			return user;
+		});
 	};
 
-	Messaging.renameRoom = function (uid, roomId, newName, callback) {
+	Messaging.renameRoom = async function (uid, roomId, newName) {
 		if (!newName) {
-			return callback(new Error('[[error:invalid-name]]'));
+			throw new Error('[[error:invalid-name]]');
 		}
 		newName = newName.trim();
 		if (newName.length > 75) {
-			return callback(new Error('[[error:chat-room-name-too-long]]'));
+			throw new Error('[[error:chat-room-name-too-long]]');
 		}
-		async.waterfall([
-			function (next) {
-				plugins.fireHook('filter:chat.renameRoom', {
-					uid: uid,
-					roomId: roomId,
-					newName: newName,
-				}, next);
-			},
-			function (result, next) {
-				Messaging.isRoomOwner(uid, roomId, next);
-			},
-			function (isOwner, next) {
-				if (!isOwner) {
-					return next(new Error('[[error:no-privileges]]'));
-				}
-				db.setObjectField('chat:room:' + roomId, 'roomName', newName, next);
-			},
-			async.apply(plugins.fireHook, 'action:chat.renameRoom', {
-				roomId: roomId,
-				newName: newName,
-			}),
-		], callback);
-	};
 
-	Messaging.canReply = function (roomId, uid, callback) {
-		async.waterfall([
-			function (next) {
-				db.isSortedSetMember('chat:room:' + roomId + ':uids', uid, next);
-			},
-			function (inRoom, next) {
-				plugins.fireHook('filter:messaging.canReply', { uid: uid, roomId: roomId, inRoom: inRoom, canReply: inRoom }, next);
-			},
-			function (data, next) {
-				next(null, data.canReply);
-			},
-		], callback);
+		const payload = await plugins.fireHook('filter:chat.renameRoom', {
+			uid: uid,
+			roomId: roomId,
+			newName: newName,
+		});
+		const isOwner = await Messaging.isRoomOwner(payload.uid, payload.roomId);
+		if (!isOwner) {
+			throw new Error('[[error:no-privileges]]');
+		}
+
+		await db.setObjectField('chat:room:' + payload.roomId, 'roomName', payload.newName);
+		await Messaging.addSystemMessage('room-rename, ' + payload.newName.replace(',', '%2C'), payload.uid, payload.roomId);
+
+		plugins.fireHook('action:chat.renameRoom', {
+			roomId: payload.roomId,
+			newName: payload.newName,
+		});
 	};
 
-	Messaging.loadRoom = function (uid, data, callback) {
-		async.waterfall([
-			function (next) {
-				privileges.global.can('chat', uid, next);
-			},
-			function (canChat, next) {
-				if (!canChat) {
-					return next(new Error('[[error:no-privileges]]'));
-				}
+	Messaging.canReply = async (roomId, uid) => {
+		const inRoom = db.isSortedSetMember('chat:room:' + roomId + ':uids', uid);
+		const data = await plugins.fireHook('filter:messaging.canReply', { uid: uid, roomId: roomId, inRoom: inRoom, canReply: inRoom });
+		return data.canReply;
+	};
 
-				Messaging.isUserInRoom(uid, data.roomId, next);
-			},
-			function (inRoom, next) {
-				if (!inRoom) {
-					return callback(null, null);
-				}
+	Messaging.loadRoom = async (uid, data) => {
+		const canChat = await privileges.global.can('chat', uid);
+		if (!canChat) {
+			throw new Error('[[error:no-privileges]]');
+		}
+		const inRoom = await Messaging.isUserInRoom(uid, data.roomId);
+		if (!inRoom) {
+			return null;
+		}
 
-				async.parallel({
-					roomData: async.apply(Messaging.getRoomData, data.roomId),
-					canReply: async.apply(Messaging.canReply, data.roomId, uid),
-					users: async.apply(Messaging.getUsersInRoom, data.roomId, 0, -1),
-					messages: async.apply(Messaging.getMessages, {
-						callerUid: uid,
-						uid: data.uid || uid,
-						roomId: data.roomId,
-						isNew: false,
-					}),
-					isAdminOrGlobalMod: function (next) {
-						user.isAdminOrGlobalMod(uid, next);
-					},
-				}, next);
-			},
-			function (results, next) {
-				var room = results.roomData;
-				room.messages = results.messages;
-				room.isOwner = parseInt(room.owner, 10) === parseInt(uid, 10);
-				room.users = results.users.filter(function (user) {
-					return user && parseInt(user.uid, 10) && parseInt(user.uid, 10) !== uid;
-				});
-				room.canReply = results.canReply;
-				room.groupChat = room.hasOwnProperty('groupChat') ? room.groupChat : results.users.length > 2;
-				room.usernames = Messaging.generateUsernames(results.users, uid);
-				room.maximumUsersInChatRoom = meta.config.maximumUsersInChatRoom;
-				room.maximumChatMessageLength = meta.config.maximumChatMessageLength;
-				room.showUserInput = !room.maximumUsersInChatRoom || room.maximumUsersInChatRoom > 2;
-				room.isAdminOrGlobalMod = results.isAdminOrGlobalMod;
-				next(null, room);
-			},
-		], callback);
+		const [roomData, canReply, users, messages, isAdminOrGlobalMod] = await Promise.all([
+			Messaging.getRoomData(data.roomId),
+			Messaging.canReply(data.roomId, uid),
+			Messaging.getUsersInRoom(data.roomId, 0, -1),
+			Messaging.getMessages({
+				callerUid: uid,
+				uid: data.uid || uid,
+				roomId: data.roomId,
+				isNew: false,
+			}),
+			user.isAdminOrGlobalMod(uid),
+		]);
+
+		var room = roomData;
+		room.messages = messages;
+		room.isOwner = parseInt(room.owner, 10) === parseInt(uid, 10);
+		room.users = users.filter(function (user) {
+			return user && parseInt(user.uid, 10) && parseInt(user.uid, 10) !== uid;
+		});
+		room.canReply = canReply;
+		room.groupChat = room.hasOwnProperty('groupChat') ? room.groupChat : users.length > 2;
+		room.usernames = Messaging.generateUsernames(users, uid);
+		room.maximumUsersInChatRoom = meta.config.maximumUsersInChatRoom;
+		room.maximumChatMessageLength = meta.config.maximumChatMessageLength;
+		room.showUserInput = !room.maximumUsersInChatRoom || room.maximumUsersInChatRoom > 2;
+		room.isAdminOrGlobalMod = isAdminOrGlobalMod;
+
+		return room;
 	};
 };

test/messaging.js

@@ -113,6 +113,16 @@ describe('Messaging Library', function () {
 			});
 		});
 
+		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 }, function (err, messages) {
+				assert.ifError(err);
+				assert.equal(messages.length, 1);
+				assert.strictEqual(messages[0].system, true);
+				assert.strictEqual(messages[0].content, 'user-join');
+				done();
+			});
+		});
+
 		it('should fail to add user to room with invalid data', function (done) {
 			socketModules.chats.addUserToRoom({ uid: fooUid }, null, function (err) {
 				assert.equal(err.message, '[[error:invalid-data]]');
@@ -185,6 +195,17 @@ describe('Messaging Library', function () {
 			});
 		});
 
+		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 }, function (err, messages) {
+				assert.ifError(err);
+				assert.equal(messages.length, 3);
+				const message = messages.pop();
+				assert.strictEqual(message.system, true);
+				assert.strictEqual(message.content, 'user-leave');
+				done();
+			});
+		});
+
 		it('should change owner when owner leaves room', function (done) {
 			socketModules.chats.newRoom({ uid: herpUid }, { touid: fooUid }, function (err, roomId) {
 				assert.ifError(err);
@@ -330,7 +351,8 @@ describe('Messaging Library', function () {
 					myRoomId = _roomId;
 					assert.ifError(err);
 					assert(myRoomId);
-					socketModules.chats.getRaw({ uid: bazUid }, { mid: 1 }, function (err) {
+					socketModules.chats.getRaw({ uid: bazUid }, { mid: 2 }, function (err) {
+						assert(err);
 						assert.equal(err.message, '[[error:not-allowed]]');
 						socketModules.chats.send({ uid: bazUid }, { roomId: myRoomId, message: 'admin will see this' }, function (err, message) {
 							assert.ifError(err);
@@ -392,8 +414,8 @@ describe('Messaging Library', function () {
 			}, function (err, messages) {
 				assert.ifError(err);
 				assert(Array.isArray(messages));
-				assert.equal(messages[0].roomId, roomId);
-				assert.equal(messages[0].fromuid, fooUid);
+				assert.equal(messages[4].roomId, roomId);
+				assert.equal(messages[4].fromuid, fooUid);
 				done();
 			});
 		});
@@ -449,6 +471,16 @@ describe('Messaging Library', function () {
 			});
 		});
 
+		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 }, function (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', function (done) {
 			socketModules.chats.loadRoom({ uid: fooUid }, null, function (err) {
 				assert.equal(err.message, '[[error:invalid-data]]');