refactor: validator

Author: sysulq

internal/callgraph/graph.go

@@ -7,10 +7,12 @@ import (
 	"sort"
 )
 
+// MakeEdgeString returns a string that represents an edge in the call graph.
 func MakeEdgeString(src, dst string) string {
 	return fmt.Sprintf("⟦%s:KoDeDgE:%s→%s⟧", checksumEdge(src, dst), src, dst)
 }
 
+// ParseEdges returns a list of edges from the given data.
 func ParseEdges(data []byte) [][2]string {
 	var result [][2]string
 	re := regexp.MustCompile(`⟦([0-9a-fA-F]+):KoDeDgE:([a-zA-Z0-9\-.~_/]*?)→([a-zA-Z0-9\-.~_/]*?)⟧`)
@@ -33,8 +35,9 @@ func ParseEdges(data []byte) [][2]string {
 	return result
 }
 
+// checksumEdge returns a checksum for the given edge.
 func checksumEdge(src, dst string) string {
 	edge := fmt.Sprintf("KoDeDgE:%s→%s", src, dst)
-	sum := sha256.Sum256([]byte(edge))
-	return fmt.Sprintf("%0x", sum)[:8]
+	sum := fmt.Sprintf("%0x", sha256.Sum256([]byte(edge)))[:8]
+	return sum
 }

kod.go

@@ -297,11 +297,11 @@ func newKod(opts options) (*Kod, error) {
 		return nil, err
 	}
 
-	if err := registry.ValidateRegistrations(kod.regs); err != nil {
+	if err := validateRegistrations(kod.regs); err != nil {
 		return nil, err
 	}
 
-	if err := registry.CheckCircularDependency(kod.regs); err != nil {
+	if err := checkCircularDependency(kod.regs); err != nil {
 		return nil, err
 	}
 

internal/registry/validate.go validate.go

@@ -1,4 +1,4 @@
-package registry
+package kod
 
 import (
 	"errors"
@@ -10,9 +10,9 @@ import (
 	"github.com/go-kod/kod/internal/reflects"
 )
 
-// CheckCircularDependency checks that there are no circular dependencies
+// checkCircularDependency checks that there are no circular dependencies
 // between registered components.
-func CheckCircularDependency(reg []*Registration) error {
+func checkCircularDependency(reg []*Registration) error {
 	g := graph.New(graph.StringHash, graph.Directed(), graph.PreventCycles())
 
 	for _, reg := range reg {
@@ -39,19 +39,19 @@ func CheckCircularDependency(reg []*Registration) error {
 	return errors.Join(errs...)
 }
 
-// ValidateRegistrations checks that all registered component interfaces are
+// validateRegistrations checks that all registered component interfaces are
 // implemented by a registered component implementation struct.
-func ValidateRegistrations(reg []*Registration) error {
+func validateRegistrations(regs []*Registration) error {
 	// Gather the set of registered interfaces.
 	intfs := map[reflect.Type]struct{}{}
-	for _, reg := range reg {
+	for _, reg := range regs {
 		intfs[reg.Iface] = struct{}{}
 	}
 
 	// Check that for every kod.Ref[T] field in a component implementation
 	// struct, T is a registered interface.
 	var errs []error
-	for _, reg := range reg {
+	for _, reg := range regs {
 		for i := 0; i < reg.Impl.NumField(); i++ {
 			f := reg.Impl.Field(i)
 			switch {

validate_test.go

@@ -0,0 +1,94 @@
+package kod
+
+import (
+	"io"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/go-kod/kod/internal/reflects"
+	"github.com/go-kod/kod/internal/registry"
+)
+
+func TestValidateUnregisteredRef(t *testing.T) {
+	type foo interface{}
+	type fooImpl struct{ Ref[io.Reader] }
+	regs := []*registry.Registration{
+		{
+			Name:  "foo",
+			Iface: reflects.TypeFor[foo](),
+			Impl:  reflects.TypeFor[fooImpl](),
+		},
+	}
+	err := validateRegistrations(regs)
+	if err == nil {
+		t.Fatal("unexpected validateRegistrations success")
+	}
+	const want = "component io.Reader was not registered"
+	if !strings.Contains(err.Error(), want) {
+		t.Fatalf("validateRegistrations: got %q, want %q", err, want)
+	}
+}
+
+// TestValidateNoRegistrations tests that validateRegistrations succeeds on an
+// empty set of registrations.
+func TestValidateNoRegistrations(t *testing.T) {
+	if err := validateRegistrations(nil); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestMultipleRegistrations(t *testing.T) {
+	type foo interface{}
+	type fooImpl struct{ Ref[io.Reader] }
+	regs := []*Registration{
+		{
+			Name:  "github.com/go-kod/kod/Main",
+			Iface: reflect.TypeOf((*Main)(nil)).Elem(),
+			Impl:  reflect.TypeOf(fooImpl{}),
+			Refs:  `⟦48699770:KoDeDgE:github.com/go-kod/kod/Main→github.com/go-kod/kod/tests/graphcase/test1Controller⟧`,
+		},
+		{
+			Name:  "github.com/go-kod/kod/Main",
+			Iface: reflect.TypeOf((*foo)(nil)).Elem(),
+			Impl:  reflect.TypeOf(fooImpl{}),
+			Refs:  `⟦48699770:KoDeDgE:github.com/go-kod/kod/tests/graphcase/test1Controller→github.com/go-kod/kod/Main⟧`,
+		},
+	}
+	err := checkCircularDependency(regs)
+	if err == nil {
+		t.Fatal("unexpected checkCircularDependency success")
+	}
+	const want = "components [github.com/go-kod/kod/Main], error vertex already exists"
+	if !strings.Contains(err.Error(), want) {
+		t.Fatalf("checkCircularDependency: got %q, want %q", err, want)
+	}
+}
+
+func TestCycleRegistrations(t *testing.T) {
+	type test1Controller interface{}
+	type test1ControllerImpl struct{ Ref[io.Reader] }
+	type mainImpl struct{ Ref[test1Controller] }
+	regs := []*Registration{
+		{
+			Name:  "github.com/go-kod/kod/Main",
+			Iface: reflect.TypeOf((*Main)(nil)).Elem(),
+			Impl:  reflect.TypeOf(mainImpl{}),
+			Refs:  `⟦48699770:KoDeDgE:github.com/go-kod/kod/Main→github.com/go-kod/kod/test1Controller⟧`,
+		},
+		{
+			Name:  "github.com/go-kod/kod/test1Controller",
+			Iface: reflect.TypeOf((*test1Controller)(nil)).Elem(),
+			Impl:  reflect.TypeOf(test1ControllerImpl{}),
+			Refs:  `⟦b8422d0e:KoDeDgE:github.com/go-kod/kod/test1Controller→github.com/go-kod/kod/Main⟧`,
+		},
+	}
+	err := checkCircularDependency(regs)
+	if err == nil {
+		t.Fatal("unexpected checkCircularDependency success")
+	}
+	const want = "components [github.com/go-kod/kod/test1Controller] and [github.com/go-kod/kod/Main] have cycle Ref"
+	if !strings.Contains(err.Error(), want) {
+		t.Fatalf("checkCircularDependency: got %q, want %q", err, want)
+	}
+}