test: added unit test for Item

unit tests for ItemsDB and ExpenseIncomeStats would require more methods

Author: ca20110820

projects/Expense-Tracker/expense_income_stats.py

@@ -9,24 +9,28 @@ def __init__(self, db_path: str, start: str = None, end: str = None):
         self.start = start
         self.end = end
 
-        if start is None and end is None:
-            # Get all Items
-            self._items = self._items_db.get_all_items()
-            pass
-        elif start is None and end is not None:
-            # Start from the Oldest Item(s) to the given end date string
-            oldest = min(item.date for item in self._items_db.get_all_items())
-            self._items = self._items_db.get_items_by_date_range(oldest.strftime("%Y-%m-%d"), end)
-        elif start is not None and end is None:
-            # Start from the given start date string to the latest date
-            latest = max(item.date for item in self._items_db.get_all_items())
-            self._items = self._items_db.get_items_by_date_range(start, latest.strftime("%Y-%m-%d"))
-        else:
-            # Get item from given date range
-            self._items = self._items_db.get_items_by_date_range(start, end)
+        # if start is None and end is None:
+        #     # Get all Items
+        #     self._items = self._items_db.get_all_items()
+        #     pass
+        # elif start is None and end is not None:
+        #     # Start from the Oldest Item(s) to the given end date string
+        #     oldest = min(item.date for item in self._items_db.get_all_items())
+        #     self._items = self._items_db.get_items_by_date_range(oldest.strftime("%Y-%m-%d"), end)
+        # elif start is not None and end is None:
+        #     # Start from the given start date string to the latest date
+        #     latest = max(item.date for item in self._items_db.get_all_items())
+        #     self._items = self._items_db.get_items_by_date_range(start, latest.strftime("%Y-%m-%d"))
+        # else:
+        #     # Get item from given date range
+        #     self._items = self._items_db.get_items_by_date_range(start, end)
+
+    @property
+    def items(self):
+        return self._items_db.get_all_items()
 
     @staticmethod
-    def _get_stats(items) -> dict:
+    def get_stats_expense_and_income(items) -> dict:
         expense_items = [item.amount for item in items if item.amount < 0]
         if len(expense_items) > 0:
             expense_stats = {
@@ -49,20 +53,26 @@ def _get_stats(items) -> dict:
 
         return expense_stats | income_stats
 
-    def get_stats(self):
-        return self._get_stats(self._items)
+    @staticmethod
+    def get_stats(items) -> dict:
+        if len(items) < 1:
+            raise ValueError('The list of items must contain at least one item')
+
+        return {
+            "average": statistics.mean(items),
+            "max": max(items),
+            "min": min(items),
+        }
 
-    def get_stats_by_category(self) -> dict:
-        # The 'root' of category (i.e. it aggregates the subcategories). We do not care about the subcategories.
-        # Set of Root Categories
-        # item.get_category_str() for an item without category would return 'Uncategorized'
-        category_names = {item.category.name if item.category is not None else item.get_category_str() for item in
-                          self._items}
+    def get_stats_all_items(self):
+        return self.get_stats_expense_and_income(self.items)
 
+    def get_stats_by_category(self) -> dict:
+        category_names = self._items_db.get_category_names()
         out_dict = {}
         for category_name in category_names:
-            items = [item for item in self._items if item.category.name == category_name]
-            out_dict[category_name] = self._get_stats(items)
+            items = [item for item in self._items_db.get_items_by_category(category_name)]
+            out_dict[category_name] = self.get_stats_expense_and_income(items)
 
         return out_dict
 
@@ -71,12 +81,14 @@ def get_stats_by_category_with_subcategories(self) -> dict:
         stats_dict = {}
         for category_name in category_names:
             # Case: With Category and Without Subcategory
-            stats_dict[f'{category_name}-NoSubcategory'] = self._get_stats(
+            stats_dict[f'{category_name}-NoSubcategory'] = self.get_stats_expense_and_income(
                 self._items_db.get_items_without_subcategory(category_name))
+
             # Case: With Category and With Subcategory
-            for subcategory in self._items_db.get_subcategory_name(category_name):
+            for subcategory in self._items_db.get_subcategory_names(category_name):
                 stats_dict[f'{category_name}-{subcategory}'] = \
-                    self._get_stats(self._items_db.get_items_by_category_and_subcategory(category_name, subcategory))
+                    self.get_stats_expense_and_income(
+                        self._items_db.get_items_by_category_and_subcategory(category_name, subcategory))
 
         return stats_dict
 

projects/Expense-Tracker/item.py

@@ -100,48 +100,56 @@ def to_serializable_dict(self) -> dict:
 class ItemsDB:
     def __init__(self, db_path: str):
         self.db_path = db_path
-        self._db = TinyDB(self.db_path)
 
     def __len__(self):
-        return len(self._db)
+        with TinyDB(self.db_path) as db:
+            return len(db)
 
     def print_db(self):
         for item in self.get_all_items():
             print(item.to_json_str(indent=4))
 
     def insert_item(self, item: Item) -> None:
         data_dict = dict(json.loads(item.to_json_str()))
-        self._db.insert(data_dict)
+        with TinyDB(self.db_path) as db:
+            db.insert(data_dict)
 
     def insert_items(self, items: List[Item]) -> None:
-        self._db.insert_multiple([dict(json.loads(item.to_json_str())) for item in items])
+        with TinyDB(self.db_path) as db:
+            db.insert_multiple([dict(json.loads(item.to_json_str())) for item in items])
 
     def update_items(self, update_dict: dict, query: Query) -> None:
-        self._db.update(update_dict, query)
+        with TinyDB(self.db_path) as db:
+            db.update(update_dict, query)
 
     def upsert_item(self, item: Item) -> None:
         dct = item.to_serializable_dict()
-        self._db.upsert(dct, Query().item_id == str(dct['item_id']))
+        with TinyDB(self.db_path) as db:
+            db.upsert(dct, Query().item_id == str(dct['item_id']))
 
     def delete_items(self, cond: Query) -> None:
-        self._db.remove(cond)
+        with TinyDB(self.db_path) as db:
+            db.remove(cond)
 
     def delete_item(self, item: Item) -> None:
         self.delete_items(Query().item_id == item.item_id)
 
     def delete_all_items(self):
-        self._db.truncate()
+        with TinyDB(self.db_path) as db:
+            db.truncate()
 
     def get_all_items(self) -> List[Item]:
-        return [Item.from_json_str(json.dumps(doc)) for doc in self._db.all()]
+        with TinyDB(self.db_path) as db:
+            return [Item.from_json_str(json.dumps(doc)) for doc in db.all()]
 
     def get_items_by_date_range(self, start: str, end: str) -> List[Item]:
         start_date = datetime.strptime(start, "%Y-%m-%d")
         end_date = datetime.strptime(end, "%Y-%m-%d")
         return [item for item in self.get_all_items() if start_date <= item.date <= end_date]
 
     def get_items_by_category(self, category_name: str) -> List[Item]:
-        return [item for item in self.get_all_items() if item.category.name == category_name]
+        return [item for item in self.get_all_items() if
+                item.category is not None and item.category.name == category_name]
 
     def get_items_by_category_and_subcategory(self, category_name: str, subcategory_name: str) -> List[Item]:
         return [item for item in self.get_all_items() if
@@ -165,8 +173,14 @@ def get_category_names(self) -> Set[str]:
         # This excludes the Items with No Category (i.e. item.category is None)
         return {item.category.name for item in self.get_all_items() if item.category is not None}
 
-    def get_subcategory_name(self, category_name: str) -> Set[str]:
+    def get_subcategory_names(self, category_name: str) -> Set[str]:
         # This excludes items without subcategories
         return {item.category.subcategory for item in self.get_all_items() if
                 item.category is not None and item.category.name == category_name and item.category.subcategory is not
                 None}
+
+    def get_expense_items(self):
+        return [item for item in self.get_all_items() if item.amount < 0]
+
+    def get_income_items(self):
+        return [item for item in self.get_all_items() if item.amount > 0]