modules/rooms/test/user-default-flags-service-test.js

   1 'use strict';
   2
   3 var assert = require('assert');
   4 var Promise = require('bluebird');
   5 var fixtureLoader = require('gitter-web-test-utils/lib/test-fixtures');
   6 var roomMembershipFlags = require('../lib/room-membership-flags');
   7 var userDefaultFlagsService = require('../lib/user-default-flags-service');
   8 var userDefaultFlagsUpdateService = require('../lib/user-default-flags-update-service');
   9
  10 describe('user-default-flags', function() {
  11   describe('useOneToOneDefaultWhenMute', function() {
  12     var FIXTURES = [
  13       {
  14         name: 'all',
  15         flags: roomMembershipFlags.MODES.all,
  16         expected: roomMembershipFlags.MODES.all
  17       },
  18       {
  19         name: 'annoucement',
  20         flags: roomMembershipFlags.MODES.all,
  21         expected: roomMembershipFlags.MODES.all
  22       },
  23       {
  24         name: 'mute',
  25         flags: roomMembershipFlags.MODES.mute,
  26         expected: roomMembershipFlags.DEFAULT_ONE_TO_ONE_FLAGS_WHEN_MUTE
  27       }
  28     ];
  29
  30     describe('without default flag', function() {
  31       FIXTURES.forEach(function(meta) {
  32         it(meta.name, function() {
  33           var result = userDefaultFlagsService.testOnly.useOneToOneDefaultWhenMute(meta.flags);
  34           assert.strictEqual(result, meta.expected);
  35         });
  36       });
  37     });
  38
  39     describe('strips off the default flag', function() {
  40       FIXTURES.forEach(function(meta) {
  41         it(meta.name, function() {
  42           var flags = roomMembershipFlags.addDefaultFlag(meta.flags);
  43           var result = userDefaultFlagsService.testOnly.useOneToOneDefaultWhenMute(flags);
  44           assert.strictEqual(result, meta.expected);
  45         });
  46       });
  47     });
  48   });
  49
  50   describe('#slow', function() {
  51     var fixture = fixtureLoader.setup({
  52       user1: {},
  53       user2: {},
  54       user3: {}
  55     });
  56
  57     describe('getDefaultFlagsForUserId', function() {
  58       it('should handle users without a default', function() {
  59         var userId1 = fixture.user1._id;
  60
  61         return userDefaultFlagsService
  62           .setDefaultFlagsForUserId(userId1, null)
  63           .then(function() {
  64             return userDefaultFlagsService.getDefaultFlagsForUserId(userId1);
  65           })
  66           .then(function(flags) {
  67             assert.strictEqual(flags, roomMembershipFlags.DEFAULT_USER_FLAGS);
  68           });
  69       });
  70
  71       it('should handle users with a value', function() {
  72         var userId1 = fixture.user1._id;
  73
  74         return userDefaultFlagsService
  75           .setDefaultFlagsForUserId(userId1, 1)
  76           .then(function() {
  77             return userDefaultFlagsService.getDefaultFlagsForUserId(userId1);
  78           })
  79           .then(function(flags) {
  80             assert.strictEqual(flags, 1);
  81           });
  82       });
  83     });
  84
  85     describe('getDefaultFlagsForUserIds', function() {
  86       it('should handle users without a default', function() {
  87         var userId1 = fixture.user1._id;
  88         var userId2 = fixture.user2._id;
  89
  90         return Promise.join(
  91           userDefaultFlagsService.setDefaultFlagsForUserId(userId1, null),
  92           userDefaultFlagsService.setDefaultFlagsForUserId(userId2, null)
  93         )
  94           .then(function() {
  95             return userDefaultFlagsService.getDefaultFlagsForUserIds([userId1, userId2]);
  96           })
  97           .then(function(flags) {
  98             var expected = {};
  99             expected[userId1] = roomMembershipFlags.DEFAULT_USER_FLAGS;
 100             expected[userId2] = roomMembershipFlags.DEFAULT_USER_FLAGS;
 101             assert.deepEqual(flags, expected);
 102           });
 103       });
 104
 105       it('should handle users with a value', function() {
 106         var userId1 = fixture.user1._id;
 107         var userId2 = fixture.user2._id;
 108
 109         return Promise.join(
 110           userDefaultFlagsService.setDefaultFlagsForUserId(userId1, 1),
 111           userDefaultFlagsService.setDefaultFlagsForUserId(userId2, 2)
 112         )
 113           .then(function() {
 114             return userDefaultFlagsService.getDefaultFlagsForUserIds([userId1, userId2]);
 115           })
 116           .then(function(flags) {
 117             var expected = {};
 118             expected[userId1] = 1;
 119             expected[userId2] = 2;
 120             assert.deepEqual(flags, expected);
 121           });
 122       });
 123     });
 124
 125     describe('setDefaultFlagsForUserId', function() {
 126       it('should handle setting and unsetting the value', function() {
 127         var userId1 = fixture.user1._id;
 128
 129         return userDefaultFlagsService
 130           .setDefaultFlagsForUserId(userId1, null)
 131           .then(function() {
 132             return userDefaultFlagsService.getDefaultFlagsForUserId(userId1);
 133           })
 134           .then(function(flags) {
 135             assert.strictEqual(flags, roomMembershipFlags.DEFAULT_USER_FLAGS);
 136             return userDefaultFlagsService.setDefaultFlagsForUserId(userId1, 1);
 137           })
 138           .then(function() {
 139             return userDefaultFlagsService.getDefaultFlagsForUserId(userId1);
 140           })
 141           .then(function(flags) {
 142             assert.strictEqual(flags, 1);
 143             return userDefaultFlagsService.setDefaultFlagsForUserId(userId1, 2);
 144           })
 145           .then(function() {
 146             return userDefaultFlagsService.getDefaultFlagsForUserId(userId1);
 147           })
 148           .then(function(flags) {
 149             assert.strictEqual(flags, 2);
 150             return userDefaultFlagsService.setDefaultFlagsForUserId(userId1, null);
 151           })
 152           .then(function() {
 153             return userDefaultFlagsService.getDefaultFlagsForUserId(userId1);
 154           })
 155           .then(function(flags) {
 156             assert.strictEqual(flags, roomMembershipFlags.DEFAULT_USER_FLAGS);
 157             return userDefaultFlagsService.setDefaultFlagsForUserId(userId1, 1);
 158           });
 159       });
 160     });
 161
 162     describe('getDefaultFlagDetailsForUserId', function() {
 163       it('should handle users who have not changed their default', function() {
 164         var user3 = fixture.user3;
 165
 166         return userDefaultFlagsService
 167           .getDefaultFlagDetailsForUserId(user3._id)
 168           .then(function(details) {
 169             assert.deepEqual(details, {
 170               activity: false,
 171               announcement: true,
 172               desktop: true,
 173               flags: 125,
 174               lurk: false,
 175               mention: true,
 176               mobile: true,
 177               mode: 'all',
 178               unread: true
 179             });
 180           });
 181       });
 182
 183       it('should handle users who have changed their default to all', function() {
 184         var user1 = fixture.user1;
 185         return userDefaultFlagsUpdateService
 186           .updateDefaultModeForUser(user1, 'all', false)
 187           .then(function() {
 188             return userDefaultFlagsService.getDefaultFlagDetailsForUserId(user1._id);
 189           })
 190           .then(function(details) {
 191             assert.deepEqual(details, {
 192               activity: false,
 193               announcement: true,
 194               desktop: true,
 195               flags: 125,
 196               lurk: false,
 197               mention: true,
 198               mobile: true,
 199               mode: 'all',
 200               unread: true
 201             });
 202           });
 203       });
 204
 205       it('should handle users who have changed their default to announcement', function() {
 206         var user1 = fixture.user1;
 207         return userDefaultFlagsUpdateService
 208           .updateDefaultModeForUser(user1, 'announcement', false)
 209           .then(function() {
 210             return userDefaultFlagsService.getDefaultFlagDetailsForUserId(user1._id);
 211           })
 212           .then(function(details) {
 213             assert.deepEqual(details, {
 214               activity: false,
 215               announcement: true,
 216               desktop: false,
 217               flags: 29,
 218               lurk: false,
 219               mention: true,
 220               mobile: false,
 221               mode: 'announcement',
 222               unread: true
 223             });
 224           });
 225       });
 226
 227       it('should handle users who have changed their default to mute', function() {
 228         var user1 = fixture.user1;
 229         return userDefaultFlagsUpdateService
 230           .updateDefaultModeForUser(user1, 'mute', false)
 231           .then(function() {
 232             return userDefaultFlagsService.getDefaultFlagDetailsForUserId(user1._id);
 233           })
 234           .then(function(details) {
 235             assert.deepEqual(details, {
 236               activity: true,
 237               announcement: false,
 238               desktop: false,
 239               flags: 22,
 240               lurk: true,
 241               mention: true,
 242               mobile: false,
 243               mode: 'mute',
 244               unread: false
 245             });
 246           });
 247       });
 248     });
 249   });
 250 });