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
 119         QUnit.test( 'isNewState', function ( assert ) {
 120                 var uriProcessor,
 121                         filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
 122                         cases = [
 123                                 {
 124                                         states: {
 125                                                 curr: {},
 126                                                 new: {}
 127                                         },
 128                                         result: false,
 129                                         message: 'Empty objects are not new state.'
 130                                 },
 131                                 {
 132                                         states: {
 133                                                 curr: { filter1: '1' },
 134                                                 new: { filter1: '0' }
 135                                         },
 136                                         result: true,
 137                                         message: 'Nulified parameter is a new state'
 138                                 },
 139                                 {
 140                                         states: {
 141                                                 curr: { filter1: '1' },
 142                                                 new: { filter1: '1', filter2: '1' }
 143                                         },
 144                                         result: true,
 145                                         message: 'Added parameters are a new state'
 146                                 },
 147                                 {
 148                                         states: {
 149                                                 curr: { filter1: '1' },
 150                                                 new: { filter1: '1', filter2: '0' }
 151                                         },
 152                                         result: false,
 153                                         message: 'Added null parameters are not a new state (normalizing equals old state)'
 154                                 },
 155                                 {
 156                                         states: {
 157                                                 curr: { filter1: '1' },
 158                                                 new: { filter1: '1', foo: 'bar' }
 159                                         },
 160                                         result: true,
 161                                         message: 'Added unrecognized parameters are a new state'
 162                                 },
 163                                 {
 164                                         states: {
 165                                                 curr: { filter1: '1', foo: 'bar' },
 166                                                 new: { filter1: '1', foo: 'baz' }
 167                                         },
 168                                         result: true,
 169                                         message: 'Changed unrecognized parameters are a new state'
 170                                 }
 171                         ];
 172
 173                 filtersModel.initializeFilters( mockFilterStructure );
 174                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
 175
 176                 cases.forEach( function ( testCase ) {
 177                         assert.equal(
 178                                 uriProcessor.isNewState( testCase.states.curr, testCase.states.new ),
 179                                 testCase.result,
 180                                 testCase.message
 181                         );
 182                 } );
 183         } );
 184
 185         QUnit.test( 'doesQueryContainRecognizedParams', function ( assert ) {
 186                 var uriProcessor,
 187                         filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
 188                         cases = [
 189                                 {
 190                                         query: {},
 191                                         result: false,
 192                                         message: 'Empty query is not valid for load.'
 193                                 },
 194                                 {
 195                                         query: { highlight: '1' },
 196                                         result: false,
 197                                         message: 'Highlight state alone is not valid for load'
 198                                 },
 199                                 {
 200                                         query: { urlversion: '2' },
 201                                         result: true,
 202                                         message: 'urlversion=2 state alone is valid for load as an empty state'
 203                                 },
 204                                 {
 205                                         query: { filter1: '1', foo: 'bar' },
 206                                         result: true,
 207                                         message: 'Existence of recognized parameters makes the query valid for load'
 208                                 },
 209                                 {
 210                                         query: { foo: 'bar', debug: true },
 211                                         result: false,
 212                                         message: 'Only unrecognized parameters makes the query invalid for load'
 213                                 }
 214                         ];
 215
 216                 filtersModel.initializeFilters( mockFilterStructure );
 217                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
 218
 219                 cases.forEach( function ( testCase ) {
 220                         assert.equal(
 221                                 uriProcessor.doesQueryContainRecognizedParams( testCase.query ),
 222                                 testCase.result,
 223                                 testCase.message
 224                         );
 225                 } );
 226         } );
 227
 228         QUnit.test( '_getNormalizedQueryParams', function ( assert ) {
 229                 var uriProcessor,
 230                         filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
 231                         cases = [
 232                                 {
 233                                         query: {},
 234                                         result: $.extend( true, { urlversion: '2' }, minimalDefaultParams ),
 235                                         message: 'Empty query returns defaults (urlversion 1).'
 236                                 },
 237                                 {
 238                                         query: { urlversion: '2' },
 239                                         result: { urlversion: '2' },
 240                                         message: 'Empty query returns empty (urlversion 2)'
 241                                 },
 242                                 {
 243                                         query: { filter1: '0' },
 244                                         result: { urlversion: '2', filter4: '1' },
 245                                         message: 'urlversion 1 returns query that overrides defaults'
 246                                 },
 247                                 {
 248                                         query: { filter3: '1' },
 249                                         result: { urlversion: '2', filter1: '1', filter4: '1', filter3: '1' },
 250                                         message: 'urlversion 1 with an extra param value returns query that is joined with defaults'
 251                                 }
 252                         ];
 253
 254                 filtersModel.initializeFilters( mockFilterStructure );
 255                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
 256
 257                 cases.forEach( function ( testCase ) {
 258                         assert.deepEqual(
 259                                 uriProcessor._getNormalizedQueryParams( testCase.query ),
 260                                 testCase.result,
 261                                 testCase.message
 262                         );
 263                 } );
 264         } );
 265
 266 }( mediaWiki, jQuery ) );