test-confighub-k8s

#!/bin/bash
set -e

# Mini TCK for ConfigHub + Kubernetes Integration
# Tests: 1 space + 1 unit + 1 kind cluster + 1 worker + 1 apply
# No dependencies on any project - pure ConfigHub + K8s verification

echo "🧪 ConfigHub + Kubernetes Mini TCK"
echo "==================================="
echo ""
echo "This test verifies:"
echo "  - ConfigHub API connectivity"
echo "  - Kubernetes cluster access"
echo "  - Worker installation"
echo "  - Unit apply workflow"
echo "  - Live state verification"
echo ""

# Cleanup function
cleanup() {
  echo ""
  echo "🧹 Cleaning up test resources..."

  # Get space ID if it exists
  SPACE_ID=$(cub space list --format json 2>/dev/null | jq -r '.[] | select(.Slug == "confighub-tck") | .ID' 2>/dev/null || echo "")

  if [ -n "$SPACE_ID" ]; then
    echo "  Cleaning up space: $SPACE_ID"

    # List and delete all units in the space
    cub unit list --space confighub-tck --format json 2>/dev/null | \
      jq -r '.[].Slug' 2>/dev/null | \
      while read slug; do
        echo "  Deleting unit: $slug"
        cub unit delete "$slug" --space confighub-tck 2>/dev/null || true
      done

    # Uninstall worker
    cub worker delete tck-worker --space confighub-tck 2>/dev/null || true

    # Delete space
    cub space delete confighub-tck 2>/dev/null || true
  fi

  # Delete Kind cluster
  kind delete cluster --name confighub-tck 2>/dev/null || true

  # Cleanup temp files
  rm -f /tmp/tck-test-pod.yaml

  echo "✅ Cleanup complete"
}

# Trap exit to cleanup
trap cleanup EXIT

# Check prerequisites
echo "Checking prerequisites..."
if ! command -v cub &> /dev/null; then
  echo "❌ Error: 'cub' command not found"
  echo "   Install: brew install confighubai/tap/cub"
  exit 1
fi

if ! command -v kind &> /dev/null; then
  echo "❌ Error: 'kind' command not found"
  echo "   Install: brew install kind"
  exit 1
fi

if ! command -v kubectl &> /dev/null; then
  echo "❌ Error: 'kubectl' command not found"
  echo "   Install: brew install kubectl"
  exit 1
fi

# Check ConfigHub authentication
if ! cub space list &>/dev/null; then
  echo "❌ Error: ConfigHub authentication failed"
  echo "   Run: cub auth login"
  exit 1
fi

echo "✅ All prerequisites met"
echo ""

# Clean up any leftover resources from previous runs
echo "Cleaning up any leftover resources..."
kind delete cluster --name confighub-tck 2>/dev/null || true
cub space delete confighub-tck 2>/dev/null || true
echo ""

# Step 1: Create Kind cluster
echo "Step 1: Create Kind cluster"
echo "----------------------------"
if kind get clusters 2>/dev/null | grep -q "^confighub-tck$"; then
  echo "⚠️  Kind cluster 'confighub-tck' already exists, deleting..."
  kind delete cluster --name confighub-tck
fi

kind create cluster --name confighub-tck --wait 60s
echo "✅ Kind cluster created"
echo ""

# Step 2: Create ConfigHub space
echo "Step 2: Create ConfigHub space"
echo "-------------------------------"
cub space create confighub-tck --label test=tck 2>/dev/null || true
echo "✅ ConfigHub space created"
echo ""

# Step 3: Create test unit (minimal nginx pod)
echo "Step 3: Create test unit (nginx pod)"
echo "-------------------------------------"

# Use unique name with timestamp to avoid conflicts
UNIT_NAME="test-pod-$(date +%s)"

cat > /tmp/tck-test-pod.yaml <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: ${UNIT_NAME}
  namespace: default
  labels:
    app: tck-test
spec:
  containers:
  - name: nginx
    image: nginx:alpine
    ports:
    - containerPort: 80
EOF

cub unit create \
  --space confighub-tck \
  --label type=test \
  "${UNIT_NAME}" \
  /tmp/tck-test-pod.yaml
echo "✅ Unit created in ConfigHub (${UNIT_NAME})"
echo ""

# Step 4: Create and install ConfigHub worker
echo "Step 4: Create and install ConfigHub worker"
echo "--------------------------------------------"
kubectl config use-context kind-confighub-tck

# First create the worker in ConfigHub
cub worker create tck-worker --space confighub-tck 2>/dev/null || true

# Then install it to the cluster
if ! cub worker install tck-worker \
  --space confighub-tck \
  --namespace confighub \
  --include-secret \
  --export | kubectl apply -f -; then
  echo "❌ Worker installation failed"
  echo "   Checking worker status..."
  cub worker list --space confighub-tck || true
  kubectl get pods -n confighub || true
  exit 1
fi

# Wait for worker deployment to be ready
echo "Waiting for worker deployment to be ready..."
if ! kubectl rollout status deployment/tck-worker -n confighub --timeout=90s 2>/dev/null; then
  echo "❌ Worker deployment did not become ready"
  kubectl get pods -n confighub || true
  kubectl describe pod -n confighub -l app=tck-worker || true
  exit 1
fi

# Wait for worker to connect to ConfigHub
echo "Waiting for worker to connect to ConfigHub..."
for i in {1..30}; do
  WORKER_STATUS=$(cub worker list --space confighub-tck --format json 2>/dev/null | jq -r '.[0].Condition // "Unknown"' 2>/dev/null || echo "Unknown")
  if [ "$WORKER_STATUS" = "Ready" ]; then
    break
  fi
  sleep 2
done

if [ "$WORKER_STATUS" != "Ready" ]; then
  echo "⚠️  Worker status: $WORKER_STATUS (may still be connecting)"
fi

echo "✅ Worker installed and connected"
echo ""

# Step 5: Set target and apply unit to Kubernetes
echo "Step 5: Set target and apply unit to Kubernetes"
echo "------------------------------------------------"

# Get the Kubernetes target ID (use the k8s-* target for YAML resources)
TARGET_SLUG="k8s-tck-worker"

# Verify target exists
if ! cub target list --space confighub-tck --names 2>/dev/null | grep -q "$TARGET_SLUG"; then
  echo "❌ Could not find target: $TARGET_SLUG"
  cub target list --space confighub-tck || true
  exit 1
fi

echo "Using target: $TARGET_SLUG"

# Set the unit's target
cub unit set-target "${UNIT_NAME}" "$TARGET_SLUG" --space confighub-tck

# Apply the unit
cub unit apply "${UNIT_NAME}" --space confighub-tck
echo "✅ Unit applied"
echo ""

# Step 6: Verify deployment
echo "Step 6: Verify deployment"
echo "-------------------------"
echo "Waiting for pod to be ready (max 60s)..."

# Wait for pod to be ready
if ! kubectl wait --for=condition=ready "pod/${UNIT_NAME}" --timeout=60s 2>/dev/null; then
  echo "❌ Pod did not become ready in time"
  kubectl get pod "${UNIT_NAME}" -o yaml || true
  exit 1
fi

echo "✅ Pod is ready in Kubernetes"
echo ""

# Step 7: Verify ConfigHub live state
echo "Step 7: Verify ConfigHub live state"
echo "------------------------------------"
LIVE_STATE=$(cub unit get-live-state "${UNIT_NAME}" --space confighub-tck --format json 2>/dev/null || echo "{}")

if echo "$LIVE_STATE" | jq -e '.status.phase == "Running"' > /dev/null 2>&1; then
  echo "✅ ConfigHub live state shows: Running"
else
  PHASE=$(echo "$LIVE_STATE" | jq -r '.status.phase // "Unknown"' 2>/dev/null || echo "Unknown")
  echo "⚠️  ConfigHub live state shows: $PHASE"
  if [ "$PHASE" != "Running" ]; then
    echo "   (Pod may still be starting)"
  fi
fi
echo ""

# Final verification
echo "Step 8: Final verification"
echo "--------------------------"
POD_STATUS=$(kubectl get pod "${UNIT_NAME}" -o jsonpath='{.status.phase}' 2>/dev/null || echo "Unknown")

if [ "$POD_STATUS" = "Running" ]; then
  echo "✅ Pod verified in Kubernetes: $POD_STATUS"
else
  echo "❌ Pod not running in Kubernetes: $POD_STATUS"
  kubectl describe pod "${UNIT_NAME}" || true
  exit 1
fi

echo ""
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "🎉 SUCCESS! ConfigHub + Kubernetes integration verified"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo ""
echo "Summary:"
echo "  ✅ Kind cluster: confighub-tck"
echo "  ✅ ConfigHub space: confighub-tck"
echo "  ✅ ConfigHub unit: ${UNIT_NAME}"
echo "  ✅ Worker: tck-worker (connected)"
echo "  ✅ Pod status: $POD_STATUS"
echo "  ✅ ConfigHub → Kubernetes flow: WORKING"
echo ""
echo "Your ConfigHub + Kubernetes environment is correctly configured!"
echo ""
echo "Note: All test resources will be cleaned up automatically."