test: Improve pkg/types test coverage from 78.1% to 80.3%

Add comprehensive tests for core types package:
- Add ExporterReloadSummary tests (exporter_test.go):
  - TestExporterReloadSummary_AddResult with success/failure scenarios
  - TestExporterReloadResult_Fields for field validation
  - TestExporterReloadSummary_InitialState and order preservation tests

- Add edge case validation tests (types_test.go):
  - TestProblemWithMetadata_NilMetadataMap for nil metadata handling
  - TestConditionValidation_EdgeCases for missing reason/message/transition
  - TestStatusValidation_EdgeCases for missing timestamp/invalid condition
  - TestProblemValidation_EdgeCases for missing severity/message/detected time
  - TestGetMetadata_NilMetadataMap for nil metadata retrieval

Coverage: 78.1% -> 80.3% (exceeds 80% target)
All tests pass with race detection.

Author: mattmattox

pkg/types/exporter_test.go

@@ -0,0 +1,151 @@
+package types
+
+import (
+	"errors"
+	"testing"
+)
+
+// TestExporterReloadSummary_AddResult verifies AddResult method functionality.
+func TestExporterReloadSummary_AddResult(t *testing.T) {
+	tests := []struct {
+		name                      string
+		results                   []ExporterReloadResult
+		expectedTotal             int
+		expectedSuccessful        int
+		expectedFailed            int
+		expectedReloadableCount   int
+	}{
+		{
+			name:                    "empty summary",
+			results:                 []ExporterReloadResult{},
+			expectedTotal:           0,
+			expectedSuccessful:      0,
+			expectedFailed:          0,
+			expectedReloadableCount: 0,
+		},
+		{
+			name: "single successful reload",
+			results: []ExporterReloadResult{
+				{ExporterType: "prometheus", Success: true, Message: "reloaded successfully"},
+			},
+			expectedTotal:           1,
+			expectedSuccessful:      1,
+			expectedFailed:          0,
+			expectedReloadableCount: 0,
+		},
+		{
+			name: "single failed reload",
+			results: []ExporterReloadResult{
+				{ExporterType: "kubernetes", Success: false, Error: errors.New("config invalid"), Message: "reload failed"},
+			},
+			expectedTotal:           1,
+			expectedSuccessful:      0,
+			expectedFailed:          1,
+			expectedReloadableCount: 0,
+		},
+		{
+			name: "mixed results",
+			results: []ExporterReloadResult{
+				{ExporterType: "prometheus", Success: true, Message: "reloaded successfully"},
+				{ExporterType: "kubernetes", Success: false, Error: errors.New("config invalid")},
+				{ExporterType: "http", Success: true, Message: "reloaded successfully"},
+				{ExporterType: "logs", Success: false, Error: errors.New("not reloadable")},
+			},
+			expectedTotal:           4,
+			expectedSuccessful:      2,
+			expectedFailed:          2,
+			expectedReloadableCount: 0,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			summary := &ExporterReloadSummary{
+				ReloadableCount: tt.expectedReloadableCount,
+			}
+
+			for _, result := range tt.results {
+				summary.AddResult(result)
+			}
+
+			if summary.TotalExporters != tt.expectedTotal {
+				t.Errorf("TotalExporters = %d, want %d", summary.TotalExporters, tt.expectedTotal)
+			}
+			if summary.SuccessfulReloads != tt.expectedSuccessful {
+				t.Errorf("SuccessfulReloads = %d, want %d", summary.SuccessfulReloads, tt.expectedSuccessful)
+			}
+			if summary.FailedReloads != tt.expectedFailed {
+				t.Errorf("FailedReloads = %d, want %d", summary.FailedReloads, tt.expectedFailed)
+			}
+			if len(summary.Results) != len(tt.results) {
+				t.Errorf("Results count = %d, want %d", len(summary.Results), len(tt.results))
+			}
+		})
+	}
+}
+
+// TestExporterReloadResult_Fields verifies ExporterReloadResult field assignments.
+func TestExporterReloadResult_Fields(t *testing.T) {
+	err := errors.New("test error")
+	result := ExporterReloadResult{
+		ExporterType: "prometheus",
+		Success:      false,
+		Error:        err,
+		Message:      "config validation failed",
+	}
+
+	if result.ExporterType != "prometheus" {
+		t.Errorf("ExporterType = %s, want prometheus", result.ExporterType)
+	}
+	if result.Success {
+		t.Error("Success should be false")
+	}
+	if result.Error != err {
+		t.Errorf("Error = %v, want %v", result.Error, err)
+	}
+	if result.Message != "config validation failed" {
+		t.Errorf("Message = %s, want 'config validation failed'", result.Message)
+	}
+}
+
+// TestExporterReloadSummary_InitialState verifies initial state of ExporterReloadSummary.
+func TestExporterReloadSummary_InitialState(t *testing.T) {
+	summary := ExporterReloadSummary{}
+
+	if summary.TotalExporters != 0 {
+		t.Errorf("TotalExporters = %d, want 0", summary.TotalExporters)
+	}
+	if summary.ReloadableCount != 0 {
+		t.Errorf("ReloadableCount = %d, want 0", summary.ReloadableCount)
+	}
+	if summary.SuccessfulReloads != 0 {
+		t.Errorf("SuccessfulReloads = %d, want 0", summary.SuccessfulReloads)
+	}
+	if summary.FailedReloads != 0 {
+		t.Errorf("FailedReloads = %d, want 0", summary.FailedReloads)
+	}
+	if summary.Results != nil && len(summary.Results) != 0 {
+		t.Errorf("Results should be nil or empty, got %d items", len(summary.Results))
+	}
+}
+
+// TestExporterReloadSummary_ResultsPreserveOrder verifies results maintain insertion order.
+func TestExporterReloadSummary_ResultsPreserveOrder(t *testing.T) {
+	summary := &ExporterReloadSummary{}
+
+	results := []ExporterReloadResult{
+		{ExporterType: "first"},
+		{ExporterType: "second"},
+		{ExporterType: "third"},
+	}
+
+	for _, r := range results {
+		summary.AddResult(r)
+	}
+
+	for i, r := range results {
+		if summary.Results[i].ExporterType != r.ExporterType {
+			t.Errorf("Results[%d].ExporterType = %s, want %s", i, summary.Results[i].ExporterType, r.ExporterType)
+		}
+	}
+}

pkg/types/types_test.go

@@ -618,3 +618,210 @@ func TestNilPointerHandling(t *testing.T) {
 		t.Error("expected GetMetadata on nil pointer to return empty string and false")
 	}
 }
+
+// TestProblemWithMetadata_NilMetadataMap verifies WithMetadata handles nil Metadata map.
+func TestProblemWithMetadata_NilMetadataMap(t *testing.T) {
+	// Create problem manually without initializing Metadata
+	problem := &Problem{
+		Type:       "test-type",
+		Resource:   "test-resource",
+		Severity:   ProblemWarning,
+		Message:    "Test message",
+		DetectedAt: time.Now(),
+		Metadata:   nil, // Explicitly nil
+	}
+
+	// WithMetadata should initialize the map
+	problem.WithMetadata("key1", "value1")
+
+	if problem.Metadata == nil {
+		t.Error("expected Metadata to be initialized")
+	}
+	if val, ok := problem.Metadata["key1"]; !ok || val != "value1" {
+		t.Errorf("expected Metadata[key1]=value1, got %v", problem.Metadata)
+	}
+}
+
+// TestConditionValidation_EdgeCases verifies Condition validation edge cases.
+func TestConditionValidation_EdgeCases(t *testing.T) {
+	tests := []struct {
+		name      string
+		condition Condition
+		wantErr   bool
+		errSubstr string
+	}{
+		{
+			name: "missing reason",
+			condition: Condition{
+				Type:       "TestType",
+				Status:     ConditionTrue,
+				Transition: time.Now(),
+				Message:    "Test message",
+			},
+			wantErr:   true,
+			errSubstr: "reason",
+		},
+		{
+			name: "missing message",
+			condition: Condition{
+				Type:       "TestType",
+				Status:     ConditionTrue,
+				Transition: time.Now(),
+				Reason:     "TestReason",
+			},
+			wantErr:   true,
+			errSubstr: "message",
+		},
+		{
+			name: "missing transition time",
+			condition: Condition{
+				Type:    "TestType",
+				Status:  ConditionTrue,
+				Reason:  "TestReason",
+				Message: "Test message",
+			},
+			wantErr:   true,
+			errSubstr: "transition",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.condition.Validate()
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err != nil && tt.errSubstr != "" {
+				if !stringContains(err.Error(), tt.errSubstr) {
+					t.Errorf("Error message %q should contain %q", err.Error(), tt.errSubstr)
+				}
+			}
+		})
+	}
+}
+
+// TestStatusValidation_EdgeCases verifies Status validation edge cases.
+func TestStatusValidation_EdgeCases(t *testing.T) {
+	tests := []struct {
+		name      string
+		status    *Status
+		wantErr   bool
+		errSubstr string
+	}{
+		{
+			name: "missing timestamp",
+			status: &Status{
+				Source:     "test-monitor",
+				Events:     []Event{},
+				Conditions: []Condition{},
+			},
+			wantErr:   true,
+			errSubstr: "timestamp",
+		},
+		{
+			name: "invalid condition in status",
+			status: &Status{
+				Source:    "test-monitor",
+				Timestamp: time.Now(),
+				Events:    []Event{},
+				Conditions: []Condition{
+					{Type: "TestType"}, // missing required fields
+				},
+			},
+			wantErr:   true,
+			errSubstr: "condition",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.status.Validate()
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err != nil && tt.errSubstr != "" {
+				if !stringContains(err.Error(), tt.errSubstr) {
+					t.Errorf("Error message %q should contain %q", err.Error(), tt.errSubstr)
+				}
+			}
+		})
+	}
+}
+
+// TestProblemValidation_EdgeCases verifies Problem validation edge cases.
+func TestProblemValidation_EdgeCases(t *testing.T) {
+	tests := []struct {
+		name      string
+		problem   *Problem
+		wantErr   bool
+		errSubstr string
+	}{
+		{
+			name: "missing severity",
+			problem: &Problem{
+				Type:       "test-type",
+				Resource:   "test-resource",
+				Message:    "Test message",
+				DetectedAt: time.Now(),
+			},
+			wantErr:   true,
+			errSubstr: "severity",
+		},
+		{
+			name: "missing message",
+			problem: &Problem{
+				Type:       "test-type",
+				Resource:   "test-resource",
+				Severity:   ProblemWarning,
+				DetectedAt: time.Now(),
+			},
+			wantErr:   true,
+			errSubstr: "message",
+		},
+		{
+			name: "missing detected time",
+			problem: &Problem{
+				Type:     "test-type",
+				Resource: "test-resource",
+				Severity: ProblemWarning,
+				Message:  "Test message",
+			},
+			wantErr:   true,
+			errSubstr: "detected",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.problem.Validate()
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err != nil && tt.errSubstr != "" {
+				if !stringContains(err.Error(), tt.errSubstr) {
+					t.Errorf("Error message %q should contain %q", err.Error(), tt.errSubstr)
+				}
+			}
+		})
+	}
+}
+
+// TestGetMetadata_NilMetadataMap verifies GetMetadata handles nil Metadata map.
+func TestGetMetadata_NilMetadataMap(t *testing.T) {
+	problem := &Problem{
+		Type:       "test-type",
+		Resource:   "test-resource",
+		Severity:   ProblemWarning,
+		Message:    "Test message",
+		DetectedAt: time.Now(),
+		Metadata:   nil, // Explicitly nil
+	}
+
+	val, ok := problem.GetMetadata("nonexistent")
+	if ok {
+		t.Error("expected ok=false for nil Metadata map")
+	}
+	if val != "" {
+		t.Errorf("expected empty string, got %q", val)
+	}
+}