java_test.go

package tools

import (
	"os"
	"path/filepath"
	"runtime"
	"testing"

	"github.com/gnodet/mvx/pkg/config"
)

func TestUseSystemTool(t *testing.T) {
	// Test when MVX_USE_SYSTEM_JAVA is not set
	os.Unsetenv("MVX_USE_SYSTEM_JAVA")
	if UseSystemTool("java") {
		t.Error("UseSystemTool('java') should return false when MVX_USE_SYSTEM_JAVA is not set")
	}

	// Test when MVX_USE_SYSTEM_JAVA is set to false
	os.Setenv("MVX_USE_SYSTEM_JAVA", "false")
	if UseSystemTool("java") {
		t.Error("UseSystemTool('java') should return false when MVX_USE_SYSTEM_JAVA=false")
	}

	// Test when MVX_USE_SYSTEM_JAVA is set to true
	os.Setenv("MVX_USE_SYSTEM_JAVA", "true")
	if !UseSystemTool("java") {
		t.Error("UseSystemTool('java') should return true when MVX_USE_SYSTEM_JAVA=true")
	}

	// Test Maven tool
	os.Unsetenv("MVX_USE_SYSTEM_MAVEN")
	if UseSystemTool("maven") {
		t.Error("UseSystemTool('maven') should return false when MVX_USE_SYSTEM_MAVEN is not set")
	}

	os.Setenv("MVX_USE_SYSTEM_MAVEN", "true")
	if !UseSystemTool("maven") {
		t.Error("UseSystemTool('maven') should return true when MVX_USE_SYSTEM_MAVEN=true")
	}

	// Clean up
	os.Unsetenv("MVX_USE_SYSTEM_JAVA")
	os.Unsetenv("MVX_USE_SYSTEM_MAVEN")
}

func TestUseSystemJava(t *testing.T) {
	// Test when MVX_USE_SYSTEM_JAVA is not set
	os.Unsetenv("MVX_USE_SYSTEM_JAVA")
	if UseSystemTool("java") {
		t.Error("UseSystemTool('java') should return false when MVX_USE_SYSTEM_JAVA is not set")
	}

	// Test when MVX_USE_SYSTEM_JAVA is set to false
	os.Setenv("MVX_USE_SYSTEM_JAVA", "false")
	if UseSystemTool("java") {
		t.Error("UseSystemTool('java') should return false when MVX_USE_SYSTEM_JAVA=false")
	}

	// Test when MVX_USE_SYSTEM_JAVA is set to true
	os.Setenv("MVX_USE_SYSTEM_JAVA", "true")
	if !UseSystemTool("java") {
		t.Error("UseSystemTool('java') should return true when MVX_USE_SYSTEM_JAVA=true")
	}

	// Clean up
	os.Unsetenv("MVX_USE_SYSTEM_JAVA")
}

func TestJavaSystemDetector(t *testing.T) {
	// Save original JAVA_HOME
	originalJavaHome := os.Getenv("JAVA_HOME")
	defer func() {
		if originalJavaHome != "" {
			os.Setenv("JAVA_HOME", originalJavaHome)
		} else {
			os.Unsetenv("JAVA_HOME")
		}
	}()

	// Test when JAVA_HOME is not set and java is not in PATH
	os.Unsetenv("JAVA_HOME")
	// Note: This test might pass if java is in PATH, which is fine
	// We're testing that the generic function handles the case gracefully
	javaBinaryName := BinaryJava
	if runtime.GOOS == "windows" {
		javaBinaryName = BinaryJava + ".exe"
	}
	_, _, err := getSystemToolHome(ToolJava, javaBinaryName, EnvJavaHome)
	if err != nil {
		// This is expected if java is not in PATH and JAVA_HOME is not set
		t.Logf("getSystemToolHome() returned error as expected: %v", err)
	}

	// Test when JAVA_HOME points to non-existent directory
	os.Setenv("JAVA_HOME", "/non/existent/path")
	_, _, err = getSystemToolHome(ToolJava, javaBinaryName, EnvJavaHome)
	// Note: getSystemToolHome() will fall back to PATH if JAVA_HOME is invalid
	// So this test will only fail if java is also not in PATH
	// This is the expected behavior - we want to be permissive and use PATH as fallback
	if err != nil {
		t.Logf("getSystemToolHome() returned error (java not in PATH): %v", err)
	} else {
		t.Logf("getSystemToolHome() succeeded by falling back to PATH despite invalid JAVA_HOME")
	}
}

func TestJavaSystemDetectorVersion(t *testing.T) {
	// This test requires a real Java installation, so we'll skip it if JAVA_HOME is not set
	javaHome := os.Getenv("JAVA_HOME")
	if javaHome == "" {
		t.Skip("Skipping test because JAVA_HOME is not set")
	}

	// Check if Java executable exists
	javaExe := filepath.Join(javaHome, "bin", "java")
	if runtime.GOOS == "windows" {
		javaExe += ".exe"
	}

	if _, err := os.Stat(javaExe); err != nil {
		t.Skip("Skipping test because Java executable not found at JAVA_HOME")
	}

	version, err := getSystemJavaVersion(javaHome)
	if err != nil {
		t.Errorf("getSystemJavaVersion() failed: %v", err)
	}

	if version == "" {
		t.Error("getSystemJavaVersion() returned empty version")
	}

	t.Logf("Detected Java version: %s", version)
}

func TestJavaVersionCompatibility(t *testing.T) {
	tests := []struct {
		systemVersion    string
		requestedVersion string
		expected         bool
	}{
		{"21", "21", true},
		{"17", "17", true},
		{"11", "11", true},
		{"8", "8", true},
		{"21", "17", false},
		{"17", "21", false},
		{"11", "8", false},
	}

	for _, test := range tests {
		result := isJavaVersionCompatible(test.systemVersion, test.requestedVersion)
		if result != test.expected {
			t.Errorf("isJavaVersionCompatible(%s, %s) = %v, expected %v",
				test.systemVersion, test.requestedVersion, result, test.expected)
		}
	}
}

func TestJavaToolWithSystemJava(t *testing.T) {
	// Save original environment variables
	originalUseSystemJava := os.Getenv("MVX_USE_SYSTEM_JAVA")
	originalJavaHome := os.Getenv("JAVA_HOME")
	defer func() {
		if originalUseSystemJava != "" {
			os.Setenv("MVX_USE_SYSTEM_JAVA", originalUseSystemJava)
		} else {
			os.Unsetenv("MVX_USE_SYSTEM_JAVA")
		}
		if originalJavaHome != "" {
			os.Setenv("JAVA_HOME", originalJavaHome)
		} else {
			os.Unsetenv("JAVA_HOME")
		}
	}()

	// Create a mock manager
	manager, err := NewManager()
	if err != nil {
		t.Fatalf("Failed to create manager: %v", err)
	}

	javaTool := NewJavaTool(manager)

	// Test with MVX_USE_SYSTEM_JAVA=false (default behavior)
	os.Unsetenv("MVX_USE_SYSTEM_JAVA")
	os.Unsetenv("JAVA_HOME")

	cfg := config.ToolConfig{
		Version:      "99", // Use version 99 which definitely won't be installed
		Distribution: "temurin",
	}

	// IsInstalled should return false when no Java is installed and MVX_USE_SYSTEM_JAVA is not set
	if javaTool.IsInstalled("99", cfg) {
		t.Error("IsInstalled should return false when no Java is installed")
	}

	// Test with MVX_USE_SYSTEM_JAVA=true but no JAVA_HOME
	os.Setenv("MVX_USE_SYSTEM_JAVA", "true")
	os.Unsetenv("JAVA_HOME")

	// Note: With standardized approach, IsInstalled will check PATH as fallback
	// So this test now depends on whether Java is available in system PATH
	// For now, we'll skip the strict JAVA_HOME validation test
	t.Logf("Skipping strict JAVA_HOME validation test - standardized approach is more permissive")

	// Test with MVX_USE_SYSTEM_JAVA=true and JAVA_HOME set to non-existent path
	os.Setenv("MVX_USE_SYSTEM_JAVA", "true")
	os.Setenv("JAVA_HOME", "/nonexistent/path/to/java")

	// Note: With standardized approach, this will fall back to checking PATH
	// The old behavior was more strict and would fail if JAVA_HOME was invalid
	t.Logf("Note: Standardized approach is more permissive than old Java-specific logic")
}