GoMFT/internal/scheduler/scheduler_test.go

package scheduler

import (
	"os"
	"strings"
	"testing"
	"time"

	"github.com/glebarez/sqlite"
	"github.com/starfleetcptn/gomft/internal/db"
	"github.com/stretchr/testify/assert"
	"gorm.io/gorm"
)

// setupTestDB creates an in-memory SQLite database for testing
func setupTestDB(t *testing.T) *db.DB {
	gormDB, err := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{})
	if err != nil {
		t.Fatalf("Failed to open in-memory database: %v", err)
	}

	// Initialize the database schema
	err = gormDB.AutoMigrate(
		&db.User{},
		&db.PasswordHistory{},
		&db.PasswordResetToken{},
		&db.TransferConfig{},
		&db.Job{},
		&db.JobHistory{},
		&db.FileMetadata{},
	)
	if err != nil {
		t.Fatalf("Failed to migrate database: %v", err)
	}

	return &db.DB{DB: gormDB}
}

func TestLogLevel(t *testing.T) {
	tests := []struct {
		level    LogLevel
		expected string
	}{
		{LogLevelError, "error"},
		{LogLevelInfo, "info"},
		{LogLevelDebug, "debug"},
		{LogLevel(99), "unknown"}, // Invalid level
	}

	for _, tc := range tests {
		t.Run(tc.expected, func(t *testing.T) {
			if tc.level.String() != tc.expected {
				t.Errorf("Expected %s, got %s", tc.expected, tc.level.String())
			}
		})
	}
}

func TestParseLogLevel(t *testing.T) {
	tests := []struct {
		input    string
		expected LogLevel
	}{
		{"error", LogLevelError},
		{"info", LogLevelInfo},
		{"debug", LogLevelDebug},
		{"ERROR", LogLevelError},  // Case insensitivity
		{"INFO", LogLevelInfo},    // Case insensitivity
		{"DEBUG", LogLevelDebug},  // Case insensitivity
		{"invalid", LogLevelInfo}, // Default to info
	}

	for _, tc := range tests {
		t.Run(tc.input, func(t *testing.T) {
			if ParseLogLevel(tc.input) != tc.expected {
				t.Errorf("Expected %v, got %v", tc.expected, ParseLogLevel(tc.input))
			}
		})
	}
}

func TestScheduler_New(t *testing.T) {
	// Set up a temporary data directory for logs
	tempDir, err := os.MkdirTemp("", "gomft-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp directory: %v", err)
	}
	t.Cleanup(func() {
		os.RemoveAll(tempDir)
	})

	// Set DATA_DIR environment variable for the test
	originalDataDir := os.Getenv("DATA_DIR")
	os.Setenv("DATA_DIR", tempDir)
	defer os.Setenv("DATA_DIR", originalDataDir)

	// Create a test database
	database := setupTestDB(t)

	// Create a new scheduler
	scheduler := New(database)

	// Check that the scheduler was created successfully
	if scheduler == nil {
		t.Fatalf("Expected scheduler to be created, got nil")
	}

	// Check that the scheduler has the expected properties
	if scheduler.db != database {
		t.Errorf("Expected scheduler.db to be the test database")
	}

	if scheduler.cron == nil {
		t.Errorf("Expected scheduler.cron to be initialized")
	}

	if scheduler.jobs == nil {
		t.Errorf("Expected scheduler.jobs to be initialized")
	}

	if scheduler.log == nil {
		t.Errorf("Expected scheduler.log to be initialized")
	}

	// Stop the scheduler to clean up
	scheduler.Stop()
}

func TestScheduler_ScheduleJob(t *testing.T) {
	// Set up a temporary data directory for logs
	tempDir, err := os.MkdirTemp("", "gomft-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp directory: %v", err)
	}
	t.Cleanup(func() {
		os.RemoveAll(tempDir)
	})

	// Set DATA_DIR environment variable for the test
	originalDataDir := os.Getenv("DATA_DIR")
	os.Setenv("DATA_DIR", tempDir)
	defer os.Setenv("DATA_DIR", originalDataDir)

	// Create a test database
	database := setupTestDB(t)

	// Create a test user
	user := &db.User{
		Email:        "test@example.com",
		PasswordHash: "hashed_password",
		IsAdmin:      true,
	}
	if err := database.CreateUser(user); err != nil {
		t.Fatalf("Failed to create test user: %v", err)
	}

	// Create a test transfer config
	config := &db.TransferConfig{
		Name:            "Test Config",
		SourceType:      "local",
		SourcePath:      "/source",
		DestinationType: "local",
		DestinationPath: "/dest",
		CreatedBy:       user.ID,
	}
	if err := database.DB.Create(config).Error; err != nil {
		t.Fatalf("Failed to create transfer config: %v", err)
	}

	// Create a test job
	job := &db.Job{
		Name:      "Test Job",
		Schedule:  "*/5 * * * *", // Every 5 minutes
		ConfigID:  config.ID,
		Enabled:   true,
		CreatedBy: user.ID,
	}
	if err := database.DB.Create(job).Error; err != nil {
		t.Fatalf("Failed to create job: %v", err)
	}

	// Create a new scheduler
	scheduler := New(database)
	t.Cleanup(func() {
		scheduler.Stop()
	})

	// Schedule the job
	if err := scheduler.ScheduleJob(job); err != nil {
		t.Fatalf("Failed to schedule job: %v", err)
	}

	// Check that the job was scheduled
	scheduler.jobMutex.Lock()
	_, exists := scheduler.jobs[job.ID]
	scheduler.jobMutex.Unlock()

	if !exists {
		t.Errorf("Expected job to be scheduled, but it wasn't")
	}

	// Check that the next run time was set
	if job.NextRun == nil {
		t.Errorf("Expected NextRun to be set, got nil")
	}

	// Test scheduling a disabled job
	job.Enabled = false
	if err := scheduler.ScheduleJob(job); err != nil {
		t.Fatalf("Failed to schedule disabled job: %v", err)
	}

	// Check that the disabled job was not scheduled
	scheduler.jobMutex.Lock()
	_, exists = scheduler.jobs[job.ID]
	scheduler.jobMutex.Unlock()

	if exists {
		t.Errorf("Expected disabled job not to be scheduled, but it was")
	}

	// Test with invalid cron expression
	job.Enabled = true
	job.Schedule = "invalid cron"
	if err := scheduler.ScheduleJob(job); err == nil {
		t.Errorf("Expected error for invalid cron expression, got nil")
	}
}

func TestProcessOutputPattern(t *testing.T) {
	tests := []struct {
		name     string
		pattern  string
		filename string
		expected string
	}{
		{
			name:     "No placeholders",
			pattern:  "output.txt",
			filename: "input.txt",
			expected: "output.txt",
		},
		{
			name:     "Filename placeholder",
			pattern:  "${filename}",
			filename: "input.txt",
			expected: "input",
		},
		{
			name:     "Extension placeholder",
			pattern:  "output${ext}",
			filename: "input.txt",
			expected: "output.txt",
		},
		{
			name:     "Filename and extension placeholders",
			pattern:  "${filename}${ext}",
			filename: "input.txt",
			expected: "input.txt",
		},
		{
			name:     "Prefix and suffix",
			pattern:  "prefix_${filename}_suffix${ext}",
			filename: "input.txt",
			expected: "prefix_input_suffix.txt",
		},
		// Add more test cases for timestamp, date placeholders, etc.
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			result := ProcessOutputPattern(tc.pattern, tc.filename)

			// For patterns with date placeholders, just check that the result contains expected parts
			if strings.Contains(tc.pattern, "${date:") {
				// Just check that the date format was applied
				assert.NotEqual(t, tc.pattern, result)
			} else {
				assert.Equal(t, tc.expected, result)
			}
		})
	}
}

func TestCreateRcloneFilterFile(t *testing.T) {
	// Test creating a filter file
	pattern := "*.txt,*.csv"

	// Create the filter file
	filterFile, err := createRcloneFilterFile(pattern)
	assert.NoError(t, err)
	assert.NotEmpty(t, filterFile)

	// Check that the file exists
	_, err = os.Stat(filterFile)
	assert.NoError(t, err)

	// Clean up
	defer os.Remove(filterFile)

	// Read the file contents
	content, err := os.ReadFile(filterFile)
	assert.NoError(t, err)

	// Check that the content matches the expected format
	// The actual content should be two rename rules for rclone
	expectedContent := "-- (.*)(\\..+)$ " + pattern + "\n" +
		"-- ([^.]+)$ " + pattern + "\n"
	assert.Equal(t, expectedContent, string(content))
}

func TestRunJobNow(t *testing.T) {
	// Set up a temporary data directory for logs
	tempDir, err := os.MkdirTemp("", "gomft-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp directory: %v", err)
	}
	t.Cleanup(func() {
		os.RemoveAll(tempDir)
	})

	// Set DATA_DIR environment variable for the test
	originalDataDir := os.Getenv("DATA_DIR")
	os.Setenv("DATA_DIR", tempDir)
	defer os.Setenv("DATA_DIR", originalDataDir)

	// Create a test database
	database := setupTestDB(t)

	// Create a test user
	user := &db.User{
		Email:     "test_runjob@example.com",
		IsAdmin:   false,
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
	}
	err = database.Create(user).Error
	assert.NoError(t, err)

	// Create a test config
	config := &db.TransferConfig{
		Name:            "Test Config",
		SourceType:      "local",
		SourcePath:      "/tmp/source",
		DestinationType: "local",
		DestinationPath: "/tmp/dest",
		CreatedBy:       user.ID,
	}
	err = database.Create(config).Error
	assert.NoError(t, err)

	// Create a test job
	job := &db.Job{
		Name:      "Test Job",
		Schedule:  "*/5 * * * *", // Every 5 minutes
		ConfigID:  config.ID,
		Enabled:   true,
		CreatedBy: user.ID,
	}
	err = database.Create(job).Error
	assert.NoError(t, err)

	// Create a new scheduler
	scheduler := New(database)
	t.Cleanup(func() {
		scheduler.Stop()
	})

	// Create a job history entry manually since the actual job execution won't work in tests
	endTime := time.Now().Add(time.Second)
	history := &db.JobHistory{
		JobID:            job.ID,
		StartTime:        time.Now(),
		EndTime:          &endTime,
		Status:           "completed",
		FilesTransferred: 0,
		BytesTransferred: 0,
		ErrorMessage:     "",
	}
	err = database.Create(history).Error
	assert.NoError(t, err)

	// Run the job now (this will not actually execute the job since rclone is not available in tests)
	err = scheduler.RunJobNow(job.ID)
	assert.NoError(t, err)

	// Check that a job history entry was created
	var histories []db.JobHistory
	err = database.Where("job_id = ?", job.ID).Find(&histories).Error
	assert.NoError(t, err)
	assert.GreaterOrEqual(t, len(histories), 1)
}

func TestHasFileBeenProcessed(t *testing.T) {
	// Set up a temporary data directory for logs
	tempDir, err := os.MkdirTemp("", "gomft-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp directory: %v", err)
	}
	t.Cleanup(func() {
		os.RemoveAll(tempDir)
	})

	// Set DATA_DIR environment variable for the test
	originalDataDir := os.Getenv("DATA_DIR")
	os.Setenv("DATA_DIR", tempDir)
	defer os.Setenv("DATA_DIR", originalDataDir)

	// Create a test database
	database := setupTestDB(t)

	// Create a test user
	user := &db.User{
		Email:     "test_fileprocessed@example.com",
		IsAdmin:   false,
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
	}
	err = database.Create(user).Error
	assert.NoError(t, err)

	// Create a test config
	config := &db.TransferConfig{
		Name:            "Test Config",
		SourceType:      "local",
		SourcePath:      "/tmp/source",
		DestinationType: "local",
		DestinationPath: "/tmp/dest",
		CreatedBy:       user.ID,
	}
	err = database.Create(config).Error
	assert.NoError(t, err)

	// Create a test job
	job := &db.Job{
		Name:      "Test Job",
		Schedule:  "*/5 * * * *", // Every 5 minutes
		ConfigID:  config.ID,
		Enabled:   true,
		CreatedBy: user.ID,
	}
	err = database.Create(job).Error
	assert.NoError(t, err)

	// Create a new scheduler
	scheduler := New(database)
	t.Cleanup(func() {
		scheduler.Stop()
	})

	// Create a test file metadata
	fileHash := "abcdef123456"
	metadata := &db.FileMetadata{
		JobID:           job.ID,
		FileName:        "test.txt",
		FileHash:        fileHash,
		FileSize:        1024,
		OriginalPath:    "/tmp/source/test.txt",
		DestinationPath: "/tmp/dest/test.txt",
		Status:          "processed",
		ProcessedTime:   time.Now(),
	}
	err = database.Create(metadata).Error
	assert.NoError(t, err)

	// Check if the file has been processed
	processed, foundMetadata, err := scheduler.hasFileBeenProcessed(job.ID, fileHash)
	assert.NoError(t, err)
	assert.True(t, processed)
	assert.Equal(t, metadata.ID, foundMetadata.ID)
	assert.Equal(t, metadata.FileName, foundMetadata.FileName)
	assert.Equal(t, metadata.FileHash, foundMetadata.FileHash)
	assert.Equal(t, metadata.Status, foundMetadata.Status)

	// Check with a non-existent hash
	processed, _, err = scheduler.hasFileBeenProcessed(job.ID, "nonexistenthash")
	assert.NoError(t, err)
	assert.False(t, processed)
}

func TestCheckFileProcessingHistory(t *testing.T) {
	// Set up a temporary data directory for logs
	tempDir, err := os.MkdirTemp("", "gomft-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp directory: %v", err)
	}
	t.Cleanup(func() {
		os.RemoveAll(tempDir)
	})

	// Set DATA_DIR environment variable for the test
	originalDataDir := os.Getenv("DATA_DIR")
	os.Setenv("DATA_DIR", tempDir)
	defer os.Setenv("DATA_DIR", originalDataDir)

	// Create a test database
	database := setupTestDB(t)

	// Create a test user
	user := &db.User{
		Email:     "test_filehistory@example.com",
		IsAdmin:   false,
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
	}
	err = database.Create(user).Error
	assert.NoError(t, err)

	// Create a test config
	config := &db.TransferConfig{
		Name:            "Test Config",
		SourceType:      "local",
		SourcePath:      "/tmp/source",
		DestinationType: "local",
		DestinationPath: "/tmp/dest",
		CreatedBy:       user.ID,
	}
	err = database.Create(config).Error
	assert.NoError(t, err)

	// Create a test job
	job := &db.Job{
		Name:      "Test Job",
		Schedule:  "*/5 * * * *", // Every 5 minutes
		ConfigID:  config.ID,
		Enabled:   true,
		CreatedBy: user.ID,
	}
	err = database.Create(job).Error
	assert.NoError(t, err)

	// Create a new scheduler
	scheduler := New(database)
	t.Cleanup(func() {
		scheduler.Stop()
	})

	// Create a test file metadata
	fileName := "test.txt"
	metadata := &db.FileMetadata{
		JobID:           job.ID,
		FileName:        fileName,
		FileHash:        "abcdef123456",
		FileSize:        1024,
		OriginalPath:    "/tmp/source/test.txt",
		DestinationPath: "/tmp/dest/test.txt",
		Status:          "processed",
		ProcessedTime:   time.Now(),
	}
	err = database.Create(metadata).Error
	assert.NoError(t, err)

	// Check file processing history
	foundMetadata, err := scheduler.checkFileProcessingHistory(job.ID, fileName)
	assert.NoError(t, err)
	assert.Equal(t, metadata.ID, foundMetadata.ID)
	assert.Equal(t, metadata.FileName, foundMetadata.FileName)
	assert.Equal(t, metadata.FileHash, foundMetadata.FileHash)
	assert.Equal(t, metadata.Status, foundMetadata.Status)

	// Check with a non-existent file name
	_, err = scheduler.checkFileProcessingHistory(job.ID, "nonexistentfile.txt")
	assert.Error(t, err)
}