test.yml

name: Test

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
  # Daily canary: the action installs from neokapi/neokapi releases, so it can
  # break without a commit here (a renamed release asset did exactly that for
  # 1.2.0). The schedule catches that class of breakage; the prerelease job
  # below catches it while it is still an RC.
  schedule:
    - cron: "17 5 * * *"
  workflow_dispatch:

jobs:
  test-latest:
    name: "Latest (${{ matrix.os }})"
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
    steps:
      - uses: actions/checkout@v6

      - name: Setup kapi (latest)
        id: setup
        uses: ./
        with:
          token: ${{ secrets.NEOKAPI_GITHUB_TOKEN }}

      - name: Verify version output
        shell: bash
        env:
          INSTALLED_VERSION: ${{ steps.setup.outputs.version }}
        run: |
          echo "Installed version: ${INSTALLED_VERSION}"
          test -n "${INSTALLED_VERSION}"

      - name: Verify kapi is on PATH
        shell: bash
        run: kapi version

  test-pinned:
    name: "Pinned version (${{ matrix.os }})"
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
    steps:
      - uses: actions/checkout@v6

      - name: Get latest version for pinned test
        id: version
        shell: bash
        env:
          GH_TOKEN: ${{ secrets.NEOKAPI_GITHUB_TOKEN }}
        # Use the action's own resolver rather than a second copy of the logic.
        # This step used to call `releases/latest` directly and hit exactly the
        # bug the action had: neokapi/neokapi publishes plugin and app releases
        # alongside CLI ones, so that flag lands on whichever was published last
        # (a plugin, today), and the pinned test then asked for version
        # "check-v0.1.0".
        run: |
          VERSION=$(./scripts/resolve-version.sh latest)
          echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
          echo "Pinning to CLI version ${VERSION}"

      - name: Setup kapi (pinned)
        id: setup
        uses: ./
        with:
          token: ${{ secrets.NEOKAPI_GITHUB_TOKEN }}
          version: ${{ steps.version.outputs.version }}

      - name: Verify correct version
        shell: bash
        env:
          EXPECTED: ${{ steps.version.outputs.version }}
          ACTUAL: ${{ steps.setup.outputs.version }}
        run: |
          echo "Expected: ${EXPECTED}, Actual: ${ACTUAL}"
          test "${EXPECTED}" = "${ACTUAL}"

  # Canary against the newest CLI prerelease. Release packaging changes land
  # on RCs first (the kapi_ → kapi-cli_ archive rename shipped on 1.2.0-rc1),
  # so installing the newest prerelease here fails weeks before the same
  # breakage would reach a stable release and every consumer workflow.
  test-prerelease:
    name: "Prerelease canary"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6

      - name: Resolve newest CLI prerelease
        id: prerelease
        shell: bash
        env:
          GH_TOKEN: ${{ secrets.NEOKAPI_GITHUB_TOKEN }}
        # Same tag discipline as resolve-version.sh: only vX.Y.Z-… CLI tags,
        # never plugin/app tags (check-v…, asr-v…, bowrain-v…).
        run: |
          VERSION=$(
            gh api "repos/neokapi/neokapi/releases?per_page=100" --paginate \
              --jq '.[] | select(.draft == false and .prerelease == true) | .tag_name' |
              grep -E '^v[0-9]+\.[0-9]+\.[0-9]+-' |
              sed 's/^v//' |
              sort -V |
              tail -n 1
          ) || true
          if [ -z "${VERSION}" ]; then
            echo "No CLI prerelease found — nothing to canary."
          else
            echo "Newest CLI prerelease: ${VERSION}"
          fi
          echo "version=${VERSION}" >> "$GITHUB_OUTPUT"

      - name: Setup kapi (prerelease)
        if: steps.prerelease.outputs.version != ''
        id: setup
        uses: ./
        with:
          token: ${{ secrets.NEOKAPI_GITHUB_TOKEN }}
          version: ${{ steps.prerelease.outputs.version }}

      - name: Verify kapi is on PATH
        if: steps.prerelease.outputs.version != ''
        shell: bash
        run: kapi version

  test-cache:
    name: "Cache hit (${{ matrix.os }})"
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
    steps:
      - uses: actions/checkout@v6

      # First install — populates cache
      - name: Setup kapi (first)
        uses: ./
        with:
          token: ${{ secrets.NEOKAPI_GITHUB_TOKEN }}

      # Second install — should hit cache
      - name: Setup kapi (cached)
        uses: ./
        with:
          token: ${{ secrets.NEOKAPI_GITHUB_TOKEN }}

      - name: Verify kapi works from cache
        shell: bash
        run: kapi version