doctor

func RunWithEnv(src Source, mode string, w io.Writer) error

{
	report := CheckSource(src)
	mode = strings.ToLower(strings.TrimSpace(mode))
	if mode == "" {
		mode = "print"
	}

	switch mode {
	case "off":
		return nil
	case "json":
		return report.WriteJSON(w)
	case "fail":
		if err := report.WriteText(w); err != nil {
			return err
		}
		if failures := report.Failures(); failures > 0 {
			return fmt.Errorf("foundation doctor: %d failure(s)", failures)
		}
		return nil
	default:
		return report.WriteText(w)
	}
}

func checkRoutes(routes []Route) []Check

{
	if len(routes) == 0 {
		return []Check{{
			Severity: Fail,
			Name:     "routes",
			Message:  "no routes registered",
		}}
	}

	seen := make(map[string]bool, len(routes))
	for _, route := range routes {
		key := route.Method + " " + route.Path
		if seen[key] {
			return []Check{{
				Severity: Fail,
				Name:     "routes",
				Message:  "duplicate route " + key,
			}}
		}
		seen[key] = true
	}

	return []Check{{
		Severity: OK,
		Name:     "routes",
		Message:  fmt.Sprintf("%d route(s) registered", len(routes)),
	}}
}

func checkHealth(routes []Route) Check

{
	paths := make([]string, 0, len(routes))
	for _, route := range routes {
		if route.Method == "GET" {
			paths = append(paths, route.Path)
		}
	}
	sort.Strings(paths)

	hasLive := false
	hasReady := false
	for _, path := range paths {
		if path == "/health" || path == "/health/live" {
			hasLive = true
		}
		if path == "/health/ready" {
			hasReady = true
		}
	}

	if hasLive && hasReady {
		return Check{Severity: OK, Name: "health", Message: "liveness and readiness routes registered"}
	}
	if hasLive {
		return Check{Severity: Warn, Name: "health", Message: "liveness route registered without readiness route"}
	}
	return Check{Severity: Warn, Name: "health", Message: "no health route registered"}
}

func TestCheckSourceRoutesAndHealth(t *testing.T)

{
	report := CheckSource(Source{Routes: []Route{
		{Method: "GET", Path: "/health/live"},
		{Method: "GET", Path: "/health/ready"},
	}})

	if report.Failures() != 0 {
		t.Fatalf("Failures() = %d, want 0", report.Failures())
	}
	if report.Warnings() != 0 {
		t.Fatalf("Warnings() = %d, want 0", report.Warnings())
	}
}

func TestRunWithEnvPrintsText(t *testing.T)

{
	var buf bytes.Buffer

	err := RunWithEnv(Source{Routes: []Route{{Method: "GET", Path: "/ping"}}}, "print", &buf)
	if err != nil {
		t.Fatalf("RunWithEnv() error = %v", err)
	}
	if !strings.Contains(buf.String(), "foundation doctor") {
		t.Fatalf("output = %q", buf.String())
	}
}

func TestRunWithEnvWritesJSON(t *testing.T)

{
	var buf bytes.Buffer

	err := RunWithEnv(Source{Routes: []Route{{Method: "GET", Path: "/ping"}}}, "json", &buf)
	if err != nil {
		t.Fatalf("RunWithEnv() error = %v", err)
	}
	if !strings.Contains(buf.String(), `"checks"`) {
		t.Fatalf("output = %q", buf.String())
	}
}