more notification tests

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) {

src/user/notifications.js

@@ -10,16 +10,17 @@ var meta = require('../meta');
 var notifications = require('../notifications');
 var privileges = require('../privileges');
 
-(function (UserNotifications) {
+var UserNotifications = module.exports;
+
 UserNotifications.get = function (uid, callback) {
 	if (!parseInt(uid, 10)) {
 		return callback(null, { read: [], unread: [] });
 	}
-		getNotifications(uid, 0, 9, function (err, notifications) {
+	async.waterfall([
-			if (err) {
+		function (next) {
-				return callback(err);
+			getNotifications(uid, 0, 9, next);
-			}
+		},
-
+		function (notifications, next) {
 			notifications.read = notifications.read.filter(Boolean);
 			notifications.unread = notifications.unread.filter(Boolean);
 
@@ -28,8 +29,9 @@ var privileges = require('../privileges');
 				notifications.read.length = maxNotifs - notifications.unread.length;
 			}
 
-			callback(null, notifications);
+			next(null, notifications);
-		});
+		},
+	], callback);
 };
 
 function filterNotifications(nids, filter, callback) {
@@ -170,17 +172,18 @@ var privileges = require('../privileges');
 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) {
+	async.waterfall([
-			if (err) {
+		function (next) {
-				return callback(err);
+			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, callback);
+			UserNotifications.getNotifications(nids, uid, next);
-		});
+		},
+	], callback);
 };
 
 UserNotifications.getUnreadCount = function (uid, callback) {
@@ -188,10 +191,14 @@ var privileges = require('../privileges');
 		return callback(null, 0);
 	}
 
-		// Collapse any notifications with identical mergeIds
+
 	async.waterfall([
-			async.apply(db.getSortedSetRevRange, 'uid:' + uid + ':notifications:unread', 0, 99),
+		function (next) {
-			async.apply(notifications.filterExists),
+			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;
@@ -200,6 +207,7 @@ var privileges = require('../privileges');
 			db.getObjectsFields(keys, ['mergeId'], next);
 		},
 		function (mergeIds, next) {
+			// Collapse any notifications with identical mergeIds
 			mergeIds = mergeIds.map(function (set) {
 				return set.mergeId;
 			});
@@ -217,11 +225,13 @@ var privileges = require('../privileges');
 };
 
 UserNotifications.getUnreadByField = function (uid, field, values, callback) {
-		db.getSortedSetRevRange('uid:' + uid + ':notifications:unread', 0, 99, function (err, nids) {
+	var nids;
-			if (err) {
+	async.waterfall([
-				return callback(err);
+		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, []);
 			}
@@ -230,11 +240,9 @@ var privileges = require('../privileges');
 				return 'notifications:' + nid;
 			});
 
-			db.getObjectsFields(keys, ['nid', field], function (err, notifications) {
+			db.getObjectsFields(keys, ['nid', field], next);
-				if (err) {
+		},
-					return callback(err);
+		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;
@@ -242,9 +250,9 @@ var privileges = require('../privileges');
 				return notification.nid;
 			});
 
-				callback(null, nids);
+			next(null, nids);
-			});
+		},
-		});
+	], callback);
 };
 
 UserNotifications.deleteAll = function (uid, callback) {
@@ -314,17 +322,21 @@ var privileges = require('../privileges');
 
 	var path = meta.config.welcomeLink ? meta.config.welcomeLink : '#';
 
+	async.waterfall([
+		function (next) {
 			notifications.create({
 				bodyShort: meta.config.welcomeNotification,
 				path: path,
 				nid: 'welcome_' + uid,
-		}, function (err, notification) {
+			}, next);
-			if (err || !notification) {
+		},
-				return callback(err);
+		function (notification, next) {
+			if (!notification) {
+				return next();
 			}
-
+			notifications.push(notification, [uid], next);
-			notifications.push(notification, [uid], callback);
+		},
-		});
+	], callback);
 };
 
 UserNotifications.sendNameChangeNotification = function (uid, username) {
@@ -350,4 +362,3 @@ var privileges = require('../privileges');
 		websockets.in('uid_' + uid).emit('event:notifications.updateCount', count);
 	});
 };
-}(exports));

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',