actions test: Cover PlatformActions.launchUrl

Author: chrisbobbe

lib/widgets/actions.dart

@@ -283,7 +283,6 @@ abstract final class PlatformActions {
   }
 
   /// Opens a URL with [ZulipBinding.launchUrl], with an error dialog on failure.
-  // TODO widget tests
   static Future<void> launchUrl(BuildContext context, Uri url) async {
     final globalSettings = GlobalStoreWidget.settingsOf(context);
 

test/model/binding.dart

@@ -161,11 +161,21 @@ class TestZulipBinding extends ZulipBinding {
 
   /// The value that `ZulipBinding.instance.launchUrl()` should return.
   ///
-  /// See also [takeLaunchUrlCalls].
+  /// See also:
+  ///   * [launchUrlException]
+  ///   * [takeLaunchUrlCalls]
   bool launchUrlResult = true;
 
+  /// The [PlatformException] that `ZulipBinding.instance.launchUrl()` should throw.
+  ///
+  /// See also:
+  ///   * [launchUrlResult]
+  ///   * [takeLaunchUrlCalls]
+  PlatformException? launchUrlException;
+
   void _resetLaunchUrl() {
     launchUrlResult = true;
+    launchUrlException = null;
     _launchUrlCalls = null;
   }
 
@@ -189,6 +199,22 @@ class TestZulipBinding extends ZulipBinding {
     url_launcher.LaunchMode mode = url_launcher.LaunchMode.platformDefault,
   }) async {
     (_launchUrlCalls ??= []).add((url: url, mode: mode));
+
+    if (!launchUrlResult && launchUrlException != null) {
+      throw FlutterError.fromParts([
+        ErrorSummary(
+          'TestZulipBinding.launchUrl called '
+          'with launchUrlResult: false and non-null launchUrlException'),
+        ErrorHint(
+          'Tests should either set launchUrlResult or launchUrlException, '
+          'but not both.'),
+      ]);
+    }
+
+    if (launchUrlException != null) {
+      throw launchUrlException!;
+    }
+
     return launchUrlResult;
   }
 

test/model/settings_test.dart

@@ -14,6 +14,9 @@ void main() {
   final nonHttpLink = Uri.parse('mailto:[email protected]');
 
   group('getUrlLaunchMode', () {
+    // See also test/widgets/actions_test.dart, where we test that the setting
+    // is actually used when we open links, with PlatformActions.launchUrl.
+
     testAndroidIos('globalSettings.browserPreference is null; use our per-platform defaults for HTTP links', () {
       final globalSettings = eg.globalStore(globalSettings: GlobalSettingsData(
         browserPreference: null)).settings;

test/widgets/actions_test.dart

@@ -1,6 +1,7 @@
 import 'dart:convert';
 
 import 'package:checks/checks.dart';
+import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_test/flutter_test.dart';
@@ -12,6 +13,7 @@ import 'package:zulip/api/route/messages.dart';
 import 'package:zulip/model/binding.dart';
 import 'package:zulip/model/localizations.dart';
 import 'package:zulip/model/narrow.dart';
+import 'package:zulip/model/settings.dart';
 import 'package:zulip/model/store.dart';
 import 'package:zulip/widgets/actions.dart';
 
@@ -414,5 +416,95 @@ void main() {
         await checkSnackBar(tester, expected: true);
       });
     });
+
+    group('launchUrl', () {
+      Future<void> call(WidgetTester tester, {required Uri url}) async {
+        await tester.pumpWidget(TestZulipApp(
+          child: Builder(builder: (context) => Center(
+            child: ElevatedButton(
+              onPressed: () async {
+                await PlatformActions.launchUrl(context, url);
+              },
+              child: const Text('link'))))));
+        await tester.pump();
+        await tester.tap(find.text('link'));
+        await tester.pump(Duration.zero);
+      }
+
+      final httpUrl = Uri.parse('https://chat.example');
+      final nonHttpUrl = Uri.parse('mailto:chat@example');
+
+      Future<void> runAndCheckSuccess(WidgetTester tester, {
+        required Uri url,
+        required UrlLaunchMode expectedModeAndroid,
+        required UrlLaunchMode expectedModeIos,
+      }) async {
+        await call(tester, url: url);
+
+        final expectedMode = switch (defaultTargetPlatform) {
+          TargetPlatform.android => expectedModeAndroid,
+          TargetPlatform.iOS =>     expectedModeIos,
+          _ => throw StateError('attempted to test with $defaultTargetPlatform'),
+        };
+        check(testBinding.takeLaunchUrlCalls()).single
+          .equals((url: url, mode: expectedMode));
+      }
+
+      final androidIosVariant = TargetPlatformVariant({TargetPlatform.iOS, TargetPlatform.android});
+
+      testWidgets('globalSettings.browserPreference is null; use our per-platform defaults for HTTP links', (tester) async {
+        await testBinding.globalStore.settings.setBrowserPreference(null);
+        await runAndCheckSuccess(tester,
+          url: httpUrl,
+          expectedModeAndroid: UrlLaunchMode.inAppBrowserView,
+          expectedModeIos: UrlLaunchMode.externalApplication);
+      }, variant: androidIosVariant);
+
+      testWidgets('globalSettings.browserPreference is null; use our per-platform defaults for non-HTTP links', (tester) async {
+        await testBinding.globalStore.settings.setBrowserPreference(null);
+        await runAndCheckSuccess(tester,
+          url: nonHttpUrl,
+          expectedModeAndroid: UrlLaunchMode.platformDefault,
+          expectedModeIos: UrlLaunchMode.externalApplication);
+      }, variant: androidIosVariant);
+
+      testWidgets('globalSettings.browserPreference is inApp; follow the user preference for http links', (tester) async {
+        await testBinding.globalStore.settings.setBrowserPreference(BrowserPreference.inApp);
+        await runAndCheckSuccess(tester,
+          url: httpUrl,
+          expectedModeAndroid: UrlLaunchMode.inAppBrowserView,
+          expectedModeIos: UrlLaunchMode.inAppBrowserView);
+      }, variant: androidIosVariant);
+
+      testWidgets('globalSettings.browserPreference is inApp; use platform default for non-http links', (tester) async {
+        await testBinding.globalStore.settings.setBrowserPreference(BrowserPreference.inApp);
+        await runAndCheckSuccess(tester,
+          url: nonHttpUrl,
+          expectedModeAndroid: UrlLaunchMode.platformDefault,
+          expectedModeIos: UrlLaunchMode.platformDefault);
+      }, variant: androidIosVariant);
+
+      testWidgets('globalSettings.browserPreference is external; follow the user preference', (tester) async {
+        await testBinding.globalStore.settings.setBrowserPreference(BrowserPreference.external);
+        await runAndCheckSuccess(tester,
+          url: httpUrl,
+          expectedModeAndroid: UrlLaunchMode.externalApplication,
+          expectedModeIos: UrlLaunchMode.externalApplication);
+      }, variant: androidIosVariant);
+
+      testWidgets('ZulipBinding.launchUrl returns false', (tester) async {
+        testBinding.launchUrlResult = false;
+        await call(tester, url: httpUrl);
+        checkErrorDialog(tester, expectedTitle: 'Unable to open link');
+      }, variant: androidIosVariant);
+
+      testWidgets('ZulipBinding.launchUrl throws PlatformException', (tester) async {
+        testBinding.launchUrlException = PlatformException(code: 'code', message: 'error message');
+        await call(tester, url: httpUrl);
+        checkErrorDialog(tester,
+          expectedTitle: 'Unable to open link',
+          expectedMessage: 'Link could not be opened: ${httpUrl.toString()}\n\nerror message');
+      }, variant: androidIosVariant);
+    });
   });
 }