Fix: Don't render until AFTER all are fetched

src/api/FileVersionAPI.js

@@ -46,7 +46,7 @@ class FileVersionAPI extends API {
      */
     fetchVersionAnnotations(version: string): Promise<AnnotationMap> {
         this.fileVersionId = version;
-        
+
         // $FlowFixMe
         return this.fetchFromMarker({ version, fields: FIELDS }).then(this.createAnnotationMap);
     }
@@ -77,11 +77,20 @@ class FileVersionAPI extends API {
      * @param {Params} queryParams - Key-value map of querystring params
      * @return {void}
      */
-    successHandler = (data: Data, queryParams: Params): void => {
+    successHandler = (data: Data, queryParams: Params): Promise<any> => {
+        if (data.type === 'error' || !Array.isArray(data.entries)) {
+            const error = new Error(`Could not read annotations from file version with ID ${this.fileVersionId}`);
+            this.emit(ANNOTATOR_EVENT.error, {
+                reason: ERROR_TYPE.read,
+                error: error.toString()
+            });
+            return Promise.reject(error);
+        }
+
         const entries = this.data ? this.data.entries : [];
         this.data = {
             ...data,
-            entries: entries.concat(data.entries)
+            entries: [...entries, ...data.entries]
         };
 
         const { next_marker } = data;
@@ -91,16 +100,10 @@ class FileVersionAPI extends API {
                 marker: next_marker
             };
 
-            this.fetchFromMarker(params);
+            return this.fetchFromMarker(params);
         }
 
-        if (data.type === 'error' || !Array.isArray(data.entries)) {
-            const error = new Error(`Could not read annotations from file version with ID ${this.fileVersionId}`);
-            this.emit(ANNOTATOR_EVENT.error, {
-                reason: ERROR_TYPE.read,
-                error: error.toString()
-            });
-        }
+        return Promise.resolve(this.data);
     };
 
     /**

src/api/__tests__/FileVersionAPI-test.js

@@ -55,34 +55,37 @@ describe('api/FileVersionAPI', () => {
 
     describe('successHandler()', () => {
         beforeEach(() => {
-            api.fetchFromMarker = jest.fn();
+            api.fetchFromMarker = jest.fn().mockReturnValue(Promise.resolve());
             api.emit = jest.fn();
         });
 
         it('should call fetch the remaining annotations if the version has more to fetch', () => {
             api.data = { entries: [{}] };
-            api.successHandler({ entries: [{}, {}], next_marker: 'marker', limit: 1 });
-            expect(api.data.entries.length).toEqual(3);
-            expect(api.fetchFromMarker).toBeCalled();
+            api.successHandler({ entries: [{}, {}], next_marker: 'marker', limit: 1 }).then(() => {
+                expect(api.data.entries.length).toEqual(3);
+                expect(api.fetchFromMarker).toBeCalled();
+            });
         });
 
         it('should not call fetch if no more annotations need to be fetched', () => {
             api.data = { entries: [{}] };
-            api.successHandler({ entries: [{}, {}], limit: 1 });
-            expect(api.data.entries.length).toEqual(3);
-            expect(api.fetchFromMarker).not.toBeCalled();
+            api.successHandler({ entries: [{}, {}], limit: 1 }).then(() => {
+                expect(api.data.entries.length).toEqual(3);
+                expect(api.fetchFromMarker).not.toBeCalled();
+            });
         });
 
         it('should emit an error if the success response is of type error', () => {
             api.fileVersionId = 123;
-            api.successHandler({ type: 'error' });
-            const error = new Error(`Could not read annotations from file version with ID ${api.fileVersionId}`);
+            api.successHandler({ type: 'error' }).catch(() => {
+                const error = new Error(`Could not read annotations from file version with ID ${api.fileVersionId}`);
 
-            expect(api.data.entries.length).toEqual(1);
-            expect(api.fetchFromMarker).not.toBeCalled();
-            expect(api.emit).toBeCalledWith(ANNOTATOR_EVENT.error, {
-                reason: ERROR_TYPE.read,
-                error: error.toString()
+                expect(api.data.entries.length).toEqual(1);
+                expect(api.fetchFromMarker).not.toBeCalled();
+                expect(api.emit).toBeCalledWith(ANNOTATOR_EVENT.error, {
+                    reason: ERROR_TYPE.read,
+                    error: error.toString()
+                });
             });
         });
     });