feat: notification service

2026-04-22 08:49:45 +02:00
parent 5b7593e6f6
commit 32dc29359a
135 changed files with 21828 additions and 130 deletions
@@ -0,0 +1,390 @@
+package transcoder
+
+import (
+	"errors"
+	"fmt"
+
+	notificationfbs "galaxy/schema/fbs/notification"
+
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+// GameTurnReadyEvent is the independent Go representation of
+// `notification.GameTurnReadyEvent`.
+type GameTurnReadyEvent struct {
+	GameID     string
+	TurnNumber int64
+}
+
+// GameFinishedEvent is the independent Go representation of
+// `notification.GameFinishedEvent`.
+type GameFinishedEvent struct {
+	GameID          string
+	FinalTurnNumber int64
+}
+
+// LobbyApplicationSubmittedEvent is the independent Go representation of
+// `notification.LobbyApplicationSubmittedEvent`.
+type LobbyApplicationSubmittedEvent struct {
+	GameID          string
+	ApplicantUserID string
+}
+
+// LobbyMembershipApprovedEvent is the independent Go representation of
+// `notification.LobbyMembershipApprovedEvent`.
+type LobbyMembershipApprovedEvent struct {
+	GameID string
+}
+
+// LobbyMembershipRejectedEvent is the independent Go representation of
+// `notification.LobbyMembershipRejectedEvent`.
+type LobbyMembershipRejectedEvent struct {
+	GameID string
+}
+
+// LobbyInviteCreatedEvent is the independent Go representation of
+// `notification.LobbyInviteCreatedEvent`.
+type LobbyInviteCreatedEvent struct {
+	GameID        string
+	InviterUserID string
+}
+
+// LobbyInviteRedeemedEvent is the independent Go representation of
+// `notification.LobbyInviteRedeemedEvent`.
+type LobbyInviteRedeemedEvent struct {
+	GameID        string
+	InviteeUserID string
+}
+
+// GameTurnReadyEventToPayload converts GameTurnReadyEvent to FlatBuffers bytes
+// suitable for the authenticated gateway push transport.
+func GameTurnReadyEventToPayload(event *GameTurnReadyEvent) ([]byte, error) {
+	if event == nil {
+		return nil, errors.New("encode game turn ready payload: event is nil")
+	}
+	if event.GameID == "" {
+		return nil, errors.New("encode game turn ready payload: game_id is empty")
+	}
+
+	builder := flatbuffers.NewBuilder(64)
+	gameID := builder.CreateString(event.GameID)
+
+	notificationfbs.GameTurnReadyEventStart(builder)
+	notificationfbs.GameTurnReadyEventAddGameId(builder, gameID)
+	notificationfbs.GameTurnReadyEventAddTurnNumber(builder, event.TurnNumber)
+	offset := notificationfbs.GameTurnReadyEventEnd(builder)
+	notificationfbs.FinishGameTurnReadyEventBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToGameTurnReadyEvent converts FlatBuffers payload bytes into
+// GameTurnReadyEvent.
+func PayloadToGameTurnReadyEvent(data []byte) (result *GameTurnReadyEvent, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode game turn ready payload: data is empty")
+	}
+
+	defer recoverNotificationDecodePanic("decode game turn ready payload", &result, &err)
+
+	event := notificationfbs.GetRootAsGameTurnReadyEvent(data, 0)
+	gameID, err := requiredNotificationString(event.GameId(), "game_id")
+	if err != nil {
+		return nil, fmt.Errorf("decode game turn ready payload: %w", err)
+	}
+
+	return &GameTurnReadyEvent{
+		GameID:     gameID,
+		TurnNumber: event.TurnNumber(),
+	}, nil
+}
+
+// GameFinishedEventToPayload converts GameFinishedEvent to FlatBuffers bytes
+// suitable for the authenticated gateway push transport.
+func GameFinishedEventToPayload(event *GameFinishedEvent) ([]byte, error) {
+	if event == nil {
+		return nil, errors.New("encode game finished payload: event is nil")
+	}
+	if event.GameID == "" {
+		return nil, errors.New("encode game finished payload: game_id is empty")
+	}
+
+	builder := flatbuffers.NewBuilder(64)
+	gameID := builder.CreateString(event.GameID)
+
+	notificationfbs.GameFinishedEventStart(builder)
+	notificationfbs.GameFinishedEventAddGameId(builder, gameID)
+	notificationfbs.GameFinishedEventAddFinalTurnNumber(builder, event.FinalTurnNumber)
+	offset := notificationfbs.GameFinishedEventEnd(builder)
+	notificationfbs.FinishGameFinishedEventBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToGameFinishedEvent converts FlatBuffers payload bytes into
+// GameFinishedEvent.
+func PayloadToGameFinishedEvent(data []byte) (result *GameFinishedEvent, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode game finished payload: data is empty")
+	}
+
+	defer recoverNotificationDecodePanic("decode game finished payload", &result, &err)
+
+	event := notificationfbs.GetRootAsGameFinishedEvent(data, 0)
+	gameID, err := requiredNotificationString(event.GameId(), "game_id")
+	if err != nil {
+		return nil, fmt.Errorf("decode game finished payload: %w", err)
+	}
+
+	return &GameFinishedEvent{
+		GameID:          gameID,
+		FinalTurnNumber: event.FinalTurnNumber(),
+	}, nil
+}
+
+// LobbyApplicationSubmittedEventToPayload converts
+// LobbyApplicationSubmittedEvent to FlatBuffers bytes suitable for the
+// authenticated gateway push transport.
+func LobbyApplicationSubmittedEventToPayload(event *LobbyApplicationSubmittedEvent) ([]byte, error) {
+	if event == nil {
+		return nil, errors.New("encode lobby application submitted payload: event is nil")
+	}
+	if event.GameID == "" {
+		return nil, errors.New("encode lobby application submitted payload: game_id is empty")
+	}
+	if event.ApplicantUserID == "" {
+		return nil, errors.New("encode lobby application submitted payload: applicant_user_id is empty")
+	}
+
+	builder := flatbuffers.NewBuilder(96)
+	gameID := builder.CreateString(event.GameID)
+	applicantUserID := builder.CreateString(event.ApplicantUserID)
+
+	notificationfbs.LobbyApplicationSubmittedEventStart(builder)
+	notificationfbs.LobbyApplicationSubmittedEventAddGameId(builder, gameID)
+	notificationfbs.LobbyApplicationSubmittedEventAddApplicantUserId(builder, applicantUserID)
+	offset := notificationfbs.LobbyApplicationSubmittedEventEnd(builder)
+	notificationfbs.FinishLobbyApplicationSubmittedEventBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToLobbyApplicationSubmittedEvent converts FlatBuffers payload bytes
+// into LobbyApplicationSubmittedEvent.
+func PayloadToLobbyApplicationSubmittedEvent(data []byte) (result *LobbyApplicationSubmittedEvent, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode lobby application submitted payload: data is empty")
+	}
+
+	defer recoverNotificationDecodePanic("decode lobby application submitted payload", &result, &err)
+
+	event := notificationfbs.GetRootAsLobbyApplicationSubmittedEvent(data, 0)
+	gameID, err := requiredNotificationString(event.GameId(), "game_id")
+	if err != nil {
+		return nil, fmt.Errorf("decode lobby application submitted payload: %w", err)
+	}
+	applicantUserID, err := requiredNotificationString(event.ApplicantUserId(), "applicant_user_id")
+	if err != nil {
+		return nil, fmt.Errorf("decode lobby application submitted payload: %w", err)
+	}
+
+	return &LobbyApplicationSubmittedEvent{
+		GameID:          gameID,
+		ApplicantUserID: applicantUserID,
+	}, nil
+}
+
+// LobbyMembershipApprovedEventToPayload converts LobbyMembershipApprovedEvent
+// to FlatBuffers bytes suitable for the authenticated gateway push transport.
+func LobbyMembershipApprovedEventToPayload(event *LobbyMembershipApprovedEvent) ([]byte, error) {
+	if event == nil {
+		return nil, errors.New("encode lobby membership approved payload: event is nil")
+	}
+	if event.GameID == "" {
+		return nil, errors.New("encode lobby membership approved payload: game_id is empty")
+	}
+
+	builder := flatbuffers.NewBuilder(48)
+	gameID := builder.CreateString(event.GameID)
+
+	notificationfbs.LobbyMembershipApprovedEventStart(builder)
+	notificationfbs.LobbyMembershipApprovedEventAddGameId(builder, gameID)
+	offset := notificationfbs.LobbyMembershipApprovedEventEnd(builder)
+	notificationfbs.FinishLobbyMembershipApprovedEventBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToLobbyMembershipApprovedEvent converts FlatBuffers payload bytes
+// into LobbyMembershipApprovedEvent.
+func PayloadToLobbyMembershipApprovedEvent(data []byte) (result *LobbyMembershipApprovedEvent, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode lobby membership approved payload: data is empty")
+	}
+
+	defer recoverNotificationDecodePanic("decode lobby membership approved payload", &result, &err)
+
+	event := notificationfbs.GetRootAsLobbyMembershipApprovedEvent(data, 0)
+	gameID, err := requiredNotificationString(event.GameId(), "game_id")
+	if err != nil {
+		return nil, fmt.Errorf("decode lobby membership approved payload: %w", err)
+	}
+
+	return &LobbyMembershipApprovedEvent{GameID: gameID}, nil
+}
+
+// LobbyMembershipRejectedEventToPayload converts LobbyMembershipRejectedEvent
+// to FlatBuffers bytes suitable for the authenticated gateway push transport.
+func LobbyMembershipRejectedEventToPayload(event *LobbyMembershipRejectedEvent) ([]byte, error) {
+	if event == nil {
+		return nil, errors.New("encode lobby membership rejected payload: event is nil")
+	}
+	if event.GameID == "" {
+		return nil, errors.New("encode lobby membership rejected payload: game_id is empty")
+	}
+
+	builder := flatbuffers.NewBuilder(48)
+	gameID := builder.CreateString(event.GameID)
+
+	notificationfbs.LobbyMembershipRejectedEventStart(builder)
+	notificationfbs.LobbyMembershipRejectedEventAddGameId(builder, gameID)
+	offset := notificationfbs.LobbyMembershipRejectedEventEnd(builder)
+	notificationfbs.FinishLobbyMembershipRejectedEventBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToLobbyMembershipRejectedEvent converts FlatBuffers payload bytes
+// into LobbyMembershipRejectedEvent.
+func PayloadToLobbyMembershipRejectedEvent(data []byte) (result *LobbyMembershipRejectedEvent, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode lobby membership rejected payload: data is empty")
+	}
+
+	defer recoverNotificationDecodePanic("decode lobby membership rejected payload", &result, &err)
+
+	event := notificationfbs.GetRootAsLobbyMembershipRejectedEvent(data, 0)
+	gameID, err := requiredNotificationString(event.GameId(), "game_id")
+	if err != nil {
+		return nil, fmt.Errorf("decode lobby membership rejected payload: %w", err)
+	}
+
+	return &LobbyMembershipRejectedEvent{GameID: gameID}, nil
+}
+
+// LobbyInviteCreatedEventToPayload converts LobbyInviteCreatedEvent to
+// FlatBuffers bytes suitable for the authenticated gateway push transport.
+func LobbyInviteCreatedEventToPayload(event *LobbyInviteCreatedEvent) ([]byte, error) {
+	if event == nil {
+		return nil, errors.New("encode lobby invite created payload: event is nil")
+	}
+	if event.GameID == "" {
+		return nil, errors.New("encode lobby invite created payload: game_id is empty")
+	}
+	if event.InviterUserID == "" {
+		return nil, errors.New("encode lobby invite created payload: inviter_user_id is empty")
+	}
+
+	builder := flatbuffers.NewBuilder(96)
+	gameID := builder.CreateString(event.GameID)
+	inviterUserID := builder.CreateString(event.InviterUserID)
+
+	notificationfbs.LobbyInviteCreatedEventStart(builder)
+	notificationfbs.LobbyInviteCreatedEventAddGameId(builder, gameID)
+	notificationfbs.LobbyInviteCreatedEventAddInviterUserId(builder, inviterUserID)
+	offset := notificationfbs.LobbyInviteCreatedEventEnd(builder)
+	notificationfbs.FinishLobbyInviteCreatedEventBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToLobbyInviteCreatedEvent converts FlatBuffers payload bytes into
+// LobbyInviteCreatedEvent.
+func PayloadToLobbyInviteCreatedEvent(data []byte) (result *LobbyInviteCreatedEvent, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode lobby invite created payload: data is empty")
+	}
+
+	defer recoverNotificationDecodePanic("decode lobby invite created payload", &result, &err)
+
+	event := notificationfbs.GetRootAsLobbyInviteCreatedEvent(data, 0)
+	gameID, err := requiredNotificationString(event.GameId(), "game_id")
+	if err != nil {
+		return nil, fmt.Errorf("decode lobby invite created payload: %w", err)
+	}
+	inviterUserID, err := requiredNotificationString(event.InviterUserId(), "inviter_user_id")
+	if err != nil {
+		return nil, fmt.Errorf("decode lobby invite created payload: %w", err)
+	}
+
+	return &LobbyInviteCreatedEvent{
+		GameID:        gameID,
+		InviterUserID: inviterUserID,
+	}, nil
+}
+
+// LobbyInviteRedeemedEventToPayload converts LobbyInviteRedeemedEvent to
+// FlatBuffers bytes suitable for the authenticated gateway push transport.
+func LobbyInviteRedeemedEventToPayload(event *LobbyInviteRedeemedEvent) ([]byte, error) {
+	if event == nil {
+		return nil, errors.New("encode lobby invite redeemed payload: event is nil")
+	}
+	if event.GameID == "" {
+		return nil, errors.New("encode lobby invite redeemed payload: game_id is empty")
+	}
+	if event.InviteeUserID == "" {
+		return nil, errors.New("encode lobby invite redeemed payload: invitee_user_id is empty")
+	}
+
+	builder := flatbuffers.NewBuilder(96)
+	gameID := builder.CreateString(event.GameID)
+	inviteeUserID := builder.CreateString(event.InviteeUserID)
+
+	notificationfbs.LobbyInviteRedeemedEventStart(builder)
+	notificationfbs.LobbyInviteRedeemedEventAddGameId(builder, gameID)
+	notificationfbs.LobbyInviteRedeemedEventAddInviteeUserId(builder, inviteeUserID)
+	offset := notificationfbs.LobbyInviteRedeemedEventEnd(builder)
+	notificationfbs.FinishLobbyInviteRedeemedEventBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToLobbyInviteRedeemedEvent converts FlatBuffers payload bytes into
+// LobbyInviteRedeemedEvent.
+func PayloadToLobbyInviteRedeemedEvent(data []byte) (result *LobbyInviteRedeemedEvent, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode lobby invite redeemed payload: data is empty")
+	}
+
+	defer recoverNotificationDecodePanic("decode lobby invite redeemed payload", &result, &err)
+
+	event := notificationfbs.GetRootAsLobbyInviteRedeemedEvent(data, 0)
+	gameID, err := requiredNotificationString(event.GameId(), "game_id")
+	if err != nil {
+		return nil, fmt.Errorf("decode lobby invite redeemed payload: %w", err)
+	}
+	inviteeUserID, err := requiredNotificationString(event.InviteeUserId(), "invitee_user_id")
+	if err != nil {
+		return nil, fmt.Errorf("decode lobby invite redeemed payload: %w", err)
+	}
+
+	return &LobbyInviteRedeemedEvent{
+		GameID:        gameID,
+		InviteeUserID: inviteeUserID,
+	}, nil
+}
+
+func requiredNotificationString(value []byte, field string) (string, error) {
+	if len(value) == 0 {
+		return "", fmt.Errorf("%s is missing", field)
+	}
+
+	return string(value), nil
+}
+
+func recoverNotificationDecodePanic[T any](message string, result **T, err *error) {
+	if recovered := recover(); recovered != nil {
+		*result = nil
+		*err = fmt.Errorf("%s: panic recovered: %v", message, recovered)
+	}
+}
@@ -0,0 +1,387 @@
+package transcoder
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+
+	notificationfbs "galaxy/schema/fbs/notification"
+
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+func TestNotificationPayloadRoundTrips(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name   string
+		source any
+		encode func(any) ([]byte, error)
+		decode func([]byte) (any, error)
+	}{
+		{
+			name:   "game turn ready",
+			source: &GameTurnReadyEvent{GameID: "game-1", TurnNumber: 54},
+			encode: func(value any) ([]byte, error) { return GameTurnReadyEventToPayload(value.(*GameTurnReadyEvent)) },
+			decode: func(data []byte) (any, error) { return PayloadToGameTurnReadyEvent(data) },
+		},
+		{
+			name:   "game finished",
+			source: &GameFinishedEvent{GameID: "game-2", FinalTurnNumber: 99},
+			encode: func(value any) ([]byte, error) { return GameFinishedEventToPayload(value.(*GameFinishedEvent)) },
+			decode: func(data []byte) (any, error) { return PayloadToGameFinishedEvent(data) },
+		},
+		{
+			name:   "lobby application submitted",
+			source: &LobbyApplicationSubmittedEvent{GameID: "game-3", ApplicantUserID: "user-7"},
+			encode: func(value any) ([]byte, error) {
+				return LobbyApplicationSubmittedEventToPayload(value.(*LobbyApplicationSubmittedEvent))
+			},
+			decode: func(data []byte) (any, error) { return PayloadToLobbyApplicationSubmittedEvent(data) },
+		},
+		{
+			name:   "lobby membership approved",
+			source: &LobbyMembershipApprovedEvent{GameID: "game-4"},
+			encode: func(value any) ([]byte, error) {
+				return LobbyMembershipApprovedEventToPayload(value.(*LobbyMembershipApprovedEvent))
+			},
+			decode: func(data []byte) (any, error) { return PayloadToLobbyMembershipApprovedEvent(data) },
+		},
+		{
+			name:   "lobby membership rejected",
+			source: &LobbyMembershipRejectedEvent{GameID: "game-5"},
+			encode: func(value any) ([]byte, error) {
+				return LobbyMembershipRejectedEventToPayload(value.(*LobbyMembershipRejectedEvent))
+			},
+			decode: func(data []byte) (any, error) { return PayloadToLobbyMembershipRejectedEvent(data) },
+		},
+		{
+			name:   "lobby invite created",
+			source: &LobbyInviteCreatedEvent{GameID: "game-6", InviterUserID: "user-8"},
+			encode: func(value any) ([]byte, error) {
+				return LobbyInviteCreatedEventToPayload(value.(*LobbyInviteCreatedEvent))
+			},
+			decode: func(data []byte) (any, error) { return PayloadToLobbyInviteCreatedEvent(data) },
+		},
+		{
+			name:   "lobby invite redeemed",
+			source: &LobbyInviteRedeemedEvent{GameID: "game-7", InviteeUserID: "user-9"},
+			encode: func(value any) ([]byte, error) {
+				return LobbyInviteRedeemedEventToPayload(value.(*LobbyInviteRedeemedEvent))
+			},
+			decode: func(data []byte) (any, error) { return PayloadToLobbyInviteRedeemedEvent(data) },
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			payload, err := tt.encode(tt.source)
+			if err != nil {
+				t.Fatalf("encode payload: %v", err)
+			}
+
+			decoded, err := tt.decode(payload)
+			if err != nil {
+				t.Fatalf("decode payload: %v", err)
+			}
+
+			if !reflect.DeepEqual(tt.source, decoded) {
+				t.Fatalf("round-trip mismatch\nsource: %#v\ndecoded:%#v", tt.source, decoded)
+			}
+		})
+	}
+}
+
+func TestNotificationPayloadEncodersRejectNilInputs(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		call func() error
+	}{
+		{
+			name: "game turn ready",
+			call: func() error {
+				_, err := GameTurnReadyEventToPayload(nil)
+				return err
+			},
+		},
+		{
+			name: "game finished",
+			call: func() error {
+				_, err := GameFinishedEventToPayload(nil)
+				return err
+			},
+		},
+		{
+			name: "lobby application submitted",
+			call: func() error {
+				_, err := LobbyApplicationSubmittedEventToPayload(nil)
+				return err
+			},
+		},
+		{
+			name: "lobby membership approved",
+			call: func() error {
+				_, err := LobbyMembershipApprovedEventToPayload(nil)
+				return err
+			},
+		},
+		{
+			name: "lobby membership rejected",
+			call: func() error {
+				_, err := LobbyMembershipRejectedEventToPayload(nil)
+				return err
+			},
+		},
+		{
+			name: "lobby invite created",
+			call: func() error {
+				_, err := LobbyInviteCreatedEventToPayload(nil)
+				return err
+			},
+		},
+		{
+			name: "lobby invite redeemed",
+			call: func() error {
+				_, err := LobbyInviteRedeemedEventToPayload(nil)
+				return err
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			if err := tt.call(); err == nil {
+				t.Fatal("expected error")
+			}
+		})
+	}
+}
+
+func TestNotificationPayloadDecodersRejectEmptyPayloads(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		call func() error
+	}{
+		{
+			name: "game turn ready",
+			call: func() error {
+				_, err := PayloadToGameTurnReadyEvent(nil)
+				return err
+			},
+		},
+		{
+			name: "game finished",
+			call: func() error {
+				_, err := PayloadToGameFinishedEvent(nil)
+				return err
+			},
+		},
+		{
+			name: "lobby application submitted",
+			call: func() error {
+				_, err := PayloadToLobbyApplicationSubmittedEvent(nil)
+				return err
+			},
+		},
+		{
+			name: "lobby membership approved",
+			call: func() error {
+				_, err := PayloadToLobbyMembershipApprovedEvent(nil)
+				return err
+			},
+		},
+		{
+			name: "lobby membership rejected",
+			call: func() error {
+				_, err := PayloadToLobbyMembershipRejectedEvent(nil)
+				return err
+			},
+		},
+		{
+			name: "lobby invite created",
+			call: func() error {
+				_, err := PayloadToLobbyInviteCreatedEvent(nil)
+				return err
+			},
+		},
+		{
+			name: "lobby invite redeemed",
+			call: func() error {
+				_, err := PayloadToLobbyInviteRedeemedEvent(nil)
+				return err
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			if err := tt.call(); err == nil {
+				t.Fatal("expected error")
+			}
+		})
+	}
+}
+
+func TestNotificationPayloadEncodersRejectMissingRequiredStrings(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		call func() error
+		want string
+	}{
+		{
+			name: "game turn ready",
+			call: func() error {
+				_, err := GameTurnReadyEventToPayload(&GameTurnReadyEvent{})
+				return err
+			},
+			want: "game_id is empty",
+		},
+		{
+			name: "lobby application submitted",
+			call: func() error {
+				_, err := LobbyApplicationSubmittedEventToPayload(&LobbyApplicationSubmittedEvent{GameID: "game-1"})
+				return err
+			},
+			want: "applicant_user_id is empty",
+		},
+		{
+			name: "lobby invite created",
+			call: func() error {
+				_, err := LobbyInviteCreatedEventToPayload(&LobbyInviteCreatedEvent{GameID: "game-1"})
+				return err
+			},
+			want: "inviter_user_id is empty",
+		},
+		{
+			name: "lobby invite redeemed",
+			call: func() error {
+				_, err := LobbyInviteRedeemedEventToPayload(&LobbyInviteRedeemedEvent{GameID: "game-1"})
+				return err
+			},
+			want: "invitee_user_id is empty",
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			err := tt.call()
+			if err == nil {
+				t.Fatal("expected error")
+			}
+			if !strings.Contains(err.Error(), tt.want) {
+				t.Fatalf("unexpected error: %v", err)
+			}
+		})
+	}
+}
+
+func TestNotificationPayloadDecodersRejectMissingRequiredStrings(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name    string
+		payload func() []byte
+		decode  func([]byte) error
+		want    string
+	}{
+		{
+			name: "game turn ready",
+			payload: func() []byte {
+				builder := flatbuffers.NewBuilder(32)
+				notificationfbs.GameTurnReadyEventStart(builder)
+				offset := notificationfbs.GameTurnReadyEventEnd(builder)
+				notificationfbs.FinishGameTurnReadyEventBuffer(builder, offset)
+				return builder.FinishedBytes()
+			},
+			decode: func(data []byte) error {
+				_, err := PayloadToGameTurnReadyEvent(data)
+				return err
+			},
+			want: "game_id is missing",
+		},
+		{
+			name: "lobby application submitted",
+			payload: func() []byte {
+				builder := flatbuffers.NewBuilder(32)
+				gameID := builder.CreateString("game-1")
+				notificationfbs.LobbyApplicationSubmittedEventStart(builder)
+				notificationfbs.LobbyApplicationSubmittedEventAddGameId(builder, gameID)
+				offset := notificationfbs.LobbyApplicationSubmittedEventEnd(builder)
+				notificationfbs.FinishLobbyApplicationSubmittedEventBuffer(builder, offset)
+				return builder.FinishedBytes()
+			},
+			decode: func(data []byte) error {
+				_, err := PayloadToLobbyApplicationSubmittedEvent(data)
+				return err
+			},
+			want: "applicant_user_id is missing",
+		},
+		{
+			name: "lobby invite created",
+			payload: func() []byte {
+				builder := flatbuffers.NewBuilder(32)
+				gameID := builder.CreateString("game-1")
+				notificationfbs.LobbyInviteCreatedEventStart(builder)
+				notificationfbs.LobbyInviteCreatedEventAddGameId(builder, gameID)
+				offset := notificationfbs.LobbyInviteCreatedEventEnd(builder)
+				notificationfbs.FinishLobbyInviteCreatedEventBuffer(builder, offset)
+				return builder.FinishedBytes()
+			},
+			decode: func(data []byte) error {
+				_, err := PayloadToLobbyInviteCreatedEvent(data)
+				return err
+			},
+			want: "inviter_user_id is missing",
+		},
+		{
+			name: "lobby invite redeemed",
+			payload: func() []byte {
+				builder := flatbuffers.NewBuilder(32)
+				gameID := builder.CreateString("game-1")
+				notificationfbs.LobbyInviteRedeemedEventStart(builder)
+				notificationfbs.LobbyInviteRedeemedEventAddGameId(builder, gameID)
+				offset := notificationfbs.LobbyInviteRedeemedEventEnd(builder)
+				notificationfbs.FinishLobbyInviteRedeemedEventBuffer(builder, offset)
+				return builder.FinishedBytes()
+			},
+			decode: func(data []byte) error {
+				_, err := PayloadToLobbyInviteRedeemedEvent(data)
+				return err
+			},
+			want: "invitee_user_id is missing",
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			err := tt.decode(tt.payload())
+			if err == nil {
+				t.Fatal("expected error")
+			}
+			if !strings.Contains(err.Error(), tt.want) {
+				t.Fatalf("unexpected error: %v", err)
+			}
+		})
+	}
+}