packages/flutter_tools/test/general.shard/preview_device_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 'dart:async';

import 'package:file/memory.dart';
import 'package:flutter_tools/src/application_package.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/build_info.dart';
import 'package:flutter_tools/src/build_system/build_system.dart';
import 'package:flutter_tools/src/bundle.dart';
import 'package:flutter_tools/src/bundle_builder.dart';
import 'package:flutter_tools/src/cache.dart';
import 'package:flutter_tools/src/device.dart';
import 'package:flutter_tools/src/preview_device.dart';
import 'package:flutter_tools/src/project.dart';
import 'package:meta/meta.dart';
import 'package:test/fake.dart';

import '../src/common.dart';
import '../src/context.dart';
import '../src/fakes.dart';

void main() {
  String? flutterRootBackup;
  late MemoryFileSystem fs;
  late File previewBinary;

  setUp(() {
    fs = MemoryFileSystem.test(style: FileSystemStyle.windows);
    Cache.flutterRoot = r'C:\path\to\flutter';
    previewBinary = fs.file('${Cache.flutterRoot}\\bin\\cache\\artifacts\\flutter_preview\\flutter_preview.exe');
    previewBinary.createSync(recursive: true);
    flutterRootBackup = Cache.flutterRoot;
  });

  tearDown(() {
    Cache.flutterRoot = flutterRootBackup;
  });

  testWithoutContext('PreviewDevice defaults', () async {
    final PreviewDevice device = PreviewDevice(
      artifacts: Artifacts.test(),
      fileSystem: fs,
      processManager: FakeProcessManager.any(),
      previewBinary: previewBinary,
      logger: BufferLogger.test(),
    );

    expect(await device.isLocalEmulator, false);
    expect(device.name, 'Preview');
    expect(await device.sdkNameAndVersion, 'preview');
    expect(await device.targetPlatform, TargetPlatform.windows_x64);
    expect(device.category, Category.desktop);
    expect(device.ephemeral, false);
    expect(device.id, 'preview');

    expect(device.isSupported(), true);
    expect(device.isSupportedForProject(FakeFlutterProject()), true);
    expect(await device.isLatestBuildInstalled(FakeApplicationPackage()), false);
    expect(await device.isAppInstalled(FakeApplicationPackage()), false);
    expect(await device.uninstallApp(FakeApplicationPackage()), true);
  });

  testUsingContext('Can build a simulator app', () async {
    final Completer<void> completer = Completer<void>();
    final BufferLogger logger = BufferLogger.test();
    final PreviewDevice device = PreviewDevice(
      artifacts: Artifacts.test(),
      fileSystem: fs,
      previewBinary: previewBinary,
      processManager: FakeProcessManager.list(<FakeCommand>[
        FakeCommand(
          command: const <String>[
            r'C:\.tmp_rand0\flutter_preview.rand0\flutter_preview.exe',
          ],
          stdout: 'The Dart VM service is listening on http://127.0.0.1:64494/fZ_B2N6JRwY=/\n',
          completer: completer,
        ),
      ]),
      logger: logger,
      builderFactory: () => FakeBundleBuilder(fs),
    );
    final Directory previewDeviceCacheDir = fs
      .directory('Artifact.windowsDesktopPath.TargetPlatform.windows_x64.debug')
      ..createSync(recursive: true);
    previewDeviceCacheDir.childFile('flutter_windows.dll').writeAsStringSync('1010101');
    previewDeviceCacheDir.childFile('icudtl.dat').writeAsStringSync('1010101');

    final LaunchResult result = await device.startApp(
      FakeApplicationPackage(),
      debuggingOptions: DebuggingOptions.enabled(BuildInfo.debug),
    );

    expect(result.started, true);
    expect(result.vmServiceUri, Uri.parse('http://127.0.0.1:64494/fZ_B2N6JRwY=/'));
  });

  group('PreviewDeviceDiscovery', () {
    late Artifacts artifacts;
    late ProcessManager processManager;
    final FakePlatform windowsPlatform = FakePlatform(operatingSystem: 'windows');
    final FakePlatform macPlatform = FakePlatform(operatingSystem: 'macos');
    final FakePlatform linuxPlatform = FakePlatform();
    final TestFeatureFlags featureFlags = TestFeatureFlags(isPreviewDeviceEnabled: true);

    setUp(() {
      artifacts = Artifacts.test(fileSystem: fs);
      processManager = FakeProcessManager.empty();
    });

    testWithoutContext('PreviewDeviceDiscovery on linux', () async {
      final PreviewDeviceDiscovery discovery = PreviewDeviceDiscovery(
        artifacts: artifacts,
        fileSystem: fs,
        logger: BufferLogger.test(),
        processManager: processManager,
        platform: linuxPlatform,
        featureFlags: featureFlags,
      );

      final List<Device> devices = await discovery.devices();

      expect(devices, isEmpty);
    });

    testWithoutContext('PreviewDeviceDiscovery on macOS', () async {
      final PreviewDeviceDiscovery discovery = PreviewDeviceDiscovery(
        artifacts: artifacts,
        fileSystem: fs,
        logger: BufferLogger.test(),
        processManager: processManager,
        platform: macPlatform,
        featureFlags: featureFlags,
      );

      final List<Device> devices = await discovery.devices();

      expect(devices, isEmpty);
    });

    testWithoutContext('PreviewDeviceDiscovery on Windows returns preview when binary exists', () async {
      // ensure Flutter preview binary exists in cache.
      fs.file(artifacts.getArtifactPath(Artifact.flutterPreviewDevice)).writeAsBytesSync(<int>[1, 0, 0, 1]);
      final PreviewDeviceDiscovery discovery = PreviewDeviceDiscovery(
        artifacts: artifacts,
        fileSystem: fs,
        logger: BufferLogger.test(),
        processManager: processManager,
        platform: windowsPlatform,
        featureFlags: featureFlags,
      );

      final List<Device> devices = await discovery.devices();

      expect(devices, hasLength(1));
      final Device previewDevice = devices.first;
      expect(previewDevice, isA<PreviewDevice>());
    });

    testWithoutContext('PreviewDeviceDiscovery on Windows returns nothing when binary does not exist', () async {
      final PreviewDeviceDiscovery discovery = PreviewDeviceDiscovery(
        artifacts: artifacts,
        fileSystem: fs,
        logger: BufferLogger.test(),
        processManager: processManager,
        platform: windowsPlatform,
        featureFlags: featureFlags,
      );

      final List<Device> devices = await discovery.devices();

      expect(devices, isEmpty);
    });
  });
}

class FakeFlutterProject extends Fake implements FlutterProject { }
class FakeApplicationPackage extends Fake implements ApplicationPackage { }
class FakeBundleBuilder extends Fake implements BundleBuilder {
  FakeBundleBuilder(this.fileSystem);

  final FileSystem fileSystem;

  @override
  Future<void> build({
    required TargetPlatform platform,
    required BuildInfo buildInfo,
    FlutterProject? project,
    String? mainPath,
    String manifestPath = defaultManifestPath,
    String? applicationKernelFilePath,
    String? depfilePath,
    String? assetDirPath,
    bool buildNativeAssets = true,
    @visibleForTesting BuildSystem? buildSystem
  }) async {
    final Directory assetDirectory = fileSystem
      .directory(assetDirPath)
      .childDirectory('flutter_assets')
      ..createSync(recursive: true);
    assetDirectory.childFile('kernel_blob.bin').createSync();
  }
}