bamort/backend/character/reference_data_handlers_test.go

package character

import (
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"os"
	"testing"

	"bamort/database"
	"bamort/models"

	"github.com/gin-gonic/gin"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func setupRefDataTestEnv(t *testing.T) {
	t.Helper()
	original := os.Getenv("ENVIRONMENT")
	os.Setenv("ENVIRONMENT", "test")
	t.Cleanup(func() {
		if original != "" {
			os.Setenv("ENVIRONMENT", original)
		} else {
			os.Unsetenv("ENVIRONMENT")
		}
	})
	database.SetupTestDB(true, true)
	t.Cleanup(database.ResetTestDB)
	require.NoError(t, models.MigrateStructure())
	gin.SetMode(gin.TestMode)
}

func TestGetRaces(t *testing.T) {
	setupRefDataTestEnv(t)

	w := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(w)
	c.Request = httptest.NewRequest(http.MethodGet, "/api/characters/races", nil)

	GetRaces(c)

	assert.Equal(t, http.StatusOK, w.Code)
	var resp map[string]interface{}
	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &resp))
	races, ok := resp["races"]
	assert.True(t, ok, "Response should contain 'races' key")
	assert.NotEmpty(t, races)
}

func TestGetCharacterClasses(t *testing.T) {
	setupRefDataTestEnv(t)

	w := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(w)
	c.Request = httptest.NewRequest(http.MethodGet, "/api/characters/classes", nil)

	GetCharacterClasses(c)

	assert.Equal(t, http.StatusOK, w.Code)
	var resp map[string]interface{}
	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &resp))
	assert.NotNil(t, resp)
}

func TestGetOrigins(t *testing.T) {
	setupRefDataTestEnv(t)

	w := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(w)
	c.Request = httptest.NewRequest(http.MethodGet, "/api/characters/origins", nil)

	GetOrigins(c)

	assert.Equal(t, http.StatusOK, w.Code)
	var resp map[string]interface{}
	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &resp))
	assert.NotNil(t, resp)
}

func TestGetSkillCategoriesHandlerStatic(t *testing.T) {
	setupRefDataTestEnv(t)

	w := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(w)
	c.Request = httptest.NewRequest(http.MethodGet, "/api/characters/skill-categories", nil)

	GetSkillCategoriesHandlerStatic(c)

	assert.Equal(t, http.StatusOK, w.Code)
	var resp map[string]interface{}
	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &resp))
	categories, ok := resp["skill_categories"]
	assert.True(t, ok, "Response should contain 'skill_categories' key")
	catMap, ok := categories.(map[string]interface{})
	assert.True(t, ok)
	assert.Contains(t, catMap, "Alltag")
}

func TestGetRewardTypesStaticImprove(t *testing.T) {
	setupRefDataTestEnv(t)

	w := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(w)
	c.Params = gin.Params{{Key: "id", Value: "1"}}
	req := httptest.NewRequest(http.MethodGet, "/api/characters/reward-types?learning_type=improve&skill_name=Athletik&skill_type=skill", nil)
	c.Request = req

	GetRewardTypesStatic(c)

	assert.Equal(t, http.StatusOK, w.Code)
	var resp map[string]interface{}
	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &resp))
	assert.NotNil(t, resp["reward_types"])
	assert.Equal(t, "improve", resp["learning_type"])
}

func TestGetRewardTypesStaticLearn(t *testing.T) {
	setupRefDataTestEnv(t)

	w := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(w)
	c.Params = gin.Params{{Key: "id", Value: "1"}}
	req := httptest.NewRequest(http.MethodGet, "/api/characters/reward-types?learning_type=learn&skill_name=Athletik", nil)
	c.Request = req

	GetRewardTypesStatic(c)

	assert.Equal(t, http.StatusOK, w.Code)
	var resp map[string]interface{}
	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &resp))
	rewardTypes, ok := resp["reward_types"].([]interface{})
	assert.True(t, ok)
	assert.GreaterOrEqual(t, len(rewardTypes), 1)
}

func TestGetRewardTypesStaticSpell(t *testing.T) {
	setupRefDataTestEnv(t)

	w := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(w)
	c.Params = gin.Params{{Key: "id", Value: "1"}}
	req := httptest.NewRequest(http.MethodGet, "/api/characters/reward-types?learning_type=spell", nil)
	c.Request = req

	GetRewardTypesStatic(c)

	assert.Equal(t, http.StatusOK, w.Code)
	var resp map[string]interface{}
	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &resp))
	assert.Equal(t, "spell", resp["learning_type"])
}

func TestGetSpellDetailsNotFound(t *testing.T) {
	setupRefDataTestEnv(t)

	w := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(w)
	req := httptest.NewRequest(http.MethodGet, "/api/characters/spell-details?name=NonExistentSpellXYZ", nil)
	c.Request = req

	GetSpellDetails(c)

	assert.Equal(t, http.StatusNotFound, w.Code)
}

func TestGetSpellDetailsMissingName(t *testing.T) {
	setupRefDataTestEnv(t)

	w := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(w)
	req := httptest.NewRequest(http.MethodGet, "/api/characters/spell-details", nil)
	c.Request = req

	GetSpellDetails(c)

	assert.Equal(t, http.StatusBadRequest, w.Code)
}