breakpilot-compliance/ai-compliance-sdk/internal/maximizer/scoring_test.go

package maximizer

import "testing"

func TestSafetyScoreAllSafe(t *testing.T) {
	zm := make(map[string]ZoneInfo)
	for _, dim := range allDimensions {
		zm[dim] = ZoneInfo{Zone: ZoneSafe}
	}
	eval := &EvaluationResult{ZoneMap: zm}
	score := ComputeSafetyScore(eval)
	if score != 100 {
		t.Errorf("expected 100, got %d", score)
	}
}

func TestSafetyScoreWithRestrictions(t *testing.T) {
	zm := make(map[string]ZoneInfo)
	for _, dim := range allDimensions {
		zm[dim] = ZoneInfo{Zone: ZoneSafe}
	}
	// Mark 3 as restricted
	zm["automation_level"] = ZoneInfo{Zone: ZoneRestricted}
	zm["human_in_loop"] = ZoneInfo{Zone: ZoneRestricted}
	zm["logging_required"] = ZoneInfo{Zone: ZoneForbidden}

	eval := &EvaluationResult{ZoneMap: zm}
	score := ComputeSafetyScore(eval)

	safe := len(allDimensions) - 3
	expected := (safe * 100) / len(allDimensions)
	if score != expected {
		t.Errorf("expected %d, got %d", expected, score)
	}
}

func TestSafetyScoreNil(t *testing.T) {
	if s := ComputeSafetyScore(nil); s != 0 {
		t.Errorf("expected 0 for nil, got %d", s)
	}
}

func TestUtilityScoreNoChanges(t *testing.T) {
	config := &DimensionConfig{AutomationLevel: AutoFull}
	score := ComputeUtilityScore(config, config)
	if score != 100 {
		t.Errorf("expected 100 for identical configs, got %d", score)
	}
}

func TestUtilityScoreWithChanges(t *testing.T) {
	original := &DimensionConfig{
		AutomationLevel: AutoFull,
		HumanInLoop:     HILNone,
	}
	variant := &DimensionConfig{
		AutomationLevel: AutoAssistive,
		HumanInLoop:     HILRequired,
	}
	score := ComputeUtilityScore(original, variant)
	if score >= 100 {
		t.Errorf("expected < 100 with changes, got %d", score)
	}
	if score <= 0 {
		t.Errorf("expected > 0 for moderate changes, got %d", score)
	}
}

func TestUtilityScoreNil(t *testing.T) {
	if s := ComputeUtilityScore(nil, nil); s != 0 {
		t.Errorf("expected 0 for nil, got %d", s)
	}
}

func TestCompositeScore(t *testing.T) {
	score := ComputeCompositeScore(80, 60, DefaultWeights)
	expected := 0.4*80.0 + 0.6*60.0 // 32 + 36 = 68
	if score != expected {
		t.Errorf("expected %.1f, got %.1f", expected, score)
	}
}

func TestCompositeScoreCustomWeights(t *testing.T) {
	score := ComputeCompositeScore(100, 0, ScoreWeights{Safety: 1.0, Utility: 0.0})
	if score != 100.0 {
		t.Errorf("expected 100, got %.1f", score)
	}
}