func run()

in Sources/PackageRegistryCompatibilityTestSuite/TestConfigurationGenerator.swift [25:112]
70 lines of code
5 McCabe index (conditional complexity)

    func run(configuration: Configuration, tmpDir: AbsolutePath) throws -> PackageRegistryCompatibilityTestSuite.Configuration {
        guard !configuration.packages.isEmpty else {
            throw TestError("\"packages\" must not be empty")
        }
        guard configuration.packages.first(where: { $0.releases.isEmpty }) == nil else {
            throw TestError("\"package.releases\" must not be empty")
        }

        let resourceBaseDirectoryPath = try configuration.resourceBaseDirectory.map { try AbsolutePath(validating: $0) }

        // Generate test packages
        let packages: [PackageDescriptor] = try configuration.packages.enumerated().map { offset, element in
            let package: PackageIdentity
            switch element.id {
            case .some(let id):
                package = id
            case .none:
                let randomString = randomAlphaNumericString(length: 6)
                package = PackageIdentity(scope: "test-\(randomString)", name: "package-\(randomString)")
            }

            let explicitVersions = element.releases.enumerated().reduce(into: [Int: Version]()) { result, item in
                guard let v = item.element.version, let version = Version(v) else { return }
                result[item.offset] = version
            }
            var randomVersions: [Version] = explicitVersions.count == element.releases.count ? [] :
                // If we need to generate any versions, start from the "next" major version to avoid conflicts
                randomVersions(major: (explicitVersions.values.sorted(by: >).first?.major ?? 0) + 1, count: element.releases.count - explicitVersions.count)

            let releases: [PackageDescriptor.Release] = try element.releases.enumerated().map { offset, element in
                // Version is either specified in the configuration or generated randomly
                let version = explicitVersions[offset] ?? randomVersions.removeFirst()

                let sourceArchivePath = try makeAbsolutePath(element.sourceArchivePath, relativeTo: resourceBaseDirectoryPath)
                // Compute checksum of the source archive
                let checksum = try Process.checkNonZeroExit(arguments: ["swift", "package", "compute-checksum", sourceArchivePath.pathString])
                    .trimmingCharacters(in: .whitespacesAndNewlines)

                let metadataTemplatePath = try element.metadataPath.map { try makeAbsolutePath($0, relativeTo: resourceBaseDirectoryPath) }
                // Replace values in metadata template if any
                var metadataPath: AbsolutePath?
                if let metadataTemplatePath = metadataTemplatePath {
                    let metadataData = try Data(contentsOf: metadataTemplatePath.asURL)
                    guard let metadataJSON = String(data: metadataData, encoding: .utf8) else {
                        throw TestError("\(metadataTemplatePath) contains invalid JSON")
                    }

                    let modifiedMetadata = metadataJSON.replacingOccurrences(of: "{TEST_SCOPE}", with: package.scope)
                        .replacingOccurrences(of: "{TEST_NAME}", with: package.name)
                        .replacingOccurrences(of: "{TEST_VERSION}", with: version.description)
                    metadataPath = tmpDir.appending(component: "\(package)-\(version)-metadata.json")

                    // Write the modified metadata file to tmp dir
                    try self.fileSystem.writeFileContents(metadataPath!, bytes: ByteString(encodingAsUTF8: modifiedMetadata)) // !-safe since we assign value above
                }

                return PackageDescriptor.Release(
                    version: version,
                    sourceArchivePath: sourceArchivePath,
                    checksum: checksum,
                    metadataPath: metadataPath,
                    versionManifests: element.versionManifests
                )
            }

            return PackageDescriptor(id: package, repositoryURL: element.repositoryURL, releases: releases)
        }

        let unknownPackages = self.randomPackageIdentities(count: 1)

        return PackageRegistryCompatibilityTestSuite.Configuration(
            createPackageRelease: self.buildCreatePackageRelease(packages: packages, configuration: configuration.createPackageRelease),
            listPackageReleases: configuration.listPackageReleases.map {
                self.buildListPackageReleases(packages: packages, unknownPackages: unknownPackages, configuration: $0)
            },
            fetchPackageReleaseInfo: try configuration.fetchPackageReleaseInfo.map {
                try self.buildFetchPackageReleaseInfo(packages: packages, unknownPackages: unknownPackages, configuration: $0)
            },
            fetchPackageReleaseManifest: configuration.fetchPackageReleaseManifest.map {
                self.buildFetchPackageReleaseManifest(packages: packages, unknownPackages: unknownPackages, configuration: $0)
            },
            downloadSourceArchive: configuration.downloadSourceArchive.map {
                self.buildDownloadSourceArchive(packages: packages, unknownPackages: unknownPackages, configuration: $0)
            },
            lookupPackageIdentifiers: try self.buildLookupPackageIdentifiers(packages: packages, unknownPackages: unknownPackages,
                                                                             configuration: configuration.lookupPackageIdentifiers)
        )
    }