bamort/backend/maintenance/api_maint_test.go

package maintenance

import (
	"bamort/character"
	"bamort/database"
	"bamort/gsmaster"
	"bamort/models"
	"bamort/router"
	"bamort/user"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"path/filepath"
	"testing"

	"github.com/gin-gonic/gin"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

func TestMaintSetupCheck(t *testing.T) {
	// Setup proper test database
	database.SetupTestDB(true)
	t.Cleanup(database.ResetTestDB)

	// Create a proper HTTP test context
	gin.SetMode(gin.TestMode)
	w := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(w)

	// Call the handler
	SetupCheck(c)

	// Check the response
	assert.Equal(t, http.StatusOK, w.Code)

	// Parse the JSON response
	var response map[string]string
	err := json.Unmarshal(w.Body.Bytes(), &response)
	assert.NoError(t, err)
	assert.Equal(t, "Setup Check OK", response["message"])
}

func TestGetMasterData(t *testing.T) {
	// Ensure fresh database connection
	database.ResetTestDB()
	database.SetupTestDB()
	t.Cleanup(database.ResetTestDB)
	// Initialize a Gin router
	r := gin.Default()
	router.SetupGin(r)

	// Routes
	protected := router.BaseRouterGrp(r)
	character.RegisterRoutes(protected)
	gsmaster.RegisterRoutes(protected)
	RegisterRoutes(protected)
	protected.GET("/test", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"status": "Test OK"})
	})
	u := user.User{}
	err := u.FirstId(1)
	require.NoError(t, err, "Failed to load user with ID 1")
	require.Equal(t, "admin", u.Role, "User 1 should be admin")

	// Create a test HTTP request
	req, _ := http.NewRequest("GET", "/api/maintenance", nil)
	req.Header.Set("Content-Type", "application/json")
	token := user.GenerateToken(&u)
	req.Header.Set("Authorization", "Bearer "+token)

	// Create a response recorder to capture the handler's response
	respRecorder := httptest.NewRecorder()

	// Perform the test request
	r.ServeHTTP(respRecorder, req)

	// Assert the response status code
	assert.Equal(t, http.StatusOK, respRecorder.Code)

	// Assert the response body
	type dtaStruct struct {
		Skills       []models.Skill       `json:"skills"`
		Weaponskills []models.WeaponSkill `json:"weaponskills"`
		Spell        []models.Spell       `json:"spells"`
		Equipment    []models.Equipment   `json:"equipment"`
		Weapons      []models.Weapon      `json:"weapons"`
	}
	var dta dtaStruct
	errUnmarshal := json.Unmarshal(respRecorder.Body.Bytes(), &dta)
	assert.NoError(t, errUnmarshal)
}

func TestGetMDSkillCategories(t *testing.T) {
	database.SetupTestDB() //(false)
	t.Cleanup(database.ResetTestDB)

	ski := models.Skill{}
	categories, err := ski.GetSkillCategories()
	assert.NoError(t, err)
	assert.GreaterOrEqual(t, len(categories), 1, "Should have at least one skill category")
	// Check that categories come from learning_skill_categories table
	assert.Contains(t, categories, "Alltag", "Should contain 'Alltag' category")
	assert.Contains(t, categories, "Wissen", "Should contain 'Wissen' category")
	assert.Contains(t, categories, "Kampf", "Should contain 'Kampf' category")
	assert.Contains(t, categories, "Schilde und Parierwaffen", "Should contain 'Schilde und Parierwaffen' category")
}

func TestGetMDSkills(t *testing.T) {
	database.SetupTestDB() //(false)
	t.Cleanup(database.ResetTestDB)
	// Initialize a Gin router
	r := gin.Default()
	router.SetupGin(r)

	// Routes
	protected := router.BaseRouterGrp(r)

	// Character routes
	character.RegisterRoutes(protected)
	gsmaster.RegisterRoutes(protected)
	protected.GET("/test", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"status": "Test OK"})
	})
	u := user.User{}
	u.FirstId(1)

	// Create a test HTTP request
	req, _ := http.NewRequest("GET", "/api/characters/20", nil)
	//req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Content-Type", "application/json")
	//req.Header.Set("Authorization", "Bearer ${token}")
	req.Header.Set("Authorization", "Bearer dc7a780.1:bba7f4daabda117f2a2c14263")

	// Create a response recorder to capture the handler's response
	respRecorder := httptest.NewRecorder()

	// Perform the test request
	r.ServeHTTP(respRecorder, req)

	// Assert the response status code
	assert.Equal(t, http.StatusOK, respRecorder.Code)

	// Assert the response body
	var listOfCharacter *models.Char
	err := json.Unmarshal(respRecorder.Body.Bytes(), &listOfCharacter)
	assert.NoError(t, err)
	assert.Equal(t, "Harsk Hammerhuter, Zen", listOfCharacter.Name)
	assert.Equal(t, "Zwerg", listOfCharacter.Rasse)
	assert.Equal(t, 20, int(listOfCharacter.ID)) // Check the simulated ID
	assert.Equal(t, "Krieger", listOfCharacter.Typ)
	assert.Equal(t, 3, listOfCharacter.Grad)
	//assert.Equal(t, "test", listOfCharacter.Owner)
	//assert.Equal(t, false, listOfCharacter.Public)

}

func TestMaintMakeTestdataFromLive(t *testing.T) {
	// Redirect the output to a temporary file so the snapshot is never overwritten.
	tmpDir := t.TempDir()
	tmpDB := filepath.Join(tmpDir, "test_live_copy.db")
	original := preparedTestDB
	preparedTestDB = tmpDB
	t.Cleanup(func() { preparedTestDB = original })

	// Setup proper test database
	database.SetupTestDB(true)
	t.Cleanup(database.ResetTestDB)

	// Create a proper HTTP test context
	gin.SetMode(gin.TestMode)
	w := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(w)

	// Call the handler
	MakeTestdataFromLive(c)

	// Check the response
	assert.Equal(t, http.StatusOK, w.Code)

	// Parse the JSON response
	var response map[string]interface{}
	err := json.Unmarshal(w.Body.Bytes(), &response)
	assert.NoError(t, err)
	assert.Equal(t, "Live database copied to file successfully", response["message"])
	assert.Contains(t, response, "test_data_file")
}

func TestMaintReconnectDataBase(t *testing.T) {
	// Create a proper HTTP test context
	gin.SetMode(gin.TestMode)
	w := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(w)

	// Call the handler
	ReconnectDataBase(c)

	// Check the response
	assert.Equal(t, http.StatusOK, w.Code)

	// Parse the JSON response
	var response map[string]string
	err := json.Unmarshal(w.Body.Bytes(), &response)
	assert.NoError(t, err)
	assert.Equal(t, "Database reconnected successfully", response["message"])
}

func TestMaintReloadENV(t *testing.T) {
	// Create a proper HTTP test context
	gin.SetMode(gin.TestMode)
	w := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(w)

	// Call the handler
	ReloadENV(c)

	// Check the response
	assert.Equal(t, http.StatusOK, w.Code)

	// Parse the JSON response
	var response map[string]string
	err := json.Unmarshal(w.Body.Bytes(), &response)
	assert.NoError(t, err)
	assert.Equal(t, "Environment variables reloaded successfully", response["message"])
}

func TestMaintLoadPredefinedTestData(t *testing.T) {
	// Setup proper test database
	database.SetupTestDB(true)
	t.Cleanup(database.ResetTestDB)

	// Create a proper HTTP test context
	gin.SetMode(gin.TestMode)
	w := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(w)

	// Call the handler
	LoadPredefinedTestData(c)

	// The function should always attempt to load data, but may return different status codes
	// based on whether the predefined test data file exists and is accessible
	if w.Code == http.StatusOK {
		// Parse the JSON response for success case
		var response map[string]interface{}
		err := json.Unmarshal(w.Body.Bytes(), &response)
		assert.NoError(t, err)
		assert.Equal(t, "Predefined test data loaded successfully into in-memory database", response["message"])
		assert.Contains(t, response, "test_data_file")
		assert.Contains(t, response, "statistics")
	} else {
		// Check that it fails gracefully if no test data file exists or other issues
		// Could be 404 (file not found), 500 (internal server error), etc.
		assert.True(t, w.Code >= 400, "Should return an error status code when predefined data is not available")

		// Verify error response structure
		var response map[string]interface{}
		err := json.Unmarshal(w.Body.Bytes(), &response)
		if err == nil {
			// If we can parse JSON, check for error field
			assert.Contains(t, response, "error")
		}
		// If we can't parse JSON, that's also acceptable for some error cases
	}
}

func TestLoadPredefinedTestDataFromFile(t *testing.T) {
	// Create a temporary test database file
	tempDir := t.TempDir()
	testDataFile := filepath.Join(tempDir, "test_data.db")

	// Create a simple test database with some data
	sourceDB, err := gorm.Open(sqlite.Open(testDataFile), &gorm.Config{})
	require.NoError(t, err, "Should create test database file")

	// Migrate basic structures
	err = sourceDB.AutoMigrate(&user.User{})
	require.NoError(t, err, "Should migrate structures")

	// Add test data
	testUser := &user.User{
		UserID:       1,
		Username:     "testuser",
		Email:        "test@example.com",
		PasswordHash: "hash",
	}
	err = sourceDB.Create(testUser).Error
	require.NoError(t, err, "Should create test user")

	// Close the source database
	if sqlDB, err := sourceDB.DB(); err == nil {
		sqlDB.Close()
	}

	// Create target in-memory database
	targetDB, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	require.NoError(t, err, "Should create target database")
	defer func() {
		if sqlDB, err := targetDB.DB(); err == nil {
			sqlDB.Close()
		}
	}()

	// Test the function
	err = LoadPredefinedTestDataFromFile(targetDB, testDataFile)
	assert.NoError(t, err, "LoadPredefinedTestDataFromFile should succeed")

	// Verify data was loaded
	var userCount int64
	err = targetDB.Model(&user.User{}).Count(&userCount).Error
	assert.NoError(t, err, "Should be able to count users")
	assert.Equal(t, int64(1), userCount, "Should have loaded the test user")
}

func TestMaintTransferSQLiteToMariaDB(t *testing.T) {
	// Skip this test if we don't have MariaDB available
	// This test would typically be an integration test
	t.Skip("Skipping TransferSQLiteToMariaDB test - requires MariaDB setup")

	// Note: This test would need:
	// 1. A real MariaDB instance running
	// 2. Proper test data setup in SQLite source
	// 3. Verification of data transfer
	//
	// For unit testing, this would be better tested by testing the
	// individual components like copySQLiteToMariaDB function separately
}