bebe/bamort
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup unused code

Browse Source
This commit is contained in:
Frank
2025-07-29 10:51:03 +02:00
parent f178a14e24
commit 74cc552c24
7 changed files with 36 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/api/api_test.go
+2 -3
View File
@@ -190,7 +190,7 @@ func TestCreateCharacter(t *testing.T) {
}
func TestGetSkillCost(t *testing.T) {
database.SetupTestDB(false)
database.SetupTestDB() //(false)
// Initialize a Gin router
r := gin.Default()
router.SetupGin(r)
@@ -248,8 +248,7 @@ func TestGetSkillCost(t *testing.T) {
}
func TestGetSkillAllLevelCosts(t *testing.T) {
database.SetupTestDB(true, true) // Use true to load test data
//database.SetupTestDB(false)
database.SetupTestDB() //(true, true) // Use true to load test data
// Initialize a Gin router
r := gin.Default()
router.SetupGin(r)
backend/database/testhelper.go
+21 -113
View File
@@ -1,34 +1,16 @@
package database
import (
"fmt"
"io"
"os"
"path/filepath"
"gorm.io/driver/mysql"
"gorm.io/driver/sqlite"
"gorm.io/gorm"
)
var migrationDone bool
var isTestDb bool
// testDataLoader is a callback function that can be set to load test data
var testDataLoader func(*gorm.DB) error
// migrationCallback is a callback function that can be set to migrate all structures
var migrationCallback func(*gorm.DB) error
// SetTestDataLoader sets the function to load test data
func SetTestDataLoader(loader func(*gorm.DB) error) {
testDataLoader = loader
}
// SetMigrationCallback sets the function to migrate all structures
func SetMigrationCallback(migrator func(*gorm.DB) error) {
migrationCallback = migrator
}
var testdbTempDir string
// copyFile copies a file from src to dst
func copyFile(src, dst string) error {
@@ -48,121 +30,47 @@ func copyFile(src, dst string) error {
return err
}
// LoadCopyOfPredefinedTestData loads predefined test data from a specific file into the provided database
func LoadCopyOfPredefinedTestData(targetDB *gorm.DB, dataFile string) error {
// Check if file exists
if _, err := os.Stat(dataFile); os.IsNotExist(err) {
return fmt.Errorf("predefined test data file not found: %s", dataFile)
}
testpath := filepath.Join(filepath.Dir(dataFile), "tmp_test_data.db")
if _, err := os.Stat(testpath); os.IsExist(err) {
os.Remove(testpath) // delete existing test data file
}
copyFile(dataFile, testpath)
targetDB, err := gorm.Open(sqlite.Open(testpath), &gorm.Config{})
if err != nil {
return fmt.Errorf("failed to open temporary test database: %w", err)
}
DB = targetDB
return nil
}
// The Database for testing is created from the live database whenever needed and stored in the path defined in database.PreparedTestDB
// to use the test database make a temporary copy of it and then open this new copy as testing database
// This allows to have a clean database for each test run without affecting the live database
// However SetupTestDB can still open the live database if required by setting isTestDb to false
// SetupTestDB creates an in-memory SQLite database for testing
// Parameters:
// - opts[0]: isTestDb (bool) - whether to use in-memory SQLite (true) or persistent MariaDB (false)
// - opts[1]: loadTestData (bool) - whether to load predefined test data from file
// - opts[0]: isTestDb (bool) - whether to use precopied SQLite (true) or persistent (Live) MariaDB (false)
func SetupTestDB(opts ...bool) {
isTestDb = true
loadTestData := false
if len(opts) > 0 {
isTestDb = opts[0]
}
if len(opts) > 1 {
loadTestData = opts[1]
}
if DB == nil {
var db *gorm.DB
var err error
if isTestDb {
//*
db, err = gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
testdbTempDir, err := os.MkdirTemp("", "bamort-test-")
if err != nil {
panic("failed to connect to the test database")
panic("failed to create temporary directory: " + err.Error())
}
//*/
targetFile := filepath.Join(testdbTempDir, "test_backup.db")
err = copyFile(PreparedTestDB, targetFile)
if err != nil {
panic("failed to copy prepared test database: " + err.Error())
}
db, err = gorm.Open(sqlite.Open(targetFile), &gorm.Config{})
if err != nil {
panic("failed to connect to the test database: " + err.Error())
}
defer os.RemoveAll(testdbTempDir)
} else {
//* //testing with persistent MariaDB
dsn := os.Getenv("TEST_DB_DSN")
if dsn == "" {
dsn = "bamort:password@tcp(localhost:3306)/bamort_test?charset=utf8mb4&parseTime=True&loc=Local"
}
db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})
if err != nil {
//panic("failed to connect to the live database")
// noch ein versuch mit der lokalen SQLite-Datenbank
testDataPath := filepath.Join("..", "testdata", "test_data.db")
// Check if test_data.db exists, if not try to copy from predefined_test_data.db
if _, err := os.Stat(testDataPath); os.IsNotExist(err) {
predefinedPath := filepath.Join("..", "testdata", "prepared_test_data.db")
if _, err := os.Stat(predefinedPath); err == nil {
// Create directory if it doesn't exist
if mkdirErr := os.MkdirAll(filepath.Dir(testDataPath), 0755); mkdirErr != nil {
panic("failed to create testdata directory: " + mkdirErr.Error())
}
// Copy predefined_test_data.db to test_data.db
if copyErr := copyFile(predefinedPath, testDataPath); copyErr != nil {
panic("failed to copy predefined test data: " + copyErr.Error())
}
}
}
db, err = gorm.Open(sqlite.Open(testDataPath), &gorm.Config{})
}
if err != nil {
db = ConnectDatabase()
if db == nil {
panic("failed to connect to the live database")
}
//*/
migrationDone = true
}
DB = db
}
// If loadTestData is requested and we have an in-memory database
if loadTestData && isTestDb && DB != nil {
// First migrate the structures using callback if available
if migrationCallback != nil {
err := migrationCallback(DB)
if err != nil {
panic("failed to migrate all structures for test data loading: " + err.Error())
}
} else {
// Fallback to basic migration
err := MigrateStructure()
if err != nil {
panic("failed to MigrateStructure for test data loading: " + err.Error())
}
}
// Load test data using maintenance function
// We need to import the maintenance package, but to avoid circular imports,
// we'll create a callback mechanism
if testDataLoader != nil {
err := testDataLoader(DB)
if err != nil {
panic("failed to load test data: " + err.Error())
}
} else if isTestDb {
// If no test data loader is set, we can still use the default test data loading
err := LoadCopyOfPredefinedTestData(DB, "../testdata/prepared_test_data.db")
if err != nil {
panic("failed to load predefined test data: " + err.Error())
}
}
migrationDone = true
}
}
func ResetTestDB() {
if isTestDb {
@@ -170,7 +78,7 @@ func ResetTestDB() {
if err == nil {
sqlDB.Close()
DB = nil
migrationDone = false
os.RemoveAll(testdbTempDir)
}
}
}
backend/doc/transformation_db.md
+9
View File
@@ -0,0 +1,9 @@
transformiere die Struktur von LearningCostsTable2 so so das die Daten in einer Datenbank verwaltet werden können. Normalisiere die Tabellen soweit sinnvoll.
Beachte das Charakterklassen einen Code(Hx) und einen Namen Hexer haben.
Beachte das Fertigkeiten in mehreren Katagorien enthalten sein können und das die Fetigkeiten je nach Kategorie eine unterschiedliche Schwierigkeit aufweisen können was zu unterschiedlichen Lernkosten führen kann.
Erstelle nur die neue Struktur, erstelle keine Inhalte
erstelle eine Funktion die den Inhalt der bestehenden learningCostsData Variablen in die Datenbank überträgt
Erstelle eine Funktion die die Daten der neuen Tabellen mit denen der schon zuvor vorhandenen Tabellen ergänzt
backend/example_second_db_migration.go
-100
View File
@@ -1,100 +0,0 @@
package main
import (
"bamort/database"
"bamort/models"
"bamort/user"
"fmt"
"gorm.io/driver/sqlite"
"gorm.io/gorm"
)
func main() {
// Beispiel 1: Verwende die Standard-Datenbank (wie bisher)
fmt.Println("=== Standard Datenbank Migration ===")
err := user.MigrateStructure()
if err != nil {
fmt.Printf("Fehler bei Standard-Migration: %v\n", err)
return
}
fmt.Println("Standard-Migration erfolgreich")
// Beispiel 2: Verwende eine zweite Datenbank
fmt.Println("\n=== Zweite Datenbank Migration ===")
// Erstelle eine zweite Datenbankverbindung
secondDB, err := gorm.Open(sqlite.Open("second_database.db"), &gorm.Config{})
if err != nil {
fmt.Printf("Fehler beim Öffnen der zweiten DB: %v\n", err)
return
}
// Migriere alle Packages zur zweiten Datenbank
err = database.MigrateStructure(secondDB)
if err != nil {
fmt.Printf("Fehler bei database Migration: %v\n", err)
return
}
err = user.MigrateStructure(secondDB)
if err != nil {
fmt.Printf("Fehler bei user Migration: %v\n", err)
return
}
/*err = character.MigrateStructure(secondDB)
if err != nil {
fmt.Printf("Fehler bei character Migration: %v\n", err)
return
}*/
err = models.MigrateStructure(secondDB)
if err != nil {
fmt.Printf("Fehler bei models Migration: %v\n", err)
return
}
/*err = equipment.MigrateStructure(secondDB)
if err != nil {
fmt.Printf("Fehler bei equipment Migration: %v\n", err)
return
}
err = skills.MigrateStructure(secondDB)
if err != nil {
fmt.Printf("Fehler bei skills Migration: %v\n", err)
return
}
*/
fmt.Println("Migration zur zweiten Datenbank erfolgreich")
// Beispiel 3: Helper-Funktion für komplette Migration
fmt.Println("\n=== Helper Funktion Beispiel ===")
err = migrateAllToSecondDB(secondDB)
if err != nil {
fmt.Printf("Fehler bei kompletter Migration: %v\n", err)
return
}
fmt.Println("Komplette Migration erfolgreich")
}
// Helper-Funktion für komplette Migration zu einer spezifischen Datenbank
func migrateAllToSecondDB(db *gorm.DB) error {
migrators := []func(db ...*gorm.DB) error{
database.MigrateStructure,
user.MigrateStructure,
//character.MigrateStructure,
models.MigrateStructure,
//equipment.MigrateStructure,
//skills.MigrateStructure,
}
for _, migrate := range migrators {
if err := migrate(db); err != nil {
return fmt.Errorf("migration failed: %w", err)
}
}
return nil
}
backend/integration_test/getspellinfo_test.go
+1 -4
View File
@@ -9,12 +9,9 @@ import (
// TestGetSpellInfoIntegration tests the GetSpellInfo function with full database integration
func TestGetSpellInfoIntegration(t *testing.T) {
// The maintenance package init() already sets up:
// database.SetTestDataLoader(LoadPredefinedTestDataFromFile)
// database.SetMigrationCallback(migrateAllStructures)
// Initialize test database with test data loading
database.SetupTestDB(true, true) // Use in-memory SQLite with test data
database.SetupTestDB(true) // Use in-memory SQLite with test data
defer database.ResetTestDB()
// Test with real spell names that should exist in the prepared test database
backend/maintenance/api_maint_test.go
+3 -3
View File
@@ -39,7 +39,7 @@ func TestMaintSetupCheck(t *testing.T) {
}
func TestGetMasterData(t *testing.T) {
database.SetupTestDB(false)
database.SetupTestDB() //(false)
// Initialize a Gin router
r := gin.Default()
router.SetupGin(r)
@@ -83,7 +83,7 @@ func TestGetMasterData(t *testing.T) {
}
func TestGetMDSkillCategories(t *testing.T) {
database.SetupTestDB(false)
database.SetupTestDB() //(false)
ski := models.Skill{}
categories, err := ski.GetSkillCategories()
@@ -93,7 +93,7 @@ func TestGetMDSkillCategories(t *testing.T) {
}
func TestGetMDSkills(t *testing.T) {
database.SetupTestDB(false)
database.SetupTestDB() //(false)
// Initialize a Gin router
r := gin.Default()
router.SetupGin(r)
backend/maintenance/handlers.go
-9
View File
@@ -22,15 +22,6 @@ var (
preparedTestDB = database.PreparedTestDB
)
// init function to register the test data loader and migration callback
// This callback mechanism is necessary to avoid circular imports between database and maintenance packages
func init() {
database.SetTestDataLoader(func(targetDB *gorm.DB) error {
return LoadPredefinedTestDataFromFile(targetDB, preparedTestDB)
})
database.SetMigrationCallback(migrateAllStructures)
}
func respondWithError(c *gin.Context, status int, message string) {
c.JSON(status, gin.H{"error": message})
}