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