test/poll.js

   1 const assert = require('assert');
   2 const { Poll } = require('../lib/poll');
   3
   4 describe('Poll', () => {
   5     describe('constructor', () => {
   6         it('constructs a poll', () => {
   7             let poll = Poll.create(
   8                 'pollster',
   9                 'Which is better?',
  10                 [
  11                     'Coke',
  12                     'Pepsi'
  13                 ]
  14                 /* default opts */
  15             );
  16
  17             assert.strictEqual(poll.createdBy, 'pollster');
  18             assert.strictEqual(poll.title, 'Which is better?');
  19             assert.deepStrictEqual(poll.choices, ['Coke', 'Pepsi']);
  20             assert.strictEqual(poll.hideVotes, false);
  21         });
  22
  23         it('constructs a poll with hidden vote setting', () => {
  24             let poll = Poll.create(
  25                 'pollster',
  26                 'Which is better?',
  27                 [
  28                     'Coke',
  29                     'Pepsi'
  30                 ],
  31                 { hideVotes: true }
  32             );
  33
  34             assert.strictEqual(poll.hideVotes, true);
  35         });
  36
  37         it('sanitizes title and choices', () => {
  38             let poll = Poll.create(
  39                 'pollster',
  40                 'Which is better? <script></script>',
  41                 [
  42                     '<strong>Coke</strong>',
  43                     'Pepsi'
  44                 ]
  45                 /* default opts */
  46             );
  47
  48             assert.strictEqual(poll.title, 'Which is better? &lt;script&gt;&lt;/script&gt;');
  49             assert.deepStrictEqual(poll.choices, ['&lt;strong&gt;Coke&lt;/strong&gt;', 'Pepsi']);
  50         });
  51
  52         it('replaces URLs in title and choices', () => {
  53             let poll = Poll.create(
  54                 'pollster',
  55                 'Which is better? https://example.com',
  56                 [
  57                     'Coke https://example.com',
  58                     'Pepsi'
  59                 ]
  60                 /* default opts */
  61             );
  62
  63             assert.strictEqual(
  64                 poll.title,
  65                 'Which is better? <a href="https://example.com" target="_blank" rel="noopener noreferer">https://example.com</a>'
  66             );
  67             assert.deepStrictEqual(
  68                 poll.choices,
  69                 [
  70                     'Coke <a href="https://example.com" target="_blank" rel="noopener noreferer">https://example.com</a>',
  71                     'Pepsi'
  72                 ]
  73             );
  74         });
  75     });
  76
  77     describe('#countVote', () => {
  78         let poll;
  79         beforeEach(() => {
  80             poll = Poll.create(
  81                 'pollster',
  82                 'Which is better?',
  83                 [
  84                     'Coke',
  85                     'Pepsi'
  86                 ]
  87                 /* default opts */
  88             );
  89         });
  90
  91         it('counts a new vote', () => {
  92             assert.strictEqual(poll.countVote('userA', 0), true);
  93             assert.strictEqual(poll.countVote('userB', 1), true);
  94             assert.strictEqual(poll.countVote('userC', 0), true);
  95
  96             let { counts } = poll.toUpdateFrame();
  97             assert.deepStrictEqual(counts, [2, 1]);
  98         });
  99
 100         it('does not count a revote for the same choice', () => {
 101             assert.strictEqual(poll.countVote('userA', 0), true);
 102             assert.strictEqual(poll.countVote('userA', 0), false);
 103
 104             let { counts } = poll.toUpdateFrame();
 105             assert.deepStrictEqual(counts, [1, 0]);
 106         });
 107
 108         it('changes a vote to a different choice', () => {
 109             assert.strictEqual(poll.countVote('userA', 0), true);
 110             assert.strictEqual(poll.countVote('userA', 1), true);
 111
 112             let { counts } = poll.toUpdateFrame();
 113             assert.deepStrictEqual(counts, [0, 1]);
 114         });
 115
 116         it('ignores out of range votes', () => {
 117             assert.strictEqual(poll.countVote('userA', 1000), false);
 118             assert.strictEqual(poll.countVote('userA', -10), false);
 119
 120             let { counts } = poll.toUpdateFrame();
 121             assert.deepStrictEqual(counts, [0, 0]);
 122         });
 123     });
 124
 125     describe('#uncountVote', () => {
 126         let poll;
 127         beforeEach(() => {
 128             poll = Poll.create(
 129                 'pollster',
 130                 'Which is better?',
 131                 [
 132                     'Coke',
 133                     'Pepsi'
 134                 ]
 135                 /* default opts */
 136             );
 137         });
 138
 139         it('uncounts an existing vote', () => {
 140             assert.strictEqual(poll.countVote('userA', 0), true);
 141             assert.strictEqual(poll.uncountVote('userA', 0), true);
 142
 143             let { counts } = poll.toUpdateFrame();
 144             assert.deepStrictEqual(counts, [0, 0]);
 145         });
 146
 147         it('does not uncount if there is no existing vote', () => {
 148             assert.strictEqual(poll.uncountVote('userA', 0), false);
 149
 150             let { counts } = poll.toUpdateFrame();
 151             assert.deepStrictEqual(counts, [0, 0]);
 152         });
 153     });
 154
 155     describe('#toUpdateFrame', () => {
 156         let poll;
 157         beforeEach(() => {
 158             poll = Poll.create(
 159                 'pollster',
 160                 'Which is better?',
 161                 [
 162                     'Coke',
 163                     'Pepsi'
 164                 ]
 165                 /* default opts */
 166             );
 167             poll.countVote('userA', 0);
 168             poll.countVote('userB', 1);
 169             poll.countVote('userC', 0);
 170         });
 171
 172         it('generates an update frame', () => {
 173             assert.deepStrictEqual(
 174                 poll.toUpdateFrame(),
 175                 {
 176                     title: 'Which is better?',
 177                     options: ['Coke', 'Pepsi'],
 178                     counts: [2, 1],
 179                     initiator: 'pollster',
 180                     timestamp: poll.createdAt.getTime()
 181                 }
 182             );
 183         });
 184
 185         it('hides votes when poll is hidden', () => {
 186             poll.hideVotes = true;
 187
 188             assert.deepStrictEqual(
 189                 poll.toUpdateFrame(),
 190                 {
 191                     title: 'Which is better?',
 192                     options: ['Coke', 'Pepsi'],
 193                     counts: ['?', '?'],
 194                     initiator: 'pollster',
 195                     timestamp: poll.createdAt.getTime()
 196                 }
 197             );
 198         });
 199
 200         it('displays hidden votes when requested', () => {
 201             poll.hideVotes = true;
 202
 203             assert.deepStrictEqual(
 204                 poll.toUpdateFrame(true),
 205                 {
 206                     title: 'Which is better?',
 207                     options: ['Coke', 'Pepsi'],
 208                     counts: ['2?', '1?'],
 209                     initiator: 'pollster',
 210                     timestamp: poll.createdAt.getTime()
 211                 }
 212             );
 213         });
 214     });
 215
 216     describe('#toChannelData/fromChannelData', () => {
 217         it('round trips a poll', () => {
 218             let data = {
 219                 title: '&lt;strong&gt;ready?&lt;/strong&gt;',
 220                 initiator: 'aUser',
 221                 options: ['yes', 'no'],
 222                 counts: [0, 1],
 223                 votes:{
 224                     '1.2.3.4': null, // Previous poll code would set removed votes to null
 225                     '5.6.7.8': 1
 226                 },
 227                 obscured: false,
 228                 timestamp: 1483414981110
 229             };
 230
 231             let poll = Poll.fromChannelData(data);
 232
 233             // New code does not store null votes
 234             data.votes = { '5.6.7.8': 1 };
 235             assert.deepStrictEqual(poll.toChannelData(), data);
 236         });
 237
 238         it('coerces a missing timestamp to the current time', () => {
 239             let data = {
 240                 title: '&lt;strong&gt;ready?&lt;/strong&gt;',
 241                 initiator: 'aUser',
 242                 options: ['yes', 'no'],
 243                 counts: [0, 1],
 244                 votes:{
 245                     '1.2.3.4': null,
 246                     '5.6.7.8': 1
 247                 },
 248                 obscured: false
 249             };
 250
 251             let now = Date.now();
 252             let poll = Poll.fromChannelData(data);
 253             const { timestamp } = poll.toChannelData();
 254             if (typeof timestamp !== 'number' || isNaN(timestamp))
 255                 assert.fail(`Unexpected timestamp: ${timestamp}`);
 256
 257             if (Math.abs(timestamp - now) > 1000)
 258                 assert.fail(`Unexpected timestamp: ${timestamp}`);
 259         });
 260     });
 261 });