From c5c755fbb0bcdebde136147d47718e22e509101c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Soner=20U=C5=9Fakl=C4=B1?=
 <baris@nodebb.org>
Date: Sat, 20 May 2017 22:30:12 -0400
Subject: [PATCH] more notification tests

---
 src/user/follow.js        |   4 +-
 src/user/notifications.js | 603 +++++++++++++++++++-------------------
 test/notifications.js     | 122 ++++++++
 3 files changed, 432 insertions(+), 297 deletions(-)

diff --git a/src/user/follow.js b/src/user/follow.js
index fe3dc0931d..d2056065b4 100644
--- a/src/user/follow.js
+++ b/src/user/follow.js
@@ -57,7 +57,9 @@ module.exports = function (User) {
 					], next);
 				}
 			},
-		], callback);
+		], function (err) {
+			callback(err);
+		});
 	}
 
 	User.getFollowing = function (uid, start, stop, callback) {
diff --git a/src/user/notifications.js b/src/user/notifications.js
index 318794fb20..953caeb2c2 100644
--- a/src/user/notifications.js
+++ b/src/user/notifications.js
@@ -10,16 +10,17 @@ var meta = require('../meta');
 var notifications = require('../notifications');
 var privileges = require('../privileges');
 
-(function (UserNotifications) {
-	UserNotifications.get = function (uid, callback) {
-		if (!parseInt(uid, 10)) {
-			return callback(null, { read: [], unread: [] });
-		}
-		getNotifications(uid, 0, 9, function (err, notifications) {
-			if (err) {
-				return callback(err);
-			}
+var UserNotifications = module.exports;
 
+UserNotifications.get = function (uid, callback) {
+	if (!parseInt(uid, 10)) {
+		return callback(null, { read: [], unread: [] });
+	}
+	async.waterfall([
+		function (next) {
+			getNotifications(uid, 0, 9, next);
+		},
+		function (notifications, next) {
 			notifications.read = notifications.read.filter(Boolean);
 			notifications.unread = notifications.unread.filter(Boolean);
 
@@ -28,326 +29,336 @@ var privileges = require('../privileges');
 				notifications.read.length = maxNotifs - notifications.unread.length;
 			}
 
-			callback(null, notifications);
-		});
-	};
-
-	function filterNotifications(nids, filter, callback) {
-		if (!filter) {
-			return setImmediate(callback, null, nids);
-		}
-		async.waterfall([
-			function (next) {
-				var keys = nids.map(function (nid) {
-					return 'notifications:' + nid;
-				});
-				db.getObjectsFields(keys, ['nid', 'type'], next);
-			},
-			function (notifications, next) {
-				nids = notifications.filter(function (notification) {
-					return notification && notification.nid && notification.type === filter;
-				}).map(function (notification) {
-					return notification.nid;
-				});
-				next(null, nids);
-			},
-		], callback);
-	}
-
-	UserNotifications.getAll = function (uid, filter, callback) {
-		var nids;
-		async.waterfall([
-			function (next) {
-				async.parallel({
-					unread: function (next) {
-						db.getSortedSetRevRange('uid:' + uid + ':notifications:unread', 0, -1, next);
-					},
-					read: function (next) {
-						db.getSortedSetRevRange('uid:' + uid + ':notifications:read', 0, -1, next);
-					},
-				}, next);
-			},
-			function (results, next) {
-				nids = results.unread.concat(results.read);
-				db.isSortedSetMembers('notifications', nids, next);
-			},
-			function (exists, next) {
-				var deleteNids = [];
-
-				nids = nids.filter(function (nid, index) {
-					if (!nid || !exists[index]) {
-						deleteNids.push(nid);
-					}
-					return nid && exists[index];
-				});
-
-				deleteUserNids(deleteNids, uid, next);
-			},
-			function (next) {
-				filterNotifications(nids, filter, next);
-			},
-		], callback);
-	};
-
-	function deleteUserNids(nids, uid, callback) {
-		callback = callback || function () {};
-		if (!nids.length) {
-			return setImmediate(callback);
-		}
-		async.parallel([
-			function (next) {
-				db.sortedSetRemove('uid:' + uid + ':notifications:read', nids, next);
-			},
-			function (next) {
-				db.sortedSetRemove('uid:' + uid + ':notifications:unread', nids, next);
-			},
-		], function (err) {
-			callback(err);
-		});
-	}
+			next(null, notifications);
+		},
+	], callback);
+};
 
-	function getNotifications(uid, start, stop, callback) {
-		async.parallel({
-			unread: function (next) {
-				getNotificationsFromSet('uid:' + uid + ':notifications:unread', false, uid, start, stop, next);
-			},
-			read: function (next) {
-				getNotificationsFromSet('uid:' + uid + ':notifications:read', true, uid, start, stop, next);
-			},
-		}, callback);
+function filterNotifications(nids, filter, callback) {
+	if (!filter) {
+		return setImmediate(callback, null, nids);
 	}
-
-	function getNotificationsFromSet(set, read, uid, start, stop, callback) {
-		async.waterfall([
-			function (next) {
-				db.getSortedSetRevRange(set, start, stop, next);
-			},
-			function (nids, next) {
-				if (!Array.isArray(nids) || !nids.length) {
-					return callback(null, []);
+	async.waterfall([
+		function (next) {
+			var keys = nids.map(function (nid) {
+				return 'notifications:' + nid;
+			});
+			db.getObjectsFields(keys, ['nid', 'type'], next);
+		},
+		function (notifications, next) {
+			nids = notifications.filter(function (notification) {
+				return notification && notification.nid && notification.type === filter;
+			}).map(function (notification) {
+				return notification.nid;
+			});
+			next(null, nids);
+		},
+	], callback);
+}
+
+UserNotifications.getAll = function (uid, filter, callback) {
+	var nids;
+	async.waterfall([
+		function (next) {
+			async.parallel({
+				unread: function (next) {
+					db.getSortedSetRevRange('uid:' + uid + ':notifications:unread', 0, -1, next);
+				},
+				read: function (next) {
+					db.getSortedSetRevRange('uid:' + uid + ':notifications:read', 0, -1, next);
+				},
+			}, next);
+		},
+		function (results, next) {
+			nids = results.unread.concat(results.read);
+			db.isSortedSetMembers('notifications', nids, next);
+		},
+		function (exists, next) {
+			var deleteNids = [];
+
+			nids = nids.filter(function (nid, index) {
+				if (!nid || !exists[index]) {
+					deleteNids.push(nid);
 				}
+				return nid && exists[index];
+			});
 
-				UserNotifications.getNotifications(nids, uid, next);
-			},
-		], callback);
+			deleteUserNids(deleteNids, uid, next);
+		},
+		function (next) {
+			filterNotifications(nids, filter, next);
+		},
+	], callback);
+};
+
+function deleteUserNids(nids, uid, callback) {
+	callback = callback || function () {};
+	if (!nids.length) {
+		return setImmediate(callback);
 	}
-
-	UserNotifications.getNotifications = function (nids, uid, callback) {
-		var notificationData = [];
-		async.waterfall([
-			function (next) {
-				async.parallel({
-					notifications: function (next) {
-						notifications.getMultiple(nids, next);
-					},
-					hasRead: function (next) {
-						db.isSortedSetMembers('uid:' + uid + ':notifications:read', nids, next);
-					},
-				}, next);
-			},
-			function (results, next) {
-				var deletedNids = [];
-				notificationData = results.notifications.filter(function (notification, index) {
-					if (!notification || !notification.nid) {
-						deletedNids.push(nids[index]);
-					}
-					if (notification) {
-						notification.read = results.hasRead[index];
-						notification.readClass = !notification.read ? 'unread' : '';
-					}
-
-					return notification && notification.path;
-				});
-
-				deleteUserNids(deletedNids, uid, next);
-			},
-			function (next) {
-				notifications.merge(notificationData, next);
-			},
-		], callback);
-	};
-
-	UserNotifications.getDailyUnread = function (uid, callback) {
-		var yesterday = Date.now() - (1000 * 60 * 60 * 24);	// Approximate, can be more or less depending on time changes, makes no difference really.
-
-		db.getSortedSetRevRangeByScore('uid:' + uid + ':notifications:unread', 0, 20, '+inf', yesterday, function (err, nids) {
-			if (err) {
-				return callback(err);
-			}
-
+	async.parallel([
+		function (next) {
+			db.sortedSetRemove('uid:' + uid + ':notifications:read', nids, next);
+		},
+		function (next) {
+			db.sortedSetRemove('uid:' + uid + ':notifications:unread', nids, next);
+		},
+	], function (err) {
+		callback(err);
+	});
+}
+
+function getNotifications(uid, start, stop, callback) {
+	async.parallel({
+		unread: function (next) {
+			getNotificationsFromSet('uid:' + uid + ':notifications:unread', false, uid, start, stop, next);
+		},
+		read: function (next) {
+			getNotificationsFromSet('uid:' + uid + ':notifications:read', true, uid, start, stop, next);
+		},
+	}, callback);
+}
+
+function getNotificationsFromSet(set, read, uid, start, stop, callback) {
+	async.waterfall([
+		function (next) {
+			db.getSortedSetRevRange(set, start, stop, next);
+		},
+		function (nids, next) {
 			if (!Array.isArray(nids) || !nids.length) {
 				return callback(null, []);
 			}
 
-			UserNotifications.getNotifications(nids, uid, callback);
-		});
-	};
-
-	UserNotifications.getUnreadCount = function (uid, callback) {
-		if (!parseInt(uid, 10)) {
-			return callback(null, 0);
-		}
+			UserNotifications.getNotifications(nids, uid, next);
+		},
+	], callback);
+}
+
+UserNotifications.getNotifications = function (nids, uid, callback) {
+	var notificationData = [];
+	async.waterfall([
+		function (next) {
+			async.parallel({
+				notifications: function (next) {
+					notifications.getMultiple(nids, next);
+				},
+				hasRead: function (next) {
+					db.isSortedSetMembers('uid:' + uid + ':notifications:read', nids, next);
+				},
+			}, next);
+		},
+		function (results, next) {
+			var deletedNids = [];
+			notificationData = results.notifications.filter(function (notification, index) {
+				if (!notification || !notification.nid) {
+					deletedNids.push(nids[index]);
+				}
+				if (notification) {
+					notification.read = results.hasRead[index];
+					notification.readClass = !notification.read ? 'unread' : '';
+				}
 
-		// Collapse any notifications with identical mergeIds
-		async.waterfall([
-			async.apply(db.getSortedSetRevRange, 'uid:' + uid + ':notifications:unread', 0, 99),
-			async.apply(notifications.filterExists),
-			function (nids, next) {
-				var keys = nids.map(function (nid) {
-					return 'notifications:' + nid;
-				});
-
-				db.getObjectsFields(keys, ['mergeId'], next);
-			},
-			function (mergeIds, next) {
-				mergeIds = mergeIds.map(function (set) {
-					return set.mergeId;
-				});
-
-				next(null, mergeIds.reduce(function (count, mergeId, idx, arr) {
-					// A missing (null) mergeId means that notification is counted separately.
-					if (mergeId === null || idx === arr.indexOf(mergeId)) {
-						count += 1;
-					}
-
-					return count;
-				}, 0));
-			},
-		], callback);
-	};
-
-	UserNotifications.getUnreadByField = function (uid, field, values, callback) {
-		db.getSortedSetRevRange('uid:' + uid + ':notifications:unread', 0, 99, function (err, nids) {
-			if (err) {
-				return callback(err);
-			}
+				return notification && notification.path;
+			});
 
+			deleteUserNids(deletedNids, uid, next);
+		},
+		function (next) {
+			notifications.merge(notificationData, next);
+		},
+	], callback);
+};
+
+UserNotifications.getDailyUnread = function (uid, callback) {
+	var yesterday = Date.now() - (1000 * 60 * 60 * 24);	// Approximate, can be more or less depending on time changes, makes no difference really.
+
+	async.waterfall([
+		function (next) {
+			db.getSortedSetRevRangeByScore('uid:' + uid + ':notifications:unread', 0, 20, '+inf', yesterday, next);
+		},
+		function (nids, next) {
 			if (!Array.isArray(nids) || !nids.length) {
 				return callback(null, []);
 			}
 
+			UserNotifications.getNotifications(nids, uid, next);
+		},
+	], callback);
+};
+
+UserNotifications.getUnreadCount = function (uid, callback) {
+	if (!parseInt(uid, 10)) {
+		return callback(null, 0);
+	}
+
+
+	async.waterfall([
+		function (next) {
+			db.getSortedSetRevRange('uid:' + uid + ':notifications:unread', 0, 99, next);
+		},
+		function (nids, next) {
+			notifications.filterExists(nids, next);
+		},
+		function (nids, next) {
 			var keys = nids.map(function (nid) {
 				return 'notifications:' + nid;
 			});
 
-			db.getObjectsFields(keys, ['nid', field], function (err, notifications) {
-				if (err) {
-					return callback(err);
+			db.getObjectsFields(keys, ['mergeId'], next);
+		},
+		function (mergeIds, next) {
+			// Collapse any notifications with identical mergeIds
+			mergeIds = mergeIds.map(function (set) {
+				return set.mergeId;
+			});
+
+			next(null, mergeIds.reduce(function (count, mergeId, idx, arr) {
+				// A missing (null) mergeId means that notification is counted separately.
+				if (mergeId === null || idx === arr.indexOf(mergeId)) {
+					count += 1;
 				}
 
-				values = values.map(function () { return values.toString(); });
-				nids = notifications.filter(function (notification) {
-					return notification && notification[field] && values.indexOf(notification[field].toString()) !== -1;
-				}).map(function (notification) {
-					return notification.nid;
-				});
+				return count;
+			}, 0));
+		},
+	], callback);
+};
+
+UserNotifications.getUnreadByField = function (uid, field, values, callback) {
+	var nids;
+	async.waterfall([
+		function (next) {
+			db.getSortedSetRevRange('uid:' + uid + ':notifications:unread', 0, 99, next);
+		},
+		function (_nids, next) {
+			nids = _nids;
+			if (!Array.isArray(nids) || !nids.length) {
+				return callback(null, []);
+			}
 
-				callback(null, nids);
+			var keys = nids.map(function (nid) {
+				return 'notifications:' + nid;
 			});
-		});
-	};
 
-	UserNotifications.deleteAll = function (uid, callback) {
-		if (!parseInt(uid, 10)) {
-			return callback();
-		}
-		async.parallel([
-			function (next) {
-				db.delete('uid:' + uid + ':notifications:unread', next);
-			},
-			function (next) {
-				db.delete('uid:' + uid + ':notifications:read', next);
-			},
-		], callback);
-	};
-
-	UserNotifications.sendTopicNotificationToFollowers = function (uid, topicData, postData) {
-		var followers;
-		async.waterfall([
-			function (next) {
-				db.getSortedSetRange('followers:' + uid, 0, -1, next);
-			},
-			function (followers, next) {
-				if (!Array.isArray(followers) || !followers.length) {
-					return;
-				}
-				privileges.categories.filterUids('read', topicData.cid, followers, next);
-			},
-			function (_followers, next) {
-				followers = _followers;
-				if (!followers.length) {
-					return;
-				}
+			db.getObjectsFields(keys, ['nid', field], next);
+		},
+		function (notifications, next) {
+			values = values.map(function () { return values.toString(); });
+			nids = notifications.filter(function (notification) {
+				return notification && notification[field] && values.indexOf(notification[field].toString()) !== -1;
+			}).map(function (notification) {
+				return notification.nid;
+			});
 
-				var title = topicData.title;
-				if (title) {
-					title = S(title).decodeHTMLEntities().s;
-				}
+			next(null, nids);
+		},
+	], callback);
+};
 
-				notifications.create({
-					type: 'new-topic',
-					bodyShort: '[[notifications:user_posted_topic, ' + postData.user.username + ', ' + title + ']]',
-					bodyLong: postData.content,
-					pid: postData.pid,
-					path: '/post/' + postData.pid,
-					nid: 'tid:' + postData.tid + ':uid:' + uid,
-					tid: postData.tid,
-					from: uid,
-				}, next);
-			},
-		], function (err, notification) {
-			if (err) {
-				return winston.error(err);
+UserNotifications.deleteAll = function (uid, callback) {
+	if (!parseInt(uid, 10)) {
+		return callback();
+	}
+	async.parallel([
+		function (next) {
+			db.delete('uid:' + uid + ':notifications:unread', next);
+		},
+		function (next) {
+			db.delete('uid:' + uid + ':notifications:read', next);
+		},
+	], callback);
+};
+
+UserNotifications.sendTopicNotificationToFollowers = function (uid, topicData, postData) {
+	var followers;
+	async.waterfall([
+		function (next) {
+			db.getSortedSetRange('followers:' + uid, 0, -1, next);
+		},
+		function (followers, next) {
+			if (!Array.isArray(followers) || !followers.length) {
+				return;
+			}
+			privileges.categories.filterUids('read', topicData.cid, followers, next);
+		},
+		function (_followers, next) {
+			followers = _followers;
+			if (!followers.length) {
+				return;
 			}
 
-			if (notification) {
-				notifications.push(notification, followers);
+			var title = topicData.title;
+			if (title) {
+				title = S(title).decodeHTMLEntities().s;
 			}
-		});
-	};
 
-	UserNotifications.sendWelcomeNotification = function (uid, callback) {
-		callback = callback || function () {};
-		if (!meta.config.welcomeNotification) {
-			return callback();
+			notifications.create({
+				type: 'new-topic',
+				bodyShort: '[[notifications:user_posted_topic, ' + postData.user.username + ', ' + title + ']]',
+				bodyLong: postData.content,
+				pid: postData.pid,
+				path: '/post/' + postData.pid,
+				nid: 'tid:' + postData.tid + ':uid:' + uid,
+				tid: postData.tid,
+				from: uid,
+			}, next);
+		},
+	], function (err, notification) {
+		if (err) {
+			return winston.error(err);
 		}
 
-		var path = meta.config.welcomeLink ? meta.config.welcomeLink : '#';
+		if (notification) {
+			notifications.push(notification, followers);
+		}
+	});
+};
 
-		notifications.create({
-			bodyShort: meta.config.welcomeNotification,
-			path: path,
-			nid: 'welcome_' + uid,
-		}, function (err, notification) {
-			if (err || !notification) {
-				return callback(err);
-			}
+UserNotifications.sendWelcomeNotification = function (uid, callback) {
+	callback = callback || function () {};
+	if (!meta.config.welcomeNotification) {
+		return callback();
+	}
 
-			notifications.push(notification, [uid], callback);
-		});
-	};
-
-	UserNotifications.sendNameChangeNotification = function (uid, username) {
-		notifications.create({
-			bodyShort: '[[user:username_taken_workaround, ' + username + ']]',
-			image: 'brand:logo',
-			nid: 'username_taken:' + uid,
-			datetime: Date.now(),
-		}, function (err, notification) {
-			if (!err && notification) {
-				notifications.push(notification, uid);
-			}
-		});
-	};
-
-	UserNotifications.pushCount = function (uid) {
-		var websockets = require('./../socket.io');
-		UserNotifications.getUnreadCount(uid, function (err, count) {
-			if (err) {
-				return winston.error(err.stack);
+	var path = meta.config.welcomeLink ? meta.config.welcomeLink : '#';
+
+	async.waterfall([
+		function (next) {
+			notifications.create({
+				bodyShort: meta.config.welcomeNotification,
+				path: path,
+				nid: 'welcome_' + uid,
+			}, next);
+		},
+		function (notification, next) {
+			if (!notification) {
+				return next();
 			}
+			notifications.push(notification, [uid], next);
+		},
+	], callback);
+};
+
+UserNotifications.sendNameChangeNotification = function (uid, username) {
+	notifications.create({
+		bodyShort: '[[user:username_taken_workaround, ' + username + ']]',
+		image: 'brand:logo',
+		nid: 'username_taken:' + uid,
+		datetime: Date.now(),
+	}, function (err, notification) {
+		if (!err && notification) {
+			notifications.push(notification, uid);
+		}
+	});
+};
+
+UserNotifications.pushCount = function (uid) {
+	var websockets = require('./../socket.io');
+	UserNotifications.getUnreadCount(uid, function (err, count) {
+		if (err) {
+			return winston.error(err.stack);
+		}
 
-			websockets.in('uid_' + uid).emit('event:notifications.updateCount', count);
-		});
-	};
-}(exports));
+		websockets.in('uid_' + uid).emit('event:notifications.updateCount', count);
+	});
+};
diff --git a/test/notifications.js b/test/notifications.js
index fbbf4fd49b..d2585e4029 100644
--- a/test/notifications.js
+++ b/test/notifications.js
@@ -5,7 +5,11 @@ var assert = require('assert');
 var async = require('async');
 
 var db = require('./mocks/databasemock');
+var meta = require('../src/meta');
 var user = require('../src/user');
+var topics = require('../src/topics');
+var categories = require('../src/categories');
+var groups = require('../src/groups');
 var notifications = require('../src/notifications');
 var socketNotifications = require('../src/socket.io/notifications');
 
@@ -14,6 +18,7 @@ describe('Notifications', function () {
 	var notification;
 
 	before(function (done) {
+		groups.resetCache();
 		user.create({ username: 'poster' }, function (err, _uid) {
 			if (err) {
 				return done(err);
@@ -329,6 +334,123 @@ describe('Notifications', function () {
 		});
 	});
 
+	it('should return empty with falsy uid', function (done) {
+		user.notifications.get(0, function (err, data) {
+			assert.ifError(err);
+			assert.equal(data.read.length, 0);
+			assert.equal(data.unread.length, 0);
+			done();
+		});
+	});
+
+	it('should get all notifications and filter', function (done) {
+		var nid = 'willbefiltered';
+		notifications.create({
+			bodyShort: 'bodyShort',
+			nid: nid,
+			path: '/notification/path',
+			type: 'post',
+		}, function (err, notification) {
+			assert.ifError(err);
+			notifications.push(notification, [uid], function (err) {
+				assert.ifError(err);
+				setTimeout(function () {
+					user.notifications.getAll(uid, 'post', function (err, nids) {
+						assert.ifError(err);
+						assert.notEqual(nids.indexOf(nid), -1);
+						done();
+					});
+				}, 1500);
+			});
+		});
+	});
+
+	it('should not get anything if notifications does not exist', function (done) {
+		user.notifications.getNotifications(['doesnotexistnid1', 'doesnotexistnid2'], uid, function (err, data) {
+			assert.ifError(err);
+			assert.deepEqual(data, []);
+			done();
+		});
+	});
+
+	it('should get daily notifications', function (done) {
+		user.notifications.getDailyUnread(uid, function (err, data) {
+			assert.ifError(err);
+			assert.equal(data[0].nid, 'willbefiltered');
+			done();
+		});
+	});
+
+	it('should return 0 for falsy uid', function (done) {
+		user.notifications.getUnreadCount(0, function (err, count) {
+			assert.ifError(err);
+			assert.equal(count, 0);
+			done();
+		});
+	});
+
+	it('should not do anything if uid is falsy', function (done) {
+		user.notifications.deleteAll(0, function (err) {
+			assert.ifError(err);
+			done();
+		});
+	});
+
+	it('should send notification to followers of user when he posts', function (done) {
+		var followerUid;
+		async.waterfall([
+			function (next) {
+				user.create({ username: 'follower' }, next);
+			},
+			function (_followerUid, next) {
+				followerUid = _followerUid;
+				user.follow(followerUid, uid, next);
+			},
+			function (next) {
+				categories.create({
+					name: 'Test Category',
+					description: 'Test category created by testing script',
+				}, next);
+			},
+			function (category, next) {
+				topics.post({
+					uid: uid,
+					cid: category.cid,
+					title: 'Test Topic Title',
+					content: 'The content of test topic',
+				}, next);
+			},
+			function (data, next) {
+				setTimeout(next, 1100);
+			},
+			function (next) {
+				user.notifications.getAll(followerUid, '', next);
+			},
+		], function (err, data) {
+			assert.ifError(err);
+			assert(data);
+			done();
+		});
+	});
+
+	it('should send welcome notification', function (done) {
+		meta.config.welcomeNotification = 'welcome to the forums';
+		user.notifications.sendWelcomeNotification(uid, function (err) {
+			assert.ifError(err);
+			user.notifications.sendWelcomeNotification(uid, function (err) {
+				assert.ifError(err);
+				setTimeout(function () {
+					user.notifications.getAll(uid, '', function (err, data) {
+						meta.config.welcomeNotification = '';
+						assert.ifError(err);
+						assert.notEqual(data.indexOf('welcome_' + uid), -1);
+						done();
+					});
+				}, 1100);
+			});
+		});
+	});
+
 	it('should prune notifications', function (done) {
 		notifications.create({
 			bodyShort: 'bodyShort',