action.yml

name: 'Setup mockd'
description: 'Install and optionally start the mockd mock server for integration testing'
author: 'Mockd LLC'
branding:
  icon: 'server'
  color: 'purple'

inputs:
  version:
    description: 'mockd version to install (e.g., "0.4.4"). Default: latest release.'
    required: false
    default: 'latest'
  github-token:
    description: 'GitHub token for API requests (avoids rate limiting when resolving latest version)'
    required: false
    default: ${{ github.token }}
  start:
    description: 'Start mockd server in background after install'
    required: false
    default: 'false'
  config:
    description: 'Path to mockd.yaml config file to load on start'
    required: false
  port:
    description: 'Mock server port (default: 4280)'
    required: false
    default: '4280'
  admin-port:
    description: 'Admin API port (default: 4290)'
    required: false
    default: '4290'
  log-level:
    description: 'Server log level: debug, info, warn, error'
    required: false
    default: 'warn'

outputs:
  version:
    description: 'Installed mockd version'
    value: ${{ steps.install.outputs.version }}
  mockd-url:
    description: 'Mock server base URL (e.g., http://localhost:4280)'
    value: ${{ steps.start-server.outputs.mockd-url }}
  admin-url:
    description: 'Admin API base URL (e.g., http://localhost:4290)'
    value: ${{ steps.start-server.outputs.admin-url }}
  cache-hit:
    description: 'Whether the binary was found in cache'
    value: ${{ steps.cache.outputs.cache-hit }}

runs:
  using: 'composite'
  steps:
    - name: Resolve version
      id: resolve
      shell: bash
      env:
        INPUT_VERSION: ${{ inputs.version }}
        GH_TOKEN: ${{ inputs.github-token }}
      run: |
        if [ "$INPUT_VERSION" = "latest" ]; then
          VERSION=$(gh api repos/getmockd/mockd/releases/latest --jq '.tag_name' | sed 's/^v//')
          echo "Resolved latest version: $VERSION"
        else
          VERSION=$(echo "$INPUT_VERSION" | sed 's/^v//')
        fi
        echo "version=$VERSION" >> "$GITHUB_OUTPUT"

    - name: Detect platform
      id: platform
      shell: bash
      run: |
        OS=$(uname -s | tr '[:upper:]' '[:lower:]')
        ARCH=$(uname -m)
        case "$ARCH" in
          x86_64|amd64) ARCH="amd64" ;;
          aarch64|arm64) ARCH="arm64" ;;
          *) echo "::error::Unsupported architecture: $ARCH"; exit 1 ;;
        esac
        case "$OS" in
          linux|darwin) ;;
          mingw*|msys*|cygwin*) OS="windows" ;;
          *) echo "::error::Unsupported OS: $OS"; exit 1 ;;
        esac
        BINARY="mockd-${OS}-${ARCH}"
        [ "$OS" = "windows" ] && BINARY="${BINARY}.exe"
        echo "os=$OS" >> "$GITHUB_OUTPUT"
        echo "arch=$ARCH" >> "$GITHUB_OUTPUT"
        echo "binary=$BINARY" >> "$GITHUB_OUTPUT"

    - name: Cache mockd binary
      id: cache
      uses: actions/cache@v4
      with:
        path: ${{ runner.temp }}/mockd-bin
        key: mockd-${{ steps.resolve.outputs.version }}-${{ steps.platform.outputs.os }}-${{ steps.platform.outputs.arch }}

    - name: Download mockd
      if: steps.cache.outputs.cache-hit != 'true'
      shell: bash
      env:
        VERSION: ${{ steps.resolve.outputs.version }}
        BINARY: ${{ steps.platform.outputs.binary }}
      run: |
        mkdir -p "$RUNNER_TEMP/mockd-bin"
        BASE_URL="https://github.com/getmockd/mockd/releases/download/v${VERSION}"
        URL="${BASE_URL}/${BINARY}"
        echo "Downloading mockd v${VERSION} from ${URL}"
        curl -fsSL -o "$RUNNER_TEMP/mockd-bin/mockd" "$URL"

        # Try per-binary .sha256 sidecar first, fall back to checksums.txt
        EXPECTED=""
        if curl -fsSL -o "$RUNNER_TEMP/mockd-bin/mockd.sha256" "${URL}.sha256" 2>/dev/null; then
          EXPECTED=$(awk '{print $1}' "$RUNNER_TEMP/mockd-bin/mockd.sha256")
          echo "Using per-binary checksum sidecar"
        elif curl -fsSL -o "$RUNNER_TEMP/mockd-bin/checksums.txt" "${BASE_URL}/checksums.txt" 2>/dev/null; then
          EXPECTED=$(grep "  ${BINARY}$" "$RUNNER_TEMP/mockd-bin/checksums.txt" | awk '{print $1}')
          echo "Using checksums.txt (sidecar not found)"
        fi

        if [ -z "$EXPECTED" ]; then
          echo "::warning::No checksum found for ${BINARY} — skipping verification"
        else
          ACTUAL=$(sha256sum "$RUNNER_TEMP/mockd-bin/mockd" | awk '{print $1}')
          if [ "$EXPECTED" != "$ACTUAL" ]; then
            echo "::error::SHA256 checksum mismatch! Expected: $EXPECTED, Got: $ACTUAL"
            exit 1
          fi
          echo "Checksum verified: $ACTUAL"
        fi
        chmod +x "$RUNNER_TEMP/mockd-bin/mockd"

    - name: Install mockd
      id: install
      shell: bash
      env:
        VERSION: ${{ steps.resolve.outputs.version }}
      run: |
        echo "$RUNNER_TEMP/mockd-bin" >> "$GITHUB_PATH"
        echo "version=$VERSION" >> "$GITHUB_OUTPUT"
        "$RUNNER_TEMP/mockd-bin/mockd" version
        echo "::notice::mockd v${VERSION} installed"

    - name: Start mockd server
      id: start-server
      if: inputs.start == 'true'
      shell: bash
      env:
        PORT: ${{ inputs.port }}
        ADMIN_PORT: ${{ inputs.admin-port }}
        LOG_LEVEL: ${{ inputs.log-level }}
        CONFIG: ${{ inputs.config }}
      run: |
        ARGS="--no-auth --port $PORT --admin-port $ADMIN_PORT --log-level $LOG_LEVEL"
        [ -n "$CONFIG" ] && ARGS="$ARGS --config $CONFIG"

        echo "Starting mockd serve $ARGS"
        nohup "$RUNNER_TEMP/mockd-bin/mockd" serve $ARGS > "$RUNNER_TEMP/mockd.log" 2>&1 &
        PID=$!
        echo "$PID" > "$RUNNER_TEMP/mockd.pid"
        echo "mockd started with PID $PID"

        # Wait for health check
        for i in $(seq 1 30); do
          if curl -sf "http://localhost:${ADMIN_PORT}/health" > /dev/null 2>&1; then
            echo "mockd is healthy after ${i}s"
            echo "mockd-url=http://localhost:${PORT}" >> "$GITHUB_OUTPUT"
            echo "admin-url=http://localhost:${ADMIN_PORT}" >> "$GITHUB_OUTPUT"
            echo "::notice::mockd server running on :${PORT} (admin :${ADMIN_PORT})"
            exit 0
          fi
          sleep 1
        done

        echo "::error::mockd failed to start within 30s"
        cat "$RUNNER_TEMP/mockd.log"
        exit 1