xml validator for unit and team stashs

config.yaml

     state_template: "opencombat/state_template.xml"
     unit_stash: "opencombat.strategy.unit.stash.UnitStash"
     team_stash: "opencombat.strategy.team.stash.TeamStash"
+    teams_schema: "opencombat/strategy/teams.xsd"
+    units_schema: "opencombat/strategy/units.xsd"
     cache_dir_path: 'cache'
     include_path:
       maps:

opencombat/state.py

 from synergine2.config import Config
 from synergine2.log import get_logger
 
-from opencombat.exception import StateLoadError
 from opencombat.exception import NotFoundError
 from opencombat.simulation.base import TileStrategySimulation
 from opencombat.simulation.subject import TileSubject
 from opencombat.util import get_class_from_string_path
 from opencombat.util import pretty_xml
 from opencombat.util import get_text_xml_element
+from opencombat.xml import XmlValidator
 
 
 class State(object):
         self._config = config
         self._simulation = simulation
 
+        schema_file_path = self._config.get(
+            'global.state_schema',
+            'opencombat/state.xsd',
+        )
+        self._xml_validator = XmlValidator(
+            config,
+            schema_file_path,
+        )
+
     def get_state(
         self,
         state_file_path: str,
         self,
         state_file_path: str,
     ) -> Element:
-        # open and read schema file
-        schema_file_path = self._config.get(
-            'global.state_schema',
-            'opencombat/state.xsd',
-        )
-        with open(schema_file_path, 'r') as schema_file:
-            schema_to_check = schema_file.read()
-
-        # open and read xml file
-        with open(state_file_path, 'r') as xml_file:
-            xml_to_check = xml_file.read()
-
-        xmlschema_doc = etree.fromstring(schema_to_check.encode('utf-8'))
-        xmlschema = etree.XMLSchema(xmlschema_doc)
-
-        try:
-            doc = etree.fromstring(xml_to_check.encode('utf-8'))
-        # check for file IO error
-        except IOError as exc:
-            self._logger.error(exc)
-            raise StateLoadError('Invalid File "{}": {}'.format(
-                state_file_path,
-                str(exc),
-            ))
-        # check for XML syntax errors
-        except etree.XMLSyntaxError as exc:
-            self._logger.error(exc)
-            raise StateLoadError('XML Syntax Error in "{}": {}'.format(
-                state_file_path,
-                str(exc.error_log),
-            ))
-        except Exception as exc:
-            self._logger.error(exc)
-            raise StateLoadError('Unknown error with "{}": {}'.format(
-                state_file_path,
-                str(exc),
-            ))
-
-        # validate against schema
-        try:
-            xmlschema.assertValid(doc)
-        except etree.DocumentInvalid as exc:
-            self._logger.error(exc)
-            raise StateLoadError(
-                'Schema validation error with "{}": {}'.format(
-                    state_file_path,
-                    str(exc),
-                )
-            )
-        except Exception as exc:
-            self._logger.error(exc)
-            raise StateLoadError(
-                'Unknown validation error with "{}": {}'.format(
-                    state_file_path,
-                    str(exc),
-                )
-            )
-
-        return doc
+        return self._xml_validator.validate_and_return(state_file_path)
 
 
 class StateConstructorBuilder(object):

opencombat/strategy/team/stash.py

 from synergine2.config import Config
 
 from opencombat.strategy.unit.model import TeamModel
+from opencombat.xml import XmlValidator
 
 
 class TeamStash(object):
         config: Config,
         teams_file_path: str,
     ) -> None:
-        self._confg = config
-        # TODO Load xml, validate
+        self._config = config
         self._teams = None  # typing.List[TeamModel]
 
+        schema_file_path = self._config.get(
+            'global.teams_schema',
+            'opencombat/strategy/teams.xsd',
+        )
+        self._xml_validator = XmlValidator(
+            config,
+            schema_file_path,
+        )
+
     def get_teams(self) -> typing.List[TeamModel]:
         pass
 

opencombat/strategy/teams.xsd

 <?xml version="1.0" encoding="UTF-8" ?>
 <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-    <xs:complexType name="teams">
+
+    <xs:element name="teams" type="teamstype"/>
+
+    <xs:complexType name="teamstype">
         <xs:sequence>
             <xs:element name="team" type="teamtype" maxOccurs="unbounded"/>
         </xs:sequence>
             <xs:element name="name" type="xs:string" maxOccurs="1"/>
             <xs:element name="units" type="unitstype" maxOccurs="1"/>
         </xs:sequence>
+        <xs:attribute name="id" type="xs:string" use="required"/>
+        <xs:attribute name="country" type="xs:string" use="required"/>
     </xs:complexType>
 
     <xs:complexType name="unitstype">
         <xs:sequence>
-            <xs:element name="unit" type="unittype" maxOccurs="unbounded"/>
+            <xs:element name="unit" type="unittype" maxOccurs="unbounded" minOccurs="1"/>
         </xs:sequence>
     </xs:complexType>
 
     <xs:complexType name="unittype">
         <xs:sequence>
-            <xs:element name="id" type="xs:string" maxOccurs="1"/>
+            <xs:element name="id" type="xs:string" maxOccurs="1" minOccurs="1"/>
         </xs:sequence>
     </xs:complexType>
 

opencombat/strategy/unit/stash.py

 from synergine2.config import Config
 
 from opencombat.strategy.team.model import UnitModel
+from opencombat.xml import XmlValidator
 
 
 class UnitStash(object):
         config: Config,
         units_file_path: str,
     ) -> None:
-        self._confg = config
-        # TODO Load xml, validate
+        self._config = config
         self._units = None  # typing.List[UnitModel]
 
+        schema_file_path = self._config.get(
+            'global.teams_schema',
+            'opencombat/strategy/teams.xsd',
+        )
+        self._xml_validator = XmlValidator(
+            config,
+            schema_file_path,
+        )
+
     def get_units(self) -> typing.List[UnitModel]:
         pass
 

opencombat/strategy/units.xsd

+<?xml version="1.0" encoding="UTF-8" ?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+    <xs:element name="units" type="unitstype"/>
+
+    <xs:complexType name="unitstype">
+        <xs:sequence>
+            <xs:element name="unit" type="unittype" maxOccurs="unbounded" minOccurs="1"/>
+        </xs:sequence>
+    </xs:complexType>
+
+    <xs:complexType name="unittype">
+        <xs:sequence>
+            <xs:element name="name" type="xs:string" maxOccurs="1" minOccurs="1"/>
+            <xs:element name="type" type="xs:string" maxOccurs="1" minOccurs="1"/>
+        </xs:sequence>
+        <xs:attribute name="id" type="xs:string" use="required"/>
+        <xs:attribute name="country" type="xs:string" use="required"/>
+    </xs:complexType>
+
+</xs:schema>

opencombat/xml.py

+# coding: utf-8
+from _elementtree import Element
+
+from lxml import etree
+from synergine2.config import Config
+from synergine2.log import get_logger
+
+from opencombat.exception import StateLoadError
+
+
+class XmlValidator(object):
+    def __init__(
+        self,
+        config: Config,
+        schema_file_path: str,
+    ) -> None:
+        self._config = config
+        self._logger = get_logger('XmlValidator', config)
+        self._schema_file_path = schema_file_path
+
+    def validate_and_return(self, xml_file_path: str) -> Element:
+        with open(self._schema_file_path, 'r') as schema_file:
+            schema_to_check = schema_file.read()
+
+        # open and read xml file
+        with open(xml_file_path, 'r') as xml_file:
+            xml_to_check = xml_file.read()
+
+        xmlschema_doc = etree.fromstring(schema_to_check.encode('utf-8'))
+        xmlschema = etree.XMLSchema(xmlschema_doc)
+
+        try:
+            doc = etree.fromstring(xml_to_check.encode('utf-8'))
+        # check for file IO error
+        except IOError as exc:
+            self._logger.error(exc)
+            raise StateLoadError('Invalid File "{}": {}'.format(
+                xml_file_path,
+                str(exc),
+            ))
+        # check for XML syntax errors
+        except etree.XMLSyntaxError as exc:
+            self._logger.error(exc)
+            raise StateLoadError('XML Syntax Error in "{}": {}'.format(
+                xml_file_path,
+                str(exc.error_log),
+            ))
+        except Exception as exc:
+            self._logger.error(exc)
+            raise StateLoadError('Unknown error in "{}": {}'.format(
+                xml_file_path,
+                str(exc),
+            ))
+
+        # validate against schema
+        try:
+            xmlschema.assertValid(doc)
+        except etree.DocumentInvalid as exc:
+            self._logger.error(exc)
+            raise StateLoadError(
+                'Schema validation error in "{}": {}'.format(
+                    xml_file_path,
+                    str(exc),
+                )
+            )
+        except Exception as exc:
+            self._logger.error(exc)
+            raise StateLoadError(
+                'Unknown validation error in "{}": {}'.format(
+                    xml_file_path,
+                    str(exc),
+                )
+            )
+
+        return doc

test_config.yaml

       draw_interior_gap: 2
 
 global:
+    state_loader: "opencombat.state.StateLoader"
+    state_dumper: "opencombat.state.StateDumper"
+    state_schema: "opencombat/state.xsd"
+    state_template: "opencombat/state_template.xml"
+    unit_stash: "opencombat.strategy.unit.stash.UnitStash"
+    team_stash: "opencombat.strategy.team.stash.TeamStash"
+    teams_schema: "opencombat/strategy/teams.xsd"
+    units_schema: "opencombat/strategy/units.xsd"
     cache_dir_path: 'cache'
     include_path:
       maps:

tests/strategy/test_teams.py

+# coding: utf-8
+from synergine2.config import Config
+
+from opencombat.strategy.team.stash import TeamStash
+
+
+def test_units_stash__ok__instantiate(
+    config: Config,
+):
+    TeamStash(
+        config,
+        'opencombat/strategy/teams.xml',
+    )

tests/strategy/test_units.py

+# coding: utf-8
+from synergine2.config import Config
+
+from opencombat.strategy.unit.stash import UnitStash
+
+
+def test_units_stash__ok__instantiate(
+    config: Config,
+):
+    UnitStash(
+        config,
+        'opencombat/strategy/units.xml',
+    )