finish team and unit stashs

opencombat/exception.py

@@ -23,3 +23,7 @@ class StateLoadError(OpenCombatException):
 
 class NotFoundError(OpenCombatException):
     pass
+
+
+class NotFoundException(OpenCombatException):
+    pass

opencombat/strategy/team/model.py

@@ -1,13 +1,34 @@
 # coding: utf-8
+import typing
 
+from opencombat.strategy.unit.model import UnitModel
 
-class UnitModel(object):
+
+class TeamModel(object):
     def __init__(
         self,
+        id_: str,
         name: str,
+        country: str,
+        units: typing.List[UnitModel],
     ) -> None:
+        self._id = id_
         self._name = name
+        self._country = country
+        self._units = units
+
+    @property
+    def id(self) -> str:
+        return self._id
 
     @property
     def name(self) -> str:
         return self._name
+
+    @property
+    def country(self) -> str:
+        return self._country
+
+    @property
+    def units(self) -> typing.List[UnitModel]:
+        return self._units

opencombat/strategy/team/stash.py

@@ -1,9 +1,13 @@
 # coding: utf-8
 import typing
+from _elementtree import Element
 
 from synergine2.config import Config
 
-from opencombat.strategy.unit.model import TeamModel
+from opencombat.exception import NotFoundException
+from opencombat.strategy.team.model import TeamModel
+from opencombat.strategy.unit.stash import UnitStash
+from opencombat.util import get_text_xml_element
 from opencombat.xml import XmlValidator
 
 
@@ -12,21 +16,72 @@ class TeamStash(object):
         self,
         config: Config,
         teams_file_path: str,
+        unit_stash: UnitStash,
     ) -> None:
         self._config = config
-        self._teams = None  # typing.List[TeamModel]
+        self._teams = None  # type: typing.List[TeamModel]
+        self._unit_stash = unit_stash
 
-        schema_file_path = self._config.get(
+        self.schema_file_path = self._config.get(
             'global.teams_schema',
             'opencombat/strategy/teams.xsd',
         )
         self._xml_validator = XmlValidator(
             config,
-            schema_file_path,
+            self.schema_file_path,
         )
+        self._root_element = self._xml_validator.validate_and_return(
+            teams_file_path,
+        )
+
+    def _get_computed_teams(self) -> typing.List[TeamModel]:
+        teams = []
+
+        for team_element in self._root_element.findall('team'):
+            team_element = typing.cast(Element, team_element)
+
+            team_id = team_element.attrib['id']
+            team_country = team_element.attrib['country']
+            team_name = get_text_xml_element(team_element, 'name')
+            team_units = []
+
+            units_element = team_element.find('units')
+            for unit_element in units_element.findall('unit'):
+                unit_id = get_text_xml_element(unit_element, 'id')
+                unit = self._unit_stash.get_unit(unit_id, team_country)
+                team_units.append(unit)
+
+            teams.append(
+                TeamModel(
+                    id_=team_id,
+                    country=team_country,
+                    name=team_name,
+                    units=team_units
+                )
+            )
 
-    def get_teams(self) -> typing.List[TeamModel]:
-        pass
+        return teams
 
-    def get_team(self, unit_id: str) -> TeamModel:
-        pass
+    @property
+    def teams(self) -> typing.List[TeamModel]:
+        if self._teams is None:
+            self._teams = self._get_computed_teams()
+
+        return self._teams
+
+    def get_team(
+        self,
+        team_id: str,
+        team_country: str,
+    ) -> TeamModel:
+        for team in self.teams:
+            if team.id == team_id and team.country == team_country:
+                return team
+
+        raise NotFoundException(
+            'No team matching with id "{}" and country "{}" in "{}"'.format(
+                team_id,
+                team_country,
+                self.schema_file_path,
+            )
+        )

opencombat/strategy/unit/model.py

@@ -1,13 +1,34 @@
 # coding: utf-8
+import typing
 
+from opencombat.simulation.subject import TileSubject
 
-class TeamModel(object):
+
+class UnitModel(object):
     def __init__(
         self,
+        id_: str,
         name: str,
+        class_: typing.Type[TileSubject],
+        country: str,
     ) -> None:
+        self._id = id_
         self._name = name
+        self._class = class_
+        self._country = country
+
+    @property
+    def id(self) -> str:
+        return self._id
 
     @property
     def name(self) -> str:
         return self._name
+
+    @property
+    def class_(self) -> typing.Type[TileSubject]:
+        return self._class
+
+    @property
+    def country(self) -> str:
+        return self._country

opencombat/strategy/unit/stash.py

@@ -1,9 +1,13 @@
 # coding: utf-8
 import typing
+from _elementtree import Element
 
 from synergine2.config import Config
 
+from opencombat.exception import NotFoundException
 from opencombat.strategy.team.model import UnitModel
+from opencombat.util import get_text_xml_element
+from opencombat.util import get_class_from_string_path
 from opencombat.xml import XmlValidator
 
 
@@ -14,19 +18,66 @@ class UnitStash(object):
         units_file_path: str,
     ) -> None:
         self._config = config
-        self._units = None  # typing.List[UnitModel]
+        self._units = None  # type: typing.List[UnitModel]
 
-        schema_file_path = self._config.get(
+        self.schema_file_path = self._config.get(
             'global.teams_schema',
-            'opencombat/strategy/teams.xsd',
+            'opencombat/strategy/units.xsd',
         )
         self._xml_validator = XmlValidator(
             config,
-            schema_file_path,
+            self.schema_file_path,
         )
+        self._root_element = self._xml_validator.validate_and_return(
+            units_file_path,
+        )
+
+    def _get_computed_units(self) -> typing.List[UnitModel]:
+        units = []
+
+        for unit_element in self._root_element.findall('unit'):
+            unit_element = typing.cast(Element, unit_element)
+
+            unit_id = unit_element.attrib['id']
+            unit_country = unit_element.attrib['country']
+            unit_name = get_text_xml_element(unit_element, 'name')
+            unit_class_path = get_text_xml_element(unit_element, 'type')
+            unit_class = get_class_from_string_path(
+                self._config,
+                unit_class_path,
+            )
+
+            units.append(
+                UnitModel(
+                    id_=unit_id,
+                    name=unit_name,
+                    class_=unit_class,
+                    country=unit_country,
+                )
+            )
 
-    def get_units(self) -> typing.List[UnitModel]:
-        pass
+        return units
 
-    def get_unit(self, unit_id: str) -> UnitModel:
-        pass
+    @property
+    def units(self) -> typing.List[UnitModel]:
+        if self._units is None:
+            self._units = self._get_computed_units()
+
+        return self._units
+
+    def get_unit(
+        self,
+        unit_id: str,
+        unit_country: str,
+    ) -> UnitModel:
+        for unit in self.units:
+            if unit.id == unit_id and unit.country == unit_country:
+                return unit
+
+        raise NotFoundException(
+            'No unit matching with id "{}" and country "{}" in "{}"'.format(
+                unit_id,
+                unit_country,
+                self.schema_file_path,
+            )
+        )

tests/fixtures/teams.xml

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<teams>
+    <team id="std_team" country="URSS">
+        <name>Standard team</name>
+        <units>
+            <unit>
+                <id>std_soldier</id>
+            </unit>
+            <unit>
+                <id>std_soldier</id>
+            </unit>
+            <unit>
+                <id>std_soldier</id>
+            </unit>
+            <unit>
+                <id>std_soldier</id>
+            </unit>
+        </units>
+    </team>
+    <team id="std_team" country="DE">
+        <name>Standard team</name>
+        <units>
+            <unit>
+                <id>std_soldier</id>
+            </unit>
+            <unit>
+                <id>std_soldier</id>
+            </unit>
+            <unit>
+                <id>std_soldier</id>
+            </unit>
+            <unit>
+                <id>std_soldier</id>
+            </unit>
+        </units>
+    </team>
+</teams>

tests/fixtures/units.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<units>
+    <unit id="std_soldier" country="URSS">
+        <name>Standard soldier</name>
+        <type>opencombat.simulation.subject.ManSubject</type>
+    </unit>
+    <unit id="std_soldier" country="DE">
+        <name>Standard soldier</name>
+        <type>opencombat.simulation.subject.ManSubject</type>
+    </unit>
+</units>

tests/strategy/test_teams.py

@@ -1,13 +1,107 @@
 # coding: utf-8
+import pytest
 from synergine2.config import Config
 
+from opencombat.exception import NotFoundException
+from opencombat.strategy.team.model import TeamModel
 from opencombat.strategy.team.stash import TeamStash
+from opencombat.strategy.unit.model import UnitModel
+from opencombat.strategy.unit.stash import UnitStash
+
+
+@pytest.fixture
+def unit_stash(
+    config: Config,
+) -> UnitStash:
+    return UnitStash(
+        config,
+        'tests/fixtures/units.xml',
+    )
 
 
 def test_units_stash__ok__instantiate(
     config: Config,
+    unit_stash: UnitStash,
 ):
     TeamStash(
         config,
         'opencombat/strategy/teams.xml',
+        unit_stash=unit_stash,
     )
+
+
+def test_team_stash__ok__get_teams(
+    config: Config,
+    unit_stash: UnitStash,
+):
+    stash = TeamStash(
+        config,
+        'tests/fixtures/teams.xml',
+        unit_stash=unit_stash,
+    )
+    assert stash.teams
+    assert 2 == len(stash.teams)
+    assert isinstance(stash.teams[0], TeamModel)
+    assert isinstance(stash.teams[1], TeamModel)
+
+    assert 'std_team' == stash.teams[0].id
+    assert 'Standard team' == stash.teams[0].name
+    assert 'URSS' == stash.teams[0].country
+    assert stash.teams[0].units
+    assert 4 == len(stash.teams[0].units)
+    assert isinstance(stash.teams[0].units[0], UnitModel)
+    assert 'std_soldier' == stash.teams[0].units[0].id
+    assert 'std_soldier' == stash.teams[0].units[1].id
+    assert 'std_soldier' == stash.teams[0].units[2].id
+    assert 'std_soldier' == stash.teams[0].units[3].id
+
+    assert 'std_team' == stash.teams[1].id
+    assert 'Standard team' == stash.teams[1].name
+    assert 'DE' == stash.teams[1].country
+    assert stash.teams[0].units
+    assert 4 == len(stash.teams[1].units)
+    assert isinstance(stash.teams[1].units[0], UnitModel)
+    assert 'std_soldier' == stash.teams[1].units[0].id
+    assert 'std_soldier' == stash.teams[1].units[1].id
+    assert 'std_soldier' == stash.teams[1].units[2].id
+    assert 'std_soldier' == stash.teams[1].units[3].id
+
+
+def test_teams_stash__ok__get_unit(
+    config: Config,
+    unit_stash: UnitStash,
+):
+    stash = TeamStash(
+        config,
+        'tests/fixtures/teams.xml',
+        unit_stash=unit_stash,
+    )
+    assert stash.get_team('std_team', 'URSS')
+
+
+def test_teams_stash__error__get_team_wrong_country(
+    config: Config,
+    unit_stash: UnitStash,
+):
+    stash = TeamStash(
+        config,
+        'tests/fixtures/teams.xml',
+        unit_stash=unit_stash,
+    )
+
+    with pytest.raises(NotFoundException):
+        stash.get_team('std_team', 'UNKNOWN')
+
+
+def test_teams_stash__error__get_team_wrong_id(
+    config: Config,
+    unit_stash: UnitStash,
+):
+    stash = TeamStash(
+        config,
+        'tests/fixtures/teams.xml',
+        unit_stash=unit_stash,
+    )
+
+    with pytest.raises(NotFoundException):
+        stash.get_team('unknown', 'URSS')

tests/strategy/test_units.py

@@ -1,6 +1,10 @@
 # coding: utf-8
+import pytest
 from synergine2.config import Config
 
+from opencombat.exception import NotFoundException
+from opencombat.simulation.subject import ManSubject
+from opencombat.strategy.team.model import UnitModel
 from opencombat.strategy.unit.stash import UnitStash
 
 
@@ -11,3 +15,60 @@ def test_units_stash__ok__instantiate(
         config,
         'opencombat/strategy/units.xml',
     )
+
+
+def test_units_stash__ok__get_units(
+    config: Config,
+):
+    stash = UnitStash(
+        config,
+        'tests/fixtures/units.xml',
+    )
+    assert stash.units
+    assert 2 == len(stash.units)
+    assert isinstance(stash.units[0], UnitModel)
+    assert isinstance(stash.units[1], UnitModel)
+
+    assert 'std_soldier' == stash.units[0].id
+    assert 'Standard soldier' == stash.units[0].name
+    assert 'URSS' == stash.units[0].country
+    assert ManSubject == stash.units[0].class_
+
+    assert 'std_soldier' == stash.units[1].id
+    assert 'Standard soldier' == stash.units[1].name
+    assert 'DE' == stash.units[1].country
+    assert ManSubject == stash.units[1].class_
+
+
+def test_units_stash__ok__get_unit(
+    config: Config,
+):
+    stash = UnitStash(
+        config,
+        'tests/fixtures/units.xml',
+    )
+    assert stash.get_unit('std_soldier', 'URSS')
+
+
+def test_units_stash__error__get_unit_wrong_country(
+    config: Config,
+):
+    stash = UnitStash(
+        config,
+        'tests/fixtures/units.xml',
+    )
+
+    with pytest.raises(NotFoundException):
+        stash.get_unit('std_soldier', 'UNKNOWN')
+
+
+def test_units_stash__error__get_unit_wrong_id(
+    config: Config,
+):
+    stash = UnitStash(
+        config,
+        'tests/fixtures/units.xml',
+    )
+
+    with pytest.raises(NotFoundException):
+        stash.get_unit('unknown', 'URSS')