Swap xcodeproj_tests from MockProcessManager to FakeProcessManager (#56505)

2025-06-03 00:51:18 +00:00 · 2020-05-07 15:18:27 -07:00 · 2020-05-07 15:18:27 -07:00 · 4be791994f
commit 4be791994f
parent 13501af6e6
1 changed files with 180 additions and 132 deletions
--- a/packages/flutter_tools/test/general.shard/ios/xcodeproj_test.dart
+++ b/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')))
-      .thenReturn(ProcessResult(1, 0, '', ''));
-    expect(await xcodeProjectInterpreter.getBuildSettings('', ''), const <String, String>{});
+    ));
+    expect(await xcodeProjectInterpreter.getBuildSettings('', 'Runner'), const <String, String>{});
+    expect(fakeProcessManager.hasRemainingExpectations, isFalse);
  });

  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(
-      <String>[xcodebuild, '-list'],
-      environment: anyNamed('environment'),
-      workingDirectory: workingDirectory),
-    ).thenAnswer((_) {
-      return Future<ProcessResult>.value(ProcessResult(1, 0, '', ''));
-    });
+    fakeProcessManager.addCommand(const FakeCommand(
+      command: <String>[xcodebuild, '-list'],
+    ));
+
    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'],
-      environment: anyNamed('environment'),
-      workingDirectory: workingDirectory),
-    ).thenAnswer((_) {
-      return Future<ProcessResult>.value(ProcessResult(1, 66, '', stderr));
-    });
+
+    fakeProcessManager.addCommand(const FakeCommand(
+      command: <String>[xcodebuild, '-list'],
+      exitCode: 66,
+      stderr: 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