pkl/pkl-cli/src/test/kotlin/org/pkl/cli/CliCommandRunnerTest.kt

/*
 * Copyright © 2025-2026 Apple Inc. and the Pkl project authors. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.pkl.cli

import com.github.ajalt.clikt.core.CliktError
import com.github.ajalt.clikt.core.MissingOption
import com.github.ajalt.clikt.core.PrintCompletionMessage
import com.github.tomakehurst.wiremock.junit5.WireMockTest
import java.io.ByteArrayOutputStream
import java.net.URI
import java.nio.charset.StandardCharsets
import java.nio.file.Files
import java.nio.file.Path
import kotlin.io.path.ExperimentalPathApi
import kotlin.io.path.createDirectories
import kotlin.io.path.createParentDirectories
import kotlin.io.path.deleteRecursively
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.AfterAll
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows
import org.pkl.commons.cli.CliBaseOptions
import org.pkl.commons.cli.CliException
import org.pkl.commons.test.FileTestUtils
import org.pkl.commons.test.PackageServer
import org.pkl.commons.writeString

@OptIn(ExperimentalPathApi::class)
@WireMockTest(httpsEnabled = true, proxyMode = true)
class CliCommandRunnerTest {
  private val renderOptions =
    """
    extends "pkl:Command"

    options: Options

    output {
      value = options
    }

    """
      .trimIndent()

  companion object {
    private val packageServer = PackageServer()

    @AfterAll
    @JvmStatic
    fun afterAll() {
      packageServer.close()
    }
  }

  // use manually constructed temp dir instead of @TempDir to work around
  // https://forums.developer.apple.com/thread/118358
  private val tempDir: Path = run {
    val baseDir = FileTestUtils.rootProjectDir.resolve("pkl-cli/build/tmp/CliCommandRunnerTest")
    baseDir.createDirectories()
    Files.createTempDirectory(baseDir, null)
  }

  @AfterEach
  fun afterEach() {
    tempDir.deleteRecursively()
  }

  private fun writePklFile(fileName: String, contents: String): URI {
    tempDir.resolve(fileName).createParentDirectories()
    return tempDir.resolve(fileName).writeString(contents).toUri()
  }

  private fun runToStdout(options: CliBaseOptions, args: List<String>): String {
    val outWriter = ByteArrayOutputStream()
    CliCommandRunner(
        options,
        setOf("root-dir"),
        emptySet(),
        args,
        outWriter,
        ByteArrayOutputStream(),
      )
      .run()
    return outWriter.toString(StandardCharsets.UTF_8)
  }

  @Test
  fun `missing required flag`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            foo: String
          }
          """
            .trimIndent(),
      )

    val exc =
      assertThrows<MissingOption> {
        runToStdout(CliBaseOptions(sourceModules = listOf(moduleUri), testMode = true), listOf())
      }
    assertThat(exc.paramName).isEqualTo("--foo")
  }

  @Test
  fun `primitive flags`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            `number-as-int`: Number
            `number-as-float`: Number
            `number-nullable`: Number?
            `number-default`: Number = 100.0
            `number-default-overridden`: Number = 100.0
            
            float: Float
            `float-without-decimals`: Float
            `float-nullable`: Float?
            `float-default`: Float = 100.0
            `float-default-overridden`: Float = 100.0
            
            int: Int
            `int-nullable`: Int?
            `int-default`: Int = 100
            `int-default-overridden`: Int = 100
            
            int8: Int8
            int16: Int16
            int32: Int32
            uint: UInt
            uint8: UInt8
            uint16: UInt16
            uint32: UInt32
            
            boolean: Boolean
            `boolean-nullable`: Boolean?
            `boolean-default`: Boolean = true
            `boolean-default-overridden`: Boolean = false
            
            string: String
            `string-nullable`: String?
            `string-default`: String = "default"
            `string-default-overridden`: String = "default"
            
            char: Char
            `char-nullable`: Char?
            `char-default`: Char = "a"
            `char-default-overridden`: Char = "b"
          }
          """
            .trimIndent(),
      )
    val output =
      runToStdout(
        CliBaseOptions(sourceModules = listOf(moduleUri)),
        listOf(
          "--number-as-int=123",
          "--number-as-float=123.0",
          "--number-default-overridden=-200.0",
          "--float=123.456",
          "--float-without-decimals=789",
          "--float-default-overridden=-200",
          "--int=123",
          "--int-default-overridden=-200",
          "--int8=127",
          "--int16=32767",
          "--int32=2147483647",
          "--uint=0",
          "--uint8=255",
          "--uint16=65535",
          "--uint32=4294967295",
          "--boolean=n",
          "--boolean-default-overridden=1",
          "--string=foobar",
          "--string-default-overridden=non-default",
          "--char=X",
          "--char-default-overridden=c",
        ),
      )
    assertThat(output)
      .isEqualTo(
        """
        `number-as-int` = 123
        `number-as-float` = 123.0
        `number-nullable` = null
        `number-default` = 100.0
        `number-default-overridden` = -200.0
        float = 123.456
        `float-without-decimals` = 789.0
        `float-nullable` = null
        `float-default` = 100.0
        `float-default-overridden` = -200.0
        int = 123
        `int-nullable` = null
        `int-default` = 100
        `int-default-overridden` = -200
        int8 = 127
        int16 = 32767
        int32 = 2147483647
        uint = 0
        uint8 = 255
        uint16 = 65535
        uint32 = 4294967295
        boolean = false
        `boolean-nullable` = null
        `boolean-default` = true
        `boolean-default-overridden` = true
        string = "foobar"
        `string-nullable` = null
        `string-default` = "default"
        `string-default-overridden` = "non-default"
        char = "X"
        `char-nullable` = null
        `char-default` = "a"
        `char-default-overridden` = "c"

        """
          .trimIndent()
      )
  }

  @Test
  fun `primitive arguments`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            @Argument
            `number-as-int`: Number
            @Argument
            `number-as-float`: Number
            
            @Argument
            float: Float
            @Argument
            `float-without-decimals`: Float
            
            @Argument
            int: Int
            
            @Argument
            int8: Int8
            @Argument
            int16: Int16
            @Argument
            int32: Int32
            @Argument
            uint: UInt
            @Argument
            uint8: UInt8
            @Argument
            uint16: UInt16
            @Argument
            uint32: UInt32
            
            @Argument
            boolean: Boolean
            
            @Argument
            string: String
            
            @Argument
            char: Char
          }
          """
            .trimIndent(),
      )
    val output =
      runToStdout(
        CliBaseOptions(sourceModules = listOf(moduleUri)),
        listOf(
          "123",
          "123.0",
          "123.456",
          "789",
          "123",
          "127",
          "32767",
          "2147483647",
          "0",
          "255",
          "65535",
          "4294967295",
          "n",
          "foobar",
          "X",
        ),
      )
    assertThat(output)
      .isEqualTo(
        """
        `number-as-int` = 123
        `number-as-float` = 123.0
        float = 123.456
        `float-without-decimals` = 789.0
        int = 123
        int8 = 127
        int16 = 32767
        int32 = 2147483647
        uint = 0
        uint8 = 255
        uint16 = 65535
        uint32 = 4294967295
        boolean = false
        string = "foobar"
        char = "X"

        """
          .trimIndent()
      )
  }

  @Test
  fun `enum flags`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          typealias MyEnum = "d" | "e" | *"f"
          class Options {
            enum: "a" | "b" | "c"
            `enum-default`: "a" | *"b" | "c"
            `enum-explicit-default`: "a" | "b" | "c" = "c"
            `enum-alias-default`: MyEnum
            `enum-alias-explicit-default`: MyEnum = "e"
            `enum-alias-default-overridden`: MyEnum
            
            `enum-single`: "x"
            `enum-single-nullable`: "x"?
            `enum-single-explicit-default`: "x" = "x"
            `enum-single-overridden`: "x"
          }
          """
            .trimIndent(),
      )
    val output =
      runToStdout(
        CliBaseOptions(sourceModules = listOf(moduleUri)),
        listOf("--enum=a", "--enum-alias-default-overridden=d", "--enum-single-overridden=x"),
      )
    assertThat(output)
      .isEqualTo(
        """
        enum = "a"
        `enum-default` = "b"
        `enum-explicit-default` = "c"
        `enum-alias-default` = "f"
        `enum-alias-explicit-default` = "e"
        `enum-alias-default-overridden` = "d"
        `enum-single` = "x"
        `enum-single-nullable` = null
        `enum-single-explicit-default` = "x"
        `enum-single-overridden` = "x"

        """
          .trimIndent()
      )
  }

  @Test
  fun `enum args`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          typealias MyEnum = "d" | "e" | *"f"
          class Options {
            @Argument
            enum: "a" | "b" | "c"
            @Argument
            `enum-default`: "a" | *"b" | "c"
            @Argument
            `enum-alias-default`: MyEnum
          }
          """
            .trimIndent(),
      )
    val output =
      runToStdout(CliBaseOptions(sourceModules = listOf(moduleUri)), listOf("a", "c", "d"))
    assertThat(output)
      .isEqualTo(
        """
        enum = "a"
        `enum-default` = "c"
        `enum-alias-default` = "d"

        """
          .trimIndent()
      )
  }

  @Test
  fun `collection flags`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            list: List<Number>
            `list-nullable`: List<Number>?
            `list-default`: List<Number> = List(1, 2, 300.0)
            set: Set<Number>
            `set-nullable`: Set<Number>?
            `set-default`: Set<Number> = Set(1, 2, 300.0, 2)
            
            `enum-list`: List<"a" | "b" | *"c">
            `enum-set`: Set<"a" | "b" | *"c">
          }
          """
            .trimIndent(),
      )
    val output =
      runToStdout(
        CliBaseOptions(sourceModules = listOf(moduleUri)),
        listOf(
          "--list=1",
          "--list=0",
          "--list=0.0",
          "--list=1",
          "--set=1",
          "--set=0",
          "--set=0.0",
          "--set=1",
          "--enum-list=a",
          "--enum-list=a",
          "--enum-list=b",
          "--enum-set=a",
          "--enum-set=a",
          "--enum-set=b",
        ),
      )
    assertThat(output)
      .isEqualTo(
        """
        list = List(1, 0, 0.0, 1)
        `list-nullable` = null
        `list-default` = List(1, 2, 300.0)
        set = Set(1, 0, 0.0)
        `set-nullable` = null
        `set-default` = Set(1, 2, 300.0)
        `enum-list` = List("a", "a", "b")
        `enum-set` = Set("a", "b")

        """
          .trimIndent()
      )
  }

  @Test
  fun `sequence args`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            @Argument
            list: List<Number>
          }
          """
            .trimIndent(),
      )
    val output =
      runToStdout(CliBaseOptions(sourceModules = listOf(moduleUri)), listOf("1", "0", "0.0", "1"))
    assertThat(output)
      .isEqualTo(
        """
        list = List(1, 0, 0.0, 1)

        """
          .trimIndent()
      )

    val moduleUri2 =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            @Argument
            set: Set<Number>
          }
          """
            .trimIndent(),
      )
    val output2 =
      runToStdout(CliBaseOptions(sourceModules = listOf(moduleUri2)), listOf("1", "0", "0.0", "1"))
    assertThat(output2)
      .isEqualTo(
        """
        set = Set(1, 0, 0.0)

        """
          .trimIndent()
      )

    val moduleUri3 =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            @Argument
            listing: Listing<Number>
          }
          """
            .trimIndent(),
      )
    val output3 =
      runToStdout(CliBaseOptions(sourceModules = listOf(moduleUri3)), listOf("1", "0", "0.0", "1"))
    assertThat(output3)
      .isEqualTo(
        """
        listing {
          1
          0
          0.0
          1
        }

        """
          .trimIndent()
      )
  }

  @Test
  fun `keyval args`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            @Argument
            map: Map<Number, Number>
          }
          """
            .trimIndent(),
      )
    val output =
      runToStdout(CliBaseOptions(sourceModules = listOf(moduleUri)), listOf("1=0", "0.0=1"))
    assertThat(output)
      .isEqualTo(
        """
        map = Map(1, 0, 0.0, 1)

        """
          .trimIndent()
      )

    val moduleUri2 =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            @Argument
            mapping: Mapping<Number, Number>
          }
          """
            .trimIndent(),
      )
    val output2 =
      runToStdout(CliBaseOptions(sourceModules = listOf(moduleUri2)), listOf("1=0", "0.0=1"))
    assertThat(output2)
      .isEqualTo(
        """
        mapping {
          [1] = 0
          [0.0] = 1
        }

        """
          .trimIndent()
      )

    val moduleUri3 =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            @Argument
            pair: Pair<Number, Number>
          }
          """
            .trimIndent(),
      )
    val output3 = runToStdout(CliBaseOptions(sourceModules = listOf(moduleUri3)), listOf("1=0.0"))
    assertThat(output3)
      .isEqualTo(
        """
        pair = Pair(1, 0.0)

        """
          .trimIndent()
      )
  }

  @Test
  fun `map flags`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          typealias MyEnum = "a" | "b" | *"c"
          class Options {
            map: Map<Char, Number>
            `map-nullable`: Map<Char, Number>?
            `map-default`: Map<Char, Number> = Map("x", 123, "y", 456.789)
            
            `enum-map`: Map<MyEnum, MyEnum>
          }
          """
            .trimIndent(),
      )
    val output =
      runToStdout(
        CliBaseOptions(sourceModules = listOf(moduleUri)),
        listOf("--map=a=0.0", "--map=b=1", "--enum-map=a=b", "--enum-map=b=c"),
      )
    assertThat(output)
      .isEqualTo(
        """
        map = Map("a", 0.0, "b", 1)
        `map-nullable` = null
        `map-default` = Map("x", 123, "y", 456.789)
        `enum-map` = Map("a", "b", "b", "c")

        """
          .trimIndent()
      )
  }

  @Test
  fun `mapping flags`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          typealias MyEnum = "a" | "b" | *"c"
          class Options {
            mapping: Mapping<Char, Number>
            `mapping-nullable`: Mapping<Char, Number>?
            `mapping-default`: Mapping<Char, Number> = new { ["x"] = 123; ["y"] = 456.789 }
            
            `enum-mapping`: Mapping<MyEnum, MyEnum>
          }
          """
            .trimIndent(),
      )
    val output =
      runToStdout(
        CliBaseOptions(sourceModules = listOf(moduleUri)),
        listOf("--mapping=a=0.0", "--mapping=b=1", "--enum-mapping=a=b", "--enum-mapping=b=c"),
      )
    assertThat(output)
      .isEqualTo(
        """
        mapping {
          ["a"] = 0.0
          ["b"] = 1
        }
        `mapping-nullable` = null
        `mapping-default` {
          ["x"] = 123
          ["y"] = 456.789
        }
        `enum-mapping` {
          ["a"] = "b"
          ["b"] = "c"
        }

        """
          .trimIndent()
      )
  }

  @Test
  fun `pair flags`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          typealias MyEnum = "a" | "b" | *"c"
          class Options {
            pair: Pair<Char, Number>
            `pair-nullable`: Pair<Char, Number>?
            `pair-default`: Pair<Char, Number> = Pair("x", 123)
            
            `enum-pair`: Pair<MyEnum, MyEnum>
          }
          """
            .trimIndent(),
      )
    val output =
      runToStdout(
        CliBaseOptions(sourceModules = listOf(moduleUri)),
        listOf("--pair=a=0.0", "--enum-pair=a=b"),
      )
    assertThat(output)
      .isEqualTo(
        """
        pair = Pair("a", 0.0)
        `pair-nullable` = null
        `pair-default` = Pair("x", 123)
        `enum-pair` = Pair("a", "b")

        """
          .trimIndent()
      )
  }

  @Test
  fun `convert Duration`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            @Argument { convert = module.convertDuration }
            a: Duration
            @Argument { convert = module.convertDuration }
            b: Duration
            @Argument { convert = module.convertDuration }
            c: Duration
            @Argument { convert = module.convertDuration }
            d: Duration
          }
          """
            .trimIndent(),
      )
    val output =
      runToStdout(
        CliBaseOptions(sourceModules = listOf(moduleUri)),
        listOf("10.h", "10H", "10.5.MS", "10.5d"),
      )
    assertThat(output)
      .isEqualTo(
        """
        a = 10.h
        b = 10.h
        c = 10.5.ms
        d = 10.5.d

        """
          .trimIndent()
      )
  }

  @Test
  fun `convert DataSize`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            @Argument { convert = module.convertDataSize }
            a: DataSize
            @Argument { convert = module.convertDataSize }
            b: DataSize
            @Argument { convert = module.convertDataSize }
            c: DataSize
            @Argument { convert = module.convertDataSize }
            d: DataSize
          }
          """
            .trimIndent(),
      )
    val output =
      runToStdout(
        CliBaseOptions(sourceModules = listOf(moduleUri)),
        listOf("10.gb", "10GB", "10.5.MB", "10.5tib"),
      )
    assertThat(output)
      .isEqualTo(
        """
        a = 10.gb
        b = 10.gb
        c = 10.5.mb
        d = 10.5.tib

        """
          .trimIndent()
      )
  }

  @Test
  fun `convert import`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        """
        extends "pkl:Command"

        options: Options

        output {
          value = (options) {
            fromImport {
             baz = true // assert that imported modules are not forced
            }
          }
        }

        class Options {
          @Argument { convert = (it) -> new Import{ uri = it } }
          fromImport: Module
        }
        """
          .trimIndent(),
      )

    val importUri =
      writePklFile(
        "import.pkl",
        """
        foo = 1
        bar = "baz"
        baz: Boolean
        """
          .trimIndent(),
      )

    val output =
      runToStdout(CliBaseOptions(sourceModules = listOf(moduleUri)), listOf(importUri.toString()))
    assertThat(output)
      .isEqualTo(
        """
        fromImport {
          foo = 1
          bar = "baz"
          baz = true
        }

        """
          .trimIndent()
      )
  }

  @Test
  fun `transformAll import`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        """
        extends "pkl:Command"

        options: Options

        output {
          value = (options) {
            fromImport {
             baz = true // assert that imported modules are not forced
            }
          }
        }

        class Options {
          @Flag {
            convert = (it) -> new Import{ uri = it }
            transformAll = (values) -> values.firstOrNull ?? new Import { uri = "./default.pkl" }
          }
          fromImport: Module
        }
        """
          .trimIndent(),
      )

    val importUri =
      writePklFile(
        "default.pkl",
        """
        foo = 1
        bar = "baz"
        baz: Boolean
        """
          .trimIndent(),
      )

    val output =
      runToStdout(
        CliBaseOptions(sourceModules = listOf(moduleUri), workingDir = tempDir),
        emptyList(),
      )
    assertThat(output)
      .isEqualTo(
        """
        fromImport {
          foo = 1
          bar = "baz"
          baz = true
        }

        """
          .trimIndent()
      )
  }

  @Test
  fun `convert glob import`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        """
        extends "pkl:Command"
        import "base.pkl"

        options: Options

        output {
          value = (options) {
            fromGlobImport {
              [[true]] {
                baz = true // assert that imported modules are not forced
              }
            }
          }
        }

        class Options {
          @Argument { convert = (it) -> new Import { uri = it; glob = true }; multiple = false }
          fromGlobImport: Mapping<String, base>
        }
        """
          .trimIndent(),
      )

    val baseImport =
      writePklFile(
        "base.pkl",
        """
        foo: Int
        bar: String
        baz: Boolean
        """
          .trimIndent(),
      )
    writePklFile(
      "glob1.pkl",
      """
      amends "base.pkl"
      foo = 1
      bar = "baz"
      """
        .trimIndent(),
    )
    writePklFile(
      "glob2.pkl",
      """
      amends "base.pkl"
      foo = 2
      bar = "qux"
      """
        .trimIndent(),
    )

    val importDirUri = baseImport.resolve(".")

    val output =
      runToStdout(
        CliBaseOptions(sourceModules = listOf(moduleUri)),
        listOf(importDirUri.resolve("./glob*.pkl").toString()),
      )
    assertThat(output.replace(importDirUri.toString(), "file:/<dir>/"))
      .isEqualTo(
        """
        fromGlobImport {
          ["file:/<dir>/glob1.pkl"] {
            foo = 1
            bar = "baz"
            baz = true
          }
          ["file:/<dir>/glob2.pkl"] {
            foo = 2
            bar = "qux"
            baz = true
          }
        }

        """
          .trimIndent()
      )
  }

  @Test
  fun `convert that throws`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            @Argument { convert = (it) -> throw("oops!") }
            foo: String
          }
          """
            .trimIndent(),
      )

    val exc =
      assertThrows<CliktError> {
        runToStdout(CliBaseOptions(sourceModules = listOf(moduleUri)), listOf("hi"))
      }
    assertThat(exc.message).contains("oops!")
  }

  @Test
  fun `convert with eval error`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            @Argument { convert = (it) -> it.noSuchMethod() }
            foo: String
          }
          """
            .trimIndent(),
      )

    val exc =
      assertThrows<CliktError> {
        runToStdout(CliBaseOptions(sourceModules = listOf(moduleUri)), listOf("hi"))
      }
    assertThat(exc.message).contains("Cannot find method `noSuchMethod` in class `String`.")
  }

  @Test
  fun `convert with stack overflow`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          const function overflow(it) = overflow(it)
          class Options {
            @Argument { convert = (it) -> overflow(it) }
            foo: String
          }
          """
            .trimIndent(),
      )

    val exc =
      assertThrows<CliktError> {
        runToStdout(CliBaseOptions(sourceModules = listOf(moduleUri)), listOf("hi"))
      }
    assertThat(exc.message).contains("A stack overflow occurred.")
  }

  @Test
  fun `boolean flag`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            @BooleanFlag
            `bool-true`: Boolean
            @BooleanFlag
            `bool-false`: Boolean
            @BooleanFlag
            `bool-nullable`: Boolean?
            @BooleanFlag
            `bool-default-true`: Boolean = true
            @BooleanFlag
            `bool-default-false`: Boolean = false
          }
          """
            .trimIndent(),
      )

    val output =
      runToStdout(
        CliBaseOptions(sourceModules = listOf(moduleUri)),
        listOf("--bool-true", "--no-bool-false"),
      )
    assertThat(output)
      .isEqualTo(
        """
        `bool-true` = true
        `bool-false` = false
        `bool-nullable` = null
        `bool-default-true` = true
        `bool-default-false` = false

        """
          .trimIndent()
      )
  }

  @Test
  fun `boolean flag with bad type`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            @BooleanFlag
            foo: String
          }
          """
            .trimIndent(),
      )

    val exc =
      assertThrows<CliException> {
        runToStdout(CliBaseOptions(sourceModules = listOf(moduleUri)), listOf("hi"))
      }
    assertThat(exc.message)
      .contains("Option `foo` with annotation `@BooleanFlag` has invalid type `String`.")
  }

  @Test
  fun `counted flag`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            @CountedFlag { shortName = "a" }
            int: Int
            @CountedFlag { shortName = "b" }
            int8: Int8
            @CountedFlag { shortName = "c" }
            int16: Int16
            @CountedFlag { shortName = "d" }
            int32: Int32
            @CountedFlag { shortName = "x" }
            uint: UInt
            @CountedFlag { shortName = "y" }
            uint8: UInt8
            @CountedFlag { shortName = "g" }
            uint16: UInt16
            @CountedFlag { shortName = "i" }
            uint32: UInt32
          }
          """
            .trimIndent(),
      )

    val output =
      runToStdout(
        CliBaseOptions(sourceModules = listOf(moduleUri)),
        listOf("-abbcccddddxxxxxyyyyyygggggggiiiiiiii"),
      )
    assertThat(output)
      .isEqualTo(
        """
        int = 1
        int8 = 2
        int16 = 3
        int32 = 4
        uint = 5
        uint8 = 6
        uint16 = 7
        uint32 = 8

        """
          .trimIndent()
      )
  }

  @Test
  fun `test transformAll`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            @Flag {
              multiple = true
              transformAll = (values) -> values.fold(0, (res, acc) -> res + acc)
            }
            foo: Int
          }
          """
            .trimIndent(),
      )

    val output =
      runToStdout(
        CliBaseOptions(sourceModules = listOf(moduleUri)),
        listOf("--foo=1", "--foo=5", "--foo=8"),
      )
    assertThat(output)
      .isEqualTo(
        """
        foo = 14

        """
          .trimIndent()
      )
  }

  @Test
  fun `completion candidates`() {
    val moduleUri =
      writePklFile(
        "cmd.pkl",
        renderOptions +
          """
          class Options {
            none: String?
            enum: *"a" | "b" | "c"
            @Flag { completionCandidates = "paths" }
            path: String?
            @Flag { completionCandidates { "foo"; "bar"; "baz" } }
            explicit: String?
            @Argument
            enumArg: *"a" | "b" | "c"
            @Argument { completionCandidates = "paths" }
            pathArg: String
            @Argument { completionCandidates { "foo"; "bar"; "baz" } }
            explicitArg: String
          }
          """
            .trimIndent(),
      )
    val exc =
      assertThrows<PrintCompletionMessage> {
        runToStdout(
          CliBaseOptions(sourceModules = listOf(moduleUri)),
          listOf("a", "foo", "bar", "shell-completion", "bash"),
        )
      }
    assertThat(exc.message)
      .contains(
        """
    "--none")
      ;;
    "--enum")
      COMPREPLY=($(compgen -W 'a b c' -- "${'$'}{word}"))
      ;;
    "--path")
       __complete_files "${'$'}{word}"
      ;;
    "--explicit")
      COMPREPLY=($(compgen -W 'bar baz foo' -- "${'$'}{word}"))
      ;;
    "--help")
      ;;
    "enumArg")
      COMPREPLY=($(compgen -W '' -- "${'$'}{word}"))
      ;;
    "pathArg")
       __complete_files "${'$'}{word}"
      ;;
    "explicitArg")
      COMPREPLY=($(compgen -W 'bar baz foo' -- "${'$'}{word}"))
      ;;"""
      )
  }
}