swift-hpa/Tests/ConfigurationClientTests/ConfigurationClientTests.swift

@_spi(Internal) import ConfigurationClient
import Foundation
import Testing
import TestSupport

@Suite("ConfigurationClientTests")
struct ConfigurationClientTests: TestCase {

  @Test
  func sanity() {
    withTestLogger(key: "sanity") {
      @Dependency(\.logger) var logger
      logger.debug("Testing sanity.")
      #expect(Bool(true))
    }
  }

  @Test(arguments: ["config.toml", "config.json"])
  func generateConfigFile(fileName: String) async throws {
    try await withTestLogger(key: "generateConfigFile") {
      $0.coders = .liveValue
      $0.fileClient = .liveValue
    } operation: {
      @Dependency(\.logger) var logger
      @Dependency(\.fileClient) var fileClient
      let configuration = ConfigurationClient.liveValue

      try await withTemporaryDirectory { tempDir in
        let tempFile = tempDir.appending(path: fileName)
        let output = try await configuration.generate(.init(
          force: false,
          json: fileName.hasSuffix("json"),
          path: .file(File(tempFile)!)
        ))
        #expect(FileManager.default.fileExists(atPath: tempFile.cleanFilePath))
        #expect(fileClient.fileExists(tempFile))
        #expect(output == tempFile.cleanFilePath)
      }
    }
  }

  @Test(arguments: ["config.toml", "config.json", nil])
  func loadConfigFile(fileName: String?) async throws {
    try await withTestLogger(key: "generateConfigFile") {
      $0.coders = .liveValue
      $0.fileClient = .liveValue
    } operation: {
      @Dependency(\.logger) var logger
      @Dependency(\.fileClient) var fileClient
      let configuration = ConfigurationClient.liveValue

      guard let fileName else {
        let loaded = try await configuration.load(nil)
        #expect(loaded == .init())
        return
      }

      try await withGeneratedConfigFile(named: fileName, client: configuration) { file in
        let loaded = try await configuration.load(file)
        #expect(loaded == .mock)
      }
    }
  }

  @Test(arguments: ["config.toml", "config.json", ".hparc.json", ".hparc.toml"])
  func findConfiguration(fileName: String) async throws {
    try await withTestLogger(key: "findConfiguration") {
      $0.fileClient = .liveValue
    } operation: {
      @Dependency(\.logger) var logger
      @Dependency(\.fileClient) var fileClient
      let client = ConfigurationClient.liveValue

      try await withGeneratedConfigFile(named: fileName, client: client) { file in
        for environment in generateFindEnvironments(file: file) {
          if let home = environment["HOME"] {
            try await withDependencies {
              $0.fileClient.homeDirectory = { URL(filePath: home) }
            } operation: {
              let configuration = ConfigurationClient.live(environment: environment)
              let found = try await configuration.find()
              #expect(found == file)
            }
          } else {
            let configuration = ConfigurationClient.live(environment: environment)
            let found = try await configuration.find()
            #expect(found == file)
          }
        }
      }
    }
  }

  @Test(arguments: ["config.toml", "config.json", ".hparc.json", ".hparc.toml"])
  func findXdgConfiguration(fileName: String) async throws {
    try await withTestLogger(key: "findXdgConfiguration") {
      $0.fileClient = .liveValue
    } operation: {
      @Dependency(\.logger) var logger
      @Dependency(\.fileClient) var fileClient
      let client = ConfigurationClient.liveValue

      try await withGeneratedXDGConfigFile(named: fileName, client: client) { file, xdgDir in
        let environment = ["XDG_CONFIG_HOME": xdgDir.cleanFilePath]
        let configuration = ConfigurationClient.live(environment: environment)
        let found = try await configuration.find()
        #expect(found == file)
      }
    }
  }

  @Test
  func testFailingFind() async {
    await withTestLogger(key: "testFailingFind") {
      $0.fileClient = .liveValue
    } operation: {
      await withTemporaryDirectory { tempDir in
        let environment = [
          "PWD": tempDir.cleanFilePath,
          "HPA_CONFIG_HOME": tempDir.cleanFilePath
        ]
        let configuration = ConfigurationClient.live(environment: environment)
        do {
          _ = try await configuration.find()
          #expect(Bool(false))
        } catch {
          #expect(Bool(true))
        }
      }
    }
  }

  @Test
  func writeCreatesBackupFile() async throws {
    try await withDependencies {
      $0.fileClient = .liveValue
    } operation: {
      let client = ConfigurationClient.liveValue

      try await withGeneratedConfigFile(named: "config.toml", client: client) { configFile in
        @Dependency(\.fileClient) var fileClient

        let backupUrl = configFile.url.appendingPathExtension("back")
        #expect(fileClient.fileExists(backupUrl) == false)

        let config = Configuration()
        try await client.write(config, to: configFile)

        #expect(fileClient.fileExists(backupUrl))
      }
    }
  }
}

func generateFindEnvironments(file: File) -> [[String: String]] {
  let directory = file.url.deletingLastPathComponent().cleanFilePath

  return [
    ["PWD": directory],
    ["HPA_CONFIG_HOME": directory],
    ["HPA_CONFIG_FILE": file.path],
    ["HOME": directory]
  ]
}

func withGeneratedConfigFile(
  named fileName: String,
  client: ConfigurationClient,
  _ operation: @Sendable (File) async throws -> Void
) async rethrows {
  try await withTemporaryDirectory { tempDir in
    let file = File(tempDir.appending(path: fileName))!
    _ = try await client.generate(.init(
      force: true,
      json: fileName.hasSuffix("json"),
      path: .file(file)
    ))
    try await operation(file)
  }
}

func withGeneratedXDGConfigFile(
  named fileName: String,
  client: ConfigurationClient,
  _ operation: @Sendable (File, URL) async throws -> Void
) async rethrows {
  try await withTemporaryDirectory { tempDir in
    let xdgDir = tempDir.appending(path: HPAKey.configDirName)
    try FileManager.default.createDirectory(
      atPath: xdgDir.cleanFilePath,
      withIntermediateDirectories: false
    )
    let file = File(xdgDir.appending(path: fileName))!
    _ = try await client.generate(.init(
      force: true,
      json: fileName.hasSuffix("json"),
      path: .file(file)
    ))
    try await operation(file, tempDir)
  }
}