# app/tests/test_unitarios.py
import pytest
from datetime import date
from src.dominio import calcular_disponibilitat, validar_reserva, ErrorValidacio

class TestDisponibilitat:
    """La regla de negoci central: mai més reserves que capacitat."""

    def test_refugi_buit_ofereix_tota_la_capacitat(self):
        assert calcular_disponibilitat(capacitat=40, ocupades=0) == 40

    def test_descompta_les_places_ocupades(self):
        assert calcular_disponibilitat(capacitat=40, ocupades=15) == 25

    def test_refugi_ple_ofereix_zero(self):
        assert calcular_disponibilitat(capacitat=40, ocupades=40) == 0

    def test_mai_retorna_negatiu(self):
        """Cas límit: si per un error hi hagués sobrevenda a les dades,
        la funció ha de retornar 0, no una xifra negativa que la interfície
        mostraria com a '-3 places lliures'."""
        assert calcular_disponibilitat(capacitat=40, ocupades=45) == 0

class TestValidacio:
    @pytest.mark.parametrize("places", [0, -1, 13, 999])
    def test_rebutja_places_fora_de_rang(self, places):
        with pytest.raises(ErrorValidacio):
            validar_reserva(places=places, data=date(2026, 8, 15))

    def test_rebutja_data_passada(self):
        with pytest.raises(ErrorValidacio, match="passat"):
            validar_reserva(places=2, data=date(2020, 1, 1))

    @pytest.mark.parametrize("correu", ["", "sense-arrova", "a@", "@b.com"])
    def test_rebutja_correu_invalid(self, correu):
        with pytest.raises(ErrorValidacio):
            validar_reserva(places=2, data=date(2026, 8, 15), email=correu)

# Emuladors locals, gratis i sense tocar el núvol
gcloud emulators firestore start --host-port=localhost:8080
gcloud emulators pubsub    start --host-port=localhost:8085

# Les biblioteques client els detecten per variable d'entorn
export FIRESTORE_EMULATOR_HOST=localhost:8080
export PUBSUB_EMULATOR_HOST=localhost:8085

# app/tests/conftest.py
import pytest, subprocess, time, os
import psycopg

@pytest.fixture(scope="session")
def bd_efimera():
    """PostgreSQL en un contenidor, creat i destruït per la sessió de proves.
    Cost: 0 €. No toca el núvol."""
    subprocess.run([
        "docker", "run", "-d", "--name", "pg-proves",
        "-e", "POSTGRES_PASSWORD=proves",
        "-e", "POSTGRES_DB=reservas",
        "-p", "55432:5432", "postgres:16-alpine",
    ], check=True)

    dsn = "postgresql://postgres:proves@localhost:55432/reservas"
    for _ in range(30):                       # espera que accepti connexions
        try:
            psycopg.connect(dsn).close()
            break
        except Exception:
            time.sleep(1)

    # Aplicar les MATEIXES migracions que en producció
    with psycopg.connect(dsn) as con:
        for f in sorted(os.listdir("data/migraciones")):
            with open(f"data/migraciones/{f}") as fh:
                con.execute(fh.read())
        con.commit()

    yield dsn

    subprocess.run(["docker", "rm", "-f", "pg-proves"], check=True)

# app/tests/test_integracion.py
import pytest, psycopg
from concurrent.futures import ThreadPoolExecutor
from src.repositorio import crear_reserva, ErrorSensePlaces

def test_no_hi_ha_sobrevenda_amb_concurrencia(bd_efimera):
    """El cas que trenca els sistemes de reserves mal fets:
    vint persones intenten reservar l'última plaça alhora."""
    with psycopg.connect(bd_efimera) as con:
        con.execute("INSERT INTO refugio (nombre, altitud_m, capacidad) "
                    "VALUES ('Refugi de Prova', 2000, 1)")
        con.commit()

    def intentar():
        try:
            with psycopg.connect(bd_efimera) as c:
                crear_reserva(c, refugio_id=1, fecha="2026-08-15", plazas=1,
                              titular="Fictici", email="[email protected]")
            return "ok"
        except ErrorSensePlaces:
            return "sense_places"

    with ThreadPoolExecutor(max_workers=20) as ex:
        resultats = list(ex.map(lambda _: intentar(), range(20)))

    # EXACTAMENT una ha de reeixir. Ni cap, ni dues.
    assert resultats.count("ok") == 1, f"Sobrevenda: {resultats.count('ok')} reserves"
    assert resultats.count("sense_places") == 19

    with psycopg.connect(bd_efimera) as con:
        total = con.execute("SELECT COALESCE(SUM(plazas),0) FROM reserva "
                            "WHERE refugio_id=1 AND estado='confirmada'").fetchone()[0]
    assert total == 1

def crear_reserva(con, refugio_id, fecha, plazas, titular, email):
    with con.transaction():
        # El bloqueig de fila serialitza els intents concurrents
        cap = con.execute(
            "SELECT capacidad FROM refugio WHERE id = %s FOR UPDATE",
            (refugio_id,)).fetchone()[0]
        ocupades = con.execute(
            "SELECT COALESCE(SUM(plazas),0) FROM reserva "
            "WHERE refugio_id=%s AND fecha=%s AND estado='confirmada'",
            (refugio_id, fecha)).fetchone()[0]
        if ocupades + plazas > cap:
            raise ErrorSensePlaces()
        con.execute("INSERT INTO reserva (refugio_id, fecha, plazas, "
                    "nombre_titular, email_titular) VALUES (%s,%s,%s,%s,%s)",
                    (refugio_id, fecha, plazas, titular, email))

# app/tests/test_e2e.py
import os, time, uuid, pytest, requests
from google.cloud import bigquery

BASE = os.environ["URL_DEV"]

@pytest.mark.e2e
def test_flux_complet_reserva_arriba_a_analitica():
    """Camí crític sencer: reservar → esdeveniment → BigQuery."""
    marca = str(uuid.uuid4())[:8]
    r = requests.post(f"{BASE}/api/reservas", timeout=30, json={
        "refugio_id": 1, "fecha": "2027-01-15", "plazas": 1,
        "nombre_titular": f"E2E {marca}",          # dada FICTÍCIA
        "email_titular": f"e2e-{marca}@example.com",
    })
    assert r.status_code == 201
    reserva_id = r.json()["id"]

    # La propagació per Pub/Sub no és instantània: se sondeja amb límit
    bq = bigquery.Client()
    consulta = """
      SELECT COUNT(*) AS n
      FROM `refugio-datos.refugio_analitica.reservas_eventos`
      WHERE reserva_id = @rid AND DATE(ocurrido_en) = CURRENT_DATE()
    """
    cfg = bigquery.QueryJobConfig(query_parameters=[
        bigquery.ScalarQueryParameter("rid", "STRING", reserva_id)])

    for _ in range(12):                     # fins a 2 minuts
        n = list(bq.query(consulta, job_config=cfg).result())[0].n
        if n == 1:
            return
        time.sleep(10)
    pytest.fail("L'esdeveniment no ha arribat a BigQuery en 2 minuts")

@pytest.mark.e2e
def test_sondes_de_salut_responen():
    assert requests.get(f"{BASE}/salud/vivo", timeout=10).status_code == 200
    assert requests.get(f"{BASE}/salud/arranque", timeout=10).status_code == 200

steps:
  - id: unitaries-i-integracio
    name: python:3.12-slim
    entrypoint: bash
    args:
      - -c
      - |
        pip install --no-cache-dir -r app/requirements.txt -r app/requirements-dev.txt
        cd app && python -m pytest tests/ -v -m "not e2e" --tb=short \
          --junitxml=/workspace/resultados.xml

  # ... construir, publicar, desplegar ...

  - id: e2e
    name: python:3.12-slim
    entrypoint: bash
    args:
      - -c
      - |
        pip install --no-cache-dir -r app/requirements-dev.txt
        export URL_DEV=$(gcloud run services describe refugio-web \
          --region=europe-west1 --format='value(status.url)')
        cd app && python -m pytest tests/ -v -m e2e
    waitFor: [desplegar]

terraform fmt -check -recursive        # format consistent
terraform validate                     # sintaxi i referències
terraform plan -detailed-exitcode      # 0=sense canvis, 2=hi ha canvis, 1=error

# .github/workflows/plan.yml
name: Terraform plan
on: pull_request

permissions:
  contents: read
  id-token: write
  pull-requests: write

jobs:
  plan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: google-github-actions/auth@v2
        with:
          workload_identity_provider: ${{ vars.WIF_PROVIDER }}
          service_account: ${{ vars.SA_PLAN }}      # SA de NOMÉS LECTURA
      - uses: hashicorp/setup-terraform@v3
      - run: terraform -chdir=infra/envs/dev init
      - id: plan
        run: terraform -chdir=infra/envs/dev plan -no-color -out=plan.tfplan
      - name: Publicar el plan com a comentari
        uses: actions/github-script@v7
        with:
          script: |
            const sortida = `#### Terraform plan
            \`\`\`
            ${{ steps.plan.outputs.stdout }}
            \`\`\``;
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner, repo: context.repo.repo, body: sortida
            });

# tflint: errors de sintaxi, arguments invàlids, bones pràctiques del proveïdor
tflint --init && tflint --recursive

# checkov: comprovacions de seguretat i compliment sobre el codi
checkov -d infra/ --framework terraform --compact

# checkov:skip=CKV_GCP_79:Alta disponibilitat no aplicable; projecte de porfolio
# amb pressupost de 12 €/mes. Vegeu docs/adr/ADR-002.

  - id: analisi-iac
    name: bridgecrew/checkov:latest
    args: ["-d", "infra/", "--compact", "--soft-fail"]

#!/usr/bin/env bash
# scripts/prueba-reconstruccion.sh
set -euo pipefail

ENTORNO="dev"
INICIO=$(date +%s)

echo "=== 1. Estat inicial ==="
terraform -chdir="infra/envs/${ENTORNO}" state list | wc -l

echo "=== 2. DESTRUIR ==="
terraform -chdir="infra/envs/${ENTORNO}" destroy -auto-approve

echo "=== 3. Verificar que no queda res ==="
gcloud run services list      --project="refugio-${ENTORNO}" --format="value(name)"
gcloud sql instances list     --project="refugio-${ENTORNO}" --format="value(name)"
gcloud compute networks list  --project="refugio-${ENTORNO}" --format="value(name)"

echo "=== 4. RECONSTRUIR ==="
terraform -chdir="infra/envs/${ENTORNO}" apply -auto-approve

echo "=== 5. Migracions i dades ==="
./scripts/migrar.sh "${ENTORNO}"
python data/seed/generar.py --entorno="${ENTORNO}"

echo "=== 6. Desplegar l'última imatge coneguda ==="
./scripts/desplegar.sh "${ENTORNO}" "$(git rev-parse --short HEAD)"

echo "=== 7. Verificar que funciona ==="
URL=$(gcloud run services describe refugio-web --region=europe-west1 \
      --project="refugio-${ENTORNO}" --format='value(status.url)')
CODIGO=$(curl -s -o /dev/null -w '%{http_code}' "${URL}/salud/arranque")
test "${CODIGO}" = "200" || { echo "FALLADA: l'app no respon"; exit 1; }

echo "=== 8. Prova d'extrem a extrem ==="
URL_DEV="${URL}" python -m pytest app/tests/ -m e2e -q

FIN=$(date +%s)
echo "✅ RECONSTRUCCIÓ COMPLETA en $(( (FIN-INICIO)/60 )) minuts"

gcloud artifacts docker images scan \
  "europe-west1-docker.pkg.dev/refugio-dev/refugio-imagenes/web:latest" \
  --format="value(response.scan)"

# I per llistar les troballes
gcloud artifacts docker images list-vulnerabilities <RESULTAT_DEL_SCAN> \
  --format="table(vulnerability.effectiveSeverity, vulnerability.shortDescription)"

#!/usr/bin/env bash
# scripts/auditoria-seguridad.sh
set -uo pipefail
PROY="${1:?Ús: $0 <projecte>}"
FALLOS=0
ok()   { echo "  ✅ $1"; }
falla(){ echo "  ❌ $1"; FALLOS=$((FALLOS+1)); }
avisa(){ echo "  ⚠️  $1"; }

echo "=== AUDITORIA DE SEGURETAT: ${PROY} ==="

echo "[1] Rols primitius en comptes de servei"
N=$(gcloud projects get-iam-policy "$PROY" --format=json |
    jq '[.bindings[] | select(.role|test("roles/(owner|editor)")) |
         .members[] | select(startswith("serviceAccount:"))] | length')
[ "$N" -eq 0 ] && ok "Cap SA amb owner/editor" || falla "$N comptes amb rol primitiu"

echo "[2] Claus de compte de servei gestionades per l'usuari"
TOTAL=0
for SA in $(gcloud iam service-accounts list --project="$PROY" --format="value(email)"); do
  K=$(gcloud iam service-accounts keys list --iam-account="$SA" --managed-by=user \
      --format="value(name)" 2>/dev/null | wc -l)
  TOTAL=$((TOTAL+K))
  [ "$K" -gt 0 ] && echo "     · $SA té $K clau(s)"
done
[ "$TOTAL" -eq 0 ] && ok "Zero claus JSON" || falla "$TOTAL claus descarregables"

echo "[3] Buckets accessibles públicament"
PUB=0
for B in $(gcloud storage buckets list --project="$PROY" --format="value(name)"); do
  if gcloud storage buckets get-iam-policy "gs://$B" --format=json |
     jq -e '.bindings[]?.members[]? | select(. == "allUsers" or . == "allAuthenticatedUsers")' >/dev/null 2>&1; then
    echo "     · gs://$B és PÚBLIC"; PUB=$((PUB+1))
  fi
done
[ "$PUB" -eq 0 ] && ok "Cap bucket públic" || falla "$PUB bucket(s) públic(s)"

echo "[4] Bases de dades amb IP pública"
for I in $(gcloud sql instances list --project="$PROY" --format="value(name)"); do
  IPV4=$(gcloud sql instances describe "$I" --project="$PROY" \
         --format="value(settings.ipConfiguration.ipv4Enabled)")
  [ "$IPV4" = "False" ] && ok "$I sense IP pública" || falla "$I TÉ IP PÚBLICA"
done

echo "[5] Secrets al repositori"
if git log -p --all 2>/dev/null | grep -Ei '(password|api[_-]?key|secret|BEGIN (RSA|PRIVATE))' \
   | grep -v 'secret_id\|secretAccessor\|SecretManager\|secret_key_ref\|refugio-db-password' \
   | head -5 | grep -q .; then
  falla "Possibles secrets a l'historial de git — REVISAR"
else
  ok "Sense secrets evidents a l'historial"
fi

echo "[6] Fitxers de credencials a l'arbre"
if find . -name "*.json" -not -path "./node_modules/*" -not -path "./.git/*" \
   -exec grep -l '"type": *"service_account"' {} \; 2>/dev/null | grep -q .; then
  falla "Hi ha fitxers de clau de compte de servei al repositori"
else
  ok "Sense fitxers de credencials"
fi

echo "[7] Serveis de Cloud Run sense autenticació"
for S in $(gcloud run services list --project="$PROY" --region=europe-west1 --format="value(name)"); do
  if gcloud run services get-iam-policy "$S" --project="$PROY" --region=europe-west1 \
     --format=json | jq -e '.bindings[]?.members[]? | select(. == "allUsers")' >/dev/null 2>&1; then
    avisa "$S és públic (correcte si és la web; revisar si no)"
  else
    ok "$S requereix autenticació"
  fi
done

echo "[8] Registres d'auditoria d'activitat d'administrador"
gcloud logging read 'logName:"cloudaudit.googleapis.com%2Factivity"' \
  --project="$PROY" --limit=1 --format="value(timestamp)" | grep -q . \
  && ok "Hi ha registres d'auditoria" || avisa "Sense activitat recent registrada"

echo
echo "=== RESULTAT: ${FALLOS} fallada(es) ==="
exit $((FALLOS > 0))

DOMINIO="refugioreserva.example"

# Certificat: emissor i validesa
echo | openssl s_client -connect "${DOMINIO}:443" -servername "${DOMINIO}" 2>/dev/null |
  openssl x509 -noout -subject -issuer -dates

# Versions de TLS: 1.2 i 1.3 sí; 1.0 i 1.1 han de fallar
for V in tls1 tls1_1 tls1_2 tls1_3; do
  printf "%-8s " "$V"
  echo | openssl s_client -"$V" -connect "${DOMINIO}:443" 2>/dev/null | \
    grep -q "Verify return code: 0" && echo "accepta" || echo "rebutja"
done

# Capçaleres de seguretat
curl -sI "https://${DOMINIO}" | grep -iE \
  'strict-transport|x-content-type|x-frame|content-security|referrer-policy'

# HTTP ha de redirigir
curl -sI "http://${DOMINIO}" | head -1

# Què pot fer realment el meu compte de servei de l'aplicació?
gcloud projects get-iam-policy refugio-prod --format=json |
  jq -r --arg sa "serviceAccount:[email protected]" \
     '.bindings[] | select(.members[]? == $sa) | .role'

# Comprovar un permís concret que NO hauria de tenir
gcloud policy-troubleshoot iam \
  "//cloudresourcemanager.googleapis.com/projects/refugio-prod" \
  --principal-email="[email protected]" \
  --permission="resourcemanager.projects.setIamPolicy"
# Esperat: NOT_GRANTED

// pruebas/carga.js  —  executar amb: k6 run pruebas/carga.js
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate } from 'k6/metrics';

const errorsNegoci = new Rate('errors_negoci');

export const options = {
  stages: [
    { duration: '1m', target: 10 },   // escalfament
    { duration: '2m', target: 50 },   // càrrega esperada
    { duration: '2m', target: 100 },  // el doble
    { duration: '1m', target: 0 },    // refredament
  ],
  thresholds: {
    http_req_duration:  ['p(95)<1000', 'p(99)<2000'],
    http_req_failed:    ['rate<0.01'],
    errors_negoci:      ['rate<0.05'],
  },
};

const BASE = __ENV.URL;

export default function () {
  // 80% consultes, 20% reserves: perfil realista, no tot escriptures
  if (Math.random() < 0.8) {
    const r = http.get(`${BASE}/api/disponibilidad?refugio_id=1&fecha=2027-01-15`);
    check(r, { 'consulta 200': (x) => x.status === 200 });
    errorsNegoci.add(r.status >= 500);
  } else {
    const r = http.post(`${BASE}/api/reservas`, JSON.stringify({
      refugio_id: Math.ceil(Math.random() * 12),
      fecha: '2027-01-15', plazas: 1,
      nombre_titular: 'Càrrega Fictícia',
      email_titular: `carga-${__VU}-${__ITER}@example.com`,
    }), { headers: { 'Content-Type': 'application/json' } });
    // 409 (sense places) és correcte, no un error del sistema
    check(r, { 'reserva 201 o 409': (x) => x.status === 201 || x.status === 409 });
    errorsNegoci.add(r.status >= 500);
  }
  sleep(Math.random() * 2);
}

# ASSAIG EN DESENVOLUPAMENT, amb l'hora anotada
echo "Inici de l'assaig: $(date)" | tee -a docs/evidencias/ensayo-bd.log

# Aturar la base de dades
gcloud sql instances patch refugio-db --project=refugio-dev \
  --activation-policy=NEVER --quiet

# Observar el comportament
curl -s -o /dev/null -w "Portada: %{http_code} en %{time_total}s\n"  "${URL}/"
curl -s -o /dev/null -w "API:     %{http_code} en %{time_total}s\n"  "${URL}/api/refugios"
curl -s -w "Salut: %{http_code}\n" "${URL}/salud/arranque"
curl -s "${URL}/api/refugios" | head -c 300

# Restaurar
gcloud sql instances patch refugio-db --project=refugio-dev \
  --activation-policy=ALWAYS --quiet

INICIO=$(date +%s)

# 1. Quines còpies tinc?
gcloud sql backups list --instance=refugio-db --project=refugio-dev \
  --format="table(id, windowStartTime, status)"

BACKUP_ID=$(gcloud sql backups list --instance=refugio-db --project=refugio-dev \
            --format="value(id)" --limit=1)

# 2. Restaurar sobre una instància NOVA (mai sobre l'original en un assaig)
gcloud sql instances create refugio-db-restaurada \
  --project=refugio-dev --region=europe-west1 \
  --database-version=POSTGRES_16 --tier=db-f1-micro

gcloud sql backups restore "${BACKUP_ID}" \
  --restore-instance=refugio-db-restaurada \
  --backup-instance=refugio-db --project=refugio-dev --quiet

# 3. VERIFICAR que les dades hi són (això és el que gairebé ningú no fa)
./cloud-sql-proxy --port 55433 "refugio-dev:europe-west1:refugio-db-restaurada" &
psql -h 127.0.0.1 -p 55433 -U app -d reservas -c "
  SELECT (SELECT count(*) FROM reserva) AS reservas,
         (SELECT count(*) FROM refugio) AS refugios,
         (SELECT max(creada_en) FROM reserva) AS ultima;"

FIN=$(date +%s)
echo "RTO mesurat: $(( (FIN-INICIO)/60 )) minuts"

# 4. NETEJAR — no deixis la instància restaurada encesa
gcloud sql instances delete refugio-db-restaurada --project=refugio-dev --quiet

# Obtenir el digest EXACTE de la imatge provada a dev
DIGEST=$(gcloud run services describe refugio-web --region=europe-west1 \
         --project=refugio-dev --format="value(spec.template.spec.containers[0].image)")
echo "Promocionant: ${DIGEST}"

# Desplegar en producció SENSE trànsit
gcloud run deploy refugio-web --image="${DIGEST}" \
  --region=europe-west1 --project=refugio-prod \
  --no-traffic --tag=candidata

SERVICIO="refugio-web"; REGION="europe-west1"; PROY="refugio-prod"
NUEVA=$(gcloud run revisions list --service=$SERVICIO --region=$REGION \
        --project=$PROY --limit=1 --format="value(name)")

# Fase 1 — 10% durant 10 minuts
gcloud run services update-traffic $SERVICIO --region=$REGION --project=$PROY \
  --to-revisions="${NUEVA}=10"

# Observar la revisió nova EN CONCRET, no el servei sencer
gcloud logging read \
  "resource.type=cloud_run_revision AND
   resource.labels.revision_name=${NUEVA} AND severity>=ERROR" \
  --project=$PROY --limit=20 --freshness=10m

#!/usr/bin/env bash
# scripts/revertir.sh — provat el 2026-10-28, triga 38 segons
set -euo pipefail
SERVICIO="${1:-refugio-web}"; REGION="europe-west1"; PROY="refugio-prod"

ANTERIOR=$(gcloud run revisions list --service="$SERVICIO" --region="$REGION" \
  --project="$PROY" --format="value(name)" --sort-by="~metadata.creationTimestamp" \
  | sed -n '2p')

echo "Revertint ${SERVICIO} → ${ANTERIOR}"
gcloud run services update-traffic "$SERVICIO" --region="$REGION" --project="$PROY" \
  --to-revisions="${ANTERIOR}=100"

URL=$(gcloud run services describe "$SERVICIO" --region="$REGION" --project="$PROY" \
      --format='value(status.url)')
sleep 5
curl -s -o /dev/null -w "Verificació: %{http_code}\n" "${URL}/salud/arranque"
echo "✅ Revertit a ${ANTERIOR}"

# Manual d'operació — RefugioReserva

## Dades de contacte i accessos
Responsable: <jo>. Projectes: refugio-dev, refugio-prod, refugio-datos.
Consola: https://console.cloud.google.com/home/dashboard?project=refugio-prod

## P1 — L'aplicació retorna errors 5xx
1. `gcloud logging read 'severity>=ERROR' --project=refugio-prod --limit=20 --freshness=15m`
2. Coincideix amb un desplegament? `gcloud run revisions list --service=refugio-web --limit=3`
3. Si coincideix → **revertir**: `./scripts/revertir.sh refugio-web` (38 s)
4. Si no → comprovar la BD: `gcloud sql instances describe refugio-db --format="value(state)"`
5. Escriure el que ha passat a `docs/diario.md`

## P2 — L'aplicació no respon gens
1. `curl -sI https://refugioreserva.example`
2. Servei viu? `gcloud run services describe refugio-web --format="value(status.conditions)"`
3. El DNS resol? `dig +short refugioreserva.example`
4. Certificat vàlid? `openssl s_client -connect refugioreserva.example:443`

## P3 — Restaurar la base de dades
Vegeu `scripts/restaurar.sh`. **RTO mesurat: 22 minuts. RPO: fins a 24 h.**

## P4 — Cost disparat
1. Informe de facturació → agrupar per servei i per etiqueta `componente`
2. Sospitosos habituals: instàncies oblidades, jobs en bucle, consultes de BigQuery sense filtre de partició
3. Mesura immediata: baixar `max-instances`; en últim extrem, `terraform destroy` de dev

## P5 — Desplegar una versió nova
`git push` a `main` → dev automàtic → aprovar a Cloud Build → canari 10/50/100

# 1. Última verificació
./scripts/auditoria-seguridad.sh refugio-prod
terraform -chdir=infra/envs/prod plan          # No changes

# 2. Promocionar la imatge provada
./scripts/promocionar.sh "$(git rev-parse --short HEAD)"

# 3. Canari 10%, esperar, verificar
# 4. 50%, esperar, verificar
# 5. 100%
# 6. Marcar el moment
git tag -a v1.0.0 -m "Llançament del projecte final"
git push --tags

# La comanda que deixes corrent en un terminal durant la primera hora
gcloud logging tail \
  'resource.type="cloud_run_revision" AND severity>=WARNING' \
  --project=refugio-prod

# Incident 2026-11-04 — Errors 5xx després del desplegament de v1.1.0

**Durada:** 19:42 → 19:51 (9 minuts)
**Impacte:** ~40 peticions amb error 500. Sense pèrdua de dades.
**Detecció:** alerta de taxa d'errors (va arribar a les 19:47, 5 min després de l'inici)

## Què va passar
El desplegament de v1.1.0 va introduir una consulta que feia servir una columna
(`opinion.magnitud`) creada per la migració 003, que no s'havia aplicat
en producció. L'aplicació va arrencar bé (la sonda d'arrencada no toca aquesta
taula) i va fallar només a les peticions a `/api/opiniones`.

## Cronologia
- 19:42 Desplegament canari al 10 %
- 19:44 Primers 500 als registres (no els vaig mirar: mirava el tauler, que
        amb el 10 % de trànsit gairebé no va moure l'agulla)
- 19:47 Arriba l'alerta
- 19:49 Executo `./scripts/revertir.sh`
- 19:51 Verificat: 0 errors

## Causa arrel
El pipeline desplega l'aplicació però **no executa les migracions**.
A desenvolupament les aplico a mà, així que allà funcionava.

## Què va funcionar
- La reversió: 38 segons, tal com estava assajada.
- El canari va limitar l'impacte al 10 % del trànsit.

## Què no va funcionar
- L'alerta va trigar 5 minuts. Amb el 10 % de trànsit, el llindar del 5 % sobre
  el total del servei s'assoleix tard.
- No estava mirant els registres de la revisió canària en concret.

## Accions
1. ✅ Afegir pas de migracions al pipeline, abans del desplegament.
2. ✅ Alerta addicional per revisió, no només per servei.
3. ⬜ Prova de fum específica sobre `/api/opiniones` després de desplegar.

     ✓ consulta 200
     ✓ reserva 201 o 409

     checks.........................: 99.31% ✓ 24893  ✗ 172
     http_req_duration..............: avg=241ms min=61ms med=178ms max=8.9s
       { expected_response:true }...: avg=228ms
       p(90)=402ms  p(95)=712ms  p(99)=2.41s
     http_req_failed................: 0.68%  ✓ 172    ✗ 25065
     errors_negoci..................: 0.68%
     iterations.....................: 25065
     vus_max........................: 100

     ✗ http_req_duration.............: p(99)<2000  → 2.41s  FALLADA
     ✓ http_req_failed...............: rate<0.01   → 0.0068 OK

$ gcloud logging read 'severity>=ERROR' --project=refugio-dev --limit=5 \
    --format="value(jsonPayload.message)"
FATAL: remaining connection slots are reserved for non-replication superuser connections

# Abans
pool = ConnectionPool(dsn, min_size=5, max_size=10)
# Després
pool = ConnectionPool(dsn, min_size=1, max_size=3, timeout=5)

     http_req_duration.....: p(95)=634ms  p(99)=1.82s   ✓
     http_req_failed.......: 0.00%  ✓ 0  ✗ 26102        ✓
     Cost de la prova: 0,38 €

Símptoma: després de desplegar v1.2.0 al 10 %, la latència p95 de la revisió
canària va passar de 680 ms a 1.940 ms. Zero errors 5xx. Zero alertes.

Detecció: la mirava jo, comparant la revisió canària amb l'estable
al tauler, perquè el criteri de promoció inclou
«p95 < 1,2 × la base» i 1.940 no el compleix.

Causa: v1.2.0 afegia el sentiment mitjà a la resposta de /api/refugios
amb una subconsulta correlacionada sobre `opinion`, sense índex.

Decisió: revertir sense investigar més, a les 22:14. La correcció
(un índex i una consulta reescrita) es va desplegar dos dies després.

FAILED test_no_hi_ha_sobrevenda_amb_concurrencia
AssertionError: Sobrevenda: 7 reserves

=== AUDITORIA DE SEGURETAT: refugio-prod ===
[1] Rols primitius             ✅ Cap SA amb owner/editor
[2] Claus de compte            ✅ Zero claus JSON
[3] Buckets públics            ❌ 1 bucket públic: gs://refugio-fotos-8f2a
[4] BD amb IP pública          ✅ refugio-db sense IP pública
[5] Secrets a git              ✅ Sense secrets evidents
[6] Credencials a l'arbre      ✅ Sense fitxers de credencials
[7] Cloud Run sense auth       ⚠️  refugio-web és públic (correcte)
[8] Registres d'auditoria      ✅ Hi ha registres

=== RESULTAT: 1 fallada ===

def url_signada(nom_objecte: str, minuts: int = 60) -> str:
    blob = _bucket.blob(nom_objecte)
    return blob.generate_signed_url(version="v4",
                                    expiration=timedelta(minutes=minuts),
                                    method="GET")

tls1     rebutja    ✅
tls1_1   rebutja    ✅
tls1_2   accepta    ✅
tls1_3   accepta    ✅
strict-transport-security: max-age=31536000; includeSubDomains
x-content-type-options: nosniff
x-frame-options: DENY
content-security-policy: default-src 'self'; img-src 'self' data: https://storage.googleapis.com
referrer-policy: strict-origin-when-cross-origin

Portada: 200 en 0.31s          ✅ continua funcionant (contingut estàtic)
API:     500 en 30.02s         ❌ 30 segons i una traça de Python
Salut:   200                   ❌ MENT: diu que està a punt i no ho està

Portada: 200 en 0.28s          ✅
API:     503 en 1.24s          ✅ {"error":"servei_no_disponible",
                                   "missatge":"No podem consultar la disponibilitat
                                   ara mateix. Torna-ho a provar d'aquí a uns minuts."}
Salut:   503                   ✅ Cloud Run deixa d'enviar trànsit
Fotos:   200                   ✅ el bucket és independent de la BD
Tauler:  200                   ✅ Looker Studio llegeix de BigQuery