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' : ''), {
+		function done(html) {
-			messages: data,
-		}, function (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.addRoomToUsers, data.roomId, uids, timestamp),
-					async.apply(Messaging.addMessageToUsers, data.roomId, uids, mid, data.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) {
+				function (states, _next) {
-					done = !deleted;
+					done = !states.deleted && !states.system;
-					if (!deleted) {
+					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) {
+	Messaging.getRoomData = async (roomId) => {
-		async.waterfall([
+		const data = await db.getObject('chat:room:' + roomId);
-			function (next) {
+		if (!data) {
-				db.getObject('chat:room:' + roomId, next);
+			throw new Error('[[error:no-chat-room]]');
-			},
+		}
-			function (data, next) {
+
-				if (!data) {
+		modifyRoomData([data]);
-					return callback(new Error('[[error:no-chat-room]]'));
+		return data;
-				}
-				modifyRoomData([data]);
-				next(null, data);
-			},
-		], callback);
 	};
 
-	Messaging.getRoomsData = function (roomIds, callback) {
+	Messaging.getRoomsData = async (roomIds) => {
-		var keys = roomIds.map(function (roomId) {
+		const roomData = await db.getObjects(roomIds.map(function (roomId) {
 			return 'chat:room:' + roomId;
-		});
+		}));
-		async.waterfall([
+
-			function (next) {
+		modifyRoomData(roomData);
-				db.getObjects(keys, next);
+		return roomData;
-			},
-			function (roomData, next) {
-				modifyRoomData(roomData);
-				next(null, roomData);
-			},
-		], callback);
 	};
 
 	function modifyRoomData(rooms) {
@@ -52,284 +40,204 @@ module.exports = function (Messaging) {
 		});
 	}
 
-	Messaging.newRoom = function (uid, toUids, callback) {
+	Messaging.newRoom = async (uid, toUids) => {
-		var roomId;
+		const now = Date.now();
-		var now = Date.now();
+		const roomId = await db.incrObjectField('global', 'nextChatRoomId');
-		async.waterfall([
+		const room = {
-			function (next) {
+			owner: uid,
-				db.incrObjectField('global', 'nextChatRoomId', next);
+			roomId: roomId,
-			},
+		};
-			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.isUserInRoom = function (uid, roomId, callback) {
+		await Promise.all([
-		async.waterfall([
+			db.setObject('chat:room:' + roomId, room),
-			function (next) {
+			db.sortedSetAdd('chat:room:' + roomId + ':uids', now, uid),
-				db.isSortedSetMember('chat:room:' + roomId + ':uids', uid, next);
+		]);
-			},
+		await Promise.all([
-			function (inRoom, next) {
+			Messaging.addUsersToRoom(uid, toUids, roomId),
-				plugins.fireHook('filter:messaging.isUserInRoom', { uid: uid, roomId: roomId, inRoom: inRoom }, next);
+			Messaging.addRoomToUsers(roomId, [uid].concat(toUids), now),
-			},
+		]);
-			function (data, next) {
-				next(null, data.inRoom);
-			},
-		], callback);
-	};
 
-	Messaging.roomExists = function (roomId, callback) {
+		return roomId;
-		db.exists('chat:room:' + roomId + ':uids', callback);
 	};
 
-	Messaging.getUserCountInRoom = function (roomId, callback) {
+	Messaging.isUserInRoom = async (uid, roomId) => {
-		db.sortedSetCard('chat:room:' + roomId + ':uids', callback);
+		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) {
+	Messaging.roomExists = async roomId => db.exists('chat:room:' + roomId + ':uids');
-		async.waterfall([
+
-			function (next) {
+	Messaging.getUserCountInRoom = async roomId => db.sortedSetCard('chat:room:' + roomId + ':uids');
-				db.getObjectField('chat:room:' + roomId, 'owner', next);
+
-			},
+	Messaging.isRoomOwner = async (uid, roomId) => {
-			function (owner, next) {
+		const owner = await db.getObjectField('chat:room:' + roomId, 'owner');
-				next(null, parseInt(uid, 10) === parseInt(owner, 10));
+		return parseInt(uid, 10) === parseInt(owner, 10);
-			},
-		], callback);
 	};
 
-	Messaging.addUsersToRoom = function (uid, uids, roomId, callback) {
+	Messaging.addUsersToRoom = async function (uid, uids, roomId) {
-		async.waterfall([
+		const now = Date.now();
-			function (next) {
+		const timestamps = uids.map(() => now);
-				Messaging.isUserInRoom(uid, roomId, next);
+		const inRoom = await Messaging.isUserInRoom(uid, roomId);
-			},
+		if (!inRoom) {
-			function (inRoom, next) {
+			throw new Error('[[error:cant-add-users-to-chat-room]]');
-				if (!inRoom) {
+		}
-					return next(new Error('[[error:cant-add-users-to-chat-room]]'));
+
-				}
+		await db.sortedSetAdd('chat:room:' + roomId + ':uids', timestamps, uids);
-				const now = Date.now();
+		const [userCount, roomData] = await Promise.all([
-				const timestamps = uids.map(() => now);
+			db.sortedSetCard('chat:room:' + roomId + ':uids'),
-				db.sortedSetAdd('chat:room:' + roomId + ':uids', timestamps, uids, next);
+			db.getObject('chat:room:' + roomId),
-			},
+		]);
-			function (next) {
+
-				async.parallel({
+		if (!roomData.hasOwnProperty('groupChat') && userCount > 2) {
-					userCount: async.apply(db.sortedSetCard, 'chat:room:' + roomId + ':uids'),
+			await db.setObjectField('chat:room:' + roomId, 'groupChat', 1);
-					roomData: async.apply(db.getObject, 'chat:room:' + roomId),
+		}
-				}, next);
+
-			},
+		await Promise.all(uids.map(uid => Messaging.addSystemMessage('user-join', uid, roomId)));
-			function (results, next) {
-				if (!results.roomData.hasOwnProperty('groupChat') && results.userCount > 2) {
-					return db.setObjectField('chat:room:' + roomId, 'groupChat', 1, next);
-				}
-				next();
-			},
-		], callback);
 	};
 
-	Messaging.removeUsersFromRoom = function (uid, uids, roomId, callback) {
+	Messaging.removeUsersFromRoom = async (uid, uids, roomId) => {
-		async.waterfall([
+		const [isOwner, userCount] = await Promise.all([
-			function (next) {
+			Messaging.isRoomOwner(uid, roomId),
-				async.parallel({
+			Messaging.getUserCountInRoom(roomId),
-					isOwner: async.apply(Messaging.isRoomOwner, uid, roomId),
+		]);
-					userCount: async.apply(Messaging.getUserCountInRoom, roomId),
+
-				}, next);
+		if (!isOwner) {
-			},
+			throw new Error('[[error:cant-remove-users-from-chat-room]]');
-			function (results, next) {
+		}
-				if (!results.isOwner) {
+		if (userCount === 2) {
-					return next(new Error('[[error:cant-remove-users-from-chat-room]]'));
+			throw new Error('[[error:cant-remove-last-user]]');
-				}
+		}
-				if (results.userCount === 2) {
+
-					return next(new Error('[[error:cant-remove-last-user]]'));
+		await Messaging.leaveRoom(uids, roomId);
-				}
-				Messaging.leaveRoom(uids, roomId, next);
-			},
-		], callback);
 	};
 
-	Messaging.leaveRoom = function (uids, roomId, callback) {
+	Messaging.leaveRoom = async (uids, roomId) => {
-		async.waterfall([
+		const keys = uids
-			function (next) {
+			.map(function (uid) {
-				db.sortedSetRemove('chat:room:' + roomId + ':uids', uids, next);
+				return 'uid:' + uid + ':chat:rooms';
-			},
+			})
-			function (next) {
+			.concat(uids.map(function (uid) {
-				var keys = uids.map(function (uid) {
+				return 'uid:' + uid + ':chat:rooms:unread';
-					return 'uid:' + uid + ':chat:rooms';
+			}));
-				});
+
-				keys = keys.concat(uids.map(function (uid) {
+		await Promise.all([
-					return 'uid:' + uid + ':chat:rooms:unread';
+			db.sortedSetRemove('chat:room:' + roomId + ':uids', uids),
-				}));
+			db.sortedSetsRemove(keys, roomId),
-				db.sortedSetsRemove(keys, roomId, next);
+		]);
-			},
+
-			function (next) {
+		await Promise.all(uids.map(uid => Messaging.addSystemMessage('user-leave', uid, roomId)));
-				updateOwner(roomId, next);
+		await updateOwner(roomId);
-			},
-		], callback);
 	};
 
-	Messaging.leaveRooms = function (uid, roomIds, callback) {
+	Messaging.leaveRooms = async (uid, roomIds) => {
-		async.waterfall([
+		const roomKeys = roomIds.map(roomId => 'chat:room:' + roomId + ':uids');
-			function (next) {
+		await Promise.all([
-				const roomKeys = roomIds.map(roomId => 'chat:room:' + roomId + ':uids');
+			db.sortedSetsRemove(roomKeys, uid),
-				db.sortedSetsRemove(roomKeys, uid, next);
+			db.sortedSetRemove([
-			},
+				'uid:' + uid + ':chat:rooms',
-			function (next) {
+				'uid:' + uid + ':chat:rooms:unread',
-				db.sortedSetRemove([
+			], roomIds),
-					'uid:' + uid + ':chat:rooms',
+		]);
-					'uid:' + uid + ':chat:rooms:unread',
+
-				], roomIds, next);
+		await Promise.all(
-			},
+			roomIds.map(roomId => updateOwner(roomId))
-			function (next) {
+				.concat(roomIds.map(roomId => Messaging.addSystemMessage('user-leave', uid, roomId)))
-				async.eachSeries(roomIds, updateOwner, next);
+		);
-			},
-		], callback);
 	};
 
-	function updateOwner(roomId, callback) {
+	async function updateOwner(roomId) {
-		async.waterfall([
+		const uids = await db.getSortedSetRange('chat:room:' + roomId + ':uids', 0, 0);
-			function (next) {
+		const newOwner = uids[0] || 0;
-				db.getSortedSetRange('chat:room:' + roomId + ':uids', 0, 0, next);
+		await db.setObjectField('chat:room:' + roomId, 'owner', newOwner);
-			},
-			function (uids, next) {
-				var newOwner = uids[0] || 0;
-				db.setObjectField('chat:room:' + roomId, 'owner', newOwner, next);
-			},
-		], callback);
 	}
 
-	Messaging.getUidsInRoom = function (roomId, start, stop, callback) {
+	Messaging.getUidsInRoom = async (roomId, start, stop) => db.getSortedSetRevRange('chat:room:' + roomId + ':uids', start, stop);
-		db.getSortedSetRevRange('chat:room:' + roomId + ':uids', start, stop, callback);
+
-	};
+	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) {
+		return users.map(function (user) {
-		async.waterfall([
+			user.isOwner = parseInt(user.uid, 10) === parseInt(ownerId, 10);
-			function (next) {
+			return user;
-				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);
 	};
 
-	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) {
+		const payload = await plugins.fireHook('filter:chat.renameRoom', {
-		async.waterfall([
+			uid: uid,
-			function (next) {
+			roomId: roomId,
-				db.isSortedSetMember('chat:room:' + roomId + ':uids', uid, next);
+			newName: newName,
-			},
+		});
-			function (inRoom, next) {
+		const isOwner = await Messaging.isRoomOwner(payload.uid, payload.roomId);
-				plugins.fireHook('filter:messaging.canReply', { uid: uid, roomId: roomId, inRoom: inRoom, canReply: inRoom }, next);
+		if (!isOwner) {
-			},
+			throw new Error('[[error:no-privileges]]');
-			function (data, next) {
+		}
-				next(null, data.canReply);
+
-			},
+		await db.setObjectField('chat:room:' + payload.roomId, 'roomName', payload.newName);
-		], callback);
+		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) {
+	Messaging.canReply = async (roomId, uid) => {
-		async.waterfall([
+		const inRoom = db.isSortedSetMember('chat:room:' + roomId + ':uids', uid);
-			function (next) {
+		const data = await plugins.fireHook('filter:messaging.canReply', { uid: uid, roomId: roomId, inRoom: inRoom, canReply: inRoom });
-				privileges.global.can('chat', uid, next);
+		return data.canReply;
-			},
+	};
-			function (canChat, next) {
-				if (!canChat) {
-					return next(new Error('[[error:no-privileges]]'));
-				}
 
-				Messaging.isUserInRoom(uid, data.roomId, next);
+	Messaging.loadRoom = async (uid, data) => {
-			},
+		const canChat = await privileges.global.can('chat', uid);
-			function (inRoom, next) {
+		if (!canChat) {
-				if (!inRoom) {
+			throw new Error('[[error:no-privileges]]');
-					return callback(null, null);
+		}
-				}
+		const inRoom = await Messaging.isUserInRoom(uid, data.roomId);
+		if (!inRoom) {
+			return null;
+		}
 
-				async.parallel({
+		const [roomData, canReply, users, messages, isAdminOrGlobalMod] = await Promise.all([
-					roomData: async.apply(Messaging.getRoomData, data.roomId),
+			Messaging.getRoomData(data.roomId),
-					canReply: async.apply(Messaging.canReply, data.roomId, uid),
+			Messaging.canReply(data.roomId, uid),
-					users: async.apply(Messaging.getUsersInRoom, data.roomId, 0, -1),
+			Messaging.getUsersInRoom(data.roomId, 0, -1),
-					messages: async.apply(Messaging.getMessages, {
+			Messaging.getMessages({
-						callerUid: uid,
+				callerUid: uid,
-						uid: data.uid || uid,
+				uid: data.uid || uid,
-						roomId: data.roomId,
+				roomId: data.roomId,
-						isNew: false,
+				isNew: false,
-					}),
+			}),
-					isAdminOrGlobalMod: function (next) {
+			user.isAdminOrGlobalMod(uid),
-						user.isAdminOrGlobalMod(uid, next);
+		]);
-					},
+
-				}, next);
+		var room = roomData;
-			},
+		room.messages = messages;
-			function (results, next) {
+		room.isOwner = parseInt(room.owner, 10) === parseInt(uid, 10);
-				var room = results.roomData;
+		room.users = users.filter(function (user) {
-				room.messages = results.messages;
+			return user && parseInt(user.uid, 10) && parseInt(user.uid, 10) !== uid;
-				room.isOwner = parseInt(room.owner, 10) === parseInt(uid, 10);
+		});
-				room.users = results.users.filter(function (user) {
+		room.canReply = canReply;
-					return user && parseInt(user.uid, 10) && parseInt(user.uid, 10) !== uid;
+		room.groupChat = room.hasOwnProperty('groupChat') ? room.groupChat : users.length > 2;
-				});
+		room.usernames = Messaging.generateUsernames(users, uid);
-				room.canReply = results.canReply;
+		room.maximumUsersInChatRoom = meta.config.maximumUsersInChatRoom;
-				room.groupChat = room.hasOwnProperty('groupChat') ? room.groupChat : results.users.length > 2;
+		room.maximumChatMessageLength = meta.config.maximumChatMessageLength;
-				room.usernames = Messaging.generateUsernames(results.users, uid);
+		room.showUserInput = !room.maximumUsersInChatRoom || room.maximumUsersInChatRoom > 2;
-				room.maximumUsersInChatRoom = meta.config.maximumUsersInChatRoom;
+		room.isAdminOrGlobalMod = isAdminOrGlobalMod;
-				room.maximumChatMessageLength = meta.config.maximumChatMessageLength;
+
-				room.showUserInput = !room.maximumUsersInChatRoom || room.maximumUsersInChatRoom > 2;
+		return room;
-				room.isAdminOrGlobalMod = results.isAdminOrGlobalMod;
-				next(null, room);
-			},
-		], callback);
 	};
 };

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[4].roomId, roomId);
-				assert.equal(messages[0].fromuid, fooUid);
+				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]]');