404 页面诚实地作答

package main

import (
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
	"runtime"
	"strconv"
	"strings"
	"sync/atomic"
	"time"
)

func must(err error) {
	if err != nil {
		panic(err)
	}
}

func check(ok bool, message string) {
	if !ok {
		panic(message)
	}
}

func main() {
	const missing = `<!doctype html><title>Not found</title><h1>Page not found</h1><a href="/">Home</a>`
	var restored atomic.Bool
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		status, body, media := 404, missing, "text/html; charset=utf-8"
		switch r.URL.Path {
		case "/":
			status, body = 200, "<!doctype html><title>Home</title><h1>Home</h1>"
		case "/gone":
			status = 410
		case "/moved":
			status = 308
			w.Header().Set("Location", "/")
		case "/offline":
			status, body = 503, "Service temporarily unavailable"
		case "/soft-miss":
			status = 200 // Deliberate bug: the body alone cannot identify success.
		case "/restored":
			if restored.Load() {
				status, body = 200, "Restored resource"
			}
		default:
			if strings.HasPrefix(r.URL.Path, "/api/") {
				media, body = "application/json", `{"error":"not_found"}`
			}
		}
		if r.Method != "GET" && r.Method != "HEAD" {
			status, body = 405, "Method not allowed"
			w.Header().Set("Allow", "GET, HEAD")
			if media == "application/json" {
				body = `{"error":"method_not_allowed"}`
			}
		}
		w.Header().Set("Content-Type", media)
		w.Header().Set("Cache-Control", "no-store")
		w.Header().Set("Content-Length", strconv.Itoa(len(body)))
		w.WriteHeader(status) // Status must be committed before writing the body.
		if r.Method != "HEAD" {
			_, err := io.WriteString(w, body)
			must(err)
		}
	}))
	defer server.Close()
	transport := &http.Transport{}
	defer transport.CloseIdleConnections()
	client := &http.Client{Transport: transport, Timeout: 2 * time.Second,
		CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse },
	}
	probe := func(method, route string, status int, media string) (*http.Response, string) {
		request, err := http.NewRequest(method, server.URL+route, nil)
		must(err)
		response, err := client.Do(request)
		must(err)
		body, readError := io.ReadAll(response.Body)
		closeError := response.Body.Close()
		must(readError)
		must(closeError)
		check(response.StatusCode == status && response.Proto == "HTTP/1.1", "wrong status or protocol")
		check(response.Header.Get("Content-Type") == media, "wrong media type")
		check(response.Header.Get("Cache-Control") == "no-store", "fixture must not reuse negative responses")
		check(!strings.Contains(string(body), "do-not-echo"), "request query leaked into error page")
		fmt.Printf("%s %s: %d, body=%d bytes\n", method, request.URL.Path, status, len(body))
		return response, string(body)
	}
	const html = "text/html; charset=utf-8"
	probe("GET", "/", 200, html)
	get, body := probe("GET", "/missing?hint=do-not-echo", 404, html)
	check(body == missing && strings.Contains(body, `href="/"`), "missing page must offer a real home link")
	head, empty := probe("HEAD", "/missing", 404, html)
	check(empty == "" && head.ContentLength == get.ContentLength, "HEAD must preserve status and length without a body")
	probe("GET", "/assets/missing.css", 404, html)
	_, api := probe("GET", "/api/missing", 404, "application/json")
	check(api == `{"error":"not_found"}`, "API must not receive an HTML success page")
	probe("GET", "/gone", 410, html)
	move, _ := probe("GET", "/moved", 308, html)
	check(move.Header.Get("Location") == "/", "known move must name its target")
	probe("GET", "/offline", 503, html)
	soft, softBody := probe("GET", "/soft-miss", 200, html)
	check(softBody == missing && soft.StatusCode != get.StatusCode, "negative control must expose a soft 404")
	probe("GET", "/restored", 404, html)
	restored.Store(true)
	_, recovered := probe("GET", "/restored", 200, html)
	check(recovered == "Restored resource", "restored resource must no longer return 404")
	rejected, _ := probe("POST", "/missing", 405, html)
	check(rejected.Header.Get("Allow") == "GET, HEAD", "method rejection must describe allowed methods")
	apiRejected, apiError := probe("POST", "/api/missing", 405, "application/json")
	check(apiRejected.Header.Get("Allow") == "GET, HEAD" && apiError == `{"error":"method_not_allowed"}`, "API method errors must retain JSON")
	fmt.Println("PASS: thirteen requests; missing, moved, unavailable, and restored remain distinct")
	fmt.Println(runtime.Version())
}