Entender el contrato

El proyecto final crea un endpoint de saludo y lo prueba sin abrir un puerto. Combina entradas explícitas, salida estructurada, validación y metadatos HTTP. Mantén el alcance pequeño para explicar cada rama antes de añadir almacenamiento, trabajadores o framework.

Guarda el primer bloque como main.go en un módulo nuevo. hello lee el parámetro, elimina espacios y rechaza nombres vacíos. Codifica antes de enviar encabezados para poder responder coherentemente ante errores. El handler no contiene estado mutable compartido.

Trabajar el ejemplo

Guarda el segundo bloque como main_test.go y ejecuta go test ./.... La prueba invoca hello con httptest.NewRequest y NewRecorder. Comprueba entradas válidas e inválidas, tipo JSON y contenido decodificado. Ejecuta go run . después de pasar las pruebas y visita /hello?name=Ada en el servidor local.

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "strings"
    "time"
)

type Greeting struct { Message string `json:"message"` }

func hello(w http.ResponseWriter, r *http.Request) {
    name := strings.TrimSpace(r.URL.Query().Get("name"))
    if name == "" || len(name) > 100 {
        http.Error(w, "name must contain 1-100 bytes", http.StatusBadRequest)
        return
    }
    body, err := json.Marshal(Greeting{Message: "Hello, " + name})
    if err != nil {
        http.Error(w, "encoding failed", http.StatusInternalServerError)
        return
    }
    w.Header().Set("Content-Type", "application/json")
    w.Write(body)
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("GET /hello", hello)
    server := &http.Server{
        Addr: "127.0.0.1:8080", Handler: mux,
        ReadHeaderTimeout: 5 * time.Second,
        ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second,
        IdleTimeout: 60 * time.Second,
    }
    log.Fatal(server.ListenAndServe())
}

Probar el handler sin abrir un puerto

Guarda este bloque como main_test.go junto a main.go. Ejecuta go test ./... en ese módulo.

package main

import (
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"
)

func TestHello(t *testing.T) {
    cases := []struct { name, target string; status int; message string }{
        {"valid", "/hello?name=Ada", http.StatusOK, "Hello, Ada"},
        {"missing", "/hello", http.StatusBadRequest, ""},
    }
    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            response := httptest.NewRecorder()
            hello(response, httptest.NewRequest(http.MethodGet, tc.target, nil))
            if response.Code != tc.status {
                t.Fatalf("status = %d; want %d", response.Code, tc.status)
            }
            if tc.status == http.StatusOK {
                if got := response.Header().Get("Content-Type"); got != "application/json" {
                    t.Fatalf("Content-Type = %q; want application/json", got)
                }
                var body Greeting
                if err := json.Unmarshal(response.Body.Bytes(), &body); err != nil { t.Fatal(err) }
                if body.Message != tc.message {
                    t.Fatalf("message = %q; want %q", body.Message, tc.message)
                }
            }
        })
    }
}

Revisar este límite

El máximo del nombre se mide en bytes y es una regla educativa explícita. El ejemplo no incluye persistencia, autenticación ni trabajo de fondo. Añádelos con requisitos y pruebas definidos. Si después compartes un map entre handlers, aplica las reglas de propiedad y mutex.

Practicar con otra entrada

Añade pruebas con solo espacios y nombre que supere el máximo de bytes. Añade después una prueba HTTP independiente de la regla de método de ServeMux: llamar directamente a hello omite esa selección.

Referencias y lecturas adicionales

¿Necesitas apoyo con tu backend Go?

Colaboro con equipos de ingeniería en proyectos concretos de Go y plataformas Kubernetes, con disponibilidad limitada.

Ver servicios de consultoría Go