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                                         }
  61                                 }
  62                         }
  63                 },
  64                 queriesParamRepresentation = {
  65                         version: '2',
  66                         queries: {
  67                                 1234: {
  68                                         label: 'Item converted',
  69                                         data: {
  70                                                 params: {
  71                                                         // filter1 is 'true' so filter2 and filter3 are both '1'
  72                                                         // in param representation
  73                                                         filter2: '1', filter3: '1',
  74                                                         // Group type string_options
  75                                                         group2: 'filter4',
  76                                                         // Note - Group3 is sticky, so it won't show in output
  77                                                         // highlight toggle
  78                                                         highlight: '1'
  79                                                 },
  80                                                 highlights: {
  81                                                         filter1_color: 'c5',
  82                                                         group3option1_color: 'c1'
  83                                                 }
  84                                         }
  85                                 }
  86                         }
  87                 };
  88
  89         QUnit.module( 'mediawiki.rcfilters - SavedQueriesModel' );
  90
  91         QUnit.test( 'Initializing queries', function ( assert ) {
  92                 var filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
  93                         queriesModel = new mw.rcfilters.dm.SavedQueriesModel( filtersModel ),
  94                         exampleQueryStructure = {
  95                                 version: '2',
  96                                 default: '1234',
  97                                 queries: {
  98                                         1234: {
  99                                                 label: 'Query 1234',
 100                                                 data: {
 101                                                         params: {
 102                                                                 filter2: '1'
 103                                                         },
 104                                                         highlights: {
 105                                                                 filter5_color: 'c2'
 106                                                         }
 107                                                 }
 108                                         }
 109                                 }
 110                         },
 111                         cases = [
 112                                 {
 113                                         input: {},
 114                                         finalState: { version: '2', queries: {} },
 115                                         msg: 'Empty initial query structure results in base saved queries structure.'
 116                                 },
 117                                 {
 118                                         input: $.extend( true, {}, exampleQueryStructure ),
 119                                         finalState: $.extend( true, {}, exampleQueryStructure ),
 120                                         msg: 'Initialization of given query structure does not corrupt the structure.'
 121                                 },
 122                                 {
 123                                         // Converting from old structure
 124                                         input: $.extend( true, {}, queriesFilterRepresentation ),
 125                                         finalState: $.extend( true, {}, queriesParamRepresentation ),
 126                                         msg: 'Conversion from filter representation to parameters retains data.'
 127                                 },
 128                                 {
 129                                         // Converting from old structure with default
 130                                         input: $.extend( true, { default: '1234' }, queriesFilterRepresentation ),
 131                                         finalState: $.extend( true, { default: '1234' }, queriesParamRepresentation ),
 132                                         msg: 'Conversion from filter representation to parameters, with default set up, retains data.'
 133                                 },
 134                                 {
 135                                         // New structure
 136                                         input: $.extend( true, {}, queriesParamRepresentation ),
 137                                         finalState: $.extend( true, {}, queriesParamRepresentation ),
 138                                         msg: 'Parameter representation retains its queries structure'
 139                                 }
 140                         ];
 141
 142                 filtersModel.initializeFilters( filterDefinition );
 143
 144                 cases.forEach( function ( testCase ) {
 145                         queriesModel.initialize( testCase.input );
 146                         assert.deepEqual(
 147                                 queriesModel.getState(),
 148                                 testCase.finalState,
 149                                 testCase.msg
 150                         );
 151                 } );
 152         } );
 153
 154         QUnit.test( 'Manipulating queries', function ( assert ) {
 155                 var id1, id2, item1, matchingItem,
 156                         queriesStructure = {},
 157                         filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
 158                         queriesModel = new mw.rcfilters.dm.SavedQueriesModel( filtersModel );
 159
 160                 filtersModel.initializeFilters( filterDefinition );
 161
 162                 // Start with an empty saved queries model
 163                 queriesModel.initialize( {} );
 164
 165                 // Add items
 166                 id1 = queriesModel.addNewQuery(
 167                         'New query 1',
 168                         {
 169                                 params: {
 170                                         group2: 'filter5',
 171                                         highlight: '1'
 172                                 },
 173                                 highlights: {
 174                                         filter1_color: 'c5',
 175                                         group3option1_color: 'c1'
 176                                 }
 177                         }
 178                 );
 179                 id2 = queriesModel.addNewQuery(
 180                         'New query 2',
 181                         {
 182                                 params: {
 183                                         filter1: '1',
 184                                         filter2: '1',
 185                                         invert: '1'
 186                                 },
 187                                 highlights: {}
 188                         }
 189                 );
 190                 item1 = queriesModel.getItemByID( id1 );
 191
 192                 assert.equal(
 193                         item1.getID(),
 194                         id1,
 195                         'Item created and its data retained successfully'
 196                 );
 197
 198                 // NOTE: All other methods that the item itself returns are
 199                 // tested in the dm.SavedQueryItemModel.test.js file
 200
 201                 // Build the query structure we expect per item
 202                 queriesStructure[ id1 ] = {
 203                         label: 'New query 1',
 204                         data: {
 205                                 params: {
 206                                         group2: 'filter5',
 207                                         highlight: '1'
 208                                 },
 209                                 highlights: {
 210                                         filter1_color: 'c5',
 211                                         group3option1_color: 'c1'
 212                                 }
 213                         }
 214                 };
 215                 queriesStructure[ id2 ] = {
 216                         label: 'New query 2',
 217                         data: {
 218                                 params: {
 219                                         filter1: '1',
 220                                         filter2: '1',
 221                                         invert: '1'
 222                                 },
 223                                 highlights: {}
 224                         }
 225                 };
 226
 227                 assert.deepEqual(
 228                         queriesModel.getState(),
 229                         {
 230                                 version: '2',
 231                                 queries: queriesStructure
 232                         },
 233                         'Full query represents current state of items'
 234                 );
 235
 236                 // Add default
 237                 queriesModel.setDefault( id2 );
 238
 239                 assert.deepEqual(
 240                         queriesModel.getState(),
 241                         {
 242                                 version: '2',
 243                                 default: id2,
 244                                 queries: queriesStructure
 245                         },
 246                         'Setting default is reflected in queries state'
 247                 );
 248
 249                 // Remove default
 250                 queriesModel.setDefault( null );
 251
 252                 assert.deepEqual(
 253                         queriesModel.getState(),
 254                         {
 255                                 version: '2',
 256                                 queries: queriesStructure
 257                         },
 258                         'Removing default is reflected in queries state'
 259                 );
 260
 261                 // Find matching query
 262                 matchingItem = queriesModel.findMatchingQuery(
 263                         {
 264                                 params: {
 265                                         group2: 'filter5',
 266                                         highlight: '1'
 267                                 },
 268                                 highlights: {
 269                                         filter1_color: 'c5',
 270                                         group3option1_color: 'c1'
 271                                 }
 272                         }
 273                 );
 274                 assert.deepEqual(
 275                         matchingItem.getID(),
 276                         id1,
 277                         'Finding matching item by identical state'
 278                 );
 279
 280                 // Find matching query with 0-values (base state)
 281                 matchingItem = queriesModel.findMatchingQuery(
 282                         {
 283                                 params: {
 284                                         group2: 'filter5',
 285                                         filter1: '0',
 286                                         filter2: '0',
 287                                         highlight: '1'
 288                                 },
 289                                 highlights: {
 290                                         filter1_color: 'c5',
 291                                         group3option1_color: 'c1'
 292                                 }
 293                         }
 294                 );
 295                 assert.deepEqual(
 296                         matchingItem.getID(),
 297                         id1,
 298                         'Finding matching item by "dirty" state with 0-base values'
 299                 );
 300         } );
 301 }( mediaWiki ) );