packages/activation/src/helpers/errorsMapping.test.ts

   1 import type { Label } from '@proton/shared/lib/interfaces';
   2 import type { Folder } from '@proton/shared/lib/interfaces/Folder';
   3
   4 import MailImportFoldersParser from './MailImportFoldersParser/MailImportFoldersParser';
   5 import { getApiFoldersTestHelper } from './MailImportFoldersParser/MailImportFoldersParser.test';
   6 import { isNameAlreadyUsed, isNameEmpty, isNameReserved, isNameTooLong } from './errorsMapping';
   7
   8 const smallString = '6NLaLHynY3YPM8gGLncefo5PP7n2Db';
   9 const longString =
  10     'wIfm5MY1a2j7MwYAFNzQapBIXZdBxZaqRGwun6UBFNVimgw38tmmLhn7HewkHhvuNYf5QlC8a2NmfctV42tdfrJJm10okXooWV5f';
  11
  12 describe('Activation errors mapping', () => {
  13     describe('isNameTooLong', () => {
  14         it('Should return false if the folder/label name is smaller than limit', () => {
  15             const res = isNameTooLong(smallString);
  16             expect(res).toBe(false);
  17         });
  18         it('Should return true if the folder/label name is longer than limit', () => {
  19             const res = isNameTooLong(longString);
  20             expect(res).toBe(true);
  21         });
  22     });
  23
  24     describe('isNameReserved', () => {
  25         it('Should return false if the name is not reserved', () => {
  26             const res = isNameReserved('folder');
  27             expect(res).toBe(false);
  28         });
  29         it('Should return true if the name is reserved and capitalized', () => {
  30             const res = isNameReserved('Scheduled');
  31             expect(res).toBe(true);
  32         });
  33         it('Should return true if the name is reserved and lowercase', () => {
  34             const res = isNameReserved('scheduled');
  35             expect(res).toBe(true);
  36         });
  37     });
  38
  39     describe('isNameAlreadyUsed', () => {
  40         describe('Is folder mapping', () => {
  41             const isLabelMapping = false;
  42             it('Should return false if the name not present in collection', () => {
  43                 const collection = new MailImportFoldersParser(
  44                     getApiFoldersTestHelper(['path1', 'path2', 'path3']),
  45                     isLabelMapping
  46                 ).folders;
  47                 const item = collection[0];
  48
  49                 const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
  50                 expect(res).toBe(false);
  51             });
  52
  53             it('Should return false if a parent has same name as the child', () => {
  54                 const collection = new MailImportFoldersParser(
  55                     getApiFoldersTestHelper(['marco', 'marco/marco']),
  56                     isLabelMapping
  57                 ).folders;
  58                 const item = collection[0];
  59
  60                 const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
  61                 expect(res).toBe(false);
  62             });
  63
  64             it('Should return false if name not present in array', () => {
  65                 const collection = new MailImportFoldersParser(
  66                     getApiFoldersTestHelper(['path1', 'path2']),
  67                     isLabelMapping
  68                 ).folders;
  69                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
  70                 const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
  71                 expect(res).toBe(false);
  72             });
  73
  74             it('Should return false if name not present in array', () => {
  75                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
  76                 const collection = new MailImportFoldersParser(
  77                     getApiFoldersTestHelper(['path1', 'path2']),
  78                     isLabelMapping
  79                 ).folders;
  80                 const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
  81                 expect(res).toBe(false);
  82             });
  83
  84             it('Should return true if name present in array', () => {
  85                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
  86                 // @ts-expect-error need to override the ID because test will think it's the same item
  87                 item.id = 'anothername';
  88                 const collection = new MailImportFoldersParser(
  89                     getApiFoldersTestHelper(['path1', 'path2', 'path3']),
  90                     isLabelMapping
  91                 ).folders;
  92
  93                 const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
  94                 expect(res).toBe(true);
  95             });
  96
  97             it('Should return false if name present in an empty array', () => {
  98                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path1']), isLabelMapping).folders[0];
  99                 const collection = new MailImportFoldersParser(getApiFoldersTestHelper([]), isLabelMapping).folders;
 100
 101                 const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
 102                 expect(res).toBe(false);
 103             });
 104
 105             it('Should return false if label with similar name exists', () => {
 106                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path1']), isLabelMapping).folders[0];
 107                 const collection = new MailImportFoldersParser(getApiFoldersTestHelper([]), isLabelMapping).folders;
 108
 109                 const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
 110                 expect(res).toBe(false);
 111             });
 112
 113             it('Should return true if label has same name', () => {
 114                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path1']), isLabelMapping).folders[0];
 115
 116                 const res = isNameAlreadyUsed(item, [], [{ Path: 'path1' } as Label], [], isLabelMapping);
 117                 expect(res).toBe(true);
 118             });
 119
 120             it('Should return false if folder has same name', () => {
 121                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path1']), isLabelMapping).folders[0];
 122
 123                 const res = isNameAlreadyUsed(item, [], [], [{ Path: 'path1' } as Folder], isLabelMapping);
 124                 expect(res).toBe(false);
 125             });
 126         });
 127
 128         describe('Is label mapping', () => {
 129             const isLabelMapping = true;
 130             it('Should return false if the name not present in collection', () => {
 131                 const collection = new MailImportFoldersParser(
 132                     getApiFoldersTestHelper(['path1', 'path2', 'path3']),
 133                     isLabelMapping
 134                 ).folders;
 135                 const item = collection[0];
 136
 137                 const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
 138                 expect(res).toBe(false);
 139             });
 140
 141             it('Should return false if a parent has same name as the child', () => {
 142                 const collection = new MailImportFoldersParser(
 143                     getApiFoldersTestHelper(['marco', 'marco/marco']),
 144                     isLabelMapping
 145                 ).folders;
 146                 const item = collection[0];
 147
 148                 const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
 149                 expect(res).toBe(false);
 150             });
 151
 152             it('Should return false if name not present in array', () => {
 153                 const collection = new MailImportFoldersParser(
 154                     getApiFoldersTestHelper(['path1', 'path2']),
 155                     isLabelMapping
 156                 ).folders;
 157                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
 158                 const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
 159                 expect(res).toBe(false);
 160             });
 161
 162             it('Should return false if name not present in array', () => {
 163                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
 164                 const collection = new MailImportFoldersParser(
 165                     getApiFoldersTestHelper(['path1', 'path2']),
 166                     isLabelMapping
 167                 ).folders;
 168                 const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
 169                 expect(res).toBe(false);
 170             });
 171
 172             it('Should return true if name present in array', () => {
 173                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
 174                 // @ts-expect-error need to override the ID because test will think it's the same item
 175                 item.id = 'anothername';
 176                 const collection = new MailImportFoldersParser(
 177                     getApiFoldersTestHelper(['path1', 'path2', 'path3']),
 178                     isLabelMapping
 179                 ).folders;
 180
 181                 const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
 182                 expect(res).toBe(true);
 183             });
 184
 185             it('Should return false if name present in an empty array', () => {
 186                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path1']), isLabelMapping).folders[0];
 187                 const collection = new MailImportFoldersParser(getApiFoldersTestHelper([]), isLabelMapping).folders;
 188
 189                 const res = isNameAlreadyUsed(item, collection, [], [], isLabelMapping);
 190                 expect(res).toBe(false);
 191             });
 192
 193             it('Should return false if label has same name', () => {
 194                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path1']), isLabelMapping).folders[0];
 195
 196                 const res = isNameAlreadyUsed(item, [], [{ Path: 'path1' } as Label], [], isLabelMapping);
 197                 expect(res).toBe(false);
 198             });
 199
 200             it('Should return true if folder has same name', () => {
 201                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path1']), isLabelMapping).folders[0];
 202
 203                 const res = isNameAlreadyUsed(item, [], [], [{ Path: 'path1' } as Folder], isLabelMapping);
 204                 expect(res).toBe(true);
 205             });
 206         });
 207
 208         describe('Spaces checks', () => {
 209             it('Should return true if name in collection contains a space before', () => {
 210                 const isLabelMapping = false;
 211                 const item = new MailImportFoldersParser(getApiFoldersTestHelper([' path3']), isLabelMapping)
 212                     .folders[0];
 213                 // @ts-expect-error need to override the ID because test will think it's the same item
 214                 item.id = 'anothername';
 215                 const collection = new MailImportFoldersParser(
 216                     getApiFoldersTestHelper(['path1', 'path2', 'path3']),
 217                     isLabelMapping
 218                 ).folders;
 219
 220                 const res = isNameAlreadyUsed(item, collection, [], [], false);
 221                 expect(res).toBe(true);
 222             });
 223
 224             it('Should return true if name in item contains a space after', () => {
 225                 const isLabelMapping = false;
 226                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3 ']), isLabelMapping)
 227                     .folders[0];
 228                 // @ts-expect-error need to override the ID because test will think it's the same item
 229                 item.id = 'anothername';
 230                 const collection = new MailImportFoldersParser(
 231                     getApiFoldersTestHelper(['path1', 'path2', 'path3']),
 232                     isLabelMapping
 233                 ).folders;
 234
 235                 const res = isNameAlreadyUsed(item, collection, [], [], false);
 236                 expect(res).toBe(true);
 237             });
 238
 239             it('Should return true if name in item contains a space before and after', () => {
 240                 const isLabelMapping = false;
 241                 const item = new MailImportFoldersParser(getApiFoldersTestHelper([' path3 ']), isLabelMapping)
 242                     .folders[0];
 243                 // @ts-expect-error need to override the ID because test will think it's the same item
 244                 item.id = 'anothername';
 245                 const collection = new MailImportFoldersParser(
 246                     getApiFoldersTestHelper(['path1', 'path2', 'path3']),
 247                     isLabelMapping
 248                 ).folders;
 249
 250                 const res = isNameAlreadyUsed(item, collection, [], [], false);
 251                 expect(res).toBe(true);
 252             });
 253
 254             it('Should return true if the name present in item contains a space before and after and is capitalized', () => {
 255                 const isLabelMapping = false;
 256                 const item = new MailImportFoldersParser(getApiFoldersTestHelper([' Path3 ']), isLabelMapping)
 257                     .folders[0];
 258                 // @ts-expect-error need to override the ID because test will think it's the same item
 259                 item.id = 'anothername';
 260                 const collection = new MailImportFoldersParser(
 261                     getApiFoldersTestHelper(['path1', 'path2', 'path3']),
 262                     isLabelMapping
 263                 ).folders;
 264
 265                 const res = isNameAlreadyUsed(item, collection, [], [], false);
 266                 expect(res).toBe(true);
 267             });
 268
 269             it('Should return true if the name present in item contains two space before', () => {
 270                 const isLabelMapping = false;
 271                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['  Path3']), isLabelMapping)
 272                     .folders[0];
 273                 // @ts-expect-error need to override the ID because test will think it's the same item
 274                 item.id = 'anothername';
 275                 const collection = new MailImportFoldersParser(
 276                     getApiFoldersTestHelper(['path1', 'path2', 'path3']),
 277                     isLabelMapping
 278                 ).folders;
 279
 280                 const res = isNameAlreadyUsed(item, collection, [], [], false);
 281                 expect(res).toBe(true);
 282             });
 283
 284             it('Should return true if the name in collection contains a space before and after', () => {
 285                 const isLabelMapping = false;
 286                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
 287                 // @ts-expect-error need to override the ID because test will think it's the same item
 288                 item.id = 'anothername';
 289                 const collection = new MailImportFoldersParser(
 290                     getApiFoldersTestHelper(['path1', 'path2', ' path3 ']),
 291                     isLabelMapping
 292                 ).folders;
 293
 294                 const res = isNameAlreadyUsed(item, collection, [], [], false);
 295                 expect(res).toBe(true);
 296             });
 297
 298             it('Should return true if the name passed in collection contains a space before and after and is capitalized', () => {
 299                 const isLabelMapping = false;
 300                 const item = new MailImportFoldersParser(getApiFoldersTestHelper(['path3']), isLabelMapping).folders[0];
 301                 // @ts-expect-error need to override the ID because test will think it's the same item
 302                 item.id = 'anothername';
 303                 const collection = new MailImportFoldersParser(
 304                     getApiFoldersTestHelper(['path1', 'path2', ' Path3 ']),
 305                     isLabelMapping
 306                 ).folders;
 307
 308                 const res = isNameAlreadyUsed(item, collection, [], [], false);
 309                 expect(res).toBe(true);
 310             });
 311         });
 312     });
 313
 314     describe('isNameEmpty', () => {
 315         it('Should return false if the name is not empty', () => {
 316             const res = isNameEmpty('folder');
 317             expect(res).toBe(false);
 318         });
 319         it('Should return true if the name is an empty string', () => {
 320             const res = isNameEmpty('');
 321             expect(res).toBe(true);
 322         });
 323         it('Should return true if the name is undefined', () => {
 324             const res = isNameEmpty(undefined);
 325             expect(res).toBe(true);
 326         });
 327     });
 328
 329     describe('hasMergeWarning', () => {});
 330 });