package chaos

import "testing"

// TestThreeOfFourIsNotEnough ist der Kerntest des Modells.
//
// Ein Fehler, der gemeldet und klassifiziert wird und trotzdem ein scheinbar
// gueltiges Backup hinterlaesst, ist der gefaehrlichste von allen: Er faellt
// erst an dem Tag auf, an dem jemand wiederherstellen will.
func TestThreeOfFourIsNotEnough(testInstance *testing.T) {
	almostControlled := &Outcome{
		Disruption:              DisruptionDiskFull,
		ErrorReported:           true,
		FailureClass:            "configuration",
		VisibleBackupLeftBehind: true,
		StateConsistent:         true,
	}

	if almostControlled.IsControlled() {
		testInstance.Error("ein zurückgebliebenes sichtbares Backup gilt als kontrolliert")
	}

	if verdict := almostControlled.Verdict(); verdict == "kontrolliert" {
		testInstance.Errorf("das Urteil lautet %q", verdict)
	}
}

// TestUnclassifiedFailureIsNotControlled prueft die zweite Bedingung.
//
// Ohne Klasse kann die Ausfuehrungsschleife nicht entscheiden, ob eine
// Wiederholung sinnvoll ist — und wiederholt dann entweder alles oder nichts.
func TestUnclassifiedFailureIsNotControlled(testInstance *testing.T) {
	unclassified := &Outcome{
		ErrorReported:   true,
		StateConsistent: true,
	}

	if unclassified.IsControlled() {
		testInstance.Error("ein unklassifizierter Fehler gilt als kontrolliert")
	}
}

// TestSilentFailureIsTheWorstCase prueft die erste Bedingung.
func TestSilentFailureIsTheWorstCase(testInstance *testing.T) {
	silent := &Outcome{
		FailureClass:    "transient",
		StateConsistent: true,
	}

	if silent.IsControlled() {
		testInstance.Error("ein verschluckter Fehler gilt als kontrolliert")
	}
}

// TestFullyControlledOutcome prueft die Gegenprobe.
func TestFullyControlledOutcome(testInstance *testing.T) {
	controlled := &Outcome{
		Disruption:      DisruptionDiskFull,
		ErrorReported:   true,
		FailureClass:    "configuration",
		StateConsistent: true,
	}

	if !controlled.IsControlled() {
		testInstance.Errorf("ein vollständiges Ergebnis gilt als unkontrolliert: %s",
			controlled.Verdict())
	}
}

// TestReportNamesUntestedDisruptions prueft die Vollstaendigkeit.
//
// Ein Chaosbericht, der verschweigt, was er nicht ausgeloest hat, liest sich
// vollstaendig und ist es nicht.
func TestReportNamesUntestedDisruptions(testInstance *testing.T) {
	chaosReport := &Report{}
	chaosReport.AddUntested(DisruptionNetworkLoss, "Kein entferntes Repository verfügbar.")

	if len(chaosReport.UntestedDisruptions) != 1 {
		testInstance.Error("die nicht ausgelöste Störung fehlt im Bericht")
	}

	chaosReport.Outcomes = append(chaosReport.Outcomes, &Outcome{ErrorReported: false})

	if chaosReport.UncontrolledCount() != 1 {
		testInstance.Error("das unkontrollierte Ergebnis wird nicht gezählt")
	}
}