752 lines
23 KiB
Bash
752 lines
23 KiB
Bash
#!/usr/bin/env bash
|
||
# Runs Phase 10 verification checks from docs/plans/phase-10-plan.md.
|
||
#
|
||
# Covers cover sheet generation, lookup, list filters, PDF endpoints,
|
||
# barcode-assisted batch upload, redeem/auto-assign, and reuse prevention.
|
||
#
|
||
# Prerequisites:
|
||
# docker compose up -d (PostgreSQL, Redis, MinIO)
|
||
# dotnet ef database update --project VigilCareRecordsAPI
|
||
# dotnet run --project VigilCareRecordsAPI
|
||
# Phase 1–9 seed data (intake1, entry1, admin1)
|
||
#
|
||
# Environment overrides:
|
||
# VIGILCARE_API_URL default: http://localhost:5217
|
||
# VIGILCARE_COMPOSE_FILE default: <repo>/docker-compose.yml
|
||
# VIGILCARE_PG_HOST default: localhost
|
||
# VIGILCARE_PG_PORT default: 5437
|
||
# VIGILCARE_PG_DB default: vigilcare_records
|
||
# VIGILCARE_PG_USER default: postgres
|
||
# VIGILCARE_PG_PASSWORD default: password
|
||
# VIGILCARE_SKIP_DB_CHECKS set to 1 to skip PostgreSQL assertions
|
||
# VIGILCARE_SKIP_TEST_CHECKS set to 1 to skip dotnet integration tests
|
||
#
|
||
# Usage:
|
||
# chmod +x scripts/run-vigilcare-records-phase-10-verification.sh
|
||
# ./scripts/run-vigilcare-records-phase-10-verification.sh
|
||
|
||
set -uo pipefail
|
||
|
||
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
||
REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
|
||
FIXTURE_PDF="$SCRIPT_DIR/fixtures/test-scan.pdf"
|
||
|
||
API_URL="${VIGILCARE_API_URL:-http://localhost:5217}"
|
||
COMPOSE_FILE="${VIGILCARE_COMPOSE_FILE:-$REPO_ROOT/docker-compose.yml}"
|
||
COMPOSE=(docker compose -f "$COMPOSE_FILE")
|
||
PG_HOST="${VIGILCARE_PG_HOST:-localhost}"
|
||
PG_PORT="${VIGILCARE_PG_PORT:-5437}"
|
||
PG_DB="${VIGILCARE_PG_DB:-vigilcare_records}"
|
||
PG_USER="${VIGILCARE_PG_USER:-postgres}"
|
||
PG_PASSWORD="${VIGILCARE_PG_PASSWORD:-password}"
|
||
SKIP_DB_CHECKS="${VIGILCARE_SKIP_DB_CHECKS:-0}"
|
||
SKIP_TEST_CHECKS="${VIGILCARE_SKIP_TEST_CHECKS:-0}"
|
||
|
||
# Resolved at runtime from the live API (seed IDs vary per environment)
|
||
ENTRY_CLERK1_ID=""
|
||
PATIENT1_ID=""
|
||
|
||
PASS_COUNT=0
|
||
FAIL_COUNT=0
|
||
FAILED_TESTS=()
|
||
|
||
# Shared state populated during the run
|
||
INTAKE_TOKEN=""
|
||
ADMIN_TOKEN=""
|
||
ENTRY_TOKEN=""
|
||
UPLOAD_CODE=""
|
||
UPLOAD_COVER_SHEET_ID=""
|
||
UPLOAD_BATCH_ID=""
|
||
ASSIGN_CODE=""
|
||
PDF_SHEET_IDS=()
|
||
|
||
log() {
|
||
printf '%s\n' "$*"
|
||
}
|
||
|
||
section() {
|
||
log ""
|
||
log "== $1 =="
|
||
}
|
||
|
||
pass() {
|
||
PASS_COUNT=$((PASS_COUNT + 1))
|
||
log " PASS: $1"
|
||
}
|
||
|
||
fail() {
|
||
FAIL_COUNT=$((FAIL_COUNT + 1))
|
||
FAILED_TESTS+=("$1")
|
||
log " FAIL: $1"
|
||
}
|
||
|
||
require_cmd() {
|
||
local cmd="$1"
|
||
if ! command -v "$cmd" >/dev/null 2>&1; then
|
||
log "ERROR: required command not found: $cmd"
|
||
exit 1
|
||
fi
|
||
}
|
||
|
||
ensure_fixture_pdf() {
|
||
if [[ -f "$FIXTURE_PDF" ]]; then
|
||
return 0
|
||
fi
|
||
mkdir -p "$(dirname "$FIXTURE_PDF")"
|
||
cat >"$FIXTURE_PDF" <<'EOF'
|
||
%PDF-1.0
|
||
1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj 2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1>>endobj 3 0 obj<</Type/Page/MediaBox[0 0 612 792]/Parent 2 0 R/Resources<<>>>>endobj
|
||
xref
|
||
0 4
|
||
0000000000 65535 f
|
||
0000000009 00000 n
|
||
0000000058 00000 n
|
||
0000000115 00000 n
|
||
trailer<</Size 4/Root 1 0 R>>
|
||
startxref
|
||
206
|
||
%%EOF
|
||
EOF
|
||
}
|
||
|
||
unique_pdf_path() {
|
||
local suffix="$1"
|
||
local path="/tmp/vigilcare-p10-${suffix}-${RANDOM}.pdf"
|
||
printf '%%PDF-1.4\nphase10-%s-%s\n%%%%EOF\n' "$suffix" "$(date +%s%N)" >"$path"
|
||
printf '%s' "$path"
|
||
}
|
||
|
||
http_code() {
|
||
curl -sS -o /dev/null -w '%{http_code}' "$@"
|
||
}
|
||
|
||
json_post() {
|
||
local url="$1"
|
||
local body="$2"
|
||
local token="${3:-}"
|
||
if [[ -n "$token" ]]; then
|
||
curl -sS -X POST "$url" \
|
||
-H "Authorization: Bearer $token" \
|
||
-H 'Content-Type: application/json' \
|
||
-d "$body"
|
||
else
|
||
curl -sS -X POST "$url" \
|
||
-H 'Content-Type: application/json' \
|
||
-d "$body"
|
||
fi
|
||
}
|
||
|
||
json_get() {
|
||
local url="$1"
|
||
local token="$2"
|
||
curl -sS "$url" -H "Authorization: Bearer $token"
|
||
}
|
||
|
||
login() {
|
||
local username="$1"
|
||
local password="${2:-password}"
|
||
json_post "$API_URL/api/v1/auth/login" \
|
||
"{\"username\":\"$username\",\"password\":\"$password\"}"
|
||
}
|
||
|
||
extract_data_field() {
|
||
local json="$1"
|
||
local field="$2"
|
||
jq -er ".data.$field // empty" <<<"$json"
|
||
}
|
||
|
||
extract_bool_field() {
|
||
local json="$1"
|
||
local field="$2"
|
||
jq -er ".data.$field | if . == null then empty else tostring end" <<<"$json"
|
||
}
|
||
|
||
resolve_directory_ids() {
|
||
local users_json patients_json
|
||
users_json="$(json_get "$API_URL/api/v1/users?role=DATA_ENTRY_CLERK" "$INTAKE_TOKEN")"
|
||
patients_json="$(json_get "$API_URL/api/v1/patients/search?q=Patient" "$INTAKE_TOKEN")"
|
||
|
||
ENTRY_CLERK1_ID="$(jq -er '.data[0].id // empty' <<<"$users_json" 2>/dev/null || true)"
|
||
PATIENT1_ID="$(jq -er '.data[0].id // empty' <<<"$patients_json" 2>/dev/null || true)"
|
||
|
||
if [[ -n "$ENTRY_CLERK1_ID" ]]; then
|
||
pass "resolved entry clerk ID for auto-assign test"
|
||
else
|
||
fail "resolved entry clerk ID for auto-assign test"
|
||
fi
|
||
|
||
if [[ -n "$PATIENT1_ID" ]]; then
|
||
pass "resolved patient ID for patient-linked cover sheet test"
|
||
else
|
||
fail "resolved patient ID for patient-linked cover sheet test"
|
||
fi
|
||
}
|
||
|
||
extract_error_code() {
|
||
local json="$1"
|
||
jq -er '.error.code // empty' <<<"$json" 2>/dev/null || true
|
||
}
|
||
|
||
assert_api_reachable() {
|
||
local code
|
||
code="$(http_code "$API_URL/swagger/index.html" || true)"
|
||
if [[ "$code" != "200" ]]; then
|
||
log "ERROR: API not reachable at $API_URL (HTTP $code)."
|
||
log "Start infrastructure with: docker compose up -d"
|
||
log "Apply migrations with: dotnet ef database update --project VigilCareRecordsAPI"
|
||
log "Start API with: dotnet run --project VigilCareRecordsAPI"
|
||
exit 1
|
||
fi
|
||
}
|
||
|
||
compose_service_running() {
|
||
local service="$1"
|
||
"${COMPOSE[@]}" ps --status running --services 2>/dev/null | grep -qx "$service"
|
||
}
|
||
|
||
psql_available() {
|
||
[[ "$SKIP_DB_CHECKS" == "1" ]] && return 1
|
||
compose_service_running postgres && return 0
|
||
command -v psql >/dev/null 2>&1 && return 0
|
||
return 1
|
||
}
|
||
|
||
psql_query() {
|
||
if [[ "$SKIP_DB_CHECKS" == "1" ]]; then
|
||
return 1
|
||
fi
|
||
if compose_service_running postgres; then
|
||
"${COMPOSE[@]}" exec -T postgres \
|
||
psql -U "$PG_USER" -d "$PG_DB" -Atqc "$1"
|
||
elif command -v psql >/dev/null 2>&1; then
|
||
PGPASSWORD="$PG_PASSWORD" psql -h "$PG_HOST" -p "$PG_PORT" -U "$PG_USER" -d "$PG_DB" -Atqc "$1"
|
||
else
|
||
return 1
|
||
fi
|
||
}
|
||
|
||
upload_with_cover_sheet() {
|
||
local token="$1"
|
||
local code="$2"
|
||
local pdf="$3"
|
||
curl -sS -X POST "$API_URL/api/v1/digitization-batches" \
|
||
-H "Authorization: Bearer $token" \
|
||
-F "file=@${pdf};type=application/pdf" \
|
||
-F "coverSheetCode=$code"
|
||
}
|
||
|
||
upload_with_cover_sheet_status() {
|
||
local token="$1"
|
||
local code="$2"
|
||
local pdf="$3"
|
||
local body_file http_code_val
|
||
body_file="$(mktemp)"
|
||
http_code_val="$(curl -sS -o "$body_file" -w '%{http_code}' -X POST "$API_URL/api/v1/digitization-batches" \
|
||
-H "Authorization: Bearer $token" \
|
||
-F "file=@${pdf};type=application/pdf" \
|
||
-F "coverSheetCode=$code")"
|
||
cat "$body_file"
|
||
rm -f "$body_file"
|
||
printf '\n__HTTP_STATUS__:%s' "$http_code_val"
|
||
}
|
||
|
||
generate_cover_sheets() {
|
||
local token="$1"
|
||
local body="$2"
|
||
json_post "$API_URL/api/v1/cover-sheets/generate" "$body" "$token"
|
||
}
|
||
|
||
test_authentication() {
|
||
section "0. Authentication"
|
||
|
||
local intake_json admin_json entry_json
|
||
intake_json="$(login intake1)"
|
||
admin_json="$(login admin1)"
|
||
entry_json="$(login entry1)"
|
||
|
||
INTAKE_TOKEN="$(extract_data_field "$intake_json" token)"
|
||
ADMIN_TOKEN="$(extract_data_field "$admin_json" token)"
|
||
ENTRY_TOKEN="$(extract_data_field "$entry_json" token)"
|
||
|
||
if [[ -z "$INTAKE_TOKEN" ]]; then
|
||
log "ERROR: intake1 login failed."
|
||
log "Response: ${intake_json:-<empty>}"
|
||
exit 1
|
||
fi
|
||
|
||
if [[ -n "$INTAKE_TOKEN" ]]; then
|
||
pass "intake1 login returns JWT"
|
||
else
|
||
fail "intake1 login returns JWT"
|
||
fi
|
||
|
||
if [[ -n "$ADMIN_TOKEN" ]]; then
|
||
pass "admin1 login returns JWT"
|
||
else
|
||
fail "admin1 login returns JWT"
|
||
fi
|
||
|
||
if [[ -n "$ENTRY_TOKEN" ]]; then
|
||
pass "entry1 login returns JWT"
|
||
else
|
||
fail "entry1 login returns JWT"
|
||
fi
|
||
|
||
resolve_directory_ids
|
||
}
|
||
|
||
test_database_schema() {
|
||
section "1. Database — cover_sheets table"
|
||
|
||
if ! psql_available; then
|
||
log " SKIP: PostgreSQL checks (set VIGILCARE_SKIP_DB_CHECKS=0 and start postgres)"
|
||
return
|
||
fi
|
||
|
||
local table_exists index_code index_unused
|
||
table_exists="$(psql_query "
|
||
SELECT count(*)
|
||
FROM information_schema.tables
|
||
WHERE table_schema = 'public' AND table_name = 'cover_sheets';
|
||
")"
|
||
index_code="$(psql_query "
|
||
SELECT count(*)
|
||
FROM pg_indexes
|
||
WHERE tablename = 'cover_sheets' AND indexname = 'ix_cover_sheets_code';
|
||
")"
|
||
index_unused="$(psql_query "
|
||
SELECT count(*)
|
||
FROM pg_indexes
|
||
WHERE tablename = 'cover_sheets' AND indexname = 'ix_cover_sheets_unused';
|
||
")"
|
||
|
||
if [[ "$table_exists" == "1" ]]; then
|
||
pass "cover_sheets table exists"
|
||
else
|
||
fail "cover_sheets table exists"
|
||
fi
|
||
|
||
if [[ "$index_code" == "1" ]]; then
|
||
pass "unique index ix_cover_sheets_code exists"
|
||
else
|
||
fail "unique index ix_cover_sheets_code exists"
|
||
fi
|
||
|
||
if [[ "$index_unused" == "1" ]]; then
|
||
pass "filtered index ix_cover_sheets_unused exists"
|
||
else
|
||
fail "filtered index ix_cover_sheets_unused exists"
|
||
fi
|
||
}
|
||
|
||
test_cover_sheet_generation() {
|
||
section "2. Cover sheet generation (plan §1)"
|
||
|
||
local gen_json count unique_count bad_format
|
||
gen_json="$(generate_cover_sheets "$INTAKE_TOKEN" \
|
||
'{"count":5,"batchType":"VITALS_SHEET","track":"BACKFILL"}')"
|
||
|
||
if [[ "$(jq -er '.success' <<<"$gen_json")" == "true" ]]; then
|
||
pass "POST /cover-sheets/generate returns success for intake1"
|
||
else
|
||
fail "POST /cover-sheets/generate returns success for intake1"
|
||
log " response: $gen_json"
|
||
return
|
||
fi
|
||
|
||
count="$(jq '.data | length' <<<"$gen_json")"
|
||
unique_count="$(jq '[.data[].code] | unique | length' <<<"$gen_json")"
|
||
if [[ "$count" == "5" && "$unique_count" == "5" ]]; then
|
||
pass "generate creates 5 cover sheets with unique codes"
|
||
else
|
||
fail "generate creates 5 cover sheets with unique codes (count=$count unique=$unique_count)"
|
||
fi
|
||
|
||
bad_format="$(jq -r '[.data[].code | test("^VCR-CS-[0-9A-F]{8}$")] | all' <<<"$gen_json")"
|
||
if [[ "$bad_format" == "true" ]]; then
|
||
pass "all codes match VCR-CS-{8-hex} format"
|
||
else
|
||
fail "all codes match VCR-CS-{8-hex} format"
|
||
fi
|
||
|
||
UPLOAD_CODE="$(jq -r '.data[0].code' <<<"$gen_json")"
|
||
UPLOAD_COVER_SHEET_ID="$(jq -r '.data[0].id' <<<"$gen_json")"
|
||
PDF_SHEET_IDS=($(jq -r '.data[0].id, .data[1].id' <<<"$gen_json"))
|
||
|
||
local entry_json entry_token entry_code
|
||
entry_json="$(login entry1)"
|
||
entry_token="$(extract_data_field "$entry_json" token)"
|
||
entry_code="$(http_code -X POST "$API_URL/api/v1/cover-sheets/generate" \
|
||
-H "Authorization: Bearer $entry_token" \
|
||
-H 'Content-Type: application/json' \
|
||
-d '{"count":1,"batchType":"VITALS_SHEET","track":"BACKFILL"}')"
|
||
if [[ "$entry_code" == "403" ]]; then
|
||
pass "generate denied for DATA_ENTRY_CLERK (403)"
|
||
else
|
||
fail "generate denied for DATA_ENTRY_CLERK (403) — got HTTP $entry_code"
|
||
fi
|
||
|
||
local admin_json
|
||
admin_json="$(generate_cover_sheets "$ADMIN_TOKEN" \
|
||
'{"count":1,"batchType":"LAB_RESULTS","track":"BACKFILL"}')"
|
||
if [[ "$(jq -er '.success' <<<"$admin_json")" == "true" ]]; then
|
||
pass "generate allowed for ADMINISTRATOR"
|
||
else
|
||
fail "generate allowed for ADMINISTRATOR"
|
||
fi
|
||
}
|
||
|
||
test_cover_sheet_lookup_and_list() {
|
||
section "3. Cover sheet lookup and list (plan §2)"
|
||
|
||
if [[ -z "$UPLOAD_CODE" ]]; then
|
||
fail "lookup requires generated cover sheet code"
|
||
return
|
||
fi
|
||
|
||
local lookup_json is_used batch_type
|
||
lookup_json="$(json_get "$API_URL/api/v1/cover-sheets/lookup/$UPLOAD_CODE" "$INTAKE_TOKEN")"
|
||
|
||
if [[ "$(jq -er '.success' <<<"$lookup_json")" == "true" ]]; then
|
||
pass "GET /cover-sheets/lookup/{code} returns success"
|
||
else
|
||
fail "GET /cover-sheets/lookup/{code} returns success"
|
||
return
|
||
fi
|
||
|
||
is_used="$(extract_bool_field "$lookup_json" isUsed)"
|
||
batch_type="$(extract_data_field "$lookup_json" batchType)"
|
||
if [[ "$is_used" == "false" ]]; then
|
||
pass "lookup shows isUsed=false before upload"
|
||
else
|
||
fail "lookup shows isUsed=false before upload (isUsed=$is_used)"
|
||
fi
|
||
|
||
if [[ "$batch_type" == "VITALS_SHEET" ]]; then
|
||
pass "lookup returns batchType VITALS_SHEET"
|
||
else
|
||
fail "lookup returns batchType VITALS_SHEET (got $batch_type)"
|
||
fi
|
||
|
||
local unknown_json unknown_code
|
||
unknown_json="$(json_get "$API_URL/api/v1/cover-sheets/lookup/VCR-CS-DEADBEEF" "$INTAKE_TOKEN")"
|
||
unknown_code="$(extract_error_code "$unknown_json")"
|
||
if [[ "$unknown_code" == "COVER_SHEET_NOT_FOUND" ]]; then
|
||
pass "lookup unknown code returns COVER_SHEET_NOT_FOUND"
|
||
else
|
||
fail "lookup unknown code returns COVER_SHEET_NOT_FOUND (got ${unknown_code:-<none>})"
|
||
fi
|
||
|
||
local list_json unused_count
|
||
list_json="$(json_get "$API_URL/api/v1/cover-sheets?isUsed=false&page=1&pageSize=20" "$INTAKE_TOKEN")"
|
||
unused_count="$(jq '.data | length' <<<"$list_json")"
|
||
if [[ "$(jq -er '.success' <<<"$list_json")" == "true" && "$unused_count" -ge 5 ]]; then
|
||
pass "GET /cover-sheets?isUsed=false lists unused sheets"
|
||
else
|
||
fail "GET /cover-sheets?isUsed=false lists unused sheets (count=$unused_count)"
|
||
fi
|
||
}
|
||
|
||
test_pdf_generation() {
|
||
section "4. Cover sheet PDF generation (plan Step 5)"
|
||
|
||
if [[ -z "$UPLOAD_COVER_SHEET_ID" || ${#PDF_SHEET_IDS[@]} -lt 2 ]]; then
|
||
fail "PDF tests require generated cover sheet IDs"
|
||
return
|
||
fi
|
||
|
||
local pdf_tmp headers_file pdf_code content_type pdf_header
|
||
pdf_tmp="$(mktemp)"
|
||
headers_file="$(mktemp)"
|
||
pdf_code="$(curl -sS -D "$headers_file" -o "$pdf_tmp" -w '%{http_code}' -X POST \
|
||
"$API_URL/api/v1/cover-sheets/${UPLOAD_COVER_SHEET_ID}/pdf" \
|
||
-H "Authorization: Bearer $INTAKE_TOKEN")"
|
||
content_type="$(awk -F': ' 'tolower($1)=="content-type"{print $2}' "$headers_file" | tr -d '\r' | head -1)"
|
||
rm -f "$headers_file"
|
||
|
||
if [[ "$pdf_code" == "200" ]]; then
|
||
pass "POST /cover-sheets/{id}/pdf returns 200"
|
||
else
|
||
fail "POST /cover-sheets/{id}/pdf returns 200 (got HTTP $pdf_code)"
|
||
fi
|
||
|
||
if [[ "$content_type" == application/pdf* ]]; then
|
||
pass "single PDF response Content-Type is application/pdf"
|
||
else
|
||
fail "single PDF response Content-Type is application/pdf (got ${content_type:-<none>})"
|
||
fi
|
||
|
||
pdf_header="$(head -c 8 "$pdf_tmp" || true)"
|
||
if [[ "$pdf_header" == %PDF-1.* ]]; then
|
||
pass "single PDF body starts with %PDF header"
|
||
else
|
||
fail "single PDF body starts with %PDF header"
|
||
fi
|
||
|
||
if grep -aq "$UPLOAD_CODE" "$pdf_tmp" 2>/dev/null; then
|
||
pass "single PDF embeds cover sheet code text"
|
||
else
|
||
fail "single PDF embeds cover sheet code text"
|
||
fi
|
||
rm -f "$pdf_tmp"
|
||
|
||
local batch_pdf_tmp batch_pdf_code
|
||
batch_pdf_tmp="$(mktemp)"
|
||
batch_pdf_code="$(curl -sS -o "$batch_pdf_tmp" -w '%{http_code}' -X POST \
|
||
"$API_URL/api/v1/cover-sheets/batch-pdf" \
|
||
-H "Authorization: Bearer $INTAKE_TOKEN" \
|
||
-H 'Content-Type: application/json' \
|
||
-d "{\"coverSheetIds\":[\"${PDF_SHEET_IDS[0]}\",\"${PDF_SHEET_IDS[1]}\"]}")"
|
||
|
||
if [[ "$batch_pdf_code" == "200" ]]; then
|
||
pass "POST /cover-sheets/batch-pdf returns 200"
|
||
else
|
||
fail "POST /cover-sheets/batch-pdf returns 200 (got HTTP $batch_pdf_code)"
|
||
fi
|
||
|
||
if grep -aq '/Count 2' "$batch_pdf_tmp" 2>/dev/null || strings "$batch_pdf_tmp" | grep -q '/Count 2'; then
|
||
pass "batch PDF contains two pages (/Count 2)"
|
||
else
|
||
fail "batch PDF contains two pages (/Count 2)"
|
||
fi
|
||
rm -f "$batch_pdf_tmp"
|
||
}
|
||
|
||
test_barcode_assisted_upload() {
|
||
section "5. Barcode-assisted upload (plan §3)"
|
||
|
||
if [[ -z "$UPLOAD_CODE" ]]; then
|
||
fail "barcode upload requires generated cover sheet code"
|
||
return
|
||
fi
|
||
|
||
local pdf upload_json batch_type track status entered_by
|
||
pdf="$(unique_pdf_path upload)"
|
||
upload_json="$(upload_with_cover_sheet "$INTAKE_TOKEN" "$UPLOAD_CODE" "$pdf")"
|
||
rm -f "$pdf"
|
||
|
||
if [[ "$(jq -er '.success' <<<"$upload_json")" == "true" ]]; then
|
||
pass "POST /digitization-batches with coverSheetCode creates batch"
|
||
else
|
||
fail "POST /digitization-batches with coverSheetCode creates batch"
|
||
log " response: $upload_json"
|
||
return
|
||
fi
|
||
|
||
batch_type="$(extract_data_field "$upload_json" batchType)"
|
||
track="$(extract_data_field "$upload_json" track)"
|
||
status="$(extract_data_field "$upload_json" status)"
|
||
UPLOAD_BATCH_ID="$(extract_data_field "$upload_json" id)"
|
||
|
||
if [[ "$batch_type" == "VITALS_SHEET" && "$track" == "BACKFILL" ]]; then
|
||
pass "batch inherits batchType and track from cover sheet"
|
||
else
|
||
fail "batch inherits batchType and track from cover sheet (type=$batch_type track=$track)"
|
||
fi
|
||
|
||
local redeemed_json redeemed_used redeemed_batch_id
|
||
redeemed_json="$(json_get "$API_URL/api/v1/cover-sheets/lookup/$UPLOAD_CODE" "$INTAKE_TOKEN")"
|
||
redeemed_used="$(extract_bool_field "$redeemed_json" isUsed)"
|
||
redeemed_batch_id="$(extract_data_field "$redeemed_json" batchId)"
|
||
|
||
if [[ "$redeemed_used" == "true" && "$redeemed_batch_id" == "$UPLOAD_BATCH_ID" ]]; then
|
||
pass "cover sheet redeemed and linked to batch after upload"
|
||
else
|
||
fail "cover sheet redeemed and linked to batch after upload"
|
||
fi
|
||
|
||
if psql_available && [[ -n "$UPLOAD_COVER_SHEET_ID" ]]; then
|
||
local db_used db_batch
|
||
db_used="$(psql_query "
|
||
SELECT is_used FROM cover_sheets WHERE id = '$UPLOAD_COVER_SHEET_ID';
|
||
")"
|
||
db_batch="$(psql_query "
|
||
SELECT batch_id FROM cover_sheets WHERE id = '$UPLOAD_COVER_SHEET_ID';
|
||
")"
|
||
if [[ "$db_used" == "t" && "$db_batch" == "$UPLOAD_BATCH_ID" ]]; then
|
||
pass "database row shows is_used=true with batch_id"
|
||
else
|
||
fail "database row shows is_used=true with batch_id"
|
||
fi
|
||
fi
|
||
}
|
||
|
||
test_cover_sheet_reuse_and_unknown() {
|
||
section "6. Reuse prevention and unknown code (plan §4)"
|
||
|
||
if [[ -z "$UPLOAD_CODE" ]]; then
|
||
fail "reuse test requires uploaded cover sheet code"
|
||
return
|
||
fi
|
||
|
||
local pdf reuse_response reuse_status reuse_code unknown_response unknown_status unknown_code
|
||
pdf="$(unique_pdf_path reuse)"
|
||
reuse_response="$(upload_with_cover_sheet_status "$INTAKE_TOKEN" "$UPLOAD_CODE" "$pdf")"
|
||
rm -f "$pdf"
|
||
|
||
reuse_status="${reuse_response##*__HTTP_STATUS__:}"
|
||
reuse_response="${reuse_response%$'\n'__HTTP_STATUS__:*}"
|
||
reuse_code="$(extract_error_code "$reuse_response")"
|
||
|
||
if [[ "$reuse_status" == "409" && "$reuse_code" == "COVER_SHEET_ALREADY_USED" ]]; then
|
||
pass "reused cover sheet code returns 409 COVER_SHEET_ALREADY_USED"
|
||
else
|
||
fail "reused cover sheet code returns 409 COVER_SHEET_ALREADY_USED (HTTP $reuse_status code=${reuse_code:-<none>})"
|
||
fi
|
||
|
||
pdf="$(unique_pdf_path unknown)"
|
||
unknown_response="$(upload_with_cover_sheet_status "$INTAKE_TOKEN" "VCR-CS-DEADBEEF" "$pdf")"
|
||
rm -f "$pdf"
|
||
|
||
unknown_status="${unknown_response##*__HTTP_STATUS__:}"
|
||
unknown_response="${unknown_response%$'\n'__HTTP_STATUS__:*}"
|
||
unknown_code="$(extract_error_code "$unknown_response")"
|
||
|
||
if [[ "$unknown_status" == "404" && "$unknown_code" == "COVER_SHEET_NOT_FOUND" ]]; then
|
||
pass "unknown cover sheet code on upload returns 404 COVER_SHEET_NOT_FOUND"
|
||
else
|
||
fail "unknown cover sheet code on upload returns 404 COVER_SHEET_NOT_FOUND (HTTP $unknown_status code=${unknown_code:-<none>})"
|
||
fi
|
||
}
|
||
|
||
test_auto_assign_cover_sheet() {
|
||
section "7. Pre-assigned cover sheet auto-assigns batch"
|
||
|
||
if [[ -z "$ENTRY_CLERK1_ID" ]]; then
|
||
fail "auto-assign test skipped — no entry clerk ID"
|
||
return
|
||
fi
|
||
|
||
local gen_json assign_code pdf upload_json status entered_by
|
||
gen_json="$(generate_cover_sheets "$INTAKE_TOKEN" \
|
||
"{\"count\":1,\"batchType\":\"LAB_RESULTS\",\"track\":\"BACKFILL\",\"assignToUserId\":\"$ENTRY_CLERK1_ID\"}")"
|
||
|
||
if [[ "$(jq -er '.success' <<<"$gen_json")" != "true" ]]; then
|
||
fail "generate pre-assigned cover sheet"
|
||
return
|
||
fi
|
||
|
||
assign_code="$(jq -r '.data[0].code' <<<"$gen_json")"
|
||
pdf="$(unique_pdf_path assign)"
|
||
upload_json="$(upload_with_cover_sheet "$INTAKE_TOKEN" "$assign_code" "$pdf")"
|
||
rm -f "$pdf"
|
||
|
||
status="$(extract_data_field "$upload_json" status)"
|
||
entered_by="$(extract_data_field "$upload_json" enteredByUserId)"
|
||
|
||
if [[ "$status" == "IN_ENTRY" ]]; then
|
||
pass "pre-assigned upload transitions batch to IN_ENTRY"
|
||
else
|
||
fail "pre-assigned upload transitions batch to IN_ENTRY (status=$status)"
|
||
fi
|
||
|
||
if [[ "$entered_by" == "$ENTRY_CLERK1_ID" ]]; then
|
||
pass "pre-assigned upload sets enteredByUserId to entry clerk"
|
||
else
|
||
fail "pre-assigned upload sets enteredByUserId to entry clerk (got $entered_by)"
|
||
fi
|
||
}
|
||
|
||
test_patient_linked_cover_sheet() {
|
||
section "8. Patient-linked cover sheet populates batch patient"
|
||
|
||
if [[ -z "$PATIENT1_ID" ]]; then
|
||
fail "patient-linked test skipped — no patient ID"
|
||
return
|
||
fi
|
||
|
||
local gen_json patient_code pdf upload_json patient_id
|
||
gen_json="$(generate_cover_sheets "$INTAKE_TOKEN" \
|
||
"{\"count\":1,\"batchType\":\"MEDICATION_LIST\",\"track\":\"BACKFILL\",\"patientId\":\"$PATIENT1_ID\"}")"
|
||
|
||
if [[ "$(jq -er '.success' <<<"$gen_json")" != "true" ]]; then
|
||
fail "generate patient-linked cover sheet"
|
||
return
|
||
fi
|
||
|
||
patient_code="$(jq -r '.data[0].code' <<<"$gen_json")"
|
||
pdf="$(unique_pdf_path patient)"
|
||
upload_json="$(upload_with_cover_sheet "$INTAKE_TOKEN" "$patient_code" "$pdf")"
|
||
rm -f "$pdf"
|
||
|
||
patient_id="$(extract_data_field "$upload_json" patientId)"
|
||
if [[ "$patient_id" == "$PATIENT1_ID" ]]; then
|
||
pass "patient-linked cover sheet sets batch patientId"
|
||
else
|
||
fail "patient-linked cover sheet sets batch patientId (got $patient_id)"
|
||
fi
|
||
}
|
||
|
||
test_integration_tests() {
|
||
section "9. dotnet integration tests — CoverSheetBatchTests, CoverSheetPdfTests"
|
||
|
||
if [[ "$SKIP_TEST_CHECKS" == "1" ]]; then
|
||
log " SKIP: dotnet integration tests (VIGILCARE_SKIP_TEST_CHECKS=1)"
|
||
return
|
||
fi
|
||
|
||
if ! command -v dotnet >/dev/null 2>&1; then
|
||
log " SKIP: dotnet not installed"
|
||
return
|
||
fi
|
||
|
||
if dotnet test "$REPO_ROOT/VigilCareRecordsAPI.Tests/VigilCareRecordsAPI.Tests.csproj" \
|
||
--filter "FullyQualifiedName~CoverSheet" \
|
||
--no-restore >/tmp/vigilcare-p10-tests.log 2>&1; then
|
||
pass "CoverSheet integration tests passed"
|
||
else
|
||
fail "CoverSheet integration tests passed"
|
||
log " see /tmp/vigilcare-p10-tests.log"
|
||
fi
|
||
}
|
||
|
||
print_manual_ui_checklist() {
|
||
section "10. Manual Vue UI checks (plan §5)"
|
||
log " Login as intake1 → /cover-sheets"
|
||
log " - Generate 5 VITALS_SHEET covers"
|
||
log " - Print Cover Sheets opens PDF in new tab"
|
||
log " - Cover sheet list shows unused sheets"
|
||
log " Navigate to /intake"
|
||
log " - Scan/type a cover sheet code (Enter triggers lookup)"
|
||
log " - Lookup auto-fills batch type, track, patient"
|
||
log " - Upload with Cover Sheet marks sheet as Used with linked batch ID"
|
||
}
|
||
|
||
main() {
|
||
require_cmd curl
|
||
require_cmd jq
|
||
ensure_fixture_pdf
|
||
|
||
log "VigilCare Records — Phase 10 verification"
|
||
log "API: $API_URL"
|
||
|
||
assert_api_reachable
|
||
|
||
test_authentication
|
||
test_database_schema
|
||
test_cover_sheet_generation
|
||
test_cover_sheet_lookup_and_list
|
||
test_pdf_generation
|
||
test_barcode_assisted_upload
|
||
test_cover_sheet_reuse_and_unknown
|
||
test_auto_assign_cover_sheet
|
||
test_patient_linked_cover_sheet
|
||
test_integration_tests
|
||
print_manual_ui_checklist
|
||
|
||
log ""
|
||
log "Results: $PASS_COUNT passed, $FAIL_COUNT failed"
|
||
if (( FAIL_COUNT > 0 )); then
|
||
log "Failed checks:"
|
||
for item in "${FAILED_TESTS[@]}"; do
|
||
log " - $item"
|
||
done
|
||
exit 1
|
||
fi
|
||
|
||
log "All Phase 10 API verification checks passed."
|
||
log "Complete the manual Vue UI checklist above if not already done."
|
||
}
|
||
|
||
main "$@"
|