Merge pull request #108 from sturdy-robot/develop

test: remove coupling between db and settings

esm/core/db.py

@@ -18,56 +18,41 @@
 from pathlib import Path
 
 from .esports.moba.champion import Champion
-from .esports.moba.generator import (
-    ChampionGenerator,
-    TeamGenerator,
-    get_default_champion_defs,
-)
+from .esports.moba.generator import ChampionGenerator, TeamGenerator
 from .esports.moba.mobaregion import MobaRegion
 from .esports.moba.mobateam import MobaTeam
 from .esports.moba.player import MobaPlayer
 from .gamestate import GameState
-from .settings import Settings
-from .utils import load_list_from_file
 
 
 class DB:
-    def __init__(self, settings: Settings):
-        self.settings = settings
-
-    def generate_moba_champions(self) -> list[Champion]:
+    def generate_moba_champions(
+        self, champion_defs: list[dict[str, str | int]]
+    ) -> list[Champion]:
         champion_gen = ChampionGenerator()
-        try:
-            champion_defs = load_list_from_file(self.settings.moba_champion_defs)
-        except FileNotFoundError:
-            champion_defs = get_default_champion_defs()
         return [champion_gen.generate(champion_def) for champion_def in champion_defs]
 
     def generate_moba_teams(
-        self, champions_list: list[Champion]
-    ) -> tuple[list[MobaTeam], list[MobaRegion]]:
-        player_names = load_list_from_file(self.settings.names_file)
+        self,
+        player_names: list[dict[str, dict[str, str | int]]],
+        champions_list: list[Champion],
+        teams_def: list[dict[str, str | int]],
+    ) -> list[MobaTeam]:
         team_gen = TeamGenerator(champions_list, player_names)
+        return [team_gen.generate(team_def) for team_def in teams_def]
 
-        regions = self.get_region_definitions()
-        moba_regions = []
-        teams_list = []
+    def get_moba_region_definitions(
+        self, regions: list[dict[str, str]], directory: Path
+    ) -> list[dict[str, str]]:
         for region in regions:
-            region_teams = []
-            teams_def = load_list_from_file(Path(region["filename"]))
-            for team_def in teams_def:
-                team = team_gen.generate(team_def)
-                region_teams.append(team)
-                teams_list.append(team)
-            moba_region = MobaRegion(
-                region["id"],
-                region["name"],
-                region["short_name"],
-                region_teams,
-            )
-            moba_regions.append(moba_region)
-
-        return teams_list, moba_regions
+            filename = region["filename"]
+            path = os.path.join(directory, filename)
+            region["filename"] = path
+
+        return regions
+
+    def generate_moba_regions(self):
+        pass
 
     @staticmethod
     def get_moba_players(teams_list: list[MobaTeam]) -> list[MobaPlayer]:
@@ -103,42 +88,19 @@ def serialize_players(
     def serialize_regions(regions_list: list[MobaRegion]) -> dict[str, dict]:
         return {region.region_id: region.serialize() for region in regions_list}
 
-    def generate_moba_teams_file(
-        self, serialized_teams: dict[str, dict[str, str | list[str]]]
-    ) -> None:
-        self.settings.moba_teams.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.settings.moba_teams, "w", encoding="utf-8") as fp:
-            json.dump(
-                serialized_teams, fp, indent=4, ensure_ascii=False, sort_keys=True
-            )
-
-    def generate_moba_champions_file(
-        self, serialized_champions: dict[str, dict[str, str | list[str]]]
+    def generate_moba_file(
+        self, filepath: Path, serialized_data: dict[str, dict[str, str | list[str]]]
     ) -> None:
-        self.settings.moba_champions.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.settings.moba_champions, "w", encoding="utf-8") as fp:
-            json.dump(
-                serialized_champions, fp, indent=4, ensure_ascii=False, sort_keys=True
-            )
-
-    def generate_moba_players_file(
-        self, serialized_players: dict[str, dict[str, str | list[str]]]
-    ) -> None:
-        self.settings.moba_players.parent.mkdir(parents=True, exist_ok=True)
-        with self.settings.moba_players.open("w", encoding="utf-8") as fp:
-            json.dump(
-                serialized_players, fp, indent=4, ensure_ascii=False, sort_keys=True
-            )
-
-    def generate_moba_regions_file(self, serialized_regions: dict[str, dict]) -> None:
-        self.settings.moba_regions.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.settings.moba_regions, "w", encoding="utf-8") as fp:
-            json.dump(
-                serialized_regions, fp, indent=4, ensure_ascii=False, sort_keys=True
-            )
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+        with open(filepath, "w", encoding="utf-8") as fp:
+            json.dump(serialized_data, fp, indent=4, ensure_ascii=False, sort_keys=True)
 
     def generate_moba_files(
         self,
+        champions_file: Path,
+        teams_file: Path,
+        players_file: Path,
+        regions_file: Path,
         champions_list: list[Champion],
         teams_list: list[MobaTeam],
         regions: list[MobaRegion],
@@ -149,24 +111,10 @@ def generate_moba_files(
         serialized_players = self.serialize_players(players_list=players_list)
         serialized_regions = self.serialize_regions(regions_list=regions)
 
-        self.settings.db_dir.mkdir(parents=True, exist_ok=True)
-        self.settings.db_moba_dir.mkdir(parents=True, exist_ok=True)
-
-        self.generate_moba_champions_file(serialized_champions)
-        self.generate_moba_teams_file(serialized_teams)
-        self.generate_moba_players_file(serialized_players)
-        self.generate_moba_regions_file(serialized_regions)
-
-    def get_region_definitions(self) -> list[dict[str, str]]:
-        regions = load_list_from_file(self.settings.moba_region_defs)
-
-        for region in regions:
-            directory = self.settings.moba_team_defs
-            filename = region["filename"]
-            path = os.path.join(directory, filename)
-            region["filename"] = path
-
-        return regions
+        self.generate_moba_file(champions_file, serialized_champions)
+        self.generate_moba_file(teams_file, serialized_teams)
+        self.generate_moba_file(players_file, serialized_players)
+        self.generate_moba_file(regions_file, serialized_regions)
 
     def load_moba_teams(self) -> list[MobaTeam]:
         pass

esm/core/esmcore.py

@@ -35,7 +35,7 @@ def __init__(self):
         self.settings = Settings()
         self.settings.load_config_file()
         self.logger = self.initialize_logging()
-        self.db = DB(self.settings)
+        self.db = DB()
         self.game_session = GameSession(self.settings, self.db)
 
     def initialize_logging(self):

esm/core/esports/moba/generator/generate_teams.py

@@ -33,7 +33,7 @@ class TeamGenerator(GeneratorInterface):
     def __init__(
         self,
         champions: list[Champion],
-        player_names: list[dict[str, dict[str | int]]],
+        player_names: list[dict[str, dict[str, str | int]]],
         players: Optional[list] = None,
     ):
         self.player_list = players

esm/tests/conftest.py

@@ -360,5 +360,29 @@ def settings(tmp_path: Path) -> Settings:
 
 
 @pytest.fixture
-def db(settings: Settings) -> DB:
-    return DB(settings)
+def db() -> DB:
+    return DB()
+
+
+@pytest.fixture
+def mock_team_definitions() -> list[dict[str, int | str]]:
+    return [
+        {
+            "name": "KoreanTeam",
+            "nationality": "Korea",
+            "mu": 88,
+            "sigma": 15,
+        },
+        {
+            "name": "GermanTeam",
+            "nationality": "Germany",
+            "mu": 75,
+            "sigma": 20,
+        },
+        {
+            "name": "ChineseTeam",
+            "nationality": "China",
+            "mu": 89,
+            "sigma": 10,
+        },
+    ]

esm/tests/test_db.py

@@ -14,26 +14,37 @@
 #      You should have received a copy of the GNU General Public License
 #      along with this program.  If not, see <https://www.gnu.org/licenses/>.
 import json
+from pathlib import Path
 
 from esm.core.db import DB
 
 
-def test_generate_champion_files(db: DB) -> None:
-    champions = db.generate_moba_champions()
+def test_generate_champion_files(
+    db: DB, mock_champion_defs: list[dict[str, str | int | float]], tmp_path: Path
+) -> None:
+    moba_champions_path = tmp_path / "moba_champions.json"
+    champions = db.generate_moba_champions(mock_champion_defs)
     expected_champions = db.serialize_champions(champions)
-    db.generate_moba_champions_file(expected_champions)
-    assert db.settings.moba_champions.exists()
-    with open(db.settings.moba_champions) as fp:
+    db.generate_moba_file(moba_champions_path, expected_champions)
+    assert moba_champions_path.exists()
+    with moba_champions_path.open("r") as fp:
         actual_champions = json.load(fp)
     assert actual_champions == expected_champions
 
 
-def test_generate_team_files(db: DB) -> None:
-    champions = db.generate_moba_champions()
-    teams, _ = db.generate_moba_teams(champions)
+def test_generate_team_files(
+    db: DB,
+    mock_champion_defs: list[dict[str, str | int | float]],
+    mock_team_definitions: list[dict[str, str | int]],
+    names_file: list[dict[str, dict[str, str | int]]],
+    tmp_path: Path,
+) -> None:
+    teams_filepath = tmp_path / "moba_teams.json"
+    champions = db.generate_moba_champions(mock_champion_defs)
+    teams = db.generate_moba_teams(names_file, champions, mock_team_definitions)
     serialized_teams = db.serialize_teams(teams)
-    db.generate_moba_teams_file(serialized_teams)
-    assert db.settings.moba_teams.exists()
-    with open(db.settings.moba_teams) as fp:
+    db.generate_moba_file(teams_filepath, serialized_teams)
+    assert teams_filepath.exists()
+    with teams_filepath.open("r") as fp:
         actual_teams = json.load(fp)
     assert actual_teams == serialized_teams

esm/tests/test_generate_teams.py

@@ -37,32 +37,9 @@ def mock_team_definition() -> dict[str, int | str]:
     }
 
 
-def mock_team_definitions() -> list[dict[str, int | str]]:
-    return [
-        {
-            "name": "KoreanTeam",
-            "nationality": "Korea",
-            "mu": 88,
-            "sigma": 15,
-        },
-        {
-            "name": "GermanTeam",
-            "nationality": "Germany",
-            "mu": 75,
-            "sigma": 20,
-        },
-        {
-            "name": "ChineseTeam",
-            "nationality": "China",
-            "mu": 89,
-            "sigma": 10,
-        },
-    ]
-
-
 @pytest.fixture
 def team_generator(
-    mock_champions: list[Champion], names_file: list[dict[str, str | float]]
+    mock_champions: list[Champion], names_file: list[dict[str, dict[str, str | int]]]
 ) -> TeamGenerator:
     return TeamGenerator(champions=mock_champions, player_names=names_file)
 
@@ -72,7 +49,7 @@ def test_team_generator_champion_list_is_empty():
         TeamGenerator(champions=[], player_names=[])
 
 
-def test_generate_team(team_generator):
+def test_generate_team(team_generator: TeamGenerator):
     team_def = mock_team_definition()
     team = team_generator.generate(team_definition=team_def)
     assert isinstance(team, MobaTeam)
@@ -82,9 +59,11 @@ def test_generate_team(team_generator):
         assert isinstance(player, MobaPlayer)
 
 
-def test_generate_multiple_teams(team_generator):
-    teams = [team_generator.generate(team_def) for team_def in mock_team_definitions()]
-    for team, team_def in zip(teams, mock_team_definitions()):
+def test_generate_multiple_teams(
+    team_generator: TeamGenerator, mock_team_definitions: list[dict[str, int | str]]
+):
+    teams = [team_generator.generate(team_def) for team_def in mock_team_definitions]
+    for team, team_def in zip(teams, mock_team_definitions):
         assert isinstance(team, MobaTeam)
         assert team.name == team_def["name"]
         assert team.nationality == team_def["nationality"]