error_handler_test.go

// error_handler_test.go: Testing Argus Error Handling
//
// Copyright (c) 2025 AGILira - A. Giordano
// Series: an AGILira fragment
// SPDX-License-Identifier: MPL-2.0

package argus

import (
	"os"
	"path/filepath"
	"strings"
	"sync"
	"testing"
	"time"
)

func TestErrorHandler_FileReadError(t *testing.T) {
	tempDir := t.TempDir()
	configPath := filepath.Join(tempDir, "config.json")

	var capturedError error
	var capturedPath string
	var callbackCalled bool
	var callbackCount int
	var mu sync.Mutex

	errorHandler := func(err error, path string) {
		mu.Lock()
		defer mu.Unlock()
		capturedError = err
		capturedPath = path
		t.Logf("ErrorHandler called: %v", err)
	}

	config := Config{
		PollInterval: 50 * time.Millisecond,
		ErrorHandler: errorHandler,
	}

	// Note: We don't create the file initially to avoid the callback being called

	watcher, err := UniversalConfigWatcherWithConfig(configPath, func(config map[string]interface{}) {
		mu.Lock()
		defer mu.Unlock()
		callbackCalled = true
		callbackCount++
		t.Logf("Config callback called (count: %d): %+v", callbackCount, config)
	}, config)
	if err != nil {
		t.Fatalf("Failed to create watcher: %v", err)
	}
	defer func() {
		if err := watcher.Stop(); err != nil {
			t.Logf("Failed to stop watcher: %v", err)
		}
	}()

	// The watcher should already be started since UniversalConfigWatcherWithConfig auto-starts
	// Wait for initial setup
	time.Sleep(200 * time.Millisecond)

	// Strategy: Create a file that can't be read due to permissions
	// On Windows and Unix, we'll create a file with no read permissions

	// Create the file first
	if err := os.WriteFile(configPath, []byte(`{"test": true}`), 0644); err != nil {
		t.Fatalf("Failed to create test file: %v", err)
	}

	// Wait for potential initial callback (this is expected behavior)
	time.Sleep(300 * time.Millisecond)

	// Reset callback tracking after potential initial call
	mu.Lock()
	initialCallbackCount := callbackCount
	callbackCalled = false // Reset for the error test
	callbackCount = 0      // Reset counter
	capturedError = nil    // Reset error tracking
	mu.Unlock()

	t.Logf("Initial callback count: %d, now testing error scenario", initialCallbackCount)

	// Remove all permissions (including read) to cause read error
	if err := os.Chmod(configPath, 0000); err != nil {
		t.Fatalf("Failed to remove file permissions: %v", err)
	}

	// Restore permissions at the end for cleanup
	defer func() {
		if err := os.Chmod(configPath, 0644); err != nil {
			t.Logf("Failed to restore file permissions: %v", err)
		}
		if err := os.Remove(configPath); err != nil {
			t.Logf("Failed to remove config file: %v", err)
		}
	}()

	// Trigger a change by updating file timestamp via touch
	// This is more reliable cross-platform than trying to write to it
	time.Sleep(100 * time.Millisecond)

	// Use a more direct approach: temporarily restore write permission,
	// modify content, then remove all permissions again
	if err := os.Chmod(configPath, 0644); err != nil {
		t.Logf("Failed to restore write permission: %v", err)
	}
	if err := os.WriteFile(configPath, []byte(`{"test": "modified"}`), 0644); err != nil {
		t.Logf("Failed to modify config file: %v", err)
	}
	if err := os.Chmod(configPath, 0000); err != nil {
		t.Logf("Failed to remove permissions again: %v", err)
	}

	// Wait for error to be captured with extended retry logic for CI
	maxRetries := 20 // Extended for macOS CI timing
	var finalCallbackCalled bool
	var finalCallbackCount int
	var finalError error

	for i := 0; i < maxRetries; i++ {
		mu.Lock()
		finalCallbackCalled = callbackCalled
		finalCallbackCount = callbackCount
		finalError = capturedError
		mu.Unlock()

		// If we got an error, that's what we want (regardless of callback state)
		if finalError != nil {
			t.Logf("Error captured after %d attempts: %v", i+1, finalError)
			break
		}
		time.Sleep(200 * time.Millisecond) // Extended timing for CI
	}

	mu.Lock()
	defer mu.Unlock()

	t.Logf("Final state - Callback called: %v, Callback count: %d, Error: %v",
		finalCallbackCalled, finalCallbackCount, finalError)

	// On some platforms (especially macOS), the behavior might be different
	// The key requirement is that errors should be captured by ErrorHandler
	if finalError == nil {
		t.Skip("No read error was captured - this might be platform-dependent behavior (some systems allow reading despite permission restrictions)")
	}

	if capturedPath != configPath {
		t.Errorf("Expected path %s, got %s", configPath, capturedPath)
	}

	// Check for various types of read errors that might occur across platforms
	errorMsg := finalError.Error()
	if !strings.Contains(errorMsg, "failed to read config file") &&
		!strings.Contains(errorMsg, "permission denied") &&
		!strings.Contains(errorMsg, "access is denied") &&
		!strings.Contains(errorMsg, "operation not permitted") &&
		!strings.Contains(errorMsg, "is a directory") {
		t.Errorf("Expected error message about file read failure, got: %v", finalError)
	}

	// If callback was called despite the error, that's not ideal but might be platform behavior
	if finalCallbackCalled {
		t.Logf("Warning: Callback was called despite read error - this suggests platform-specific behavior")
	}
}

func TestErrorHandler_ParseError(t *testing.T) {
	tempDir := t.TempDir()
	configPath := filepath.Join(tempDir, "config.json")

	var capturedError error
	var capturedPath string
	var mu sync.Mutex

	errorHandler := func(err error, path string) {
		mu.Lock()
		defer mu.Unlock()
		capturedError = err
		capturedPath = path
	}

	config := Config{
		PollInterval: 50 * time.Millisecond,
		ErrorHandler: errorHandler,
	}

	watcher, err := UniversalConfigWatcherWithConfig(configPath, func(config map[string]interface{}) {
		// Should not be called due to parse error
		t.Error("Callback should not be called when parsing fails")
	}, config)
	if err != nil {
		t.Fatalf("Failed to create watcher: %v", err)
	}
	defer func() {
		if err := watcher.Stop(); err != nil {
			t.Logf("Failed to stop watcher: %v", err)
		}
	}()

	// Write invalid JSON
	if err := os.WriteFile(configPath, []byte(`{"test": invalid_json`), 0644); err != nil {
		t.Fatalf("Failed to write invalid JSON: %v", err)
	}

	// Wait for error to be captured
	time.Sleep(200 * time.Millisecond)

	mu.Lock()
	defer mu.Unlock()

	if capturedError == nil {
		t.Fatal("Expected parse error to be captured by ErrorHandler")
	}

	if capturedPath != configPath {
		t.Errorf("Expected path %s, got %s", configPath, capturedPath)
	}

	if !strings.Contains(capturedError.Error(), "failed to parse") {
		t.Errorf("Expected error message about parsing, got: %v", capturedError)
	}
}

func TestErrorHandler_DefaultBehavior(t *testing.T) {
	tempDir := t.TempDir()
	configPath := filepath.Join(tempDir, "config.json")

	// Test that default error handler doesn't panic
	config := Config{
		PollInterval: 50 * time.Millisecond,
		// No ErrorHandler set - should use default
	}

	watcher, err := UniversalConfigWatcherWithConfig(configPath, func(config map[string]interface{}) {
		// Should not be called
	}, config)
	if err != nil {
		t.Fatalf("Failed to create watcher: %v", err)
	}
	defer func() {
		if err := watcher.Stop(); err != nil {
			t.Logf("Failed to stop watcher: %v", err)
		}
	}()

	// Write invalid JSON to trigger error
	if err := os.WriteFile(configPath, []byte(`{"test": invalid`), 0644); err != nil {
		t.Fatalf("Failed to write invalid JSON: %v", err)
	}

	// Wait a bit - should not panic
	time.Sleep(200 * time.Millisecond)

	// If we get here without panic, the default error handler works
	t.Log("✅ Default error handler works without panicking")
}

func TestErrorHandler_StatError(t *testing.T) {
	tempDir := t.TempDir()
	configPath := filepath.Join(tempDir, "config.json")

	var capturedError error
	var capturedPath string
	var mu sync.Mutex

	errorHandler := func(err error, path string) {
		mu.Lock()
		defer mu.Unlock()
		capturedError = err
		capturedPath = path
	}

	config := Config{
		PollInterval: 50 * time.Millisecond,
		ErrorHandler: errorHandler,
	}

	watcher := New(config)

	if err := watcher.Start(); err != nil {
		t.Fatalf("Failed to start watcher: %v", err)
	}
	defer func() {
		if err := watcher.Stop(); err != nil {
			t.Logf("Failed to stop watcher: %v", err)
		}
	}()

	// Create a file first
	if err := os.WriteFile(configPath, []byte(`{"test": true}`), 0644); err != nil {
		t.Fatalf("Failed to create test file: %v", err)
	}

	// Watch the file
	if err := watcher.Watch(configPath, func(event ChangeEvent) {
		// This callback is fine for normal operation
	}); err != nil {
		t.Fatalf("Failed to watch file: %v", err)
	}

	// Wait for initial stat
	time.Sleep(100 * time.Millisecond)

	// Create a directory with the same name to cause stat error
	if err := os.Remove(configPath); err != nil {
		t.Fatalf("Failed to remove file: %v", err)
	}
	if err := os.Mkdir(configPath, 0755); err != nil {
		t.Fatalf("Failed to create directory: %v", err)
	}
	defer func() {
		if err := os.RemoveAll(configPath); err != nil {
			t.Logf("Failed to cleanup configPath: %v", err)
		}
	}()

	// Change the directory to make it inaccessible (permission denied)
	if err := os.Chmod(configPath, 0000); err != nil {
		t.Fatalf("Failed to change directory permissions: %v", err)
	}

	// Wait for error to be captured
	time.Sleep(300 * time.Millisecond)

	mu.Lock()
	defer mu.Unlock()

	// This test might be flaky on some systems, so we'll be more lenient
	// The main goal is to test that ErrorHandler gets called for non-NotExist errors
	if capturedError != nil {
		if capturedPath != configPath {
			t.Errorf("Expected path %s, got %s", configPath, capturedPath)
		}

		if !strings.Contains(capturedError.Error(), "failed to stat file") {
			t.Errorf("Expected error message about stat failure, got: %v", capturedError)
		}
		t.Log("✅ ErrorHandler correctly captured stat error")
	} else {
		// On some systems, the directory might still be readable, so this isn't a hard failure
		t.Skip("Stat error was not captured - this might be system-dependent")
	}
}