New test TestCalculateSpellLearnCostNewSystem in chain of learning system
This commit is contained in:
@@ -1,118 +1,55 @@
|
||||
package gsmaster
|
||||
|
||||
//Diese Tests hier sind SCHROTT denn sie testen statisch erzeugt Strukturen und nicht die Abfrage aus der DB wie erhofft
|
||||
/*
|
||||
// Test for exported GetAvailableSkillCategories function
|
||||
func TestGetAvailableSkillCategories(t *testing.T) {
|
||||
testCases := []struct {
|
||||
skillName string
|
||||
expectedCount int
|
||||
description string
|
||||
checkFirst bool
|
||||
firstCategory string
|
||||
}{
|
||||
{"Menschenkenntnis", 2, "Menschenkenntnis should have two categories (Sozial, Unterwelt)", true, "Sozial"},
|
||||
{"Stichwaffen", 1, "Stichwaffen should have one category", true, "Waffen"},
|
||||
{"Geländelauf", 1, "Geländelauf should have one category", true, "Körper"},
|
||||
{"NonExistentSkill", 1, "Unknown skill should have default category", true, "Alltag"},
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"bamort/database"
|
||||
"bamort/models"
|
||||
)
|
||||
|
||||
func TestGetClassAbbreviationNewSystem(t *testing.T) {
|
||||
setupTestEnvironment(t)
|
||||
|
||||
database.SetupTestDB(true)
|
||||
defer database.ResetTestDB()
|
||||
|
||||
defaultGS := GetGameSystem(1, "")
|
||||
|
||||
source := models.Source{Code: "TST", Name: "Test Source", FullName: "Test Source", GameSystem: defaultGS.Name, GameSystemId: defaultGS.ID}
|
||||
if err := database.DB.Create(&source).Error; err != nil {
|
||||
t.Fatalf("failed to create source: %v", err)
|
||||
}
|
||||
|
||||
for _, tc := range testCases {
|
||||
t.Run(tc.description, func(t *testing.T) {
|
||||
result := GetAvailableSkillCategories(tc.skillName)
|
||||
assert.Equal(t, tc.expectedCount, len(result), tc.description)
|
||||
defaultClass := models.CharacterClass{Code: "TC", Name: "Test Class", SourceID: source.ID, GameSystem: defaultGS.Name, GameSystemId: defaultGS.ID}
|
||||
if err := database.DB.Create(&defaultClass).Error; err != nil {
|
||||
t.Fatalf("failed to create default game system class: %v", err)
|
||||
}
|
||||
|
||||
if tc.checkFirst && len(result) > 0 {
|
||||
assert.Equal(t, tc.firstCategory, result[0].Category,
|
||||
fmt.Sprintf("First category for %s should be %s", tc.skillName, tc.firstCategory))
|
||||
altGS := models.GameSystem{Code: "ALT", Name: "Alternate"}
|
||||
if err := database.DB.Create(&altGS).Error; err != nil {
|
||||
t.Fatalf("failed to create alternate game system: %v", err)
|
||||
}
|
||||
|
||||
altClass := models.CharacterClass{Code: "AC", Name: "Alternate Class", SourceID: source.ID, GameSystem: altGS.Name, GameSystemId: altGS.ID}
|
||||
if err := database.DB.Create(&altClass).Error; err != nil {
|
||||
t.Fatalf("failed to create alternate game system class: %v", err)
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
input string
|
||||
expected string
|
||||
}{
|
||||
{name: "returns code for existing class", input: defaultClass.Name, expected: defaultClass.Code},
|
||||
{name: "returns empty for unknown class", input: "Unknown Class", expected: ""},
|
||||
{name: "returns empty for class in other game system", input: altClass.Name, expected: ""},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if result := GetClassAbbreviationNewSystem(tt.input); result != tt.expected {
|
||||
t.Fatalf("GetClassAbbreviationNewSystem(%q) = %q, want %q", tt.input, result, tt.expected)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Test for exported GetDefaultCategory function
|
||||
func TestGetDefaultCategory(t *testing.T) {
|
||||
testCases := []struct {
|
||||
skillName string
|
||||
expectedCategory string
|
||||
description string
|
||||
}{
|
||||
{"Menschenkenntnis", "Sozial", "Should return Sozial for Menschenkenntnis"},
|
||||
{"Stichwaffen", "Waffen", "Should return Waffen for Stichwaffen"},
|
||||
{"Geländelauf", "Körper", "Should return Körper for Geländelauf"},
|
||||
{"Sprache", "Alltag", "Should return Alltag for Sprache"},
|
||||
{"NonExistentSkill", "Alltag", "Should return default Alltag for unknown skill"},
|
||||
}
|
||||
|
||||
for _, tc := range testCases {
|
||||
t.Run(tc.description, func(t *testing.T) {
|
||||
result := GetDefaultCategory(tc.skillName)
|
||||
assert.Equal(t, tc.expectedCategory, result, tc.description)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Test for exported GetDefaultDifficulty function
|
||||
func TestGetDefaultDifficulty(t *testing.T) {
|
||||
testCases := []struct {
|
||||
skillName string
|
||||
expectedDifficulty string
|
||||
description string
|
||||
}{
|
||||
{"Menschenkenntnis", "schwer", "Should return schwer for Menschenkenntnis"},
|
||||
{"Stichwaffen", "leicht", "Should return leicht for Stichwaffen"},
|
||||
{"Geländelauf", "leicht", "Should return leicht for Geländelauf"},
|
||||
{"Sprache", "normal", "Should return normal for Sprache"},
|
||||
{"NonExistentSkill", "normal", "Should return default normal for unknown skill"},
|
||||
}
|
||||
|
||||
for _, tc := range testCases {
|
||||
t.Run(tc.description, func(t *testing.T) {
|
||||
result := GetDefaultDifficulty(tc.skillName)
|
||||
assert.Equal(t, tc.expectedDifficulty, result, tc.description)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCalculateDetailedSkillLearningCostForHexer(t *testing.T) {
|
||||
// Testfall, der direkt mit den exportierten Funktionen arbeitet
|
||||
t.Run("Lernkosten für Menschenkenntnis als Hexer", func(t *testing.T) {
|
||||
// Verwendung der exportierten Funktion CalculateDetailedSkillLearningCost
|
||||
result, err := CalculateDetailedSkillLearningCost("Menschenkenntnis", "Hexer")
|
||||
assert.NoError(t, err, "CalculateDetailedSkillLearningCost sollte keinen Fehler zurückgeben")
|
||||
assert.NotNil(t, result, "Ergebnis sollte nicht nil sein")
|
||||
|
||||
fmt.Printf("Lernkosten für Menschenkenntnis als Hexer:\n")
|
||||
fmt.Printf("Lerneinheiten (LE): %d\n", result.LE)
|
||||
fmt.Printf("Erfahrungspunkte (EP): %d\n", result.Ep)
|
||||
fmt.Printf("Geldkosten (GS): %d\n", result.Money)
|
||||
|
||||
// Test der erwarteten Werte basierend auf aktueller Implementierung
|
||||
// Menschenkenntnis ist Sozial/schwer: 4 LE
|
||||
// Hexer EP-Kosten für Sozial: 20 EP/TE
|
||||
// Money-Kosten: 20 GS/LE
|
||||
assert.Equal(t, 4, result.LE, "LE-Kosten für Menschenkenntnis (Sozial/schwer) sollten 4 sein")
|
||||
assert.Equal(t, 80, result.Ep, "EP-Kosten sollten 80 sein (4 LE * 20 EP)")
|
||||
assert.Equal(t, 80, result.Money, "Geldkosten sollten 80 GS sein (4 LE * 20 GS)")
|
||||
})
|
||||
|
||||
t.Run("Verbesserungskosten für Menschenkenntnis als Hexer", func(t *testing.T) {
|
||||
// Verwendung der exportierten Funktion CalculateDetailedSkillImprovementCost
|
||||
currentLevel := 10
|
||||
result, err := CalculateDetailedSkillImprovementCost("Menschenkenntnis", "Hexer", currentLevel)
|
||||
assert.NoError(t, err, "CalculateDetailedSkillImprovementCost sollte keinen Fehler zurückgeben")
|
||||
assert.NotNil(t, result, "Ergebnis sollte nicht nil sein")
|
||||
|
||||
fmt.Printf("\nVerbesserungskosten für Menschenkenntnis als Hexer (von %d auf %d):\n", currentLevel, currentLevel+1)
|
||||
fmt.Printf("Zielstufe: %d\n", result.Stufe) // This appears to be the target level
|
||||
fmt.Printf("Erfahrungspunkte (EP): %d\n", result.Ep)
|
||||
fmt.Printf("Geldkosten (GS): %d\n", result.Money)
|
||||
|
||||
// Test der erwarteten Werte basierend auf aktueller Implementierung
|
||||
// Result.Stufe appears to be target level (11), not training units needed
|
||||
assert.Equal(t, 11, result.Stufe, "Zielstufe sollte 11 sein (von 10 auf 11)")
|
||||
assert.Equal(t, 80, result.Ep, "EP-Kosten sollten 80 sein")
|
||||
assert.Equal(t, 80, result.Money, "Geldkosten sollten 80 GS sein")
|
||||
})
|
||||
}
|
||||
*/
|
||||
|
||||
Reference in New Issue
Block a user