430 lines
17 KiB
Go
430 lines
17 KiB
Go
package service_test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
roomv1 "hyapp.local/api/proto/room/v1"
|
|
"hyapp/pkg/appcode"
|
|
"hyapp/services/room-service/internal/room/command"
|
|
"hyapp/services/room-service/internal/testutil/mysqltest"
|
|
)
|
|
|
|
func TestMicUpReturnsExistingSeatForDuplicateUserCommand(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
now := &fixedRoomRocketClock{now: time.Date(2026, 6, 4, 8, 0, 0, 0, time.UTC)}
|
|
svc := newRocketTestService(t, repository, &rocketTestWallet{}, now)
|
|
|
|
roomID := "room-mic-up-duplicate-user"
|
|
ownerID := int64(8501)
|
|
speakerID := int64(8502)
|
|
createRocketRoom(t, ctx, svc, roomID, ownerID, 9101)
|
|
joinRocketRoom(t, ctx, svc, roomID, speakerID)
|
|
|
|
upResp, err := svc.MicUp(ctx, &roomv1.MicUpRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "mic-up-duplicate-user-first"),
|
|
SeatNo: 2,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("first mic up failed: %v", err)
|
|
}
|
|
|
|
duplicateResp, err := svc.MicUp(ctx, &roomv1.MicUpRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "mic-up-duplicate-user-second"),
|
|
SeatNo: 3,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("duplicate mic up must return current session instead of conflict: %v", err)
|
|
}
|
|
if duplicateResp.GetResult().GetApplied() {
|
|
t.Fatalf("duplicate mic up must be a no-op mutation: %+v", duplicateResp.GetResult())
|
|
}
|
|
if duplicateResp.GetRoom().GetVersion() != upResp.GetRoom().GetVersion() {
|
|
t.Fatalf("duplicate mic up must not advance room version: got=%d want=%d", duplicateResp.GetRoom().GetVersion(), upResp.GetRoom().GetVersion())
|
|
}
|
|
if duplicateResp.GetSeatNo() != 2 || duplicateResp.GetMicSessionId() != upResp.GetMicSessionId() || duplicateResp.GetPublishDeadlineMs() != upResp.GetPublishDeadlineMs() {
|
|
t.Fatalf("duplicate mic up must return original mic session: duplicate=%+v first=%+v", duplicateResp, upResp)
|
|
}
|
|
if originalSeat := seatByNo(duplicateResp.GetRoom(), 2); originalSeat == nil || originalSeat.GetUserId() != speakerID || originalSeat.GetMicSessionId() != upResp.GetMicSessionId() {
|
|
t.Fatalf("original seat must remain occupied by speaker: %+v", originalSeat)
|
|
}
|
|
if requestedSeat := seatByNo(duplicateResp.GetRoom(), 3); requestedSeat == nil || requestedSeat.GetUserId() != 0 {
|
|
// 重复 MicUp 只能表达“我已经在麦上”的幂等结果；换到 seat 3 必须走 ChangeMicSeat。
|
|
t.Fatalf("duplicate mic up must not move user to requested seat: %+v", requestedSeat)
|
|
}
|
|
}
|
|
|
|
func TestConfirmMicPublishingAcceptsFastClientClockBeforeServerDeadline(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
now := &fixedRoomRocketClock{now: time.Date(2026, 6, 4, 8, 0, 0, 0, time.UTC)}
|
|
svc := newRocketTestService(t, repository, &rocketTestWallet{}, now)
|
|
|
|
roomID := "room-mic-confirm-fast-client-clock"
|
|
ownerID := int64(8551)
|
|
speakerID := int64(8552)
|
|
createRocketRoom(t, ctx, svc, roomID, ownerID, 9101)
|
|
joinRocketRoom(t, ctx, svc, roomID, speakerID)
|
|
|
|
upResp, err := svc.MicUp(ctx, &roomv1.MicUpRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "mic-confirm-fast-clock-up"),
|
|
SeatNo: 2,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("mic up failed: %v", err)
|
|
}
|
|
|
|
arrivedAtMS := upResp.GetPublishDeadlineMs() - 1
|
|
fastClientEventMS := upResp.GetPublishDeadlineMs() + int64((5 * time.Second).Milliseconds())
|
|
now.now = time.UnixMilli(arrivedAtMS)
|
|
confirmMeta := rocketMeta(roomID, speakerID, "mic-confirm-fast-clock-confirm")
|
|
confirmResp, err := svc.ConfirmMicPublishing(ctx, &roomv1.ConfirmMicPublishingRequest{
|
|
Meta: confirmMeta,
|
|
MicSessionId: upResp.GetMicSessionId(),
|
|
RoomVersion: upResp.GetRoom().GetVersion(),
|
|
EventTimeMs: fastClientEventMS,
|
|
Source: "client",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("confirm mic publishing failed: %v", err)
|
|
}
|
|
if !confirmResp.GetResult().GetApplied() {
|
|
t.Fatalf("fast client event_time_ms must not be treated as timeout before server deadline: %+v", confirmResp.GetResult())
|
|
}
|
|
seat := seatByNo(confirmResp.GetRoom(), 2)
|
|
if seat == nil || seat.GetPublishState() != "publishing" {
|
|
t.Fatalf("seat must be confirmed as publishing: %+v", seat)
|
|
}
|
|
if seat.GetLastPublishEventTimeMs() != arrivedAtMS || seat.GetMicHeartbeatAtMs() != arrivedAtMS {
|
|
t.Fatalf("confirmation must store server accepted time, not fast client event time: seat=%+v accepted=%d client_event=%d", seat, arrivedAtMS, fastClientEventMS)
|
|
}
|
|
|
|
record, exists, err := repository.GetCommand(appcode.WithContext(ctx, appcode.Default), roomID, confirmMeta.GetCommandId())
|
|
if err != nil {
|
|
t.Fatalf("get confirm command log failed: %v", err)
|
|
}
|
|
if !exists {
|
|
t.Fatalf("confirm command log must be persisted")
|
|
}
|
|
decoded, err := command.Deserialize(command.ConfirmMicPublishing{}.Type(), record.Payload)
|
|
if err != nil {
|
|
t.Fatalf("decode confirm command log failed: %v", err)
|
|
}
|
|
confirmCmd, ok := decoded.(*command.ConfirmMicPublishing)
|
|
if !ok {
|
|
t.Fatalf("confirm command log has unexpected type: %T", decoded)
|
|
}
|
|
if confirmCmd.EventTimeMS != fastClientEventMS || confirmCmd.AcceptedEventTimeMS != arrivedAtMS {
|
|
t.Fatalf("confirm command log must keep raw client time and accepted server time: %+v raw=%d accepted=%d", confirmCmd, fastClientEventMS, arrivedAtMS)
|
|
}
|
|
}
|
|
|
|
func TestConfirmMicPublishingIgnoresStaleSessionVersionAndTimeout(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
adjust func(clock *fixedRoomRocketClock, upResp *roomv1.MicUpResponse)
|
|
request func(roomID string, speakerID int64, clock *fixedRoomRocketClock, upResp *roomv1.MicUpResponse) *roomv1.ConfirmMicPublishingRequest
|
|
}{
|
|
{
|
|
name: "old_session",
|
|
adjust: func(clock *fixedRoomRocketClock, _ *roomv1.MicUpResponse) {
|
|
clock.now = clock.now.Add(500 * time.Millisecond)
|
|
},
|
|
request: func(roomID string, speakerID int64, clock *fixedRoomRocketClock, upResp *roomv1.MicUpResponse) *roomv1.ConfirmMicPublishingRequest {
|
|
return &roomv1.ConfirmMicPublishingRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "mic-confirm-old-session"),
|
|
MicSessionId: upResp.GetMicSessionId() + "-old",
|
|
RoomVersion: upResp.GetRoom().GetVersion(),
|
|
EventTimeMs: clock.Now().UnixMilli(),
|
|
Source: "client",
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "old_room_version",
|
|
adjust: func(clock *fixedRoomRocketClock, _ *roomv1.MicUpResponse) {
|
|
clock.now = clock.now.Add(500 * time.Millisecond)
|
|
},
|
|
request: func(roomID string, speakerID int64, clock *fixedRoomRocketClock, upResp *roomv1.MicUpResponse) *roomv1.ConfirmMicPublishingRequest {
|
|
return &roomv1.ConfirmMicPublishingRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "mic-confirm-old-room-version"),
|
|
MicSessionId: upResp.GetMicSessionId(),
|
|
RoomVersion: upResp.GetRoom().GetVersion() - 1,
|
|
EventTimeMs: clock.Now().UnixMilli(),
|
|
Source: "client",
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "deadline_reached",
|
|
adjust: func(clock *fixedRoomRocketClock, upResp *roomv1.MicUpResponse) {
|
|
clock.now = time.UnixMilli(upResp.GetPublishDeadlineMs())
|
|
},
|
|
request: func(roomID string, speakerID int64, _ *fixedRoomRocketClock, upResp *roomv1.MicUpResponse) *roomv1.ConfirmMicPublishingRequest {
|
|
return &roomv1.ConfirmMicPublishingRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "mic-confirm-deadline-reached"),
|
|
MicSessionId: upResp.GetMicSessionId(),
|
|
RoomVersion: upResp.GetRoom().GetVersion(),
|
|
EventTimeMs: upResp.GetPublishDeadlineMs() - 1,
|
|
Source: "client",
|
|
}
|
|
},
|
|
},
|
|
}
|
|
|
|
for index, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
now := &fixedRoomRocketClock{now: time.Date(2026, 6, 4, 8, 0, 0, 0, time.UTC)}
|
|
svc := newRocketTestService(t, repository, &rocketTestWallet{}, now)
|
|
|
|
roomID := fmt.Sprintf("room-mic-confirm-guard-%d", index)
|
|
ownerID := int64(8561 + index*10)
|
|
speakerID := int64(8562 + index*10)
|
|
createRocketRoom(t, ctx, svc, roomID, ownerID, 9101)
|
|
joinRocketRoom(t, ctx, svc, roomID, speakerID)
|
|
|
|
upResp, err := svc.MicUp(ctx, &roomv1.MicUpRequest{
|
|
Meta: rocketMeta(roomID, speakerID, fmt.Sprintf("mic-confirm-guard-up-%d", index)),
|
|
SeatNo: 2,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("mic up failed: %v", err)
|
|
}
|
|
tt.adjust(now, upResp)
|
|
|
|
confirmResp, err := svc.ConfirmMicPublishing(ctx, tt.request(roomID, speakerID, now, upResp))
|
|
if err != nil {
|
|
t.Fatalf("stale confirm must be ignored without error: %v", err)
|
|
}
|
|
if confirmResp.GetResult().GetApplied() || confirmResp.GetRoom().GetVersion() != upResp.GetRoom().GetVersion() {
|
|
t.Fatalf("stale confirm must not advance room state: confirm=%+v up_version=%d", confirmResp.GetResult(), upResp.GetRoom().GetVersion())
|
|
}
|
|
seat := seatByNo(confirmResp.GetRoom(), 2)
|
|
if seat == nil || seat.GetPublishState() != "pending_publish" || seat.GetLastPublishEventTimeMs() != 0 || seat.GetMicHeartbeatAtMs() != 0 {
|
|
t.Fatalf("stale confirm must leave pending session untouched: %+v", seat)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestMicHeartbeatRefreshesPublishingSessionAndPresence(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
now := &fixedRoomRocketClock{now: time.Date(2026, 6, 4, 8, 0, 0, 0, time.UTC)}
|
|
svc := newRocketTestService(t, repository, &rocketTestWallet{}, now)
|
|
|
|
roomID := "room-mic-heartbeat"
|
|
ownerID := int64(8601)
|
|
speakerID := int64(8602)
|
|
createRocketRoom(t, ctx, svc, roomID, ownerID, 9101)
|
|
joinRocketRoom(t, ctx, svc, roomID, speakerID)
|
|
|
|
upResp, err := svc.MicUp(ctx, &roomv1.MicUpRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "mic-heartbeat-up"),
|
|
SeatNo: 2,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("mic up failed: %v", err)
|
|
}
|
|
now.now = now.now.Add(500 * time.Millisecond)
|
|
confirmResp, err := svc.ConfirmMicPublishing(ctx, &roomv1.ConfirmMicPublishingRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "mic-heartbeat-confirm"),
|
|
MicSessionId: upResp.GetMicSessionId(),
|
|
RoomVersion: upResp.GetRoom().GetVersion(),
|
|
EventTimeMs: now.Now().UnixMilli(),
|
|
Source: "client",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("confirm mic publishing failed: %v", err)
|
|
}
|
|
confirmedSeat := seatByNo(confirmResp.GetRoom(), 2)
|
|
if confirmedSeat == nil || confirmedSeat.GetPublishState() != "publishing" || confirmedSeat.GetMicHeartbeatAtMs() == 0 {
|
|
t.Fatalf("publish confirmation must initialize heartbeat: %+v", confirmedSeat)
|
|
}
|
|
|
|
now.now = now.now.Add(3 * time.Second)
|
|
heartbeatAtMS := now.Now().UnixMilli()
|
|
heartbeatResp, err := svc.MicHeartbeat(ctx, &roomv1.MicHeartbeatRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "mic-heartbeat-refresh"),
|
|
MicSessionId: upResp.GetMicSessionId(),
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("mic heartbeat failed: %v", err)
|
|
}
|
|
if heartbeatResp.GetSeatNo() != 2 || heartbeatResp.GetMicHeartbeatAtMs() != heartbeatAtMS {
|
|
t.Fatalf("heartbeat response mismatch: %+v want_at=%d", heartbeatResp, heartbeatAtMS)
|
|
}
|
|
seat := seatByNo(heartbeatResp.GetRoom(), 2)
|
|
if seat == nil || seat.GetMicHeartbeatAtMs() != heartbeatAtMS {
|
|
t.Fatalf("seat heartbeat must be visible in snapshot: %+v", seat)
|
|
}
|
|
user := onlineUserByID(heartbeatResp.GetRoom(), speakerID)
|
|
if user == nil || user.GetLastSeenAtMs() != heartbeatAtMS {
|
|
t.Fatalf("mic heartbeat must refresh room presence: %+v", user)
|
|
}
|
|
}
|
|
|
|
func TestConfirmMicPublishingIgnoresBackwardEventTime(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
now := &fixedRoomRocketClock{now: time.Date(2026, 6, 4, 8, 0, 0, 0, time.UTC)}
|
|
svc := newRocketTestService(t, repository, &rocketTestWallet{}, now)
|
|
|
|
roomID := "room-mic-confirm-backward-event"
|
|
ownerID := int64(8651)
|
|
speakerID := int64(8652)
|
|
createRocketRoom(t, ctx, svc, roomID, ownerID, 9101)
|
|
joinRocketRoom(t, ctx, svc, roomID, speakerID)
|
|
|
|
upResp, err := svc.MicUp(ctx, &roomv1.MicUpRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "mic-confirm-backward-up"),
|
|
SeatNo: 2,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("mic up failed: %v", err)
|
|
}
|
|
now.now = now.now.Add(time.Second)
|
|
acceptedEventMS := now.Now().UnixMilli()
|
|
confirmResp, err := svc.ConfirmMicPublishing(ctx, &roomv1.ConfirmMicPublishingRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "mic-confirm-backward-first"),
|
|
MicSessionId: upResp.GetMicSessionId(),
|
|
RoomVersion: upResp.GetRoom().GetVersion(),
|
|
EventTimeMs: acceptedEventMS,
|
|
Source: "client",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("first confirm failed: %v", err)
|
|
}
|
|
if !confirmResp.GetResult().GetApplied() {
|
|
t.Fatalf("first confirm must apply: %+v", confirmResp.GetResult())
|
|
}
|
|
|
|
now.now = now.now.Add(time.Second)
|
|
backwardResp, err := svc.ConfirmMicPublishing(ctx, &roomv1.ConfirmMicPublishingRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "mic-confirm-backward-retry"),
|
|
MicSessionId: upResp.GetMicSessionId(),
|
|
RoomVersion: confirmResp.GetRoom().GetVersion(),
|
|
EventTimeMs: acceptedEventMS - 1,
|
|
Source: "client",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("backward confirm must be ignored without error: %v", err)
|
|
}
|
|
if backwardResp.GetResult().GetApplied() || backwardResp.GetRoom().GetVersion() != confirmResp.GetRoom().GetVersion() {
|
|
t.Fatalf("backward event must not advance room state: backward=%+v confirmed_version=%d", backwardResp.GetResult(), confirmResp.GetRoom().GetVersion())
|
|
}
|
|
seat := seatByNo(backwardResp.GetRoom(), 2)
|
|
if seat == nil || seat.GetPublishState() != "publishing" || seat.GetLastPublishEventTimeMs() != acceptedEventMS {
|
|
t.Fatalf("backward event must not lower accepted event time: %+v want_event=%d", seat, acceptedEventMS)
|
|
}
|
|
}
|
|
|
|
func TestRTCAudioStoppedReleasesAfterFastClientConfirmWatermark(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
now := &fixedRoomRocketClock{now: time.Date(2026, 6, 4, 8, 0, 0, 0, time.UTC)}
|
|
svc := newRocketTestService(t, repository, &rocketTestWallet{}, now)
|
|
|
|
roomID := "room-rtc-stop-after-fast-confirm"
|
|
ownerID := int64(8661)
|
|
speakerID := int64(8662)
|
|
createRocketRoom(t, ctx, svc, roomID, ownerID, 9101)
|
|
joinRocketRoom(t, ctx, svc, roomID, speakerID)
|
|
|
|
upResp, err := svc.MicUp(ctx, &roomv1.MicUpRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "rtc-stop-after-fast-confirm-up"),
|
|
SeatNo: 2,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("mic up failed: %v", err)
|
|
}
|
|
createdAtMS := upResp.GetPublishDeadlineMs() - int64((15 * time.Second).Milliseconds())
|
|
stopEventMS := createdAtMS + int64((2 * time.Second).Milliseconds())
|
|
acceptedAtMS := upResp.GetPublishDeadlineMs() - 1
|
|
now.now = time.UnixMilli(acceptedAtMS)
|
|
confirmResp, err := svc.ConfirmMicPublishing(ctx, &roomv1.ConfirmMicPublishingRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "rtc-stop-after-fast-confirm-confirm"),
|
|
MicSessionId: upResp.GetMicSessionId(),
|
|
RoomVersion: upResp.GetRoom().GetVersion(),
|
|
EventTimeMs: upResp.GetPublishDeadlineMs() + 5000,
|
|
Source: "client",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("confirm mic publishing failed: %v", err)
|
|
}
|
|
confirmedSeat := seatByNo(confirmResp.GetRoom(), 2)
|
|
if confirmedSeat == nil || confirmedSeat.GetLastPublishEventTimeMs() != acceptedAtMS {
|
|
t.Fatalf("confirm must store accepted watermark before RTC stop test: %+v accepted=%d", confirmedSeat, acceptedAtMS)
|
|
}
|
|
|
|
now.now = now.now.Add(time.Second)
|
|
stopResp, err := svc.ApplyRTCEvent(ctx, &roomv1.ApplyRTCEventRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "rtc-stop-after-fast-confirm-stop"),
|
|
TargetUserId: speakerID,
|
|
EventType: "audio_stopped",
|
|
EventTimeMs: stopEventMS,
|
|
Reason: "rtc_audio_stopped:0",
|
|
Source: "tencent_rtc_callback",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("rtc audio stopped failed: %v", err)
|
|
}
|
|
if !stopResp.GetResult().GetApplied() {
|
|
t.Fatalf("rtc stop must release current mic session even when provider event time is below client confirm accepted time: %+v", stopResp.GetResult())
|
|
}
|
|
seat := seatByNo(stopResp.GetRoom(), 2)
|
|
if seat == nil || seat.GetUserId() != 0 || seat.GetMicSessionId() != "" {
|
|
t.Fatalf("rtc stop must clear current mic seat: %+v", seat)
|
|
}
|
|
}
|
|
|
|
func TestMicHeartbeatRejectsPendingSession(t *testing.T) {
|
|
ctx := context.Background()
|
|
repository := mysqltest.NewRepository(t)
|
|
now := &fixedRoomRocketClock{now: time.Date(2026, 6, 4, 8, 0, 0, 0, time.UTC)}
|
|
svc := newRocketTestService(t, repository, &rocketTestWallet{}, now)
|
|
|
|
roomID := "room-mic-heartbeat-pending"
|
|
ownerID := int64(8701)
|
|
speakerID := int64(8702)
|
|
createRocketRoom(t, ctx, svc, roomID, ownerID, 9101)
|
|
joinRocketRoom(t, ctx, svc, roomID, speakerID)
|
|
|
|
upResp, err := svc.MicUp(ctx, &roomv1.MicUpRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "mic-heartbeat-pending-up"),
|
|
SeatNo: 1,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("mic up failed: %v", err)
|
|
}
|
|
if _, err := svc.MicHeartbeat(ctx, &roomv1.MicHeartbeatRequest{
|
|
Meta: rocketMeta(roomID, speakerID, "mic-heartbeat-pending-refresh"),
|
|
MicSessionId: upResp.GetMicSessionId(),
|
|
}); err == nil {
|
|
t.Fatalf("pending_publish session must not accept mic heartbeat before publish confirmation")
|
|
}
|
|
}
|
|
|
|
func seatByNo(snapshot *roomv1.RoomSnapshot, seatNo int32) *roomv1.SeatState {
|
|
for _, seat := range snapshot.GetMicSeats() {
|
|
if seat.GetSeatNo() == seatNo {
|
|
return seat
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func onlineUserByID(snapshot *roomv1.RoomSnapshot, userID int64) *roomv1.RoomUser {
|
|
for _, user := range snapshot.GetOnlineUsers() {
|
|
if user.GetUserId() == userID {
|
|
return user
|
|
}
|
|
}
|
|
return nil
|
|
}
|