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"

#!/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')
case "$RUN_STATUS" in
  completed) ;;
  failed)
    # 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. `interrupted` means we restarted the server under it, which says
    # nothing about your partner, so it belongs with the network errors rather than with a
    # broken endpoint.
    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 "compliant". 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" ]; 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 an unobservable check decided nothing because the response
# carried nothing to grade. Say what was not tested rather than calling it compliant.
if [ -n "$WITHHELD" ] || [ "$UNGRADED" -gt 0 ]; then
  echo "OCPI conformance: compliant on what ran ($PASSED checks); not tested: ${WITHHELD:-none} (+$UNGRADED ungraded)"
  exit 0
fi

echo "OCPI conformance: compliant"