store: Reset backoff duration on polling success.

Fixes: zulip#554

Signed-off-by: Zixuan James Li <[email protected]>

Author: PIG208

lib/model/store.dart

@@ -750,7 +750,7 @@ class UpdateMachine {
   }
 
   void poll() async {
-    final backoffMachine = BackoffMachine();
+    BackoffMachine? backoffMachine;
 
     while (true) {
       if (_debugLoopSignal != null) {
@@ -779,20 +779,21 @@ class UpdateMachine {
                 'Backing off, then will retry…'));
             // TODO tell user if transient polling errors persist
             // TODO reset to short backoff eventually
-            await backoffMachine.wait();
+            await (backoffMachine ??= BackoffMachine()).wait();
             assert(debugLog('… Backoff wait complete, retrying poll.'));
             continue;
 
           default:
             assert(debugLog('Error polling event queue for $store: $e\n'
                 'Backing off and retrying even though may be hopeless…'));
             // TODO tell user on non-transient error in polling
-            await backoffMachine.wait();
+            await (backoffMachine ??= BackoffMachine()).wait();
             assert(debugLog('… Backoff wait complete, retrying poll.'));
             continue;
         }
       }
 
+      backoffMachine = null;
       final events = result.events;
       for (final event in events) {
         await store.handleEvent(event);

test/model/store_test.dart

@@ -1,6 +1,7 @@
 import 'dart:async';
 
 import 'package:checks/checks.dart';
+import 'package:fake_async/fake_async.dart';
 import 'package:flutter/foundation.dart';
 import 'package:http/http.dart' as http;
 import 'package:test/scaffolding.dart';
@@ -11,6 +12,7 @@ import 'package:zulip/api/route/messages.dart';
 import 'package:zulip/model/store.dart';
 import 'package:zulip/notifications/receive.dart';
 
+import '../api/backoff_test.dart';
 import '../api/fake_api.dart';
 import '../api/model/model_checks.dart';
 import '../example_data.dart' as eg;
@@ -425,6 +427,66 @@ void main() {
       check(store.userSettings!.twentyFourHourTime).isTrue();
     }));
 
+    test('reset BackoffMachine after a successful poll', () {
+      Duration measureWait(FakeAsync async) {
+        final duration = async.pendingTimers.first.duration;
+        async.flushTimers();
+        return duration;
+      }
+
+      void prepareError() {
+        connection.prepare(httpStatus: 500, body: 'splat');
+      }
+      void prepareSuccess() {
+        connection.prepare(json: GetEventsResult(events: [
+          HeartbeatEvent(id: 2),
+        ], queueId: null).toJson());
+      }
+
+      verifyRandomizedDurations(
+        expectedMaxDurationsInMs: [100, 200, 400, 800, 1600, 100, 200, 400, 800, 1600],
+        computeActualDurations: (expectedMaxDurations) => awaitFakeAsync((async) async {
+          await prepareStore();
+          updateMachine.debugPauseLoop();
+          updateMachine.poll();
+          final results = <Duration>[];
+          int lastEventId = 1;
+          for (int i = 0; i < expectedMaxDurations.length; i++) {
+            check(async.pendingTimers).isEmpty();
+            if (i > 0 && expectedMaxDurations[i] < expectedMaxDurations[i - 1]) {
+              // The backoff duration should get a reset when the poll was
+              // successful.
+              prepareSuccess();
+              updateMachine.debugAdvanceLoop();
+              async.flushTimers();
+
+              checkLastRequest(lastEventId: lastEventId);
+              // Verify that the poll completes successfully.
+              lastEventId++;
+              check(updateMachine.lastEventId).equals(lastEventId);
+            }
+
+            // Make the request, inducing an error in it.
+            prepareError();
+            updateMachine.debugAdvanceLoop();
+
+            // Wait for the request to finish.
+            async.elapse(Duration.zero);
+            checkLastRequest(lastEventId: lastEventId);
+            check(updateMachine.lastEventId).equals(lastEventId);
+
+            // The backoff timer should be active now.
+            check(async.pendingTimers).single;
+            final duration = measureWait(async);
+            results.add(duration);
+            check(async.pendingTimers).isEmpty();
+            check(connection.lastRequest).isNull();
+          }
+
+          return results;
+        }));
+    });
+
     void checkRetry(void Function() prepareError) {
       awaitFakeAsync((async) async {
         await prepareStore(lastEventId: 1);