v0.7.4 Release Candidate (#89)

* Improved unit tests
* Defect fix for golf when team events returned

.github/workflows/pylint.yaml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.9"]
+        python-version: ["3.10"]
     steps:
     - uses: actions/checkout@v3
     - name: Set up Python ${{ matrix.python-version }}

.github/workflows/pytest.yaml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.9', '3.10']
+        python-version: ['3.9', '3.10', '3.11']
 
     steps:
       - uses: actions/checkout@v3

custom_components/teamtracker/__init__.py

@@ -248,9 +248,11 @@ async def async_update_game_data(self, config, hass) -> dict:
                     "last_update"
                 ] = DEFAULT_LAST_UPDATE  # set to fixed time for compares
                 values["kickoff_in"] = DEFAULT_KICKOFF_IN
-                with open(path, "w", encoding="utf-8") as convert_file:
-                    convert_file.write(json.dumps(values, indent=4))
-
+                try:
+                    with open(path, "w", encoding="utf-8") as convert_file:
+                        convert_file.write(json.dumps(values, indent=4))
+                except:
+                    _LOGGER.debug("%s: Error creating results file '%s'", sensor_name, path)
         return values
 
     #
@@ -293,17 +295,23 @@ async def async_call_api(self, config, hass, lang) -> dict:
 
         if file_override:
             _LOGGER.debug("%s: Overriding API for '%s'", sensor_name, team_id)
-            async with aiofiles.open("/share/tt/test.json", mode="r") as f:
+            file_path = "/share/tt/test.json"
+            if not os.path.exists(file_path):
+                file_path = "tests/tt/all.json"
+            async with aiofiles.open(file_path, mode="r") as f:
                 contents = await f.read()
             data = json.loads(contents)
         else:
             async with aiohttp.ClientSession() as session:
-                async with session.get(url, headers=headers) as r:
-                    _LOGGER.debug(
-                        "%s: Getting state for '%s' from %s", sensor_name, team_id, url
-                    )
-                    if r.status == 200:
-                        data = await r.json()
+                try:
+                    async with session.get(url, headers=headers) as r:
+                        _LOGGER.debug(
+                            "%s: Getting state for '%s' from %s", sensor_name, team_id, url
+                        )
+                        if r.status == 200:
+                            data = await r.json()
+                except:
+                    data = None
 
             num_events = 0
             if data is not None:
@@ -342,15 +350,18 @@ async def async_call_api(self, config, hass, lang) -> dict:
                 url = URL_HEAD + sport_path + "/" + league_path + URL_TAIL + url_parms
 
                 async with aiohttp.ClientSession() as session:
-                    async with session.get(url, headers=headers) as r:
-                        _LOGGER.debug(
-                            "%s: Getting state without date constraint for '%s' from %s",
-                            sensor_name,
-                            team_id,
-                            url,
-                        )
-                        if r.status == 200:
-                            data = await r.json()
+                    try:
+                        async with session.get(url, headers=headers) as r:
+                            _LOGGER.debug(
+                                "%s: Getting state without date constraint for '%s' from %s",
+                                sensor_name,
+                                team_id,
+                                url,
+                            )
+                            if r.status == 200:
+                                data = await r.json()
+                    except:
+                        data = None
 
             num_events = 0
             if data is not None:
@@ -391,18 +402,21 @@ async def async_call_api(self, config, hass, lang) -> dict:
                 url = URL_HEAD + sport_path + "/" + league_path + URL_TAIL + url_parms
 
                 async with aiohttp.ClientSession() as session:
-                    async with session.get(url, headers=headers) as r:
-                        _LOGGER.debug(
-                            "%s: Getting state without language for '%s' from %s",
-                            sensor_name,
-                            team_id,
-                            url,
-                        )
-                        if r.status == 200:
-                            data = await r.json()
-
+                    try:
+                        async with session.get(url, headers=headers) as r:
+                            _LOGGER.debug(
+                                "%s: Getting state without language for '%s' from %s",
+                                sensor_name,
+                                team_id,
+                                url,
+                            )
+                            if r.status == 200:
+                                data = await r.json()
+                    except:
+                        data = None
 
         return data, file_override
+
 
     async def async_update_values(self, config, hass, data, lang) -> dict:
         """Return values based on the data passed into method"""

custom_components/teamtracker/const.py

@@ -77,7 +77,7 @@
 
 # Misc
 TEAM_ID = ""
-VERSION = "v0.7.3"
+VERSION = "v0.7.4"
 ISSUE_URL = "https://github.com/vasqued2/ha-teamtracker"
 DOMAIN = "teamtracker"
 PLATFORM = "sensor"

custom_components/teamtracker/event.py

@@ -175,7 +175,7 @@ async def async_find_search_key(
 ):
     """Check if there is a match on wildcard, team_abbreviation, event_name, or athlete_name"""
 
-    if search_key == "*" and (competitor["type"] == "athlete" or sport_path != "tennis"):
+    if search_key == "*" and (competitor["type"] == "athlete" or sport_path not in ["tennis", "golf"]):
         _LOGGER.debug(
             "%s: Found competitor using wildcard '%s'; parsing data.",
             sensor_name,

pyproject.toml

@@ -17,7 +17,7 @@ forced_separate = [
 combine_as_imports = true
 
 [tool.pylint.MAIN]
-py-version = "3.9"
+py-version = "3.10"
 ignore = [
     "tests",
 ]

tests/const.py

@@ -8,6 +8,14 @@
     "conference_id": "9999",
 }
 
+CONFIG_DATA2 = {
+    "league_id": "NCAAF",
+    "team_id": "OSU",
+    "name": "test_tt_all_test02",
+    "timeout": 120,
+    "conference_id": "5",
+}
+
 TEST_DATA = [
     {
         "sensor_name": "test_tt_all_test01",
@@ -177,6 +185,24 @@
         "league": "XXX",
         "team_abbr": "IND",
     },
+    {
+        "sensor_name": "test_tt_all_test29",
+        "sport": "racing",
+        "league": "F1",
+        "team_abbr": "SAINTZ",
+    },
+    {
+        "sensor_name": "test_tt_all_test30",
+        "sport": "racing",
+        "league": "F1",
+        "team_abbr": "VERSTAPPEN",
+    },
+    {
+        "sensor_name": "test_tt_all_test31",
+        "sport": "racing",
+        "league": "F1",
+        "team_abbr": "STROLLZ",
+    },
 ]
 
 MULTIGAME_DATA = [

tests/test_init.py

@@ -1,29 +1,27 @@
-"""Tests for init."""
-import pytest
+""" Tests for TeamTracker """
 
+import pytest
 from pytest_homeassistant_custom_component.common import MockConfigEntry
-
 from custom_components.teamtracker.const import DOMAIN
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
+from tests.const import CONFIG_DATA, CONFIG_DATA2
 
-from tests.const import CONFIG_DATA
-
-
-@pytest.fixture(autouse=True)
+@pytest.fixture(autouse=False)
 def expected_lingering_timers() -> bool:
-    """Temporary ability to bypass test failures due to lingering timers.
+    """  Temporary ability to bypass test failures due to lingering timers.
     Parametrize to True to bypass the pytest failure.
     @pytest.mark.parametrize("expected_lingering_timers", [True])
     This should be removed when all lingering timers have been cleaned up.
     """
     return False
 
 
-@pytest.mark.parametrize("expected_lingering_timers", [True])
+#@pytest.mark.parametrize("expected_lingering_timers", [True])
 async def test_setup_entry(
     hass,
 ):
-    """Test settting up entities."""
+    """ test setup """
+
     entry = MockConfigEntry(
         domain=DOMAIN,
         title="team_tracker",
@@ -38,14 +36,18 @@ async def test_setup_entry(
     entries = hass.config_entries.async_entries(DOMAIN)
     assert len(entries) == 1
 
+    assert await entry.async_unload(hass)
+    await hass.async_block_till_done()
 
-@pytest.mark.parametrize("expected_lingering_timers", [True])
+
+#@pytest.mark.parametrize("expected_lingering_timers", [True])
 async def test_unload_entry(hass):
-    """Test unloading entities."""
+    """ test unload """
+
     entry = MockConfigEntry(
         domain=DOMAIN,
         title="team_tracker",
-        data=CONFIG_DATA,
+        data=CONFIG_DATA2,
     )
 
     entry.add_to_hass(hass)
@@ -65,26 +67,5 @@ async def test_unload_entry(hass):
     await hass.async_block_till_done()
     assert len(hass.states.async_entity_ids(SENSOR_DOMAIN)) == 0
 
-
-# async def test_import(hass):
-#     """Test importing a config."""
-#     entry = MockConfigEntry(
-#         domain=DOMAIN,
-#         title="NFL",
-#         data=CONFIG_DATA,
-#     )
-#     await async_setup_component(hass, "persistent_notification", {})
-#     with patch(
-#         "custom_components.teamtracker.async_setup_entry",
-#         return_value=True,
-#     ) as mock_setup_entry:
-
-#         ent_reg = async_get(hass)
-#         ent_entry = ent_reg.async_get_or_create(
-#             "sensor", DOMAIN, unique_id="replaceable_unique_id", config_entry=entry
-#         )
-#         entity_id = ent_entry.entity_id
-#         entry.add_to_hass(hass)
-#         await hass.config_entries.async_setup(entry.entry_id)
-#         assert entry.unique_id is None
-#         assert ent_reg.async_get(entity_id).unique_id == entry.entry_id
+    assert await entry.async_unload(hass)
+    await hass.async_block_till_done()

tests/test_sensor.py

@@ -1,27 +1,25 @@
-"""Test NFL Sensor"""
+""" Test TeamTracker Sensor """
 
 import pytest
-
 from pytest_homeassistant_custom_component.common import MockConfigEntry
-
 from custom_components.teamtracker.const import DOMAIN
-
+#from custom_components.teamtracker.sensor import TeamTrackerScoresSensor
 from tests.const import CONFIG_DATA
 
 
-@pytest.fixture(autouse=True)
+@pytest.fixture(autouse=False)
 def expected_lingering_timers() -> bool:
-    """Temporary ability to bypass test failures due to lingering timers.
-    Parametrize to True to bypass the pytest failure.
-    @pytest.mark.parametrize("expected_lingering_timers", [True])
-    This should be removed when all lingering timers have been cleaned up.
+    """"  Temporary ability to bypass test failures due to lingering timers.
+        Parametrize to True to bypass the pytest failure.
+        @pytest.mark.parametrize("expected_lingering_timers", [True])
+        This should be removed when all lingering timers have been cleaned up.
     """
     return False
 
-    
-@pytest.mark.parametrize("expected_lingering_timers", [True])
+
+#@pytest.mark.parametrize("expected_lingering_timers", [True])
 async def test_sensor(hass, mocker):
-    """ Make sure sensor gets added """
+    """ test sensor """
 
     entry = MockConfigEntry(
         domain=DOMAIN,
@@ -31,11 +29,12 @@ async def test_sensor(hass, mocker):
 
     mocker.patch("locale.getlocale", return_value=("en", 0))
 
-    #    contents = "{}"
-    #    mocker.patch('aiofiles.open', return_value=mocker.mock_open(read_data=contents).return_value)
-
     entry.add_to_hass(hass)
     assert await hass.config_entries.async_setup(entry.entry_id)
     await hass.async_block_till_done()
 
     assert "teamtracker" in hass.config.components
+
+    assert await entry.async_unload(hass)
+    await hass.async_block_till_done()
+

tests/tt/README.txt

@@ -1,5 +1,32 @@
 How to regression test.
 
+Use test_event.py to validate that sensor is returning the expected results across all supported sports and game situations.
+
+The all.json file contains the json response for the simulated API call for the TEST_DATA sensors defined in const.py.
+The expected result for each sensor defined in TEST_DATA is in the results directory.
+The test_event.py file will test each sensor in the TEST_DATA and confirm it matches the expected result in the directory.
+The test will fail if there are differences.
+If the expected results are supposed to be different, the expected results file should be updated so the test will pass.
+The expected results files can be updated manually.
+The expected results files can also be regenerated in the /share/tt/results directory
+  Add the yaml to your config to create the sensor.
+  Copy the all.json file to /share/tt/test.yaml
+  Create an empty /share/tt/results directory
+  Restart HA
+  The integrationw will create a new version of the expected results file.  Compare to prior version to ensure no unexpected changes were introduce.
+  Update the expected results in the test/results directory.
+
+Use test_multigame.py to validate the sensor pulls the correct competition to test situations like doubleheaders in baseball.
+
+The multigame.json file contains the json response for the simulated API call for the MULTIGAME_DATA sensors defined in const.py.
+The test_multigame.py file will test each sensor in MULTIGAME_DATA and confirm it matches expected results.
+The test will fail if the sensor returns the wrong competition.
+The test only validates if the right competition is returned.  It does not do the deep compare of each value as the prior test does. 
+
+Legacy tests
+
+The additional files are legacy manual tests that can be run for even deeper tests of specific sports if desired.
+
 The .json files contain the json for the simulated API call.
 The .yaml files contain the yaml to create the sensors for the corresponding .json file
 The -dump.txt files contain the expected output from the sensor dump.