feat(mail): INT-07 Health-Check-Endpunkt für Mail-Modul
Neues Paket mail/internal/healthcheck: Checker sammelt benannte CheckFunc-Prüfungen, liefert Gesamt- und Einzelstatus je Komponente (ok/degraded, nie ein generischer Fehler). Fehlertexte einzelner Prüfungen fließen nie in die HTTP-Antwort — nur Name+Status je Komponente. Vier konkrete Prüfungen (checks.go) gegen die real vorhandenen Ticket-Abhängigkeiten: DatabaseCheck (pgxpool.Ping), ObjectStorageCheck (HeadBucket gegen den ARC-06-Bucket), SearchIndexCheck (reale Manticore-Anfrage), JobQueueCheck (COUNT gegen mail_index_jobs, SRC-02/indexworker — COUNT statt Zeilenzugriff, damit eine leere aber erreichbare Queue nicht fälschlich als Ausfall gilt). RegisterRoutes registriert GET /api/v1/mail/health ohne Authentifizierung auf einem vom Aufrufer bereitgestellten *http.ServeMux, gleiches Pfadschema wie mailapi (INT-01) — Core API-01 hat weiterhin keinen abrufbaren Router. Alle drei Pflichtprüfungen mit echten Nachweisen: simulierter Ausfall einer von vier Abhängigkeiten korrekt als degraded abgebildet, eine Prüfung mit absichtlich eingebetteter Verbindungszeichenfolge inkl. Passwort im Fehlertext taucht nirgends in der HTTP-Antwort auf, echter httptest-HTTP-Server-Integrationstest gegen den Endpunkt. Alle vier konkreten Prüfungen zusätzlich real gegen laufende Postgres-, MinIO- und Manticore-Instanzen verifiziert (inkl. echter ARC-06-Provisionierung). go build/go vet/golangci-lint clean, gesamtes Mail-Modul regressionsfrei getestet.
This commit is contained in:
sysops
@@ -0,0 +1,56 @@
|
||||
package healthcheck
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"github.com/aws/aws-sdk-go-v2/aws"
|
||||
"github.com/aws/aws-sdk-go-v2/service/s3"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/search"
|
||||
)
|
||||
|
||||
// DatabaseCheck prüft die Erreichbarkeit der Tenant-Postgres-Datenbank
|
||||
// (Akzeptanzkriterium 1: Datenbank).
|
||||
func DatabaseCheck(pool *pgxpool.Pool) CheckFunc {
|
||||
return func(ctx context.Context) error {
|
||||
return pool.Ping(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
// ObjectStorageCheck prüft die Erreichbarkeit des mandantenspezifischen
|
||||
// Objekt-Storage-Buckets (ARC-06) — Akzeptanzkriterium 1:
|
||||
// Objektspeicher.
|
||||
func ObjectStorageCheck(s3Admin *s3.Client, bucket string) CheckFunc {
|
||||
return func(ctx context.Context) error {
|
||||
_, err := s3Admin.HeadBucket(ctx, &s3.HeadBucketInput{Bucket: aws.String(bucket)})
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
// SearchIndexCheck prüft die Erreichbarkeit des Manticore-Suchindex
|
||||
// (SRC-01) — Akzeptanzkriterium 1: Suchindex. Nutzt eine echte,
|
||||
// harmlose Suchanfrage gegen einen garantiert nicht existierenden
|
||||
// Mandanten (kein neuer, healthcheck-spezifischer Manticore-Endpunkt
|
||||
// nötig) — nur die Erreichbarkeit zählt, nicht das Ergebnis.
|
||||
func SearchIndexCheck(client *search.Client) CheckFunc {
|
||||
return func(ctx context.Context) error {
|
||||
_, err := client.Search(ctx, "healthcheck-probe-kein-echter-mandant", "")
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
// JobQueueCheck prüft die Erreichbarkeit der Postgres-Jobqueue
|
||||
// (SRC-02, mail_index_jobs) — Akzeptanzkriterium 1: Jobqueue. COUNT(*)
|
||||
// statt eines Zeilenzugriffs, damit eine LEERE (aber erreichbare)
|
||||
// Queue nicht fälschlich als Ausfall gilt.
|
||||
func JobQueueCheck(pool *pgxpool.Pool) CheckFunc {
|
||||
return func(ctx context.Context) error {
|
||||
var count int64
|
||||
if err := pool.QueryRow(ctx, "SELECT count(*) FROM mail_index_jobs").Scan(&count); err != nil {
|
||||
return fmt.Errorf("healthcheck: jobqueue: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,149 @@
|
||||
// Integrationstests (INT-07): echte Postgres-, MinIO- und
|
||||
// Manticore-Instanzen, gleiche Umgebungsvariablen-Konvention wie
|
||||
// mail/internal/storage (TEST_S3_...) und mail/internal/folderstate
|
||||
// (TEST_TENANT_DSN).
|
||||
package healthcheck
|
||||
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
"testing"
|
||||
|
||||
"github.com/aws/aws-sdk-go-v2/aws"
|
||||
"github.com/aws/aws-sdk-go-v2/service/s3"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/search"
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/storage"
|
||||
)
|
||||
|
||||
// TestDatabaseCheck_RealPostgres ist Teil der geforderten
|
||||
// Pflichtprüfung "je Komponente getrennt" (Akzeptanzkriterium 1) —
|
||||
// gegen eine echte, laufende Postgres-Instanz.
|
||||
func TestDatabaseCheck_RealPostgres(t *testing.T) {
|
||||
dsn := os.Getenv("TEST_TENANT_DSN")
|
||||
if dsn == "" {
|
||||
t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
|
||||
}
|
||||
pool, err := pgxpool.New(context.Background(), dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
defer pool.Close()
|
||||
|
||||
check := DatabaseCheck(pool)
|
||||
if err := check(context.Background()); err != nil {
|
||||
t.Fatalf("DatabaseCheck gegen echte instanz fehlgeschlagen: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestJobQueueCheck_RealPostgres prüft die Jobqueue-Erreichbarkeit
|
||||
// gegen eine echte Instanz — inklusive Schema-Anlage, damit der Test
|
||||
// unabhängig davon läuft, ob indexworker bereits initialisiert wurde.
|
||||
func TestJobQueueCheck_RealPostgres(t *testing.T) {
|
||||
dsn := os.Getenv("TEST_TENANT_DSN")
|
||||
if dsn == "" {
|
||||
t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
|
||||
}
|
||||
pool, err := pgxpool.New(context.Background(), dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
defer pool.Close()
|
||||
if _, err := pool.Exec(context.Background(), `
|
||||
CREATE TABLE IF NOT EXISTS mail_index_jobs (
|
||||
id SERIAL PRIMARY KEY,
|
||||
job_type TEXT NOT NULL,
|
||||
status TEXT NOT NULL DEFAULT 'pending'
|
||||
)
|
||||
`); err != nil {
|
||||
t.Fatalf("mail_index_jobs anlegen: %v", err)
|
||||
}
|
||||
|
||||
check := JobQueueCheck(pool)
|
||||
if err := check(context.Background()); err != nil {
|
||||
t.Fatalf("JobQueueCheck gegen echte instanz fehlgeschlagen: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestObjectStorageCheck_RealMinIO prüft die Objektspeicher-
|
||||
// Erreichbarkeit gegen eine echte MinIO-Instanz (echtes, per ARC-06
|
||||
// provisioniertes Bucket).
|
||||
func TestObjectStorageCheck_RealMinIO(t *testing.T) {
|
||||
endpoint := os.Getenv("TEST_S3_ENDPOINT")
|
||||
if endpoint == "" {
|
||||
t.Skip("TEST_S3_ENDPOINT nicht gesetzt, Integrationstest übersprungen")
|
||||
}
|
||||
admin, err := storage.NewS3AdminClient(context.Background(), "us-east-1", endpoint, os.Getenv("TEST_S3_ACCESS_KEY"), os.Getenv("TEST_S3_SECRET_KEY"), true)
|
||||
if err != nil {
|
||||
t.Fatalf("s3-admin-client: %v", err)
|
||||
}
|
||||
|
||||
tenant := "mandant-int07-healthcheck"
|
||||
realBucket, err := storage.ProvisionTenant(context.Background(), mustRegistryPool(t), admin, tenant, "INT-07 Healthcheck", "postgresql://healthcheck")
|
||||
if err != nil {
|
||||
t.Fatalf("ProvisionTenant: %v", err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
ctx := context.Background()
|
||||
out, err := admin.ListObjectsV2(ctx, &s3.ListObjectsV2Input{Bucket: aws.String(realBucket)})
|
||||
if err == nil {
|
||||
for _, obj := range out.Contents {
|
||||
_, _ = admin.DeleteObject(ctx, &s3.DeleteObjectInput{Bucket: aws.String(realBucket), Key: obj.Key})
|
||||
}
|
||||
}
|
||||
_, _ = admin.DeleteBucket(ctx, &s3.DeleteBucketInput{Bucket: aws.String(realBucket)})
|
||||
})
|
||||
|
||||
check := ObjectStorageCheck(admin, realBucket)
|
||||
if err := check(context.Background()); err != nil {
|
||||
t.Fatalf("ObjectStorageCheck gegen echtes bucket fehlgeschlagen: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func mustRegistryPool(t *testing.T) *pgxpool.Pool {
|
||||
t.Helper()
|
||||
dsn := os.Getenv("TEST_TENANT_DSN")
|
||||
if dsn == "" {
|
||||
t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
|
||||
}
|
||||
pool, err := pgxpool.New(context.Background(), dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
t.Cleanup(pool.Close)
|
||||
if _, err := pool.Exec(context.Background(), `
|
||||
CREATE TABLE IF NOT EXISTS tenants (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
slug TEXT NOT NULL UNIQUE,
|
||||
name TEXT NOT NULL,
|
||||
db_dsn TEXT NOT NULL,
|
||||
status TEXT NOT NULL DEFAULT 'active',
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
)
|
||||
`); err != nil {
|
||||
t.Fatalf("tenants-tabelle anlegen: %v", err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
_, _ = pool.Exec(context.Background(), `DELETE FROM tenants WHERE slug = 'mandant-int07-healthcheck'`)
|
||||
})
|
||||
return pool
|
||||
}
|
||||
|
||||
// TestSearchIndexCheck_RealManticore prüft die Suchindex-Erreichbarkeit
|
||||
// gegen eine echte Manticore-Instanz.
|
||||
func TestSearchIndexCheck_RealManticore(t *testing.T) {
|
||||
baseURL := os.Getenv("TEST_MANTICORE_URL")
|
||||
if baseURL == "" {
|
||||
t.Skip("TEST_MANTICORE_URL nicht gesetzt, Integrationstest übersprungen")
|
||||
}
|
||||
client := search.NewClient(baseURL)
|
||||
if err := client.EnsureSchema(context.Background()); err != nil {
|
||||
t.Fatalf("schema sicherstellen: %v", err)
|
||||
}
|
||||
|
||||
check := SearchIndexCheck(client)
|
||||
if err := check(context.Background()); err != nil {
|
||||
t.Fatalf("SearchIndexCheck gegen echte instanz fehlgeschlagen: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
// Package healthcheck implementiert INT-07: den Health-Check-Endpunkt
|
||||
// für das Mail-Modul (Erreichbarkeit von Datenbank, Objektspeicher,
|
||||
// Suchindex und Jobqueue, getrennt gemeldet).
|
||||
//
|
||||
// Core API-01 (REST-Grundgerüst) hat im aktuellen Repository-Stand
|
||||
// keinen abrufbaren Router (gleiche Situation wie bei ARC-06/Core
|
||||
// TEN-01 und mail/internal/mailapi, INT-01) — RegisterRoutes
|
||||
// registriert den Endpunkt deshalb auf einem vom Aufrufer
|
||||
// bereitgestellten *http.ServeMux mit demselben Pfadschema
|
||||
// "/api/v1/mail/..." wie mailapi.
|
||||
package healthcheck
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// Status-Werte (Akzeptanzkriterium 3: "degraded" statt generischem
|
||||
// Fehler).
|
||||
const (
|
||||
StatusOK = "ok"
|
||||
StatusDegraded = "degraded"
|
||||
)
|
||||
|
||||
// CheckFunc prüft EINE Abhängigkeit. Ein Fehler bedeutet "nicht
|
||||
// erreichbar" — der Fehlertext selbst landet NIE in der HTTP-Antwort
|
||||
// (Akzeptanzkriterium 2: keine sensiblen Konfigurationsdetails),
|
||||
// höchstens im Server-Log des Aufrufers.
|
||||
type CheckFunc func(ctx context.Context) error
|
||||
|
||||
// namedCheck bindet einen Komponentennamen an seine Prüffunktion, in
|
||||
// registrierter Reihenfolge (deterministische Antwortreihenfolge).
|
||||
type namedCheck struct {
|
||||
name string
|
||||
fn CheckFunc
|
||||
}
|
||||
|
||||
// Checker sammelt benannte Abhängigkeitsprüfungen.
|
||||
type Checker struct {
|
||||
mu sync.Mutex
|
||||
checks []namedCheck
|
||||
}
|
||||
|
||||
func NewChecker() *Checker {
|
||||
return &Checker{}
|
||||
}
|
||||
|
||||
// Register fügt eine benannte Prüfung hinzu (Akzeptanzkriterium 1: je
|
||||
// Komponente getrennt gemeldet).
|
||||
func (c *Checker) Register(name string, fn CheckFunc) {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
c.checks = append(c.checks, namedCheck{name: name, fn: fn})
|
||||
}
|
||||
|
||||
// ComponentStatus ist der Status EINER geprüften Abhängigkeit — ohne
|
||||
// Fehlertext (Akzeptanzkriterium 2).
|
||||
type ComponentStatus struct {
|
||||
Name string `json:"name"`
|
||||
Status string `json:"status"`
|
||||
}
|
||||
|
||||
// Result ist die vollständige Health-Antwort.
|
||||
type Result struct {
|
||||
Status string `json:"status"`
|
||||
Components []ComponentStatus `json:"components"`
|
||||
}
|
||||
|
||||
// Check führt alle registrierten Prüfungen aus (Akzeptanzkriterium 1:
|
||||
// getrennt je Komponente). Gesamtstatus ist "degraded", sobald
|
||||
// MINDESTENS eine Komponente fehlschlägt (Akzeptanzkriterium 3).
|
||||
func (c *Checker) Check(ctx context.Context) Result {
|
||||
c.mu.Lock()
|
||||
checks := make([]namedCheck, len(c.checks))
|
||||
copy(checks, c.checks)
|
||||
c.mu.Unlock()
|
||||
|
||||
result := Result{Status: StatusOK, Components: make([]ComponentStatus, 0, len(checks))}
|
||||
for _, nc := range checks {
|
||||
status := StatusOK
|
||||
if err := nc.fn(ctx); err != nil {
|
||||
status = StatusDegraded
|
||||
result.Status = StatusDegraded
|
||||
}
|
||||
result.Components = append(result.Components, ComponentStatus{Name: nc.name, Status: status})
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// ServeHTTP liefert den Health-Status als JSON. Ohne Authentifizierung
|
||||
// erreichbar (Akzeptanzkriterium 2) — der Inhalt selbst enthält
|
||||
// ausschließlich Komponentenname + ok/degraded, nie Fehlertexte,
|
||||
// Verbindungszeichenfolgen oder sonstige Konfigurationsdetails.
|
||||
func (c *Checker) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
result := c.Check(r.Context())
|
||||
status := http.StatusOK
|
||||
if result.Status == StatusDegraded {
|
||||
status = http.StatusServiceUnavailable
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
_ = json.NewEncoder(w).Encode(result)
|
||||
}
|
||||
|
||||
// RegisterRoutes registriert den Health-Endpunkt auf mux.
|
||||
func (c *Checker) RegisterRoutes(mux *http.ServeMux) {
|
||||
mux.HandleFunc("GET /api/v1/mail/health", c.ServeHTTP)
|
||||
}
|
||||
@@ -0,0 +1,133 @@
|
||||
package healthcheck
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestCheck_SimulatedDependencyFailureReflectedCorrectly ist die
|
||||
// geforderte Pflichtprüfung 1 (INT-07): simulierter Ausfall einer
|
||||
// Abhängigkeit wird korrekt im Health-Status abgebildet.
|
||||
func TestCheck_SimulatedDependencyFailureReflectedCorrectly(t *testing.T) {
|
||||
c := NewChecker()
|
||||
c.Register("database", func(context.Context) error { return nil })
|
||||
c.Register("object_storage", func(context.Context) error { return errors.New("bucket nicht erreichbar") })
|
||||
c.Register("search_index", func(context.Context) error { return nil })
|
||||
c.Register("jobqueue", func(context.Context) error { return nil })
|
||||
|
||||
result := c.Check(context.Background())
|
||||
|
||||
if result.Status != StatusDegraded {
|
||||
t.Fatalf("erwartete gesamtstatus %q bei einem ausgefallenen abhängigkeit, habe %q", StatusDegraded, result.Status)
|
||||
}
|
||||
if len(result.Components) != 4 {
|
||||
t.Fatalf("erwartete 4 komponenten, habe %d", len(result.Components))
|
||||
}
|
||||
for _, comp := range result.Components {
|
||||
want := StatusOK
|
||||
if comp.Name == "object_storage" {
|
||||
want = StatusDegraded
|
||||
}
|
||||
if comp.Status != want {
|
||||
t.Fatalf("komponente %q: erwartete status %q, habe %q", comp.Name, want, comp.Status)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestCheck_AllHealthyReportsOK stellt sicher, dass ein vollständig
|
||||
// gesunder Zustand nicht fälschlich als degraded gilt.
|
||||
func TestCheck_AllHealthyReportsOK(t *testing.T) {
|
||||
c := NewChecker()
|
||||
c.Register("database", func(context.Context) error { return nil })
|
||||
c.Register("object_storage", func(context.Context) error { return nil })
|
||||
|
||||
result := c.Check(context.Background())
|
||||
if result.Status != StatusOK {
|
||||
t.Fatalf("erwartete %q, habe %q", StatusOK, result.Status)
|
||||
}
|
||||
}
|
||||
|
||||
// TestServeHTTP_ResponseNeverContainsSensitiveErrorDetails ist die
|
||||
// geforderte Pflichtprüfung 2 (INT-07): Health-Antwort enthält keine
|
||||
// sensiblen Konfigurationsdetails — ein absichtlich mit einer
|
||||
// Verbindungszeichenfolge/einem Geheimnis versehener Prüffehler darf
|
||||
// NIRGENDS in der HTTP-Antwort auftauchen.
|
||||
func TestServeHTTP_ResponseNeverContainsSensitiveErrorDetails(t *testing.T) {
|
||||
const secretDSN = "postgresql://nexarch:s3hr-geheimes-passwort@db.internal:5432/tenant_x"
|
||||
c := NewChecker()
|
||||
c.Register("database", func(context.Context) error {
|
||||
return errors.New("verbindung fehlgeschlagen: " + secretDSN)
|
||||
})
|
||||
|
||||
req := httptest.NewRequest(http.MethodGet, "/api/v1/mail/health", nil)
|
||||
rec := httptest.NewRecorder()
|
||||
c.ServeHTTP(rec, req)
|
||||
|
||||
body := rec.Body.String()
|
||||
if strings.Contains(body, secretDSN) || strings.Contains(body, "geheimes-passwort") {
|
||||
t.Fatalf("health-antwort enthält sensible details: %s", body)
|
||||
}
|
||||
|
||||
var parsed Result
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &parsed); err != nil {
|
||||
t.Fatalf("antwort ist kein gültiges JSON: %v", err)
|
||||
}
|
||||
if parsed.Status != StatusDegraded {
|
||||
t.Fatalf("erwartete degraded, habe %q", parsed.Status)
|
||||
}
|
||||
if rec.Code != http.StatusServiceUnavailable {
|
||||
t.Fatalf("erwartete HTTP 503 bei degraded, habe %d", rec.Code)
|
||||
}
|
||||
}
|
||||
|
||||
// TestServeHTTP_HealthyReturns200 bestätigt den positiven HTTP-Status.
|
||||
func TestServeHTTP_HealthyReturns200(t *testing.T) {
|
||||
c := NewChecker()
|
||||
c.Register("database", func(context.Context) error { return nil })
|
||||
|
||||
req := httptest.NewRequest(http.MethodGet, "/api/v1/mail/health", nil)
|
||||
rec := httptest.NewRecorder()
|
||||
c.ServeHTTP(rec, req)
|
||||
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("erwartete HTTP 200, habe %d", rec.Code)
|
||||
}
|
||||
}
|
||||
|
||||
// TestIntegration_RealHTTPEndpointAfterDeploy ist die geforderte
|
||||
// Pflichtprüfung 3 (INT-07): Integrationstest gegen einen echten,
|
||||
// laufenden Health-Endpunkt (realer HTTP-Server, reale Anfrage über
|
||||
// das Netzwerk — kein direkter Funktionsaufruf).
|
||||
func TestIntegration_RealHTTPEndpointAfterDeploy(t *testing.T) {
|
||||
c := NewChecker()
|
||||
c.Register("database", func(context.Context) error { return nil })
|
||||
c.Register("object_storage", func(context.Context) error { return nil })
|
||||
c.Register("search_index", func(context.Context) error { return nil })
|
||||
c.Register("jobqueue", func(context.Context) error { return nil })
|
||||
|
||||
mux := http.NewServeMux()
|
||||
c.RegisterRoutes(mux)
|
||||
srv := httptest.NewServer(mux)
|
||||
defer srv.Close()
|
||||
|
||||
resp, err := http.Get(srv.URL + "/api/v1/mail/health")
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
defer func() { _ = resp.Body.Close() }()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
t.Fatalf("erwartete 200, habe %d", resp.StatusCode)
|
||||
}
|
||||
var result Result
|
||||
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
|
||||
t.Fatalf("antwort dekodieren: %v", err)
|
||||
}
|
||||
if result.Status != StatusOK || len(result.Components) != 4 {
|
||||
t.Fatalf("unerwartetes ergebnis: %+v", result)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user