tests/qunit/suites/resources/mediawiki.rcfilters/dm.SavedQueriesModel.test.js

   1 /* eslint-disable camelcase */
   2 ( function ( mw ) {
   3         var filterDefinition = [ {
   4                         name: 'group1',
   5                         type: 'send_unselected_if_any',
   6                         filters: [
   7                                 // Note: The fact filter2 is default means that in the
   8                                 // filter representation, filter1 and filter3 are 'true'
   9                                 { name: 'filter1' },
  10                                 { name: 'filter2', default: true },
  11                                 { name: 'filter3' }
  12                         ]
  13                 }, {
  14                         name: 'group2',
  15                         type: 'string_options',
  16                         separator: ',',
  17                         filters: [
  18                                 { name: 'filter4' },
  19                                 { name: 'filter5' },
  20                                 { name: 'filter6' }
  21                         ]
  22                 }, {
  23                         name: 'group3',
  24                         type: 'boolean',
  25                         isSticky: true,
  26                         filters: [
  27                                 { name: 'group3option1' },
  28                                 { name: 'group3option2' },
  29                                 { name: 'group3option3' }
  30                         ]
  31                 } ],
  32                 queriesFilterRepresentation = {
  33                         queries: {
  34                                 1234: {
  35                                         label: 'Item converted',
  36                                         data: {
  37                                                 filters: {
  38                                                         // - This value is true, but the original filter-representation
  39                                                         // of the saved queries ran against defaults. Since filter1 was
  40                                                         // set as default in the definition, the value would actually
  41                                                         // not appear in the representation itself.
  42                                                         // It is considered 'true', though, and should appear in the
  43                                                         // converted result in its parameter representation.
  44                                                         // >> group1__filter1: true,
  45                                                         // - The reverse is true for filter3. Filter3 is set as default
  46                                                         // but we don't want it in this representation of the saved query.
  47                                                         // Since the filter representation ran against default values,
  48                                                         // it will appear as 'false' value in this representation explicitly
  49                                                         // and the resulting parameter representation should have that
  50                                                         // as the result as well
  51                                                         group1__filter3: false,
  52                                                         group2__filter4: true,
  53                                                         group3__group3option1: true
  54                                                 },
  55                                                 highlights: {
  56                                                         highlight: true,
  57                                                         filter1: 'c5',
  58                                                         group3option1: 'c1'
  59                                                 },
  60                                                 invert: true
  61                                         }
  62                                 }
  63                         }
  64                 },
  65                 queriesParamRepresentation = {
  66                         version: '2',
  67                         queries: {
  68                                 1234: {
  69                                         label: 'Item converted',
  70                                         data: {
  71                                                 params: {
  72                                                         // filter1 is 'true' so filter2 and filter3 are both '1'
  73                                                         // in param representation
  74                                                         filter2: '1', filter3: '1',
  75                                                         // Group type string_options
  76                                                         group2: 'filter4',
  77                                                         // Note - Group3 is sticky, so it won't show in output
  78                                                         // Invert/highlight toggles
  79                                                         invert: '1',
  80                                                         highlight: '1'
  81                                                 },
  82                                                 highlights: {
  83                                                         filter1_color: 'c5',
  84                                                         group3option1_color: 'c1'
  85                                                 }
  86                                         }
  87                                 }
  88                         }
  89                 };
  90
  91         QUnit.module( 'mediawiki.rcfilters - SavedQueriesModel' );
  92
  93         QUnit.test( 'Initializing queries', function ( assert ) {
  94                 var filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
  95                         queriesModel = new mw.rcfilters.dm.SavedQueriesModel( filtersModel ),
  96                         exampleQueryStructure = {
  97                                 version: '2',
  98                                 default: '1234',
  99                                 queries: {
 100                                         1234: {
 101                                                 label: 'Query 1234',
 102                                                 data: {
 103                                                         params: {
 104                                                                 filter2: '1'
 105                                                         },
 106                                                         highlights: {
 107                                                                 filter5_color: 'c2'
 108                                                         }
 109                                                 }
 110                                         }
 111                                 }
 112                         },
 113                         cases = [
 114                                 {
 115                                         input: {},
 116                                         finalState: { version: '2', queries: {} },
 117                                         msg: 'Empty initial query structure results in base saved queries structure.'
 118                                 },
 119                                 {
 120                                         input: $.extend( true, {}, exampleQueryStructure ),
 121                                         finalState: $.extend( true, {}, exampleQueryStructure ),
 122                                         msg: 'Initialization of given query structure does not corrupt the structure.'
 123                                 },
 124                                 {
 125                                         // Converting from old structure
 126                                         input: $.extend( true, {}, queriesFilterRepresentation ),
 127                                         finalState: $.extend( true, {}, queriesParamRepresentation ),
 128                                         msg: 'Conversion from filter representation to parameters retains data.'
 129                                 },
 130                                 {
 131                                         // Converting from old structure with default
 132                                         input: $.extend( true, { default: '1234' }, queriesFilterRepresentation ),
 133                                         finalState: $.extend( true, { default: '1234' }, queriesParamRepresentation ),
 134                                         msg: 'Conversion from filter representation to parameters, with default set up, retains data.'
 135                                 },
 136                                 {
 137                                         // New structure
 138                                         input: $.extend( true, {}, queriesParamRepresentation ),
 139                                         finalState: $.extend( true, {}, queriesParamRepresentation ),
 140                                         msg: 'Parameter representation retains its queries structure'
 141                                 }
 142                         ];
 143
 144                 filtersModel.initializeFilters( filterDefinition );
 145
 146                 cases.forEach( function ( testCase ) {
 147                         queriesModel.initialize( testCase.input );
 148                         assert.deepEqual(
 149                                 queriesModel.getState(),
 150                                 testCase.finalState,
 151                                 testCase.msg
 152                         );
 153                 } );
 154         } );
 155
 156         QUnit.test( 'Manipulating queries', function ( assert ) {
 157                 var id1, id2, item1, matchingItem,
 158                         queriesStructure = {},
 159                         filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
 160                         queriesModel = new mw.rcfilters.dm.SavedQueriesModel( filtersModel );
 161
 162                 filtersModel.initializeFilters( filterDefinition );
 163
 164                 // Start with an empty saved queries model
 165                 queriesModel.initialize( {} );
 166
 167                 // Add items
 168                 id1 = queriesModel.addNewQuery(
 169                         'New query 1',
 170                         {
 171                                 params: {
 172                                         group2: 'filter5',
 173                                         highlight: '1'
 174                                 },
 175                                 highlights: {
 176                                         filter1_color: 'c5',
 177                                         group3option1_color: 'c1'
 178                                 }
 179                         }
 180                 );
 181                 id2 = queriesModel.addNewQuery(
 182                         'New query 2',
 183                         {
 184                                 params: {
 185                                         filter1: '1',
 186                                         filter2: '1',
 187                                         invert: '1'
 188                                 },
 189                                 highlights: {}
 190                         }
 191                 );
 192                 item1 = queriesModel.getItemByID( id1 );
 193
 194                 assert.equal(
 195                         item1.getID(),
 196                         id1,
 197                         'Item created and its data retained successfully'
 198                 );
 199
 200                 // NOTE: All other methods that the item itself returns are
 201                 // tested in the dm.SavedQueryItemModel.test.js file
 202
 203                 // Build the query structure we expect per item
 204                 queriesStructure[ id1 ] = {
 205                         label: 'New query 1',
 206                         data: {
 207                                 params: {
 208                                         group2: 'filter5',
 209                                         highlight: '1'
 210                                 },
 211                                 highlights: {
 212                                         filter1_color: 'c5',
 213                                         group3option1_color: 'c1'
 214                                 }
 215                         }
 216                 };
 217                 queriesStructure[ id2 ] = {
 218                         label: 'New query 2',
 219                         data: {
 220                                 params: {
 221                                         filter1: '1',
 222                                         filter2: '1',
 223                                         invert: '1'
 224                                 },
 225                                 highlights: {}
 226                         }
 227                 };
 228
 229                 assert.deepEqual(
 230                         queriesModel.getState(),
 231                         {
 232                                 version: '2',
 233                                 queries: queriesStructure
 234                         },
 235                         'Full query represents current state of items'
 236                 );
 237
 238                 // Add default
 239                 queriesModel.setDefault( id2 );
 240
 241                 assert.deepEqual(
 242                         queriesModel.getState(),
 243                         {
 244                                 version: '2',
 245                                 default: id2,
 246                                 queries: queriesStructure
 247                         },
 248                         'Setting default is reflected in queries state'
 249                 );
 250
 251                 // Remove default
 252                 queriesModel.setDefault( null );
 253
 254                 assert.deepEqual(
 255                         queriesModel.getState(),
 256                         {
 257                                 version: '2',
 258                                 queries: queriesStructure
 259                         },
 260                         'Removing default is reflected in queries state'
 261                 );
 262
 263                 // Find matching query
 264                 matchingItem = queriesModel.findMatchingQuery(
 265                         {
 266                                 params: {
 267                                         group2: 'filter5',
 268                                         highlight: '1'
 269                                 },
 270                                 highlights: {
 271                                         filter1_color: 'c5',
 272                                         group3option1_color: 'c1'
 273                                 }
 274                         }
 275                 );
 276                 assert.deepEqual(
 277                         matchingItem.getID(),
 278                         id1,
 279                         'Finding matching item by identical state'
 280                 );
 281
 282                 // Find matching query with 0-values (base state)
 283                 matchingItem = queriesModel.findMatchingQuery(
 284                         {
 285                                 params: {
 286                                         group2: 'filter5',
 287                                         filter1: '0',
 288                                         filter2: '0',
 289                                         highlight: '1',
 290                                         invert: '0'
 291                                 },
 292                                 highlights: {
 293                                         filter1_color: 'c5',
 294                                         group3option1_color: 'c1'
 295                                 }
 296                         }
 297                 );
 298                 assert.deepEqual(
 299                         matchingItem.getID(),
 300                         id1,
 301                         'Finding matching item by "dirty" state with 0-base values'
 302                 );
 303         } );
 304 }( mediaWiki ) );