flutter/packages/flutter_tools/test/commands.shard/permeable/widget_preview_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:io' as io show IOOverrides;

import 'package:args/command_runner.dart';
import 'package:file_testing/file_testing.dart';
import 'package:flutter_tools/src/base/common.dart';
import 'package:flutter_tools/src/base/file_system.dart';
import 'package:flutter_tools/src/commands/widget_preview.dart';
import 'package:flutter_tools/src/dart/pub.dart';
import 'package:flutter_tools/src/globals.dart' as globals;

import '../../src/common.dart';
import '../../src/context.dart';
import '../../src/fakes.dart';
import '../../src/test_flutter_command_runner.dart';
import 'utils/project_testing_utils.dart';

void main() {
  late Directory tempDir;
  late LoggingProcessManager loggingProcessManager;
  late FakeStdio mockStdio;

  setUp(() {
    loggingProcessManager = LoggingProcessManager();
    tempDir = globals.fs.systemTempDirectory.createTempSync('flutter_tools_create_test.');
    mockStdio = FakeStdio();
  });

  tearDown(() {
    tryToDelete(tempDir);
  });

  Future<String> createRootProject() async {
    return createProject(tempDir, arguments: <String>['--pub']);
  }

  Future<void> runWidgetPreviewCommand(List<String> arguments) async {
    final CommandRunner<void> runner = createTestCommandRunner(WidgetPreviewCommand());
    await runner.run(<String>['widget-preview', ...arguments]);
  }

  Future<void> startWidgetPreview({
    required String? rootProjectPath,
    List<String>? arguments,
  }) async {
    await runWidgetPreviewCommand(<String>[
      'start',
      ...?arguments,
      if (rootProjectPath != null) rootProjectPath,
    ]);
    expect(
      globals.fs
          .directory(rootProjectPath ?? globals.fs.currentDirectory.path)
          .childDirectory('.dart_tool')
          .childDirectory('widget_preview_scaffold'),
      exists,
    );
  }

  Future<void> cleanWidgetPreview({required String rootProjectPath}) async {
    await runWidgetPreviewCommand(<String>['clean', rootProjectPath]);
    expect(
      globals.fs
          .directory(rootProjectPath)
          .childDirectory('.dart_tool')
          .childDirectory('widget_preview_scaffold'),
      isNot(exists),
    );
  }

  group('flutter widget-preview', () {
    group('start exits if', () {
      testUsingContext('given an invalid directory', () async {
        try {
          await runWidgetPreviewCommand(<String>['start', 'foo']);
          fail('Successfully executed with multiple project paths');
        } on ToolExit catch (e) {
          expect(e.message, contains('Could not find foo'));
        }
      });

      testUsingContext('more than one project directory is provided', () async {
        try {
          await runWidgetPreviewCommand(<String>['start', tempDir.path, tempDir.path]);
          fail('Successfully executed with multiple project paths');
        } on ToolExit catch (e) {
          expect(e.message, contains('Only one directory should be provided.'));
        }
      });

      testUsingContext('run outside of a Flutter project directory', () async {
        try {
          await startWidgetPreview(rootProjectPath: tempDir.path);
          fail('Successfully executed outside of a Flutter project directory');
        } on ToolExit catch (e) {
          expect(e.message, contains('${tempDir.path} is not a valid Flutter project.'));
        }
      });
    });

    testUsingContext(
      'start creates .dart_tool/widget_preview_scaffold',
      () async {
        final String rootProjectPath = await createRootProject();
        await startWidgetPreview(rootProjectPath: rootProjectPath);
      },
      overrides: <Type, Generator>{
        Pub:
            () => Pub.test(
              fileSystem: globals.fs,
              logger: globals.logger,
              processManager: globals.processManager,
              botDetector: globals.botDetector,
              platform: globals.platform,
              stdio: mockStdio,
            ),
      },
    );

    testUsingContext(
      'start creates .dart_tool/widget_preview_scaffold in the CWD',
      () async {
        final String rootProjectPath = await createRootProject();
        await io.IOOverrides.runZoned<Future<void>>(() async {
          // Try to execute using the CWD.
          await startWidgetPreview(rootProjectPath: null);
        }, getCurrentDirectory: () => globals.fs.directory(rootProjectPath));
      },
      overrides: <Type, Generator>{
        Pub:
            () => Pub.test(
              fileSystem: globals.fs,
              logger: globals.logger,
              processManager: globals.processManager,
              botDetector: globals.botDetector,
              platform: globals.platform,
              stdio: mockStdio,
            ),
      },
    );

    testUsingContext(
      'clean deletes .dart_tool/widget_preview_scaffold',
      () async {
        final String rootProjectPath = await createRootProject();
        await startWidgetPreview(rootProjectPath: rootProjectPath);
        await cleanWidgetPreview(rootProjectPath: rootProjectPath);
      },
      overrides: <Type, Generator>{
        Pub:
            () => Pub.test(
              fileSystem: globals.fs,
              logger: globals.logger,
              processManager: globals.processManager,
              botDetector: globals.botDetector,
              platform: globals.platform,
              stdio: mockStdio,
            ),
      },
    );

    testUsingContext(
      'invokes pub in online and offline modes',
      () async {
        // Run pub online first in order to populate the pub cache.
        final String rootProjectPath = await createRootProject();
        loggingProcessManager.clear();

        final RegExp dartCommand = RegExp(r'dart-sdk[\\/]bin[\\/]dart');

        await startWidgetPreview(rootProjectPath: rootProjectPath);
        expect(
          loggingProcessManager.commands,
          contains(
            predicate(
              (List<String> c) =>
                  dartCommand.hasMatch(c[0]) && c[1].contains('pub') && !c.contains('--offline'),
            ),
          ),
        );

        await cleanWidgetPreview(rootProjectPath: rootProjectPath);

        // Run pub offline.
        loggingProcessManager.clear();
        await startWidgetPreview(
          rootProjectPath: rootProjectPath,
          arguments: <String>['--pub', '--offline'],
        );

        expect(
          loggingProcessManager.commands,
          contains(
            predicate(
              (List<String> c) =>
                  dartCommand.hasMatch(c[0]) && c[1].contains('pub') && c.contains('--offline'),
            ),
          ),
        );
      },
      overrides: <Type, Generator>{
        ProcessManager: () => loggingProcessManager,
        Pub:
            () => Pub.test(
              fileSystem: globals.fs,
              logger: globals.logger,
              processManager: globals.processManager,
              botDetector: globals.botDetector,
              platform: globals.platform,
              stdio: mockStdio,
            ),
      },
    );
  });
}