refactor: Remove obsolete test files

- Deleted outdated test files for providers, authentication, password management, configuration, database, email, scheduler, and web handlers.
- Cleaned up the codebase by removing tests that are no longer relevant or have been replaced by new implementations.
- This cleanup helps maintain a more manageable and efficient testing environment.
This commit is contained in:
StarFleetCPTN committed 2025-03-26 16:51:14 -07:00
1 parent 8424e97cf8
commit a7cd021ff2
27 files changed
-11348

No files matched your search

-75
View File
@@ -1,75 +0,0 @@
package scheduler
import (
"testing"
"github.com/starfleetcptn/gomft/internal/db"
"github.com/stretchr/testify/assert"
)
func TestMockScheduler_MultiConfig(t *testing.T) {
// Create a new mock scheduler
mockScheduler := NewMockScheduler()
// Create a job with multiple configurations
job := &db.Job{
ID: 1,
Name: "Multi-Config Test Job",
Schedule: "*/5 * * * *",
ConfigID: 1, // Primary config ID
}
job.SetEnabled(true)
// Set multiple config IDs
job.SetConfigIDsList([]uint{1, 2, 3})
// Schedule the job
err := mockScheduler.ScheduleJob(job)
assert.NoError(t, err)
// Check if the job is marked as scheduled
assert.True(t, mockScheduler.ScheduledJobs[job.ID])
// Verify that the job is detected as having multiple configs
assert.True(t, mockScheduler.IsJobWithMultipleConfigs(job.ID))
// Verify the configs associated with the job
configs := mockScheduler.GetConfigsForJob(job.ID)
assert.Len(t, configs, 3)
assert.Contains(t, configs, uint(1))
assert.Contains(t, configs, uint(2))
assert.Contains(t, configs, uint(3))
// Test unscheduling the job
mockScheduler.UnscheduleJob(job.ID)
assert.True(t, mockScheduler.UnscheduledJobs[job.ID])
assert.False(t, mockScheduler.ScheduledJobs[job.ID])
// Verify the job is no longer tracked in multi-config jobs
assert.False(t, mockScheduler.IsJobWithMultipleConfigs(job.ID))
assert.Empty(t, mockScheduler.GetConfigsForJob(job.ID))
// Test a job with a single config
singleConfigJob := &db.Job{
ID: 2,
Name: "Single Config Job",
Schedule: "0 0 * * *",
ConfigID: 4,
}
singleConfigJob.SetEnabled(true)
// Set a single config ID
singleConfigJob.SetConfigIDsList([]uint{4})
// Schedule the job
err = mockScheduler.ScheduleJob(singleConfigJob)
assert.NoError(t, err)
// Not considered a multi-config job if it has only one config
assert.False(t, mockScheduler.IsJobWithMultipleConfigs(singleConfigJob.ID))
// Should still contain the single config
singleConfigs := mockScheduler.GetConfigsForJob(singleConfigJob.ID)
assert.Len(t, singleConfigs, 1)
assert.Contains(t, singleConfigs, uint(4))
}
File diff suppressed because it is too large. Load diff
@@ -1,567 +0,0 @@
package scheduler
import (
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"sync"
"testing"
"time"
"github.com/starfleetcptn/gomft/internal/db"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// TestJobExecutionWebhook tests that webhooks are correctly sent during actual job execution
func TestJobExecutionWebhook(t *testing.T) {
// Skip in short mode
if testing.Short() {
t.Skip("Skipping integration test in short mode")
}
// Set up a temporary data directory for logs
tempDir := t.TempDir()
// Set DATA_DIR environment variable for the test
originalDataDir := os.Getenv("DATA_DIR")
t.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: "webhook-integration@example.com",
PasswordHash: "hashed_password",
IsAdmin: BoolPtr(true),
}
err := database.CreateUser(user)
require.NoError(t, err)
// Set up a mock HTTP server to receive webhook notifications
var (
receivedPayload []byte
receivedHeaders http.Header
webhookCalled bool
webhookMutex sync.Mutex
waitCh = make(chan struct{})
)
mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
webhookMutex.Lock()
defer webhookMutex.Unlock()
receivedHeaders = r.Header.Clone()
var err error
receivedPayload, err = io.ReadAll(r.Body)
if err != nil {
t.Logf("Error reading request body: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
t.Logf("Received webhook payload: %s", string(receivedPayload))
webhookCalled = true
close(waitCh)
w.WriteHeader(http.StatusOK)
}))
defer mockServer.Close()
t.Logf("Mock server URL: %s", mockServer.URL)
// Create local source and destination directories
sourceDir := t.TempDir()
destDir := t.TempDir()
t.Logf("Source directory: %s", sourceDir)
t.Logf("Destination directory: %s", destDir)
// Create a test transfer config with local source and destination
config := &db.TransferConfig{
Name: "Webhook Integration Config",
SourceType: "local",
SourcePath: sourceDir,
DestinationType: "local",
DestinationPath: destDir,
CreatedBy: user.ID,
}
err = database.DB.Create(config).Error
require.NoError(t, err)
t.Logf("Created config with ID: %d", config.ID)
// Create a test job with webhook enabled
job := &db.Job{
Name: "Webhook Integration Job",
ConfigID: config.ID,
Schedule: "*/5 * * * *", // not actually used in this test
Enabled: BoolPtr(true),
WebhookEnabled: BoolPtr(true),
WebhookURL: mockServer.URL,
NotifyOnSuccess: BoolPtr(true),
NotifyOnFailure: BoolPtr(true),
CreatedBy: user.ID,
}
err = database.DB.Create(job).Error
require.NoError(t, err)
t.Logf("Created job with ID %d, NotifyOnSuccess=%v", job.ID, job.NotifyOnSuccess)
// Create and initialize the scheduler
scheduler := New(database)
defer scheduler.Stop()
// Create rclone config directory and file
configDir := filepath.Join(tempDir, "configs")
err = os.MkdirAll(configDir, 0755)
require.NoError(t, err)
// Create a minimal rclone config file
rcloneConfig := `
[source_1]
type = local
[dest_1]
type = local
`
configFile := filepath.Join(configDir, "config_1.conf")
err = os.WriteFile(configFile, []byte(rcloneConfig), 0644)
require.NoError(t, err)
t.Logf("Created rclone config file: %s", configFile)
// Put a test file in the source directory
testFile := filepath.Join(sourceDir, "test.txt")
testFileContent := []byte("This is a test file for webhook integration testing.")
err = os.WriteFile(testFile, testFileContent, 0644)
require.NoError(t, err)
t.Logf("Created test file: %s", testFile)
// Check that the file exists
fileInfo, err := os.Stat(testFile)
require.NoError(t, err, "Test file should exist")
t.Logf("Test file size: %d bytes", fileInfo.Size())
// Manually trigger job execution
t.Logf("Running job now...")
err = scheduler.RunJobNow(job.ID)
require.NoError(t, err)
// Wait for the job to complete and webhook to be called (up to 15 seconds)
t.Logf("Waiting for webhook to be called...")
timeout := time.After(15 * time.Second)
select {
case <-waitCh:
t.Logf("Webhook was called")
case <-timeout:
// Before failing, check job status
var histories []db.JobHistory
err = database.DB.Where("job_id = ?", job.ID).Find(&histories).Error
require.NoError(t, err)
if len(histories) > 0 {
t.Logf("Job history found: status=%s, error=%s",
histories[0].Status, histories[0].ErrorMessage)
} else {
t.Logf("No job history found")
}
// Check if destination file exists
destFile := filepath.Join(destDir, "test.txt")
if _, err := os.Stat(destFile); err == nil {
t.Logf("Destination file exists, but webhook was not called")
} else {
t.Logf("Destination file does not exist: %v", err)
}
webhookMutex.Lock()
called := webhookCalled
webhookMutex.Unlock()
if called {
t.Logf("Webhook was actually called but channel synchronization failed")
} else {
t.Fatal("Timed out waiting for webhook to be called")
}
return
}
// Verify the webhook notification
webhookMutex.Lock()
payload := receivedPayload
headers := receivedHeaders
webhookMutex.Unlock()
assert.NotNil(t, payload, "Webhook notification should have been sent")
// Verify the payload content
var payloadMap map[string]interface{}
err = json.Unmarshal(payload, &payloadMap)
require.NoError(t, err, "Failed to unmarshal webhook payload")
// Check essential fields
assert.Equal(t, "job_execution", payloadMap["event_type"])
assert.Equal(t, float64(job.ID), payloadMap["job_id"])
assert.Equal(t, job.Name, payloadMap["job_name"])
assert.Equal(t, float64(config.ID), payloadMap["config_id"])
assert.Equal(t, config.Name, payloadMap["config_name"])
// Check status (should be "completed" or "completed_with_errors")
status, ok := payloadMap["status"].(string)
require.True(t, ok, "Status should be a string")
assert.Contains(t, []string{"completed", "completed_with_errors"}, status)
// Check that we have bytes transferred
bytesTransferred, ok := payloadMap["bytes_transferred"].(float64)
require.True(t, ok, "bytes_transferred should be a number")
assert.Greater(t, bytesTransferred, float64(0))
// Check that we have files transferred
filesTransferred, ok := payloadMap["files_transferred"].(float64)
require.True(t, ok, "files_transferred should be a number")
assert.Equal(t, float64(1), filesTransferred)
// Check standard headers
assert.Equal(t, "application/json", headers.Get("Content-Type"))
assert.Equal(t, "GoMFT-Webhook/1.0", headers.Get("User-Agent"))
// Check that the file was actually transferred
destFile := filepath.Join(destDir, "test.txt")
_, err = os.Stat(destFile)
assert.NoError(t, err, "The file should have been transferred")
// Clean up
err = database.DB.Unscoped().Delete(job).Error
require.NoError(t, err)
err = database.DB.Unscoped().Where("job_id = ?", job.ID).Delete(&db.JobHistory{}).Error
require.NoError(t, err)
}
// TestFailedJobWebhook tests that webhooks are correctly sent for failed jobs
func TestFailedJobWebhook(t *testing.T) {
// Skip in short mode
if testing.Short() {
t.Skip("Skipping integration test in short mode")
}
// Set up a temporary data directory for logs
tempDir := t.TempDir()
// Set DATA_DIR environment variable for the test
originalDataDir := os.Getenv("DATA_DIR")
t.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: "webhook-failure@example.com",
PasswordHash: "hashed_password",
IsAdmin: BoolPtr(true),
}
err := database.CreateUser(user)
require.NoError(t, err)
// Set up a mock HTTP server to receive webhook notifications
var (
receivedPayload []byte
webhookCalled bool
webhookMutex sync.Mutex
waitCh = make(chan struct{})
)
mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
webhookMutex.Lock()
defer webhookMutex.Unlock()
var err error
receivedPayload, err = io.ReadAll(r.Body)
if err != nil {
t.Logf("Error reading request body: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
t.Logf("Received webhook payload: %s", string(receivedPayload))
webhookCalled = true
close(waitCh)
w.WriteHeader(http.StatusOK)
}))
defer mockServer.Close()
// Get a non-existent directory for source
nonexistentDir := filepath.Join(t.TempDir(), "non-existent-subdirectory")
// Create a legitimate destination directory
destDir := t.TempDir()
// Create a test transfer config with invalid source (to trigger failure)
config := &db.TransferConfig{
Name: "Webhook Failure Config",
SourceType: "local",
SourcePath: nonexistentDir,
DestinationType: "local",
DestinationPath: destDir,
CreatedBy: user.ID,
}
err = database.DB.Create(config).Error
require.NoError(t, err)
t.Logf("Created config with invalid source path: %s", nonexistentDir)
// Create a test job with webhook enabled
job := &db.Job{
Name: "Webhook Failure Job",
ConfigID: config.ID,
Schedule: "*/5 * * * *", // not actually used in this test
Enabled: BoolPtr(true),
WebhookEnabled: BoolPtr(true),
WebhookURL: mockServer.URL,
NotifyOnSuccess: BoolPtr(true),
NotifyOnFailure: BoolPtr(true),
CreatedBy: user.ID,
}
err = database.DB.Create(job).Error
require.NoError(t, err)
// Create and initialize the scheduler
scheduler := New(database)
defer scheduler.Stop()
// Create rclone config directory and file
configDir := filepath.Join(tempDir, "configs")
err = os.MkdirAll(configDir, 0755)
require.NoError(t, err)
// Create a minimal rclone config file
rcloneConfig := `
[source_1]
type = local
[dest_1]
type = local
`
configFile := filepath.Join(configDir, "config_1.conf")
err = os.WriteFile(configFile, []byte(rcloneConfig), 0644)
require.NoError(t, err)
t.Logf("Created rclone config file: %s", configFile)
// Manually trigger job execution
t.Logf("Running job now (expecting failure)...")
err = scheduler.RunJobNow(job.ID)
require.NoError(t, err)
// Wait for the job to complete and webhook to be called (up to 15 seconds)
t.Logf("Waiting for webhook to be called with failure notification...")
timeout := time.After(15 * time.Second)
select {
case <-waitCh:
t.Logf("Webhook was called")
case <-timeout:
// Before failing, check job status
var histories []db.JobHistory
err = database.DB.Where("job_id = ?", job.ID).Find(&histories).Error
require.NoError(t, err)
if len(histories) > 0 {
t.Logf("Job history found: status=%s, error=%s",
histories[0].Status, histories[0].ErrorMessage)
} else {
t.Logf("No job history found")
}
webhookMutex.Lock()
called := webhookCalled
webhookMutex.Unlock()
if called {
t.Logf("Webhook was actually called but channel synchronization failed")
} else {
t.Fatal("Timed out waiting for webhook to be called")
}
return
}
// Verify the webhook notification
assert.NotNil(t, receivedPayload, "Webhook notification should have been sent")
// Verify the payload content
var payload map[string]interface{}
err = json.Unmarshal(receivedPayload, &payload)
require.NoError(t, err, "Failed to unmarshal webhook payload")
// Check essential fields
assert.Equal(t, "job_execution", payload["event_type"])
assert.Equal(t, float64(job.ID), payload["job_id"])
assert.Equal(t, "failed", payload["status"])
// Ensure there's an error message
errorMsg, ok := payload["error_message"].(string)
require.True(t, ok, "error_message should be a string")
assert.NotEmpty(t, errorMsg)
t.Logf("Error message from webhook: %s", errorMsg)
// Clean up
err = database.DB.Unscoped().Delete(job).Error
require.NoError(t, err)
err = database.DB.Unscoped().Where("job_id = ?", job.ID).Delete(&db.JobHistory{}).Error
require.NoError(t, err)
}
// TestWebhookDisabledForSuccessNotification tests that webhooks are not sent for
// successful jobs when notify_on_success is disabled
func TestWebhookDisabledForSuccessNotification(t *testing.T) {
// Skip in short mode
if testing.Short() {
t.Skip("Skipping integration test in short mode")
}
// Set up a temporary data directory for logs
tempDir := t.TempDir()
// Set DATA_DIR environment variable for the test
originalDataDir := os.Getenv("DATA_DIR")
t.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: "webhook-disabled@example.com",
PasswordHash: "hashed_password",
IsAdmin: BoolPtr(true),
}
err := database.CreateUser(user)
require.NoError(t, err)
// Set up a mock HTTP server to receive webhook notifications
var (
webhookCalled bool
webhookMutex sync.Mutex
)
mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
webhookMutex.Lock()
defer webhookMutex.Unlock()
// Log the fact that webhook was called (it shouldn't be)
body, _ := io.ReadAll(r.Body)
t.Logf("Unexpected webhook call received: %s", string(body))
webhookCalled = true
w.WriteHeader(http.StatusOK)
}))
defer mockServer.Close()
// Create local source and destination directories
sourceDir := t.TempDir()
destDir := t.TempDir()
// Create a test transfer config with local source and destination
config := &db.TransferConfig{
Name: "Webhook Disabled Config",
SourceType: "local",
SourcePath: sourceDir,
DestinationType: "local",
DestinationPath: destDir,
CreatedBy: user.ID,
}
err = database.DB.Create(config).Error
require.NoError(t, err)
// Create a test job with webhook enabled but notify_on_success disabled
job := &db.Job{
Name: "Webhook Disabled Job",
ConfigID: config.ID,
Schedule: "*/5 * * * *", // not actually used in this test
Enabled: BoolPtr(true),
WebhookEnabled: BoolPtr(true),
WebhookURL: mockServer.URL,
NotifyOnSuccess: BoolPtr(false), // This is the key setting we're testing
NotifyOnFailure: BoolPtr(true),
CreatedBy: user.ID,
}
err = database.DB.Create(job).Error
require.NoError(t, err)
// Update the job to ensure the notification settings are correctly set
// This is necessary because the database has default values for these fields
err = database.DB.Model(job).Updates(map[string]interface{}{
"notify_on_success": false,
}).Error
require.NoError(t, err)
// Reload the job to make sure we have the correct values
var reloadedJob db.Job
err = database.DB.First(&reloadedJob, job.ID).Error
require.NoError(t, err)
job = &reloadedJob
t.Logf("Created job with ID %d, NotifyOnSuccess=%v", job.ID, job.NotifyOnSuccess)
// Create and initialize the scheduler
scheduler := New(database)
defer scheduler.Stop()
// Create rclone config directory and file
configDir := filepath.Join(tempDir, "configs")
err = os.MkdirAll(configDir, 0755)
require.NoError(t, err)
// Create a minimal rclone config file
rcloneConfig := `
[source_1]
type = local
[dest_1]
type = local
`
configFile := filepath.Join(configDir, "config_1.conf")
err = os.WriteFile(configFile, []byte(rcloneConfig), 0644)
require.NoError(t, err)
t.Logf("Created rclone config file: %s", configFile)
// Put a test file in the source directory
testFile := filepath.Join(sourceDir, "test.txt")
testFileContent := []byte("This is a test file for disabled webhook testing.")
err = os.WriteFile(testFile, testFileContent, 0644)
require.NoError(t, err)
// Manually trigger job execution
t.Logf("Running job now...")
err = scheduler.RunJobNow(job.ID)
require.NoError(t, err)
// Wait for a bit to ensure job completes (10 seconds should be plenty)
time.Sleep(10 * time.Second)
// Check if webhook was called (it should not have been)
webhookMutex.Lock()
called := webhookCalled
webhookMutex.Unlock()
assert.False(t, called, "Webhook should not have been called for successful job with NotifyOnSuccess=false")
// Verify the job actually ran successfully by checking for the file
destFile := filepath.Join(destDir, "test.txt")
_, err = os.Stat(destFile)
assert.NoError(t, err, "The job should have completed and transferred the file")
// Verify job history has been created and shows completion
var histories []db.JobHistory
err = database.DB.Where("job_id = ?", job.ID).Find(&histories).Error
require.NoError(t, err)
if len(histories) > 0 {
t.Logf("Job history found: status=%s", histories[0].Status)
assert.Equal(t, "completed", histories[0].Status, "Job should have completed successfully")
}
// Clean up
err = database.DB.Unscoped().Delete(job).Error
require.NoError(t, err)
err = database.DB.Unscoped().Where("job_id = ?", job.ID).Delete(&db.JobHistory{}).Error
require.NoError(t, err)
}
-610
View File
@@ -1,610 +0,0 @@
package scheduler
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"os"
"sync"
"testing"
"time"
"github.com/starfleetcptn/gomft/internal/db"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// TestWebhookNotification tests the webhook notification functionality
func TestWebhookNotification(t *testing.T) {
// Set up a temporary data directory for logs
tempDir := t.TempDir()
// Set DATA_DIR environment variable for the test
originalDataDir := os.Getenv("DATA_DIR")
t.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: "webhook-test@example.com",
PasswordHash: "hashed_password",
IsAdmin: BoolPtr(true),
}
err := database.CreateUser(user)
require.NoError(t, err)
// Create a test transfer config
config := &db.TransferConfig{
Name: "Webhook Test Config",
SourceType: "local",
SourcePath: "/source",
DestinationType: "local",
DestinationPath: "/dest",
CreatedBy: user.ID,
}
err = database.DB.Create(config).Error
require.NoError(t, err)
// Create a mock HTTP server to receive webhook notifications
var (
receivedPayload []byte
receivedHeaders http.Header
webhookCalled bool
webhookMutex sync.Mutex
waitCh chan struct{}
)
mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
webhookMutex.Lock()
defer webhookMutex.Unlock()
receivedHeaders = r.Header.Clone()
var err error
receivedPayload, err = io.ReadAll(r.Body)
if err != nil {
t.Logf("Error reading request body: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
// Debug output to help understand what's happening
t.Logf("Webhook called with payload: %s", string(receivedPayload))
webhookCalled = true
w.WriteHeader(http.StatusOK)
// Signal that webhook was called
if waitCh != nil {
close(waitCh)
}
}))
defer mockServer.Close()
// Create a test scheduler
scheduler := New(database)
defer scheduler.Stop()
// Test cases
tests := []struct {
name string
job *db.Job
history *db.JobHistory
webhookEnabled bool
webhookURL string
webhookSecret string
webhookHeaders map[string]string
notifyOnSuccess bool
notifyOnFailure bool
status string
expectNotification bool
}{
{
name: "Successful job with notification",
job: &db.Job{
Name: "Success Job",
ConfigID: config.ID,
WebhookEnabled: BoolPtr(true),
WebhookURL: mockServer.URL,
NotifyOnSuccess: BoolPtr(true),
NotifyOnFailure: BoolPtr(true),
CreatedBy: user.ID,
},
history: &db.JobHistory{
Status: "completed",
StartTime: time.Now().Add(-5 * time.Minute),
EndTime: timePtr(time.Now()),
BytesTransferred: 1024,
FilesTransferred: 2,
},
webhookEnabled: true,
webhookURL: mockServer.URL,
notifyOnSuccess: true,
notifyOnFailure: true,
status: "completed",
expectNotification: true,
},
{
name: "Failed job with notification",
job: &db.Job{
Name: "Failed Job",
ConfigID: config.ID,
WebhookEnabled: BoolPtr(true),
WebhookURL: mockServer.URL,
NotifyOnSuccess: BoolPtr(true),
NotifyOnFailure: BoolPtr(true),
CreatedBy: user.ID,
},
history: &db.JobHistory{
Status: "failed",
StartTime: time.Now().Add(-5 * time.Minute),
EndTime: timePtr(time.Now()),
ErrorMessage: "Test error message",
},
webhookEnabled: true,
webhookURL: mockServer.URL,
notifyOnSuccess: true,
notifyOnFailure: true,
status: "failed",
expectNotification: true,
},
{
name: "Successful job with notification disabled for success",
job: &db.Job{
Name: "Success Job No Notify",
ConfigID: config.ID,
WebhookEnabled: BoolPtr(true),
WebhookURL: mockServer.URL,
NotifyOnSuccess: BoolPtr(false),
NotifyOnFailure: BoolPtr(true),
CreatedBy: user.ID,
},
history: &db.JobHistory{
Status: "completed",
StartTime: time.Now().Add(-5 * time.Minute),
EndTime: timePtr(time.Now()),
},
webhookEnabled: true,
webhookURL: mockServer.URL,
notifyOnSuccess: false,
notifyOnFailure: true,
status: "completed",
expectNotification: false,
},
{
name: "Failed job with notification disabled for failure",
job: &db.Job{
Name: "Failed Job No Notify",
ConfigID: config.ID,
WebhookEnabled: BoolPtr(true),
WebhookURL: mockServer.URL,
NotifyOnSuccess: BoolPtr(true),
NotifyOnFailure: BoolPtr(false),
CreatedBy: user.ID,
},
history: &db.JobHistory{
Status: "failed",
StartTime: time.Now().Add(-5 * time.Minute),
EndTime: timePtr(time.Now()),
ErrorMessage: "Test error message",
},
webhookEnabled: true,
webhookURL: mockServer.URL,
notifyOnSuccess: true,
notifyOnFailure: false,
status: "failed",
expectNotification: false,
},
{
name: "Webhook disabled",
job: &db.Job{
Name: "Webhook Disabled",
ConfigID: config.ID,
WebhookEnabled: BoolPtr(true),
WebhookURL: mockServer.URL,
NotifyOnSuccess: BoolPtr(true),
NotifyOnFailure: BoolPtr(true),
CreatedBy: user.ID,
},
history: &db.JobHistory{
Status: "completed",
StartTime: time.Now().Add(-5 * time.Minute),
EndTime: timePtr(time.Now()),
},
webhookEnabled: false,
webhookURL: mockServer.URL,
notifyOnSuccess: true,
notifyOnFailure: true,
status: "completed",
expectNotification: false,
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
// Reset received data
webhookMutex.Lock()
receivedPayload = nil
receivedHeaders = nil
webhookCalled = false
waitCh = make(chan struct{})
webhookMutex.Unlock()
// Debug the test case configuration
t.Logf("Test configuration: name=%s, webhookEnabled=%v, notifyOnSuccess=%v, notifyOnFailure=%v, status=%s, expectNotification=%v",
tc.name, tc.webhookEnabled, tc.notifyOnSuccess, tc.notifyOnFailure, tc.status, tc.expectNotification)
// Create a new job instance for each test case
job := &db.Job{
Name: tc.job.Name,
ConfigID: tc.job.ConfigID,
WebhookEnabled: BoolPtr(tc.webhookEnabled),
WebhookURL: tc.webhookURL,
NotifyOnSuccess: BoolPtr(tc.notifyOnSuccess),
NotifyOnFailure: BoolPtr(tc.notifyOnFailure),
CreatedBy: tc.job.CreatedBy,
}
t.Logf("Job before DB create: WebhookEnabled=%v, NotifyOnSuccess=%v, NotifyOnFailure=%v",
job.WebhookEnabled, job.NotifyOnSuccess, job.NotifyOnFailure)
err := database.DB.Create(job).Error
require.NoError(t, err)
// Update the job to ensure the notification settings are correctly set
// This is necessary because the database has default values for these fields
err = database.DB.Model(job).Updates(map[string]interface{}{
"notify_on_success": tc.notifyOnSuccess,
"notify_on_failure": tc.notifyOnFailure,
}).Error
require.NoError(t, err)
// Reload the job to make sure we have the correct values
var reloadedJob db.Job
err = database.DB.First(&reloadedJob, job.ID).Error
require.NoError(t, err)
job = &reloadedJob
t.Logf("Job after DB create: WebhookEnabled=%v, NotifyOnSuccess=%v, NotifyOnFailure=%v",
job.WebhookEnabled, job.NotifyOnSuccess, job.NotifyOnFailure)
// Create and save job history
history := tc.history
history.JobID = job.ID
err = database.DB.Create(history).Error
require.NoError(t, err)
// Debug info
t.Logf("Test case: %s", tc.name)
t.Logf("Job settings: WebhookEnabled=%v, NotifyOnSuccess=%v, NotifyOnFailure=%v",
job.WebhookEnabled, job.NotifyOnSuccess, job.NotifyOnFailure)
t.Logf("History status: %s", history.Status)
// Send webhook notification
scheduler.sendWebhookNotification(job, history, config)
// Wait for webhook call to complete if expected
if tc.expectNotification {
// Wait with timeout for webhook to be called
select {
case <-waitCh:
// Webhook was called
case <-time.After(2 * time.Second):
t.Fatalf("Timed out waiting for webhook to be called")
}
} else {
// Give it a small window to ensure it doesn't call when not expected
time.Sleep(500 * time.Millisecond)
}
// Check if notification was sent as expected
webhookMutex.Lock()
called := webhookCalled
payload := receivedPayload
headers := receivedHeaders
webhookMutex.Unlock()
if tc.expectNotification {
assert.True(t, called, "Expected webhook notification to be sent")
require.NotNil(t, payload, "Expected webhook payload to be non-nil")
// Verify the payload
var payloadMap map[string]interface{}
err := json.Unmarshal(payload, &payloadMap)
require.NoError(t, err, "Failed to unmarshal webhook payload")
// Check common fields
assert.Equal(t, "job_execution", payloadMap["event_type"])
assert.Equal(t, float64(job.ID), payloadMap["job_id"])
assert.Equal(t, job.Name, payloadMap["job_name"])
assert.Equal(t, float64(config.ID), payloadMap["config_id"])
assert.Equal(t, config.Name, payloadMap["config_name"])
assert.Equal(t, history.Status, payloadMap["status"])
// Check headers
assert.Equal(t, "application/json", headers.Get("Content-Type"))
assert.Equal(t, "GoMFT-Webhook/1.0", headers.Get("User-Agent"))
// Additional checks for specific status
if history.Status == "failed" {
assert.Equal(t, history.ErrorMessage, payloadMap["error_message"])
}
} else {
assert.False(t, called, "Expected no webhook notification to be sent")
}
// Clean up
err = database.DB.Unscoped().Delete(history).Error
require.NoError(t, err)
err = database.DB.Unscoped().Delete(job).Error
require.NoError(t, err)
})
}
}
// TestWebhookAuthentication tests the webhook authentication functionality
func TestWebhookAuthentication(t *testing.T) {
// Set up a temporary data directory for logs
tempDir := t.TempDir()
// Set DATA_DIR environment variable for the test
originalDataDir := os.Getenv("DATA_DIR")
t.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: "webhook-auth-test@example.com",
PasswordHash: "hashed_password",
IsAdmin: BoolPtr(true),
}
err := database.CreateUser(user)
require.NoError(t, err)
// Create a test transfer config
config := &db.TransferConfig{
Name: "Webhook Auth Test Config",
SourceType: "local",
SourcePath: "/source",
DestinationType: "local",
DestinationPath: "/dest",
CreatedBy: user.ID,
}
err = database.DB.Create(config).Error
require.NoError(t, err)
// Create a mock HTTP server to receive webhook notifications
var (
receivedPayload []byte
receivedHeaders http.Header
waitCh = make(chan struct{})
)
mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
receivedHeaders = r.Header.Clone()
var err error
receivedPayload, err = io.ReadAll(r.Body)
if err != nil {
t.Logf("Error reading request body: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
close(waitCh)
}))
defer mockServer.Close()
// Create a test scheduler
scheduler := New(database)
defer scheduler.Stop()
// Set up job with webhook secret
secret := "test-webhook-secret"
job := &db.Job{
Name: "Auth Test Job",
ConfigID: config.ID,
WebhookEnabled: BoolPtr(true),
WebhookURL: mockServer.URL,
WebhookSecret: secret,
NotifyOnSuccess: BoolPtr(true),
NotifyOnFailure: BoolPtr(true),
CreatedBy: user.ID,
}
err = database.DB.Create(job).Error
require.NoError(t, err)
// Create job history
history := &db.JobHistory{
JobID: job.ID,
Status: "completed",
StartTime: time.Now().Add(-5 * time.Minute),
EndTime: timePtr(time.Now()),
BytesTransferred: 1024,
FilesTransferred: 2,
}
err = database.DB.Create(history).Error
require.NoError(t, err)
// Send webhook notification
scheduler.sendWebhookNotification(job, history, config)
// Wait for webhook to be called
select {
case <-waitCh:
// Webhook was called
case <-time.After(2 * time.Second):
t.Fatalf("Timed out waiting for webhook to be called")
}
// Verify the signature
require.NotNil(t, receivedPayload, "Expected webhook notification to be sent")
// Check that the X-Hub-Signature-256 header exists
signature := receivedHeaders.Get("X-Hub-Signature-256")
require.NotEmpty(t, signature, "Expected X-Hub-Signature-256 header to be set")
// Verify that the signature matches the expected HMAC-SHA256
h := hmac.New(sha256.New, []byte(secret))
h.Write(receivedPayload)
expectedSignature := hex.EncodeToString(h.Sum(nil))
// Print both signatures for debugging if they don't match
if expectedSignature != signature {
t.Logf("Expected signature: %s", expectedSignature)
t.Logf("Actual signature: %s", signature)
t.Logf("Secret used: %s", secret)
t.Logf("Payload length: %d", len(receivedPayload))
}
assert.Equal(t, expectedSignature, signature, "Signature does not match expected value")
// Clean up
err = database.DB.Unscoped().Delete(history).Error
require.NoError(t, err)
err = database.DB.Unscoped().Delete(job).Error
require.NoError(t, err)
}
// TestWebhookCustomHeaders tests the custom headers functionality for webhooks
func TestWebhookCustomHeaders(t *testing.T) {
// Set up a temporary data directory for logs
tempDir := t.TempDir()
// Set DATA_DIR environment variable for the test
originalDataDir := os.Getenv("DATA_DIR")
t.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: "webhook-headers-test@example.com",
PasswordHash: "hashed_password",
IsAdmin: BoolPtr(true),
}
err := database.CreateUser(user)
require.NoError(t, err)
// Create a test transfer config
config := &db.TransferConfig{
Name: "Webhook Headers Test Config",
SourceType: "local",
SourcePath: "/source",
DestinationType: "local",
DestinationPath: "/dest",
CreatedBy: user.ID,
}
err = database.DB.Create(config).Error
require.NoError(t, err)
// Create a mock HTTP server to receive webhook notifications
var (
receivedPayload []byte
receivedHeaders http.Header
waitCh = make(chan struct{})
)
mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
receivedHeaders = r.Header.Clone()
var err error
receivedPayload, err = io.ReadAll(r.Body)
if err != nil {
t.Logf("Error reading request body: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
close(waitCh)
}))
defer mockServer.Close()
// Create a test scheduler
scheduler := New(database)
defer scheduler.Stop()
// Define custom headers
customHeaders := map[string]string{
"X-API-Key": "test-api-key",
"X-Client-ID": "test-client-id",
"X-Source": "gomft-test",
}
customHeadersJSON, err := json.Marshal(customHeaders)
require.NoError(t, err)
// Set up job with custom headers
job := &db.Job{
Name: "Custom Headers Test Job",
ConfigID: config.ID,
WebhookEnabled: BoolPtr(true),
WebhookURL: mockServer.URL,
WebhookHeaders: string(customHeadersJSON),
NotifyOnSuccess: BoolPtr(true),
NotifyOnFailure: BoolPtr(true),
CreatedBy: user.ID,
}
err = database.DB.Create(job).Error
require.NoError(t, err)
// Create job history
history := &db.JobHistory{
JobID: job.ID,
Status: "completed",
StartTime: time.Now().Add(-5 * time.Minute),
EndTime: timePtr(time.Now()),
BytesTransferred: 1024,
FilesTransferred: 2,
}
err = database.DB.Create(history).Error
require.NoError(t, err)
// Send webhook notification
scheduler.sendWebhookNotification(job, history, config)
// Wait for webhook to be called
select {
case <-waitCh:
// Webhook was called
case <-time.After(2 * time.Second):
t.Fatalf("Timed out waiting for webhook to be called")
}
// Verify the headers
require.NotNil(t, receivedPayload, "Expected webhook notification to be sent")
// Check that all custom headers are present
for key, value := range customHeaders {
actualValue := receivedHeaders.Get(key)
if actualValue != value {
t.Logf("Custom header mismatch for %s: expected=%s, got=%s", key, value, actualValue)
}
assert.Equal(t, value, actualValue, "Expected custom header %s to be set", key)
}
// Also check standard headers
assert.Equal(t, "application/json", receivedHeaders.Get("Content-Type"))
assert.Equal(t, "GoMFT-Webhook/1.0", receivedHeaders.Get("User-Agent"))
// Clean up
err = database.DB.Unscoped().Delete(history).Error
require.NoError(t, err)
err = database.DB.Unscoped().Delete(job).Error
require.NoError(t, err)
}
// Helper function to create a pointer to a time.Time value
func timePtr(t time.Time) *time.Time {
return &t
}