Swap xcodeproj_tests from MockProcessManager to FakeProcessManager (#56505)

packages/flutter_tools/test/general.shard/ios/xcodeproj_test.dart

@@ -26,19 +26,18 @@ import '../../src/pubspec_schema.dart';
 const String xcodebuild = '/usr/bin/xcodebuild';
 
 void main() {
+  group('MockProcessManager', () {
     mocks.MockProcessManager processManager;
     XcodeProjectInterpreter xcodeProjectInterpreter;
     FakePlatform platform;
-  FileSystem fileSystem;
     BufferLogger logger;
-  AnsiTerminal terminal;
 
     setUp(() {
       processManager = mocks.MockProcessManager();
       platform = FakePlatform(operatingSystem: 'macos');
-    fileSystem = MemoryFileSystem();
+      final FileSystem fileSystem = MemoryFileSystem();
       fileSystem.file(xcodebuild).createSync(recursive: true);
-    terminal = MockAnsiTerminal();
+      final AnsiTerminal terminal = MockAnsiTerminal();
       logger = BufferLogger.test(
         terminal: terminal
       );
@@ -52,6 +51,7 @@ void main() {
       );
     });
 
+    // Work around https://github.com/flutter/flutter/issues/56415.
     testWithoutContext('xcodebuild versionText returns null when xcodebuild is not installed', () {
       when(processManager.runSync(<String>[xcodebuild, '-version']))
         .thenThrow(const ProcessException(xcodebuild, <String>['-version']));
@@ -59,138 +59,13 @@ void main() {
       expect(xcodeProjectInterpreter.versionText, isNull);
     });
 
-  testWithoutContext('xcodebuild versionText returns null when xcodebuild is not fully installed', () {
-    when(processManager.runSync(<String>[xcodebuild, '-version'])).thenReturn(
-      ProcessResult(
-        0,
-        1,
-        "xcode-select: error: tool 'xcodebuild' requires Xcode, "
-        "but active developer directory '/Library/Developer/CommandLineTools' "
-        'is a command line tools instance',
-        '',
-      ),
-    );
-
-    expect(xcodeProjectInterpreter.versionText, isNull);
-  });
-
-  testWithoutContext('xcodebuild versionText returns formatted version text', () {
-    when(processManager.runSync(<String>[xcodebuild, '-version']))
-        .thenReturn(ProcessResult(1, 0, 'Xcode 8.3.3\nBuild version 8E3004b', ''));
-
-    expect(xcodeProjectInterpreter.versionText, 'Xcode 8.3.3, Build version 8E3004b');
-  });
-
-  testWithoutContext('xcodebuild versionText handles Xcode version string with unexpected format', () {
-    when(processManager.runSync(<String>[xcodebuild, '-version']))
-        .thenReturn(ProcessResult(1, 0, 'Xcode Ultra5000\nBuild version 8E3004b', ''));
-
-    expect(xcodeProjectInterpreter.versionText, 'Xcode Ultra5000, Build version 8E3004b');
-  });
-
-  testWithoutContext('xcodebuild majorVersion returns major version', () {
-    when(processManager.runSync(<String>[xcodebuild, '-version']))
-        .thenReturn(ProcessResult(1, 0, 'Xcode 11.4.1\nBuild version 11N111s', ''));
-
-    expect(xcodeProjectInterpreter.majorVersion, 11);
-  });
-
-  testWithoutContext('xcodebuild majorVersion is null when version has unexpected format', () {
-    when(processManager.runSync(<String>[xcodebuild, '-version']))
-        .thenReturn(ProcessResult(1, 0, 'Xcode Ultra5000\nBuild version 8E3004b', ''));
-
-    expect(xcodeProjectInterpreter.majorVersion, isNull);
-  });
-
-  testWithoutContext('xcodebuild minorVersion returns minor version', () {
-    when(processManager.runSync(<String>[xcodebuild, '-version']))
-        .thenReturn(ProcessResult(1, 0, 'Xcode 8.3.3\nBuild version 8E3004b', ''));
-
-    expect(xcodeProjectInterpreter.minorVersion, 3);
-  });
-
-  testWithoutContext('xcodebuild minorVersion returns 0 when minor version is unspecified', () {
-    when(processManager.runSync(<String>[xcodebuild, '-version']))
-        .thenReturn(ProcessResult(1, 0, 'Xcode 8\nBuild version 8E3004b', ''));
-
-    expect(xcodeProjectInterpreter.minorVersion, 0);
-  });
-
-  testWithoutContext('xcodebuild minorVersion is null when version has unexpected format', () {
-    when(processManager.runSync(<String>[xcodebuild, '-version']))
-        .thenReturn(ProcessResult(1, 0, 'Xcode Ultra5000\nBuild version 8E3004b', ''));
-
-    expect(xcodeProjectInterpreter.minorVersion, isNull);
-  });
-
-  testWithoutContext('xcodebuild isInstalled is false when not on MacOS', () {
-    final Platform platform = FakePlatform(operatingSystem: 'notMacOS');
-    xcodeProjectInterpreter = XcodeProjectInterpreter(
-      logger: logger,
-      fileSystem: fileSystem,
-      platform: platform,
-      processManager: processManager,
-      terminal: terminal,
-      usage: Usage.test(),
-    );
-    fileSystem.file(xcodebuild).deleteSync();
-
-    expect(xcodeProjectInterpreter.isInstalled, isFalse);
-  });
-
-  testWithoutContext('xcodebuild isInstalled is false when xcodebuild does not exist', () {
-    fileSystem.file(xcodebuild).deleteSync();
-
-    expect(xcodeProjectInterpreter.isInstalled, isFalse);
-  });
-
-  testWithoutContext('xcodebuild isInstalled is false when Xcode is not fully installed', () {
-    when(processManager.runSync(<String>[xcodebuild, '-version'])).thenReturn(
-      ProcessResult(
-        0,
-        1,
-        "xcode-select: error: tool 'xcodebuild' requires Xcode, "
-        "but active developer directory '/Library/Developer/CommandLineTools' "
-        'is a command line tools instance',
-        '',
-      ),
-    );
-
-    expect(xcodeProjectInterpreter.isInstalled, isFalse);
-  });
-
-  testWithoutContext('xcodebuild isInstalled is false when version has unexpected format', () {
-    when(processManager.runSync(<String>[xcodebuild, '-version']))
-        .thenReturn(ProcessResult(1, 0, 'Xcode Ultra5000\nBuild version 8E3004b', ''));
-
-    expect(xcodeProjectInterpreter.isInstalled, isFalse);
-  });
-
-  testWithoutContext('xcodebuild isInstalled is true when version has expected format', () {
-    when(processManager.runSync(<String>[xcodebuild, '-version']))
-        .thenReturn(ProcessResult(1, 0, 'Xcode 8.3.3\nBuild version 8E3004b', ''));
-
-    expect(xcodeProjectInterpreter.isInstalled, isTrue);
-  });
-
-  testWithoutContext('xcodebuild build settings is empty when xcodebuild failed to get the build settings', () async {
-    platform.environment = Map<String, String>.unmodifiable(<String, String>{});
-    when(processManager.runSync(
-              argThat(contains(xcodebuild)),
-              workingDirectory: anyNamed('workingDirectory'),
-              environment: anyNamed('environment')))
-        .thenReturn(ProcessResult(0, 1, '', ''));
-
-    expect(await xcodeProjectInterpreter.getBuildSettings('', ''), const <String, String>{});
-  });
-
     testWithoutContext('xcodebuild build settings flakes', () async {
       const Duration delay = Duration(seconds: 1);
       processManager.processFactory = mocks.flakyProcessFactory(
         flakes: 1,
         delay: delay + const Duration(seconds: 1),
       );
-    platform.environment = Map<String, String>.unmodifiable(<String, String>{});
+      platform.environment = const <String, String>{};
 
       expect(await xcodeProjectInterpreter.getBuildSettings(
         '', '', timeout: delay),
@@ -200,44 +75,217 @@ void main() {
       // The verbose logs should tell us something timed out.
       expect(logger.traceText, contains('timed out'));
     });
+  });
+
+  FakeProcessManager fakeProcessManager;
+  XcodeProjectInterpreter xcodeProjectInterpreter;
+  FakePlatform platform;
+  FileSystem fileSystem;
+  BufferLogger logger;
+  AnsiTerminal terminal;
+
+  setUp(() {
+    fakeProcessManager = FakeProcessManager.list(<FakeCommand>[]);
+    platform = FakePlatform(operatingSystem: 'macos');
+    fileSystem = MemoryFileSystem();
+    fileSystem.file(xcodebuild).createSync(recursive: true);
+    terminal = MockAnsiTerminal();
+    logger = BufferLogger.test(
+      terminal: terminal
+    );
+    xcodeProjectInterpreter = XcodeProjectInterpreter(
+      logger: logger,
+      fileSystem: fileSystem,
+      platform: platform,
+      processManager: fakeProcessManager,
+      terminal: terminal,
+      usage: null,
+    );
+  });
+
+  testWithoutContext('xcodebuild versionText returns null when xcodebuild is not fully installed', () {
+    fakeProcessManager.addCommand(const FakeCommand(
+      command: <String>[xcodebuild, '-version'],
+      stdout: "xcode-select: error: tool 'xcodebuild' requires Xcode, "
+        "but active developer directory '/Library/Developer/CommandLineTools' "
+        'is a command line tools instance',
+      exitCode: 1,
+    ));
+
+    expect(xcodeProjectInterpreter.versionText, isNull);
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
+  });
+
+  testWithoutContext('xcodebuild versionText returns formatted version text', () {
+    fakeProcessManager.addCommand(const FakeCommand(
+      command: <String>[xcodebuild, '-version'],
+      stdout: 'Xcode 8.3.3\nBuild version 8E3004b',
+    ));
+
+    expect(xcodeProjectInterpreter.versionText, 'Xcode 8.3.3, Build version 8E3004b');
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
+  });
+
+  testWithoutContext('xcodebuild versionText handles Xcode version string with unexpected format', () {
+    fakeProcessManager.addCommand(const FakeCommand(
+      command: <String>[xcodebuild, '-version'],
+      stdout: 'Xcode Ultra5000\nBuild version 8E3004b',
+    ));
+
+    expect(xcodeProjectInterpreter.versionText, 'Xcode Ultra5000, Build version 8E3004b');
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
+  });
+
+  testWithoutContext('xcodebuild majorVersion returns major version', () {
+    fakeProcessManager.addCommand(const FakeCommand(
+      command: <String>[xcodebuild, '-version'],
+      stdout: 'Xcode 11.4.1\nBuild version 11N111s',
+    ));
+
+    expect(xcodeProjectInterpreter.majorVersion, 11);
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
+  });
+
+  testWithoutContext('xcodebuild majorVersion is null when version has unexpected format', () {
+    fakeProcessManager.addCommand(const FakeCommand(
+      command: <String>[xcodebuild, '-version'],
+      stdout: 'Xcode Ultra5000\nBuild version 8E3004b',
+    ));
+    expect(xcodeProjectInterpreter.majorVersion, isNull);
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
+  });
+
+  testWithoutContext('xcodebuild minorVersion returns minor version', () {
+    fakeProcessManager.addCommand(const FakeCommand(
+      command: <String>[xcodebuild, '-version'],
+      stdout: 'Xcode 8.3.3\nBuild version 8E3004b',
+    ));
+    expect(xcodeProjectInterpreter.minorVersion, 3);
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
+  });
+
+  testWithoutContext('xcodebuild minorVersion returns 0 when minor version is unspecified', () {
+    fakeProcessManager.addCommand(const FakeCommand(
+      command: <String>[xcodebuild, '-version'],
+      stdout: 'Xcode 8\nBuild version 8E3004b',
+    ));
+    expect(xcodeProjectInterpreter.minorVersion, 0);
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
+  });
+
+  testWithoutContext('xcodebuild minorVersion is null when version has unexpected format', () {
+    fakeProcessManager.addCommand(const FakeCommand(
+      command: <String>[xcodebuild, '-version'],
+      stdout: 'Xcode Ultra5000\nBuild version 8E3004b',
+    ));
+    expect(xcodeProjectInterpreter.minorVersion, isNull);
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
+  });
+
+  testWithoutContext('xcodebuild isInstalled is false when not on MacOS', () {
+    final Platform platform = FakePlatform(operatingSystem: 'notMacOS');
+    xcodeProjectInterpreter = XcodeProjectInterpreter(
+      logger: logger,
+      fileSystem: fileSystem,
+      platform: platform,
+      processManager: fakeProcessManager,
+      terminal: terminal,
+      usage: Usage.test(),
+    );
+    fileSystem.file(xcodebuild).deleteSync();
+
+    expect(xcodeProjectInterpreter.isInstalled, isFalse);
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
+  });
+
+  testWithoutContext('xcodebuild isInstalled is false when xcodebuild does not exist', () {
+    fileSystem.file(xcodebuild).deleteSync();
+
+    expect(xcodeProjectInterpreter.isInstalled, isFalse);
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
+  });
+
+  testWithoutContext('xcodebuild isInstalled is false when Xcode is not fully installed', () {
+    fakeProcessManager.addCommand(const FakeCommand(
+      command: <String>[xcodebuild, '-version'],
+      stdout: "xcode-select: error: tool 'xcodebuild' requires Xcode, "
+        "but active developer directory '/Library/Developer/CommandLineTools' "
+        'is a command line tools instance',
+      exitCode: 1,
+    ));
+
+    expect(xcodeProjectInterpreter.isInstalled, isFalse);
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
+  });
+
+  testWithoutContext('xcodebuild isInstalled is false when version has unexpected format', () {
+    fakeProcessManager.addCommand(const FakeCommand(
+      command: <String>[xcodebuild, '-version'],
+      stdout: 'Xcode Ultra5000\nBuild version 8E3004b',
+    ));
+
+    expect(xcodeProjectInterpreter.isInstalled, isFalse);
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
+  });
+
+  testWithoutContext('xcodebuild isInstalled is true when version has expected format', () {
+    fakeProcessManager.addCommand(const FakeCommand(
+      command: <String>[xcodebuild, '-version'],
+      stdout: 'Xcode 8.3.3\nBuild version 8E3004b',
+    ));
+
+    expect(xcodeProjectInterpreter.isInstalled, isTrue);
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
+  });
+
+  testWithoutContext('xcodebuild build settings is empty when xcodebuild failed to get the build settings', () async {
+    platform.environment = const <String, String>{};
+
+    fakeProcessManager.addCommand(const FakeCommand(
+      command: <String>[
+        '/usr/bin/xcodebuild',
+        '-project',
+        '/',
+        '-target',
+        'Runner',
+        '-showBuildSettings'
+      ],
+      exitCode: 1,
+    ));
+
+    expect(await xcodeProjectInterpreter.getBuildSettings('', 'Runner'), const <String, String>{});
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
+  });
 
   testWithoutContext('xcodebuild build settings contains Flutter Xcode environment variables', () async {
-    platform.environment = Map<String, String>.unmodifiable(<String, String>{
+    platform.environment = const <String, String>{
       'FLUTTER_XCODE_CODE_SIGN_STYLE': 'Manual',
       'FLUTTER_XCODE_ARCHS': 'arm64'
-    });
+    };
-    when(processManager.runSync(<String>[
+    fakeProcessManager.addCommand(FakeCommand(
+      command: <String>[
         xcodebuild,
         '-project',
-      platform.pathSeparator,
+        fileSystem.path.separator,
         '-target',
-      '',
+        'Runner',
         '-showBuildSettings',
         'CODE_SIGN_STYLE=Manual',
         'ARCHS=arm64'
       ],
-      workingDirectory: anyNamed('workingDirectory'),
+    ));
-      environment: anyNamed('environment')))
+    expect(await xcodeProjectInterpreter.getBuildSettings('', 'Runner'), const <String, String>{});
-      .thenReturn(ProcessResult(1, 0, '', ''));
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
-    expect(await xcodeProjectInterpreter.getBuildSettings('', ''), const <String, String>{});
   });
 
   testWithoutContext('xcodebuild clean contains Flutter Xcode environment variables', () async {
-    platform.environment = Map<String, String>.unmodifiable(<String, String>{
+    platform.environment = const <String, String>{
       'FLUTTER_XCODE_CODE_SIGN_STYLE': 'Manual',
       'FLUTTER_XCODE_ARCHS': 'arm64'
-    });
+    };
-    when(processManager.run(
-      any,
-      workingDirectory: anyNamed('workingDirectory')))
-      .thenAnswer((_) => Future<ProcessResult>.value(ProcessResult(1, 0, '', '')));
-    await xcodeProjectInterpreter.cleanWorkspace('workspace_path', 'Runner');
-    final List<dynamic> captured = verify(processManager.run(
-      captureAny,
-      workingDirectory: anyNamed('workingDirectory'),
-      environment: anyNamed('environment'))).captured;
 
-    expect(captured.first, <String>[
+    fakeProcessManager.addCommand(const FakeCommand(
+      command: <String>[
         xcodebuild,
         '-workspace',
         'workspace_path',
@@ -247,45 +295,47 @@ void main() {
         'clean',
         'CODE_SIGN_STYLE=Manual',
         'ARCHS=arm64'
-    ]);
+      ],
+    ));
+
+    await xcodeProjectInterpreter.cleanWorkspace('workspace_path', 'Runner');
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
   });
 
   testWithoutContext('xcodebuild -list getInfo returns something when xcodebuild -list succeeds', () async {
     const String workingDirectory = '/';
-    when(processManager.run(
+    fakeProcessManager.addCommand(const FakeCommand(
-      <String>[xcodebuild, '-list'],
+      command: <String>[xcodebuild, '-list'],
-      environment: anyNamed('environment'),
+    ));
-      workingDirectory: workingDirectory),
+
-    ).thenAnswer((_) {
-      return Future<ProcessResult>.value(ProcessResult(1, 0, '', ''));
-    });
     final XcodeProjectInterpreter xcodeProjectInterpreter = XcodeProjectInterpreter(
       logger: logger,
       fileSystem: fileSystem,
       platform: platform,
-      processManager: processManager,
+      processManager: fakeProcessManager,
       terminal: terminal,
       usage: Usage.test(),
     );
 
     expect(await xcodeProjectInterpreter.getInfo(workingDirectory), isNotNull);
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
   });
 
   testWithoutContext('xcodebuild -list getInfo throws a tool exit when it is unable to find a project', () async {
     const String workingDirectory = '/';
     const String stderr = 'Useful Xcode failure message about missing project.';
-    when(processManager.run(
+
-      <String>[xcodebuild, '-list'],
+    fakeProcessManager.addCommand(const FakeCommand(
-      environment: anyNamed('environment'),
+      command: <String>[xcodebuild, '-list'],
-      workingDirectory: workingDirectory),
+      exitCode: 66,
-    ).thenAnswer((_) {
+      stderr: stderr,
-      return Future<ProcessResult>.value(ProcessResult(1, 66, '', stderr));
+    ));
-    });
+
     final XcodeProjectInterpreter xcodeProjectInterpreter = XcodeProjectInterpreter(
       logger: logger,
       fileSystem: fileSystem,
       platform: platform,
-      processManager: processManager,
+      processManager: fakeProcessManager,
       terminal: terminal,
       usage: Usage.test(),
     );
@@ -293,6 +343,7 @@ void main() {
     expect(
         () async => await xcodeProjectInterpreter.getInfo(workingDirectory),
         throwsToolExit(message: stderr));
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
   });
 
   testWithoutContext('Xcode project properties from default project can be parsed', () {
@@ -427,12 +478,12 @@ Information about project "Runner":
     });
 
     testWithoutContext('environment variables as Xcode build settings', () {
-      platform.environment = Map<String, String>.unmodifiable(<String, String>{
+      platform.environment = const <String, String>{
         'Ignored': 'Bogus',
         'FLUTTER_NOT_XCODE': 'Bogus',
         'FLUTTER_XCODE_CODE_SIGN_STYLE': 'Manual',
         'FLUTTER_XCODE_ARCHS': 'arm64'
-      });
+      };
       final List<String> environmentVariablesAsBuildSettings = environmentVariablesAsXcodeBuildSettings(platform);
       expect(environmentVariablesAsBuildSettings, <String>['CODE_SIGN_STYLE=Manual', 'ARCHS=arm64']);
     });
@@ -440,14 +491,12 @@ Information about project "Runner":
 
   group('updateGeneratedXcodeProperties', () {
     MockLocalEngineArtifacts mockArtifacts;
-    MockProcessManager mockProcessManager;
     FakePlatform macOS;
     FileSystem fs;
 
     setUp(() {
       fs = MemoryFileSystem();
       mockArtifacts = MockLocalEngineArtifacts();
-      mockProcessManager = MockProcessManager();
       macOS = FakePlatform(operatingSystem: 'macos');
       fs.file(xcodebuild).createSync(recursive: true);
     });
@@ -457,7 +506,7 @@ Information about project "Runner":
         Artifacts: () => mockArtifacts,
         Platform: () => macOS,
         FileSystem: () => fs,
-        ProcessManager: () => mockProcessManager,
+        ProcessManager: () => FakeProcessManager.any(),
       });
     }
 
@@ -805,7 +854,6 @@ flutter:
 }
 
 class MockLocalEngineArtifacts extends Mock implements LocalEngineArtifacts {}
-class MockProcessManager extends Mock implements ProcessManager {}
 class MockXcodeProjectInterpreter extends Mock implements XcodeProjectInterpreter {}
 class MockAnsiTerminal extends Mock implements AnsiTerminal {
   @override