pkg/dartdev/test/sdk_cache_test.dart

// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file
// for details. 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:convert';
import 'dart:io' as io;

import 'package:code_assets/code_assets.dart' show OS;
import 'package:dartdev/src/sdk_cache.dart';
import 'package:file/file.dart';
import 'package:file/memory.dart';
import 'package:hooks_runner/hooks_runner.dart' show Target;
import 'package:http/http.dart' as http;
import 'package:http/testing.dart' as http;
import 'package:test/test.dart';

const dartArchiveUri = 'https://storage.googleapis.com/dart-archive';

void main() {
  late SdkCache cache;
  late FileSystem fs;
  late StringBuffer stderr;
  late Map<String, http.Response> expectedRequests;
  late Map<String, io.ProcessResult> chmodRuns;

  setUp(() {
    // Make sure we support both path separators.
    fs = MemoryFileSystem(
      style: io.Platform.isWindows
          ? FileSystemStyle.windows
          : FileSystemStyle.posix,
    );
    stderr = StringBuffer();
    expectedRequests = <String, http.Response>{};
    chmodRuns = <String, io.ProcessResult>{};

    cache = SdkCache(
      directory: fs.directory(Uri.file('/tmp/cache')).path,
      stderr: stderr,
      verbose: true,
      fs: fs,
      httpClient: http.MockClient((request) async {
        final key = '${request.method.toUpperCase()} ${request.url}';
        if (!expectedRequests.containsKey(key)) {
          throw Exception('Unexpected request $key');
        }
        return expectedRequests[key]!;
      }),
      chmod: (path) => chmodRuns[path]!,
    );
  });

  group('resolveStage', () {
    test('Uses signed on macOS dev for executables', () {
      expect(
        SdkCache.resolveStage(
          channel: Channel.dev,
          isExecutable: true,
          hostOS: OS.macOS,
        ),
        Stage.signed,
      );
    });

    test('Uses raw on macOS main for executables', () {
      expect(
        SdkCache.resolveStage(
          channel: Channel.main,
          isExecutable: true,
          hostOS: OS.macOS,
        ),
        Stage.raw,
      );
    });

    test('Uses raw on macOS stable for non-executables', () {
      expect(
        SdkCache.resolveStage(
          channel: Channel.stable,
          isExecutable: false,
          hostOS: OS.macOS,
        ),
        Stage.raw,
      );
    });
  });

  group('resolveVersion', () {
    test('Resolves release version', () async {
      final version = '3.4.4';
      final revision = '60465149414572c8ca189d8f65fdb39795c4b97d';
      final folder = await cache.resolveVersion(
        version: version,
        revision: revision,
        channelName: 'stable',
        host: Target.linuxArm64,
      );
      expect(folder.version, version);
      expect(folder.revision, revision);
      expect(folder.channel, Channel.stable);
      expect(
        folder.fileUri('VERSION', stage: Stage.raw).toString(),
        '$dartArchiveUri/channels/stable/raw/hash/$revision/VERSION',
      );
    });

    test('Falls back to the latest on empty main revision', () async {
      final version = '3.8.0';
      final revision = '';

      final latestVersion =
          '3.8.0-edge.7ee7416a62efb7eb23eb2a87eb34d2895559ba06';
      final latestRevision = '7ee7416a62efb7eb23eb2a87eb34d2895559ba06';

      expectedRequests['GET $dartArchiveUri/channels/main/raw/latest/VERSION'] =
          http.Response(
            json.encode({'version': latestVersion, 'revision': latestRevision}),
            io.HttpStatus.ok,
          );
      final folder = await cache.resolveVersion(
        version: version,
        revision: revision,
        channelName: 'main',
        host: Target.macOSArm64,
      );
      expect(folder.version, latestVersion);
      expect(folder.revision, latestRevision);
      expect(folder.channel, Channel.main);
    });

    test('Falls back to the latest on unknown main revision', () async {
      final version = '3.8.0';
      final revision = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';

      final latestVersion =
          '3.8.0-edge.7ee7416a62efb7eb23eb2a87eb34d2895559ba06';
      final latestRevision = '7ee7416a62efb7eb23eb2a87eb34d2895559ba06';

      expectedRequests.addAll({
        // Revision validation request.
        'HEAD $dartArchiveUri/channels/main/raw/hash/$revision/VERSION':
            http.Response('', io.HttpStatus.notFound),
        // Revision resolution request.
        'GET $dartArchiveUri/channels/main/raw/latest/VERSION': http.Response(
          json.encode({'version': latestVersion, 'revision': latestRevision}),
          io.HttpStatus.ok,
        ),
      });

      final folder = await cache.resolveVersion(
        version: version,
        revision: revision,
        channelName: 'main',
        host: Target.macOSArm64,
      );
      expect(folder.version, latestVersion);
      expect(folder.revision, latestRevision);
      expect(folder.channel, Channel.main);
    });

    test('Reports unknown channel', () async {
      try {
        await cache.resolveVersion(
          channelName: 'wat',
          host: Target.linuxArm64,
          revision: '',
          version: '4.0',
        );
        fail('expected to throw');
      } on ArgumentError catch (e) {
        expect(e.message, contains('Unsupported channel'));
      }
    });
  });

  group('ensureArtifact', () {
    test('Skips download when file exists', () async {
      final version = '3.4.4';
      final revision = '60465149414572c8ca189d8f65fdb39795c4b97d';

      final genSnapshotFile = fs.file(
        Uri.file(
          '/tmp/cache/$version/gen_snapshot_windows_arm64_linux_x64.exe',
        ),
      );
      genSnapshotFile.createSync(exclusive: true, recursive: true);

      final path = await cache.ensureGenSnapshot(
        archiveFolder: ArchiveFolder(
          channel: Channel.stable,
          version: version,
          revision: revision,
        ),
        host: Target.windowsArm64,
        target: Target.linuxX64,
      );
      expect(path, genSnapshotFile.path);
    });

    test('Downloads signed gen_snapshot on macOS beta', () async {
      final version = '3.8.0-171.2.beta';
      final revision = '54cec4d7d36e7a5066770287998f425606a2f983';

      final archiveFolder = ArchiveFolder(
        channel: Channel.beta,
        version: version,
        revision: revision,
      );
      expectedRequests['GET $dartArchiveUri/channels/beta/signed/hash/'
          '$revision/sdk/gen_snapshot_macos_arm64_linux_x64'] = http.Response(
        'i am gen_snapshot',
        io.HttpStatus.ok,
      );

      final path = await cache.ensureGenSnapshot(
        archiveFolder: archiveFolder,
        host: Target.macOSArm64,
        target: Target.linuxX64,
      );

      expect(
        path,
        fs
            .file(
              Uri.file(
                '/tmp/cache/$version/gen_snapshot_macos_arm64_linux_x64',
              ),
            )
            .path,
      );
      expect(fs.file(path).readAsStringSync(), 'i am gen_snapshot');
    });

    test('Downloads raw dartaotruntime on macOS beta', () async {
      final version = '3.8.0-171.2.beta';
      final revision = '54cec4d7d36e7a5066770287998f425606a2f983';

      final archiveFolder = ArchiveFolder(
        channel: Channel.beta,
        version: version,
        revision: revision,
      );
      expectedRequests['GET $dartArchiveUri/channels/beta/raw/hash/'
          '$revision/sdk/dartaotruntime_linux_x64'] = http.Response(
        'i am dartaotruntime',
        io.HttpStatus.ok,
      );

      final path = await cache.ensureDartAotRuntime(
        archiveFolder: archiveFolder,
        host: Target.macOSArm64,
        target: Target.linuxX64,
      );

      expect(
        path,
        fs.file(Uri.file('/tmp/cache/$version/dartaotruntime_linux_x64')).path,
      );
      expect(fs.file(path).readAsStringSync(), 'i am dartaotruntime');
    });

    test('Downloads gen_snapshot.exe on Windows stable', () async {
      final version = '3.7.2';
      final channel = Channel.stable;
      final revision = '9594995093f642957b780603c6435d9e7a61b923';
      final binary = 'gen_snapshot_windows_x64_linux_x64.exe';

      final archiveFolder = ArchiveFolder(
        channel: channel,
        version: version,
        revision: revision,
      );
      expectedRequests['GET $dartArchiveUri/channels/stable/raw/hash/'
          '$revision/sdk/$binary'] = http.Response(
        'i am gen_snapshot',
        io.HttpStatus.ok,
      );

      final path = await cache.ensureGenSnapshot(
        archiveFolder: archiveFolder,
        host: Target.windowsX64,
        target: Target.linuxX64,
      );

      expect(path, fs.file(Uri.file('/tmp/cache/$version/$binary')).path);
      expect(fs.file(path).readAsStringSync(), 'i am gen_snapshot');
    });

    test('Downloads dartaotruntime on Windows stable', () async {
      final version = '3.7.2';
      final channel = Channel.stable;
      final revision = '9594995093f642957b780603c6435d9e7a61b923';
      final binary = 'dartaotruntime_linux_x64';

      final archiveFolder = ArchiveFolder(
        channel: channel,
        version: version,
        revision: revision,
      );
      expectedRequests['GET $dartArchiveUri/channels/stable/raw/hash/'
          '$revision/sdk/$binary'] = http.Response(
        'i am dartaotruntime',
        io.HttpStatus.ok,
      );

      final path = await cache.ensureDartAotRuntime(
        archiveFolder: archiveFolder,
        host: Target.windowsX64,
        target: Target.linuxX64,
      );

      expect(path, fs.file(Uri.file('/tmp/cache/$version/$binary')).path);
      expect(fs.file(path).readAsStringSync(), 'i am dartaotruntime');
    });
  });
}