main job ajo tässä haarassa

refaktorointia
2026-06-15 17:01:26 +03:00 · 2026-06-15 16:56:22 +03:00 · 2026-06-15 16:49:44 +03:00 · 2026-06-15 16:38:27 +03:00 · 2026-06-15 16:10:55 +03:00 · 2026-06-15 15:59:35 +03:00
21 changed files with 812 additions and 351 deletions
@@ -1,30 +0,0 @@
 #!/usr/bin/env bash
 set -euo pipefail
 SHA8="${GITHUB_SHA:0:8}"
 REPORTS_DIR="reports/${SHA8}"
 mkdir -p "${REPORTS_DIR}"
 BATS_PASS=$(grep -c 'ok' "${REPORTS_DIR}/bats/results.txt" 2>/dev/null || echo 0)
 BATS_FAIL=$(grep -c 'not ok' "${REPORTS_DIR}/bats/results.txt" 2>/dev/null || echo 0)
 CUCUMBER_PASS=$(jq '.summary.passed // 0' "${REPORTS_DIR}/cucumber/report.json" 2>/dev/null || echo 0)
 CUCUMBER_FAIL=$(jq '.summary.failed // 0' "${REPORTS_DIR}/cucumber/report.json" 2>/dev/null || echo 0)
 {
  echo "<!DOCTYPE html><html><head><meta charset='utf-8'>"
  echo "<title>CI report ${SHA8}</title>"
  echo "<style>body{font-family:sans-serif;margin:2em}a{color:#2563eb}table{border-collapse:collapse}"
  echo "th,td{border:1px solid #ccc;padding:8px;text-align:left}"
  echo ".pass{color:#059669}.fail{color:#dc2626}</style></head><body>"
  echo "<h1>CI report <code>${SHA8}</code></h1>"
  echo "<p>Commit: ${GITHUB_SHA}<br>Branch: ${GITHUB_REF_NAME}<br>Run: ${GITHUB_RUN_ID}</p>"
  echo "<table><tr><th>Suite</th><th>Passed</th><th>Failed</th><th>Report</th></tr>"
  echo "<tr><td>Bats</td><td class='pass'>${BATS_PASS}</td><td class='fail'>${BATS_FAIL}</td>"
  echo "<td><a href='bats/results.txt'>results.txt</a>"
  echo " | <a href='bats/junit.xml'>junit.xml</a></td></tr>"
  echo "<tr><td>Cucumber</td><td class='pass'>${CUCUMBER_PASS}</td><td class='fail'>${CUCUMBER_FAIL}</td>"
  echo "<td><a href='cucumber/index.html'>report</a>"
  echo " | <a href='cucumber/report.json'>json</a></td></tr>"
  echo "</table></body></html>"
 } > "${REPORTS_DIR}/index.html"
@@ -1,124 +0,0 @@
 name: Build & Publish Artifact
 on:
  workflow_call:
    inputs:
      env_json:
        required: true
        type: string
      bats-image:
        required: true
        type: string
      cucumber-node-image:
        required: true
        type: string
    secrets:
      GITEA_TOKEN:
        required: true
      GIT_PAGES_PUBLISH_TOKEN:
        required: true
 env:
  GITEA_API_URL: ${{ fromJson(inputs.env_json).GITEA_API_URL }}
  GIT_PAGES_URL: ${{ fromJson(inputs.env_json).GIT_PAGES_URL }}
  GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
  GIT_PAGES_PUBLISH_TOKEN: ${{ secrets.GIT_PAGES_PUBLISH_TOKEN }}
 jobs:
  check:
    runs-on: ubuntu-latest
    outputs:
      artifact_exists: ${{ steps.check.outputs.artifact_exists }}
      version: ${{ steps.check.outputs.version }}
    steps:
      - uses: actions/checkout@v4
      - name: Check existing artifact
        id: check
        run: |
          VERSION=$(jq -r '.version' package.json)
          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
          TAG=$(curl -s "$GITEA_API_URL/api/v1/repos/$GITHUB_REPOSITORY/tags" | \
            jq -r '.[] | select(.commit.sha == "'"$GITHUB_SHA"'") | .name' | head -1)
          if [ -n "$TAG" ]; then
            echo "artifact_exists=true" >> "$GITHUB_OUTPUT"
            echo "Commit already tagged as $TAG, skipping build"
          else
            echo "artifact_exists=false" >> "$GITHUB_OUTPUT"
          fi
  quality-gate:
    needs: [check]
    if: needs.check.outputs.artifact_exists == 'false'
    uses: niko/gitea-ci-library/.gitea/workflows/quality-gate.yml@main
    secrets: inherit
    with:
      env_json: ${{ inputs.env_json }}
      bats-image: ${{ inputs.bats-image }}
      cucumber-node-image: ${{ inputs.cucumber-node-image }}
  build:
    needs: [check, quality-gate]
    if: needs.check.outputs.artifact_exists == 'false'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Build container
        run: |
          docker build -t "minimal:${{ needs.check.outputs.version }}" .
          mkdir -p /tmp/image
          docker save "minimal:${{ needs.check.outputs.version }}" -o /tmp/image/artifact.tar
      - name: Save Docker image for next job
        uses: actions/upload-artifact@v4
        with:
          name: docker-image
          path: /tmp/image/artifact.tar
  push:
    needs: [check, build]
    runs-on: ubuntu-latest
    steps:
      - name: Load saved Docker image
        uses: actions/download-artifact@v4
        with:
          name: docker-image
          path: /tmp/image
      - name: Push to Gitea Packages
        run: |
          VERSION="${{ needs.check.outputs.version }}"
          docker load -i /tmp/image/artifact.tar
          REGISTRY=$(echo "$GITEA_API_URL" | sed 's|https://||')
          IMAGE="$REGISTRY/niko/gitea-ci-library/minimal:$VERSION"
          docker tag "minimal:$VERSION" "$IMAGE"
          docker login "$REGISTRY" -u niko -p "$GITEA_TOKEN"
          docker push "$IMAGE"
          docker logout "$REGISTRY"
  tag-commit:
    needs: [check, push]
    runs-on: ubuntu-latest
    steps:
      - name: Create git tag
        run: |
          VERSION="${{ needs.check.outputs.version }}"
          HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST \
            "$GITEA_API_URL/api/v1/repos/$GITHUB_REPOSITORY/tags" \
            -H "Authorization: token $GITEA_TOKEN" \
            -H "Content-Type: application/json" \
            -d "{
              \"tag_name\": \"$VERSION\",
              \"message\": \"Build #$GITHUB_RUN_NUMBER\",
              \"target\": \"$GITHUB_SHA\"
            }")
          if [ "$HTTP_CODE" = "201" ]; then
            echo "Tag $VERSION created"
          elif [ "$HTTP_CODE" = "409" ]; then
            echo "Tag $VERSION already exists (parallel build won), skipping"
          else
            echo "Failed to create tag: HTTP $HTTP_CODE"
            exit 1
          fi
@@ -0,0 +1,64 @@
 name: Check Existing Artifact
 on:
  workflow_call:
    inputs:
      env_json:
        required: true
        type: string
    secrets:
      GITEA_TOKEN:
        required: true
    outputs:
      artifact_exists:
        value: ${{ jobs.check.outputs.artifact_exists }}
      version:
        value: ${{ jobs.check.outputs.version }}
 env:
  GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
 jobs:
  check:
    runs-on: ubuntu-latest
    outputs:
      artifact_exists: ${{ steps.set-outputs.outputs.artifact_exists }}
      version: ${{ steps.set-outputs.outputs.version }}
    steps:
      - uses: actions/checkout@v4
      - name: Check existing artifact and calculate version
        run: |
          RAW_VERSION=$(jq -r '.version' package.json)
          BASE_VERSION=$(echo "$RAW_VERSION" | cut -d'.' -f1-2)
          echo "gitea-ci-library - Tunnistettu Major.Minor versio: $BASE_VERSION"
          TAGS_JSON=$(curl -s -f -H "Authorization: token $GITEA_TOKEN" \
            "${{ gitea.server_url }}/api/v1/repos/${{ gitea.repository }}/tags")
          TAG=$(echo "$TAGS_JSON" | jq -r 'if type == "array" then .[] | select(.commit.sha == "${{ github.sha }}") | .name else empty end' | head -1)
          mkdir -p /tmp/build-ctx
          if [ -n "$TAG" ]; then
            echo "ARTIFACT_EXISTS=true" > /tmp/build-ctx/build.env
            echo "NEXT_VERSION=$TAG" >> /tmp/build-ctx/build.env
            echo "gitea-ci-library - Artefakti löytyi jo tagilla: $TAG."
          else
            echo "ARTIFACT_EXISTS=false" > /tmp/build-ctx/build.env
            HIGHEST_PATCH=$(echo "$TAGS_JSON" | jq -r --arg bv "$BASE_VERSION." '
              if type == "array" then .[] | .name | select(startswith($bv)) | sub($bv; "") | tonumber else empty end' | sort -rn | head -1)
            if [ -z "$HIGHEST_PATCH" ]; then NEXT_PATCH=0; else NEXT_PATCH=$((HIGHEST_PATCH + 1)); fi
            FULL_VERSION="${BASE_VERSION}.${NEXT_PATCH}"
            echo "NEXT_VERSION=$FULL_VERSION" >> /tmp/build-ctx/build.env
            echo "gitea-ci-library - Uusi vapaa versio: $FULL_VERSION"
          fi
      - name: Set job outputs
        id: set-outputs
        run: |
          source /tmp/build-ctx/build.env
          echo "artifact_exists=$ARTIFACT_EXISTS" >> "$GITHUB_OUTPUT"
          echo "version=$NEXT_VERSION" >> "$GITHUB_OUTPUT"
@@ -1,34 +0,0 @@
 name: CI
 on:
  push:
    branches: ["**"]
  workflow_dispatch:
 jobs:
  load-config:
    name: Load gitea-env.conf to pipeline env
    uses: niko/gitea-ci-library/.gitea/workflows/config-provider.yml@main
    with:
      config_path: .gitea/workflows/gitea-env.conf
  feature:
    name: Quality Gate
    if: github.ref != 'refs/heads/main'
    needs: [load-config]
    uses: niko/gitea-ci-library/.gitea/workflows/quality-gate.yml@main
    secrets: inherit
    with:
      env_json: ${{ needs.load-config.outputs.env_json }}
      bats-image: bats/bats:latest
      cucumber-node-image: node:22
  main:
    name: Build & Push Artifact
    if: github.ref == 'refs/heads/main'
    needs: [load-config]
    uses: niko/gitea-ci-library/.gitea/workflows/build_publish-artifact.yml@main
    secrets: inherit
    with:
      env_json: ${{ needs.load-config.outputs.env_json }}
      bats-image: bats/bats:latest
      cucumber-node-image: node:22
@@ -1,21 +1,41 @@
-name: Config Provider Library
+name: Config Provider
 on:
  workflow_call:
    inputs:
      config_path:
        required: true
        type: string
    secrets:
      GITEA_TOKEN:
        required: true
      GIT_PAGES_PUBLISH_TOKEN:
        required: true
    outputs:
      env_json:
        value: ${{ jobs.parse-config.outputs.json_data }}
      config_path:
        value: ${{ jobs.parse-config.outputs.config_path }}
 env:
  CI_CONF_FILE: ${{ inputs.config_path }}
  GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
  GIT_PAGES_PUBLISH_TOKEN: ${{ secrets.GIT_PAGES_PUBLISH_TOKEN }}
 jobs:
  parse-config:
    runs-on: ubuntu-latest
    outputs:
      json_data: ${{ steps.convert.outputs.JSON_OUT }}
      config_path: ${{ steps.set-path.outputs.CONFIG_PATH }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/checkout@v4
        with:
          repository: niko/gitea-ci-library
          path: .ci
      - name: Validate CI config
        run: bash .ci/scripts/ci-validate.sh
      - id: convert
        run: |
@@ -29,3 +49,6 @@ jobs:
          CLEAN_JSON=$(echo "$JSON_STRING" | jq -c .)
          echo "JSON_OUT=$CLEAN_JSON" >> "$GITHUB_OUTPUT"
      - id: set-path
        run: echo "CONFIG_PATH=${{ inputs.config_path }}" >> "$GITHUB_OUTPUT"
@@ -0,0 +1,101 @@
 name: Docker Build & Push
 on:
  workflow_call:
    inputs:
      env_json:
        required: true
        type: string
      version:
        required: true
        type: string
    secrets:
      GITEA_TOKEN:
        required: true
      DOCKER_USERNAME:
        required: false
      DOCKER_PASSWORD:
        required: true
 env:
  GITEA_API_URL: ${{ fromJson(inputs.env_json).GITEA_API_URL }}
  GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
  DOCKER_REGISTRY: ${{ fromJson(inputs.env_json).DOCKER_REGISTRY || '' }}
  DOCKER_IMAGE_NAME: ${{ fromJson(inputs.env_json).DOCKER_IMAGE_NAME || '' }}
  DOCKER_UI_URL: ${{ fromJson(inputs.env_json).DOCKER_UI_URL || '' }}
  VERSION: ${{ inputs.version }}
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
 jobs:
  build-push:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/checkout@v4
        with:
          repository: niko/gitea-ci-library
          path: .ci
      - name: Build and push container
        env:
          DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME || github.actor }}
          DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
        run: |
          NOW=$(date -u +%Y-%m-%dT%H:%M:%SZ)
          docker build \
            --label "git.commit=${{ github.sha }}" \
            --label "git.commitBy=${{ github.actor }}" \
            --label "build.date=${NOW}" \
            -t "${DOCKER_IMAGE_NAME}:${VERSION}" .
          REGISTRY="${DOCKER_REGISTRY:?DOCKER_REGISTRY not set in env.conf}"
          IMAGE="${DOCKER_IMAGE_NAME:?DOCKER_IMAGE_NAME not set in env.conf}"
          REGISTRY_HOST="${REGISTRY%%/*}"
          FULL_IMAGE="${REGISTRY}/${IMAGE}:${VERSION}"
          echo "Pushing ${FULL_IMAGE} ..."
          docker tag "${DOCKER_IMAGE_NAME}:${VERSION}" "$FULL_IMAGE"
          echo "$DOCKER_PASSWORD" | docker login "$REGISTRY_HOST" -u "$DOCKER_USERNAME" --password-stdin
          docker push "$FULL_IMAGE"
          docker logout "$REGISTRY_HOST"
      - name: Report status SUCCESS
        if: success()
        run: |
          CONTAINER_URL=""
          if [ -n "${DOCKER_UI_URL:-}" ] && [ -n "${VERSION:-}" ]; then
            CONTAINER_URL="${DOCKER_UI_URL}/${VERSION}"
          fi
          bash .ci/scripts/report-status.sh success "Docker build & push ${VERSION} OK" ci-docker-build-push "" "$CONTAINER_URL"
      - name: Report status FAILURE
        if: failure()
        run: bash .ci/scripts/report-status.sh failure "Docker build & push ${VERSION} FAILED" ci-docker-build-push
  tag-commit:
    runs-on: ubuntu-latest
    needs: [build-push]
    steps:
      - uses: actions/checkout@v4
      - name: Create git tag
        env:
          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
          SERVER_URL: ${{ gitea.server_url }}
          RUN_NUMBER: ${{ github.run_number }}
          SHA: ${{ github.sha }}
        run: |
          HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST \
            "$SERVER_URL/api/v1/repos/${{ github.repository }}/tags" \
            -H "Authorization: token $GITEA_TOKEN" \
            -H "Content-Type: application/json" \
            -d "{\"tag_name\": \"${VERSION}\", \"message\": \"Build #$RUN_NUMBER\", \"target\": \"$SHA\"}")
          if [ "$HTTP_CODE" = "201" ] || [ "$HTTP_CODE" = "409" ]; then
            exit 0
          else
            exit 1
          fi
@@ -0,0 +1,64 @@
 name: Bats Tests
 on:
  workflow_call:
    inputs:
      env_json:
        required: true
        type: string
      bats-image:
        required: true
        type: string
    secrets:
      GITEA_TOKEN:
        required: true
      GIT_PAGES_PUBLISH_TOKEN:
        required: true
 env:
  GITEA_API_URL: ${{ fromJson(inputs.env_json).GITEA_API_URL }}
  GIT_PAGES_URL: ${{ fromJson(inputs.env_json).GIT_PAGES_URL }}
  GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
  GIT_PAGES_PUBLISH_TOKEN: ${{ secrets.GIT_PAGES_PUBLISH_TOKEN }}
 jobs:
  bats:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/checkout@v4
        with:
          repository: niko/gitea-ci-library
          path: .ci
      - name: Run bats tests
        id: bats-tests
        shell: bash
        run: |
          docker volume create bats-workspace
          tar c . | docker run --rm -i -v bats-workspace:/data alpine tar x -C /data
          mkdir -p "reports/${GITHUB_SHA:0:8}/bats"
          set +e
          docker run --rm \
            -v bats-workspace:/data \
            --entrypoint bash ${{ inputs.bats-image }} \
            -c 'apk add -q lsof python3 jq curl ruby && cd /data && gem install bashcov -v 3.3.0 2>&1 | tail -1 && bashcov -- bats tests/' \
            > "reports/${GITHUB_SHA:0:8}/bats/results.txt" 2>&1
          BATS_EXIT=$?
          bash .ci/.gitea/scripts/bats-coverage.sh bats-workspace "reports/${GITHUB_SHA:0:8}/bats"
          docker volume rm bats-workspace > /dev/null 2>&1
          bash .ci/.gitea/scripts/bats-report.sh "reports/${GITHUB_SHA:0:8}/bats"
          echo "BATS_EXIT=${BATS_EXIT}" >> "${GITHUB_ENV}"
          exit ${BATS_EXIT}
      - name: Publish bats reports
        if: always()
        run: bash .ci/scripts/publish-git-pages.sh bats
      - name: Report status
        if: always()
        run: |
          if [ "${BATS_EXIT}" = "0" ]; then
            bash .ci/scripts/report-status.sh success "Link to Bats reports" unit-tests bats
          else
            bash .ci/scripts/report-status.sh failure "Link to Bats reports" unit-tests bats
          fi
@@ -0,0 +1,70 @@
 name: Cucumber Tests
 on:
  workflow_call:
    inputs:
      env_json:
        required: true
        type: string
      cucumber-node-image:
        required: true
        type: string
    secrets:
      GITEA_TOKEN:
        required: true
      GIT_PAGES_PUBLISH_TOKEN:
        required: true
 env:
  GITEA_API_URL: ${{ fromJson(inputs.env_json).GITEA_API_URL }}
  GIT_PAGES_URL: ${{ fromJson(inputs.env_json).GIT_PAGES_URL }}
  GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
  GIT_PAGES_PUBLISH_TOKEN: ${{ secrets.GIT_PAGES_PUBLISH_TOKEN }}
 jobs:
  cucumber:
    runs-on: ubuntu-latest
    container:
      image: ${{ inputs.cucumber-node-image }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/checkout@v4
        with:
          repository: niko/gitea-ci-library
          path: .ci
      - name: Run cucumber tests
        id: cucumber-tests
        shell: bash
        run: |
          apt-get update -qq && apt-get install -y -qq --no-install-recommends lsof jq
          npm install @cucumber/cucumber > /dev/null 2>&1
          mkdir -p "reports/${GITHUB_SHA:0:8}/cucumber"
          set +e
          npx cucumber-js \
            --format json:"reports/${GITHUB_SHA:0:8}/cucumber/report.json" \
            --format html:"reports/${GITHUB_SHA:0:8}/cucumber/index.html" 2>&1
          CUCUMBER_EXIT=$?
          echo "CUCUMBER_EXIT=${CUCUMBER_EXIT}" >> "${GITHUB_ENV}"
          exit ${CUCUMBER_EXIT}
      - name: Publish cucumber reports
        if: always()
        run: bash .ci/scripts/publish-git-pages.sh cucumber
      - name: Report status
        if: always()
        shell: bash
        run: |
          if [ "${CUCUMBER_EXIT}" = "0" ]; then
            if [ -f "reports/${GITHUB_SHA:0:8}/cucumber/index.html" ]; then
              bash .ci/scripts/report-status.sh success "Link to Cucumber reports" acc-tests cucumber
            else
              bash .ci/scripts/report-status.sh success "Link to Cucumber reports" acc-tests
            fi
          else
            if [ -f "reports/${GITHUB_SHA:0:8}/cucumber/index.html" ]; then
              bash .ci/scripts/report-status.sh failure "Link to Cucumber reports" acc-tests cucumber
            else
              bash .ci/scripts/report-status.sh failure "Link to Cucumber reports" acc-tests
            fi
          fi
@@ -0,0 +1,42 @@
 name: CI Feature
 on:
  push:
    branches-ignore:
      - feature/docker-kuntoon
      - main
  workflow_dispatch:
 jobs:
  load-config:
    name: Load example-gitea-env.conf to pipeline env
    uses: niko/gitea-ci-library/.gitea/workflows/config-provider.yml@feature/docker-kuntoon
    secrets: inherit
    with:
      config_path: .gitea/workflows/example-gitea-env.conf
  bats:
    name: Bats tests
    needs: [load-config]
    uses: niko/gitea-ci-library/.gitea/workflows/example-bats-tests.yml@feature/docker-kuntoon
    secrets: inherit
    with:
      env_json: ${{ needs.load-config.outputs.env_json }}
      bats-image: bats/bats:latest
  cucumber:
    name: Cucumber tests
    needs: [load-config]
    uses: niko/gitea-ci-library/.gitea/workflows/example-cucumber-tests.yml@feature/docker-kuntoon
    secrets: inherit
    with:
      env_json: ${{ needs.load-config.outputs.env_json }}
      cucumber-node-image: node:22
  report-summary:
    name: Report Summary
    needs: [load-config, bats, cucumber]
    if: always()
    uses: niko/gitea-ci-library/.gitea/workflows/example-report-summary.yml@feature/docker-kuntoon
    with:
      env_json: ${{ needs.load-config.outputs.env_json }}
      suites: bats cucumber
@@ -0,0 +1,5 @@
 GITEA_API_URL=https://gitea.app.keskikuja.site
 GIT_PAGES_URL=https://ci-reports.helm-dev.keskikuja.site
 DOCKER_REGISTRY=gitea.app.keskikuja.site/niko
 DOCKER_IMAGE_NAME=gitea-ci-library-test-image
 DOCKER_UI_URL=https://gitea.app.keskikuja.site/niko/-/packages/container/gitea-ci-library-test-image
@@ -0,0 +1,62 @@
 name: CI Main
 on:
  push:
    branches:
      - feature/docker-kuntoon
      - main
  workflow_dispatch:
 jobs:
  load-config:
    name: Load example-gitea-env.conf to pipeline env
    uses: niko/gitea-ci-library/.gitea/workflows/config-provider.yml@feature/docker-kuntoon
    secrets: inherit
    with:
      config_path: .gitea/workflows/example-gitea-env.conf
  check-version:
    name: Check existing artifact
    needs: [load-config]
    uses: niko/gitea-ci-library/.gitea/workflows/check-version.yml@feature/docker-kuntoon
    secrets: inherit
    with:
      env_json: ${{ needs.load-config.outputs.env_json }}
  bats:
    name: Bats tests
    needs: [load-config, check-version]
    if: needs.check-version.outputs.artifact_exists != 'true'
    uses: niko/gitea-ci-library/.gitea/workflows/example-bats-tests.yml@feature/docker-kuntoon
    secrets: inherit
    with:
      env_json: ${{ needs.load-config.outputs.env_json }}
      bats-image: bats/bats:latest
  cucumber:
    name: Cucumber tests
    needs: [load-config, check-version]
    if: needs.check-version.outputs.artifact_exists != 'true'
    uses: niko/gitea-ci-library/.gitea/workflows/example-cucumber-tests.yml@feature/docker-kuntoon
    secrets: inherit
    with:
      env_json: ${{ needs.load-config.outputs.env_json }}
      cucumber-node-image: node:22
  report-summary:
    name: Report Summary
    needs: [load-config, bats, cucumber]
    if: always()
    uses: niko/gitea-ci-library/.gitea/workflows/example-report-summary.yml@feature/docker-kuntoon
    with:
      env_json: ${{ needs.load-config.outputs.env_json }}
      suites: bats cucumber
  build-push:
    name: Build & Push Docker
    needs: [load-config, check-version, bats, cucumber]
    if: needs.check-version.outputs.artifact_exists != 'true'
    uses: niko/gitea-ci-library/.gitea/workflows/docker-build-push.yml@feature/docker-kuntoon
    secrets: inherit
    with:
      env_json: ${{ needs.load-config.outputs.env_json }}
      version: ${{ needs.check-version.outputs.version }}
@@ -0,0 +1,34 @@
 name: Report Summary
 on:
  workflow_call:
    inputs:
      env_json:
        required: true
        type: string
      suites:
        required: true
        type: string
        description: Space-separated suite names published to git-pages
 env:
  GIT_PAGES_URL: ${{ fromJson(inputs.env_json).GIT_PAGES_URL }}
 jobs:
  summary:
    runs-on: ubuntu-latest
    steps:
      - name: Generate report links
        shell: bash
        run: |
          SHA8="${GITHUB_SHA:0:8}"
          BASE="${GIT_PAGES_URL}/${GITHUB_REPOSITORY}/reports/${SHA8}"
          {
            echo "## Test Reports"
            echo ""
            echo "| Suite | Report |"
            echo "|-------|--------|"
            for suite in ${{ inputs.suites }}; do
              echo "| ${suite} | [View report](${BASE}/${suite}/) |"
            done
          } >> "${GITHUB_STEP_SUMMARY}"
@@ -1,2 +0,0 @@
 GITEA_API_URL=https://gitea.app.keskikuja.site
 GIT_PAGES_URL=https://ci-reports.helm-dev.keskikuja.site
@@ -1,133 +0,0 @@
 name: Quality Gate
 on:
  workflow_call:
    inputs:
      env_json:
        required: true
        type: string
      bats-image:
        required: true
        type: string
      cucumber-node-image:
        required: true
        type: string
    secrets:
      GITEA_TOKEN:
        required: true
      GIT_PAGES_PUBLISH_TOKEN:
        required: true
 env:
  GITEA_API_URL: ${{ fromJson(inputs.env_json).GITEA_API_URL }}
  GIT_PAGES_URL: ${{ fromJson(inputs.env_json).GIT_PAGES_URL }}
  GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
  GIT_PAGES_PUBLISH_TOKEN: ${{ secrets.GIT_PAGES_PUBLISH_TOKEN }}
 jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/checkout@v4
        with:
          repository: niko/gitea-ci-library
          path: .ci
      - name: Validate CI config
        run: bash .ci/scripts/ci-validate.sh
  bats:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/checkout@v4
        with:
          repository: niko/gitea-ci-library
          path: .ci
      - name: Run bats tests
        id: bats-tests
        shell: bash
        run: |
          docker volume create bats-workspace
          tar c . | docker run --rm -i -v bats-workspace:/data alpine tar x -C /data
          mkdir -p "reports/${GITHUB_SHA:0:8}/bats"
          set +e
          docker run --rm \
            -v bats-workspace:/data \
            --entrypoint bash ${{ inputs.bats-image }} \
            -c 'apk add -q lsof python3 jq curl ruby && cd /data && gem install bashcov -v 3.3.0 2>&1 | tail -1 && bashcov -- bats tests/' \
            > "reports/${GITHUB_SHA:0:8}/bats/results.txt" 2>&1
          BATS_EXIT=$?
          bash .ci/.gitea/scripts/bats-coverage.sh bats-workspace "reports/${GITHUB_SHA:0:8}/bats"
          docker volume rm bats-workspace > /dev/null 2>&1
          bash .ci/.gitea/scripts/bats-report.sh "reports/${GITHUB_SHA:0:8}/bats"
          echo "BATS_EXIT=${BATS_EXIT}" >> "${GITHUB_ENV}"
          exit ${BATS_EXIT}
      - name: Publish bats reports
        if: always()
        run: bash .ci/scripts/publish-git-pages.sh bats
      - name: Set bats commit status
        if: always()
        run: |
          if [ "${BATS_EXIT}" = "0" ]; then
            bash .ci/scripts/report-status.sh success "Bats tests" ci-bats bats
          else
            bash .ci/scripts/report-status.sh failure "Bats tests FAILED" ci-bats bats
          fi
  cucumber:
    runs-on: ubuntu-latest
    container:
      image: ${{ inputs.cucumber-node-image }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/checkout@v4
        with:
          repository: niko/gitea-ci-library
          path: .ci
      - name: Run cucumber tests
        id: cucumber-tests
        shell: bash
        run: |
          apt-get update -qq && apt-get install -y -qq --no-install-recommends lsof jq
          npm install @cucumber/cucumber > /dev/null 2>&1
          mkdir -p "reports/${GITHUB_SHA:0:8}/cucumber"
          set +e
          npx cucumber-js \
            --format json:"reports/${GITHUB_SHA:0:8}/cucumber/report.json" \
            --format html:"reports/${GITHUB_SHA:0:8}/cucumber/index.html" 2>&1
          CUCUMBER_EXIT=$?
          STATE="success"
          [ "${CUCUMBER_EXIT}" != "0" ] && STATE="failure"
          if [ -f "reports/${GITHUB_SHA:0:8}/cucumber/index.html" ]; then
            bash .ci/scripts/report-status.sh "${STATE}" "Cucumber tests" ci-cucumber cucumber
          else
            bash .ci/scripts/report-status.sh "${STATE}" "Cucumber tests" ci-cucumber
          fi
          exit ${CUCUMBER_EXIT}
      - name: Publish cucumber reports
        if: always()
        run: bash .ci/scripts/publish-git-pages.sh cucumber
  build:
    runs-on: ubuntu-latest
    needs: [bats, cucumber]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/checkout@v4
        with:
          repository: niko/gitea-ci-library
          path: .ci
      - name: Generate report index
        run: bash .ci/.gitea/scripts/generate-report-index.sh
      - name: Set build commit status
        run: bash .ci/scripts/report-status.sh success "Build complete" ci-build
@@ -102,34 +102,56 @@ Act runner suorittaa Gitea Actions workflowt. **IaC-lähde:** alla oleva Helm-sn
 klusterin totuus — muutokset vain snippetiin, sitten `helm upgrade --install` (ei käsin muokattuja
 arvoja klusterissa).
 > HUOM! Gitea ei ole vielä kunnolla stabiilissa tilassa, ja chart default dind sekä runner versiot ovat tätä tehdessä olleet bugiset. Niistä on olemassa uudemmat versiot, mutta eivät ole chartissa. Tätyy seurata ja päivittää tarpeen tulle.
 Asennus Kubernetes-klusteriin Helm chartilla:
-### 1. Rekisteröintitoken
+### 1. Rekisteröi token
 Hae token Giteasta:
 - **Organization-taso:** Org → Settings → Actions → Runners → Create new runner
 - **Globaali (site admin):** Site Admin → Actions → Runners → Create new runner
-### 2. Asenna runner
+### 2. variables
 ```bash
 GITEA_URL="https://<gitea-server-url>"
 GITEA_ACTIONS_TOKEN="<registration-token>"
 GITEA_ACTIONS_NAMESPACE="gitea-actions"
 ```
-helm repo add gitea https://dl.gitea.com/charts
+### 3. Tee secret vain init install yhteydessä
 helm repo update
 ```bash
 kubectl create secret generic act-runner-token \
  --from-literal=token="$GITEA_ACTIONS_TOKEN" \
  --namespace "$GITEA_ACTIONS_NAMESPACE" \
  --dry-run=client -o yaml | kubectl apply -f -
 ```
 ### 4. Helm install / upgrade
 Menee samalla komennolla. 
 > Muista asettaa variables ennen ajoa.
 Päivittää olemassa olevan installaation, käyttää olemassa olevaa secret
 ja sitä kautta Gitea ei tarvitse päivityksessä mitään temppuja.
 Päivityksen jälkeen muista tappaa pod (käynnistyy automaattisesti uudelleen), että lataa varmasti kaikki uudesta. Sillä ConfigMap tms eivät lataudu
 mikäli pod jatkaa ajamista.
 ```bash
 helm repo add gitea https://dl.gitea.com/charts
 helm repo update
 helm upgrade --install act-runner gitea/actions \
  --set enabled=true \
  --set giteaRootURL="$GITEA_URL" \
  --set existingSecret=act-runner-token \
  --set existingSecretKey=token \
  --set statefulset.runner.tag=1.0.8 \
  --set statefulset.dind.tag=29.5.2-dind \
  --set-string 'statefulset.runner.config=log:
  level: info
@@ -0,0 +1,85 @@
 # 7. Statusraportoinnin pattern
 ## Päätös
 Gitea Actionsin natiivi job-status on ensisijainen. Commit-status API:a
 (`report-status.sh`) käytetään **vain** kun työvaihe tuottaa ulkoisen linkin
 (testiraportti, Docker registry), jota natiivistaatus ei tue.
 ### Tool-jobit (validate, check-version, tag-commit)
 Ei API-kutsuja. Luotetaan Gitean omaan job-statukseen.
 ```yaml
 - uses: actions/checkout@v4
 - name: Do work
  run: do-something
 ```
 ### Test-jobit (bats, cucumber)
 API:a käytetään raporttilinkin upottamiseksi commit-näkymään.
 ```
 testit → publish (always) → status (always, exit-koodin mukaan)
 ```
 ```yaml
 - name: Run tests
  shell: bash
  run: |
    run-tests
    EXIT=$?
    echo "EXIT=${EXIT}" >> "${GITHUB_ENV}"
    exit ${EXIT}
 - name: Publish reports
  if: always()
  run: bash .ci/scripts/publish-git-pages.sh bats
 - name: Report status
  if: always()
  shell: bash
  run: |
    if [ "${EXIT}" = "0" ]; then
      bash .ci/scripts/report-status.sh success "Link to Bats reports" unit-tests bats
    else
      bash .ci/scripts/report-status.sh failure "Link to Bats reports" unit-tests bats
    fi
 ```
 ### Build & push -jobit (docker-build-push)
 API:a käytetään Docker registry -linkin upottamiseksi.
 ```
 build → push → SUCCESS (registry-linkillä) / FAILURE
 ```
 ## Periaatteet
 1. Gitea Actionsin natiivi job-status on ensisijainen — myös PENDING/Running-tila
   tulee natiivisti. API:a käytetään vain custom-linkin tarpeeseen (ADR 0004).
 2. `run`-komennon on nostettava virhe ylös — oli kyse tool-callista tai
   testivirheestä (ADR 0008).
 3. Test-jobit käyttävät `if: always()` publish- ja status-stepeissä — raportti
   julkaistaan ja status asetetaan aina, riippumatta testin lopputuloksesta.
 4. Testiraportit julkaistaan myös virhetilanteessa, mikäli ne ovat syntyneet.
 5. Commit-statuksen duplikaatio natiivijob-statuksen kanssa hyväksytään
   testijobeille — se on ainoa mekanismi upottaa raporttilinkki commit-näkymään.
 6. Tool-jobit eivät käytä API:a lainkaan — ne luottavat Gitean natiiviin
   job-statukseen.
 ## Tausta
 Aiemmin commit-status API:a käytettiin jokaisessa työvaiheessa, myös niissä
 joilla ei ollut raporttia linkitettäväksi (validate, check-version, tag-commit).
 Tämä tuotti duplikaatiota: Gitea näytti sekä natiivin `CI Main / Validate CI config
 Successful` että API-statuksen `ci-validate CI config valid`. Kehittäjälle
 molemmat kertoivat saman asian.
 Käytännön pakko kuitenkin pakottaa API:n käyttöön testijobeissa: ilman
 raporttilinkkiä kukaan ei löydä testituloksia. Gitean natiivi job-status
 linkittää aina jobin lokiin — ei ulkoiseen raporttiin. Tämä on paras
 saatavilla oleva kompromissi.
@@ -0,0 +1,73 @@
 # 8. Exit code — ainoa onnistumisen mittari
 ## Päätös
 Jokaisen `run`-stepin on nostettava virheellinen exit-koodi ylös sellaisenaan.
 Exit-koodia ei saa "syödä" missään tilanteessa. Onnistumisen ja epäonnistumisen
 päättely tapahtuu **ainoastaan** exit-koodin perusteella — ei tiedostojen
 olemassaolon, stdout-tulosteen tai minkään muun heuristiikan perusteella.
 ## Periaatteet
 1. Exit-koodi on ainoa totuus. `0` = onnistui, kaikki muut = epäonnistui.
 2. Exit-koodia ei saa syödä. Pipe (`|`) viimeisenä komentona `tee`:hen syö
   exit-koodin — `docker run … | tee file` palauttaa aina 0.
 3. Data transfer -pipet ovat sallittuja (`tar c . | docker run … tar x`),
   koska niiden exit-koodilla ei ole semanttista merkitystä.
 4. Testien tai työkalujen ajaminen ei saa päättyä pipeen.
 5. `set -o pipefail` ei ole riittävä suojaus — PIPESTATUS resetoituu herkästi.
 ## Sallitut patternit
 ```yaml
 # Oikein: suora ajo, exit koodi $?:iin
 - name: Do work
  run: |
    some-command
    EXIT=$?
    echo "EXIT=${EXIT}" >> "${GITHUB_ENV}"
    exit ${EXIT}
 # Oikein: stdout talteen ilman pipeä
 - name: Do work
  run: |
    some-command > results.txt 2>&1
    EXIT=$?
    echo "EXIT=${EXIT}" >> "${GITHUB_ENV}"
    exit ${EXIT}
 # Oikein: docker run ilman pipeä
 - name: Run in container
  run: |
    docker run --rm image command > output.txt 2>&1
    EXIT=$?
    exit ${EXIT}
 ```
 ## Kielletyt patternit
 ```yaml
 # Väärin: pipe syö exit-koodin
 - run: docker run … | tee results.txt
 # Väärin: pipe syö exit-koodin
 - run: tar … | docker … | tee file
 # Väärin: onnistumisen päättely tiedoston olemassaolosta
 - run: |
    some-command || true
    [ -f success.txt ] && exit 0 || exit 1
 ```
 ## Tausta
 Gitea Actionsissa `run`-stepin tila määräytyy viimeisen komennon exit-koodista.
 Pipe (`|`) asettaa `$?`:ksi viimeisen komennon tuloksen — jos viimeinen komento
 on `tee`, tulos on aina 0 riippumatta siitä mitä aiemmat komennot palauttivat.
 Tämä on aiheuttanut tuotannossa tilanteita, joissa testit feilasivat mutta jobi
 näytti vihreää, koska `tee` söi exit-koodin. Virhe havaittiin vasta kun raportteja
 alettiin lukea manuaalisesti — commit-status valehteli.
 Ratkaisu on yksiselitteinen: exit-koodi talteen `$?`-muuttujaan ennen kuin mikään
 muu komento ehtii muuttaa sitä, ja stepin viimeinen komento on aina `exit ${EXIT}`.
@@ -16,7 +16,7 @@ curl_with_host() {
 declare -A BRANCH_CACHE
 branch_exists() {
  local owner="$1" repo="$2" branch="$3" key="${owner}/${repo}/${branch}"
-  local status
+  local status attempt
  [ -z "$GITEA_API_URL" ] && return 0
  [ -z "$GITEA_TOKEN" ] && return 0
@@ -25,15 +25,32 @@ branch_exists() {
    return 0
  fi
-  status=$(curl -sS -o /dev/null -w "%{http_code}" \
+  # Retry up to 2 times on API errors (hardcoded)
-    -H "Authorization: token ${GITEA_TOKEN}" \
+  for attempt in 1 2 3; do
-    "${GITEA_API_URL}/api/v1/repos/${owner}/${repo}/branches/${branch}" 2>/dev/null || echo "000")
+    status=$(curl -sS -o /dev/null -w "%{http_code}" \
      -H "Authorization: token ${GITEA_TOKEN}" \
      "${GITEA_API_URL}/api/v1/repos/${owner}/${repo}/branches/${branch}" 2>/dev/null || echo "000")
-  if [ "$status" = "200" ]; then
+    if [ "$status" = "200" ]; then
-    BRANCH_CACHE[$key]=1
+      BRANCH_CACHE[$key]=1
-    return 0
+      return 0
-  fi
+    fi
-  return 1
+    
    if [ "$status" = "404" ]; then
      return 1
    fi
    # API error - retry if not last attempt
    if [ "$attempt" -lt 3 ]; then
      sleep 10
      continue
    fi
  done
  # All retries failed - keep report (fail-safe)
  echo "  WARN: Gitea API error for ${owner}/${repo}/${branch} (status ${status}) after 3 attempts - KEEPING report"
  BRANCH_CACHE[$key]=1
  return 0
 }
 default_max_age=$(jq -r '.branches.default.maxAgeDays // 90' "$CONFIG")
@@ -0,0 +1,112 @@
 # Docker Registry Setup
 Pipeline rakentaa Docker-kontin ja pushee sen haluttuun registryyn.
 ---
 ## 1. Konfiguroi `gitea-env.conf`
 ```
 # DOCKER_REGISTRY on muotoa:  registry.example.com/org
 #
 #   host+org:          registry.example.com/org
 #
 # Pipeline rakentaa kuvan:  ${DOCKER_REGISTRY}/${DOCKER_IMAGE_NAME}:${VERSION}
 DOCKER_REGISTRY=gitea.app.keskikuja.site/niko                     # PAKOLLINEN — tyhjä ei käy
 DOCKER_IMAGE_NAME=gitea-ci-library-test-image                    # PAKOLLINEN — pelkkä kuvan nimi
 DOCKER_UI_URL=  # valinnainen — tarkista Giteasta kontin oma UI-osoite ja laita se tähän ilman versiota. Workflow liittää perään /VERSION
 ```
 | Kenttä | Pakollinen | Kuvaus |
 |---|---|---|
 | `DOCKER_REGISTRY` | **kyllä** | Registry + mahdollinen organisaatio. **Tyhjä pysäyttää workflow'n.** |
 | `DOCKER_IMAGE_NAME` | **kyllä** | Pelkkä kuvan nimi. |
 | `DOCKER_UI_URL` | ei | Base-URL kontin UI-sivulle (ilman versiota). Osoite riippuu onko kontti linkitetty repoon vai ei — tarkista Giteasta. Workflow liittää perään `/VERSION`. |
 **Koko image-ref = `${DOCKER_REGISTRY}/${DOCKER_IMAGE_NAME}:${VERSION}`**  
 Esim. `gitea.app.keskikuja.site/niko/gitea-ci-library-test-image:0.1.0`
 ---
 ## 2. Luo PAT (Personal Access Token) Giteassa
 **Gitea → oma profiili (oikea yläkulma) → Settings → Applications → Manage Access Tokens → Generate New Token**
 Valitse scope:
 | Scope | Pääsy |
 |---|---|
 | `package` | **Read and Write** |
 > Tämä token toimii salasanana `docker login` -komennossa. Muut scopet (kuten `repository`) eivät riitä — konttirekisteri vaatii nimenomaan `package`-scopen.
 Tokenin arvo näytetään **vain kerran** luomisen yhteydessä. Kopioi se talteen.
 ---
 ## 3. Tallenna PAT repositoryn Secretsiin
 Nämä ovat kaksi eri paikkaa:
 - **Access Tokenit** (User Settings) = missä luot tokenin
 - **Repository Secrets** (Repository Settings) = minne talletat sen workflow'n käyttöön
 **Repository → Settings → Actions → Secrets → Add new secret**
 | Secret | Arvo |
 |---|---|
 | `DOCKER_PASSWORD` | Edellisessä vaiheessa luotu PAT |
 `DOCKER_USERNAME`-secretiä **ei tarvita**. Workflow käyttää automaattisesti `${{ github.actor }}` (workflowin käynnistäjä).
 Jos registry vaatii eri käyttäjätunnuksen kuin `github.actor` (esim. Artifactory, Docker Hub), lisää myös:
 | Secret | Arvo |
 |---|---|
 | `DOCKER_USERNAME` | Registryn käyttäjätunnus |
 ---
 ## 4. Tarkistuslista ennen ajoa
 - [ ] `DOCKER_REGISTRY` asetettu `gitea-env.conf`issa
 - [ ] `DOCKER_IMAGE_NAME` asetettu `gitea-env.conf`issa
 - [ ] PAT luotu Giteassa scopella `package` Read and Write
 - [ ] `DOCKER_PASSWORD`-secret tallennettu repositoryn Secretsiin (se PAT)
 - [ ] (tarvittaessa) `DOCKER_USERNAME`-secret — oletus `github.actor`
 ---
 ## 5. Esimerkkejä eri polkurakenteista
 ### 5a. Pelkkä hosti — Artifactory
 ```
 DOCKER_REGISTRY=ngdo-docker.artifactorypro.shared.pub.tds.tieto.com
 DOCKER_IMAGE_NAME=microservice-temperature-store
 DOCKER_UI_URL=https://artifactorypro.shared.pub.tds.tieto.com/ui/repos/tree/General/ngdo-docker.artifactorypro.shared.pub.tds.tieto.com/microservice-temperature-store
 ```
 - Kontti: `ngdo-docker.../microservice-temperature-store:0.1.0`
 - Secret `DOCKER_USERNAME` = service account -tunnus
 - Secret `DOCKER_PASSWORD` = API-token
 ### 5b. Hosti + org — Gitea user-taso
 ```
 DOCKER_REGISTRY=gitea.app.keskikuja.site/niko
 DOCKER_IMAGE_NAME=gitea-ci-library-test-image
 DOCKER_UI_URL=   # tarkista Giteasta kontin UI-osoite
 ```
 - Kontti: `gitea.app.keskikuja.site/niko/gitea-ci-library-test-image:0.1.0`
 - Paketti käyttäjän `niko` alla. Linkitys repoon tehdään Gitean UI:sta: paketin sivulta (Package → Settings) → linkitä repositoryyn.
 ```
 DOCKER_REGISTRY=docker.io/library
 DOCKER_IMAGE_NAME=oma-kuva
 DOCKER_UI_URL=https://hub.docker.com/r/library/oma-kuva
 ```
 - Secret `DOCKER_USERNAME` = Docker Hub -käyttäjä
 - Secret `DOCKER_PASSWORD` = Access Token (ei salasana)
@@ -1,17 +1,22 @@
 #!/usr/bin/env bash
 set -euo pipefail
 # https://docs.gitea.com/api/next/#tag/repository/operation/repoCreateStatus
 STATE="${1:-}"
 DESCRIPTION="${2:-}"
 KEY="${3:-commit-${GITHUB_SHA:0:8}}"
 SUITE="${4:-}"
 CUSTOM_URL="${5:-}"
 [ -z "$STATE" ] && echo "ERROR: state argument is required" >&2 && exit 1
 [ -z "$DESCRIPTION" ] && echo "ERROR: description argument is required" >&2 && exit 1
 [ -z "${GITEA_API_URL:-}" ] && echo "ERROR: GITEA_API_URL is not set" >&2 && exit 1
 [ -z "${GITEA_TOKEN:-}" ] && echo "ERROR: GITEA_TOKEN is not set" >&2 && exit 1
-if [ -n "$SUITE" ]; then
+if [ -n "$CUSTOM_URL" ]; then
  URL="$CUSTOM_URL"
 elif [ -n "$SUITE" ]; then
  SUITE="${SUITE%/}/"
  URL="${GIT_PAGES_URL}/${GITHUB_REPOSITORY}/reports/${GITHUB_SHA:0:8}/${SUITE}"
 else
@@ -28,15 +33,15 @@ HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" \
  -X POST "$GITEA_API_URL/api/v1/repos/$REPO/statuses/$COMMIT" \
  -H "Authorization: token $GITEA_TOKEN" \
  -H "Content-Type: application/json" \
-  -d "{\"state\":\"$STATE\",\"target_url\":\"$URL\",\"description\":\"$DESCRIPTION\",\"context\":\"$KEY\"}")
+  -d "{\"state\":\"$STATE\",\"target_url\":\"$URL\",\"description\":\"$DESCRIPTION\",\"context\":\"$KEY\"}" || true)
 if [ "$HTTP_CODE" = "201" ]; then
  exit 0
 fi
-if [ -z "$HTTP_CODE" ]; then
+if [ -z "$HTTP_CODE" ] || [ "$HTTP_CODE" = "000" ]; then
-  echo "ERROR: Failed to connect to Gitea API at $GITEA_API_URL" >&2
+  echo "gitea-ci-library - ERROR: Failed to connect to Gitea API at $GITEA_API_URL" >&2
 else
-  echo "ERROR: API returned HTTP $HTTP_CODE" >&2
+  echo "gitea-ci-library - ERROR: gitea-ci-library, API returned HTTP $HTTP_CODE" >&2
 fi
 exit 1
@@ -6,10 +6,15 @@ const PROJECT_ROOT = path.resolve(__dirname, '..', '..', '..');
 const MOCK_SCRIPT = path.join(PROJECT_ROOT, 'tests', 'helpers', 'mock-api.sh');
 Before({ tags: '@mock' }, function () {
-  execSync(`bash -c 'source "${MOCK_SCRIPT}" && mock_start'`, {
+  const out = execSync(`bash -c 'source "${MOCK_SCRIPT}" && mock_start && sleep 0.3 && curl -s -o /dev/null -w "%{http_code}" --max-time 3 http://localhost:18080/api/v1/repos/health/check'`, {
    cwd: PROJECT_ROOT,
-    stdio: 'ignore',
+    encoding: 'utf-8',
    stdio: ['pipe', 'pipe', 'pipe'],
  });
  const trimmed = out.trim();
  if (!trimmed.startsWith('2') && !trimmed.startsWith('4')) {
    throw new Error(`Mock server failed to start (HTTP ${trimmed})`);
  }
 });
 After({ tags: '@mock' }, function () {
		`@@ -1,2 +0,0 @@`
			`GITEA_API_URL=https://gitea.app.keskikuja.site`
			`GIT_PAGES_URL=https://ci-reports.helm-dev.keskikuja.site`