Add hosted_at field to game_info message

integration_tests/test_matchmaking.py

@@ -54,6 +54,7 @@ async def test_ladder_1v1_match(client_factory):
         "sim_mods": {},
         "num_players": 0,
         "max_players": 2,
+        "hosted_at": None,
         "launched_at": None,
         "rating_type": "ladder_1v1",
         "rating_min": None,

server/games/game.py

@@ -26,6 +26,7 @@
     resolve_game
 )
 from server.rating import InclusiveRange, RatingType
+from server.timing import datetime_now
 
 from ..players import Player, PlayerState
 from .typedefs import (
@@ -78,6 +79,7 @@ def __init__(
         self._game_stats_service = game_stats_service
         self.game_service = game_service
         self._player_options: dict[int, dict[str, Any]] = defaultdict(dict)
+        self.hosted_at = None
         self.launched_at = None
         self.finished = False
         self._logger = logging.getLogger(
@@ -264,6 +266,7 @@ def get_team_sets(self) -> list[set[Player]]:
 
     def set_hosted(self):
         self._hosted_future.set_result(None)
+        self.hosted_at = datetime_now()
 
     async def add_result(
         self,
@@ -894,6 +897,7 @@ def to_dict(self):
             "host": self.host.login if self.host else "",
             "num_players": len(connected_players),
             "max_players": self.max_players,
+            "hosted_at": self.hosted_at.isoformat() if self.hosted_at else None,
             "launched_at": self.launched_at,
             "rating_type": self.rating_type,
             "rating_min": self.displayed_rating_range.lo,

tests/integration_tests/test_game.py

@@ -1,14 +1,17 @@
 import asyncio
 import gc
 import json
+import time
 from collections import defaultdict
+from datetime import datetime
 
 import pytest
 from sqlalchemy import select
 
 from server.db.models import game_player_stats
 from server.games.game_results import GameOutcome
 from server.protocol import Protocol
+from server.timing import datetime_now
 from tests.utils import fast_forward
 
 from .conftest import (
@@ -99,7 +102,7 @@ def predecate(cmd) -> bool:
 
         return cmd["launched_at"] is not None
 
-    await read_until(proto, predecate, timeout=timeout)
+    return await read_until(proto, predecate, timeout=timeout)
 
 
 async def client_response(proto, timeout=10):
@@ -261,6 +264,70 @@ async def send_player_options(proto, *options):
         })
 
 
+@fast_forward(60)
+async def test_game_info_messages(lobby_server):
+    host_id, _, host_proto = await connect_and_sign_in(
+        ("test", "test_password"), lobby_server
+    )
+    guest_id, _, guest_proto = await connect_and_sign_in(
+        ("Rhiza", "puff_the_magic_dragon"), lobby_server
+    )
+    await read_until_command(guest_proto, "game_info")
+    await read_until_command(host_proto, "game_info")
+
+    # Host game
+    await host_proto.send_message({
+        "command": "game_host",
+        "mod": "faf",
+        "visibility": "public",
+    })
+    msg = await read_until_command(host_proto, "game_launch")
+    game_id = int(msg["uid"])
+
+    msg = await read_until_command(host_proto, "game_info")
+
+    assert msg["hosted_at"] is None
+    assert msg["launched_at"] is None
+
+    await open_fa(host_proto)
+    await read_until_command(host_proto, "HostGame", target="game")
+
+    msg = await read_until_command(host_proto, "game_info")
+    hosted_at = msg["hosted_at"]
+    assert datetime.fromisoformat(hosted_at) <= datetime_now()
+    assert msg["launched_at"] is None
+
+    # Join a player
+    await join_game(guest_proto, game_id)
+
+    # Set player options
+    await send_player_options(
+        host_proto,
+        [host_id, "Army", 1],
+        [host_id, "Team", 1],
+        [host_id, "StartSpot", 1],
+        [host_id, "Faction", 1],
+        [host_id, "Color", 1],
+        [guest_id, "Army", 2],
+        [guest_id, "Team", 2],
+        [guest_id, "StartSpot", 2],
+        [guest_id, "Faction", 2],
+        [guest_id, "Color", 2],
+    )
+
+    # Launch game
+    await host_proto.send_message({
+        "target": "game",
+        "command": "GameState",
+        "args": ["Launching"]
+    })
+
+    msg = await read_until_launched(host_proto, game_id)
+
+    assert msg["hosted_at"] == hosted_at
+    assert msg["launched_at"] <= time.time()
+
+
 @fast_forward(60)
 async def test_game_ended_rates_game(lobby_server):
     host_id, _, host_proto = await connect_and_sign_in(

tests/unit_tests/test_game.py

@@ -624,6 +624,7 @@ async def test_to_dict(game, player_factory):
         "host": game.host.login,
         "num_players": len(game.players),
         "max_players": game.max_players,
+        "hosted_at": None,
         "launched_at": game.launched_at,
         "rating_type": game.rating_type,
         "rating_min": game.displayed_rating_range.lo,