Throwing error instead of re registering sync on failure

packages/workbox-background-sync/Queue.mjs

@@ -132,17 +132,18 @@ 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 rethrow the failed requests count.
     if (failedRequests.length) {
       await Promise.all(failedRequests.map((storableRequest) => {
         return this._queueStore.addEntry(storableRequest);
       }));
 
-      await this._registerSync();
+      throw new WorkboxError('queue-replay-failed',
+        {name: this._name, count: failedRequests.length});
     }
-
-    await this._runCallback('queueDidReplay', replayedRequests);
   }
 
   /**

packages/workbox-core/models/messages/messages.mjs

@@ -128,6 +128,10 @@ export default {
       `registered.`;
   },
 
+  'queue-replay-failed': ({name, count}) => {
+    return `${count} requests failed, while trying to replay Queue: ${name}.`;
+  },
+
   'duplicate-queue-name': ({name}) => {
     return `The Queue name '${name}' is already being used. ` +
         `All instances of backgroundSync.Queue must be given unique names.`;

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

@@ -23,6 +23,7 @@ import {DB_NAME, OBJECT_STORE_NAME} from
 import {DBWrapper} from '../../../../packages/workbox-core/_private/DBWrapper.mjs';
 import {resetEventListeners} from
     '../../../../infra/testing/sw-env-mocks/event-listeners.js';
+import {WorkboxError} from '../../../../packages/workbox-core/_private/WorkboxError.mjs';
 
 const getObjectStoreEntries = async () => {
   return await new DBWrapper(DB_NAME, 1).getAll(OBJECT_STORE_NAME);
@@ -293,37 +294,42 @@ 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;
+      }
+
+      throw new Error('should have exit from catch');
     });
 
-    it(`should re-register for a sync event if re-fetching fails`,
+    it(`should throw WorkboxError 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).to.be.instanceof(WorkboxError);
+        return;
+      }
 
-      expect(self.registration.sync.register.calledOnce).to.be.true;
-      expect(self.registration.sync.register.calledWith(
-          'workbox-background-sync:foo')).to.be.true;
+      throw new Error('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;