HTTP 方法在描述意图

package main

import (
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"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 allowed = "GET, HEAD, PUT, DELETE, OPTIONS"
	var mu sync.Mutex
	value, exists := "seed", true
	var handled, writeCalls atomic.Int64
	server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		handled.Add(1)
		defer r.Body.Close()
		if r.URL.Path != "/item" {
			http.NotFound(w, r)
			return
		}
		switch r.Method {
		case http.MethodGet, http.MethodHead:
			mu.Lock()
			body, found := value, exists
			mu.Unlock()
			if !found {
				http.NotFound(w, r)
				return
			}
			w.Header().Set("Content-Type", "text/plain; charset=utf-8")
			w.Header().Set("Content-Length", strconv.Itoa(len(body)))
			if r.Method == http.MethodGet {
				fmt.Fprint(w, body)
			}
		case http.MethodPut:
			body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, 64))
			if err != nil {
				status := http.StatusBadRequest
				var oversized *http.MaxBytesError
				if errors.As(err, &oversized) {
					status = http.StatusRequestEntityTooLarge
				}
				http.Error(w, "body rejected", status)
				return
			}
			mu.Lock()
			created := !exists
			value, exists = string(body), true
			writeCalls.Add(1)
			mu.Unlock()
			if created {
				w.WriteHeader(http.StatusCreated)
			} else {
				w.WriteHeader(http.StatusNoContent)
			}
		case http.MethodDelete:
			mu.Lock()
			found := exists
			value, exists = "", false
			writeCalls.Add(1)
			mu.Unlock()
			if found {
				w.WriteHeader(http.StatusNoContent)
			} else {
				http.NotFound(w, r)
			}
		case http.MethodOptions:
			w.Header().Set("Allow", allowed)
			w.WriteHeader(http.StatusNoContent)
		case http.MethodPost, http.MethodPatch, http.MethodTrace, http.MethodConnect:
			w.Header().Set("Allow", allowed)
			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
		default:
			http.Error(w, "unknown method", http.StatusNotImplemented)
		}
	}))
	server.Config.ReadHeaderTimeout = time.Second
	server.Config.ReadTimeout = 2 * time.Second
	server.Start()
	defer server.Close()
	transport := &http.Transport{}
	defer transport.CloseIdleConnections()
	client := &http.Client{Transport: transport, Timeout: 3 * time.Second}
	probe := func(method, payload string, status int, expected string) {
		request, err := http.NewRequest(method, server.URL+"/item", strings.NewReader(payload))
		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.Proto == "HTTP/1.1" && response.StatusCode == status, method+": wrong status/protocol")
		check(string(body) == expected, method+": wrong response body")
		if method == http.MethodHead {
			check(response.ContentLength == 4 && len(body) == 0, "HEAD must report the GET length without its body")
		}
		if method == http.MethodOptions || status == 405 {
			check(response.Header.Get("Allow") == allowed, "Allow must describe the target methods")
		}
		fmt.Printf("%s: status=%d body=%q\n", method, status, body)
	}
	probe("GET", "", 200, "seed")
	probe("GET", "", 200, "seed")
	probe("HEAD", "", 200, "")
	check(writeCalls.Load() == 0, "safe requests must not call the write operation")
	probe("PUT", "new", 204, "")
	probe("PUT", "new", 204, "")
	probe("GET", "", 200, "new")
	check(writeCalls.Load() == 2, "both repeated PUT requests must reach the server")
	probe("PUT", strings.Repeat("x", 65), 413, "body rejected\n")
	probe("GET", "", 200, "new")
	check(writeCalls.Load() == 2, "rejected PUT must leave state unchanged")
	probe("DELETE", "", 204, "")
	probe("DELETE", "", 404, "404 page not found\n")
	probe("GET", "", 404, "404 page not found\n")
	probe("OPTIONS", "", 204, "")
	probe("POST", "", 405, "method not allowed\n")
	probe("FROB", "", 501, "unknown method\n")
	check(writeCalls.Load() == 4, "method discovery and rejection must not write")
	probe("PUT", "ready", 201, "")
	probe("GET", "", 200, "ready")
	check(handled.Load() == 16 && writeCalls.Load() == 5, "wrong final request counts")
	fmt.Println("sixteen requests; five PUT/DELETE handler calls; final state ready")
	fmt.Println(runtime.Version())
}