packages/shared/test/eventManager/updateCollection.spec.ts

   1 import { EVENT_ACTIONS } from '../../lib/constants';
   2 import updateCollection, { sortCollection } from '../../lib/helpers/updateCollection';
   3
   4 describe('update collection', () => {
   5     it('should remove items', () => {
   6         const labels = [
   7             {
   8                 ID: '123',
   9                 foo: 'bar',
  10             },
  11         ];
  12         const events = [
  13             {
  14                 ID: '123',
  15                 Action: EVENT_ACTIONS.DELETE,
  16             },
  17         ] as const;
  18         const newLabels = updateCollection({
  19             model: labels,
  20             events,
  21             itemKey: 'Label',
  22         });
  23         expect(newLabels).toEqual([]);
  24     });
  25
  26     it('should add items', () => {
  27         const labels = [
  28             {
  29                 ID: '123',
  30                 foo: 'bar',
  31             },
  32         ];
  33         const events = [
  34             {
  35                 ID: '124',
  36                 Action: EVENT_ACTIONS.CREATE,
  37                 Label: {
  38                     ID: '124',
  39                     foo: 'bar2',
  40                 },
  41             },
  42         ] as const;
  43         const newLabels = updateCollection({ model: labels, events, itemKey: 'Label' });
  44         expect(newLabels).toEqual([
  45             { ID: '123', foo: 'bar' },
  46             { ID: '124', foo: 'bar2' },
  47         ]);
  48     });
  49
  50     it('should update items', () => {
  51         const labels = [
  52             {
  53                 ID: '123',
  54                 foo: 'bar',
  55                 kept: true,
  56             },
  57         ];
  58         const events = [
  59             {
  60                 ID: '123',
  61                 Action: EVENT_ACTIONS.UPDATE,
  62                 Label: {
  63                     ID: '123',
  64                     foo: 'bar2',
  65                 },
  66             },
  67         ] as const;
  68         const newLabels = updateCollection({ model: labels, events, itemKey: 'Label' });
  69         expect(newLabels).toEqual([{ ID: '123', foo: 'bar2', kept: true }]);
  70     });
  71
  72     it('should delete, create and update items', () => {
  73         const labels = [
  74             {
  75                 ID: '123',
  76                 foo: 'bar',
  77             },
  78         ];
  79         const events = [
  80             {
  81                 ID: '123',
  82                 Action: EVENT_ACTIONS.UPDATE,
  83                 Label: {
  84                     ID: '123',
  85                     foo: 'bar2',
  86                 },
  87             },
  88             {
  89                 ID: '123',
  90                 Action: EVENT_ACTIONS.DELETE,
  91             },
  92             {
  93                 ID: '124',
  94                 Action: EVENT_ACTIONS.UPDATE,
  95                 Label: {
  96                     ID: '124',
  97                     foo: 'bar3',
  98                 },
  99             },
 100             {
 101                 ID: '124',
 102                 Action: EVENT_ACTIONS.CREATE,
 103                 Label: {
 104                     ID: '124',
 105                     foo: 'bar',
 106                 },
 107             },
 108         ] as const;
 109         const newLabels = updateCollection({ model: labels, events, itemKey: 'Label', item: ({ Label }) => Label });
 110         expect(newLabels).toEqual([{ ID: '124', foo: 'bar3' }]);
 111     });
 112
 113     describe('Sort collection', () => {
 114         it('should delete, create and update items and sort them', () => {
 115             const labels = [
 116                 {
 117                     ID: '123',
 118                     foo: 'bar',
 119                     Order: 1,
 120                 },
 121             ];
 122             const events = [
 123                 {
 124                     ID: '123',
 125                     Action: EVENT_ACTIONS.UPDATE,
 126                     Label: {
 127                         ID: '123',
 128                         foo: 'bar2',
 129                     },
 130                 },
 131                 {
 132                     ID: '12345',
 133                     Action: EVENT_ACTIONS.CREATE,
 134                     Label: {
 135                         ID: '12345',
 136                         foo: 'monique',
 137                         Order: 2,
 138                     },
 139                 },
 140                 {
 141                     ID: '124',
 142                     Action: EVENT_ACTIONS.CREATE,
 143                     Label: {
 144                         ID: '124',
 145                         foo: 'bar',
 146                         Order: 3,
 147                     },
 148                 },
 149             ] as const;
 150             const newLabels = updateCollection({ model: labels, events, itemKey: 'Label', item: ({ Label }) => Label });
 151             const key = 'Order';
 152             const sortedLabels = sortCollection(key, newLabels);
 153             expect(sortedLabels).toEqual([
 154                 { ID: '123', foo: 'bar2', Order: 1 },
 155                 { ID: '12345', foo: 'monique', Order: 2 },
 156                 { ID: '124', foo: 'bar', Order: 3 },
 157             ]);
 158
 159             const events2 = [
 160                 {
 161                     ID: '123',
 162                     Action: EVENT_ACTIONS.DELETE,
 163                 },
 164                 {
 165                     ID: '124',
 166                     Action: EVENT_ACTIONS.UPDATE,
 167                     Label: {
 168                         ID: '124',
 169                         foo: 'bar3',
 170                         Order: 1,
 171                     },
 172                 },
 173             ] as const;
 174
 175             const newLabels2 = updateCollection({
 176                 model: newLabels,
 177                 events: events2,
 178                 itemKey: 'Label',
 179                 item: ({ Label }) => Label,
 180             });
 181             const sortedLabels2 = sortCollection(key, newLabels2);
 182             expect(sortedLabels2).toEqual([
 183                 { ID: '124', foo: 'bar3', Order: 1 },
 184                 { ID: '12345', foo: 'monique', Order: 2 },
 185             ]);
 186         });
 187
 188         it('should delete, create and update items and not sort them', () => {
 189             const labels = [
 190                 {
 191                     ID: '123',
 192                     foo: 'bar',
 193                 },
 194             ];
 195             const events = [
 196                 {
 197                     ID: '123',
 198                     Action: EVENT_ACTIONS.UPDATE,
 199                     Label: {
 200                         ID: '123',
 201                         foo: 'bar2',
 202                     },
 203                 },
 204                 {
 205                     ID: '12345',
 206                     Action: EVENT_ACTIONS.CREATE,
 207                     Label: {
 208                         ID: '12345',
 209                         foo: 'monique',
 210                     },
 211                 },
 212                 {
 213                     ID: '124',
 214                     Action: EVENT_ACTIONS.CREATE,
 215                     Label: {
 216                         ID: '124',
 217                         foo: 'bar',
 218                     },
 219                 },
 220             ] as const;
 221             const newLabels = updateCollection({ model: labels, events, itemKey: 'Label' });
 222             expect(newLabels).toEqual([
 223                 { ID: '123', foo: 'bar2' },
 224                 { ID: '12345', foo: 'monique' },
 225                 { ID: '124', foo: 'bar' },
 226             ]);
 227
 228             const events2 = [
 229                 {
 230                     ID: '123',
 231                     Action: EVENT_ACTIONS.DELETE,
 232                 },
 233                 {
 234                     ID: '124',
 235                     Action: EVENT_ACTIONS.UPDATE,
 236                     Label: {
 237                         ID: '124',
 238                         foo: 'bar3',
 239                     },
 240                 },
 241             ] as const;
 242
 243             const newLabels2 = updateCollection({
 244                 model: newLabels,
 245                 events: events2,
 246                 itemKey: 'Label',
 247                 item: ({ Label }) => Label,
 248             });
 249             expect(newLabels2).toEqual([
 250                 { ID: '12345', foo: 'monique' },
 251                 { ID: '124', foo: 'bar3' },
 252             ]);
 253         });
 254
 255         it('should delete, create and update items and not sort them by a custom key', () => {
 256             const labels = [
 257                 {
 258                     ID: '122',
 259                     foo: 'bar',
 260                     counter: 3,
 261                 },
 262                 {
 263                     ID: '123',
 264                     foo: 'bar',
 265                     counter: 1,
 266                 },
 267             ];
 268             const events = [
 269                 {
 270                     ID: '123',
 271                     Action: EVENT_ACTIONS.UPDATE,
 272                     Label: {
 273                         ID: '123',
 274                         foo: 'bar2',
 275                         counter: 5,
 276                     },
 277                 },
 278                 {
 279                     ID: '12345',
 280                     Action: EVENT_ACTIONS.CREATE,
 281                     Label: {
 282                         ID: '12345',
 283                         foo: 'monique',
 284                         counter: 2,
 285                     },
 286                 },
 287                 {
 288                     ID: '124',
 289                     Action: EVENT_ACTIONS.CREATE,
 290                     Label: {
 291                         ID: '124',
 292                         foo: 'bar',
 293                         counter: 3,
 294                     },
 295                 },
 296             ] as const;
 297             const newLabels = sortCollection('counter', updateCollection({ model: labels, events, itemKey: 'Label' }));
 298             expect(newLabels).toEqual([
 299                 { ID: '12345', foo: 'monique', counter: 2 },
 300                 { ID: '122', foo: 'bar', counter: 3 },
 301                 { ID: '124', foo: 'bar', counter: 3 },
 302                 { ID: '123', foo: 'bar2', counter: 5 },
 303             ]);
 304         });
 305     });
 306 });