Add test use cases

Author: Bologna

internal/core/services/events/events_forwarder_service.go

@@ -335,7 +335,18 @@ func (es *EventsForwarderService) updatePlayerState(ctx context.Context, event *
 		return
 	}
 
-	players := room.Metadata["players"].(int)
+	if room.IsValidationRoom {
+		return
+	}
+
+	if room.Metadata == nil {
+		room.Metadata = make(map[string]interface{})
+	}
+
+	var players int
+	if key, ok := room.Metadata["players"]; ok {
+		players = key.(int)
+	}
 
 	switch playerAttributes.EventType {
 	case events.PlayerJoin:

internal/core/services/events/events_forwarder_service_test.go

@@ -172,7 +172,76 @@ func TestEventsForwarderService_ProduceEvent(t *testing.T) {
 	})
 
 	t.Run("should succeed when event is PlayerEvent", func(t *testing.T) {
-		eventsForwarderService, config, eventsForwarder, schedulerStorage, _, instanceStorage, schedulerCache := testSetup(t)
+		eventsForwarderService, config, eventsForwarder, schedulerStorage, roomStorage, instanceStorage, schedulerCache := testSetup(t)
+
+		event := &events.Event{
+			Name:        events.PlayerEvent,
+			SchedulerID: expectedScheduler.Name,
+			RoomID:      "room",
+			Attributes: map[string]interface{}{
+				"eventType": "playerLeft",
+				"playerId":  "player",
+			},
+		}
+
+		room := &game_room.GameRoom{
+			ID:               event.RoomID,
+			SchedulerID:      event.SchedulerID,
+			IsValidationRoom: false,
+		}
+
+		schedulerCache.EXPECT().GetScheduler(context.Background(), event.SchedulerID).Return(nil, nil)
+		schedulerStorage.EXPECT().GetScheduler(context.Background(), event.SchedulerID).Return(expectedScheduler, nil)
+		instanceStorage.EXPECT().GetInstance(context.Background(), event.SchedulerID, event.RoomID).Return(expectedGameRoomInstance, nil).Times(0)
+		schedulerCache.EXPECT().SetScheduler(context.Background(), expectedScheduler, config.SchedulerCacheTtl).Return(nil)
+		eventsForwarder.EXPECT().ForwardPlayerEvent(context.Background(), gomock.Any(), gomock.Any()).Return(nil)
+		roomStorage.EXPECT().GetRoom(gomock.Any(), event.SchedulerID, event.RoomID).Return(room, nil)
+		roomStorage.EXPECT().UpdateRoom(gomock.Any(), gomock.Any()).Return(nil)
+
+		err := eventsForwarderService.ProduceEvent(context.Background(), event)
+		require.NoError(t, err)
+		require.Empty(t, event.Attributes["ports"])
+	})
+
+	t.Run("should increase player count for PlayerEvent", func(t *testing.T) {
+		eventsForwarderService, config, eventsForwarder, schedulerStorage, roomStorage, instanceStorage, schedulerCache := testSetup(t)
+
+		event := &events.Event{
+			Name:        events.PlayerEvent,
+			SchedulerID: expectedScheduler.Name,
+			RoomID:      "room",
+			Attributes: map[string]interface{}{
+				"eventType": "playerJoin",
+				"playerId":  "player",
+			},
+		}
+
+		room := &game_room.GameRoom{
+			ID:               event.RoomID,
+			SchedulerID:      event.SchedulerID,
+			IsValidationRoom: false,
+			Metadata: map[string]interface{}{
+				"players": 5,
+			},
+		}
+
+		schedulerCache.EXPECT().GetScheduler(context.Background(), event.SchedulerID).Return(nil, nil)
+		schedulerStorage.EXPECT().GetScheduler(context.Background(), event.SchedulerID).Return(expectedScheduler, nil)
+		instanceStorage.EXPECT().GetInstance(context.Background(), event.SchedulerID, event.RoomID).Return(expectedGameRoomInstance, nil).Times(0)
+		schedulerCache.EXPECT().SetScheduler(context.Background(), expectedScheduler, config.SchedulerCacheTtl).Return(nil)
+		eventsForwarder.EXPECT().ForwardPlayerEvent(context.Background(), gomock.Any(), gomock.Any()).Return(nil)
+		roomStorage.EXPECT().GetRoom(gomock.Any(), event.SchedulerID, event.RoomID).Return(room, nil)
+
+		room.Metadata["players"] = 6
+		roomStorage.EXPECT().UpdateRoom(gomock.Any(), room).Return(nil)
+
+		err := eventsForwarderService.ProduceEvent(context.Background(), event)
+		require.NoError(t, err)
+		require.Empty(t, event.Attributes["ports"])
+	})
+
+	t.Run("should decrease player count for PlayerEvent", func(t *testing.T) {
+		eventsForwarderService, config, eventsForwarder, schedulerStorage, roomStorage, instanceStorage, schedulerCache := testSetup(t)
 
 		event := &events.Event{
 			Name:        events.PlayerEvent,
@@ -184,11 +253,56 @@ func TestEventsForwarderService_ProduceEvent(t *testing.T) {
 			},
 		}
 
+		room := &game_room.GameRoom{
+			ID:               event.RoomID,
+			SchedulerID:      event.SchedulerID,
+			IsValidationRoom: true,
+		}
+
 		schedulerCache.EXPECT().GetScheduler(context.Background(), event.SchedulerID).Return(nil, nil)
 		schedulerStorage.EXPECT().GetScheduler(context.Background(), event.SchedulerID).Return(expectedScheduler, nil)
 		instanceStorage.EXPECT().GetInstance(context.Background(), event.SchedulerID, event.RoomID).Return(expectedGameRoomInstance, nil).Times(0)
 		schedulerCache.EXPECT().SetScheduler(context.Background(), expectedScheduler, config.SchedulerCacheTtl).Return(nil)
 		eventsForwarder.EXPECT().ForwardPlayerEvent(context.Background(), gomock.Any(), gomock.Any()).Return(nil)
+		roomStorage.EXPECT().GetRoom(gomock.Any(), event.SchedulerID, event.RoomID).Return(room, nil)
+		roomStorage.EXPECT().UpdateRoom(gomock.Any(), room).MaxTimes(0)
+
+		err := eventsForwarderService.ProduceEvent(context.Background(), event)
+		require.NoError(t, err)
+		require.Empty(t, event.Attributes["ports"])
+	})
+
+	t.Run("should ignore player state update for PlayerEvent", func(t *testing.T) {
+		eventsForwarderService, config, eventsForwarder, schedulerStorage, roomStorage, instanceStorage, schedulerCache := testSetup(t)
+
+		event := &events.Event{
+			Name:        events.PlayerEvent,
+			SchedulerID: expectedScheduler.Name,
+			RoomID:      "room",
+			Attributes: map[string]interface{}{
+				"eventType": "playerLeft",
+				"playerId":  "player",
+			},
+		}
+
+		room := &game_room.GameRoom{
+			ID:               event.RoomID,
+			SchedulerID:      event.SchedulerID,
+			IsValidationRoom: false,
+			Metadata: map[string]interface{}{
+				"players": 5,
+			},
+		}
+
+		schedulerCache.EXPECT().GetScheduler(context.Background(), event.SchedulerID).Return(nil, nil)
+		schedulerStorage.EXPECT().GetScheduler(context.Background(), event.SchedulerID).Return(expectedScheduler, nil)
+		instanceStorage.EXPECT().GetInstance(context.Background(), event.SchedulerID, event.RoomID).Return(expectedGameRoomInstance, nil).Times(0)
+		schedulerCache.EXPECT().SetScheduler(context.Background(), expectedScheduler, config.SchedulerCacheTtl).Return(nil)
+		eventsForwarder.EXPECT().ForwardPlayerEvent(context.Background(), gomock.Any(), gomock.Any()).Return(nil)
+		roomStorage.EXPECT().GetRoom(gomock.Any(), event.SchedulerID, event.RoomID).Return(room, nil)
+
+		room.Metadata["players"] = 4
+		roomStorage.EXPECT().UpdateRoom(gomock.Any(), room).Return(nil)
 
 		err := eventsForwarderService.ProduceEvent(context.Background(), event)
 		require.NoError(t, err)