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.
Lección 50 de 50
Ver toda la serie Fundamentos de GoReferencias 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