modules/rooms/test/room-membership-flags-test.js

   1 'use strict';
   2
   3 var assert = require('assert');
   4
   5 describe('room-membership-flags', function() {
   6   var underTest;
   7   before(function() {
   8     underTest = require('../lib/room-membership-flags');
   9   });
  10
  11   describe('getModeFromFlags', function() {
  12     describe('strict', function() {
  13       var FIXTURES = {
  14         '1101101': 'all',
  15         '1111101': 'all', // Ignore other values
  16         '0000110': 'mute',
  17         '0010110': 'mute', // Ignore other values
  18         '0001101': 'announcement',
  19         '0011101': 'announcement', // Ignore other values
  20         '0101010': null
  21       };
  22
  23       Object.keys(FIXTURES).forEach(function(flags) {
  24         var mode = FIXTURES[flags];
  25
  26         it('should handle ' + flags + ' to ' + mode, function() {
  27           var result = underTest.getModeFromFlags(parseInt(flags, 2), true);
  28           assert.strictEqual(result, mode);
  29         });
  30       });
  31     });
  32
  33     describe('not-strict', function() {
  34       var FIXTURES = {
  35         '0101101': 'all',
  36         '1101101': 'all',
  37         '1111101': 'all', // Ignore other values
  38         '1000110': 'mute',
  39         '0000110': 'mute',
  40         '0010110': 'mute', // Ignore other values
  41         '0001101': 'announcement',
  42         '0011101': 'announcement' // Ignore other values
  43       };
  44
  45       Object.keys(FIXTURES).forEach(function(flags) {
  46         var mode = FIXTURES[flags];
  47
  48         it('should handle ' + flags + ' to ' + mode, function() {
  49           var result = underTest.getModeFromFlags(parseInt(flags, 2), false);
  50           assert.strictEqual(result, mode);
  51         });
  52       });
  53     });
  54   });
  55
  56   describe('getUpdateForMode', function() {
  57     var UNTOUCHED_BITS = '111111111111111111111';
  58
  59     var FIXTURES = {
  60       'all-no-default': {
  61         mode: 'all',
  62         and: UNTOUCHED_BITS + '1101101',
  63         or: '1101101',
  64         lurk: false,
  65         isDefault: undefined
  66       },
  67       'announcement-no-default': {
  68         mode: 'announcement',
  69         and: UNTOUCHED_BITS + '0001101',
  70         or: '0001101',
  71         lurk: false,
  72         isDefault: undefined
  73       },
  74       'mention-no-default': {
  75         mode: 'mention',
  76         and: UNTOUCHED_BITS + '0001101',
  77         or: '0001101',
  78         lurk: false,
  79         isDefault: undefined
  80       },
  81       'mute-no-default': {
  82         mode: 'mute',
  83         and: UNTOUCHED_BITS + '0000110',
  84         or: '0000110',
  85         lurk: true,
  86         isDefault: undefined
  87       },
  88
  89       // -------------------------------------------
  90
  91       'all-is-default': {
  92         mode: 'all',
  93         and: UNTOUCHED_BITS + '1111101',
  94         or: '1111101',
  95         lurk: false,
  96         isDefault: true
  97       },
  98       'announcement-is-default': {
  99         mode: 'announcement',
 100         and: UNTOUCHED_BITS + '0011101',
 101         or: '0011101',
 102         lurk: false,
 103         isDefault: true
 104       },
 105       'mention-is-default': {
 106         mode: 'mention',
 107         and: UNTOUCHED_BITS + '0011101',
 108         or: '0011101',
 109         lurk: false,
 110         isDefault: true
 111       },
 112       'mute-is-default': {
 113         mode: 'mute',
 114         and: UNTOUCHED_BITS + '0010110',
 115         or: '0010110',
 116         lurk: true,
 117         isDefault: true
 118       },
 119
 120       // -------------------------------------------
 121
 122       'all-not-default': {
 123         mode: 'all',
 124         and: UNTOUCHED_BITS + '1101101',
 125         or: '1101101',
 126         lurk: false,
 127         isDefault: false
 128       },
 129       'announcement-not-default': {
 130         mode: 'announcement',
 131         and: UNTOUCHED_BITS + '0001101',
 132         or: '0001101',
 133         lurk: false,
 134         isDefault: false
 135       },
 136       'mention-not-default': {
 137         mode: 'mention',
 138         and: UNTOUCHED_BITS + '0001101',
 139         or: '0001101',
 140         lurk: false,
 141         isDefault: false
 142       },
 143       'mute-not-default': {
 144         mode: 'mute',
 145         and: UNTOUCHED_BITS + '0000110',
 146         or: '0000110',
 147         lurk: true,
 148         isDefault: false
 149       }
 150     };
 151
 152     var FLAG_VALUES = [
 153       '0000000000000000000000000000',
 154       '1111111111111111111111111111',
 155       '1010101010101010101010101010',
 156       '1001001001001001001001001001'
 157     ];
 158
 159     Object.keys(FIXTURES).forEach(function(testName) {
 160       var values = FIXTURES[testName];
 161       var mode = values.mode;
 162
 163       it('should handle ' + testName, function() {
 164         var result = underTest.getUpdateForMode(mode, values.isDefault);
 165         assert.deepEqual(result, {
 166           $bit: {
 167             flags: {
 168               and: parseInt(values.and, 2),
 169               or: parseInt(values.or, 2)
 170             }
 171           }
 172         });
 173
 174         FLAG_VALUES.forEach(function(flags) {
 175           var flagValue = parseInt(flags, 2);
 176           // Test for bit idempotency
 177           var result1 = (flagValue & parseInt(values.and, 2)) | parseInt(values.or, 2);
 178           var result2 = (flagValue | parseInt(values.or, 2)) & parseInt(values.and, 2);
 179
 180           assert.strictEqual(result1.toString(2), result2.toString(2));
 181           var newMode = underTest.getModeFromFlags(result1);
 182
 183           assert.strictEqual(
 184             newMode,
 185             mode === 'mention' ? 'announcement' : mode,
 186             'For flags ' + flags + ', expected mode ' + mode + ' got ' + newMode
 187           );
 188         });
 189       });
 190     });
 191   });
 192
 193   describe('getLurkForFlags', function() {
 194     var FIXTURES = {
 195       '01101': false,
 196       '11101': false,
 197       '00100': true,
 198       '10100': true,
 199       '01110': true,
 200       '11110': true // Ignore other values
 201     };
 202
 203     Object.keys(FIXTURES).forEach(function(flags) {
 204       var isLurking = FIXTURES[flags];
 205
 206       it('should handle ' + flags, function() {
 207         var result = underTest.getLurkForFlags(parseInt(flags, 2));
 208         assert.strictEqual(result, isLurking);
 209       });
 210     });
 211   });
 212
 213   describe('getLurkForMode', function() {
 214     var FIXTURES = {
 215       all: false,
 216       announcement: false,
 217       mention: false,
 218       mute: true
 219     };
 220
 221     Object.keys(FIXTURES).forEach(function(mode) {
 222       var isLurking = FIXTURES[mode];
 223
 224       it('should handle ' + mode, function() {
 225         var result = underTest.getLurkForMode(mode);
 226         assert.strictEqual(result, isLurking);
 227       });
 228     });
 229   });
 230
 231   describe('getFlagsForMode', function() {
 232     var FIXTURES = {
 233       'all-default': {
 234         mode: 'all',
 235         default: true,
 236         value: '1111101'
 237       },
 238       'announcement-default': {
 239         mode: 'announcement',
 240         default: true,
 241         value: '11101'
 242       },
 243       'mention-default': {
 244         mode: 'mention',
 245         default: true,
 246         value: '11101'
 247       },
 248       'mute-default': {
 249         mode: 'mute',
 250         default: true,
 251         value: '10110'
 252       },
 253
 254       /* ----------------------- */
 255
 256       'all-not-default': {
 257         mode: 'all',
 258         default: false,
 259         value: '1101101'
 260       },
 261       'announcement-not-default': {
 262         mode: 'announcement',
 263         default: false,
 264         value: '1101'
 265       },
 266       'mention-not-default': {
 267         mode: 'mention',
 268         default: false,
 269         value: '1101'
 270       },
 271       'mute-not-default': {
 272         mode: 'mute',
 273         default: false,
 274         value: '110'
 275       }
 276     };
 277
 278     Object.keys(FIXTURES).forEach(function(testName) {
 279       var values = FIXTURES[testName];
 280
 281       it('should handle ' + testName, function() {
 282         var result = underTest.getFlagsForMode(values.mode, values.default);
 283         assert.strictEqual(result.toString(2), values.value);
 284       });
 285     });
 286   });
 287
 288   describe('toggleLegacyLurkMode', function() {
 289     var FIXTURES = [
 290       {
 291         flags: '11101',
 292         lurk: true,
 293         expected: '11110'
 294       },
 295       {
 296         flags: '11111',
 297         lurk: true,
 298         expected: '11110'
 299       },
 300       {
 301         flags: '11110',
 302         lurk: true,
 303         expected: '11110'
 304       },
 305       {
 306         flags: '0',
 307         lurk: true,
 308         expected: '0'
 309       },
 310       {
 311         flags: '11101',
 312         lurk: false,
 313         expected: '11101'
 314       },
 315       {
 316         flags: '11111',
 317         lurk: false,
 318         expected: '11111'
 319       },
 320       {
 321         flags: '11110',
 322         lurk: false,
 323         expected: '11101'
 324       },
 325       {
 326         flags: '0',
 327         lurk: false,
 328         expected: '1'
 329       }
 330     ];
 331
 332     FIXTURES.forEach(function(values, index) {
 333       it('should handle case ' + index, function() {
 334         var result = underTest.toggleLegacyLurkMode(parseInt(values.flags, 2), values.lurk);
 335         assert.strictEqual(result.toString(2), values.expected);
 336       });
 337     });
 338   });
 339 });