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                 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( 'getUpdatedUri', function ( assert ) {
  53                 var uriProcessor,
  54                         filtersModel = new mw.rcfilters.dm.FiltersViewModel();
  55
  56                 filtersModel.initializeFilters( mockFilterStructure );
  57                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
  58
  59                 assert.deepEqual(
  60                         ( uriProcessor.getUpdatedUri( {} ) ).query,
  61                         { urlversion: '2' },
  62                         'Empty model state with empty uri state, assumes the given uri is already normalized, and adds urlversion=2'
  63                 );
  64
  65                 assert.deepEqual(
  66                         ( uriProcessor.getUpdatedUri( { foo: 'bar' } ) ).query,
  67                         { urlversion: '2', foo: 'bar' },
  68                         'Empty model state with unrecognized params retains unrecognized params'
  69                 );
  70
  71                 // Update the model
  72                 filtersModel.toggleFiltersSelected( {
  73                         group1__filter1: true, // Param: filter2: '1'
  74                         group3__filter5: true // Param: group3: 'filter5'
  75                 } );
  76
  77                 assert.deepEqual(
  78                         ( uriProcessor.getUpdatedUri( {} ) ).query,
  79                         { urlversion: '2', filter2: '1', group3: 'filter5' },
  80                         'Model state is reflected in the updated URI'
  81                 );
  82
  83                 assert.deepEqual(
  84                         ( uriProcessor.getUpdatedUri( { foo: 'bar' } ) ).query,
  85                         { urlversion: '2', filter2: '1', group3: 'filter5', foo: 'bar' },
  86                         'Model state is reflected in the updated URI with existing uri params'
  87                 );
  88         } );
  89
  90         QUnit.test( 'updateModelBasedOnQuery', function ( assert ) {
  91                 var uriProcessor,
  92                         filtersModel = new mw.rcfilters.dm.FiltersViewModel();
  93
  94                 filtersModel.initializeFilters( mockFilterStructure );
  95                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
  96
  97                 uriProcessor.updateModelBasedOnQuery( {} );
  98                 assert.deepEqual(
  99                         filtersModel.getCurrentParameterState(),
 100                         minimalDefaultParams,
 101                         'Version 1: Empty url query sets model to defaults'
 102                 );
 103
 104                 uriProcessor.updateModelBasedOnQuery( { urlversion: '2' } );
 105                 assert.deepEqual(
 106                         filtersModel.getCurrentParameterState(),
 107                         {},
 108                         'Version 2: Empty url query sets model to all-false'
 109                 );
 110
 111                 uriProcessor.updateModelBasedOnQuery( { filter1: '1', urlversion: '2' } );
 112                 assert.deepEqual(
 113                         filtersModel.getCurrentParameterState(),
 114                         $.extend( true, {}, { filter1: '1' } ),
 115                         'Parameters in Uri query set parameter value in the model'
 116                 );
 117
 118                 uriProcessor.updateModelBasedOnQuery( { highlight: '1', group1__filter1_color: 'c1', urlversion: '2' } );
 119                 assert.deepEqual(
 120                         filtersModel.getCurrentParameterState(),
 121                         {
 122                                 highlight: '1',
 123                                 group1__filter1_color: 'c1'
 124                         },
 125                         'Highlight parameters in Uri query set highlight state in the model'
 126                 );
 127         } );
 128
 129         QUnit.test( 'isNewState', function ( assert ) {
 130                 var uriProcessor,
 131                         filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
 132                         cases = [
 133                                 {
 134                                         states: {
 135                                                 curr: {},
 136                                                 new: {}
 137                                         },
 138                                         result: false,
 139                                         message: 'Empty objects are not new state.'
 140                                 },
 141                                 {
 142                                         states: {
 143                                                 curr: { filter1: '1' },
 144                                                 new: { filter1: '0' }
 145                                         },
 146                                         result: true,
 147                                         message: 'Nulified parameter is a new state'
 148                                 },
 149                                 {
 150                                         states: {
 151                                                 curr: { filter1: '1' },
 152                                                 new: { filter1: '1', filter2: '1' }
 153                                         },
 154                                         result: true,
 155                                         message: 'Added parameters are a new state'
 156                                 },
 157                                 {
 158                                         states: {
 159                                                 curr: { filter1: '1' },
 160                                                 new: { filter1: '1', filter2: '0' }
 161                                         },
 162                                         result: false,
 163                                         message: 'Added null parameters are not a new state (normalizing equals old state)'
 164                                 },
 165                                 {
 166                                         states: {
 167                                                 curr: { filter1: '1' },
 168                                                 new: { filter1: '1', foo: 'bar' }
 169                                         },
 170                                         result: true,
 171                                         message: 'Added unrecognized parameters are a new state'
 172                                 },
 173                                 {
 174                                         states: {
 175                                                 curr: { filter1: '1', foo: 'bar' },
 176                                                 new: { filter1: '1', foo: 'baz' }
 177                                         },
 178                                         result: true,
 179                                         message: 'Changed unrecognized parameters are a new state'
 180                                 }
 181                         ];
 182
 183                 filtersModel.initializeFilters( mockFilterStructure );
 184                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
 185
 186                 cases.forEach( function ( testCase ) {
 187                         assert.equal(
 188                                 uriProcessor.isNewState( testCase.states.curr, testCase.states.new ),
 189                                 testCase.result,
 190                                 testCase.message
 191                         );
 192                 } );
 193         } );
 194
 195         QUnit.test( 'doesQueryContainRecognizedParams', function ( assert ) {
 196                 var uriProcessor,
 197                         filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
 198                         cases = [
 199                                 {
 200                                         query: {},
 201                                         result: false,
 202                                         message: 'Empty query is not valid for load.'
 203                                 },
 204                                 {
 205                                         query: { highlight: '1' },
 206                                         result: false,
 207                                         message: 'Highlight state alone is not valid for load'
 208                                 },
 209                                 {
 210                                         query: { urlversion: '2' },
 211                                         result: true,
 212                                         message: 'urlversion=2 state alone is valid for load as an empty state'
 213                                 },
 214                                 {
 215                                         query: { filter1: '1', foo: 'bar' },
 216                                         result: true,
 217                                         message: 'Existence of recognized parameters makes the query valid for load'
 218                                 },
 219                                 {
 220                                         query: { foo: 'bar', debug: true },
 221                                         result: false,
 222                                         message: 'Only unrecognized parameters makes the query invalid for load'
 223                                 }
 224                         ];
 225
 226                 filtersModel.initializeFilters( mockFilterStructure );
 227                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
 228
 229                 cases.forEach( function ( testCase ) {
 230                         assert.equal(
 231                                 uriProcessor.doesQueryContainRecognizedParams( testCase.query ),
 232                                 testCase.result,
 233                                 testCase.message
 234                         );
 235                 } );
 236         } );
 237
 238         QUnit.test( '_getNormalizedQueryParams', function ( assert ) {
 239                 var uriProcessor,
 240                         filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
 241                         cases = [
 242                                 {
 243                                         query: {},
 244                                         result: $.extend( true, { urlversion: '2' }, minimalDefaultParams ),
 245                                         message: 'Empty query returns defaults (urlversion 1).'
 246                                 },
 247                                 {
 248                                         query: { urlversion: '2' },
 249                                         result: { urlversion: '2' },
 250                                         message: 'Empty query returns empty (urlversion 2)'
 251                                 },
 252                                 {
 253                                         query: { filter1: '0' },
 254                                         result: { urlversion: '2', filter4: '1' },
 255                                         message: 'urlversion 1 returns query that overrides defaults'
 256                                 },
 257                                 {
 258                                         query: { filter3: '1' },
 259                                         result: { urlversion: '2', filter1: '1', filter4: '1', filter3: '1' },
 260                                         message: 'urlversion 1 with an extra param value returns query that is joined with defaults'
 261                                 }
 262                         ];
 263
 264                 filtersModel.initializeFilters( mockFilterStructure );
 265                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
 266
 267                 cases.forEach( function ( testCase ) {
 268                         assert.deepEqual(
 269                                 uriProcessor._getNormalizedQueryParams( testCase.query ),
 270                                 testCase.result,
 271                                 testCase.message
 272                         );
 273                 } );
 274         } );
 275
 276 }( mediaWiki, jQuery ) );