test(watch): additional buildUpdate queue tests

additional buildUpdate queue tests

Author: danbucholtz

src/watch.spec.ts

@@ -416,7 +416,246 @@ describe('watch', () => {
         expect(buildUpdateSpy.calls.mostRecent().args[0].concat().filter((changedFile: ChangedFile) => changedFile === changedFileFive)[0]).toEqual(changedFileFive);
         expect(buildUpdateSpy.calls.mostRecent().args[0].concat().filter((changedFile: ChangedFile) => changedFile === changedFileSix)[0]).toEqual(changedFileSix);
         expect(buildUpdateSpy.calls.mostRecent().args[1]).toEqual(context);
+      });
+
+    });
+
+    it('should run buildUpdate on the queued files even if the first build update fails', () => {
+      const changedFileOne: ChangedFile = {
+        event: 'change',
+        ext: '.ts',
+        filePath: '/some/fake/path/that/doesnt/matter.ts'
+      };
+      const changedFileTwo: ChangedFile = {
+        event: 'change',
+        ext: '.ts',
+        filePath: '/some/fake/path/that/doesnt/matter2.ts'
+      };
+
+      const changedFileThree: ChangedFile = {
+        event: 'change',
+        ext: '.ts',
+        filePath: '/some/fake/path/that/doesnt/matter3.ts'
+      };
+      const changedFileFour: ChangedFile = {
+        event: 'change',
+        ext: '.ts',
+        filePath: '/some/fake/path/that/doesnt/matter4.ts'
+      };
+
+      const changedFileFive: ChangedFile = {
+        event: 'change',
+        ext: '.ts',
+        filePath: '/some/fake/path/that/doesnt/matter5.ts'
+      };
+      const changedFileSix: ChangedFile = {
+        event: 'change',
+        ext: '.ts',
+        filePath: '/some/fake/path/that/doesnt/matter6.ts'
+      };
+
+      const originalChangedFiles = [changedFileOne, changedFileTwo];
+      const secondSetOfChangedFiles = [changedFileThree, changedFileFour];
+      const ThirdSetOfChangedFiles = [changedFileTwo, changedFileFour, changedFileFive, changedFileSix];
+      const context = {};
+
+      let firstPromiseReject: Function = null;
+      const firstPromise = new Promise((resolve, reject) => {
+        firstPromiseReject = reject;
+      });
+      spyOn(watch, watch.queueOrRunBuildUpdate.name).and.callThrough();
+      const buildUpdateSpy = spyOn(build, build.buildUpdate.name).and.callFake((changedFiles: ChangedFile[], context: BuildContext) => {
+        if (changedFiles === originalChangedFiles) {
+          return firstPromise;
+        } else {
+          return Promise.resolve();
+        }
+      });
+
+      // call the original
+      expect(watch.buildUpdatePromise).toBeFalsy();
+      const promise = watch.queueOrRunBuildUpdate(originalChangedFiles, context);
+      expect(watch.buildUpdatePromise).toBeTruthy();
+      expect(watch.queuedChangedFileMap.size).toEqual(0);
+      expect(build.buildUpdate).toHaveBeenCalledTimes(1);
+
+      // okay, call again and it should be queued now
+      watch.queueOrRunBuildUpdate(secondSetOfChangedFiles, context);
+      expect(watch.buildUpdatePromise).toBeTruthy();
+      expect(watch.queuedChangedFileMap.size).toEqual(2);
+      expect(watch.queuedChangedFileMap.get(changedFileThree.filePath)).toEqual(changedFileThree);
+      expect(watch.queuedChangedFileMap.get(changedFileFour.filePath)).toEqual(changedFileFour);
+      expect(build.buildUpdate).toHaveBeenCalledTimes(1);
+
+      // okay, let's queue some more
+      watch.queueOrRunBuildUpdate(ThirdSetOfChangedFiles, context);
+      expect(watch.buildUpdatePromise).toBeTruthy();
+      expect(watch.queuedChangedFileMap.size).toEqual(5);
+      expect(watch.queuedChangedFileMap.get(changedFileTwo.filePath)).toEqual(changedFileTwo);
+      expect(watch.queuedChangedFileMap.get(changedFileThree.filePath)).toEqual(changedFileThree);
+      expect(watch.queuedChangedFileMap.get(changedFileFour.filePath)).toEqual(changedFileFour);
+      expect(watch.queuedChangedFileMap.get(changedFileFive.filePath)).toEqual(changedFileFive);
+      expect(watch.queuedChangedFileMap.get(changedFileSix.filePath)).toEqual(changedFileSix);
+      expect(build.buildUpdate).toHaveBeenCalledTimes(1);
+
+      firstPromiseReject();
+      return promise.then(() => {
+        expect(watch.buildUpdatePromise).toBeFalsy();
+        expect(watch.queuedChangedFileMap.size).toEqual(0);
+        expect(build.buildUpdate).toHaveBeenCalledTimes(2);
+        expect(buildUpdateSpy.calls.first().args[0]).toEqual(originalChangedFiles);
+        expect(buildUpdateSpy.calls.first().args[1]).toEqual(context);
+        expect(buildUpdateSpy.calls.mostRecent().args[0].length).toEqual(5);
+        // make sure the array contains the elements that we expect it to
+        expect(buildUpdateSpy.calls.mostRecent().args[0].concat().filter((changedFile: ChangedFile) => changedFile === changedFileTwo)[0]).toEqual(changedFileTwo);
+        expect(buildUpdateSpy.calls.mostRecent().args[0].concat().filter((changedFile: ChangedFile) => changedFile === changedFileThree)[0]).toEqual(changedFileThree);
+        expect(buildUpdateSpy.calls.mostRecent().args[0].concat().filter((changedFile: ChangedFile) => changedFile === changedFileFour)[0]).toEqual(changedFileFour);
+        expect(buildUpdateSpy.calls.mostRecent().args[0].concat().filter((changedFile: ChangedFile) => changedFile === changedFileFive)[0]).toEqual(changedFileFive);
+        expect(buildUpdateSpy.calls.mostRecent().args[0].concat().filter((changedFile: ChangedFile) => changedFile === changedFileSix)[0]).toEqual(changedFileSix);
+        expect(buildUpdateSpy.calls.mostRecent().args[1]).toEqual(context);
+      });
+    });
 
+    it('should handle multiple queueing and unqueuing events aka advanced test', () => {
+      const changedFileOne: ChangedFile = {
+        event: 'change',
+        ext: '.ts',
+        filePath: '/some/fake/path/that/doesnt/matter.ts'
+      };
+      const changedFileTwo: ChangedFile = {
+        event: 'change',
+        ext: '.ts',
+        filePath: '/some/fake/path/that/doesnt/matter2.ts'
+      };
+
+      const changedFileThree: ChangedFile = {
+        event: 'change',
+        ext: '.ts',
+        filePath: '/some/fake/path/that/doesnt/matter3.ts'
+      };
+      const changedFileFour: ChangedFile = {
+        event: 'change',
+        ext: '.ts',
+        filePath: '/some/fake/path/that/doesnt/matter4.ts'
+      };
+
+      const changedFileFive: ChangedFile = {
+        event: 'change',
+        ext: '.ts',
+        filePath: '/some/fake/path/that/doesnt/matter5.ts'
+      };
+      const changedFileSix: ChangedFile = {
+        event: 'change',
+        ext: '.ts',
+        filePath: '/some/fake/path/that/doesnt/matter6.ts'
+      };
+
+      const originalChangedFiles = [changedFileOne, changedFileTwo];
+      const secondSetOfChangedFiles = [changedFileThree, changedFileFour];
+      const thirdSetOfChangedFiles = [changedFileTwo, changedFileFour, changedFileFive, changedFileSix];
+      const fourthSetOfChangedFiles = [changedFileOne, changedFileThree];
+      const fifthSetOfChangedFiles = [changedFileFour, changedFileFive, changedFileSix];
+
+      const context = {};
+
+      let firstPromiseResolve: Function = null;
+      let secondPromiseResolve: Function = null;
+      let thirdPromiseResolve: Function = null;
+      const firstPromise = new Promise((resolve, reject) => {
+        firstPromiseResolve = resolve;
+      });
+      const secondPromise = new Promise((resolve, reject) => {
+        secondPromiseResolve = resolve;
+      });
+      const thirdPromise = new Promise((resolve, reject) => {
+        thirdPromiseResolve = resolve;
+      });
+
+      spyOn(watch, watch.queueOrRunBuildUpdate.name).and.callThrough();
+      const buildUpdateSpy = spyOn(build, build.buildUpdate.name).and.callFake((changedFiles: ChangedFile[], context: BuildContext) => {
+        if (changedFiles === originalChangedFiles) {
+          return firstPromise;
+        } else if (changedFiles.length === 5) {
+          // hardcode the length for now as it's easier to detect which array it'll be
+          return secondPromise;
+        } else {
+          return thirdPromise;
+        }
+      });
+
+      // call the original
+      expect(watch.buildUpdatePromise).toBeFalsy();
+      const promise = watch.queueOrRunBuildUpdate(originalChangedFiles, context);
+      expect(watch.buildUpdatePromise).toBeTruthy();
+      expect(watch.queuedChangedFileMap.size).toEqual(0);
+      expect(build.buildUpdate).toHaveBeenCalledTimes(1);
+      expect(buildUpdateSpy.calls.first().args[0]).toEqual(originalChangedFiles);
+      expect(buildUpdateSpy.calls.first().args[1]).toEqual(context);
+
+      // okay, call again and it should be queued now
+      watch.queueOrRunBuildUpdate(secondSetOfChangedFiles, context);
+      expect(watch.buildUpdatePromise).toBeTruthy();
+      expect(watch.queuedChangedFileMap.size).toEqual(2);
+      expect(watch.queuedChangedFileMap.get(changedFileThree.filePath)).toEqual(changedFileThree);
+      expect(watch.queuedChangedFileMap.get(changedFileFour.filePath)).toEqual(changedFileFour);
+      expect(build.buildUpdate).toHaveBeenCalledTimes(1);
+
+      // okay, let's queue some more
+      watch.queueOrRunBuildUpdate(thirdSetOfChangedFiles, context);
+      expect(watch.buildUpdatePromise).toBeTruthy();
+      expect(watch.queuedChangedFileMap.size).toEqual(5);
+      expect(watch.queuedChangedFileMap.get(changedFileTwo.filePath)).toEqual(changedFileTwo);
+      expect(watch.queuedChangedFileMap.get(changedFileThree.filePath)).toEqual(changedFileThree);
+      expect(watch.queuedChangedFileMap.get(changedFileFour.filePath)).toEqual(changedFileFour);
+      expect(watch.queuedChangedFileMap.get(changedFileFive.filePath)).toEqual(changedFileFive);
+      expect(watch.queuedChangedFileMap.get(changedFileSix.filePath)).toEqual(changedFileSix);
+      expect(build.buildUpdate).toHaveBeenCalledTimes(1);
+
+      firstPromiseResolve();
+
+      return firstPromise.then(() => {
+        expect(build.buildUpdate).toHaveBeenCalledTimes(2);
+        expect(buildUpdateSpy.calls.mostRecent().args[0].length).toEqual(5);
+        expect(buildUpdateSpy.calls.mostRecent().args[0].concat().filter((changedFile: ChangedFile) => changedFile === changedFileTwo)[0]).toEqual(changedFileTwo);
+        expect(buildUpdateSpy.calls.mostRecent().args[0].concat().filter((changedFile: ChangedFile) => changedFile === changedFileThree)[0]).toEqual(changedFileThree);
+        expect(buildUpdateSpy.calls.mostRecent().args[0].concat().filter((changedFile: ChangedFile) => changedFile === changedFileFour)[0]).toEqual(changedFileFour);
+        expect(buildUpdateSpy.calls.mostRecent().args[0].concat().filter((changedFile: ChangedFile) => changedFile === changedFileFive)[0]).toEqual(changedFileFive);
+        expect(buildUpdateSpy.calls.mostRecent().args[0].concat().filter((changedFile: ChangedFile) => changedFile === changedFileSix)[0]).toEqual(changedFileSix);
+        expect(buildUpdateSpy.calls.mostRecent().args[1]).toEqual(context);
+
+        // okay, give it more changes so it queues that stuff up
+        // also do some assertions homie
+        watch.queueOrRunBuildUpdate(fourthSetOfChangedFiles, context);
+        expect(watch.buildUpdatePromise).toBeTruthy();
+        expect(watch.queuedChangedFileMap.size).toEqual(2);
+        expect(watch.queuedChangedFileMap.get(changedFileOne.filePath)).toEqual(changedFileOne);
+        expect(watch.queuedChangedFileMap.get(changedFileThree.filePath)).toEqual(changedFileThree);
+
+        // cool beans yo, go ahead and resolve another promise
+        secondPromiseResolve();
+        return secondPromise;
+      }).then(() => {
+        expect(build.buildUpdate).toHaveBeenCalledTimes(3);
+        expect(buildUpdateSpy.calls.mostRecent().args[0].length).toEqual(2);
+        expect(buildUpdateSpy.calls.mostRecent().args[0].concat().filter((changedFile: ChangedFile) => changedFile === changedFileOne)[0]).toEqual(changedFileOne);
+        expect(buildUpdateSpy.calls.mostRecent().args[0].concat().filter((changedFile: ChangedFile) => changedFile === changedFileThree)[0]).toEqual(changedFileThree);
+
+        // okay, give it more changes so it queues that stuff up
+        // also do some assertions homie
+        watch.queueOrRunBuildUpdate(fifthSetOfChangedFiles, context);
+        expect(watch.buildUpdatePromise).toBeTruthy();
+        expect(watch.queuedChangedFileMap.size).toEqual(3);
+        expect(watch.queuedChangedFileMap.get(changedFileFour.filePath)).toEqual(changedFileFour);
+        expect(watch.queuedChangedFileMap.get(changedFileFive.filePath)).toEqual(changedFileFive);
+        expect(watch.queuedChangedFileMap.get(changedFileSix.filePath)).toEqual(changedFileSix);
+
+         // cool beans yo, go ahead and resolve another promise
+        thirdPromiseResolve();
+        return thirdPromise;
+
+      }).then(() => {
+        // return the original promise just to make sure everything is chained together
+        return promise;
       });
     });
   });

src/watch.ts

@@ -231,22 +231,24 @@ export function queueOrRunBuildUpdate(changedFiles: ChangedFile[], context: Buil
     // there is not an active build going going on
     // clear out any queued file changes, and run the build
     queuedChangedFileMap.clear();
-    const buildUpdateComplete = () => {
+
+    const buildUpdateCompleteCallback: () => Promise<any> = () => {
       // the update is complete, so check if there are pending updates that need to be run
       buildUpdatePromise = null;
       if (queuedChangedFileMap.size > 0) {
         const queuedChangeFileList: ChangedFile[] = [];
         queuedChangedFileMap.forEach(changedFile => {
           queuedChangeFileList.push(changedFile);
         });
-        queueOrRunBuildUpdate(queuedChangeFileList, context);
+        return queueOrRunBuildUpdate(queuedChangeFileList, context);
       }
+      return Promise.resolve();
     };
 
-    buildUpdatePromise = buildTask.buildUpdate(changedFiles, context).then(buildUpdateComplete).catch((err: Error) => {
-      buildUpdateComplete();
+    buildUpdatePromise = buildTask.buildUpdate(changedFiles, context);
+    return buildUpdatePromise.then(buildUpdateCompleteCallback).catch((err: Error) => {
+      return buildUpdateCompleteCallback();
     });
-    return buildUpdatePromise;
   }
 }