tests: add coverage for options, types, and HTTP server

- options_test.go: GetOption, GetFloatOption, GetIntOption, GetBoolOption
  with native types, JSON round-trips, missing keys, and wrong types
- types_test.go: Status JSON marshal/unmarshal (strings, legacy ints,
  round-trip, unknown values), CheckTarget.Scope/String, BuildRulesInfo,
  empty-ID rejection
- server_test.go: /health, /collect (success, error, bad body),
  /definition, /evaluate (all rules, disabled rule), /report (HTML,
  metrics, bad body), missing endpoints without CheckerDefinitionProvider

checker/options_test.go

@@ -0,0 +1,127 @@
+// Copyright 2020-2026 The happyDomain Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package checker
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestGetOption_DirectType(t *testing.T) {
+	opts := CheckerOptions{"key": "hello"}
+	got, ok := GetOption[string](opts, "key")
+	if !ok || got != "hello" {
+		t.Errorf("GetOption[string] = (%q, %v), want (\"hello\", true)", got, ok)
+	}
+}
+
+func TestGetOption_MissingKey(t *testing.T) {
+	opts := CheckerOptions{}
+	got, ok := GetOption[string](opts, "missing")
+	if ok || got != "" {
+		t.Errorf("GetOption[string] missing key = (%q, %v), want (\"\", false)", got, ok)
+	}
+}
+
+func TestGetOption_JSONRoundTrip(t *testing.T) {
+	// Simulate what happens when options come from JSON: numbers become float64,
+	// structs become map[string]any.
+	type inner struct {
+		X int    `json:"x"`
+		Y string `json:"y"`
+	}
+	opts := CheckerOptions{
+		"obj": map[string]any{"x": float64(42), "y": "test"},
+	}
+	got, ok := GetOption[inner](opts, "obj")
+	if !ok {
+		t.Fatal("GetOption[inner] returned false")
+	}
+	if got.X != 42 || got.Y != "test" {
+		t.Errorf("GetOption[inner] = %+v, want {X:42 Y:test}", got)
+	}
+}
+
+func TestGetOption_WrongType(t *testing.T) {
+	opts := CheckerOptions{"key": 123}
+	got, ok := GetOption[string](opts, "key")
+	// int 123 cannot be unmarshaled into string via JSON
+	if ok {
+		t.Errorf("GetOption[string] with int value = (%q, true), want (\"\", false)", got)
+	}
+}
+
+func TestGetFloatOption_NativeFloat(t *testing.T) {
+	opts := CheckerOptions{"f": 3.14}
+	if got := GetFloatOption(opts, "f", 0); got != 3.14 {
+		t.Errorf("GetFloatOption = %v, want 3.14", got)
+	}
+}
+
+func TestGetFloatOption_JSONNumber(t *testing.T) {
+	opts := CheckerOptions{"f": json.Number("2.718")}
+	if got := GetFloatOption(opts, "f", 0); got != 2.718 {
+		t.Errorf("GetFloatOption(json.Number) = %v, want 2.718", got)
+	}
+}
+
+func TestGetFloatOption_Missing(t *testing.T) {
+	opts := CheckerOptions{}
+	if got := GetFloatOption(opts, "f", 99.9); got != 99.9 {
+		t.Errorf("GetFloatOption missing = %v, want 99.9", got)
+	}
+}
+
+func TestGetFloatOption_WrongType(t *testing.T) {
+	opts := CheckerOptions{"f": "not a number"}
+	if got := GetFloatOption(opts, "f", 1.0); got != 1.0 {
+		t.Errorf("GetFloatOption wrong type = %v, want 1.0", got)
+	}
+}
+
+func TestGetIntOption(t *testing.T) {
+	opts := CheckerOptions{"i": float64(42)}
+	if got := GetIntOption(opts, "i", 0); got != 42 {
+		t.Errorf("GetIntOption = %v, want 42", got)
+	}
+}
+
+func TestGetIntOption_Missing(t *testing.T) {
+	opts := CheckerOptions{}
+	if got := GetIntOption(opts, "i", 10); got != 10 {
+		t.Errorf("GetIntOption missing = %v, want 10", got)
+	}
+}
+
+func TestGetBoolOption(t *testing.T) {
+	opts := CheckerOptions{"b": true}
+	if got := GetBoolOption(opts, "b", false); got != true {
+		t.Errorf("GetBoolOption = %v, want true", got)
+	}
+}
+
+func TestGetBoolOption_Missing(t *testing.T) {
+	opts := CheckerOptions{}
+	if got := GetBoolOption(opts, "b", true); got != true {
+		t.Errorf("GetBoolOption missing = %v, want true", got)
+	}
+}
+
+func TestGetBoolOption_WrongType(t *testing.T) {
+	opts := CheckerOptions{"b": "yes"}
+	if got := GetBoolOption(opts, "b", false); got != false {
+		t.Errorf("GetBoolOption wrong type = %v, want false", got)
+	}
+}