promoted_method_test.go

package structpages

import (
	"context"
	"io"
	"net/http"
	"reflect"
	"testing"
)

// These tests pin the behavior isPromotedMethod relies on and the invariant
// the call sites depend on. Note the caveat (golang/go#73883): a value-receiver
// method looked up through the *pointer* type also gets an autogenerated
// wrapper, so isPromotedMethod reports it as promoted. That is safe only
// because every call site scans both the value type and the pointer type —
// a non-promoted method always shows its real source location on at least
// one of the two.

type promotedEmbedded struct{}

func (promotedEmbedded) EmbeddedComp() component {
	return fnComponent(func(context.Context, io.Writer) error { return nil })
}

type promotedEmbeddedPtr struct{}

func (*promotedEmbeddedPtr) EmbeddedPtrComp() component {
	return fnComponent(func(context.Context, io.Writer) error { return nil })
}

type promotedHost struct {
	promotedEmbedded
	*promotedEmbeddedPtr
}

func (promotedHost) ValueComp() component {
	return fnComponent(func(context.Context, io.Writer) error { return nil })
}

func (*promotedHost) PtrComp() component {
	return fnComponent(func(context.Context, io.Writer) error { return nil })
}

func TestIsPromotedMethod(t *testing.T) {
	st := reflect.TypeFor[promotedHost]()
	pt := reflect.TypeFor[*promotedHost]()

	get := func(t *testing.T, typ reflect.Type, name string) reflect.Method {
		t.Helper()
		m, ok := typ.MethodByName(name)
		if !ok {
			t.Fatalf("method %s not found on %s", name, typ)
		}
		return m
	}

	// Own methods report their real location on the type they're defined for.
	if m := get(t, st, "ValueComp"); isPromotedMethod(&m) {
		t.Error("value-receiver method on value type reported as promoted")
	}
	if m := get(t, pt, "PtrComp"); isPromotedMethod(&m) {
		t.Error("pointer-receiver method on pointer type reported as promoted")
	}

	// Genuinely promoted methods are autogenerated on both types.
	for _, typ := range []reflect.Type{st, pt} {
		if m, ok := typ.MethodByName("EmbeddedComp"); ok && !isPromotedMethod(&m) {
			t.Errorf("promoted EmbeddedComp on %s not detected as promoted", typ)
		}
	}
	if m := get(t, pt, "EmbeddedPtrComp"); !isPromotedMethod(&m) {
		t.Error("promoted pointer-receiver method not detected as promoted")
	}

	// The caveat itself: a value-receiver method seen through the pointer type
	// has an autogenerated wrapper, so it reads as "promoted". If this ever
	// changes, the two-type scan below becomes redundant (not broken).
	if m := get(t, pt, "ValueComp"); !isPromotedMethod(&m) {
		t.Log("note: value-receiver method via pointer type no longer autogenerated")
	}

	// The invariant all call sites rely on: every non-promoted method shows a
	// real location on at least one of {value type, pointer type}.
	for _, name := range []string{"ValueComp", "PtrComp"} {
		found := false
		for _, typ := range []reflect.Type{st, pt} {
			if m, ok := typ.MethodByName(name); ok && !isPromotedMethod(&m) {
				found = true
			}
		}
		if !found {
			t.Errorf("own method %s reads as promoted on both value and pointer type", name)
		}
	}
}

// TestProcessMethodsSkipsPromoted verifies the parse-level outcome: own
// component methods (value or pointer receiver) are registered, promoted ones
// are not.
func TestProcessMethodsSkipsPromoted(t *testing.T) {
	type root struct {
		p *promotedHost `route:"/host Host"`
	}
	pc, err := parsePageTree("/", &root{})
	if err != nil {
		t.Fatalf("parsePageTree failed: %v", err)
	}
	node := pc.root.Children[0]
	for _, want := range []string{"ValueComp", "PtrComp"} {
		if _, ok := node.Components[want]; !ok {
			t.Errorf("own method %s missing from Components", want)
		}
	}
	for _, skip := range []string{"EmbeddedComp", "EmbeddedPtrComp"} {
		if _, ok := node.Components[skip]; ok {
			t.Errorf("promoted method %s registered in Components", skip)
		}
	}
}

type valueServeHTTPPage struct{}

func (valueServeHTTPPage) ServeHTTP(http.ResponseWriter, *http.Request) {}

type embeddedHandler struct{}

func (embeddedHandler) ServeHTTP(http.ResponseWriter, *http.Request) {}

type promotedServeHTTPPage struct {
	embeddedHandler
}

func TestHasServeHTTPWithReceiverVariants(t *testing.T) {
	mk := func(v any) *PageNode { return &PageNode{Value: reflect.ValueOf(v)} }

	// Value-receiver ServeHTTP must be detected even though its pointer-type
	// wrapper reads as promoted (the caveat).
	for _, v := range []any{valueServeHTTPPage{}, &valueServeHTTPPage{}} {
		if !mk(v).hasServeHTTP() {
			t.Errorf("hasServeHTTP() = false for %T with value-receiver ServeHTTP", v)
		}
	}
	// Promoted ServeHTTP must not count.
	for _, v := range []any{promotedServeHTTPPage{}, &promotedServeHTTPPage{}} {
		if mk(v).hasServeHTTP() {
			t.Errorf("hasServeHTTP() = true for %T with only promoted ServeHTTP", v)
		}
	}
}