155 lines
4.0 KiB
Go
155 lines
4.0 KiB
Go
package transfer
|
|
|
|
import (
|
|
"bamort/config"
|
|
"bamort/database"
|
|
"bamort/models"
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
func setupTestDB(t *testing.T) *gorm.DB {
|
|
database.SetupTestDB(true, true)
|
|
models.MigrateStructure()
|
|
/*
|
|
t.Cleanup(func() {
|
|
database.ResetTestDB()
|
|
})
|
|
*/
|
|
return database.DB
|
|
}
|
|
|
|
func TestExportDatabase_Success(t *testing.T) {
|
|
//setupTestEnvironment(t)
|
|
db := setupTestDB(t)
|
|
if db.Error != nil {
|
|
t.Fatalf("Failed to setup test DB: %v", db.Error)
|
|
}
|
|
|
|
// Create temporary export directory
|
|
exportDir := t.TempDir()
|
|
config.LoadConfig()
|
|
exportDir = config.Cfg.ExportTempDir
|
|
|
|
// Export database
|
|
result, err := ExportDatabase(exportDir)
|
|
|
|
// Assertions
|
|
require.NoError(t, err, "ExportDatabase should succeed")
|
|
assert.NotNil(t, result, "Result should not be nil")
|
|
assert.NotEmpty(t, result.Filename, "Filename should be set")
|
|
assert.NotEmpty(t, result.FilePath, "FilePath should be set")
|
|
assert.True(t, result.RecordCount > 0, "Should export some records")
|
|
|
|
// Verify file exists
|
|
assert.FileExists(t, result.FilePath, "Export file should exist")
|
|
|
|
// Verify file is valid JSON
|
|
data, err := os.ReadFile(result.FilePath)
|
|
require.NoError(t, err, "Should be able to read export file")
|
|
|
|
var export DatabaseExport
|
|
err = json.Unmarshal(data, &export)
|
|
require.NoError(t, err, "Export file should be valid JSON")
|
|
}
|
|
|
|
func TestExportDatabase_InvalidDirectory(t *testing.T) {
|
|
//setupTestEnvironment(t)
|
|
db := setupTestDB(t)
|
|
if db.Error != nil {
|
|
t.Fatalf("Failed to setup test DB: %v", db.Error)
|
|
}
|
|
|
|
// Try to export to non-existent directory
|
|
result, err := ExportDatabase("/invalid/path/that/does/not/exist")
|
|
|
|
assert.Error(t, err, "Should fail with invalid directory")
|
|
assert.Nil(t, result, "Result should be nil on error")
|
|
}
|
|
|
|
func TestImportDatabase_Success(t *testing.T) {
|
|
//setupTestEnvironment(t)
|
|
db := setupTestDB(t)
|
|
if db.Error != nil {
|
|
t.Fatalf("Failed to setup test DB: %v", db.Error)
|
|
}
|
|
|
|
// First export database
|
|
exportDir := t.TempDir()
|
|
exportResult, err := ExportDatabase(exportDir)
|
|
require.NoError(t, err, "Export should succeed")
|
|
|
|
// Clear database
|
|
db.Exec("DELETE FROM characters")
|
|
db.Exec("DELETE FROM users")
|
|
|
|
// Import database
|
|
result, err := ImportDatabase(exportResult.FilePath)
|
|
|
|
// Assertions
|
|
require.NoError(t, err, "ImportDatabase should succeed")
|
|
assert.NotNil(t, result, "Result should not be nil")
|
|
assert.True(t, result.RecordCount > 0, "Should import some records")
|
|
}
|
|
|
|
func TestImportDatabase_FileNotFound(t *testing.T) {
|
|
//setupTestEnvironment(t)
|
|
db := setupTestDB(t)
|
|
if db.Error != nil {
|
|
t.Fatalf("Failed to setup test DB: %v", db.Error)
|
|
}
|
|
|
|
result, err := ImportDatabase("/nonexistent/file.json")
|
|
|
|
assert.Error(t, err, "Should fail with non-existent file")
|
|
assert.Nil(t, result, "Result should be nil on error")
|
|
}
|
|
|
|
func TestImportDatabase_InvalidJSON(t *testing.T) {
|
|
//setupTestEnvironment(t)
|
|
db := setupTestDB(t)
|
|
if db.Error != nil {
|
|
t.Fatalf("Failed to setup test DB: %v", db.Error)
|
|
}
|
|
|
|
// Create invalid JSON file
|
|
tmpFile := filepath.Join(t.TempDir(), "invalid.json")
|
|
err := os.WriteFile(tmpFile, []byte("invalid json content"), 0644)
|
|
require.NoError(t, err)
|
|
|
|
result, err := ImportDatabase(tmpFile)
|
|
|
|
assert.Error(t, err, "Should fail with invalid JSON")
|
|
assert.Nil(t, result, "Result should be nil on error")
|
|
}
|
|
|
|
func TestExportImportRoundtrip(t *testing.T) {
|
|
//setupTestEnvironment(t)
|
|
db := setupTestDB(t)
|
|
if db.Error != nil {
|
|
t.Fatalf("Failed to setup test DB: %v", db.Error)
|
|
}
|
|
|
|
exportDir := t.TempDir()
|
|
|
|
// Export
|
|
exportResult, err := ExportDatabase(exportDir)
|
|
require.NoError(t, err, "Export should succeed")
|
|
|
|
originalCount := exportResult.RecordCount
|
|
|
|
// Import
|
|
importResult, err := ImportDatabase(exportResult.FilePath)
|
|
require.NoError(t, err, "Import should succeed")
|
|
|
|
// Record counts should match
|
|
assert.Equal(t, originalCount, importResult.RecordCount,
|
|
"Import should restore same number of records")
|
|
}
|