flutter/packages/flutter_tools/test/commands.shard/hermetic/build_aar_test.dart

// Copyright 2014 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'package:file/memory.dart';
import 'package:flutter_tools/src/artifacts.dart';
import 'package:flutter_tools/src/base/file_system.dart';
import 'package:flutter_tools/src/base/logger.dart';
import 'package:flutter_tools/src/base/platform.dart';
import 'package:flutter_tools/src/base/process.dart';
import 'package:flutter_tools/src/build_system/build_system.dart';
import 'package:flutter_tools/src/cache.dart';
import 'package:flutter_tools/src/commands/build.dart';
import 'package:unified_analytics/unified_analytics.dart';

import '../../src/common.dart';
import '../../src/context.dart';
import '../../src/fake_process_manager.dart';
import '../../src/fakes.dart';
import '../../src/test_build_system.dart';
import '../../src/test_flutter_command_runner.dart';

void main() {
  late BufferLogger logger;
  late MemoryFileSystem fs;
  late Artifacts artifacts;
  late FakeProcessManager processManager;
  late Platform platform;
  late Cache cache;
  late FakeAnalytics fakeAnalytics;

  setUpAll(() {
    Cache.disableLocking();
  });

  setUp(() {
    fs = MemoryFileSystem.test();
    final Directory flutterRoot = fs.directory('flutter');
    Cache.flutterRoot = flutterRoot.path;
    artifacts = Artifacts.test(fileSystem: fs);
    logger = BufferLogger.test();
    platform = FakePlatform(environment: const <String, String>{'PATH': ''});
    processManager = FakeProcessManager.empty();
    cache = Cache.test(
      rootOverride: flutterRoot,
      logger: logger,
      processManager: processManager,
    );
    fakeAnalytics = getInitializedFakeAnalyticsInstance(
      fs: fs,
      fakeFlutterVersion: FakeFlutterVersion(),
    );
  });

  testUsingContext('will not build an AAR for a plugin', () async {
    fs.file('pubspec.yaml').writeAsStringSync('''
name: foo_bar

flutter:
  plugin:
    platforms:
      some_platform:
        null
''');

    final BuildCommand command = BuildCommand(
      androidSdk: FakeAndroidSdk(),
      artifacts: artifacts,
      buildSystem: TestBuildSystem.all(BuildResult(success: true)),
      fileSystem: fs,
      logger: logger,
      osUtils: FakeOperatingSystemUtils(),
      processUtils: ProcessUtils(
        logger: logger,
        processManager: processManager,
      ),
    );

    expect(
      createTestCommandRunner(command).run(const <String>['build', 'aar', '--no-pub']),
      throwsToolExit(message: 'AARs can only be built from modules'),
    );
    expect(processManager, hasNoRemainingExpectations);
  }, overrides: <Type, Generator>{
    Cache: () => cache,
    FileSystem: () => fs,
    Platform: () => platform,
    ProcessManager: () => processManager,
  });

  testUsingContext('will build an AAR for a module', () async {
    fs.file('pubspec.yaml').writeAsStringSync('''
name: foo_bar

flutter:
  module:
    foo: bar
''');
    final Directory dotAndroidDir = fs.directory('.android')..createSync(recursive: true);
    dotAndroidDir.childFile('gradlew').createSync();

    processManager.addCommands(<FakeCommand>[
      const FakeCommand(command: <String>['chmod', '755', 'flutter/bin/cache/artifacts']),
      const FakeCommand(command: <String>['which', 'java']),
      ...<String>['Debug', 'Profile', 'Release'].map((String buildMode) => FakeCommand(
        command: <Pattern>[
          '/.android/gradlew',
          '-I=/flutter/packages/flutter_tools/gradle/aar_init_script.gradle',
          ...List<RegExp>.filled(4, RegExp(r'-P[a-zA-Z-]+=.*')),
          '-q',
          ...List<RegExp>.filled(5, RegExp(r'-P[a-zA-Z-]+=.*')),
          'assembleAar$buildMode',
        ],
        onRun: (_) => fs.directory('/build/host/outputs/repo').createSync(recursive: true),
      )),
    ]);

    cache.getArtifactDirectory('gradle_wrapper').createSync(recursive: true);

    final BuildCommand command = BuildCommand(
      androidSdk: FakeAndroidSdk(),
      artifacts: artifacts,
      buildSystem: TestBuildSystem.all(BuildResult(success: true)),
      fileSystem: fs,
      logger: logger,
      osUtils: FakeOperatingSystemUtils(),
      processUtils: ProcessUtils(
        logger: logger,
        processManager: processManager,
      ),
    );

    await createTestCommandRunner(command).run(const <String>['build', 'aar', '--no-pub']);
    expect(processManager, hasNoRemainingExpectations);
    expect(
      fakeAnalytics.sentEvents,
      contains(Event.commandUsageValues(
        workflow: 'build/aar',
        commandHasTerminal: false,
        buildAarProjectType: 'module',
        buildAarTargetPlatform: 'android-arm,android-arm64,android-x64',
      )),
    );
  }, overrides: <Type, Generator>{
    FileSystem: () => fs,
    Platform: () => platform,
    ProcessManager: () => processManager,
    Analytics: () => fakeAnalytics,
  });
}