Mirror/Erupe
1
0
Fork 0
mirror of https://github.com/Mezeporta/Erupe.git synced 2026-03-22 07:32:32 +01:00
Code Issues Packages Projects Releases Wiki Activity

refactor(channelserver): consolidate tests into matching source test files

Browse Source 
Move ~300 test functions from 21 catch-all files (handlers_core_test.go,
handlers_coverage*_test.go, *_coverage_test.go) into the *_test.go file
matching each handler's source file. This makes tests discoverable by
convention: tests for handlers_guild.go live in handlers_guild_test.go.

New files: handlers_guild_mission_test.go, sys_time_test.go.
No test logic changed — pure file reorganization.
This commit is contained in:
Houmgaor
2026-02-26 23:41:44 +01:00
parent a68d76c55f
commit d0837e779c
53 changed files with 5922 additions and 6118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

451
server/channelserver/handlers_misc_test.go
View File

@@ -3,6 +3,7 @@ package channelserver
import (
"testing"
cfg "erupe-ce/config"
"erupe-ce/network/mhfpacket"
)
@@ -559,6 +560,38 @@ func TestHandleMsgMhfGetLobbyCrowd(t *testing.T) {
}
}
// =============================================================================
// equipSkinHistSize: pure function, tests all 3 config branches
// =============================================================================
func TestEquipSkinHistSize_Default(t *testing.T) {
got := equipSkinHistSize(cfg.ZZ)
if got != 3200 {
t.Errorf("equipSkinHistSize(ZZ) = %d, want 3200", got)
}
}
func TestEquipSkinHistSize_Z2(t *testing.T) {
got := equipSkinHistSize(cfg.Z2)
if got != 2560 {
t.Errorf("equipSkinHistSize(Z2) = %d, want 2560", got)
}
}
func TestEquipSkinHistSize_Z1(t *testing.T) {
got := equipSkinHistSize(cfg.Z1)
if got != 1280 {
t.Errorf("equipSkinHistSize(Z1) = %d, want 1280", got)
}
}
func TestEquipSkinHistSize_OlderMode(t *testing.T) {
got := equipSkinHistSize(cfg.G1)
if got != 1280 {
t.Errorf("equipSkinHistSize(G1) = %d, want 1280", got)
}
}
// Distribution struct tests
func TestDistributionStruct(t *testing.T) {
dist := Distribution{
@@ -599,3 +632,421 @@ func TestDistributionItemStruct(t *testing.T) {
t.Errorf("ItemID = %d, want 1234", item.ItemID)
}
}
// --- Enhanced Minidata tests (in-memory store, no DB) ---
func TestHandleMsgMhfGetEnhancedMinidata_NotFound(t *testing.T) {
srv := createMockServer()
srv.minidata = NewMinidataStore()
s := createMockSession(100, srv)
pkt := &mhfpacket.MsgMhfGetEnhancedMinidata{AckHandle: 1, CharID: 999}
handleMsgMhfGetEnhancedMinidata(s, pkt)
select {
case p := <-s.sendPackets:
if len(p.data) == 0 {
t.Fatal("Expected non-empty response")
}
default:
t.Fatal("No response packet queued")
}
}
func TestHandleMsgMhfGetEnhancedMinidata_Found(t *testing.T) {
srv := createMockServer()
srv.minidata = NewMinidataStore()
srv.minidata.Set(42, []byte{0xDE, 0xAD, 0xBE, 0xEF})
s := createMockSession(100, srv)
pkt := &mhfpacket.MsgMhfGetEnhancedMinidata{AckHandle: 1, CharID: 42}
handleMsgMhfGetEnhancedMinidata(s, pkt)
select {
case p := <-s.sendPackets:
if len(p.data) == 0 {
t.Fatal("Expected non-empty response")
}
default:
t.Fatal("No response packet queued")
}
}
func TestHandleMsgMhfSetEnhancedMinidata(t *testing.T) {
srv := createMockServer()
srv.minidata = NewMinidataStore()
s := createMockSession(100, srv)
payload := []byte{0x01, 0x02, 0x03}
pkt := &mhfpacket.MsgMhfSetEnhancedMinidata{AckHandle: 1, RawDataPayload: payload}
handleMsgMhfSetEnhancedMinidata(s, pkt)
select {
case <-s.sendPackets:
default:
t.Fatal("No response packet queued")
}
data, ok := srv.minidata.Get(100)
if !ok {
t.Fatal("Minidata not stored")
}
if len(data) != 3 || data[0] != 0x01 {
t.Errorf("Unexpected stored data: %v", data)
}
}
// --- Trend Weapon tests ---
func TestHandleMsgMhfGetTrendWeapon_Empty(t *testing.T) {
srv := createMockServer()
srv.miscRepo = &mockMiscRepo{}
s := createMockSession(100, srv)
pkt := &mhfpacket.MsgMhfGetTrendWeapon{AckHandle: 1}
handleMsgMhfGetTrendWeapon(s, pkt)
select {
case p := <-s.sendPackets:
if len(p.data) == 0 {
t.Fatal("Expected non-empty response")
}
default:
t.Fatal("No response packet queued")
}
}
func TestHandleMsgMhfGetTrendWeapon_WithWeapons(t *testing.T) {
srv := createMockServer()
srv.miscRepo = &mockMiscRepo{
trendWeapons: []uint16{100, 200, 300},
}
s := createMockSession(100, srv)
pkt := &mhfpacket.MsgMhfGetTrendWeapon{AckHandle: 1}
handleMsgMhfGetTrendWeapon(s, pkt)
select {
case p := <-s.sendPackets:
if len(p.data) == 0 {
t.Fatal("Expected non-empty response")
}
default:
t.Fatal("No response packet queued")
}
}
func TestHandleMsgMhfUpdateUseTrendWeaponLog(t *testing.T) {
srv := createMockServer()
srv.miscRepo = &mockMiscRepo{}
s := createMockSession(100, srv)
pkt := &mhfpacket.MsgMhfUpdateUseTrendWeaponLog{AckHandle: 1, WeaponType: 3, WeaponID: 500}
handleMsgMhfUpdateUseTrendWeaponLog(s, pkt)
select {
case <-s.sendPackets:
default:
t.Fatal("No response packet queued")
}
}
// --- Etc Points tests ---
func TestHandleMsgMhfGetEtcPoints(t *testing.T) {
srv := createMockServer()
charRepo := newMockCharacterRepo()
charRepo.etcBonusQuests = 100
charRepo.etcDailyQuests = 50
charRepo.etcPromoPoints = 25
srv.charRepo = charRepo
s := createMockSession(100, srv)
pkt := &mhfpacket.MsgMhfGetEtcPoints{AckHandle: 1}
handleMsgMhfGetEtcPoints(s, pkt)
select {
case p := <-s.sendPackets:
if len(p.data) == 0 {
t.Fatal("Expected non-empty response")
}
default:
t.Fatal("No response packet queued")
}
}
func TestHandleMsgMhfUpdateEtcPoint(t *testing.T) {
tests := []struct {
name string
pointType uint8
delta int16
column string
}{
{"bonus_quests", 0, 5, "bonus_quests"},
{"daily_quests", 1, 3, "daily_quests"},
{"promo_points", 2, 1, "promo_points"},
{"invalid_type", 99, 1, ""},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
srv := createMockServer()
charRepo := newMockCharacterRepo()
srv.charRepo = charRepo
s := createMockSession(100, srv)
pkt := &mhfpacket.MsgMhfUpdateEtcPoint{
AckHandle: 1,
PointType: tt.pointType,
Delta: tt.delta,
}
handleMsgMhfUpdateEtcPoint(s, pkt)
select {
case <-s.sendPackets:
default:
t.Fatal("No response packet queued")
}
if tt.column != "" {
val := charRepo.ints[tt.column]
if val != int(tt.delta) {
t.Errorf("Expected %s=%d, got %d", tt.column, tt.delta, val)
}
}
})
}
}
func TestHandleMsgMhfUpdateEtcPoint_NegativeDelta(t *testing.T) {
srv := createMockServer()
charRepo := newMockCharacterRepo()
charRepo.ints["bonus_quests"] = 10
srv.charRepo = charRepo
s := createMockSession(100, srv)
pkt := &mhfpacket.MsgMhfUpdateEtcPoint{AckHandle: 1, PointType: 0, Delta: -5}
handleMsgMhfUpdateEtcPoint(s, pkt)
select {
case <-s.sendPackets:
default:
t.Fatal("No response packet queued")
}
if charRepo.ints["bonus_quests"] != 5 {
t.Errorf("Expected bonus_quests=5, got %d", charRepo.ints["bonus_quests"])
}
}
func TestHandleMsgMhfUpdateEtcPoint_ClampToZero(t *testing.T) {
srv := createMockServer()
charRepo := newMockCharacterRepo()
charRepo.ints["bonus_quests"] = 3
srv.charRepo = charRepo
s := createMockSession(100, srv)
pkt := &mhfpacket.MsgMhfUpdateEtcPoint{AckHandle: 1, PointType: 0, Delta: -10}
handleMsgMhfUpdateEtcPoint(s, pkt)
select {
case <-s.sendPackets:
default:
t.Fatal("No response packet queued")
}
if charRepo.ints["bonus_quests"] != 0 {
t.Errorf("Expected bonus_quests=0, got %d", charRepo.ints["bonus_quests"])
}
}
// --- Equip Skin History tests ---
func TestHandleMsgMhfGetEquipSkinHist(t *testing.T) {
srv := createMockServer()
charRepo := newMockCharacterRepo()
srv.charRepo = charRepo
s := createMockSession(100, srv)
pkt := &mhfpacket.MsgMhfGetEquipSkinHist{AckHandle: 1}
handleMsgMhfGetEquipSkinHist(s, pkt)
select {
case p := <-s.sendPackets:
if len(p.data) == 0 {
t.Fatal("Expected non-empty response")
}
default:
t.Fatal("No response packet queued")
}
}
func TestHandleMsgMhfUpdateEquipSkinHist_Valid(t *testing.T) {
srv := createMockServer()
charRepo := newMockCharacterRepo()
srv.charRepo = charRepo
s := createMockSession(100, srv)
pkt := &mhfpacket.MsgMhfUpdateEquipSkinHist{AckHandle: 1, ArmourID: 10001, MogType: 0}
handleMsgMhfUpdateEquipSkinHist(s, pkt)
select {
case <-s.sendPackets:
default:
t.Fatal("No response packet queued")
}
if _, ok := charRepo.columns["skin_hist"]; !ok {
t.Error("Expected skin_hist to be saved")
}
}
func TestHandleMsgMhfUpdateEquipSkinHist_LowArmourID(t *testing.T) {
srv := createMockServer()
charRepo := newMockCharacterRepo()
srv.charRepo = charRepo
s := createMockSession(100, srv)
pkt := &mhfpacket.MsgMhfUpdateEquipSkinHist{AckHandle: 1, ArmourID: 5000, MogType: 0}
handleMsgMhfUpdateEquipSkinHist(s, pkt)
select {
case <-s.sendPackets:
default:
t.Fatal("No response packet queued")
}
if _, ok := charRepo.columns["skin_hist"]; ok {
t.Error("Expected skin_hist NOT to be saved for low ArmourID")
}
}
func TestHandleMsgMhfUpdateEquipSkinHist_HighMogType(t *testing.T) {
srv := createMockServer()
charRepo := newMockCharacterRepo()
srv.charRepo = charRepo
s := createMockSession(100, srv)
pkt := &mhfpacket.MsgMhfUpdateEquipSkinHist{AckHandle: 1, ArmourID: 10001, MogType: 5}
handleMsgMhfUpdateEquipSkinHist(s, pkt)
select {
case <-s.sendPackets:
default:
t.Fatal("No response packet queued")
}
if _, ok := charRepo.columns["skin_hist"]; ok {
t.Error("Expected skin_hist NOT to be saved for high MogType")
}
}
// Tests consolidated from handlers_coverage3_test.go
func TestNonTrivialHandlers_NoDB_Misc(t *testing.T) {
server := createMockServer()
t.Run("handleMsgMhfGetEarthStatus", func(t *testing.T) {
session := createMockSession(1, server)
handleMsgMhfGetEarthStatus(session, &mhfpacket.MsgMhfGetEarthStatus{AckHandle: 1})
select {
case p := <-session.sendPackets:
if len(p.data) == 0 {
t.Error("response should have data")
}
default:
t.Error("no response queued")
}
})
t.Run("handleMsgMhfGetEarthValue_Type1", func(t *testing.T) {
session := createMockSession(1, server)
handleMsgMhfGetEarthValue(session, &mhfpacket.MsgMhfGetEarthValue{AckHandle: 1, ReqType: 1})
select {
case p := <-session.sendPackets:
if len(p.data) == 0 {
t.Error("response should have data")
}
default:
t.Error("no response queued")
}
})
t.Run("handleMsgMhfGetEarthValue_Type2", func(t *testing.T) {
session := createMockSession(1, server)
handleMsgMhfGetEarthValue(session, &mhfpacket.MsgMhfGetEarthValue{AckHandle: 1, ReqType: 2})
select {
case p := <-session.sendPackets:
if len(p.data) == 0 {
t.Error("response should have data")
}
default:
t.Error("no response queued")
}
})
t.Run("handleMsgMhfGetEarthValue_Type3", func(t *testing.T) {
session := createMockSession(1, server)
handleMsgMhfGetEarthValue(session, &mhfpacket.MsgMhfGetEarthValue{AckHandle: 1, ReqType: 3})
select {
case p := <-session.sendPackets:
if len(p.data) == 0 {
t.Error("response should have data")
}
default:
t.Error("no response queued")
}
})
t.Run("handleMsgMhfGetUdShopCoin", func(t *testing.T) {
session := createMockSession(1, server)
handleMsgMhfGetUdShopCoin(session, &mhfpacket.MsgMhfGetUdShopCoin{AckHandle: 1})
select {
case p := <-session.sendPackets:
if len(p.data) == 0 {
t.Error("response should have data")
}
default:
t.Error("no response queued")
}
})
t.Run("handleMsgMhfGetLobbyCrowd", func(t *testing.T) {
session := createMockSession(1, server)
handleMsgMhfGetLobbyCrowd(session, &mhfpacket.MsgMhfGetLobbyCrowd{AckHandle: 1})
select {
case p := <-session.sendPackets:
if len(p.data) == 0 {
t.Error("response should have data")
}
default:
t.Error("no response queued")
}
})
}
func TestEmptyHandlers_MiscFiles_Misc(t *testing.T) {
server := createMockServer()
session := createMockSession(1, server)
tests := []struct {
name string
fn func()
}{
{"handleMsgMhfGetCogInfo", func() { handleMsgMhfGetCogInfo(session, nil) }},
{"handleMsgMhfUseUdShopCoin", func() { handleMsgMhfUseUdShopCoin(session, nil) }},
{"handleMsgMhfGetDailyMissionMaster", func() { handleMsgMhfGetDailyMissionMaster(session, nil) }},
{"handleMsgMhfGetDailyMissionPersonal", func() { handleMsgMhfGetDailyMissionPersonal(session, nil) }},
{"handleMsgMhfSetDailyMissionPersonal", func() { handleMsgMhfSetDailyMissionPersonal(session, nil) }},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Errorf("%s panicked: %v", tt.name, r)
}
}()
tt.fn()
})
}
}