platform/sicabe-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5661a9f299bd5c57338463f6344851fe20cd60fb
sicabe-core/deploy/test-verification.sh
T

1089 lines
46 KiB
Bash
Raw Normal View History

first commit
2026-10-09 02:35:14 +07:00
#!/usr/bin/env bash
# =============================================================================
# eBdesk SiCABE — Test & Verification Script
# =============================================================================
# Sesuai Bab 6 dokumen Deployment Guide:
# 6.1 Daftar Uji Verifikasi per Lapisan
# 6.2 End-to-End Smoke Test (Lintas Lapisan)
# 6.3 Performance Baseline Test
#
# Test Categories:
# L1 = Ingestion Layer (Airflow, Sling)
# L2 = Storage Layer (MinIO, Iceberg, Nessie)
# L3 = Processing Layer (Trino, OPA, dbt)
# L4 = Serving Layer (StarRocks shared-data, Dremio)
# L5 = Governance Layer (Keycloak, OpenMetadata, Great Expectations, Grafana)
# E2E = End-to-End Smoke Test (Lintas Lapisan)
# PERF = Performance Baseline
#
# Usage:
# ./test-verification.sh # Jalankan semua test
# ./test-verification.sh --layer L1 # Test layer tertentu (L1-L5)
# ./test-verification.sh --layer E2E # End-to-End smoke test
# ./test-verification.sh --layer PERF # Performance baseline
# ./test-verification.sh --list # Daftar semua test
# ./test-verification.sh --report # Tampilkan laporan test terakhir
# =============================================================================
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd "${SCRIPT_DIR}"
# ─── Shared Library ──────────────────────────────────────────────────────────
source "${SCRIPT_DIR}/lib/common.sh"
source "${SCRIPT_DIR}/config/environment.defaults.sh"
# Multi-host (Fase 2c): --env-file <berkas> memakai env milik SATU HOST
# (generated/host-<x>/.env) sehingga pemeriksaan berjalan sebagaimana host itu
# melihatnya — endpoint container menunjuk alamat host, bukan localhost/12xxx.
# Dipindai lebih dulu karena pemuatan env terjadi sebelum parsing argumen.
ENV_FILE_OVERRIDE=""
_prev=""
for _arg in "$@"; do
[[ "${_prev}" == "--env-file" ]] && ENV_FILE_OVERRIDE="${_arg}"
_prev="${_arg}"
done
ENV_FILE="${ENV_FILE_OVERRIDE:-${SCRIPT_DIR}/.env}"
[[ "${ENV_FILE}" != /* ]] && ENV_FILE="${SCRIPT_DIR}/${ENV_FILE}"
if [[ -n "${ENV_FILE_OVERRIDE}" && ! -f "${ENV_FILE}" ]]; then
echo -e "${ERR} Berkas env tidak ditemukan: ${ENV_FILE}"
exit 1
fi
if [[ -f "${ENV_FILE}" ]]; then
set -a; source "${ENV_FILE}"; set +a
[[ -n "${ENV_FILE_OVERRIDE}" ]] && echo -e "${INFO} env-file: ${ENV_FILE} (mode host)"
fi
# ─── Endpoint E2E (sadar host) ──────────────────────────────────────────────
# `sicabe_local_url`/`sicabe_local_host` (lib/common.sh): single-host → localhost;
# multi-host (bundle memuat SICABE_HOST_NAME) → alamat host PEMILIK. Sebelumnya blok
# E2E memakai `localhost` hardcode → GAGAL di multi-host karena Trino/StarRocks/Airflow
# berada di host lain.
E2E_TRINO_URL="$(sicabe_local_url https TRINO_HOST "${TRINO_HTTPS_PORT:-12443}" TRINO_URL)"
E2E_AIRFLOW_URL="$(sicabe_local_url http AIRFLOW_WEBSERVER_HOST "${AIRFLOW_PORT:-12082}" AIRFLOW_URL)"
E2E_OM_URL="$(sicabe_local_url http OPENMETADATA_HOST "${OPENMETADATA_PORT:-12085}" OPENMETADATA_URL)"
E2E_GRAFANA_URL="$(sicabe_local_url http GRAFANA_HOST "${GRAFANA_PORT:-12300}" GRAFANA_URL)"
# StarRocks via MySQL/TCP: `localhost` memicu unix-socket → pakai 127.0.0.1 di single-host.
E2E_SR_HOST="$(sicabe_local_host STARROCKS_FE_HOST)"
[[ "${E2E_SR_HOST}" == "localhost" ]] && E2E_SR_HOST="127.0.0.1"
# ─── Report File ─────────────────────────────────────────────────────────────
REPORT_FILE="${SCRIPT_DIR}/output/test-report-$(date +%Y%m%d-%H%M%S).log"
mkdir -p "${SCRIPT_DIR}/output"
PASS_COUNT=0
FAIL_COUNT=0
SKIP_COUNT=0
TEST_LOG=""
# ─── Test Helpers ────────────────────────────────────────────────────────────
print_section() {
local title="$1"
echo "" | tee -a "${TEST_LOG}"
echo -e "${BOLD}${BLUE}═══════════════════════════════════════════════════════${NC}" | tee -a "${TEST_LOG}"
echo -e "${BOLD} ${title}${NC}" | tee -a "${TEST_LOG}"
echo -e "${BOLD}${BLUE}═══════════════════════════════════════════════════════${NC}" | tee -a "${TEST_LOG}"
echo "" | tee -a "${TEST_LOG}"
}
test_pass() {
local test_name="$1"
local detail="${2:-}"
PASS_COUNT=$((PASS_COUNT + 1))
echo -e " ${PASS} ${test_name}" | tee -a "${TEST_LOG}"
if [[ -n "${detail}" ]]; then
echo " ${detail}" | tee -a "${TEST_LOG}"
fi
return 0
}
test_fail() {
local test_name="$1"
local detail="${2:-}"
FAIL_COUNT=$((FAIL_COUNT + 1))
echo -e " ${FAIL} ${test_name}" | tee -a "${TEST_LOG}"
if [[ -n "${detail}" ]]; then
echo " ${detail}" | tee -a "${TEST_LOG}"
fi
return 0
}
test_skip() {
local test_name="$1"
local reason="${2:-}"
SKIP_COUNT=$((SKIP_COUNT + 1))
echo -e " ${YELLOW}[SKIP]${NC} ${test_name}" | tee -a "${TEST_LOG}"
if [[ -n "${reason}" ]]; then
echo " ${reason}" | tee -a "${TEST_LOG}"
fi
return 0
}
check_url() {
# <name> <url> [budget-detik] — POLL sampai budget habis. Verifikasi dijalankan tepat
# setelah fresh install, saat banyak service masih warmup (mis. container
# sicabe-airflow-webserver menjalankan `airflow api-server` dgn healthcheck
# start_period 30s + interval 15s). Sebelumnya HANYA 1 percobaan (arg ke-3 dipakai
# sebagai --max-time curl) → service yang belum siap dilaporkan FAIL padahal sehat.
local name="$1"
local url="$2"
local budget="${3:-10}"
local deadline=$(( $(date +%s) + budget ))
while :; do
if curl -skf --max-time 5 "${url}" >/dev/null 2>&1; then
test_pass "${name}" "${url}"
return 0
fi
if (( $(date +%s) >= deadline )); then
test_fail "${name}" "Tidak dapat mengakses ${url} (setelah ${budget}s; masih warmup?)"
return 1
fi
sleep 2
done
}
# ─── Komponen existing (dikelola sistem lain) ────────────────────────────────
# Bila endpoint komponen diarahkan ke luar (.env), container-nya memang TIDAK ada
# di host ini → uji container jadi SKIP, bukan FAIL. Logika sama dengan install.sh.
external_services() {
local out=" ${EXTERNAL_SERVICES:-} "
if [[ -n "${KEYCLOAK_URL:-}" && "${KEYCLOAK_URL}" != "http://localhost:${KEYCLOAK_PORT:-12080}" ]]; then out+=" keycloak "; fi
if [[ -n "${LDAP_URL:-}" && "${LDAP_URL}" != "ldap://openldap:389" ]]; then out+=" openldap "; fi
if [[ -n "${S3_ENDPOINT:-}" && "${S3_ENDPOINT}" != "http://minio:9000" ]]; then out+=" minio minio-init "; fi
if [[ -n "${NESSIE_URL:-}" && "${NESSIE_URL}" != "http://nessie:19120" ]]; then out+=" nessie "; fi
if [[ -n "${TRINO_URL:-}" && "${TRINO_URL}" != "https://localhost:${TRINO_HTTPS_PORT:-12443}" ]]; then out+=" trino "; fi
if [[ -n "${OPA_URL:-}" && "${OPA_URL}" != "http://localhost:${OPA_PORT:-12181}" ]]; then out+=" opa "; fi
if [[ -n "${STARROCKS_HOST:-}" && "${STARROCKS_HOST}" != "localhost" && "${STARROCKS_HOST}" != "127.0.0.1" ]]; then out+=" starrocks-fe starrocks-cn "; fi
if [[ -n "${AIRFLOW_HOST:-}" && "${AIRFLOW_HOST}" != "localhost" && "${AIRFLOW_HOST}" != "127.0.0.1" ]]; then out+=" airflow-init airflow-webserver airflow-dag-processor airflow-scheduler "; fi
if [[ -n "${OPENMETADATA_URL:-}" && "${OPENMETADATA_URL}" != "http://localhost:${OPENMETADATA_PORT:-12085}" ]]; then out+=" openmetadata-opensearch openmetadata-migrate openmetadata-server "; fi
if [[ -n "${GRAFANA_URL:-}" && "${GRAFANA_URL}" != "http://localhost:${GRAFANA_PORT:-12300}" ]]; then out+=" grafana "; fi
# PENTING: `grep -v '^$'` exit 1 saat tak ada baris cocok (tanpa service eksternal)
# → dengan `set -euo pipefail` bisa mematikan skrip. `awk 'NF'` setara, selalu exit 0.
echo "${out}" | tr ' ' '\n' | awk 'NF' | sort -u | paste -sd' ' -
}
# sicabe-trino → trino ; sicabe-starrocks-cn → starrocks-cn
container_external() {
local svc="${1#sicabe-}"
[[ " $(external_services) " == *" ${svc} "* ]]
}
HOST_MODE=0
HOST_CONTAINERS=""
init_host_mode() {
[[ -z "${ENV_FILE_OVERRIDE:-}" ]] && return 0
local dir; dir="$(dirname "${ENV_FILE}")"
[[ -f "${dir}/docker-compose.yml" ]] || return 0
HOST_MODE=1
# `|| true` PENTING: di bawah `set -euo pipefail`, kegagalan pipeline ini MEMATIKAN
# skrip DIAM-DIAM (gejala: berhenti tepat setelah baris "[INFO] env-file:"). Penyebab
# umum: `docker compose` tak tersedia/daemon mati, atau PyYAML (python3-yaml) belum ada.
HOST_CONTAINERS="$(docker compose -f "${dir}/docker-compose.yml" --env-file "${ENV_FILE}" \
--profile all config 2>/dev/null | python3 -c "
import sys, yaml
d = yaml.safe_load(sys.stdin) or {}
for s in (d.get('services') or {}).values():
n = s.get('container_name')
if n: print(n)" 2>/dev/null || true)"
if [[ -z "${HOST_CONTAINERS}" ]]; then
echo -e "${ERR} Gagal membaca daftar container dari bundle host." >&2
echo " docker compose -f ${dir}/docker-compose.yml --env-file ${ENV_FILE} --profile all config" >&2
echo " Cek: 'docker compose' tersedia & daemon jalan, dan PyYAML terpasang" >&2
echo " (mis. sudo ./scripts/prepare-host.sh). Lalu ulangi perintah ini." >&2
exit 1
fi
[[ -n "${SICABE_HOST_NAME:-}" ]] && echo -e "${INFO} Mode host '${SICABE_HOST_NAME}' (tiers=${SICABE_HOST_TIERS:-?}) — komponen host lain di-SKIP"
}
host_expects_container() {
[[ ${HOST_MODE} -eq 0 ]] && return 0
printf '%s\n' "${HOST_CONTAINERS}" | grep -qx "$1"
}
# Cek endpoint untuk komponen TERTENTU. Di mode host, komponen milik host lain
# di-SKIP (bukan FAIL): `localhost:12xxx` memang tidak melayani komponen yang ada di
# host lain. Keterjangkauan lintas host diverifikasi `install.sh --preflight`.
check_url_scoped() { # <label> <container> <url> [timeout]
local label="$1" container="$2"; shift 2
if host_expects_container "${container}"; then
check_url "${label}" "$@"
else
test_skip "${label}" "Dijalankan di host lain (mode --env-file)"
fi
}
# Jalur compose yang sama dengan init_host_mode (berkas compose ada di sebelah .env).
compose_ref() {
local dir; dir="$(dirname "${ENV_FILE:-.env}")"
printf ' -f %s/docker-compose.yml --env-file %s' "${dir}" "${ENV_FILE:-.env}"
}
# Citra klien untuk cek "dari dalam jaringan Docker". Diambil dari daftar citra stack
# sendiri (itulah yang di-prefetch), BUKAN tag :latest hardcode: compose memakai tag
# pinned, dan cek pernah FAIL hanya karena meminta citra yang memang tidak pernah ada
# di server (tarikan quay.io di sana gagal).
resolve_stack_image() { # <pola-egrep> [kandidat-cadangan...]
local pat="$1"; shift
local cand images
images="$(docker compose $(compose_ref) config --images 2>/dev/null | grep -iE "${pat}" || true)"
for cand in ${images} "$@"; do
if docker image inspect "${cand}" >/dev/null 2>&1; then printf '%s' "${cand}"; return 0; fi
done
return 1
}
# Nama jaringan Docker milik sebuah container — jangan hardcode nama jaringan.
container_network() { # <container>
docker inspect -f '{{range $k,$v := .NetworkSettings.Networks}}{{$k}} {{end}}' "$1" 2>/dev/null \
| awk '{print $1}'
}
# Cek fungsional komponen bermakna bila container-nya ADA DI HOST INI, atau endpoint-nya
# memang diarahkan ke luar (.env) oleh operator.
component_checkable() { # <container>
if docker ps --format '{{.Names}}' 2>/dev/null | grep -qx "$1"; then return 0; fi
if container_external "$1"; then return 0; fi
return 1
}
# Bila komponen dikelola host ini -> kembali 0 (cek boleh dijalankan). Selain itu catat
# SKIP untuk setiap label dan kembali 1. Dipakai sebagai `... || return 0`.
# Sebabnya: cek fungsional di skrip ini memakai URL localhost, jadi kalau komponennya ada
# di host lain hasilnya FAIL palsu, padahal yang benar SKIP.
require_component() { # <container> <label>...
local container="$1"; shift
if component_checkable "${container}"; then return 0; fi
local label
for label in "$@"; do
test_skip "${label}" "Dijalankan di host lain (mode --env-file)"
done
return 1
}
check_docker() {
local container="$1"
local name="$2"
if ! host_expects_container "${container}"; then
test_skip "${name}" "Container ${container} dijalankan di host lain (mode --env-file)"
return 0
fi
if docker ps --format "{{.Names}}" | grep -q "${container}"; then
test_pass "${name}" "Container ${container} running"
return 0
fi
if container_external "${container}"; then
test_skip "${name}" "Container ${container} dikelola eksternal (endpoint di .env)"
return 0
fi
test_fail "${name}" "Container ${container} tidak running"
return 1
}
# Helper: query Trino via SERVICE ACCOUNT (HTTP Basic) lewat nginx proxy.
# Returns: seluruh response JSON yang mengandung 'data'
trino_query() {
local sql="$1"
local user="${2:-svc_seed}"
local pass="${3:-${TRINO_SVC_SEED_PASSWORD}}"
local next resp
resp=$(curl -skf -X POST "${E2E_TRINO_URL}/v1/statement" \
-u "${user}:${pass}" \
-H "Content-Type: text/plain" \
-d "${sql}" 2>/dev/null || true)
if [[ -z "${resp}" ]]; then
return 1
fi
next=$(echo "${resp}" | python3 -c "import sys,json; print(json.load(sys.stdin).get('nextUri',''))" 2>/dev/null || true)
local i=0
while [[ -n "${next}" && ${i} -lt 15 ]]; do
sleep 2
resp=$(curl -skf -u "${user}:${pass}" "${next}" 2>/dev/null || true)
if [[ -z "${resp}" ]]; then
return 1
fi
next=$(echo "${resp}" | python3 -c "import sys,json; print(json.load(sys.stdin).get('nextUri',''))" 2>/dev/null || true)
echo "${resp}" | python3 -c "import sys,json; d=json.load(sys.stdin); [print(r) for r in d.get('data',[])]" 2>/dev/null || true
i=$((i + 1))
done
return 0
}
# =============================================================================
# L5: Governance Layer — Keycloak (bab 4.1.1)
# =============================================================================
test_governance_keycloak() {
print_section "L5.1 — Governance: Keycloak (IAM)"
# 4.1.1.9 Verifikasi: test login SSO
check_docker "sicabe-keycloak" "Keycloak container running"
local kc_url="http://localhost:${KEYCLOAK_PORT:-12080}"
check_url_scoped "Keycloak health endpoint" sicabe-keycloak "${kc_url}/health/ready" 60
# Cek di bawah memakai URL localhost -> hanya bermakna bila Keycloak di host ini.
# Cek di bawah memakai URL localhost + kredensial ADMIN → hanya bermakna bila
# Keycloak di host ini. Bila Keycloak EKSTERNAL (host lain, tanpa akses admin),
# verifikasi admin didelegasikan ke pengelola IdP → SKIP (bukan FAIL).
if ! host_expects_container sicabe-keycloak; then
test_skip "Keycloak admin login" "Keycloak eksternal/milik host lain — didelegasikan ke admin IdP"
test_skip "Keycloak realm '${SICABE_REALM:-sicabe}'" "eksternal"
test_skip "Keycloak OIDC configuration" "eksternal"
return 0
fi
# Test login dengan admin credentials
local token
token=$(curl -sf -X POST "${kc_url}/realms/master/protocol/openid-connect/token" \
-H "Content-Type: application/x-www-form-urlencoded" \
--data-urlencode "client_id=admin-cli" \
--data-urlencode "username=${KEYCLOAK_ADMIN:-admin}" \
--data-urlencode "password=${KEYCLOAK_ADMIN_PASSWORD}" \
--data-urlencode "grant_type=password" \
2>/dev/null) || true
local access_token=""
if [[ -n "${token}" ]]; then
access_token=$(echo "${token}" | python3 -c "import sys,json; print(json.load(sys.stdin).get('access_token',''))" 2>/dev/null)
fi
if [[ -n "${access_token}" ]]; then
test_pass "Keycloak admin login" "Token diperoleh"
else
test_fail "Keycloak admin login" "Gagal login sebagai ${KEYCLOAK_ADMIN:-admin} (periksa KEYCLOAK_ADMIN_PASSWORD)"
fi
# Test realm sicabe ada (Keycloak Admin API butuh Bearer token, bukan Basic Auth)
local realm_check
realm_check=$(curl -sf -H "Authorization: Bearer ${access_token}" \
"${kc_url}/admin/realms/${SICABE_REALM:-sicabe}" 2>/dev/null) || true
if echo "${realm_check}" | grep -q "enabled"; then
test_pass "Keycloak realm '${SICABE_REALM:-sicabe}' ada" "Realm aktif"
else
test_fail "Keycloak realm '${SICABE_REALM:-sicabe}'" "Realm tidak ditemukan"
fi
# Test OpenID configuration
local oidc_config
oidc_config=$(curl -sf "${kc_url}/realms/${SICABE_REALM:-sicabe}/.well-known/openid-configuration" 2>/dev/null) || true
if echo "${oidc_config}" | grep -q "authorization_endpoint"; then
test_pass "Keycloak OIDC configuration" "OpenID discovery berfungsi"
else
test_fail "Keycloak OIDC configuration" "OpenID discovery gagal"
fi
}
# =============================================================================
# L2: Storage Layer — MinIO (bab 4.2.1)
# =============================================================================
test_storage_minio() {
print_section "L2.1 — Storage: MinIO (Object Storage)"
check_docker "sicabe-minio" "MinIO container running"
local minio_url="http://localhost:${MINIO_PORT:-12900}"
check_url_scoped "MinIO API" sicabe-minio "${minio_url}/minio/health/live" 45
check_url_scoped "MinIO Cluster health" sicabe-minio "${minio_url}/minio/health/cluster" 45
# Test S3 API — buat bucket test via AWS CLI atau mc
if command -v mc &>/dev/null; then
# MinIO milik host lain -> mc ke URL localhost akan FAIL palsu; catat SKIP.
if require_component sicabe-minio \
"MinIO bucket '${MINIO_BUCKET_ICEBERG_DATA:-iceberg-data}' ada" \
"MinIO upload/download"; then
mc alias set "sicabe-test" "${minio_url}" \
"${MINIO_ROOT_USER:-minioadmin}" "${MINIO_ROOT_PASSWORD}" >/dev/null 2>&1
# List buckets
local buckets
buckets=$(mc ls "sicabe-test" 2>/dev/null)
if echo "${buckets}" | grep -q "${MINIO_BUCKET_ICEBERG_DATA:-iceberg-data}"; then
test_pass "MinIO bucket '${MINIO_BUCKET_ICEBERG_DATA:-iceberg-data}' ada"
else
test_fail "MinIO bucket '${MINIO_BUCKET_ICEBERG_DATA:-iceberg-data}'" "Tidak ditemukan"
fi
# Test upload/download (4.2.1.9). Catatan: `mc cp` dites langsung sebagai kondisi
# (dulu lewat $? — di bawah `set -e` kegagalan justru menghentikan skrip).
echo "test-data-${RANDOM}" > /tmp/sicabe-verify.txt
if mc cp /tmp/sicabe-verify.txt "sicabe-test/${MINIO_BUCKET_ICEBERG_DATA:-iceberg-data}/.verify/test-${RANDOM}.txt" >/dev/null 2>&1; then
test_pass "MinIO upload/download" "S3 API berfungsi (upload)"
mc cp "sicabe-test/${MINIO_BUCKET_ICEBERG_DATA:-iceberg-data}/.verify/"* /tmp/sicabe-download.txt >/dev/null 2>&1 || true
else
test_fail "MinIO upload/download" "Gagal upload file via S3 API"
fi
rm -f /tmp/sicabe-verify.txt /tmp/sicabe-download.txt
fi
else
test_skip "MinIO S3 API test" "mc client tidak tersedia"
# Fallback: jalankan klien mc dari dalam jaringan Docker. Hanya bermakna bila
# MinIO memang dikelola host ini — kalau tidak, cek ini PASS palsu.
# Penjaga utama: container benar-benar JALAN di host ini. Urutan ini penting —
# di bundle host, S3_ENDPOINT memang berbeda (IP lintas host) sehingga
# container_external bisa salah menganggap MinIO "eksternal" padahal lokal.
if ! docker ps --format '{{.Names}}' | grep -qx 'sicabe-minio'; then
if container_external sicabe-minio; then
test_skip "MinIO accessible via container" "Container sicabe-minio dikelola eksternal (endpoint di .env)"
else
test_skip "MinIO accessible via container" "Container sicabe-minio dijalankan di host lain (mode --env-file)"
fi
else
local mc_image="" mc_net="" mc_err=""
mc_image="$(resolve_stack_image '/mc[:@]' 'minio/mc:latest')" || mc_image=""
mc_net="$(container_network sicabe-minio)" || mc_net=""
if [[ -z "${mc_image}" ]]; then
test_skip "MinIO accessible via container" "citra mc tidak ada di host — jalankan scripts/prefetch-images.sh"
elif [[ -z "${mc_net}" ]]; then
test_skip "MinIO accessible via container" "jaringan container MinIO tidak terbaca"
elif mc_err="$(docker run --rm --pull=never --network="${mc_net}" "${mc_image}" \
alias set test http://minio:9000 "${MINIO_ROOT_USER:-minioadmin}" "${MINIO_ROOT_PASSWORD:-}" 2>&1)"; then
test_pass "MinIO accessible via container" "Docker mc dapat konek (${mc_image})"
else
test_fail "MinIO accessible via container" "Docker mc gagal konek (${mc_image}, network ${mc_net})"
printf '%s\n' "${mc_err}" | grep -v '^[[:space:]]*$' | head -3 | sed 's/^/ /' || true
fi
fi
fi
}
# =============================================================================
# L2: Storage Layer — Nessie (bab 4.2.3)
# =============================================================================
test_storage_nessie() {
print_section "L2.2 — Storage: Project Nessie (Metadata Catalog)"
check_docker "sicabe-nessie" "Nessie container running"
local nessie_url="http://localhost:${NESSIE_PORT:-12120}"
# Health via API port (management 9000 tidak dipublikasikan)
check_url_scoped "Nessie API config" sicabe-nessie "${nessie_url}/api/v2/config" 60
sync @ 88a1d74
2026-10-12 21:10:45 +07:00
check_url_scoped "Nessie Iceberg REST config" sicabe-nessie "${nessie_url}${NESSIE_ICEBERG_PREFIX:-/iceberg}/v1/config" 60
first commit
2026-10-09 02:35:14 +07:00
require_component sicabe-nessie \
"Nessie branch 'main'" \
"Nessie warehouse" || return 0
# Cek reference 'main' via Nessie REST API v2
local tree
tree=$(curl -sf "${nessie_url}/api/v2/trees" 2>/dev/null || true)
if echo "${tree}" | grep -q "main"; then
test_pass "Nessie branch 'main'" "Reference utama tersedia"
else
test_skip "Nessie branch 'main'" "Belum ada reference (katalog kosong)"
fi
# Warehouse terhubung MinIO (indikatif via config)
if curl -sf "${nessie_url}/api/v2/config" 2>/dev/null | grep -qi "warehouse"; then
test_pass "Nessie warehouse" "Konfigurasi warehouse tersedia"
else
test_skip "Nessie warehouse" "Info warehouse tidak terlihat di /api/v2/config"
fi
}
# =============================================================================
# L3: Processing Layer — Trino (bab 4.3.1)
# =============================================================================
test_processing_trino() {
print_section "L3.1 — Processing: Trino (Query Engine)"
check_docker "sicabe-trino-coordinator" "Trino coordinator running"
local trino_url="https://localhost:${TRINO_HTTPS_PORT:-12443}"
check_url_scoped "Trino health" sicabe-trino-coordinator "${trino_url}/v1/info" 60
require_component sicabe-trino-coordinator \
"Trino node status" \
"Trino Iceberg catalog" \
"Trino system catalog" \
"Trino Iceberg schemas" || return 0
# Get Trino node info
local node_info
node_info=$(curl -skf "${trino_url}/v1/info" 2>/dev/null)
if echo "${node_info}" | grep -qE '"state":"ACTIVE"|"state" : "ACTIVE"'; then
test_pass "Trino node status" "Trino dalam keadaan ACTIVE"
else
test_fail "Trino node status" "Trino tidak active: ${node_info}"
fi
# Test query — SHOW CATALOGS (4.3.1.8)
# Trino 483 via service account (HTTP Basic) + polling nextUri
local query_result
query_result=$(trino_query "SHOW CATALOGS") || true
if echo "${query_result}" | grep -q "iceberg"; then
test_pass "Trino Iceberg catalog" "Catalog 'iceberg' terdeteksi"
else
test_fail "Trino Iceberg catalog" "Catalog 'iceberg' tidak muncul. Cek konektor Nessie."
fi
if echo "${query_result}" | grep -q "system"; then
test_pass "Trino system catalog" "Catalog 'system' terdeteksi"
fi
# Test query — SHOW SCHEMAS di iceberg catalog
local schemas
schemas=$(trino_query "SHOW SCHEMAS FROM iceberg") || true
if echo "${schemas}" | grep -q "bronze"; then
test_pass "Trino Iceberg schemas" "Schema 'bronze' terdeteksi"
elif echo "${schemas}" | grep -q "information_schema"; then
test_pass "Trino Iceberg schemas" "Minimal information_schema ada"
else
test_skip "Trino Iceberg schemas" "Schema belum dibuat. Jalankan bootstrap.sh step 4."
fi
}
# =============================================================================
# L4: Serving Layer — StarRocks (bab 4.4.1)
# =============================================================================
test_serving_starrocks() {
print_section "L4.1 — Serving: StarRocks (shared-data: FE + CN)"
check_docker "sicabe-starrocks-fe" "StarRocks FE container running"
check_docker "sicabe-starrocks-cn" "StarRocks CN container running"
# Test koneksi MySQL ke StarRocks FE
if command -v mysql &>/dev/null; then
# StarRocks milik host lain -> mysql ke URL localhost akan FAIL palsu; catat SKIP.
if require_component sicabe-starrocks-fe \
"StarRocks FE status" \
"StarRocks CN status" \
"StarRocks storage volume" \
"StarRocks External Catalog" \
"StarRocks LDAP group provider"; then
sr_mysql() {
mysql -h 127.0.0.1 -P "${STARROCKS_FE_PORT:-12930}" -u root -p"${STARROCKS_ROOT_PASSWORD}" -e "$1" 2>/dev/null
}
local sr_status
sr_status=$(sr_mysql "SHOW PROC '/frontends';") || true
if echo "${sr_status}" | grep -q "Alive"; then
test_pass "StarRocks FE status" "Frontend leader aktif"
else
test_fail "StarRocks FE status" "Tidak bisa konek. mysql -h localhost -P ${STARROCKS_FE_PORT:-12930} -u root -p"
fi
# Compute node (shared-data) — bukan BACKEND
local cn_status
cn_status=$(sr_mysql "SHOW COMPUTE NODES;") || true
if echo "${cn_status}" | grep -qi "Alive"; then
test_pass "StarRocks CN status" "Compute node aktif"
else
test_fail "StarRocks CN status" "Tidak ada compute node aktif"
fi
# Storage volume S3 (shared-data)
local sv
sv=$(sr_mysql "SHOW STORAGE VOLUMES;") || true
if echo "${sv}" | grep -q "s3_volume"; then
test_pass "StarRocks storage volume" "s3_volume (S3/MinIO) terdaftar"
else
test_skip "StarRocks storage volume" "s3_volume belum dibuat. Jalankan bootstrap.sh step 5."
fi
# External Catalog via Nessie
local catalogs
catalogs=$(sr_mysql "SHOW CATALOGS;") || true
if echo "${catalogs}" | grep -q "iceberg_catalog"; then
test_pass "StarRocks External Catalog" "Catalog 'iceberg_catalog' terdaftar"
else
test_skip "StarRocks External Catalog" "Catalog 'iceberg_catalog' belum dibuat. Jalankan bootstrap.sh step 5."
fi
# LDAP group provider
local gp
gp=$(sr_mysql "SHOW CREATE GROUP PROVIDER sr_ldap;") || true
if echo "${gp}" | grep -qi "ldap"; then
test_pass "StarRocks LDAP group provider" "sr_ldap terdaftar"
else
test_skip "StarRocks LDAP group provider" "sr_ldap belum dibuat."
fi
fi
else
test_skip "StarRocks FE connection" "MySQL client tidak tersedia"
# Fallback tanpa citra tambahan: klien mysql sudah ADA di dalam container
# starrocks-fe (dipakai healthcheck-nya sendiri) -> cukup docker exec.
# mysql:8 tidak dipakai stack, jadi tidak pernah ikut di-prefetch (dulu FAIL).
if ! docker ps --format '{{.Names}}' | grep -qx 'sicabe-starrocks-fe'; then
test_skip "StarRocks accessible via container" "Container sicabe-starrocks-fe tidak jalan di host ini"
elif docker exec sicabe-starrocks-fe \
mysql --connect-timeout 5 -h127.0.0.1 -P9030 -uroot -p"${STARROCKS_ROOT_PASSWORD:-}" \
-e "SELECT 1;" >/dev/null 2>&1; then
test_pass "StarRocks accessible via container" "Docker MySQL dapat konek (exec starrocks-fe)"
else
test_fail "StarRocks accessible via container" "Docker MySQL gagal konek (exec starrocks-fe)"
fi
fi
}
# =============================================================================
# L1: Ingestion Layer — Airflow (bab 4.5.1)
# =============================================================================
test_ingestion_airflow() {
print_section "L1.1 — Ingestion: Airflow (Orchestrator)"
check_docker "sicabe-airflow-webserver" "Airflow webserver container running"
check_docker "sicabe-airflow-scheduler" "Airflow scheduler container running"
local airflow_url="http://localhost:${AIRFLOW_PORT:-12082}"
check_url_scoped "Airflow webserver" sicabe-airflow-webserver "${airflow_url}/api/v2/monitor/health" 90
require_component sicabe-airflow-webserver \
"Airflow health" \
"Airflow REST API" \
"Airflow DAG 'sicabe_batch_daily'" || return 0
# Cek health endpoint (Airflow 3.x: /api/v2/monitor/health)
local health
health=$(curl -sf "${airflow_url}/api/v2/monitor/health" 2>/dev/null)
if echo "${health}" | grep -q "healthy"; then
test_pass "Airflow health" "Semua komponen healthy"
elif echo "${health}" | grep -q "scheduler.*status"; then
test_pass "Airflow health endpoint" "Health endpoint berfungsi"
else
test_fail "Airflow health" "Health check gagal: ${health}"
fi
# Cek airflow info via REST API (4.5.1.9) — Airflow 3.x pakai /api/v2
local af_info
af_info=$(curl -sf "${airflow_url}/api/v2/monitor/health" 2>/dev/null || true)
if [[ -n "${af_info}" ]]; then
test_pass "Airflow REST API" "API v2 berfungsi"
else
test_skip "Airflow REST API" "API tidak merespon. Mungkin auth diperlukan."
fi
# Cek DAG example via Airflow CLI (Airflow 3.x: REST /api/v1/dags tidak ada)
local dags
if ! host_expects_container sicabe-airflow-webserver; then
test_skip "Airflow DAG 'sicabe_batch_daily'" "Airflow dijalankan di host lain (mode --env-file)"
dags=""
else
dags=$(docker exec sicabe-airflow-webserver airflow dags list 2>/dev/null || true)
fi
if echo "${dags}" | grep -q "sicabe_batch_daily"; then
test_pass "Airflow DAG 'sicabe_batch_daily'" "DAG terdaftar"
else
test_skip "Airflow DAG 'sicabe_batch_daily'" "DAG belum didaftarkan. Jalankan bootstrap.sh step 6."
fi
if echo "${dags}" | grep -q "sicabe_cdc_realtime"; then
test_pass "Airflow DAG 'sicabe_cdc_realtime'" "DAG terdaftar"
fi
}
# =============================================================================
# L5: Governance Layer — OpenMetadata (bab 4.6.1)
# =============================================================================
test_governance_openmetadata() {
print_section "L5.2 — Governance: OpenMetadata (Metadata Platform)"
check_docker "sicabe-openmetadata" "OpenMetadata container running"
local om_url="http://localhost:${OPENMETADATA_PORT:-12085}"
check_url_scoped "OpenMetadata health" sicabe-openmetadata "${om_url}/health" 90
require_component sicabe-openmetadata \
"OpenMetadata API" \
"OpenMetadata UI" \
"OpenMetadata login" || return 0
# Cek API version
local api_info
api_info=$(curl -sf "${om_url}/health" 2>/dev/null)
if [[ -n "${api_info}" ]]; then
test_pass "OpenMetadata API" "API v1 berfungsi"
fi
# Cek UI
local ui_check
ui_check=$(curl -sf "${om_url}" 2>/dev/null)
if echo "${ui_check}" | grep -qi "openmetadata"; then
test_pass "OpenMetadata UI" "UI dapat diakses"
elif [[ -n "${ui_check}" ]]; then
test_pass "OpenMetadata UI" "UI merespon"
else
test_fail "OpenMetadata UI" "UI tidak merespon"
fi
# Test login (OpenMetadata 2.0.x: email admin@open-metadata.org, password Base64.
# Catatan: OM 2.0.x tidak lagi membaca OPENMETADATA_ADMIN_PASSWORD saat bootstrap
# — default-nya 'admin'; password dari .env dipakai bila sudah diganti lewat UI.)
local login_test
local om_pass_b64
om_pass_b64=$(printf '%s' "${OPENMETADATA_ADMIN_PASSWORD:-admin}" | base64)
login_test=$(curl -sf -X POST "${om_url}/api/v1/users/login" \
-H "Content-Type: application/json" \
-d "{\"email\":\"admin@open-metadata.org\",\"password\":\"${om_pass_b64}\"}" \
2>/dev/null) || true
if echo "${login_test}" | grep -q "accessToken"; then
test_pass "OpenMetadata login" "Admin login berhasil"
else
test_skip "OpenMetadata login" "Login gagal — mungkin password berbeda"
fi
}
# =============================================================================
# L5: Governance Layer — Grafana (bab 4.6.3)
# =============================================================================
test_governance_grafana() {
print_section "L5.3 — Governance: Grafana (Observability)"
check_docker "sicabe-grafana" "Grafana container running"
local grafana_url="http://localhost:${GRAFANA_PORT:-12300}"
check_url_scoped "Grafana health" sicabe-grafana "${grafana_url}/api/health" 60
require_component sicabe-grafana \
"Grafana login" \
"Grafana datasource Prometheus" \
"Grafana datasource MinIO Metrics" || return 0
# Cek login (Grafana 13.x: /api/auth/login deprecated — pakai Basic Auth)
local login
login=$(curl -sf -u "admin:${GRAFANA_ADMIN_PASSWORD:-grafana123}" \
"${grafana_url}/api/user" 2>/dev/null) || true
if echo "${login}" | grep -q "\"login\""; then
test_pass "Grafana login" "Admin Basic Auth berhasil"
else
test_fail "Grafana login" "Gagal autentikasi"
fi
# Cek datasource provisioning (4.6.3.6)
# Catatan (review Fase 6): datasource 'OpenMetadata' DIHAPUS karena plugin
# 'grafana-opendatasource-http' tidak ada di katalog Grafana. 'MinIO Metrics'
# juga menunjuk Prometheus — metrik MinIO diambil lewat scrape, bukan dibaca
# langsung dari API S3 MinIO.
local ds
ds=$(curl -sf -u "admin:${GRAFANA_ADMIN_PASSWORD:-grafana123}" \
"${grafana_url}/api/datasources" 2>/dev/null || true)
if [[ -n "${ds}" ]]; then
if echo "${ds}" | grep -q "Prometheus"; then
test_pass "Grafana datasource Prometheus" "Terprovisioning"
fi
if echo "${ds}" | grep -q "MinIO Metrics"; then
test_pass "Grafana datasource MinIO Metrics" "Terprovisioning (metrik MinIO via Prometheus)"
fi
fi
}
# =============================================================================
# E2E: End-to-End Smoke Test (Bab 6.2)
# =============================================================================
test_e2e_smoke() {
print_section "E2E — End-to-End Smoke Test (Lintas Lapisan)"
echo -e "${INFO} Skenario: Alur data dari Ingestion → Storage → Processing → Serving → Governance${NC}"
echo ""
# Prasyarat: semua komponen running
echo -e "${INFO} 1/5 Memeriksa semua komponen running..."
local all_running=true
# dremio OPT-IN (profile khusus, tidak ikut `--profile all`) → tidak wajib.
local optional_svcs="dremio"
for svc in keycloak openldap minio nessie opa trino starrocks-fe starrocks-cn dremio airflow-webserver openmetadata grafana; do
# Mode host: komponen host lain tidak dihitung (keterjangkauannya
# sudah diverifikasi `install.sh --preflight`).
if ! host_expects_container "sicabe-${svc}"; then
echo -e " [ .. ] sicabe-${svc} — di host lain, dilewati"
continue
fi
if ! docker ps --format "{{.Names}}" | grep -q "sicabe-${svc}"; then
if [[ " ${optional_svcs} " == *" ${svc} "* ]]; then
echo -e " ${WARN} sicabe-${svc} — tidak running (opsional, dilewati)"
else
echo -e " ${FAIL} sicabe-${svc} — TIDAK RUNNING"
all_running=false
fi
fi
done
if ${all_running}; then
if [[ ${HOST_MODE} -eq 1 ]]; then
test_pass "E2E Prasyarat" "Semua container MILIK HOST INI running (host lain di-SKIP; keterjangkauan dicek --preflight)"
else
test_pass "E2E Prasyarat" "Semua container running"
fi
else
test_fail "E2E Prasyarat" "Beberapa container tidak running"
echo -e "${ERR} E2E test dihentikan — tidak semua komponen tersedia."
return 1
fi
# Step 1: [Ingestion] Test koneksi ke sumber data & MinIO
echo -e "${INFO} 2/5 [Ingestion] Verifikasi pipeline integration..."
local airflow_ok=false
if curl -sf "${E2E_AIRFLOW_URL}/api/v2/monitor/health" >/dev/null 2>&1; then
airflow_ok=true
test_pass "E2E Ingestion: Airflow siap"
else
test_fail "E2E Ingestion: Airflow" "Airflow tidak siap (${E2E_AIRFLOW_URL})"
fi
# Step 2: [Storage] Data tersimpan sebagai Iceberg, tercatat di Nessie
echo -e "${INFO} 3/5 [Storage] Verifikasi Iceberg + Nessie..."
local tq_result
tq_result=$(trino_query "SELECT 'Storage Layer OK' AS status") || true
if [[ -n "${tq_result}" ]]; then
test_pass "E2E Storage: Trino query execution"
# Coba query Iceberg catalog
local iceberg_query
iceberg_query=$(trino_query "SHOW TABLES FROM iceberg.bronze") || true
if [[ -n "${iceberg_query}" ]]; then
test_pass "E2E Storage: Iceberg catalog queryable via Trino"
fi
else
test_fail "E2E Storage: Trino" "Query execution gagal"
fi
# Step 3: [Processing] dbt via Trino transformasi
echo -e "${INFO} 4/5 [Processing] Verifikasi data processing..."
if [[ "${airflow_ok}" == true ]]; then
# `docker exec` hanya berlaku untuk container LOKAL. Di host lain → SKIP (bukan FAIL):
# keterjangkauan lintas host sudah diverifikasi `--preflight`, dan health API di atas
# membuktikan Airflow siap dari sini.
if [[ ${HOST_MODE} -eq 1 ]] && ! host_expects_container sicabe-airflow-webserver; then
test_skip "E2E Processing: DAG" "Airflow di host lain (mode --env-file) — cek DAG via UI/API di sana"
elif docker exec sicabe-airflow-webserver airflow dags list 2>/dev/null | grep -q "sicabe"; then
test_pass "E2E Processing: DAG siap dijalankan"
else
test_skip "E2E Processing: DAG" "DAG contoh belum di-deploy. Jalankan bootstrap.sh step 6."
fi
fi
# Step 4: [Serving] StarRocks siap melayani query
echo -e "${INFO} 5/5 [Serving] Verifikasi StarRocks..."
if command -v mysql &>/dev/null; then
if mysql --protocol=TCP -h "${E2E_SR_HOST}" -P "${STARROCKS_FE_PORT:-12930}" -u root -p"${STARROCKS_ROOT_PASSWORD}" -e "SELECT 1 AS test;" >/dev/null 2>&1; then
test_pass "E2E Serving: StarRocks query execution"
else
test_fail "E2E Serving: StarRocks" "Query execution gagal (${E2E_SR_HOST}:${STARROCKS_FE_PORT:-12930})"
fi
else
test_skip "E2E Serving: StarRocks" "MySQL client tidak tersedia"
fi
# Step 5: [Governance] Verifikasi governance
echo -e "${INFO} 6/5 [Governance] Verifikasi metadata & observability..."
if curl -sf "${E2E_OM_URL}/health" >/dev/null 2>&1; then
test_pass "E2E Governance: OpenMetadata siap"
fi
if curl -sf "${E2E_GRAFANA_URL}/api/health" >/dev/null 2>&1; then
test_pass "E2E Governance: Grafana siap"
fi
}
# =============================================================================
# PERF: Performance Baseline Test (Bab 6.3)
# =============================================================================
test_performance_baseline() {
print_section "PERF — Performance Baseline Test"
# Test latency endpoint setiap komponen
echo -e "${INFO} Mengukur latency endpoint setiap lapisan...${NC}"
local endpoints=(
"Keycloak:http://localhost:${KEYCLOAK_PORT:-12080}/health/ready"
"MinIO:http://localhost:${MINIO_PORT:-12900}/minio/health/live"
"Nessie:http://localhost:${NESSIE_PORT:-12120}/api/v2/config"
"Trino:https://localhost:${TRINO_HTTPS_PORT:-12443}/v1/info"
"OPA:http://localhost:${OPA_PORT:-12181}/v1/data/trino/allow"
"Airflow:http://localhost:${AIRFLOW_PORT:-12082}/api/v2/monitor/health"
"OpenMetadata:http://localhost:${OPENMETADATA_PORT:-12085}/health"
"Grafana:http://localhost:${GRAFANA_PORT:-12300}/api/health"
)
for ep in "${endpoints[@]}"; do
local name="${ep%%:*}"
local url="${ep#*:}"
# Mode host: ukur hanya komponen milik host ini — latency ke
# localhost komponen host lain tidak bermakna.
local ep_container=""
case "${name}" in
Keycloak) ep_container="sicabe-keycloak" ;;
MinIO) ep_container="sicabe-minio" ;;
Nessie) ep_container="sicabe-nessie" ;;
Trino) ep_container="sicabe-trino-coordinator" ;;
OPA) ep_container="sicabe-opa" ;;
Airflow) ep_container="sicabe-airflow-webserver" ;;
OpenMetadata) ep_container="sicabe-openmetadata" ;;
Grafana) ep_container="sicabe-grafana" ;;
esac
if [[ -n "${ep_container}" ]] && ! host_expects_container "${ep_container}"; then
echo -e " [ .. ] ${name} — di host lain, dilewati"
continue
fi
local total_time=0
local success=true
for run in 1 2 3; do
local time_val
time_val=$(curl -kso /dev/null -w "%{time_total}" --max-time 5 "${url}" 2>/dev/null || echo "0")
total_time=$(echo "${total_time} + ${time_val}" | bc -l 2>/dev/null || echo "0")
if [[ "${time_val}" == "0" ]]; then
success=false
fi
done
if [[ "${success}" == true ]]; then
local avg
avg=$(echo "scale=3; ${total_time} / 3" | bc -l 2>/dev/null || echo "N/A")
test_pass "PERF Latency: ${name}" "Rata-rata ${avg}s"
else
test_skip "PERF Latency: ${name}" "Endpoint tidak merespon"
fi
done
# Test query latency Trino
echo -e "${INFO} Mengukur query latency Trino...${NC}"
if curl -skf "https://localhost:${TRINO_HTTPS_PORT:-12443}/v1/info" >/dev/null 2>&1; then
local query_times=()
for run in 1 2; do
local qtime
qtime=$(curl -skf -X POST "https://localhost:${TRINO_HTTPS_PORT:-12443}/v1/statement" \
-u "svc_seed:${TRINO_SVC_SEED_PASSWORD}" \
-H "Content-Type: text/plain" \
-d "SELECT 1" -w "%{time_total}" -o /dev/null 2>/dev/null || echo "0")
query_times+=("${qtime}")
done
local qavg
qavg=$(echo "scale=3; (${query_times[0]} + ${query_times[1]}) / 2" | bc -l 2>/dev/null || echo "N/A")
test_pass "PERF Trino query" "Rata-rata ${qavg}s"
else
test_skip "PERF Trino query" "Trino tidak tersedia"
fi
}
# =============================================================================
# REPORT
# =============================================================================
show_report() {
echo ""
echo -e "${BOLD}${BLUE}═══════════════════════════════════════════════════════${NC}"
echo -e "${BOLD} LAPORAN VERIFIKASI${NC}"
echo -e "${BOLD}${BLUE}═══════════════════════════════════════════════════════${NC}"
echo ""
echo -e " Total Pass: ${PASS_COUNT}"
echo -e " Total Fail: ${FAIL_COUNT}"
echo -e " Total Skip: ${SKIP_COUNT}"
echo -e " Total: $((PASS_COUNT + FAIL_COUNT + SKIP_COUNT))"
echo ""
echo -e " Report file: ${REPORT_FILE}"
echo ""
if [[ ${FAIL_COUNT} -eq 0 ]]; then
echo -e "${GREEN}${BOLD} ✅ SEMUA TEST PASS${NC}"
else
echo -e "${RED}${BOLD} ❌ ${FAIL_COUNT} TEST FAILED${NC}"
echo -e " Periksa ${REPORT_FILE} untuk detail."
fi
echo ""
}
# =============================================================================
# MAIN
# =============================================================================
main() {
# Mode per-host ditentukan setelah env dimuat (ENV_FILE) dan fungsi tersedia.
init_host_mode
local TEST_LAYER="ALL"
if [[ $# -gt 0 ]]; then
case "$1" in
--env-file)
# Sudah ditangani sebelum pemuatan env (lihat di atas banner).
shift 2 2>/dev/null || shift
;;
--help|-h)
echo "Usage: $0 [--layer L1|L2|L3|L4|L5|E2E|PERF] [--list] [--report]"
echo " Default: semua test"
echo " --layer L1 Test Ingestion Layer (Airflow)"
echo " --layer L2 Test Storage Layer (MinIO, Nessie)"
echo " --layer L3 Test Processing Layer (Trino)"
echo " --layer L4 Test Serving Layer (StarRocks)"
echo " --layer L5 Test Governance Layer (Keycloak, OpenMetadata, Grafana)"
echo " --layer E2E End-to-End Smoke Test"
echo " --layer PERF Performance Baseline Test"
echo " --list Daftar test yang tersedia"
echo " --report Tampilkan hasil test terakhir"
exit 0
;;
--list)
echo "Test yang tersedia:"
echo " L1 - Ingestion Layer: Airflow"
echo " L2 - Storage Layer: MinIO, Nessie"
echo " L3 - Processing Layer: Trino"
echo " L4 - Serving Layer: StarRocks"
echo " L5 - Governance Layer: Keycloak, OpenMetadata, Grafana"
echo " E2E - End-to-End Smoke Test"
echo " PERF - Performance Baseline Test"
exit 0
;;
--layer)
TEST_LAYER="${2:-ALL}"
;;
--report)
local latest_report
latest_report=$(ls -t "${SCRIPT_DIR}/output"/test-report-*.log 2>/dev/null | head -1)
if [[ -n "${latest_report}" ]]; then
cat "${latest_report}"
else
echo "Belum ada laporan test. Jalankan $0 terlebih dahulu."
fi
exit 0
;;
*)
echo -e "${ERR} Argumen tidak dikenal: $1"
echo "Gunakan --help untuk bantuan."
exit 1
;;
esac
fi
# Setup test log
TEST_LOG="${REPORT_FILE}"
exec > >(tee -a "${TEST_LOG}") 2>&1
echo -e "${BOLD}${BLUE}"
echo "╔═══════════════════════════════════════════════════════╗"
echo "║ eBdesk SiCABE — Test & Verification ║"
echo "║ Bab 6: Verifikasi & Smoke Test ║"
echo "╚═══════════════════════════════════════════════════════╝"
echo -e "${NC}"
echo "Timestamp: $(date)"
echo ""
# Pastikan Docker berjalan
if ! docker ps >/dev/null 2>&1; then
echo -e "${ERR} Docker tidak berjalan. Test dihentikan."
exit 1
fi
case "${TEST_LAYER}" in
L1) test_ingestion_airflow ;;
L2) test_storage_minio; test_storage_nessie ;;
L3) test_processing_trino ;;
L4) test_serving_starrocks ;;
L5) test_governance_keycloak; test_governance_openmetadata; test_governance_grafana ;;
E2E) test_e2e_smoke ;;
PERF) test_performance_baseline ;;
ALL)
test_governance_keycloak
test_storage_minio
test_storage_nessie
test_processing_trino
test_serving_starrocks
test_ingestion_airflow
test_governance_openmetadata
test_governance_grafana
test_e2e_smoke
test_performance_baseline
;;
esac
show_report
}
main "$@"
Reference in New Issue Copy Permalink