Handle Weaponskill Categories like Skill categories.

got categories from wrong source
fix some tests

backend/character/derived_values_calculator.go

@@ -102,12 +102,12 @@ func CalculateStaticFieldsLogic(req CalculateStaticFieldsRequest) StaticFieldsRe
 	}
 
 	// Finale Resistenzwerte (mit Gradbonus)
-	response.ResistenzKoerper = getResistenzBaseByGrade(grad) // + response.ResistenzBonusKoerper
+	response.ResistenzKoerper = getResistenzBaseByGrade(grad) + response.ResistenzBonusKoerper
-	response.ResistenzGeist = getResistenzBaseByGrade(grad)   //+ response.ResistenzBonusGeist
+	response.ResistenzGeist = getResistenzBaseByGrade(grad) + response.ResistenzBonusGeist
 
 	// Finale Kampfwerte (mit Gradbonus)
-	response.Abwehr = getAbwehrBaseByGrade(grad)   //+ response.AbwehrBonus
+	response.Abwehr = getAbwehrBaseByGrade(grad) + response.AbwehrBonus
-	response.Zaubern = getZaubernBaseByGrade(grad) //+ response.ZauberBonus
+	response.Zaubern = getZaubernBaseByGrade(grad) + response.ZauberBonus
 
 	// Raufen: (St + GW)/20 + angriffs_bonus + Rassenboni
 	raceBonus := 0
@@ -376,11 +376,11 @@ func isZauberer(typ string) bool {
 // getRaceModifierLP gibt den LP-Modifikator für eine Rasse zurück
 func getRaceModifierLP(rasse string) int {
 	switch rasse {
-	case "Gnome":
+	case "Gnom":
 		return -3
-	case "Halblinge":
+	case "Halbling":
 		return -2
-	case "Zwerge":
+	case "Zwerg":
 		return 1
 	default:
 		return 0
@@ -402,11 +402,11 @@ func getClassModifierAP(typ string) int {
 // getMovementBaseAndFormula gibt den Basiswert und die Formel für Bewegung zurück
 func getMovementBaseAndFormula(rasse string) (int, string) {
 	switch rasse {
-	case "Gnome", "Halblinge":
+	case "Gnom", "Halbling":
 		return 8, "2d3 + 8"
-	case "Zwerge":
+	case "Zwerg":
 		return 12, "3d3 + 12"
-	default: // Menschen, Elfen
+	default: // Mensch, Elf
 		return 16, "4d3 + 16"
 	}
 }

backend/character/derived_values_calculator_test.go

@@ -23,10 +23,10 @@ func TestCalculateStaticFields_Success(t *testing.T) {
 		expected StaticFieldsResponse
 	}{
 		{
-			name: "Menschen Krieger",
+			name: "Mensch Krieger",
 			request: CalculateStaticFieldsRequest{
 				St: 70, Gs: 60, Gw: 65, Ko: 75, In: 50, Zt: 30, Au: 55,
-				Rasse: "Menschen", Typ: "Krieger",
+				Rasse: "Mensch", Typ: "Krieger",
 			},
 			expected: StaticFieldsResponse{
 				AusdauerBonus:         10, // (75/10) + (70/20) = 7 + 3 = 10
@@ -34,8 +34,8 @@ func TestCalculateStaticFields_Success(t *testing.T) {
 				AngriffsBonus:         0,  // GS 60 -> 0
 				AbwehrBonus:           0,  // GW 65 -> 0
 				ZauberBonus:           0,  // ZT 30 -> 0 (21-80 range)
-				ResistenzBonusKoerper: 1,  // Menschen: Ko-Bonus (0) + Kämpfer (+1) = 1
+				ResistenzBonusKoerper: 1,  // Mensch: Ko-Bonus (0) + Kämpfer (+1) = 1
-				ResistenzBonusGeist:   0,  // Menschen: In-Bonus (0) + kein Zauberer = 0
+				ResistenzBonusGeist:   0,  // Mensch: In-Bonus (0) + kein Zauberer = 0
 				ResistenzKoerper:      12, // 11 + 1
 				ResistenzGeist:        11, // 11 + 0
 				Abwehr:                11, // 11 + 0
@@ -44,10 +44,10 @@ func TestCalculateStaticFields_Success(t *testing.T) {
 			},
 		},
 		{
-			name: "Elfen Magier",
+			name: "Elf Magier",
 			request: CalculateStaticFieldsRequest{
 				St: 45, Gs: 70, Gw: 80, Ko: 60, In: 90, Zt: 85, Au: 85,
-				Rasse: "Elfen", Typ: "Magier",
+				Rasse: "Elf", Typ: "Magier",
 			},
 			expected: StaticFieldsResponse{
 				AusdauerBonus:         8,  // (60/10) + (45/20) = 6 + 2 = 8
@@ -55,8 +55,8 @@ func TestCalculateStaticFields_Success(t *testing.T) {
 				AngriffsBonus:         0,  // GS 70 -> 0
 				AbwehrBonus:           0,  // GW 80 -> 0
 				ZauberBonus:           1,  // ZT 85 -> +1
-				ResistenzBonusKoerper: 4,  // Elfen: +2, Zauberer: +2 = 4
+				ResistenzBonusKoerper: 4,  // Elf: +2, Zauberer: +2 = 4
-				ResistenzBonusGeist:   4,  // Elfen: +2, Zauberer: +2 = 4
+				ResistenzBonusGeist:   4,  // Elf: +2, Zauberer: +2 = 4
 				ResistenzKoerper:      15, // 11 + 4
 				ResistenzGeist:        15, // 11 + 4
 				Abwehr:                11, // 11 + 0
@@ -65,10 +65,10 @@ func TestCalculateStaticFields_Success(t *testing.T) {
 			},
 		},
 		{
-			name: "Zwerge Barbar",
+			name: "Zwerg Barbar",
 			request: CalculateStaticFieldsRequest{
 				St: 85, Gs: 45, Gw: 50, Ko: 90, In: 40, Zt: 20, Au: 35,
-				Rasse: "Zwerge", Typ: "Barbar",
+				Rasse: "Zwerg", Typ: "Barbar",
 			},
 			expected: StaticFieldsResponse{
 				AusdauerBonus:         13, // (90/10) + (85/20) = 9 + 4 = 13
@@ -76,13 +76,13 @@ func TestCalculateStaticFields_Success(t *testing.T) {
 				AngriffsBonus:         0,  // GS 45 -> 0 (21-80 range)
 				AbwehrBonus:           0,  // GW 50 -> 0 (21-80 range)
 				ZauberBonus:           -1, // ZT 20 -> -1 (6-20 range)
-				ResistenzBonusKoerper: 4,  // Zwerge: +3, Kämpfer: +1 = 4
+				ResistenzBonusKoerper: 4,  // Zwerg: +3, Kämpfer: +1 = 4
-				ResistenzBonusGeist:   3,  // Zwerge: +3, kein Zauberer = 3
+				ResistenzBonusGeist:   3,  // Zwerg: +3, kein Zauberer = 3
 				ResistenzKoerper:      15, // 11 + 4
 				ResistenzGeist:        14, // 11 + 3
 				Abwehr:                11, // 11 + 0
 				Zaubern:               10, // 11 + (-1)
-				Raufen:                7,  // (85+50)/20 + 0 + 1(Zwerge) = 6 + 0 + 1 = 7
+				Raufen:                7,  // (85+50)/20 + 0 + 1(Zwerg) = 6 + 0 + 1 = 7
 			},
 		},
 	}
@@ -103,7 +103,7 @@ func TestCalculateStaticFields_Success(t *testing.T) {
 			require.NoError(t, err)
 
 			// Korrigiere die erwarteten Werte falls nötig
-			if tt.name == "Elfen Magier" {
+			if tt.name == "Elf Magier" {
 				tt.expected.SchadensBonus = 1 // Korrektur: (45/20) + (70/30) - 3 = 2 + 2 - 3 = 1
 			}
 
@@ -142,7 +142,7 @@ func TestCalculateStaticFields_InvalidRequest(t *testing.T) {
 				"in":    50,
 				"zt":    30,
 				"au":    55,
-				"rasse": "Menschen",
+				"rasse": "Mensch",
 				"typ":   "Krieger",
 			},
 		},
@@ -150,14 +150,14 @@ func TestCalculateStaticFields_InvalidRequest(t *testing.T) {
 			name: "Attribut zu hoch",
 			request: CalculateStaticFieldsRequest{
 				St: 150, Gs: 60, Gw: 65, Ko: 75, In: 50, Zt: 30, Au: 55,
-				Rasse: "Menschen", Typ: "Krieger",
+				Rasse: "Mensch", Typ: "Krieger",
 			},
 		},
 		{
 			name: "Attribut zu niedrig",
 			request: CalculateStaticFieldsRequest{
 				St: 0, Gs: 60, Gw: 65, Ko: 75, In: 50, Zt: 30, Au: 55,
-				Rasse: "Menschen", Typ: "Krieger",
+				Rasse: "Mensch", Typ: "Krieger",
 			},
 		},
 	}
@@ -183,7 +183,7 @@ func TestCalculateRolledField_PA(t *testing.T) {
 
 	request := CalculateRolledFieldRequest{
 		St: 70, Gs: 60, Gw: 65, Ko: 75, In: 50, Zt: 30, Au: 55,
-		Rasse: "Menschen", Typ: "Krieger",
+		Rasse: "Mensch", Typ: "Krieger",
 		Field: "pa",
 		Roll:  float64(55),
 	}
@@ -220,7 +220,7 @@ func TestCalculateRolledField_WK(t *testing.T) {
 
 	request := CalculateRolledFieldRequest{
 		St: 70, Gs: 60, Gw: 65, Ko: 75, In: 50, Zt: 30, Au: 55,
-		Rasse: "Menschen", Typ: "Krieger",
+		Rasse: "Mensch", Typ: "Krieger",
 		Field: "wk",
 		Roll:  float64(45),
 	}
@@ -256,9 +256,9 @@ func TestCalculateRolledField_LPMax(t *testing.T) {
 		ko       int
 		expected int
 	}{
-		{"Menschen", "Menschen", 2, 75, 16}, // 2 + 7 + 7 + 0 = 16
+		{"Mensch", "Mensch", 2, 75, 16}, // 2 + 7 + 7 + 0 = 16
-		{"Gnome", "Gnome", 3, 60, 4},        // 3 + 7 + 6 + (-3) = 13
+		{"Gnom", "Gnom", 3, 60, 4},      // 3 + 7 + 6 + (-3) = 13
-		{"Zwerge", "Zwerge", 1, 80, 16},     // 1 + 7 + 8 + 1 = 17
+		{"Zwerg", "Zwerg", 1, 80, 16},   // 1 + 7 + 8 + 1 = 17
 	}
 
 	for _, tt := range tests {
@@ -286,11 +286,11 @@ func TestCalculateRolledField_LPMax(t *testing.T) {
 			// Korrigiere erwartete Werte
 			expectedValue := int(tt.roll) + 7 + (tt.ko / 10)
 			switch tt.rasse {
-			case "Gnome":
+			case "Gnom":
 				expectedValue -= 3
-			case "Halblinge":
+			case "Halbling":
 				expectedValue -= 2
-			case "Zwerge":
+			case "Zwerg":
 				expectedValue += 1
 			}
 
@@ -323,7 +323,7 @@ func TestCalculateRolledField_APMax(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			request := CalculateRolledFieldRequest{
 				St: 70, Gs: 60, Gw: 65, Ko: 75, In: 50, Zt: 30, Au: 55,
-				Rasse: "Menschen", Typ: tt.typ,
+				Rasse: "Mensch", Typ: tt.typ,
 				Field: "ap_max",
 				Roll:  float64(2),
 			}
@@ -360,11 +360,11 @@ func TestCalculateRolledField_BMax(t *testing.T) {
 		baseVal int
 		formula string
 	}{
-		{"Menschen", "Menschen", []interface{}{2.0, 1.0, 3.0, 2.0}, 16, "4d3 + 16"},
+		{"Mensch", "Mensch", []interface{}{2.0, 1.0, 3.0, 2.0}, 16, "4d3 + 16"},
-		{"Elfen", "Elfen", []interface{}{2.0, 1.0, 3.0, 2.0}, 16, "4d3 + 16"},
+		{"Elf", "Elf", []interface{}{2.0, 1.0, 3.0, 2.0}, 16, "4d3 + 16"},
-		{"Gnome", "Gnome", []interface{}{3.0, 1.0}, 8, "2d3 + 8"},
+		{"Gnom", "Gnom", []interface{}{3.0, 1.0}, 8, "2d3 + 8"},
-		{"Halblinge", "Halblinge", []interface{}{2.0, 3.0}, 8, "2d3 + 8"},
+		{"Halbling", "Halbling", []interface{}{2.0, 3.0}, 8, "2d3 + 8"},
-		{"Zwerge", "Zwerge", []interface{}{1.0, 2.0, 3.0}, 12, "3d3 + 12"},
+		{"Zwerg", "Zwerg", []interface{}{1.0, 2.0, 3.0}, 12, "3d3 + 12"},
 	}
 
 	for _, tt := range tests {
@@ -409,7 +409,7 @@ func TestCalculateRolledField_InvalidField(t *testing.T) {
 
 	request := CalculateRolledFieldRequest{
 		St: 70, Gs: 60, Gw: 65, Ko: 75, In: 50, Zt: 30, Au: 55,
-		Rasse: "Menschen", Typ: "Krieger",
+		Rasse: "Mensch", Typ: "Krieger",
 		Field: "invalid_field",
 		Roll:  float64(50),
 	}
@@ -431,7 +431,7 @@ func TestCalculateRolledField_InvalidRoll(t *testing.T) {
 
 	request := CalculateRolledFieldRequest{
 		St: 70, Gs: 60, Gw: 65, Ko: 75, In: 50, Zt: 30, Au: 55,
-		Rasse: "Menschen", Typ: "Krieger",
+		Rasse: "Mensch", Typ: "Krieger",
 		Field: "pa",
 		Roll:  "invalid_roll", // String statt Zahl
 	}

backend/character/derived_values_grade_test.go

@@ -158,7 +158,7 @@ func TestCalculateStaticFieldsLogic_WithGrade(t *testing.T) {
 				In:    50,
 				Zt:    50,
 				Au:    50,
-				Rasse: "Menschen",
+				Rasse: "Mensch",
 				Typ:   "Krieger",
 				Grad:  tt.grad,
 			}

backend/character/derived_values_test.go

@@ -116,7 +116,7 @@ func TestCalculateBonuses(t *testing.T) {
 
 	t.Run("Calculate bonuses for Zwerg Kämpfer", func(t *testing.T) {
 		char := models.Char{
-			Rasse: "Zwerge",
+			Rasse: "Zwerg",
 			Typ:   "Krieger",
 			Eigenschaften: []models.Eigenschaft{
 				{Name: "Ko", Value: 85},
@@ -126,16 +126,16 @@ func TestCalculateBonuses(t *testing.T) {
 
 		bonuses := char.CalculateBonuses()
 
-		// Zwerge get +3 base, Kämpfer +1 = 4
+		// Zwerg get +3 base, Kämpfer +1 = 4
-		assert.Equal(t, 4, bonuses.ResistenzBonusKoerper, "Zwerge Kämpfer ResistenzBonusKoerper should be 4")
+		assert.Equal(t, 4, bonuses.ResistenzBonusKoerper, "Zwerg Kämpfer ResistenzBonusKoerper should be 4")
 
-		// Zwerge get +3 base
+		// Zwerg get +3 base
-		assert.Equal(t, 3, bonuses.ResistenzBonusGeist, "Zwerge ResistenzBonusGeist should be 3")
+		assert.Equal(t, 3, bonuses.ResistenzBonusGeist, "Zwerg ResistenzBonusGeist should be 3")
 	})
 
 	t.Run("Calculate bonuses for Elf Magier", func(t *testing.T) {
 		char := models.Char{
-			Rasse: "Elfen",
+			Rasse: "Elf",
 			Typ:   "Magier",
 			Eigenschaften: []models.Eigenschaft{
 				{Name: "Ko", Value: 50},
@@ -145,10 +145,10 @@ func TestCalculateBonuses(t *testing.T) {
 
 		bonuses := char.CalculateBonuses()
 
-		// Elfen get +2 base, Magier (Zauberer) +2 = 4
+		// Elf get +2 base, Magier (Zauberer) +2 = 4
-		assert.Equal(t, 4, bonuses.ResistenzBonusKoerper, "Elfen Magier ResistenzBonusKoerper should be 4")
+		assert.Equal(t, 4, bonuses.ResistenzBonusKoerper, "Elf Magier ResistenzBonusKoerper should be 4")
 
-		// Elfen get +2 base, Magier (Zauberer) +2 = 4
+		// Elf get +2 base, Magier (Zauberer) +2 = 4
-		assert.Equal(t, 4, bonuses.ResistenzBonusGeist, "Elfen Magier ResistenzBonusGeist should be 4")
+		assert.Equal(t, 4, bonuses.ResistenzBonusGeist, "Elf Magier ResistenzBonusGeist should be 4")
 	})
 }

backend/character/handlers.go

@@ -2979,16 +2979,6 @@ func GetCharacterClasses(c *gin.Context) {
 		classNames = append(classNames, class.Name)
 	}
 
-	// If no classes found in database, fall back to hardcoded list
-	if len(classNames) == 0 {
-		classNames = []string{
-			"Assassine", "Barbar", "Barde",
-			"Heiler", "Händler", "Kämpfer", "Krieger",
-			"Magier", "Ordenskrieger", "Priester Beschützer", "Schamane", "Skalde",
-			"Magister", "Thaumaturg", "Waldläufer", "Zauberer",
-		}
-	}
-
 	c.JSON(http.StatusOK, gin.H{"classes": classNames})
 }
 
@@ -3030,18 +3020,6 @@ func SearchBeliefs(c *gin.Context) {
 		allBeliefs = append(allBeliefs, belief.Name)
 	}
 
-	// If no beliefs found in database, fall back to hardcoded list
-	if len(allBeliefs) == 0 {
-		allBeliefs = []string{
-			"Apshai", "Arthusos", "Beschützer", "Dwyllas", "Elfen",
-			"Fruchtbarkeitsgöttin", "Gaia", "Grafschafter", "Heiler",
-			"Jäger", "Kämpfer", "Lichbringer", "Meeresherr", "Natur",
-			"Ostküste", "Priester", "Rechtschaffener", "Schutzpatron",
-			"Stammesgeist", "Totengott", "Unterwelt", "Vater", "Weisheit",
-			"Xan", "Ylhoon", "Zauberer",
-		}
-	}
-
 	var results []string
 	queryLower := strings.ToLower(query)
 	for _, belief := range allBeliefs {

backend/config/config_test.go

@@ -55,6 +55,9 @@ QUOTED_VALUE='single quotes'
 	os.Unsetenv("DATABASE_URL")
 	os.Unsetenv("QUOTED_VALUE")
 
+	// Load the test env file
+	loadEnvFileContent(".env.test")
+
 	// Tests
 	tests := []struct {
 		key      string
@@ -146,7 +149,7 @@ func TestLoadConfigWithEnvFile(t *testing.T) {
 	envContent := `ENVIRONMENT=development
 DEBUG=true
 LOG_LEVEL=DEBUG
-PORT=7777
+SERVER_PORT=7777
 DATABASE_URL=test://localhost/testdb`
 
 	// Temporäre .env-Datei erstellen
@@ -161,7 +164,7 @@ DATABASE_URL=test://localhost/testdb`
 		"ENVIRONMENT":  os.Getenv("ENVIRONMENT"),
 		"DEBUG":        os.Getenv("DEBUG"),
 		"LOG_LEVEL":    os.Getenv("LOG_LEVEL"),
-		"PORT":         os.Getenv("PORT"),
+		"SERVER_PORT":  os.Getenv("SERVER_PORT"),
 		"DATABASE_URL": os.Getenv("DATABASE_URL"),
 	}
 

backend/gsmaster/gsm_model_test.go

@@ -330,33 +330,22 @@ func TestSkill_Delete(t *testing.T) {
 
 func TestSkill_GetSkillCategories(t *testing.T) {
 	database.SetupTestDB()
-	// Create test skills with different categories
+	// Create test skill categories in the lookup table
-	testSkills := []*models.Skill{
+	// Note: GetSkillCategories() reads from gsm_skill_categories table, not from skills
+	testCategories := []*models.SkillCategory{
 		{
-			Name:       "Skill1",
+			Name:       "Category1",
 			GameSystem: "midgard",
-			Category:   "Category1",
 		},
 		{
-			Name:       "Skill2",
+			Name:       "Category2",
 			GameSystem: "midgard",
-			Category:   "Category2",
-		},
-		{
-			Name:       "Skill3",
-			GameSystem: "midgard",
-			Category:   "Category1", // Duplicate category
-		},
-		{
-			Name:       "Skill4",
-			GameSystem: "midgard",
-			Category:   "", // Empty category
 		},
 	}
 
-	// Create test data
+	// Create test categories in the lookup table
-	for _, skill := range testSkills {
+	for _, cat := range testCategories {
-		err := skill.Create()
+		err := cat.Create()
 		assert.NoError(t, err)
 	}
 
@@ -368,8 +357,8 @@ func TestSkill_GetSkillCategories(t *testing.T) {
 	}{
 		{
 			name:                "get categories",
-			expectedMinCount:    3,
+			expectedMinCount:    2,
-			expectedMustContain: []string{"Category1", "Category2", ""},
+			expectedMustContain: []string{"Category1", "Category2"},
 			wantErr:             false,
 		},
 	}

backend/importer/importJSON2ImportStruct_test.go

@@ -298,8 +298,8 @@ func TestImportSpell2GSMaster(t *testing.T) {
 	assert.GreaterOrEqual(t, int(skill.ID), 1)
 	assert.Equal(t, "midgard", skill.GameSystem)
 	assert.Equal(t, "Angst", skill.Name)
-	assert.Equal(t, "macht Angst", skill.Beschreibung)
+	assert.Equal(t, "", skill.Beschreibung)
-	assert.Equal(t, "ARK5 63", skill.Quelle)
+	assert.Equal(t, "ARK", skill.Quelle)
 	assert.Equal(t, 2, skill.Stufe)
 	assert.Equal(t, "2 je Wesen", skill.AP)
 	assert.Equal(t, "Geist", skill.Wirkungsziel)

backend/models/model_character.go

@@ -379,15 +379,15 @@ func calculateAttributeBonus(value int) int {
 func calculateResistenzBonusKoerper(ko int, rasse string, typ string) int {
 	bonus := 0
 
-	if rasse == "Mensch" || rasse == "Menschen" {
+	if rasse == "Mensch" {
 		bonus = calculateAttributeBonus(ko)
 	} else {
 		switch rasse {
-		case "Elfen":
+		case "Elf":
 			bonus = 2
-		case "Gnome", "Halblinge":
+		case "Gnom", "Halbling":
 			bonus = 4
-		case "Zwerge":
+		case "Zwerg":
 			bonus = 3
 		}
 	}
@@ -409,11 +409,11 @@ func calculateResistenzBonusGeist(in int, rasse string, typ string) int {
 		bonus = calculateAttributeBonus(in)
 	} else {
 		switch rasse {
-		case "Elfen":
+		case "Elf":
 			bonus = 2
-		case "Gnome", "Halblinge":
+		case "Gnom", "Halbling":
 			bonus = 4
-		case "Zwerge":
+		case "Zwerg":
 			bonus = 3
 		}
 	}

backend/models/model_gsmaster_test.go

@@ -286,19 +286,24 @@ func TestSkill_Select(t *testing.T) {
 func TestSkill_GetSkillCategories(t *testing.T) {
 	setupGSMasterTestDB(t)
 
-	// Create test skills with different categories
+	// Create test skill categories in the lookup table
-	skill1 := createTestGSMSkill("TestCategorySkill1")
+	cat1 := &SkillCategory{
-	skill1.Category = "TestCategory1"
+		GameSystem: "midgard",
-	err := skill1.Create()
+		Name:       "TestCategory1",
+	}
+	err := cat1.Create()
 	require.NoError(t, err)
 
-	skill2 := createTestGSMSkill("TestCategorySkill2")
+	cat2 := &SkillCategory{
-	skill2.Category = "TestCategory2"
+		GameSystem: "midgard",
-	err = skill2.Create()
+		Name:       "TestCategory2",
+	}
+	err = cat2.Create()
 	require.NoError(t, err)
 
 	// Test GetSkillCategories
-	categories, err := skill1.GetSkillCategories()
+	skill := &Skill{}
+	categories, err := skill.GetSkillCategories()
 
 	assert.NoError(t, err)
 	assert.Contains(t, categories, "TestCategory1")
@@ -523,19 +528,24 @@ func TestSpell_Save(t *testing.T) {
 func TestSpell_GetSpellCategories(t *testing.T) {
 	setupGSMasterTestDB(t)
 
-	// Create test spells with different categories
+	// Create test spell categories in the lookup table (SpellSchool)
-	spell1 := createTestSpell("TestSpellCategory1")
+	school1 := &SpellSchool{
-	spell1.Category = "TestSpellCat1"
+		GameSystem: "midgard",
-	err := spell1.Create()
+		Name:       "TestSpellCat1",
+	}
+	err := school1.Create()
 	require.NoError(t, err)
 
-	spell2 := createTestSpell("TestSpellCategory2")
+	school2 := &SpellSchool{
-	spell2.Category = "TestSpellCat2"
+		GameSystem: "midgard",
-	err = spell2.Create()
+		Name:       "TestSpellCat2",
+	}
+	err = school2.Create()
 	require.NoError(t, err)
 
 	// Test GetSpellCategories
-	categories, err := spell1.GetSpellCategories()
+	spell := &Spell{}
+	categories, err := spell.GetSpellCategories()
 
 	assert.NoError(t, err)
 	assert.Contains(t, categories, "TestSpellCat1")

backend/models/model_learning_costs_test.go

@@ -528,7 +528,7 @@ func TestLearningCostsWorkflow_CompleteDataValidation(t *testing.T) {
 	assert.Equal(t, "leicht", skillInfo.DifficultyName)
 	assert.Equal(t, "Bb", skillInfo.ClassCode)
 	assert.Equal(t, 10, skillInfo.EPPerTE, "EP per TE should match the class/category cost")
-	assert.Equal(t, 1, skillInfo.LearnCost, "Learn cost should be 1 for leicht difficulty")
+	assert.Equal(t, 5, skillInfo.LearnCost, "Learn cost should be 5 for leicht difficulty")
 
 	// 3. Verify active source codes include expected values
 	sourceCodes, err := GetActiveSourceCodes()

backend/pdfrender/mapper_test.go

@@ -248,11 +248,18 @@ func TestMapCharacterToViewModel_Weapons(t *testing.T) {
 		t.Fatalf("Expected no error, got %v", err)
 	}
 
-	if len(vm.Weapons) != 1 {
+	// Expect 2 weapons: Raufen (always first) + Langschwert
-		t.Fatalf("Expected 1 weapon, got %d", len(vm.Weapons))
+	if len(vm.Weapons) != 2 {
+		t.Fatalf("Expected 2 weapons (Raufen + Langschwert), got %d", len(vm.Weapons))
 	}
 
-	weapon := vm.Weapons[0]
+	// Check first weapon is Raufen
+	if vm.Weapons[0].Name != "Raufen" {
+		t.Errorf("Expected first weapon to be 'Raufen', got '%s'", vm.Weapons[0].Name)
+	}
+
+	// Check second weapon is Langschwert
+	weapon := vm.Weapons[1]
 	if weapon.Name != "Langschwert" {
 		t.Errorf("Expected weapon name 'Langschwert', got '%s'", weapon.Name)
 	}

backend/pdfrender/todo_fixes_test.go

@@ -193,11 +193,24 @@ func TestWeaponsWithEW(t *testing.T) {
 	}
 
 	// Weapons should contain equipped weapons with EW from skill
-	if len(viewModel.Weapons) == 0 {
+	// Note: Raufen is always added as first weapon
-		t.Fatal("Expected weapons from equipped Waffen, got none")
+	if len(viewModel.Weapons) < 2 {
+		t.Fatalf("Expected at least 2 weapons (Raufen + Schwert), got %d", len(viewModel.Weapons))
+	}
+
+	// Find the Schwert weapon (not Raufen)
+	var weapon *WeaponViewModel
+	for i := range viewModel.Weapons {
+		if viewModel.Weapons[i].Name == "Schwert" {
+			weapon = &viewModel.Weapons[i]
+			break
+		}
+	}
+
+	if weapon == nil {
+		t.Fatal("Schwert not found in weapons list")
 	}
 
-	weapon := viewModel.Weapons[0]
 	if weapon.Name != "Schwert" {
 		t.Errorf("Expected weapon name 'Schwert', got '%s'", weapon.Name)
 	}

backend/pdfrender/weapon_mapper_test.go

@@ -98,12 +98,18 @@ func TestMapWeapons_WithEWCalculation(t *testing.T) {
 		t.Fatalf("Expected no error, got %v", err)
 	}
 
-	if len(vm.Weapons) != 2 {
+	// Expect 3 weapons: Raufen + Langschwert + Langbogen
-		t.Fatalf("Expected 2 weapons, got %d", len(vm.Weapons))
+	if len(vm.Weapons) != 3 {
+		t.Fatalf("Expected 3 weapons (Raufen + 2 equipped), got %d", len(vm.Weapons))
 	}
 
-	// Test Langschwert
+	// Check first weapon is Raufen
-	sword := vm.Weapons[0]
+	if vm.Weapons[0].Name != "Raufen" {
+		t.Errorf("Expected first weapon to be 'Raufen', got '%s'", vm.Weapons[0].Name)
+	}
+
+	// Test Langschwert (index 1)
+	sword := vm.Weapons[1]
 	if sword.Name != "Langschwert" {
 		t.Errorf("Expected weapon name 'Langschwert', got '%s'", sword.Name)
 	}
@@ -115,8 +121,8 @@ func TestMapWeapons_WithEWCalculation(t *testing.T) {
 		t.Errorf("Expected sword EW >= 14 (skill 12 + weapon bonus 2), got %d", sword.Value)
 	}
 
-	// Test Langbogen
+	// Test Langbogen (index 2)
-	bow := vm.Weapons[1]
+	bow := vm.Weapons[2]
 	if bow.Name != "Langbogen" {
 		t.Errorf("Expected weapon name 'Langbogen', got '%s'", bow.Name)
 	}
@@ -188,11 +194,13 @@ func TestMapWeapons_WithDamageCalculation(t *testing.T) {
 		t.Fatalf("Expected no error, got %v", err)
 	}
 
-	if len(vm.Weapons) != 1 {
+	// Expect 2 weapons: Raufen + Langschwert
-		t.Fatalf("Expected 1 weapon, got %d", len(vm.Weapons))
+	if len(vm.Weapons) != 2 {
+		t.Fatalf("Expected 2 weapons (Raufen + Langschwert), got %d", len(vm.Weapons))
 	}
 
-	sword := vm.Weapons[0]
+	// Check Langschwert (index 1, after Raufen)
+	sword := vm.Weapons[1]
 
 	// Damage should be in format like "1W6+3" where the bonus combines
 	// Character's SchadenBonus (from St=95 -> +1) + Weapon's Schb (2) = +3
@@ -319,11 +327,17 @@ func TestMapWeapons_WithRangedWeaponRanges(t *testing.T) {
 		t.Fatalf("Expected no error, got %v", err)
 	}
 
-	if len(vm.Weapons) != 2 {
+	// Expect 3 weapons: Raufen + Langbogen + Kurzschwert
-		t.Fatalf("Expected 2 weapons, got %d", len(vm.Weapons))
+	if len(vm.Weapons) != 3 {
+		t.Fatalf("Expected 3 weapons (Raufen + 2 equipped), got %d", len(vm.Weapons))
 	}
 
-	// Find the bow
+	// Check first weapon is Raufen
+	if vm.Weapons[0].Name != "Raufen" {
+		t.Errorf("Expected first weapon to be 'Raufen', got '%s'", vm.Weapons[0].Name)
+	}
+
+	// Find the bow and sword
 	var bow *WeaponViewModel
 	var sword *WeaponViewModel
 	for i := range vm.Weapons {