Run a conformance suite

curl -fsS "https://chargerdojo.com/api/v1/testing/suites" \
  -H "Authorization: Bearer $DOJO_KEY"

curl -fsS -X POST "https://chargerdojo.com/api/v1/testing/runs?wait=55" \
  -H "Authorization: Bearer $DOJO_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"connectionId\": \"$CONNECTION_ID\"}"

curl -fsS -X POST "https://chargerdojo.com/api/v1/testing/runs" \
  -H "Authorization: Bearer $DOJO_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"connectionId\": \"$CONNECTION_ID\", \"seed\": \"nightly-2026-08-29\"}"

curl -fsS -X POST "https://chargerdojo.com/api/v1/testing/runs" \
  -H "Authorization: Bearer $DOJO_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"connectionId\": \"$CONNECTION_ID\", \"module\": \"scenario_ptp_e2e\"}"

curl -fsS -X POST "https://chargerdojo.com/api/v1/testing/command" \
  -H "Authorization: Bearer $DOJO_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"connectionId\": \"$CONNECTION_ID\", \"method\": \"GET\", \"endpoint\": \"/locations\"}"

# List your runs, optionally filtered
curl -fsS "https://chargerdojo.com/api/v1/testing/runs?connectionId=$CONNECTION_ID" \
  -H "Authorization: Bearer $DOJO_KEY"

# Delete one run
curl -fsS -X DELETE "https://chargerdojo.com/api/v1/testing/runs/$REPORT_ID" \
  -H "Authorization: Bearer $DOJO_KEY"

- uses: chargerdojo/ocpi-conformance-action@v1
  with:
    api_key: ${{ secrets.CHARGERDOJO_API_KEY }}
    connection_id: ${{ vars.CHARGERDOJO_CONNECTION_ID }}
    module: locations

#!/usr/bin/env bash
set -euo pipefail

BASE="https://chargerdojo.com"
AUTH="Authorization: Bearer $DOJO_KEY"

# Capture the HTTP status as well as the body. Without it, an expired wait (202), a rate
# limit (429) or an auth error (401) all look identical to a failing run, and you would
# tell your partner they are broken when the truth is that your script never got an answer.
RESPONSE=$(curl -sS -w '\n%{http_code}' -X POST "$BASE/api/v1/testing/runs?wait=55" \
  -H "$AUTH" \
  -H "Content-Type: application/json" \
  -d "{\"connectionId\": \"$CONNECTION_ID\"}")

STATUS=$(printf '%s' "$RESPONSE" | tail -n1)
BODY=$(printf '%s' "$RESPONSE" | sed '$d')

case "$STATUS" in
  200) ;;
  202) echo "Run did not finish within the wait. Poll it; do not treat this as a failure."
       exit 2 ;;
  *)   echo "Could not run conformance (HTTP $STATUS): $BODY"
       exit 2 ;;
esac

# Read the status before the counters. A run can end without ever being graded: restart the
# server and the run it was carrying is stamped `interrupted`, and such a run carries no summary
# at all, so `.data.summary.failed` is null rather than a number. Treating that as zero is how a
# killed run reads as a pass.
RUN_STATUS=$(printf '%s' "$BODY" | jq -r '.data.status')
if [ "$RUN_STATUS" = "interrupted" ] && [ "$(printf '%s' "$BODY" | jq '.data.summary != null')" = "true" ]; then
  # Our run limit stopped it after grading some checks. What it graded is real.
  RUN_STATUS=stopped
fi
case "$RUN_STATUS" in
  completed) ;;
  failed|stopped)
    # The run stopped early, but what it graded before it stopped is real. Treat those failures
    # as failures: they are your partner's, not ours.
    echo "Run stopped early: $(printf '%s' "$BODY" | jq -r '.data.error // "no reason given"')" ;;
  *)
    # Terminal without a verdict. The server restarted or a release cut the run.
    # This says nothing about your partner.
    echo "Run ended as '$RUN_STATUS' and was never graded. Run it again."
    exit 2 ;;
esac

FAILED=$(printf '%s' "$BODY" | jq '.data.summary.failed')
PASSED=$(printf '%s' "$BODY" | jq '.data.summary.passed // 0')
UNGRADED=$(printf '%s' "$BODY" | jq '.data.summary.unobservable // 0')
WITHHELD=$(printf '%s' "$BODY" | jq -r '.data.withheldModules // [] | join(", ")')

# A completed run always carries counters. If one ever does not, jq hands you `null`, and
# `[ null -gt 0 ]` is a bash error rather than a comparison, which falls through to the
# success path below and prints a pass. Refuse instead of guessing.
if [ "$FAILED" = "null" ]; then
  echo "The run reported no results to read. Treat this as no answer, not as a pass."
  exit 2
fi

# How many checks were actually graded: passed plus failed, and nothing else. Zero of them is
# not a pass. A version that advertises no runnable suite, or a mistyped module name, ends as a
# run with every counter at zero, and "nothing failed" is vacuously true of a run that asked
# nothing.
if [ "$(( PASSED + FAILED ))" -eq 0 ]; then
  echo "The run graded no checks, so nothing is proved. Treat this as no answer, not a pass."
  exit 2
fi

if [ "$FAILED" -gt 0 ]; then
  echo "OCPI conformance: $FAILED required checks failed"
  exit 1
fi

# A run that stopped early proves its failures and nothing else. With none of them, it never
# finished asking, so the checks it did not reach are untested rather than clean. That belongs
# with "we did not get an answer", beside an interrupted run.
if [ "$RUN_STATUS" = "failed" ] || [ "$RUN_STATUS" = "stopped" ]; then
  echo "The run stopped before it finished, with nothing failing yet. That is not a pass. Run it again."
  exit 2
fi

# Zero failures is not a pass on its own: a module your plan does not cover contributes no
# failures because it never ran, and a check marked not tested decided nothing: the response carried
# nothing to grade, or an earlier step left it nothing to send. Say what was not tested rather
# than calling it compliant.
if [ -n "$WITHHELD" ] || [ "$UNGRADED" -gt 0 ]; then
  echo "OCPI conformance: every check that ran passed ($PASSED checks); not tested: ${WITHHELD:-none} (+$UNGRADED ungraded)"
  exit 0
fi

echo "OCPI conformance: all $PASSED checks passed"