tests/qunit/suites/resources/mediawiki.rcfilters/UriProcessor.test.js

   1 /* eslint-disable camelcase */
   2 /* eslint no-underscore-dangle: "off" */
   3 ( function ( mw, $ ) {
   4         var mockFilterStructure = [ {
   5                         name: 'group1',
   6                         title: 'Group 1',
   7                         type: 'send_unselected_if_any',
   8                         filters: [
   9                                 { name: 'filter1', cssClass: 'filter1class', default: true },
  10                                 { name: 'filter2', cssClass: 'filter2class' }
  11                         ]
  12                 }, {
  13                         name: 'group2',
  14                         title: 'Group 2',
  15                         type: 'send_unselected_if_any',
  16                         filters: [
  17                                 { name: 'filter3', cssClass: 'filter3class' },
  18                                 { name: 'filter4', cssClass: 'filter4class', default: true }
  19                         ]
  20                 }, {
  21                         name: 'group3',
  22                         title: 'Group 3',
  23                         type: 'string_options',
  24                         filters: [
  25                                 { name: 'filter5', cssClass: 'filter5class' },
  26                                 { name: 'filter6' } // Not supporting highlights
  27                         ]
  28                 }, {
  29                         name: 'group4',
  30                         title: 'Group 4',
  31                         type: 'boolean',
  32                         isSticky: true,
  33                         filters: [
  34                                 { name: 'stickyFilter7', cssClass: 'filter7class' },
  35                                 { name: 'stickyFilter8', cssClass: 'filter8class' }
  36                         ]
  37                 } ],
  38                 minimalDefaultParams = {
  39                         filter1: '1',
  40                         filter4: '1'
  41                 };
  42
  43         QUnit.module( 'mediawiki.rcfilters - UriProcessor' );
  44
  45         QUnit.test( 'getVersion', function ( assert ) {
  46                 var uriProcessor = new mw.rcfilters.UriProcessor( new mw.rcfilters.dm.FiltersViewModel() );
  47
  48                 assert.ok(
  49                         uriProcessor.getVersion( { param1: 'foo', urlversion: '2' } ),
  50                         2,
  51                         'Retrieving the version from the URI query'
  52                 );
  53
  54                 assert.ok(
  55                         uriProcessor.getVersion( { param1: 'foo' } ),
  56                         1,
  57                         'Getting version 1 if no version is specified'
  58                 );
  59         } );
  60
  61         QUnit.test( 'getUpdatedUri', function ( assert ) {
  62                 var uriProcessor,
  63                         filtersModel = new mw.rcfilters.dm.FiltersViewModel();
  64
  65                 filtersModel.initializeFilters( mockFilterStructure );
  66                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
  67
  68                 assert.deepEqual(
  69                         ( uriProcessor.getUpdatedUri( {} ) ).query,
  70                         { urlversion: '2' },
  71                         'Empty model state with empty uri state, assumes the given uri is already normalized, and adds urlversion=2'
  72                 );
  73
  74                 assert.deepEqual(
  75                         ( uriProcessor.getUpdatedUri( { foo: 'bar' } ) ).query,
  76                         { urlversion: '2', foo: 'bar' },
  77                         'Empty model state with unrecognized params retains unrecognized params'
  78                 );
  79
  80                 // Update the model
  81                 filtersModel.toggleFiltersSelected( {
  82                         group1__filter1: true, // Param: filter2: '1'
  83                         group3__filter5: true // Param: group3: 'filter5'
  84                 } );
  85
  86                 assert.deepEqual(
  87                         ( uriProcessor.getUpdatedUri( {} ) ).query,
  88                         { urlversion: '2', filter2: '1', group3: 'filter5' },
  89                         'Model state is reflected in the updated URI'
  90                 );
  91
  92                 assert.deepEqual(
  93                         ( uriProcessor.getUpdatedUri( { foo: 'bar' } ) ).query,
  94                         { urlversion: '2', filter2: '1', group3: 'filter5', foo: 'bar' },
  95                         'Model state is reflected in the updated URI with existing uri params'
  96                 );
  97
  98                 // Update the model with sticky filter
  99                 filtersModel.toggleFiltersSelected( {
 100                         group4__stickyFilter7: true
 101                 } );
 102
 103                 assert.deepEqual(
 104                         ( uriProcessor.getUpdatedUri( {} ) ).query,
 105                         { urlversion: '2', filter2: '1', group3: 'filter5' },
 106                         'Sticky parameters are not reflected in the URI query'
 107                 );
 108         } );
 109
 110         QUnit.test( 'updateModelBasedOnQuery', function ( assert ) {
 111                 var uriProcessor,
 112                         filtersModel = new mw.rcfilters.dm.FiltersViewModel();
 113
 114                 filtersModel.initializeFilters( mockFilterStructure );
 115                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
 116
 117                 uriProcessor.updateModelBasedOnQuery( {} );
 118                 assert.deepEqual(
 119                         filtersModel.getCurrentParameterState(),
 120                         minimalDefaultParams,
 121                         'Version 1: Empty url query sets model to defaults'
 122                 );
 123
 124                 uriProcessor.updateModelBasedOnQuery( { urlversion: '2' } );
 125                 assert.deepEqual(
 126                         filtersModel.getCurrentParameterState(),
 127                         {},
 128                         'Version 2: Empty url query sets model to all-false'
 129                 );
 130
 131                 uriProcessor.updateModelBasedOnQuery( { filter1: '1', urlversion: '2' } );
 132                 assert.deepEqual(
 133                         filtersModel.getCurrentParameterState(),
 134                         $.extend( true, {}, { filter1: '1' } ),
 135                         'Parameters in Uri query set parameter value in the model'
 136                 );
 137         } );
 138
 139         QUnit.test( 'isNewState', function ( assert ) {
 140                 var uriProcessor,
 141                         filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
 142                         cases = [
 143                                 {
 144                                         states: {
 145                                                 curr: {},
 146                                                 new: {}
 147                                         },
 148                                         result: false,
 149                                         message: 'Empty objects are not new state.'
 150                                 },
 151                                 {
 152                                         states: {
 153                                                 curr: { filter1: '1' },
 154                                                 new: { filter1: '0' }
 155                                         },
 156                                         result: true,
 157                                         message: 'Nulified parameter is a new state'
 158                                 },
 159                                 {
 160                                         states: {
 161                                                 curr: { filter1: '1' },
 162                                                 new: { filter1: '1', filter2: '1' }
 163                                         },
 164                                         result: true,
 165                                         message: 'Added parameters are a new state'
 166                                 },
 167                                 {
 168                                         states: {
 169                                                 curr: { filter1: '1' },
 170                                                 new: { filter1: '1', filter2: '0' }
 171                                         },
 172                                         result: false,
 173                                         message: 'Added null parameters are not a new state (normalizing equals old state)'
 174                                 },
 175                                 {
 176                                         states: {
 177                                                 curr: { filter1: '1' },
 178                                                 new: { filter1: '1', foo: 'bar' }
 179                                         },
 180                                         result: true,
 181                                         message: 'Added unrecognized parameters are a new state'
 182                                 },
 183                                 {
 184                                         states: {
 185                                                 curr: { filter1: '1', foo: 'bar' },
 186                                                 new: { filter1: '1', foo: 'baz' }
 187                                         },
 188                                         result: true,
 189                                         message: 'Changed unrecognized parameters are a new state'
 190                                 }
 191                         ];
 192
 193                 filtersModel.initializeFilters( mockFilterStructure );
 194                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
 195
 196                 cases.forEach( function ( testCase ) {
 197                         assert.equal(
 198                                 uriProcessor.isNewState( testCase.states.curr, testCase.states.new ),
 199                                 testCase.result,
 200                                 testCase.message
 201                         );
 202                 } );
 203         } );
 204
 205         QUnit.test( 'doesQueryContainRecognizedParams', function ( assert ) {
 206                 var uriProcessor,
 207                         filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
 208                         cases = [
 209                                 {
 210                                         query: {},
 211                                         result: false,
 212                                         message: 'Empty query is not valid for load.'
 213                                 },
 214                                 {
 215                                         query: { highlight: '1' },
 216                                         result: false,
 217                                         message: 'Highlight state alone is not valid for load'
 218                                 },
 219                                 {
 220                                         query: { urlversion: '2' },
 221                                         result: true,
 222                                         message: 'urlversion=2 state alone is valid for load as an empty state'
 223                                 },
 224                                 {
 225                                         query: { filter1: '1', foo: 'bar' },
 226                                         result: true,
 227                                         message: 'Existence of recognized parameters makes the query valid for load'
 228                                 },
 229                                 {
 230                                         query: { foo: 'bar', debug: true },
 231                                         result: false,
 232                                         message: 'Only unrecognized parameters makes the query invalid for load'
 233                                 }
 234                         ];
 235
 236                 filtersModel.initializeFilters( mockFilterStructure );
 237                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
 238
 239                 cases.forEach( function ( testCase ) {
 240                         assert.equal(
 241                                 uriProcessor.doesQueryContainRecognizedParams( testCase.query ),
 242                                 testCase.result,
 243                                 testCase.message
 244                         );
 245                 } );
 246         } );
 247
 248         QUnit.test( '_getNormalizedQueryParams', function ( assert ) {
 249                 var uriProcessor,
 250                         filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
 251                         cases = [
 252                                 {
 253                                         query: {},
 254                                         result: $.extend( true, { urlversion: '2' }, minimalDefaultParams ),
 255                                         message: 'Empty query returns defaults (urlversion 1).'
 256                                 },
 257                                 {
 258                                         query: { urlversion: '2' },
 259                                         result: { urlversion: '2' },
 260                                         message: 'Empty query returns empty (urlversion 2)'
 261                                 },
 262                                 {
 263                                         query: { filter1: '0' },
 264                                         result: { urlversion: '2', filter4: '1' },
 265                                         message: 'urlversion 1 returns query that overrides defaults'
 266                                 },
 267                                 {
 268                                         query: { filter3: '1' },
 269                                         result: { urlversion: '2', filter1: '1', filter4: '1', filter3: '1' },
 270                                         message: 'urlversion 1 with an extra param value returns query that is joined with defaults'
 271                                 }
 272                         ];
 273
 274                 filtersModel.initializeFilters( mockFilterStructure );
 275                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
 276
 277                 cases.forEach( function ( testCase ) {
 278                         assert.deepEqual(
 279                                 uriProcessor._getNormalizedQueryParams( testCase.query ),
 280                                 testCase.result,
 281                                 testCase.message
 282                         );
 283                 } );
 284         } );
 285
 286 }( mediaWiki, jQuery ) );