mirror of
https://github.com/Mezeporta/Erupe.git
synced 2026-03-22 07:32:32 +01:00
test: increase code coverage from 45.1% to 48.3%
Add unit tests across multiple packages: - byteframe: SetBE/SetLE byte order switching - config: Mode.String() for all safe version ranges - mhfpacket: 28 Parse methods, 5 Build methods, empty packet builds, variable-length packets, NOT IMPLEMENTED error paths, UpdateWarehouse - network: PacketID.String() for known IDs, out-of-range, and all valid - channelserver: handleMsgMhfGetPaperData (6 switch cases), grpToGR (11 input values), gacha handlers, TimeGameAbsolute, equipSkinHistSize (4 config branches), guild mission handlers, dumpSaveData disabled path - entranceserver: makeHeader with various inputs
This commit is contained in:
Houmgaor
246
server/channelserver/handlers_coverage4_test.go
Normal file
246
server/channelserver/handlers_coverage4_test.go
Normal file
@@ -0,0 +1,246 @@
|
||||
package channelserver
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"erupe-ce/network/mhfpacket"
|
||||
)
|
||||
|
||||
// =============================================================================
|
||||
// handleMsgMhfGetPaperData: 565-line pure data serialization function.
|
||||
// Tests all switch cases: 0, 5, 6, >1000 (known & unknown), default <1000.
|
||||
// =============================================================================
|
||||
|
||||
func TestHandleMsgMhfGetPaperData_Case0(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
handleMsgMhfGetPaperData(session, &mhfpacket.MsgMhfGetPaperData{
|
||||
AckHandle: 1,
|
||||
Unk2: 0,
|
||||
})
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("case 0: response should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("case 0: no response queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgMhfGetPaperData_Case5(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
handleMsgMhfGetPaperData(session, &mhfpacket.MsgMhfGetPaperData{
|
||||
AckHandle: 1,
|
||||
Unk2: 5,
|
||||
})
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("case 5: response should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("case 5: no response queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgMhfGetPaperData_Case6(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
handleMsgMhfGetPaperData(session, &mhfpacket.MsgMhfGetPaperData{
|
||||
AckHandle: 1,
|
||||
Unk2: 6,
|
||||
})
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("case 6: response should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("case 6: no response queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgMhfGetPaperData_GreaterThan1000_KnownKey(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
// 6001 is a known key in paperGiftData
|
||||
handleMsgMhfGetPaperData(session, &mhfpacket.MsgMhfGetPaperData{
|
||||
AckHandle: 1,
|
||||
Unk2: 6001,
|
||||
})
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error(">1000 known: response should have data")
|
||||
}
|
||||
default:
|
||||
t.Error(">1000 known: no response queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgMhfGetPaperData_GreaterThan1000_UnknownKey(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
// 9999 is not a known key in paperGiftData
|
||||
handleMsgMhfGetPaperData(session, &mhfpacket.MsgMhfGetPaperData{
|
||||
AckHandle: 1,
|
||||
Unk2: 9999,
|
||||
})
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
// Even unknown keys should produce a response (empty earth succeed)
|
||||
_ = p
|
||||
default:
|
||||
t.Error(">1000 unknown: no response queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgMhfGetPaperData_DefaultUnknownLessThan1000(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
// Unknown type < 1000, hits default case then falls to else branch
|
||||
handleMsgMhfGetPaperData(session, &mhfpacket.MsgMhfGetPaperData{
|
||||
AckHandle: 1,
|
||||
Unk2: 99,
|
||||
})
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
_ = p
|
||||
default:
|
||||
t.Error("default <1000: no response queued")
|
||||
}
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// handleMsgMhfGetGachaPlayHistory and handleMsgMhfPlayFreeGacha
|
||||
// =============================================================================
|
||||
|
||||
func TestHandleMsgMhfGetGachaPlayHistory(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
handleMsgMhfGetGachaPlayHistory(session, &mhfpacket.MsgMhfGetGachaPlayHistory{
|
||||
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 TestHandleMsgMhfPlayFreeGacha(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
handleMsgMhfPlayFreeGacha(session, &mhfpacket.MsgMhfPlayFreeGacha{
|
||||
AckHandle: 1,
|
||||
})
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("response should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("no response queued")
|
||||
}
|
||||
}
|
||||
|
||||
// Seibattle handlers: GetBreakSeibatuLevelReward, GetFixedSeibatuRankingTable,
|
||||
// ReadLastWeekBeatRanking, ReadBeatLevelAllRanking, ReadBeatLevelMyRanking
|
||||
// are already tested in handlers_misc_test.go and handlers_tower_test.go.
|
||||
|
||||
// =============================================================================
|
||||
// grpToGR: pure function, no dependencies
|
||||
// =============================================================================
|
||||
|
||||
func TestGrpToGR(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
input int
|
||||
expected uint16
|
||||
}{
|
||||
{"zero", 0, 1},
|
||||
{"low_value", 500, 2},
|
||||
{"first_bracket", 1000, 2},
|
||||
{"mid_bracket", 208750, 51},
|
||||
{"second_bracket", 300000, 62},
|
||||
{"high_value", 593400, 100},
|
||||
{"third_bracket", 700000, 113},
|
||||
{"very_high", 993400, 150},
|
||||
{"above_993400", 1000000, 150},
|
||||
{"fourth_bracket", 1400900, 200},
|
||||
{"max_bracket", 11345900, 900},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got := grpToGR(tt.input)
|
||||
if got != tt.expected {
|
||||
t.Errorf("grpToGR(%d) = %d, want %d", tt.input, got, tt.expected)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// dumpSaveData: test disabled path
|
||||
// =============================================================================
|
||||
|
||||
func TestDumpSaveData_Disabled(t *testing.T) {
|
||||
server := createMockServer()
|
||||
server.erupeConfig.SaveDumps.Enabled = false
|
||||
session := createMockSession(1, server)
|
||||
|
||||
// Should return immediately without error
|
||||
dumpSaveData(session, []byte{0x01, 0x02, 0x03}, "test")
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// TimeGameAbsolute
|
||||
// =============================================================================
|
||||
|
||||
func TestTimeGameAbsolute(t *testing.T) {
|
||||
result := TimeGameAbsolute()
|
||||
|
||||
// TimeGameAbsolute returns (adjustedUnix - 2160) % 5760
|
||||
// Result should be in range [0, 5760)
|
||||
if result >= 5760 {
|
||||
t.Errorf("TimeGameAbsolute() = %d, should be < 5760", result)
|
||||
}
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// handleMsgSysAuthData: empty handler
|
||||
// =============================================================================
|
||||
|
||||
func TestHandleMsgSysAuthData(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
t.Errorf("handleMsgSysAuthData panicked: %v", r)
|
||||
}
|
||||
}()
|
||||
handleMsgSysAuthData(session, nil)
|
||||
}
|
||||
202
server/channelserver/handlers_coverage5_test.go
Normal file
202
server/channelserver/handlers_coverage5_test.go
Normal file
@@ -0,0 +1,202 @@
|
||||
package channelserver
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
_config "erupe-ce/config"
|
||||
"erupe-ce/network/mhfpacket"
|
||||
)
|
||||
|
||||
// =============================================================================
|
||||
// equipSkinHistSize: pure function, tests all 3 config branches
|
||||
// =============================================================================
|
||||
|
||||
func TestEquipSkinHistSize_Default(t *testing.T) {
|
||||
orig := _config.ErupeConfig.RealClientMode
|
||||
defer func() { _config.ErupeConfig.RealClientMode = orig }()
|
||||
|
||||
_config.ErupeConfig.RealClientMode = _config.ZZ
|
||||
got := equipSkinHistSize()
|
||||
if got != 3200 {
|
||||
t.Errorf("equipSkinHistSize() with ZZ = %d, want 3200", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEquipSkinHistSize_Z2(t *testing.T) {
|
||||
orig := _config.ErupeConfig.RealClientMode
|
||||
defer func() { _config.ErupeConfig.RealClientMode = orig }()
|
||||
|
||||
_config.ErupeConfig.RealClientMode = _config.Z2
|
||||
got := equipSkinHistSize()
|
||||
if got != 2560 {
|
||||
t.Errorf("equipSkinHistSize() with Z2 = %d, want 2560", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEquipSkinHistSize_Z1(t *testing.T) {
|
||||
orig := _config.ErupeConfig.RealClientMode
|
||||
defer func() { _config.ErupeConfig.RealClientMode = orig }()
|
||||
|
||||
_config.ErupeConfig.RealClientMode = _config.Z1
|
||||
got := equipSkinHistSize()
|
||||
if got != 1280 {
|
||||
t.Errorf("equipSkinHistSize() with Z1 = %d, want 1280", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEquipSkinHistSize_OlderMode(t *testing.T) {
|
||||
orig := _config.ErupeConfig.RealClientMode
|
||||
defer func() { _config.ErupeConfig.RealClientMode = orig }()
|
||||
|
||||
_config.ErupeConfig.RealClientMode = _config.G1
|
||||
got := equipSkinHistSize()
|
||||
if got != 1280 {
|
||||
t.Errorf("equipSkinHistSize() with G1 = %d, want 1280", got)
|
||||
}
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// DB-free guild handlers: simple ack stubs
|
||||
// =============================================================================
|
||||
|
||||
func TestHandleMsgMhfAddGuildMissionCount(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
handleMsgMhfAddGuildMissionCount(session, &mhfpacket.MsgMhfAddGuildMissionCount{
|
||||
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 TestHandleMsgMhfSetGuildMissionTarget(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
handleMsgMhfSetGuildMissionTarget(session, &mhfpacket.MsgMhfSetGuildMissionTarget{
|
||||
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 TestHandleMsgMhfCancelGuildMissionTarget(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
handleMsgMhfCancelGuildMissionTarget(session, &mhfpacket.MsgMhfCancelGuildMissionTarget{
|
||||
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 TestHandleMsgMhfGetGuildMissionRecord(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
handleMsgMhfGetGuildMissionRecord(session, &mhfpacket.MsgMhfGetGuildMissionRecord{
|
||||
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 TestHandleMsgMhfAcquireGuildTresureSouvenir(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
handleMsgMhfAcquireGuildTresureSouvenir(session, &mhfpacket.MsgMhfAcquireGuildTresureSouvenir{
|
||||
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 TestHandleMsgMhfGetUdGuildMapInfo(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
handleMsgMhfGetUdGuildMapInfo(session, &mhfpacket.MsgMhfGetUdGuildMapInfo{
|
||||
AckHandle: 1,
|
||||
})
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("response should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("no response queued")
|
||||
}
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// DB-free guild mission list handler (large static data)
|
||||
// =============================================================================
|
||||
|
||||
func TestHandleMsgMhfGetGuildMissionList(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
handleMsgMhfGetGuildMissionList(session, &mhfpacket.MsgMhfGetGuildMissionList{
|
||||
AckHandle: 1,
|
||||
})
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("response should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("no response queued")
|
||||
}
|
||||
}
|
||||
|
||||
// handleMsgMhfEnumerateUnionItem requires DB (calls userGetItems)
|
||||
|
||||
// handleMsgMhfRegistSpabiTime, handleMsgMhfKickExportForce, handleMsgMhfUseUdShopCoin
|
||||
// are tested in handlers_misc_test.go
|
||||
|
||||
// handleMsgMhfGetUdShopCoin and handleMsgMhfGetLobbyCrowd are tested in handlers_misc_test.go
|
||||
|
||||
// handleMsgMhfEnumerateGuacot requires DB (calls getGoocooData)
|
||||
|
||||
// handleMsgMhfPostRyoudama is tested in handlers_caravan_test.go
|
||||
// handleMsgMhfResetTitle is tested in handlers_coverage2_test.go
|
||||
35
server/entranceserver/make_resp_extended_test.go
Normal file
35
server/entranceserver/make_resp_extended_test.go
Normal file
@@ -0,0 +1,35 @@
|
||||
package entranceserver
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestMakeHeader tests the makeHeader function with various inputs
|
||||
func TestMakeHeader(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
data []byte
|
||||
respType string
|
||||
entryCount uint16
|
||||
key byte
|
||||
}{
|
||||
{"empty data", []byte{}, "SV2", 0, 0x00},
|
||||
{"small data", []byte{0x01, 0x02, 0x03}, "SV2", 1, 0x00},
|
||||
{"SVR type", []byte{0xAA, 0xBB}, "SVR", 2, 0x42},
|
||||
{"USR type", []byte{0x01}, "USR", 1, 0x00},
|
||||
{"larger data", make([]byte, 100), "SV2", 5, 0xFF},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := makeHeader(tt.data, tt.respType, tt.entryCount, tt.key)
|
||||
if len(result) == 0 {
|
||||
t.Error("makeHeader returned empty result")
|
||||
}
|
||||
// First byte should be the key
|
||||
if result[0] != tt.key {
|
||||
t.Errorf("first byte = %x, want %x", result[0], tt.key)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user