fix(dart_frog_cli): run update check on sigint (#368)

Author: felangel

packages/dart_frog_cli/lib/src/command_runner.dart

@@ -1,3 +1,5 @@
+import 'dart:io' as io;
+
 import 'package:args/args.dart';
 import 'package:args/command_runner.dart';
 import 'package:dart_frog_cli/src/commands/commands.dart';
@@ -6,6 +8,9 @@ import 'package:dart_frog_cli/src/version.dart';
 import 'package:mason/mason.dart' hide packageVersion;
 import 'package:pub_updater/pub_updater.dart';
 
+/// Typedef for [io.exit].
+typedef Exit = dynamic Function(int exitCode);
+
 /// The package name.
 const packageName = 'dart_frog_cli';
 
@@ -24,8 +29,12 @@ class DartFrogCommandRunner extends CommandRunner<int> {
   DartFrogCommandRunner({
     Logger? logger,
     PubUpdater? pubUpdater,
+    io.ProcessSignal? sigint,
+    Exit? exit,
   })  : _logger = logger ?? Logger(),
         _pubUpdater = pubUpdater ?? PubUpdater(),
+        _sigint = sigint ?? io.ProcessSignal.sigint,
+        _exit = exit ?? io.exit,
         super(executableName, executableDescription) {
     argParser.addFlags();
     addCommand(BuildCommand(logger: _logger));
@@ -36,12 +45,16 @@ class DartFrogCommandRunner extends CommandRunner<int> {
 
   final Logger _logger;
   final PubUpdater _pubUpdater;
+  final io.ProcessSignal _sigint;
+  final Exit _exit;
 
   @override
   Future<int> run(Iterable<String> args) async {
     final argResults = parse(args);
     late final int exitCode;
 
+    _sigint.watch().listen(_onSigint);
+
     try {
       exitCode = await runCommand(argResults) ?? ExitCode.success.code;
     } catch (error) {
@@ -54,11 +67,25 @@ class DartFrogCommandRunner extends CommandRunner<int> {
     return exitCode;
   }
 
+  Future<void> _onSigint(io.ProcessSignal signal) async {
+    await _checkForUpdates();
+    _exit(0);
+  }
+
   Future<void> _checkForUpdates() async {
+    _logger.detail('[updater] checking for updates...');
     try {
       final latestVersion = await _pubUpdater.getLatestVersion(packageName);
+      _logger.detail('[updater] latest version is $latestVersion.');
+
       final isUpToDate = packageVersion == latestVersion;
+      if (isUpToDate) {
+        _logger.detail('[updater] no updates available.');
+        return;
+      }
+
       if (!isUpToDate) {
+        _logger.detail('[updater] update available.');
         final changelogLink = lightCyan.wrap(
           styleUnderlined.wrap(
             link(
@@ -77,7 +104,13 @@ ${lightYellow.wrap('Changelog:')} $changelogLink
 Run ${lightCyan.wrap('$executableName update')} to update''',
           );
       }
-    } catch (_) {}
+    } catch (error, stackTrace) {
+      _logger.detail(
+        '[updater] update check error.\n$error\n$stackTrace',
+      );
+    } finally {
+      _logger.detail('[updater] update check complete.');
+    }
   }
 
   @override

packages/dart_frog_cli/lib/src/commands/dev/dev.dart

@@ -213,14 +213,12 @@ class DevCommand extends DartFrogCommand {
     logger.detail('[process] killing process...');
     if (_isWindows) {
       logger.detail('[process] taskkill /F /T /PID ${process.pid}');
-      final result = await _runProcess(
-        'taskkill',
-        ['/F', '/T', '/PID', '${process.pid}'],
-      );
-      logger.detail('[process] exit(${result.exitCode})');
-      return _exit(result.exitCode);
+      await _runProcess('taskkill', ['/F', '/T', '/PID', '${process.pid}']);
+    } else {
+      logger.detail('[process] process.kill()...');
+      process.kill();
     }
-    process.kill();
+    logger.detail('[process] killing process complete.');
   }
 }
 

packages/dart_frog_cli/test/src/command_runner_test.dart

@@ -1,5 +1,6 @@
 // ignore_for_file: no_adjacent_strings_in_list
 import 'dart:async';
+import 'dart:io';
 
 import 'package:dart_frog_cli/src/command_runner.dart';
 import 'package:dart_frog_cli/src/version.dart';
@@ -12,6 +13,8 @@ class _MockLogger extends Mock implements Logger {}
 
 class _MockPubUpdater extends Mock implements PubUpdater {}
 
+class _MockProcessSignal extends Mock implements ProcessSignal {}
+
 const expectedUsage = [
   'A fast, minimalistic backend framework for Dart.\n'
       '\n'
@@ -51,19 +54,25 @@ void main() {
     late Logger logger;
     late PubUpdater pubUpdater;
     late DartFrogCommandRunner commandRunner;
+    late ProcessSignal sigint;
 
     setUp(() {
       printLogs = [];
       logger = _MockLogger();
       pubUpdater = _MockPubUpdater();
+      sigint = _MockProcessSignal();
 
       when(
         () => pubUpdater.getLatestVersion(any()),
       ).thenAnswer((_) async => packageVersion);
 
+      when(() => sigint.watch()).thenAnswer((_) => const Stream.empty());
+
       commandRunner = DartFrogCommandRunner(
         logger: logger,
         pubUpdater: pubUpdater,
+        exit: (_) {},
+        sigint: sigint,
       );
     });
 
@@ -73,6 +82,20 @@ void main() {
     });
 
     group('run', () {
+      test('checks for updates on sigint', () async {
+        final exitCalls = <int>[];
+        commandRunner = DartFrogCommandRunner(
+          logger: logger,
+          pubUpdater: pubUpdater,
+          exit: exitCalls.add,
+          sigint: sigint,
+        );
+        when(() => sigint.watch()).thenAnswer((_) => Stream.value(sigint));
+        await commandRunner.run(['--version']);
+        expect(exitCalls, equals([0]));
+        verify(() => pubUpdater.getLatestVersion(any())).called(2);
+      });
+
       test('prompts for update when newer version exists', () async {
         when(
           () => pubUpdater.getLatestVersion(any()),
@@ -136,9 +159,8 @@ void main() {
         test(
           'sets correct log level.',
           overridePrint(() async {
-            final logger = Logger();
-            await DartFrogCommandRunner(logger: logger).run(['--verbose']);
-            expect(logger.level, equals(Level.verbose));
+            await commandRunner.run(['--verbose']);
+            verify(() => logger.level = Level.verbose).called(1);
           }),
         );
 

packages/dart_frog_cli/test/src/commands/dev/dev_test.dart

@@ -67,6 +67,7 @@ void main() {
       process = _MockProcess();
       processResult = _MockProcessResult();
       sigint = _MockProcessSignal();
+      when(() => sigint.watch()).thenAnswer((_) => const Stream.empty());
       generatorTarget = _MockRestorableDirectoryGeneratorTarget();
       command = DevCommand(
         logger: logger,
@@ -531,7 +532,6 @@ void main() {
       const processId = 42;
       final generatorHooks = _MockGeneratorHooks();
       final processRunCalls = <List<String>>[];
-      int? exitCode;
       when(
         () => generatorHooks.preGen(
           vars: any(named: 'vars'),
@@ -554,7 +554,6 @@ void main() {
       when(() => process.stdout).thenAnswer((_) => const Stream.empty());
       when(() => process.stderr).thenAnswer((_) => const Stream.empty());
       when(() => process.pid).thenReturn(processId);
-      when(() => processResult.exitCode).thenReturn(ExitCode.success.code);
       when(
         () => directoryWatcher.events,
       ).thenAnswer((_) => StreamController<WatchEvent>().stream);
@@ -581,7 +580,6 @@ void main() {
       )..testArgResults = argResults;
       command.run().ignore();
       await untilCalled(() => process.pid);
-      expect(exitCode, equals(ExitCode.success.code));
       expect(
         processRunCalls,
         equals([