store: Ignore boring NetworkExceptions

Usually when a client goes back from sleep or lose network connection,
there will be a bunch of errors when polling event queue.  This known
error will always be a `NetworkException`, so we make a separate case
for it.

Previously, we may report these errors, and it ended up being spammy.
This filters out the more interesting one to report instead.

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

Author: PIG208

lib/model/store.dart

@@ -817,7 +817,7 @@ class UpdateMachine {
             debugLog('… Event queue replaced.');
             return;
 
-          case Server5xxException() || NetworkException():
+          case Server5xxException():
             assert(debugLog('Transient error polling event queue for $store: $e\n'
                 'Backing off, then will retry…'));
             maybeReportTransientError(
@@ -828,6 +828,27 @@ class UpdateMachine {
             assert(debugLog('… Backoff wait complete, retrying poll.'));
             continue;
 
+          case NetworkException():
+            assert(debugLog('Transient error polling event queue for $store: $e\n'
+                'Backing off, then will retry…'));
+            if (e.cause is! SocketException) {
+              // Heuristic check to only report interesting errors to the user.
+              // This currently ignores [SocketException], which typically
+              // occurs when the client goes back from sleep.
+              // TODO: Investigate if there are other cases of [SocketException]
+              //   that might turn out to be interesting.
+              //
+              // See also:
+              //  * [NetworkException.cause], which is the underlying exception.
+              maybeReportTransientError(
+                localizations.errorConnectingToServerShort,
+                details: localizations.errorConnectingToServerDetails(
+                  serverUrl, e.toString()));
+            }
+            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…'));

test/model/store_test.dart

@@ -1,4 +1,5 @@
 import 'dart:async';
+import 'dart:io';
 
 import 'package:checks/checks.dart';
 import 'package:flutter/foundation.dart';
@@ -476,10 +477,14 @@ void main() {
       /// Check if [UpdateMachine.poll] retries as expected when there are
       /// errors.
       ///
-      /// This verifies that the first user-facing error message when the
+      /// By default, verify that the first user-facing error message when the
       /// `numRetries`'th polling failure occurs.
+      ///
+      /// If `expectNotifyError` is false, verify that there is no user-facing
+      /// error message regardless of the retries.
       void checkRetry(void Function() prepareError, {
         required int numRetries,
+        bool expectNotifyError = true,
       }) {
         assert(numRetries > 0);
         reportErrorToUserBriefly = logAndReportErrorToUserBriefly;
@@ -510,12 +515,19 @@ void main() {
               async.flushTimers();
             }
 
+            if (!expectNotifyError) {
+              // No matter how many retries there have been, no request should
+              // result in an error message.
+              check(takeLastReportedError()).isNull();
+              continue;
+            }
             if (i < numRetries - 1) {
               // The error message should not appear until the `updateMachine`
               // has retried the given number of times.
               check(takeLastReportedError()).isNull();
               continue;
             }
+            assert(expectNotifyError);
             // Only expect an error message from the last retry.
             assert(i == numRetries - 1);
             check(takeLastReportedError()).isNotNull().contains(expectedErrorMessage);
@@ -549,6 +561,13 @@ void main() {
           numRetries: UpdateMachine.transientFailureCountNotifyThreshold + 1);
       });
 
+      test('NetworkException to be ignored', () {
+        checkRetry(() => connection.prepare(
+          exception: const SocketException("failed")),
+          numRetries: UpdateMachine.transientFailureCountNotifyThreshold + 1,
+          expectNotifyError: false);
+      });
+
       test('ZulipApiException', () {
         checkRetry(() => connection.prepare(httpStatus: 400, json: {
           'result': 'error', 'code': 'BAD_REQUEST', 'msg': 'Bad request'}),