feat(dart_frog_cli): Add dart-vm-port option to dev command (#599)

easazade · erickzanardo · web-flow · commit 0cda2e800c18 · 2023-06-01T11:06:30.000-03:00
* feat(dart_frog_cli): Add dart-vm-port option to dev command

* test(dart_frog_cli): Add test for --dart-vm-port option of dev command

* docs(dart_frog_cli): Add doc for dev command --dart-vm-port option

* chore(dart_frog_cli): Apply requested changes

* test(dart_frog_cli): Add e2e tests for --dart-vm-port option

* test(dart_frog_cli): Update e2e tests for dev command --dart-vm-port option

* test(dart_frog_cli): Update tests for dev command

* chore(dart_frog_cli): Change dev command option --dart-vm-port to dart-vm-service-port

* test(dart_frog_cli): Revert back test tearDownAll since it fails on windows

---------

Co-authored-by: Erick &lt;erickzanardoo@gmail.com&gt;
diff --git a/docs/docs/overview.md b/docs/docs/overview.md
@@ -50,6 +50,12 @@ dart_frog dev
 By default port `8080` is used. A custom port can be used via the `--port` option.
 :::
 
+:::tip
+It's also possible to set a custom port for the dart vm service using `--dart-vm-service-port` option.
+
+This is required when trying to run `dart_frog dev` multiple times.
+:::
+
 :::caution
 Each release of the `dart_frog_cli` supports a specific version range of the `dart_frog` runtime. If the current version of the `dart_frog` runtime is incompatible with the installed `dart_frog_cli` version, an error will be reported and you will need to update your `dart_frog_cli` version or `dart_frog` version accordingly.
 :::
diff --git a/packages/dart_frog_cli/e2e/test/dev_test.dart b/packages/dart_frog_cli/e2e/test/dev_test.dart
@@ -47,4 +47,80 @@ void main() {
       expect(response.body, 'Route not found');
     });
   });
+
+  group('dart_frog dev when ran multiple times', () {
+    const projectName1 = 'example1';
+    const projectName2 = 'example2';
+
+    final tempDirectory = Directory.systemTemp.createTempSync();
+
+    Process? process1;
+    Process? process2;
+
+    setUp(() async {
+      await dartFrogCreate(projectName: projectName1, directory: tempDirectory);
+      await dartFrogCreate(projectName: projectName2, directory: tempDirectory);
+    });
+
+    tearDown(() async {
+      if (process1 != null) {
+        killDartFrogServer(process1!.pid).ignore();
+      }
+
+      if (process2 != null) {
+        killDartFrogServer(process2!.pid).ignore();
+      }
+    });
+
+    tearDownAll(() {
+      tempDirectory.delete(recursive: true).ignore();
+    });
+
+    test(
+      'running two different dart_frog dev command will fail '
+      'when different dart vm port is not set',
+      () async {
+        process1 = await dartFrogDev(
+          directory: Directory(path.join(tempDirectory.path, projectName1)),
+        );
+
+        try {
+          await dartFrogDev(
+            directory: Directory(path.join(tempDirectory.path, projectName2)),
+            exitOnError: false,
+          ).then((process) => process2 = process);
+
+          fail('exception not thrown');
+        } catch (e) {
+          expect(
+            e,
+            contains(
+              '''Could not start the VM service: localhost:8181 is already in use.''',
+            ),
+          );
+        }
+      },
+    );
+
+    test(
+      'runs two different dart_frog dev servers without any issues',
+      () async {
+        expect(
+          dartFrogDev(
+            directory: Directory(path.join(tempDirectory.path, projectName1)),
+          ).then((process) => process1 = process),
+          completes,
+        );
+
+        expect(
+          dartFrogDev(
+            directory: Directory(path.join(tempDirectory.path, projectName2)),
+            exitOnError: false,
+            args: ['--dart-vm-service-port', '9191'],
+          ).then((process) => process2 = process),
+          completes,
+        );
+      },
+    );
+  });
 }
diff --git a/packages/dart_frog_cli/e2e/test/helpers/dart_frog_dev.dart b/packages/dart_frog_cli/e2e/test/helpers/dart_frog_dev.dart
@@ -2,12 +2,16 @@ import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
-Future<Process> dartFrogDev({required Directory directory}) async {
+Future<Process> dartFrogDev({
+  required Directory directory,
+  List<String> args = const [],
+  bool exitOnError = true,
+}) async {
   final completer = Completer<Process>();
 
   final process = await Process.start(
     'dart_frog',
-    ['dev'],
+    ['dev', ...args],
     workingDirectory: directory.path,
     runInShell: true,
   );
@@ -29,7 +33,7 @@ Future<Process> dartFrogDev({required Directory directory}) async {
     stdoutSubscription.cancel();
     stderrSubscription.cancel();
     completer.completeError(message);
-    exit(1);
+    if (exitOnError) exit(1);
   });
 
   return completer.future;
diff --git a/packages/dart_frog_cli/lib/src/commands/dev/dev.dart b/packages/dart_frog_cli/lib/src/commands/dev/dev.dart
@@ -74,12 +74,18 @@ class DevCommand extends DartFrogCommand {
         _sigint = sigint ?? io.ProcessSignal.sigint,
         _startProcess = startProcess ?? io.Process.start,
         _generatorTarget = generatorTarget ?? _defaultGeneratorTarget {
-    argParser.addOption(
-      'port',
-      abbr: 'p',
-      defaultsTo: '8080',
-      help: 'Which port number the server should start on.',
-    );
+    argParser
+      ..addOption(
+        'port',
+        abbr: 'p',
+        defaultsTo: '8080',
+        help: 'Which port number the server should start on.',
+      )
+      ..addOption(
+        'dart-vm-service-port',
+        abbr: 'd',
+        help: 'Which port number the dart vm service should listen on.',
+      );
   }
 
   final void Function(io.Directory) _ensureRuntimeCompatibility;
@@ -111,6 +117,7 @@ class DevCommand extends DartFrogCommand {
     var reloading = false;
     var hotReloadEnabled = false;
     final port = io.Platform.environment['PORT'] ?? results['port'] as String;
+    final dartVmServicePort = results['dart-vm-service-port'] as String?;
     final target = _generatorTarget(logger);
     final generator = await _generator(dartFrogDevServerBundle);
 
@@ -140,13 +147,16 @@ class DevCommand extends DartFrogCommand {
       logger.detail('[codegen] reload complete.');
     }
 
+    final enableVmServiceFlag = '--enable-vm-service'
+        '${dartVmServicePort == null ? "" : "=$dartVmServicePort"}';
+
     Future<void> serve() async {
       logger.detail(
-        '''[process] dart --enable-vm-service ${path.join('.dart_frog', 'server.dart')}''',
+        '''[process] dart $enableVmServiceFlag ${path.join('.dart_frog', 'server.dart')}''',
       );
       final process = await _startProcess(
         'dart',
-        ['--enable-vm-service', path.join('.dart_frog', 'server.dart')],
+        [enableVmServiceFlag, path.join('.dart_frog', 'server.dart')],
         runInShell: true,
       );
 
diff --git a/packages/dart_frog_cli/test/src/commands/dev/dev_test.dart b/packages/dart_frog_cli/test/src/commands/dev/dev_test.dart
@@ -527,6 +527,125 @@ void main() {
       ).called(1);
     });
 
+    test('dart vm port can be specified using --dart-vm-service-port',
+        () async {
+      late List<String> receivedArgs;
+      when<dynamic>(() => argResults['dart-vm-service-port'])
+          .thenReturn('1372');
+      command.testArgResults = argResults;
+      final generatorHooks = _MockGeneratorHooks();
+      when(
+        () => generatorHooks.preGen(
+          vars: any(named: 'vars'),
+          workingDirectory: any(named: 'workingDirectory'),
+          onVarsChanged: any(named: 'onVarsChanged'),
+        ),
+      ).thenAnswer((invocation) async {
+        (invocation.namedArguments[const Symbol('onVarsChanged')] as void
+                Function(Map<String, dynamic> vars))
+            .call(<String, dynamic>{});
+      });
+      when(
+        () => generator.generate(
+          any(),
+          vars: any(named: 'vars'),
+          fileConflictResolution: FileConflictResolution.overwrite,
+        ),
+      ).thenAnswer((_) async => []);
+      when(() => generator.hooks).thenReturn(generatorHooks);
+      when(() => process.stdout).thenAnswer((_) => const Stream.empty());
+      when(() => process.stderr).thenAnswer((_) => const Stream.empty());
+      when(() => directoryWatcher.events)
+          .thenAnswer((_) => const Stream.empty());
+
+      command = DevCommand(
+        logger: logger,
+        ensureRuntimeCompatibility: (_) {},
+        directoryWatcher: (_) => directoryWatcher,
+        generator: (_) async => generator,
+        startProcess: (
+          String executable,
+          List<String> arguments, {
+          bool runInShell = false,
+        }) async {
+          receivedArgs = arguments;
+          return process;
+        },
+        sigint: sigint,
+      )..testArgResults = argResults;
+      final exitCode = await command.run();
+      expect(exitCode, equals(ExitCode.success.code));
+      expect(receivedArgs[0], equals('--enable-vm-service=1372'));
+      verify(
+        () => generatorHooks.preGen(
+          vars: <String, dynamic>{'port': '8080'},
+          workingDirectory: any(named: 'workingDirectory'),
+          onVarsChanged: any(named: 'onVarsChanged'),
+        ),
+      ).called(1);
+      verifyNever(process.kill);
+    });
+
+    test(
+      'when dart vm port not specified, --enable-vm-service option should '
+      'be called without any port number value',
+      () async {
+        late List<String> receivedArgs;
+        command.testArgResults = argResults;
+        final generatorHooks = _MockGeneratorHooks();
+        when(
+          () => generatorHooks.preGen(
+            vars: any(named: 'vars'),
+            workingDirectory: any(named: 'workingDirectory'),
+            onVarsChanged: any(named: 'onVarsChanged'),
+          ),
+        ).thenAnswer((invocation) async {
+          (invocation.namedArguments[const Symbol('onVarsChanged')] as void
+                  Function(Map<String, dynamic> vars))
+              .call(<String, dynamic>{});
+        });
+        when(
+          () => generator.generate(
+            any(),
+            vars: any(named: 'vars'),
+            fileConflictResolution: FileConflictResolution.overwrite,
+          ),
+        ).thenAnswer((_) async => []);
+        when(() => generator.hooks).thenReturn(generatorHooks);
+        when(() => process.stdout).thenAnswer((_) => const Stream.empty());
+        when(() => process.stderr).thenAnswer((_) => const Stream.empty());
+        when(() => directoryWatcher.events)
+            .thenAnswer((_) => const Stream.empty());
+
+        command = DevCommand(
+          logger: logger,
+          ensureRuntimeCompatibility: (_) {},
+          directoryWatcher: (_) => directoryWatcher,
+          generator: (_) async => generator,
+          startProcess: (
+            String executable,
+            List<String> arguments, {
+            bool runInShell = false,
+          }) async {
+            receivedArgs = arguments;
+            return process;
+          },
+          sigint: sigint,
+        )..testArgResults = argResults;
+        final exitCode = await command.run();
+        expect(exitCode, equals(ExitCode.success.code));
+        expect(receivedArgs[0], equals('--enable-vm-service'));
+        verify(
+          () => generatorHooks.preGen(
+            vars: <String, dynamic>{'port': '8080'},
+            workingDirectory: any(named: 'workingDirectory'),
+            onVarsChanged: any(named: 'onVarsChanged'),
+          ),
+        ).called(1);
+        verifyNever(process.kill);
+      },
+    );
+
     test('kills all child processes when sigint received on windows', () async {
       final generatorHooks = _MockGeneratorHooks();
       final processRunCalls = <List<String>>[];
