except_test.go

package except

import (
	"testing"
)

// getValue is a mock function for testing
func getValue() int {
	return 50 // Not 100, will trigger assertion error
}

func TestTryGetsExecuted(t *testing.T) {
	var hasTryExecuted bool
	e := New()
	e.Try(func() {
		hasTryExecuted = true
	}).
		Catch(nil, func(excep *Exception) {}).
		Run()

	if !hasTryExecuted {
		t.Fatal("Try was not executed")
	}
}

func TestCatchGetsExecutedForAllErrorsIfExceptionThrownInTry(t *testing.T) {
	var exceptionType ExceptionType
	var hasCaughtException bool
	e := New()
	e.Try(func() {
		e.Throw(e.ReferenceError("Dummy error text"))
	}).
		Catch(nil, func(excep *Exception) {
			hasCaughtException = true
			exceptionType = excep.Type
		}).Run()

	if !hasCaughtException {
		t.Fatal("Exception was not caught")
	}
	if exceptionType != ReferenceErrorType {
		t.Fatalf("Expecting %s but found %s", ReferenceErrorType, exceptionType)
	}
}

func TestFinallyGetsExecutedAlways(t *testing.T) {
	var hasFinallyExecuted bool
	e := New()
	e.Try(func() {
		e.Throw(e.NetworkError())
	}).
		Catch(nil, func(excep *Exception) {}).
		Finally(func() {
			hasFinallyExecuted = true
		}).
		Run()

	if !hasFinallyExecuted {
		t.Fatal("Finally was not executed")
	}
}

func TestExpectedCatchBlockGetsExecutedForDefinedExceptionType(t *testing.T) {
	var thrownExceptionType ExceptionType
	var caughtFrom string
	e := New()
	e.Try(func() {
		user := map[string]string{
			"name": "John Doe",
		}
		_, ok := user["email"]
		if !ok {
			e.Throw(e.LookupError("Email doesn't exist"))
		}
	}).
		Catch(e.In(LookupErrorType), func(excep *Exception) {
			thrownExceptionType = excep.Type
			caughtFrom = "LookupErrorHandler"
		}).
		Catch(e.In(ReferenceErrorType, IndexErrorType), func(excep *Exception) {
			thrownExceptionType = excep.Type
			caughtFrom = "ReferenceErrorHandler"
		}).
		Catch(nil, func(excep *Exception) {
			thrownExceptionType = excep.Type
			caughtFrom = "DefaultExceptionHandler"
		}).Run()

	if thrownExceptionType != LookupErrorType {
		t.Fatalf("Expecting Exception type to be %s but found %s", LookupErrorType, thrownExceptionType)
	}

	if caughtFrom != "LookupErrorHandler" {
		t.Fatalf("Expecting Catch block to be %s but found %s", "LookupErrorHandler", caughtFrom)
	}
}

func TestDefaultCatchBlockGetsExecutedForUnmatchedException(t *testing.T) {
	var thrownExceptionType ExceptionType
	var caughtFrom string
	e := New()
	e.Try(func() {
		e.Throw(e.NewException(UnknownErrorType, "Unknown Error"))
	}).
		Catch(e.In(LookupErrorType), func(excep *Exception) {
			thrownExceptionType = excep.Type
			caughtFrom = "LookupErrorHandler"
		}).
		Catch(e.In(ReferenceErrorType, IndexErrorType), func(excep *Exception) {
			thrownExceptionType = excep.Type
			caughtFrom = "ReferenceErrorHandler"
		}).
		Catch(nil, func(excep *Exception) {
			thrownExceptionType = excep.Type
			caughtFrom = "DefaultExceptionHandler"
		}).Run()

	if thrownExceptionType != UnknownErrorType {
		t.Fatalf("Expecting Exception type to be %s but found %s", UnknownErrorType, thrownExceptionType)
	}

	if caughtFrom != "DefaultExceptionHandler" {
		t.Fatalf("Expecting Catch block to be %s but found %s", "DefaultExceptionHandler", caughtFrom)
	}
}

func TestAllPanicGetsRecoveredWithinTryCatch(t *testing.T) {
	var panicAttack = "Something went very wrong!"
	var caughtMessage string
	e := New()
	e.Try(func() {
		panic(panicAttack)
	}).
		Catch(nil, func(excep *Exception) {
			caughtMessage = excep.Message
		}).
		Run()

	if caughtMessage != panicAttack {
		t.Fatal("Could not recover panic attack!")
	}
}

func TestNestedExceptionWasHandledAsExpected(t *testing.T) {
	var firstThrownExceptionType ExceptionType
	var secondThrownExceptionType ExceptionType
	var hasCaughtNestedException bool
	var CustomExceptionType ExceptionType = "CustomException"

	e1 := New()
	e1.Try(func() {
		e1.Throw(e1.ReferenceError("Dummy error text"))
	}).
		Catch(nil, func(excep1 *Exception) {
			e2 := New()
			e2.Try(func() {
				// trying to save the world
				e2.Throw(e2.NewException(CustomExceptionType, "Custom Error Message"))
			}).Catch(e2.In(CustomExceptionType), func(excep2 *Exception) {
				firstThrownExceptionType = excep1.Type
				secondThrownExceptionType = excep2.Type
				hasCaughtNestedException = true
			}).Run()
		}).Run()

	if !hasCaughtNestedException {
		t.Fatal("Nested exception was not handled")
	}

	if firstThrownExceptionType != ReferenceErrorType {
		t.Fatalf("Expecting first exception to be %s but found %s", ReferenceErrorType, firstThrownExceptionType)
	}

	if secondThrownExceptionType != CustomExceptionType {
		t.Fatalf("Expecting second exception to be %s but found %s", CustomExceptionType, secondThrownExceptionType)
	}
}

func TestPanicIsRecoveredInDefaultCatch(t *testing.T) {
	errorMsg := "I'm gonna panic but don't worry"
	var caughtErrorMsg string
	e := New()
	e.Try(func() {
		panic(errorMsg)
	}).Catch(nil, func(excep *Exception) {
		caughtErrorMsg = excep.Message
		// Debug: Panic successfully caught and recovered
	}).Run()

	if caughtErrorMsg != errorMsg {
		t.Fatalf("Expecting error message to be %s but found %s", errorMsg, caughtErrorMsg)
	}
}

// Test the exact example from the user's requirement
func TestUserExampleFromRequirement(t *testing.T) {
	var assertionErrorCaught bool
	var finallyExecuted bool
	var caughtMessage string
	var caughtType ExceptionType

	e := New()
	e.Try(func() {
		data := getValue() // get me the value from Allions
		if data != 100 {
			e.Throw(e.AssertionError("Expected value is not the same as 100"))
		}
	}).
		Catch(e.In(AssertionErrorType, ValueErrorType), func(excep *Exception) {
			// Debug: Assertion error caught successfully
			// Message: excep.Message
			// Type: excep.Type
			// Stack trace available in excep.StackTrace
			assertionErrorCaught = true
			caughtMessage = excep.Message
			caughtType = excep.Type
		}).
		Catch(nil, func(excep *Exception) {
			// Debug: Fallback handler executed
		}).
		Finally(func() {
			// Debug: Finally block executed for cleanup
			finallyExecuted = true
		}).
		Run()

	if !assertionErrorCaught {
		t.Fatal("AssertionError was not caught")
	}

	if !finallyExecuted {
		t.Fatal("Finally block was not executed")
	}

	if caughtType != AssertionErrorType {
		t.Fatalf("Expected AssertionErrorType but got %s", caughtType)
	}

	if caughtMessage != "Expected value is not the same as 100" {
		t.Fatalf("Expected specific error message but got: %s", caughtMessage)
	}
}

// Test all exception types
func TestAllExceptionTypes(t *testing.T) {
	e := New()

	tests := []struct {
		name          string
		exceptionFunc func() *Exception
		expectedType  ExceptionType
	}{
		{"AssertionError", func() *Exception { return e.AssertionError("test") }, AssertionErrorType},
		{"IndexError", func() *Exception { return e.IndexError("test") }, IndexErrorType},
		{"RuntimeError", func() *Exception { return e.RuntimeError("test") }, RuntimeErrorType},
		{"ValueError", func() *Exception { return e.ValueError("test") }, ValueErrorType},
		{"NetworkError", func() *Exception { return e.NetworkError("test") }, NetworkErrorType},
		{"SyntaxError", func() *Exception { return e.SyntaxError("test") }, SyntaxErrorType},
		{"PermissionError", func() *Exception { return e.PermissionError("test") }, PermissionErrorType},
		{"TimeoutError", func() *Exception { return e.TimeoutError("test") }, TimeoutErrorType},
		{"TypeError", func() *Exception { return e.TypeError("test") }, TypeErrorType},
		{"ConnectionError", func() *Exception { return e.ConnectionError("test") }, ConnectionErrorType},
		{"ReferenceError", func() *Exception { return e.ReferenceError("test") }, ReferenceErrorType},
		{"EOFError", func() *Exception { return e.EOFError("test") }, EOFErrorType},
		{"LookupError", func() *Exception { return e.LookupError("test") }, LookupErrorType},
		{"UnknownError", func() *Exception { return e.UnknownError("test") }, UnknownErrorType},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			exception := tt.exceptionFunc()
			if exception.Type != tt.expectedType {
				t.Errorf("Expected type %s, got %s", tt.expectedType, exception.Type)
			}
			if exception.Message != "test" {
				t.Errorf("Expected message 'test', got %s", exception.Message)
			}
		})
	}
}