compose: Enforce max topic/content length by code points, following API

lib/api/route/messages.dart

@@ -156,7 +156,7 @@ class GetMessagesResult {
 }
 
 // https://zulip.com/api/send-message#parameter-topic
-const int kMaxTopicLength = 60;
+const int kMaxTopicLengthCodePoints = 60;
 
 // https://zulip.com/api/send-message#parameter-content
 const int kMaxMessageLengthCodePoints = 10000;

lib/widgets/compose_box.dart

@@ -28,10 +28,30 @@ const double _composeButtonSize = 44;
 ///
 /// Subclasses must ensure that [_update] is called in all exposed constructors.
 abstract class ComposeController<ErrorT> extends TextEditingController {
+  int get maxLengthUnicodeCodePoints;
+
   String get textNormalized => _textNormalized;
   late String _textNormalized;
   String _computeTextNormalized();
 
+  /// Length of [textNormalized] in Unicode code points,
+  /// if it might exceed [maxLengthUnicodeCodePoints], else null.
+  ///
+  /// Use this instead of [String.length]
+  /// to enforce a max length expressed in code points.
+  /// [String.length] is conservative and may cut the user off too short.
+  ///
+  /// Counting code points ([String.runes])
+  /// is more expensive than getting the number of UTF-16 code units
+  /// ([String.length]), so we avoid it when the result definitely won't exceed
+  /// [maxLengthUnicodeCodePoints].
+  int? get lengthUnicodeCodePointsIfLong => _lengthUnicodeCodePointsIfLong;
+  late int? _lengthUnicodeCodePointsIfLong;
+  int? _computeLengthUnicodeCodePointsIfLong() =>
+    _textNormalized.length > maxLengthUnicodeCodePoints
+      ? _textNormalized.runes.length
+      : null;
+
   List<ErrorT> get validationErrors => _validationErrors;
   late List<ErrorT> _validationErrors;
   List<ErrorT> _computeValidationErrors();
@@ -40,6 +60,8 @@ abstract class ComposeController<ErrorT> extends TextEditingController {
 
   void _update() {
     _textNormalized = _computeTextNormalized();
+    // uses _textNormalized, so comes after _computeTextNormalized()
+    _lengthUnicodeCodePointsIfLong = _computeLengthUnicodeCodePointsIfLong();
     _validationErrors = _computeValidationErrors();
     hasValidationErrors.value = _validationErrors.isNotEmpty;
   }
@@ -74,6 +96,9 @@ class ComposeTopicController extends ComposeController<TopicValidationError> {
   //   https://zulip.com/help/require-topics
   final mandatory = true;
 
+  // TODO(#307) use `max_topic_length` instead of hardcoded limit
+  @override final maxLengthUnicodeCodePoints = kMaxTopicLengthCodePoints;
+
   @override
   String _computeTextNormalized() {
     String trimmed = text.trim();
@@ -85,7 +110,11 @@ class ComposeTopicController extends ComposeController<TopicValidationError> {
     return [
       if (mandatory && textNormalized == kNoTopicTopic)
         TopicValidationError.mandatoryButEmpty,
-      if (textNormalized.length > kMaxTopicLength)
+
+      if (
+        lengthUnicodeCodePointsIfLong != null
+        && lengthUnicodeCodePointsIfLong! > maxLengthUnicodeCodePoints
+      )
         TopicValidationError.tooLong,
     ];
   }
@@ -116,6 +145,9 @@ class ComposeContentController extends ComposeController<ContentValidationError>
     _update();
   }
 
+  // TODO(#1237) use `max_message_length` instead of hardcoded limit
+  @override final maxLengthUnicodeCodePoints = kMaxMessageLengthCodePoints;
+
   int _nextQuoteAndReplyTag = 0;
   int _nextUploadTag = 0;
 
@@ -257,10 +289,10 @@ class ComposeContentController extends ComposeController<ContentValidationError>
       if (textNormalized.isEmpty)
         ContentValidationError.empty,
 
-      // normalized.length is the number of UTF-16 code units, while the server
-      // API expresses the max in Unicode code points. So this comparison will
-      // be conservative and may cut the user off shorter than necessary.
-      if (textNormalized.length > kMaxMessageLengthCodePoints)
+      if (
+        lengthUnicodeCodePointsIfLong != null
+        && lengthUnicodeCodePointsIfLong! > maxLengthUnicodeCodePoints
+      )
         ContentValidationError.tooLong,
 
       if (_quoteAndReplies.isNotEmpty)

test/widgets/app_test.dart

@@ -280,14 +280,14 @@ void main() {
       check(ZulipApp.ready).value.isFalse();
       await tester.pump();
       check(findSnackBarByText(message).evaluate()).isEmpty();
-      check(find.byType(AlertDialog).evaluate()).isEmpty();
+      checkNoErrorDialog(tester);
 
       check(ZulipApp.ready).value.isTrue();
       // After app startup, reportErrorToUserBriefly displays a SnackBar.
       reportErrorToUserBriefly(message, details: details);
       await tester.pumpAndSettle();
       check(findSnackBarByText(message).evaluate()).single;
-      check(find.byType(AlertDialog).evaluate()).isEmpty();
+      checkNoErrorDialog(tester);
 
       // Open the error details dialog.
       await tester.tap(find.text('Details'));

test/widgets/compose_box_test.dart

@@ -79,6 +79,7 @@ void main() {
     controller = tester.state<ComposeBoxState>(find.byType(ComposeBox)).controller;
   }
 
+  /// Set the topic input's text to [topic], using [WidgetTester.enterText].
   Future<void> enterTopic(WidgetTester tester, {
     required ChannelNarrow narrow,
     required String topic,
@@ -94,6 +95,23 @@ void main() {
       ..url.path.equals('/api/v1/users/me/${narrow.streamId}/topics');
   }
 
+  /// Set the content input's text to [content], using [WidgetTester.enterText].
+  Future<void> enterContent(WidgetTester tester, {
+    required ChannelNarrow narrow,
+    required String content,
+  }) async {
+    final contentInputFinder = find.byWidgetPredicate(
+      (widget) => widget is TextField && widget.controller is ComposeContentController);
+
+    await tester.enterText(contentInputFinder, content);
+  }
+
+  Future<void> tapSendButton(WidgetTester tester) async {
+    connection.prepare(json: SendMessageResult(id: 123).toJson());
+    await tester.tap(find.byIcon(ZulipIcons.send));
+    await tester.pump(Duration.zero);
+  }
+
   group('ComposeContentController', () {
     group('insertPadded', () {
       // Like `parseMarkedText` in test/model/autocomplete_test.dart,
@@ -196,6 +214,109 @@ void main() {
     });
   });
 
+  group('length validation', () {
+    final channel = eg.stream();
+
+    /// String where the number of Unicode code points is [n]
+    /// and the number of UTF-16 code units is higher.
+    String makeStringWithCodePoints(int n) {
+      assert(n >= 5);
+      const graphemeCluster = '👨‍👩‍👦';
+      assert(graphemeCluster.runes.length == 5);
+      assert(graphemeCluster.length == 8);
+      assert(graphemeCluster.characters.length == 1);
+
+      final result =
+        graphemeCluster * (n ~/ 5)
+        + 'a' * (n % 5);
+      assert(result.runes.length == n);
+
+      return result;
+    }
+
+    group('content', () {
+      void doTest(String description, {required String content, required bool expectError}) {
+        testWidgets(description, (tester) async {
+          TypingNotifier.debugEnable = false;
+          addTearDown(TypingNotifier.debugReset);
+
+          final narrow = ChannelNarrow(channel.streamId);
+          await prepareComposeBox(tester, narrow: narrow, streams: [channel]);
+          await enterTopic(tester, narrow: narrow, topic: 'some topic');
+          await enterContent(tester, narrow: narrow, content: content);
+
+          await tapSendButton(tester);
+          if (expectError) {
+            await tester.tap(find.byWidget(checkErrorDialog(tester,
+              expectedTitle: 'Message not sent',
+              expectedMessage: 'Message length shouldn\'t be greater than 10000 characters.')));
+          } else {
+            checkNoErrorDialog(tester);
+          }
+        });
+      }
+
+      doTest('too-long content is rejected',
+        content: makeStringWithCodePoints(kMaxMessageLengthCodePoints + 1), expectError: true);
+
+      doTest('max-length content not rejected',
+        content: makeStringWithCodePoints(kMaxMessageLengthCodePoints), expectError: false);
+
+      testWidgets('code points not counted unnecessarily', (tester) async {
+        TypingNotifier.debugEnable = false;
+        addTearDown(TypingNotifier.debugReset);
+
+        final narrow = ChannelNarrow(channel.streamId);
+        await prepareComposeBox(tester, narrow: narrow, streams: [channel]);
+        await enterTopic(tester, narrow: narrow, topic: 'some topic');
+        await enterContent(tester, narrow: narrow, content: 'a' * kMaxMessageLengthCodePoints);
+
+        check(controller!.content.lengthUnicodeCodePointsIfLong).isNull();
+      });
+    });
+
+    group('topic', () {
+      void doTest(String description, {required String topic, required bool expectError}) {
+        testWidgets(description, (tester) async {
+          TypingNotifier.debugEnable = false;
+          addTearDown(TypingNotifier.debugReset);
+
+          final narrow = ChannelNarrow(channel.streamId);
+          await prepareComposeBox(tester, narrow: narrow, streams: [channel]);
+          await enterTopic(tester, narrow: narrow, topic: topic);
+          await enterContent(tester, narrow: narrow, content: 'some content');
+
+          await tapSendButton(tester);
+          if (expectError) {
+            await tester.tap(find.byWidget(checkErrorDialog(tester,
+              expectedTitle: 'Message not sent',
+              expectedMessage: 'Topic length shouldn\'t be greater than 60 characters.')));
+          } else {
+            checkNoErrorDialog(tester);
+          }
+        });
+      }
+
+      doTest('too-long topic is rejected',
+        topic: makeStringWithCodePoints(kMaxTopicLengthCodePoints + 1), expectError: true);
+
+      doTest('max-length topic not rejected',
+        topic: makeStringWithCodePoints(kMaxTopicLengthCodePoints), expectError: false);
+
+      testWidgets('code points not counted unnecessarily', (tester) async {
+        TypingNotifier.debugEnable = false;
+        addTearDown(TypingNotifier.debugReset);
+
+        final narrow = ChannelNarrow(channel.streamId);
+        await prepareComposeBox(tester, narrow: narrow, streams: [channel]);
+        await enterTopic(tester, narrow: narrow, topic: 'a' * kMaxTopicLengthCodePoints);
+        await enterContent(tester, narrow: narrow, content: 'some content');
+
+        check((controller as StreamComposeBoxController).topic.lengthUnicodeCodePointsIfLong).isNull();
+      });
+    });
+  });
+
   group('ComposeBox textCapitalization', () {
     void checkComposeBoxTextFields(WidgetTester tester, {
       required bool expectTopicTextField,
@@ -426,8 +547,7 @@ void main() {
       await setupAndTapSend(tester, prepareResponse: (int messageId) {
         connection.prepare(json: SendMessageResult(id: messageId).toJson());
       });
-      final errorDialogs = tester.widgetList(find.byType(AlertDialog));
-      check(errorDialogs).isEmpty();
+      checkNoErrorDialog(tester);
     });
 
     testWidgets('ZulipApiException', (tester) async {
@@ -496,8 +616,7 @@ void main() {
         check(call.allowMultiple).equals(true);
         check(call.type).equals(FileType.media);
 
-        final errorDialogs = tester.widgetList(find.byType(AlertDialog));
-        check(errorDialogs).isEmpty();
+        checkNoErrorDialog(tester);
 
         check(controller!.content.text)
           .equals('see image: [Uploading image.jpg…]()\n\n');
@@ -556,8 +675,7 @@ void main() {
         check(call.source).equals(ImageSource.camera);
         check(call.requestFullMetadata).equals(false);
 
-        final errorDialogs = tester.widgetList(find.byType(AlertDialog));
-        check(errorDialogs).isEmpty();
+        checkNoErrorDialog(tester);
 
         check(controller!.content.text)
           .equals('see image: [Uploading image.jpg…]()\n\n');

test/widgets/dialog_checks.dart

@@ -1,4 +1,6 @@
+import 'package:checks/checks.dart';
 import 'package:flutter/material.dart';
+import 'package:flutter_checks/flutter_checks.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:zulip/widgets/dialog.dart';
 
@@ -26,6 +28,11 @@ Widget checkErrorDialog(WidgetTester tester, {
       matching: find.widgetWithText(TextButton, 'OK')));
 }
 
+// TODO(#996) update this to check for per-platform flavors of alert dialog
+void checkNoErrorDialog(WidgetTester tester) {
+  check(find.byType(AlertDialog)).findsNothing();
+}
+
 /// In a widget test, check that [showSuggestedActionDialog] was called
 /// with the right text.
 ///