Throwing error instead of re registering sync on failure

packages/workbox-background-sync/Queue.mjs

@@ -104,6 +104,8 @@ class Queue {
    * `queueDidReplay` callback is invoked (which implies the queue is
    * now empty). If any of the requests fail, a new sync registration is
    * created to retry again later.
+   *
+   * @return {Promise}
    */
   async replayRequests() {
     const now = Date.now();
@@ -132,17 +134,17 @@ class Queue {
       replayedRequests.push(replay);
     }
 
+    await this._runCallback('queueDidReplay', replayedRequests);
+
     // If any requests failed, put the failed requests back in the queue
-    // and register for another sync.
+    // and reject promise.
     if (failedRequests.length) {
       await Promise.all(failedRequests.map((storableRequest) => {
         return this._queueStore.addEntry(storableRequest);
       }));
 
-      await this._registerSync();
+      return Promise.reject(failedRequests);
     }
-
-    await this._runCallback('queueDidReplay', replayedRequests);
   }
 
   /**

test/workbox-background-sync/node/lib/test-Queue.mjs

@@ -293,37 +293,43 @@ describe(`[workbox-background-sync] Queue`, function() {
       await queue.addRequest(new Request('/three'));
       await queue.addRequest(new Request('/four'));
       await queue.addRequest(new Request('/five'));
-      await queue.replayRequests(); // The 2nd and 4th requests should fail.
 
-
-      const entries = await getObjectStoreEntries();
-      expect(entries.length).to.equal(2);
-      expect(entries[0].storableRequest.url).to.equal('/two');
-      expect(entries[1].storableRequest.url).to.equal('/four');
+      try {
+        await queue.replayRequests(); // The 2nd and 4th requests should fail.
+      } catch (error) {
+        const entries = await getObjectStoreEntries();
+        expect(entries.length).to.equal(2);
+        expect(entries[0].storableRequest.url).to.equal('/two');
+        expect(entries[1].storableRequest.url).to.equal('/four');
+        return;
+      }
+
+      return Promise.reject('should have exit from catch');
     });
 
-    it(`should re-register for a sync event if re-fetching fails`,
+    it(`should reject replayRequests promise if re-fetching fails`,
         async function() {
-      sandbox.stub(self.registration, 'sync').value({
-        register: sinon.stub().resolves(),
-      });
       sandbox.stub(self, 'fetch')
           .onCall(1).rejects(new Error())
           .callThrough();
 
+      const failureURL = '/two';
       const queue = new Queue('foo');
 
       // Add requests for both queues to ensure only the requests from
       // the matching queue are replayed.
       await queue.addRequest(new Request('/one'));
-      await queue.addRequest(new Request('/two'));
+      await queue.addRequest(new Request(failureURL));
 
-      self.registration.sync.register.reset();
-      await queue.replayRequests(); // The second request should fail.
+      try {
+        await queue.replayRequests(); // The second request should fail.
+      } catch (error) {
+        expect(error.length).to.be.equal(1);
+        expect(error[0].url).to.be.equal(failureURL);
+        return;
+      }
 
-      expect(self.registration.sync.register.calledOnce).to.be.true;
-      expect(self.registration.sync.register.calledWith(
-          'workbox-background-sync:foo')).to.be.true;
+      return Promise.reject('should have exit from catch');
     });
 
     it(`should invoke all replay callbacks`, async function() {
@@ -376,7 +382,13 @@ describe(`[workbox-background-sync] Queue`, function() {
 
       await queue.addRequest(new Request('/three'));
       await queue.addRequest(new Request('/four'));
-      await queue.replayRequests();
+      try {
+        await queue.replayRequests();
+      } catch (error) {
+        // Dont do anything as this is expected to be rejected
+        // but every callback should still be called.
+      }
+
 
       expect(requestWillReplay.calledTwice).to.be.true;