311 lines
9.0 KiB
Go
311 lines
9.0 KiB
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)
|
|
|
|
// 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.DB = nil
|
|
database.SetupTestDB()
|
|
// Initialize a Gin router
|
|
r := gin.Default()
|
|
router.SetupGin(r)
|
|
|
|
// Routes
|
|
protected := router.BaseRouterGrp(r)
|
|
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{}
|
|
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)
|
|
|
|
ski := models.Skill{}
|
|
categories, err := ski.GetSkillCategories()
|
|
assert.NoError(t, err)
|
|
assert.LessOrEqual(t, 1, len(categories))
|
|
assert.Equal(t, "Wissen", categories[0])
|
|
}
|
|
|
|
func TestGetMDSkills(t *testing.T) {
|
|
database.SetupTestDB() //(false)
|
|
// 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) {
|
|
// Setup proper test database
|
|
database.SetupTestDB(true)
|
|
|
|
// 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)
|
|
|
|
// 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
|
|
}
|