From 31266fcb210d111c7570560b216042223aa33dd8 Mon Sep 17 00:00:00 2001 From: Houmgaor Date: Fri, 27 Feb 2026 13:19:33 +0100 Subject: [PATCH] test(entranceserver): push coverage from 56.1% to 82.2% Add 18 tests covering makeSv2Resp (ZZ, G3.2/SVR, MezFes/Return filtering, debug logging), encodeServerInfo branches (non-local IP, empty IP fallback, GG/G1-G5 client modes, ProxyPort, type filtering), makeUsrResp debug logging, sanitizeAddr, and startEntranceCapture (disabled, entrance-disabled, enabled, default output dir). --- .../entranceserver/make_resp_extended_test.go | 283 ++++++++++++++++++ server/entranceserver/sys_capture_test.go | 208 +++++++++++++ 2 files changed, 491 insertions(+) create mode 100644 server/entranceserver/sys_capture_test.go diff --git a/server/entranceserver/make_resp_extended_test.go b/server/entranceserver/make_resp_extended_test.go index 70695ac30..ae40c2218 100644 --- a/server/entranceserver/make_resp_extended_test.go +++ b/server/entranceserver/make_resp_extended_test.go @@ -2,6 +2,10 @@ package entranceserver import ( "testing" + + cfg "erupe-ce/config" + + "go.uber.org/zap" ) // TestMakeHeader tests the makeHeader function with various inputs @@ -33,3 +37,282 @@ func TestMakeHeader(t *testing.T) { }) } } + +// helper to create a standard test config with one server entry and one channel +func newTestConfig(mode cfg.Mode) *cfg.Config { + return &cfg.Config{ + RealClientMode: mode, + Host: "127.0.0.1", + Entrance: cfg.Entrance{ + Enabled: true, + Port: 53310, + Entries: []cfg.EntranceServerInfo{ + { + Name: "TestServer", + Description: "Test", + IP: "127.0.0.1", + Type: 0, + Recommended: 1, + AllowedClientFlags: 0xFFFFFFFF, + Channels: []cfg.EntranceChannelInfo{ + {Port: 54001, MaxPlayers: 100}, + }, + }, + }, + }, + GameplayOptions: cfg.GameplayOptions{ + ClanMemberLimits: [][]uint8{{1, 60}}, + }, + } +} + +func newTestServer(config *cfg.Config) *Server { + return &Server{ + logger: zap.NewNop(), + erupeConfig: config, + serverRepo: &mockEntranceServerRepo{currentPlayers: 10}, + } +} + +// --- makeSv2Resp tests --- + +func TestMakeSv2Resp_ZZ(t *testing.T) { + config := newTestConfig(cfg.ZZ) + s := newTestServer(config) + + result := makeSv2Resp(config, s, true) + if len(result) == 0 { + t.Fatal("makeSv2Resp returned empty result") + } + // First byte is key (0x00), then encrypted data containing "SV2" + if result[0] != 0x00 { + t.Errorf("first byte = %x, want 0x00", result[0]) + } +} + +func TestMakeSv2Resp_G32_SVR(t *testing.T) { + config := newTestConfig(cfg.G32) + s := newTestServer(config) + + result := makeSv2Resp(config, s, true) + if len(result) == 0 { + t.Fatal("makeSv2Resp returned empty result for G3.2") + } + // Decrypt the response to verify it contains "SVR" instead of "SV2" + decrypted := DecryptBin8(result[1:], result[0]) + if len(decrypted) < 3 { + t.Fatalf("decrypted response too short: %d bytes", len(decrypted)) + } + respType := string(decrypted[:3]) + if respType != "SVR" { + t.Errorf("respType = %q, want SVR", respType) + } +} + +func TestMakeSv2Resp_Z1_FiltersMezFes(t *testing.T) { + config := newTestConfig(cfg.Z1) + // Add a MezFes entry (Type=6) + config.Entrance.Entries = append(config.Entrance.Entries, cfg.EntranceServerInfo{ + Name: "MezFes", + Description: "MezFes World", + IP: "127.0.0.1", + Type: 6, + Channels: []cfg.EntranceChannelInfo{{Port: 54002, MaxPlayers: 100}}, + }) + s := newTestServer(config) + + result := makeSv2Resp(config, s, true) + if len(result) == 0 { + t.Fatal("makeSv2Resp returned empty for Z1 + MezFes") + } + // Decrypt and check server count (should be 1, not 2) + decrypted := DecryptBin8(result[1:], result[0]) + // Header: 3 bytes type + 2 bytes count + 2 bytes length + serverCount := uint16(decrypted[3])<<8 | uint16(decrypted[4]) + if serverCount != 1 { + t.Errorf("server count = %d, want 1 (MezFes should be filtered)", serverCount) + } +} + +func TestMakeSv2Resp_G6_FiltersReturn(t *testing.T) { + config := newTestConfig(cfg.G6) + // Add a Return entry (Type=5) + config.Entrance.Entries = append(config.Entrance.Entries, cfg.EntranceServerInfo{ + Name: "Return", + Description: "Return World", + IP: "127.0.0.1", + Type: 5, + Channels: []cfg.EntranceChannelInfo{{Port: 54002, MaxPlayers: 100}}, + }) + s := newTestServer(config) + + result := makeSv2Resp(config, s, true) + if len(result) == 0 { + t.Fatal("makeSv2Resp returned empty for G6 + Return") + } + // Decrypt and check server count + decrypted := DecryptBin8(result[1:], result[0]) + serverCount := uint16(decrypted[3])<<8 | uint16(decrypted[4]) + if serverCount != 1 { + t.Errorf("server count = %d, want 1 (Return should be filtered)", serverCount) + } +} + +func TestMakeSv2Resp_WithDebugLogging(t *testing.T) { + config := newTestConfig(cfg.ZZ) + config.DebugOptions.LogOutboundMessages = true + s := newTestServer(config) + + result := makeSv2Resp(config, s, true) + if len(result) == 0 { + t.Fatal("makeSv2Resp with debug logging returned empty") + } +} + +// --- encodeServerInfo branch tests --- + +func TestEncodeServerInfo_NonLocalIP(t *testing.T) { + config := newTestConfig(cfg.ZZ) + config.Entrance.Entries[0].IP = "192.168.1.100" + s := newTestServer(config) + + localResult := encodeServerInfo(config, s, true) + nonLocalResult := encodeServerInfo(config, s, false) + + if len(localResult) == 0 || len(nonLocalResult) == 0 { + t.Fatal("encodeServerInfo returned empty result") + } + // First 4 bytes are the IP — they should differ between local and non-local + if bytesEqual(localResult[:4], nonLocalResult[:4]) { + t.Error("local and non-local should encode different IPs") + } + // Local IP is written as WriteUint32(0x0100007F), which is big-endian: 01 00 00 7F + if localResult[0] != 0x01 || localResult[1] != 0x00 || localResult[2] != 0x00 || localResult[3] != 0x7F { + t.Errorf("local IP bytes = %02x%02x%02x%02x, want 0100007F", localResult[0], localResult[1], localResult[2], localResult[3]) + } +} + +func TestEncodeServerInfo_EmptyIP(t *testing.T) { + config := newTestConfig(cfg.ZZ) + config.Host = "10.0.0.1" + config.Entrance.Entries[0].IP = "" // should fall back to config.Host + s := newTestServer(config) + + result := encodeServerInfo(config, s, false) + if len(result) == 0 { + t.Fatal("encodeServerInfo returned empty for empty IP") + } + // 10.0.0.1 → LittleEndian.Uint32 → 0x0100000A, written big-endian: 01 00 00 0A + if result[0] != 0x01 || result[1] != 0x00 || result[2] != 0x00 || result[3] != 0x0A { + t.Errorf("fallback IP bytes = %02x%02x%02x%02x, want 0100000A", result[0], result[1], result[2], result[3]) + } +} + +func TestEncodeServerInfo_GGClientMode(t *testing.T) { + config := newTestConfig(cfg.GG) + config.Entrance.Entries[0].AllowedClientFlags = 0xDEADBEEF + s := newTestServer(config) + + result := encodeServerInfo(config, s, true) + if len(result) == 0 { + t.Fatal("encodeServerInfo returned empty for GG mode") + } +} + +func TestEncodeServerInfo_G1toG5ClientMode(t *testing.T) { + config := newTestConfig(cfg.G3) + s := newTestServer(config) + + result := encodeServerInfo(config, s, true) + if len(result) == 0 { + t.Fatal("encodeServerInfo returned empty for G3 mode") + } +} + +func TestEncodeServerInfo_ProxyPort(t *testing.T) { + config := newTestConfig(cfg.ZZ) + config.DebugOptions.ProxyPort = 9999 + s := newTestServer(config) + + result := encodeServerInfo(config, s, true) + if len(result) == 0 { + t.Fatal("encodeServerInfo returned empty for ProxyPort config") + } +} + +func TestEncodeServerInfo_Z1_SkipsMezFesType(t *testing.T) { + configWithMezFes := newTestConfig(cfg.Z1) + configWithMezFes.Entrance.Entries = append(configWithMezFes.Entrance.Entries, cfg.EntranceServerInfo{ + Name: "MezFes", + Description: "MezFes World", + IP: "127.0.0.1", + Type: 6, + Channels: []cfg.EntranceChannelInfo{{Port: 54002, MaxPlayers: 100}}, + }) + + configWithout := newTestConfig(cfg.Z1) + + sWith := newTestServer(configWithMezFes) + sWithout := newTestServer(configWithout) + + resultWith := encodeServerInfo(configWithMezFes, sWith, true) + resultWithout := encodeServerInfo(configWithout, sWithout, true) + + // Both should produce identical output since MezFes Type=6 is skipped on Z1 + if !bytesEqual(resultWith, resultWithout) { + t.Errorf("MezFes entry should be skipped on Z1, but output differs: %d vs %d bytes", + len(resultWith), len(resultWithout)) + } +} + +func TestEncodeServerInfo_G6_SkipsReturnType(t *testing.T) { + configWithReturn := newTestConfig(cfg.G6) + configWithReturn.Entrance.Entries = append(configWithReturn.Entrance.Entries, cfg.EntranceServerInfo{ + Name: "Return", + Description: "Return World", + IP: "127.0.0.1", + Type: 5, + Channels: []cfg.EntranceChannelInfo{{Port: 54002, MaxPlayers: 100}}, + }) + + configWithout := newTestConfig(cfg.G6) + + sWith := newTestServer(configWithReturn) + sWithout := newTestServer(configWithout) + + resultWith := encodeServerInfo(configWithReturn, sWith, true) + resultWithout := encodeServerInfo(configWithout, sWithout, true) + + if !bytesEqual(resultWith, resultWithout) { + t.Errorf("Return entry should be skipped on G6, but output differs: %d vs %d bytes", + len(resultWith), len(resultWithout)) + } +} + +// --- makeUsrResp debug logging test --- + +func TestMakeUsrResp_WithDebugLogging(t *testing.T) { + config := &cfg.Config{ + RealClientMode: cfg.ZZ, + DebugOptions: cfg.DebugOptions{ + LogOutboundMessages: true, + }, + } + s := &Server{ + logger: zap.NewNop(), + erupeConfig: config, + sessionRepo: &mockEntranceSessionRepo{serverID: 1234}, + } + + pkt := []byte{ + 'A', 'L', 'L', '+', + 0x00, + 0x00, 0x01, // 1 entry + 0x00, 0x00, 0x00, 0x01, // char_id = 1 + } + + result := makeUsrResp(pkt, s) + if len(result) == 0 { + t.Error("makeUsrResp with debug logging returned empty") + } +} diff --git a/server/entranceserver/sys_capture_test.go b/server/entranceserver/sys_capture_test.go new file mode 100644 index 000000000..57a348977 --- /dev/null +++ b/server/entranceserver/sys_capture_test.go @@ -0,0 +1,208 @@ +package entranceserver + +import ( + "bytes" + "io" + "net" + "os" + "sync" + "testing" + "time" + + cfg "erupe-ce/config" + "erupe-ce/network" + + "go.uber.org/zap" +) + +func TestSanitizeAddr(t *testing.T) { + tests := []struct { + name string + addr string + want string + }{ + {"ip_port", "127.0.0.1:8080", "127.0.0.1_8080"}, + {"no_colon", "127.0.0.1", "127.0.0.1"}, + {"empty", "", ""}, + {"multiple_colons", "::1:8080", "__1_8080"}, + {"ipv6", "[::1]:8080", "[__1]_8080"}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := sanitizeAddr(tt.addr) + if got != tt.want { + t.Errorf("sanitizeAddr(%q) = %q, want %q", tt.addr, got, tt.want) + } + }) + } +} + +// mockConn implements net.Conn for testing capture functions. +type mockConn struct { + readBuf *bytes.Buffer + writeBuf *bytes.Buffer + mu sync.Mutex + closed bool +} + +func newMockConn() *mockConn { + return &mockConn{ + readBuf: new(bytes.Buffer), + writeBuf: new(bytes.Buffer), + } +} + +func (m *mockConn) Read(b []byte) (int, error) { + m.mu.Lock() + defer m.mu.Unlock() + if m.closed { + return 0, io.EOF + } + return m.readBuf.Read(b) +} + +func (m *mockConn) Write(b []byte) (int, error) { + m.mu.Lock() + defer m.mu.Unlock() + if m.closed { + return 0, io.ErrClosedPipe + } + return m.writeBuf.Write(b) +} + +func (m *mockConn) Close() error { + m.mu.Lock() + defer m.mu.Unlock() + m.closed = true + return nil +} + +func (m *mockConn) LocalAddr() net.Addr { + return &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 53310} +} + +func (m *mockConn) RemoteAddr() net.Addr { + return &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 12345} +} + +func (m *mockConn) SetDeadline(time.Time) error { return nil } +func (m *mockConn) SetReadDeadline(time.Time) error { return nil } +func (m *mockConn) SetWriteDeadline(time.Time) error { return nil } + +func TestStartEntranceCapture_Disabled(t *testing.T) { + server := &Server{ + logger: zap.NewNop(), + erupeConfig: &cfg.Config{ + Capture: cfg.CaptureOptions{ + Enabled: false, + CaptureEntrance: false, + }, + }, + } + + mc := newMockConn() + origConn := network.NewCryptConn(mc, cfg.ZZ, nil) + remoteAddr := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 12345} + + resultConn, cleanup := startEntranceCapture(server, origConn, remoteAddr) + + if resultConn != origConn { + t.Error("disabled capture should return original conn") + } + cleanup() +} + +func TestStartEntranceCapture_EnabledButEntranceDisabled(t *testing.T) { + server := &Server{ + logger: zap.NewNop(), + erupeConfig: &cfg.Config{ + Capture: cfg.CaptureOptions{ + Enabled: true, + CaptureEntrance: false, + }, + }, + } + + mc := newMockConn() + origConn := network.NewCryptConn(mc, cfg.ZZ, nil) + remoteAddr := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 12345} + + resultConn, cleanup := startEntranceCapture(server, origConn, remoteAddr) + + if resultConn != origConn { + t.Error("capture with entrance disabled should return original conn") + } + cleanup() +} + +func TestStartEntranceCapture_EnabledSuccess(t *testing.T) { + outputDir := t.TempDir() + server := &Server{ + logger: zap.NewNop(), + erupeConfig: &cfg.Config{ + Host: "127.0.0.1", + Entrance: cfg.Entrance{Port: 53310}, + Capture: cfg.CaptureOptions{ + Enabled: true, + CaptureEntrance: true, + OutputDir: outputDir, + }, + }, + } + + mc := newMockConn() + origConn := network.NewCryptConn(mc, cfg.ZZ, nil) + remoteAddr := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 12345} + + resultConn, cleanup := startEntranceCapture(server, origConn, remoteAddr) + defer cleanup() + + if resultConn == origConn { + t.Error("enabled capture should return a different (recording) conn") + } +} + +func TestStartEntranceCapture_DefaultOutputDir(t *testing.T) { + origDir, err := os.Getwd() + if err != nil { + t.Fatal(err) + } + tmpDir := t.TempDir() + if err := os.Chdir(tmpDir); err != nil { + t.Fatal(err) + } + defer func() { _ = os.Chdir(origDir) }() + + server := &Server{ + logger: zap.NewNop(), + erupeConfig: &cfg.Config{ + Host: "127.0.0.1", + Entrance: cfg.Entrance{Port: 53310}, + Capture: cfg.CaptureOptions{ + Enabled: true, + CaptureEntrance: true, + OutputDir: "", // empty → should default to "captures" + }, + }, + } + + mc := newMockConn() + origConn := network.NewCryptConn(mc, cfg.ZZ, nil) + remoteAddr := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 12345} + + resultConn, cleanup := startEntranceCapture(server, origConn, remoteAddr) + defer cleanup() + + if resultConn == origConn { + t.Error("capture with default dir should return recording conn") + } + + info, err := os.Stat("captures") + if err != nil { + t.Fatalf("default 'captures' directory not created: %v", err) + } + if !info.IsDir() { + t.Error("'captures' should be a directory") + } +}