Added testing for the event retrieval

Author: krcb197

pyproject.toml

@@ -53,12 +53,13 @@ dev = [
     "pylint",
     "coverage",
     "types-requests",
-    "pytest"
+    "pytest",
 ]
 unit_tests = [
     "pytest",
     "pytest-mock",
-    "requests-mock"
+    "requests-mock",
+    "Faker"
     ]
 integration_tests = [
     "pytest",

src/pytito/__about__.py

@@ -17,4 +17,4 @@
 
 Variables that describes the Package
 """
-__version__ = "0.0.2"
+__version__ = "0.0.3"

src/pytito/admin/_base_client.py

@@ -79,7 +79,10 @@ def _populate_json(self) -> None:
 
     def _get_response(self, endpoint: str) -> dict[str, Any]:
 
-        full_end_point = self._end_point + '/' + endpoint
+        if endpoint == '':
+            full_end_point = self._end_point
+        else:
+            full_end_point = self._end_point + '/' + endpoint
 
         response = requests.get(
             url=full_end_point,

src/pytito/admin/account.py

@@ -30,9 +30,13 @@ class Account(AdminAPIBase):
     One of the accounts available through the Tito IO AdminAPI
     """
 
-    def __init__(self, account_slug:str, json_content:Optional[dict[str, Any]]=None):
-        super().__init__(json_content=json_content, allow_automatic_json_retrieval=True)
+    def __init__(self, account_slug: str, json_content: Optional[dict[str, Any]] = None,
+                 api_key: Optional[str] = None):
+        super().__init__(json_content=json_content,
+                         allow_automatic_json_retrieval=True,
+                         api_key=api_key)
         self.__account_slug = account_slug
+        self.__api_key_internal = api_key
 
     @property
     def _end_point(self) -> str:
@@ -51,6 +55,7 @@ def __event_getter(self, end_point: str) -> dict[str, Event]:
                 raise RuntimeError('Account Slug inconsistency')
             slug = event['slug']
             return_dict[slug] = Event(event_slug=slug, account_slug=self.__account_slug,
+                                      api_key=self.__api_key_internal,
                                       json_content=event)
         return return_dict
 

src/pytito/admin/admin.py

@@ -32,7 +32,7 @@ class AdminAPI(AdminAPIBase):
     def __init__(self, api_key:Optional[str]=None) -> None:
         super().__init__(json_content=None, api_key=api_key)
         self._populate_json()
-        self.accounts = {account_slug:Account(account_slug=account_slug)
+        self.accounts = {account_slug:Account(account_slug=account_slug, api_key=api_key)
                          for account_slug in self.__account_slugs}
 
     @property

src/pytito/admin/event.py

@@ -31,8 +31,9 @@ class Event(AdminAPIBase):
     """
 
     def __init__(self, account_slug:str, event_slug:str,
-                 json_content:Optional[dict[str, Any]]=None) -> None:
-        super().__init__(json_content=json_content)
+                 json_content:Optional[dict[str, Any]]=None,
+                 api_key: Optional[str] = None) -> None:
+        super().__init__(json_content=json_content, api_key=api_key)
         self.__account_slug = account_slug
         self.__event_slug = event_slug
 

tests/integration_tests/conftest.py

@@ -1,4 +1,22 @@
+"""
+pytito is a python wrapper for the tito.io API
+Copyright (C) 2024
 
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+This module provides supporting test fixtures for the integration tests
+"""
 import pytest
 from pytito import AdminAPI
 
@@ -18,4 +36,3 @@ def pytito_account_implementation(admin_api):
     A test fixture that provides an mocked AdminAPI with mocked data
     """
     yield admin_api.accounts['pytito']
-

tests/integration_tests/test_connection.py

@@ -38,4 +38,4 @@ def test_pytito_connection(pytito_account):
     correctly
     """
     assert isinstance(pytito_account, Account)
-    assert pytito_account.name == 'pytito'
+    assert pytito_account.name == 'pytito'

tests/unit_tests/conftest.py

@@ -18,10 +18,11 @@
 This module provides supporting test fixtures for the unit test
 """
 from typing import Optional
+from datetime import timedelta
 
 import pytest
 from faker import Faker
-from faker.providers import company
+from faker.providers import company, lorem, date_time
 
 from pytito import AdminAPI
 
@@ -39,24 +40,66 @@ def mocked_environment_api_key_implementation(mocker):
     yield key
 
 
+# pylint:disable-next=too-few-public-methods
+class Event:
+    """
+    Event within the data model of the mocked data
+    """
+    faker: Optional[Faker] = None
+
+    def __init__(self, date_range_start, date_range_end):
+        if self.faker is None:
+            self.faker = Faker()
+            self.faker.add_provider(lorem)
+            self.faker.add_provider(date_time)
+
+        self.title = ' '.join(self.faker.words(3))
+        self.description = self.faker.paragraph(nb_sentences=3,
+                                                variable_nb_sentences=True)
+        self.start_at = self.faker.date_time_between_dates(
+            datetime_start=date_range_start,
+            datetime_end=date_range_end).astimezone()
+
+    @property
+    def slug(self) -> str:
+        """
+        slug used to form the end_point of the api
+        """
+        return self.title.replace(' ', '-')
+
+
+# pylint:disable-next=too-few-public-methods
 class Account:
-    FAKER:Optional[Faker] = None
+    """
+    Account with in the data model of the mocked data
+    """
+    faker: Optional[Faker] = None
 
     def __init__(self):
-        if self.FAKER is None:
-            self.FAKER = Faker()
-            self.FAKER.add_provider(company)
+        if self.faker is None:
+            self.faker = Faker()
+            self.faker.add_provider(company)
 
-        self.name = self.FAKER.bs()
-        self.description = self.FAKER.catch_phrase()
+        self.name = self.faker.bs()
+        self.description = self.faker.catch_phrase()
+
+        # future events
+        self.events: list[Event] = [Event(date_range_start=timedelta(days=1),
+                                          date_range_end=timedelta(days=365)) for _ in range(5)]
 
     @property
     def slug(self) -> str:
+        """
+        slug used to form the end_point of the api
+        """
         return self.name.replace(' ', '-')
 
 
 @pytest.fixture(scope='function', name='mocked_data')
-def mocked_data_implementation(requests_mock):
+def mocked_data_implementation():
+    """
+    Test fixture to generate a set of mocked data for the use in various tests
+    """
     yield [Account() for _ in range(2)]
 
 
@@ -65,12 +108,22 @@ def mocked_admin_api_implementation(requests_mock, mocked_data):
     """
     A test fixture that provides an mocked AdminAPI with mocked data
     """
+
+    # pylint:disable-next=unused-argument
     def hello_json_content(request, context):
-        return {'accounts':[item.slug for item in mocked_data] }
+        return {'accounts': [item.slug for item in mocked_data]}
 
     requests_mock.get("https://api.tito.io/v3/hello", status_code=200,
                       json=hello_json_content)
+    for account in mocked_data:
+        requests_mock.get(f"https://api.tito.io/v3/{account.slug}", status_code=200,
+                          json={'account': {'name': account.name, 'slug': account.slug}})
+        requests_mock.get(f"https://api.tito.io/v3/{account.slug}/events", status_code=200,
+                          json={'events': [
+                              {'title': event.title,
+                               'slug': event.slug,
+                               'start_at': event.start_at.isoformat(timespec='milliseconds'),
+                               'account_slug': account.slug}
+                              for event in account.events]})
 
     yield AdminAPI(api_key='fake_api_key')
-
-

tests/unit_tests/test_account.py

@@ -19,11 +19,43 @@
 """
 from pytito.admin import Account
 
+
 def test_accounts(mocked_data, mocked_admin_api):
     """
     Check the accounts are instantiated correctly
     """
-    for data_model_account, (admin_api_account_slug, admin_api_account) in zip(mocked_data, mocked_admin_api.accounts.items()):
+    for data_model_account, (admin_api_account_slug, admin_api_account) in \
+            zip(mocked_data, mocked_admin_api.accounts.items()):
         assert isinstance(admin_api_account, Account)
         assert data_model_account.slug == admin_api_account_slug
 
+
+def test_account_attributes(mocked_data, mocked_admin_api):
+    """
+    check that the data is properly populated with in the account when requested
+    """
+    for data_model_account, admin_api_account in \
+            zip(mocked_data, mocked_admin_api.accounts.values()):
+        assert data_model_account.name == admin_api_account.name
+
+
+def test_account_events(mocked_data, mocked_admin_api):
+    """
+    test that the list of upcoming events is served up correctly
+    """
+    for data_model_account, admin_api_account in \
+            zip(mocked_data, mocked_admin_api.accounts.values()):
+        for data_model_event, (event_slug, event) in \
+            zip(data_model_account.events, admin_api_account.events.items()):
+            assert data_model_event.title == event.title
+            assert data_model_event.slug == event_slug
+
+
+def test_account_next_event(mocked_data, mocked_admin_api):
+    """
+    Test that the next event is report correctly
+    """
+    for data_model_account, admin_api_account in \
+            zip(mocked_data, mocked_admin_api.accounts.values()):
+        data_model_next_event = sorted(data_model_account.events, key=lambda item: item.start_at)[0]
+        assert admin_api_account.next_event.title == data_model_next_event.title