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