feat: add verify-only flag to update command (#817)

Author: jsgalarraga

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

@@ -1,6 +1,6 @@
 import 'dart:io';
 
-import 'package:args/command_runner.dart';
+import 'package:dart_frog_cli/src/command.dart';
 import 'package:dart_frog_cli/src/command_runner.dart';
 import 'package:dart_frog_cli/src/version.dart';
 import 'package:mason/mason.dart' hide packageVersion;
@@ -9,13 +9,19 @@ import 'package:pub_updater/pub_updater.dart';
 /// {@template update_command}
 /// `dart_frog update` command which updates the dart_frog_cli.
 /// {@endtemplate}
-class UpdateCommand extends Command<int> {
+class UpdateCommand extends DartFrogCommand {
   /// {@macro update_command}
   UpdateCommand({
     required Logger logger,
     PubUpdater? pubUpdater,
   })  : _logger = logger,
-        _pubUpdater = pubUpdater ?? PubUpdater();
+        _pubUpdater = pubUpdater ?? PubUpdater() {
+    argParser.addFlag(
+      'verify-only',
+      help: 'Check if an update is available, without committing to update.',
+      negatable: false,
+    );
+  }
 
   final Logger _logger;
   final PubUpdater _pubUpdater;
@@ -26,8 +32,13 @@ class UpdateCommand extends Command<int> {
   @override
   String get name => 'update';
 
+  @override
+  final String invocation = 'dart_frog update';
+
   @override
   Future<int> run() async {
+    final verifyOnly = results['verify-only'] as bool;
+
     final updateCheckProgress = _logger.progress('Checking for updates');
     late final String latestVersion;
     try {
@@ -43,6 +54,13 @@ class UpdateCommand extends Command<int> {
     if (isUpToDate) {
       _logger.info('$packageName is already at the latest version.');
       return ExitCode.success.code;
+    } else if (verifyOnly) {
+      _logger
+        ..info('A new version of $packageName is available.\n')
+        ..info(styleBold.wrap('The latest version: $latestVersion'))
+        ..info('Your current version: $packageVersion\n')
+        ..info('To update now, run "$executableName update".');
+      return ExitCode.success.code;
     }
 
     final updateProgress = _logger.progress('Updating to $latestVersion');

packages/dart_frog_cli/test/src/commands/update/update_test.dart

@@ -1,5 +1,8 @@
+// ignore_for_file: no_adjacent_strings_in_list
+
 import 'dart:io';
 
+import 'package:args/args.dart';
 import 'package:dart_frog_cli/src/command_runner.dart';
 import 'package:dart_frog_cli/src/commands/update/update.dart';
 import 'package:dart_frog_cli/src/version.dart';
@@ -8,11 +11,28 @@ import 'package:mocktail/mocktail.dart';
 import 'package:pub_updater/pub_updater.dart';
 import 'package:test/test.dart';
 
-class MockLogger extends Mock implements Logger {}
+import '../../../helpers/helpers.dart';
+
+class _MockLogger extends Mock implements Logger {}
+
+class _MockPubUpdater extends Mock implements PubUpdater {}
+
+class _MockProgress extends Mock implements Progress {}
 
-class MockPubUpdater extends Mock implements PubUpdater {}
+class _MockArgResults extends Mock implements ArgResults {}
 
-class MockProgress extends Mock implements Progress {}
+class _MockProcessSignal extends Mock implements ProcessSignal {}
+
+const expectedUsage = [
+  'Update the Dart Frog CLI.\n'
+      '\n'
+      'Usage: dart_frog update\n'
+      '-h, --help           Print this usage information.\n'
+      '    --verify-only    Check if an update is available, without '
+      'committing to update.\n'
+      '\n'
+      'Run "dart_frog help" to see global options.'
+];
 
 void main() {
   const latestVersion = '0.0.0';
@@ -24,12 +44,15 @@ void main() {
     late Logger logger;
     late PubUpdater pubUpdater;
     late UpdateCommand command;
+    late ArgResults argResults;
+    late DartFrogCommandRunner commandRunner;
 
     setUp(() {
-      logger = MockLogger();
-      pubUpdater = MockPubUpdater();
+      logger = _MockLogger();
+      pubUpdater = _MockPubUpdater();
+      argResults = _MockArgResults();
 
-      when(() => logger.progress(any())).thenReturn(MockProgress());
+      when(() => logger.progress(any())).thenReturn(_MockProgress());
       when(
         () => pubUpdater.getLatestVersion(any()),
       ).thenAnswer((_) async => packageVersion);
@@ -40,9 +63,32 @@ void main() {
         ),
       ).thenAnswer((_) => Future.value(processResult));
 
-      command = UpdateCommand(logger: logger, pubUpdater: pubUpdater);
+      when(() => argResults['verify-only']).thenReturn(false);
+
+      command = UpdateCommand(logger: logger, pubUpdater: pubUpdater)
+        ..testArgResults = argResults;
+
+      final sigint = _MockProcessSignal();
+      when(sigint.watch).thenAnswer((_) => const Stream.empty());
+
+      commandRunner = DartFrogCommandRunner(
+        logger: logger,
+        pubUpdater: _MockPubUpdater(),
+        exit: (_) {},
+        sigint: sigint,
+      );
     });
 
+    test(
+      'usage shows help text',
+      overridePrint((printLogs) async {
+        final result = await commandRunner.run(['update', '--help']);
+
+        expect(result, equals(ExitCode.success.code));
+        expect(printLogs, equals(expectedUsage));
+      }),
+    );
+
     test('handles pub latest version query errors', () async {
       when(
         () => pubUpdater.getLatestVersion(any()),
@@ -59,6 +105,56 @@ void main() {
       );
     });
 
+    group('--verify-only', () {
+      test(
+        'logs latest available version',
+        () async {
+          when(
+            () => pubUpdater.getLatestVersion(any()),
+          ).thenAnswer((_) async => latestVersion);
+          when(() => argResults['verify-only']).thenReturn(true);
+
+          final result = await command.run();
+
+          expect(result, equals(ExitCode.success.code));
+          verify(
+            () => logger.info('A new version of $packageName is available.\n'),
+          ).called(1);
+          verify(
+            () => logger.info(
+              styleBold.wrap('The latest version: $latestVersion'),
+            ),
+          ).called(1);
+          verify(
+            () => logger.info('Your current version: $packageVersion\n'),
+          ).called(1);
+          verify(
+            () => logger.info('To update now, run "$executableName update".'),
+          ).called(1);
+        },
+      );
+
+      test(
+        'does not update',
+        () async {
+          when(
+            () => pubUpdater.getLatestVersion(any()),
+          ).thenAnswer((_) async => latestVersion);
+          when(() => argResults['verify-only']).thenReturn(true);
+
+          final result = await command.run();
+
+          expect(result, equals(ExitCode.success.code));
+          verifyNever(
+            () => pubUpdater.update(
+              packageName: any(named: 'packageName'),
+              versionConstraint: any(named: 'versionConstraint'),
+            ),
+          );
+        },
+      );
+    });
+
     test('handles pub update errors', () async {
       when(
         () => pubUpdater.getLatestVersion(any()),
@@ -119,7 +215,7 @@ void main() {
         ),
       ).thenAnswer((_) => Future.value(processResult));
 
-      when(() => logger.progress(any())).thenReturn(MockProgress());
+      when(() => logger.progress(any())).thenReturn(_MockProgress());
       final result = await command.run();
       expect(result, equals(ExitCode.success.code));
       verify(() => logger.progress('Checking for updates')).called(1);
@@ -136,7 +232,7 @@ void main() {
       when(
         () => pubUpdater.getLatestVersion(any()),
       ).thenAnswer((_) async => packageVersion);
-      when(() => logger.progress(any())).thenReturn(MockProgress());
+      when(() => logger.progress(any())).thenReturn(_MockProgress());
       final result = await command.run();
       expect(result, equals(ExitCode.success.code));
       verify(