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

   1 ( function ( mw, $ ) {
   2         QUnit.module( 'mediawiki.rcfilters - FiltersViewModel' );
   3
   4         QUnit.test( 'Setting up filters', function ( assert ) {
   5                 var definition = {
   6                                 group1: {
   7                                         title: 'Group 1',
   8                                         type: 'send_unselected_if_any',
   9                                         filters: [
  10                                                 {
  11                                                         name: 'group1filter1',
  12                                                         label: 'Group 1: Filter 1',
  13                                                         description: 'Description of Filter 1 in Group 1'
  14                                                 },
  15                                                 {
  16                                                         name: 'group1filter2',
  17                                                         label: 'Group 1: Filter 2',
  18                                                         description: 'Description of Filter 2 in Group 1'
  19                                                 }
  20                                         ]
  21                                 },
  22                                 group2: {
  23                                         title: 'Group 2',
  24                                         type: 'send_unselected_if_any',
  25                                         filters: [
  26                                                 {
  27                                                         name: 'group2filter1',
  28                                                         label: 'Group 2: Filter 1',
  29                                                         description: 'Description of Filter 1 in Group 2'
  30                                                 },
  31                                                 {
  32                                                         name: 'group2filter2',
  33                                                         label: 'Group 2: Filter 2',
  34                                                         description: 'Description of Filter 2 in Group 2'
  35                                                 }
  36                                         ]
  37                                 }
  38                         },
  39                         model = new mw.rcfilters.dm.FiltersViewModel();
  40
  41                 model.initializeFilters( definition );
  42
  43                 assert.ok(
  44                         model.getItemByName( 'group1filter1' ) instanceof mw.rcfilters.dm.FilterItem &&
  45                         model.getItemByName( 'group1filter2' ) instanceof mw.rcfilters.dm.FilterItem &&
  46                         model.getItemByName( 'group2filter1' ) instanceof mw.rcfilters.dm.FilterItem &&
  47                         model.getItemByName( 'group2filter2' ) instanceof mw.rcfilters.dm.FilterItem,
  48                         'Filters instantiated and stored correctly'
  49                 );
  50
  51                 assert.deepEqual(
  52                         model.getState(),
  53                         {
  54                                 group1filter1: false,
  55                                 group1filter2: false,
  56                                 group2filter1: false,
  57                                 group2filter2: false
  58                         },
  59                         'Initial state of filters'
  60                 );
  61
  62                 model.updateFilters( {
  63                         group1filter1: true,
  64                         group2filter2: true
  65                 } );
  66                 assert.deepEqual(
  67                         model.getState(),
  68                         {
  69                                 group1filter1: true,
  70                                 group1filter2: false,
  71                                 group2filter1: false,
  72                                 group2filter2: true
  73                         },
  74                         'Updating filter states correctly'
  75                 );
  76         } );
  77
  78         QUnit.test( 'Finding matching filters', function ( assert ) {
  79                 var matches,
  80                         definition = {
  81                                 group1: {
  82                                         title: 'Group 1',
  83                                         type: 'send_unselected_if_any',
  84                                         filters: [
  85                                                 {
  86                                                         name: 'group1filter1',
  87                                                         label: 'Group 1: Filter 1',
  88                                                         description: 'Description of Filter 1 in Group 1'
  89                                                 },
  90                                                 {
  91                                                         name: 'group1filter2',
  92                                                         label: 'Group 1: Filter 2',
  93                                                         description: 'Description of Filter 2 in Group 1'
  94                                                 }
  95                                         ]
  96                                 },
  97                                 group2: {
  98                                         title: 'Group 2',
  99                                         type: 'send_unselected_if_any',
 100                                         filters: [
 101                                                 {
 102                                                         name: 'group2filter1',
 103                                                         label: 'Group 2: Filter 1',
 104                                                         description: 'Description of Filter 1 in Group 2'
 105                                                 },
 106                                                 {
 107                                                         name: 'group2filter2',
 108                                                         label: 'Group 2: Filter 2',
 109                                                         description: 'Description of Filter 2 in Group 2'
 110                                                 }
 111                                         ]
 112                                 }
 113                         },
 114                         model = new mw.rcfilters.dm.FiltersViewModel();
 115
 116                 model.initializeFilters( definition );
 117
 118                 matches = model.findMatches( 'group 1' );
 119                 assert.equal(
 120                         matches.group1.length,
 121                         2,
 122                         'findMatches finds correct group with correct number of results'
 123                 );
 124
 125                 assert.deepEqual(
 126                         matches.group1.map( function ( item ) { return item.getName(); } ),
 127                         [ 'group1filter1', 'group1filter2' ],
 128                         'findMatches finds the correct items within a single group'
 129                 );
 130
 131                 matches = model.findMatches( 'filter 1' );
 132                 assert.ok(
 133                         matches.group1.length === 1 && matches.group2.length === 1,
 134                         'findMatches finds correct number of results in multiple groups'
 135                 );
 136
 137                 assert.deepEqual(
 138                         [
 139                                 matches.group1.map( function ( item ) { return item.getName(); } ),
 140                                 matches.group2.map( function ( item ) { return item.getName(); } )
 141                         ],
 142                         [
 143                                 [ 'group1filter1' ],
 144                                 [ 'group2filter1' ]
 145                         ],
 146                         'findMatches finds the correct items within multiple groups'
 147                 );
 148
 149                 matches = model.findMatches( 'foo' );
 150                 assert.ok(
 151                         $.isEmptyObject( matches ),
 152                         'findMatches returns an empty object when no results found'
 153                 );
 154         } );
 155
 156         QUnit.test( 'getParametersFromFilters', function ( assert ) {
 157                 var definition = {
 158                                 group1: {
 159                                         title: 'Group 1',
 160                                         type: 'send_unselected_if_any',
 161                                         filters: [
 162                                                 {
 163                                                         name: 'hidefilter1',
 164                                                         label: 'Group 1: Filter 1',
 165                                                         description: 'Description of Filter 1 in Group 1'
 166                                                 },
 167                                                 {
 168                                                         name: 'hidefilter2',
 169                                                         label: 'Group 1: Filter 2',
 170                                                         description: 'Description of Filter 2 in Group 1'
 171                                                 },
 172                                                 {
 173                                                         name: 'hidefilter3',
 174                                                         label: 'Group 1: Filter 3',
 175                                                         description: 'Description of Filter 3 in Group 1'
 176                                                 }
 177                                         ]
 178                                 },
 179                                 group2: {
 180                                         title: 'Group 2',
 181                                         type: 'send_unselected_if_any',
 182                                         filters: [
 183                                                 {
 184                                                         name: 'hidefilter4',
 185                                                         label: 'Group 2: Filter 1',
 186                                                         description: 'Description of Filter 1 in Group 2'
 187                                                 },
 188                                                 {
 189                                                         name: 'hidefilter5',
 190                                                         label: 'Group 2: Filter 2',
 191                                                         description: 'Description of Filter 2 in Group 2'
 192                                                 },
 193                                                 {
 194                                                         name: 'hidefilter6',
 195                                                         label: 'Group 2: Filter 3',
 196                                                         description: 'Description of Filter 3 in Group 2'
 197                                                 }
 198                                         ]
 199                                 }
 200                         },
 201                         model = new mw.rcfilters.dm.FiltersViewModel();
 202
 203                 model.initializeFilters( definition );
 204
 205                 // Starting with all filters unselected
 206                 assert.deepEqual(
 207                         model.getParametersFromFilters(),
 208                         {
 209                                 hidefilter1: 0,
 210                                 hidefilter2: 0,
 211                                 hidefilter3: 0,
 212                                 hidefilter4: 0,
 213                                 hidefilter5: 0,
 214                                 hidefilter6: 0
 215                         },
 216                         'Unselected filters return all parameters falsey.'
 217                 );
 218
 219                 // Select 1 filter
 220                 model.updateFilters( {
 221                         hidefilter1: true,
 222                         hidefilter2: false,
 223                         hidefilter3: false,
 224                         hidefilter4: false,
 225                         hidefilter5: false,
 226                         hidefilter6: false
 227                 } );
 228                 // Only one filter in one group
 229                 assert.deepEqual(
 230                         model.getParametersFromFilters(),
 231                         {
 232                                 // Group 1 (one selected, the others are true)
 233                                 hidefilter1: 0,
 234                                 hidefilter2: 1,
 235                                 hidefilter3: 1,
 236                                 // Group 2 (nothing is selected, all false)
 237                                 hidefilter4: 0,
 238                                 hidefilter5: 0,
 239                                 hidefilter6: 0
 240                         },
 241                         'One filters in one "send_unselected_if_any" group returns the other parameters truthy.'
 242                 );
 243
 244                 // Select 2 filters
 245                 model.updateFilters( {
 246                         hidefilter1: true,
 247                         hidefilter2: true,
 248                         hidefilter3: false,
 249                         hidefilter4: false,
 250                         hidefilter5: false,
 251                         hidefilter6: false
 252                 } );
 253                 // Two selected filters in one group
 254                 assert.deepEqual(
 255                         model.getParametersFromFilters(),
 256                         {
 257                                 // Group 1 (two selected, the others are true)
 258                                 hidefilter1: 0,
 259                                 hidefilter2: 0,
 260                                 hidefilter3: 1,
 261                                 // Group 2 (nothing is selected, all false)
 262                                 hidefilter4: 0,
 263                                 hidefilter5: 0,
 264                                 hidefilter6: 0
 265                         },
 266                         'One filters in one "send_unselected_if_any" group returns the other parameters truthy.'
 267                 );
 268
 269                 // Select 3 filters
 270                 model.updateFilters( {
 271                         hidefilter1: true,
 272                         hidefilter2: true,
 273                         hidefilter3: true,
 274                         hidefilter4: false,
 275                         hidefilter5: false,
 276                         hidefilter6: false
 277                 } );
 278                 // All filters of the group are selected == this is the same as not selecting any
 279                 assert.deepEqual(
 280                         model.getParametersFromFilters(),
 281                         {
 282                                 // Group 1 (all selected, all false)
 283                                 hidefilter1: 0,
 284                                 hidefilter2: 0,
 285                                 hidefilter3: 0,
 286                                 // Group 2 (nothing is selected, all false)
 287                                 hidefilter4: 0,
 288                                 hidefilter5: 0,
 289                                 hidefilter6: 0
 290                         },
 291                         'All filters selected in one "send_unselected_if_any" group returns all parameters falsy.'
 292                 );
 293         } );
 294
 295         QUnit.test( 'getFiltersFromParameters', function ( assert ) {
 296                 var definition = {
 297                                 group1: {
 298                                         title: 'Group 1',
 299                                         type: 'send_unselected_if_any',
 300                                         filters: [
 301                                                 {
 302                                                         name: 'hidefilter1',
 303                                                         label: 'Show filter 1',
 304                                                         description: 'Description of Filter 1 in Group 1'
 305                                                 },
 306                                                 {
 307                                                         name: 'hidefilter2',
 308                                                         label: 'Show filter 2',
 309                                                         description: 'Description of Filter 2 in Group 1'
 310                                                 },
 311                                                 {
 312                                                         name: 'hidefilter3',
 313                                                         label: 'Show filter 3',
 314                                                         description: 'Description of Filter 3 in Group 1'
 315                                                 }
 316                                         ]
 317                                 },
 318                                 group2: {
 319                                         title: 'Group 2',
 320                                         type: 'send_unselected_if_any',
 321                                         filters: [
 322                                                 {
 323                                                         name: 'hidefilter4',
 324                                                         label: 'Show filter 4',
 325                                                         description: 'Description of Filter 1 in Group 2'
 326                                                 },
 327                                                 {
 328                                                         name: 'hidefilter5',
 329                                                         label: 'Show filter 5',
 330                                                         description: 'Description of Filter 2 in Group 2'
 331                                                 },
 332                                                 {
 333                                                         name: 'hidefilter6',
 334                                                         label: 'Show filter 6',
 335                                                         description: 'Description of Filter 3 in Group 2'
 336                                                 }
 337                                         ]
 338                                 }
 339                         },
 340                         model = new mw.rcfilters.dm.FiltersViewModel();
 341
 342                 model.initializeFilters( definition );
 343
 344                 // Empty query = empty filter definition
 345                 assert.deepEqual(
 346                         model.getFiltersFromParameters( {} ),
 347                         {
 348                                 hidefilter1: false, // The text is "show filter 1"
 349                                 hidefilter2: false, // The text is "show filter 2"
 350                                 hidefilter3: false, // The text is "show filter 3"
 351                                 hidefilter4: false, // The text is "show filter 4"
 352                                 hidefilter5: false, // The text is "show filter 5"
 353                                 hidefilter6: false // The text is "show filter 6"
 354                         },
 355                         'Empty parameter query results in filters in initial state'
 356                 );
 357
 358                 assert.deepEqual(
 359                         model.getFiltersFromParameters( {
 360                                 hidefilter1: '1'
 361                         } ),
 362                         {
 363                                 hidefilter1: false, // The text is "show filter 1"
 364                                 hidefilter2: true, // The text is "show filter 2"
 365                                 hidefilter3: true, // The text is "show filter 3"
 366                                 hidefilter4: false, // The text is "show filter 4"
 367                                 hidefilter5: false, // The text is "show filter 5"
 368                                 hidefilter6: false // The text is "show filter 6"
 369                         },
 370                         'One falsey parameter in a group makes the rest of the filters in the group truthy (checked) in the interface'
 371                 );
 372
 373                 assert.deepEqual(
 374                         model.getFiltersFromParameters( {
 375                                 hidefilter1: '1',
 376                                 hidefilter2: '1'
 377                         } ),
 378                         {
 379                                 hidefilter1: false, // The text is "show filter 1"
 380                                 hidefilter2: false, // The text is "show filter 2"
 381                                 hidefilter3: true, // The text is "show filter 3"
 382                                 hidefilter4: false, // The text is "show filter 4"
 383                                 hidefilter5: false, // The text is "show filter 5"
 384                                 hidefilter6: false // The text is "show filter 6"
 385                         },
 386                         'Two falsey parameters in a group makes the rest of the filters in the group truthy (checked) in the interface'
 387                 );
 388
 389                 assert.deepEqual(
 390                         model.getFiltersFromParameters( {
 391                                 hidefilter1: '1',
 392                                 hidefilter2: '1',
 393                                 hidefilter3: '1'
 394                         } ),
 395                         {
 396                                 // TODO: This will have to be represented as a different state, though.
 397                                 hidefilter1: false, // The text is "show filter 1"
 398                                 hidefilter2: false, // The text is "show filter 2"
 399                                 hidefilter3: false, // The text is "show filter 3"
 400                                 hidefilter4: false, // The text is "show filter 4"
 401                                 hidefilter5: false, // The text is "show filter 5"
 402                                 hidefilter6: false // The text is "show filter 6"
 403                         },
 404                         'All paremeters in the same group false is equivalent to none are truthy (checked) in the interface'
 405                 );
 406
 407                 // The ones above don't update the model, so we have a clean state.
 408
 409                 model.updateFilters(
 410                         model.getFiltersFromParameters( {
 411                                 hidefilter1: '1'
 412                         } )
 413                 );
 414
 415                 model.updateFilters(
 416                         model.getFiltersFromParameters( {
 417                                 hidefilter3: '1'
 418                         } )
 419                 );
 420
 421                 // 1 and 3 are separately unchecked via hide parameters, 2 should still be
 422                 // checked.
 423                 // This can simulate separate filters in the same group being hidden different
 424                 // ways (e.g. preferences and URL).
 425                 assert.deepEqual(
 426                         model.getState(),
 427                         {
 428                                 hidefilter1: false, // The text is "show filter 1"
 429                                 hidefilter2: true, // The text is "show filter 2"
 430                                 hidefilter3: false, // The text is "show filter 3"
 431                                 hidefilter4: false, // The text is "show filter 4"
 432                                 hidefilter5: false, // The text is "show filter 5"
 433                                 hidefilter6: false // The text is "show filter 6"
 434                         },
 435                         'After unchecking 2 of 3 filters via separate updateFilters calls, only the remaining one is still checked.'
 436                 );
 437
 438                 // Reset
 439                 model = new mw.rcfilters.dm.FiltersViewModel();
 440                 model.initializeFilters( definition );
 441
 442                 model.updateFilters(
 443                         model.getFiltersFromParameters( {
 444                                 hidefilter1: '1'
 445                         } )
 446                 );
 447                 model.updateFilters(
 448                         model.getFiltersFromParameters( {
 449                                 hidefilter1: '0'
 450                         } )
 451                 );
 452
 453                 // Simulates minor edits being hidden in preferences, then unhidden via URL
 454                 // override.
 455                 assert.deepEqual(
 456                         model.getState(),
 457                         {
 458                                 hidefilter1: false, // The text is "show filter 1"
 459                                 hidefilter2: false, // The text is "show filter 2"
 460                                 hidefilter3: false, // The text is "show filter 3"
 461                                 hidefilter4: false, // The text is "show filter 4"
 462                                 hidefilter5: false, // The text is "show filter 5"
 463                                 hidefilter6: false // The text is "show filter 6"
 464                         },
 465                         'After unchecking then checking a filter (without touching other filters in that group), all are checked'
 466                 );
 467         } );
 468 }( mediaWiki, jQuery ) );