refactored async/await for import helper to not also use then/catch

src/helpers/importHelper.js

@@ -9,35 +9,51 @@ const ih = {};
  * @async
  * @param {string} authorId - The author of the message
  * @param {string | null} [attachmentUrl] - The attached JSON url.
- * @returns {string} A successful addition of all members.
+ * @returns {Promise<string>} A successful addition of all members.
  * @throws {Error}  When the member exists, or creating a member doesn't work.
  */
 ih.pluralKitImport = async function (authorId, attachmentUrl= null) {
+    let fetchResult, pkData;
     if (!attachmentUrl) {
         throw new Error(enums.err.NOT_JSON_FILE);
     }
-    return fetch(attachmentUrl).then((res) => res.json()).then(async(pkData) => {
+    try {
+         fetchResult = await fetch(attachmentUrl);
+    }
+    catch(e) {
+        throw new Error(enums.err.CANNOT_FETCH_RESOURCE, { cause: e });
+    }
+
+    try {
+        pkData = await fetchResult.json();
+    }
+    catch(e) {
+        throw new Error(enums.err.NOT_JSON_FILE, { cause: e })
+    }
+
     const pkMembers = pkData.members;
     let errors = [];
-            const addedMembers = [];
+    let addedMembers = [];
     for (let pkMember of pkMembers) {
         const proxy = pkMember.proxy_tags[0] ? `${pkMember.proxy_tags[0].prefix ?? ''}text${pkMember.proxy_tags[0].suffix ?? ''}` : null;
-                await memberHelper.addFullMember(authorId, pkMember.name, pkMember.display_name, proxy, pkMember.avatar_url).then((memberObj) => {
+        try {
+            const memberObj = await memberHelper.addFullMember(authorId, pkMember.name, pkMember.display_name, proxy, pkMember.avatar_url);
             addedMembers.push(memberObj.member.name);
             if (memberObj.errors.length > 0) {
-                        errors.push(`\n**${pkMember.name}:** `)
+                errors.push(`\n**${pkMember.name}:** `);
                 errors = errors.concat(memberObj.errors);
             }
-                }).catch(e => {
+        }
-                    errors.push(e.message);
+        catch(e) {
-                });
+            console.error(e);
+            errors.push(e);
+        }
     }
     const aggregatedText = addedMembers.length > 0 ? `Successfully added members: ${addedMembers.join(', ')}` : `${enums.err.NO_MEMBERS_IMPORTED}`;
     if (errors.length > 0) {
         throw new AggregateError(errors, aggregatedText);
     }
     return aggregatedText;
-        });
 }
 
 export const importHelper = ih;

tests/helpers/importHelper.test.js

@@ -50,45 +50,50 @@ describe('importHelper', () => {
 
     describe('pluralKitImport', () => {
 
-        test('if no attachment URL, throws error', () => {
+        test('if no attachment URL, throws error', async() => {
-            return importHelper.pluralKitImport(authorId).catch((e) => {
+            await expect(importHelper.pluralKitImport(authorId)).rejects.toThrow(enums.err.NOT_JSON_FILE);
-                expect(e).toEqual(new Error(enums.err.NOT_JSON_FILE));
-            })
         })
 
-        test('if attachment URL, calls fetch and addFullMember and returns value', () => {
+        test('if attachment URL, calls fetch and addFullMember and returns value', async() => {
             memberHelper.addFullMember.mockResolvedValue(mockAddReturn);
-            return importHelper.pluralKitImport(authorId, attachmentUrl).then((res) => {
+            const result = await importHelper.pluralKitImport(authorId, attachmentUrl);
+
             expect(fetch).toHaveBeenCalledTimes(1);
             expect(fetch).toHaveBeenCalledWith(attachmentUrl);
             expect(memberHelper.addFullMember).toHaveBeenCalledWith(authorId, mockImportedMember.name, mockImportedMember.display_name, 'SP{text}', mockImportedMember.avatar_url);
-                expect(res).toEqual(`Successfully added members: ${mockAddReturnMember.name}`)
+            expect(result).toEqual(`Successfully added members: ${mockAddReturnMember.name}`)
-            })
         })
 
-        test('if addFullMember returns nothing, return correct enum', () => {
+
+        test('if fetch fails, throws error', async() => {
+            global.fetch = jest.fn().mockRejectedValue("can't get");
+            await expect(importHelper.pluralKitImport(authorId, attachmentUrl)).rejects.toThrow(enums.err.CANNOT_FETCH_RESOURCE, "can't get file");
+        })
+
+        test('if json conversion fails, throws error', async() => {
+            global.fetch = jest.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.reject("not json")
+            })
+            await expect(importHelper.pluralKitImport(authorId, attachmentUrl)).rejects.toThrow(enums.err.NOT_JSON_FILE, "not json");
+        })
+
+        test('if addFullMember returns nothing, return correct enum', async () => {
             memberHelper.addFullMember.mockResolvedValue();
-            return importHelper.pluralKitImport(authorId, attachmentUrl).catch((res) => {
+            await expect(importHelper.pluralKitImport(authorId, attachmentUrl)).rejects.toThrow(([], enums.err.NO_MEMBERS_IMPORTED));
-                expect(res).toEqual(new AggregateError([], enums.err.NO_MEMBERS_IMPORTED));
-            })
         })
 
-        test('if addFullMember returns nothing and throws error, catch and return error', () => {
+        test('if addFullMember returns nothing and throws error, catch and return error', async() => {
             memberHelper.addFullMember.mockResolvedValue(new Error('error'));
-            return importHelper.pluralKitImport(authorId, attachmentUrl).catch((res) => {
+            await expect(importHelper.pluralKitImport(authorId, attachmentUrl)).rejects.toThrow(([new Error('error')], enums.err.NO_MEMBERS_IMPORTED));
-                expect(res).toEqual(new AggregateError([new Error('error')], enums.err.NO_MEMBERS_IMPORTED))
-            })
         })
 
-        test('if addFullMember returns member but also contains error, return member and error', () => {
+        test('if addFullMember returns member but also contains error, return member and error', async () => {
             // Arrange
             const memberObj = {errors: ['error'], member: mockAddReturnMember};
             memberHelper.addFullMember.mockResolvedValue(memberObj);
-            // Act
+            // Act & Assert
-            return importHelper.pluralKitImport(authorId, attachmentUrl).catch((res) => {
+            await expect(importHelper.pluralKitImport(authorId, attachmentUrl)).rejects.toThrow((['error'], `Successfully added members: ${mockAddReturnMember.name}`));
-                // Assert
-                expect(res).toEqual(new AggregateError(['error'], `Successfully added members: ${mockAddReturnMember.name}`))
-            })
         })
 
     })