tests/qunit/suites/resources/mediawiki.rcfilters/dm.FilterItem.test.js

   1 /* eslint-disable camelcase */
   2 ( function () {
   3         QUnit.module( 'mediawiki.rcfilters - FilterItem' );
   4
   5         QUnit.test( 'Initializing filter item', function ( assert ) {
   6                 var item,
   7                         group1 = new mw.rcfilters.dm.FilterGroup( 'group1' ),
   8                         group2 = new mw.rcfilters.dm.FilterGroup( 'group2' );
   9
  10                 item = new mw.rcfilters.dm.FilterItem( 'filter1', group1 );
  11                 assert.strictEqual(
  12                         item.getName(),
  13                         'group1__filter1',
  14                         'Filter name is retained.'
  15                 );
  16                 assert.strictEqual(
  17                         item.getGroupName(),
  18                         'group1',
  19                         'Group name is retained.'
  20                 );
  21
  22                 item = new mw.rcfilters.dm.FilterItem(
  23                         'filter1',
  24                         group1,
  25                         {
  26                                 label: 'test label',
  27                                 description: 'test description'
  28                         }
  29                 );
  30                 assert.strictEqual(
  31                         item.getLabel(),
  32                         'test label',
  33                         'Label information is retained.'
  34                 );
  35                 assert.strictEqual(
  36                         item.getLabel(),
  37                         'test label',
  38                         'Description information is retained.'
  39                 );
  40
  41                 item = new mw.rcfilters.dm.FilterItem(
  42                         'filter1',
  43                         group1,
  44                         {
  45                                 selected: true
  46                         }
  47                 );
  48                 assert.strictEqual(
  49                         item.isSelected(),
  50                         true,
  51                         'Item can be selected in the config.'
  52                 );
  53                 item.toggleSelected( true );
  54                 assert.strictEqual(
  55                         item.isSelected(),
  56                         true,
  57                         'Item can toggle its selected state.'
  58                 );
  59
  60                 // Subsets
  61                 item = new mw.rcfilters.dm.FilterItem(
  62                         'filter1',
  63                         group1,
  64                         {
  65                                 subset: [ 'sub1', 'sub2', 'sub3' ]
  66                         }
  67                 );
  68                 assert.deepEqual(
  69                         item.getSubset(),
  70                         [ 'sub1', 'sub2', 'sub3' ],
  71                         'Subset information is retained.'
  72                 );
  73                 assert.strictEqual(
  74                         item.existsInSubset( 'sub1' ),
  75                         true,
  76                         'Specific item exists in subset.'
  77                 );
  78                 assert.strictEqual(
  79                         item.existsInSubset( 'sub10' ),
  80                         false,
  81                         'Specific item does not exists in subset.'
  82                 );
  83                 assert.strictEqual(
  84                         item.isIncluded(),
  85                         false,
  86                         'Initial state of "included" is false.'
  87                 );
  88
  89                 item.toggleIncluded( true );
  90                 assert.strictEqual(
  91                         item.isIncluded(),
  92                         true,
  93                         'Item toggles its included state.'
  94                 );
  95
  96                 // Conflicts
  97                 item = new mw.rcfilters.dm.FilterItem(
  98                         'filter1',
  99                         group1,
 100                         {
 101                                 conflicts: {
 102                                         group2__conflict1: { group: 'group2', filter: 'group2__conflict1' },
 103                                         group2__conflict2: { group: 'group2', filter: 'group2__conflict2' },
 104                                         group2__conflict3: { group: 'group2', filter: 'group2__conflict3' }
 105                                 }
 106                         }
 107                 );
 108                 assert.deepEqual(
 109                         item.getConflicts(),
 110                         {
 111                                 group2__conflict1: { group: 'group2', filter: 'group2__conflict1' },
 112                                 group2__conflict2: { group: 'group2', filter: 'group2__conflict2' },
 113                                 group2__conflict3: { group: 'group2', filter: 'group2__conflict3' }
 114                         },
 115                         'Conflict information is retained.'
 116                 );
 117                 assert.strictEqual(
 118                         item.existsInConflicts( new mw.rcfilters.dm.FilterItem( 'conflict1', group2 ) ),
 119                         true,
 120                         'Specific item exists in conflicts.'
 121                 );
 122                 assert.strictEqual(
 123                         item.existsInConflicts( new mw.rcfilters.dm.FilterItem( 'conflict10', group1 ) ),
 124                         false,
 125                         'Specific item does not exists in conflicts.'
 126                 );
 127                 assert.strictEqual(
 128                         item.isConflicted(),
 129                         false,
 130                         'Initial state of "conflicted" is false.'
 131                 );
 132
 133                 item.toggleConflicted( true );
 134                 assert.strictEqual(
 135                         item.isConflicted(),
 136                         true,
 137                         'Item toggles its conflicted state.'
 138                 );
 139
 140                 // Fully covered
 141                 item = new mw.rcfilters.dm.FilterItem( 'filter1', group1 );
 142                 assert.strictEqual(
 143                         item.isFullyCovered(),
 144                         false,
 145                         'Initial state of "full coverage" is false.'
 146                 );
 147                 item.toggleFullyCovered( true );
 148                 assert.strictEqual(
 149                         item.isFullyCovered(),
 150                         true,
 151                         'Item toggles its fully coverage state.'
 152                 );
 153
 154         } );
 155
 156         QUnit.test( 'Emitting events', function ( assert ) {
 157                 var group1 = new mw.rcfilters.dm.FilterGroup( 'group1' ),
 158                         item = new mw.rcfilters.dm.FilterItem( 'filter1', group1 ),
 159                         events = [];
 160
 161                 // Listen to update events
 162                 item.on( 'update', function () {
 163                         events.push( item.getState() );
 164                 } );
 165
 166                 // Do stuff
 167                 item.toggleSelected( true ); // { selected: true, included: false, conflicted: false, fullyCovered: false }
 168                 item.toggleSelected( true ); // No event (duplicate state)
 169                 item.toggleIncluded( true ); // { selected: true, included: true, conflicted: false, fullyCovered: false }
 170                 item.toggleConflicted( true ); // { selected: true, included: true, conflicted: true, fullyCovered: false }
 171                 item.toggleFullyCovered( true ); // { selected: true, included: true, conflicted: true, fullyCovered: true }
 172                 item.toggleSelected(); // { selected: false, included: true, conflicted: true, fullyCovered: true }
 173
 174                 // Check emitted events
 175                 assert.deepEqual(
 176                         events,
 177                         [
 178                                 { selected: true, included: false, conflicted: false, fullyCovered: false },
 179                                 { selected: true, included: true, conflicted: false, fullyCovered: false },
 180                                 { selected: true, included: true, conflicted: true, fullyCovered: false },
 181                                 { selected: true, included: true, conflicted: true, fullyCovered: true },
 182                                 { selected: false, included: true, conflicted: true, fullyCovered: true }
 183                         ],
 184                         'Events emitted successfully.'
 185                 );
 186         } );
 187
 188         QUnit.test( 'get/set boolean value', function ( assert ) {
 189                 var group = new mw.rcfilters.dm.FilterGroup( 'group1', { type: 'boolean' } ),
 190                         item = new mw.rcfilters.dm.FilterItem( 'filter1', group );
 191
 192                 item.setValue( '1' );
 193
 194                 assert.strictEqual( item.getValue(), true, 'Value is coerced to boolean' );
 195         } );
 196
 197         QUnit.test( 'get/set any value', function ( assert ) {
 198                 var group = new mw.rcfilters.dm.FilterGroup( 'group1', { type: 'any_value' } ),
 199                         item = new mw.rcfilters.dm.FilterItem( 'filter1', group );
 200
 201                 item.setValue( '1' );
 202
 203                 assert.strictEqual( item.getValue(), '1', 'Value is kept as-is' );
 204         } );
 205 }() );