prepared repo class to be used with users

ordr3/repo.py

@@ -12,31 +12,34 @@ class AbstractOrderRepository(abc.ABC):
         self.session = session
 
     @abc.abstractmethod
-    def add(self, order):
+    def add_order(self, order):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def get(self, reference):
+    def get_order(self, reference):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def list(self):
+    def list_orders(self):
         raise NotImplementedError
 
 
 class SqlAlchemyRepository(AbstractOrderRepository):
     """ Repository implementation for SQLAlchemy """
 
-    def add(self, order):
-        self.session.add(order)
+    def _add_item_to_db(self, item):
+        self.session.add(item)
         self.session.flush()
 
-    def get(self, reference):
+    def add_order(self, order):
+        self._add_item_to_db(order)
+
+    def get_order(self, reference):
         return (
             self.session.query(models.OrderItem).filter_by(id=reference).one()
         )
 
-    def list(self):
+    def list_orders(self):
         return (
             self.session.query(models.OrderItem)
             .order_by(models.OrderItem.created_on.desc())

ordr3/services.py

@@ -17,7 +17,9 @@ def find_consumables(repo, repeat=3, days=365 * 2):
 def _find_consumables(repo, repeat=3, days=365 * 2):
     """ helper function for find_consumables() implementation """
     now = datetime.now()
-    by_date = (o for o in repo.list() if (now - o.created_on).days < days)
+    by_date = (
+        o for o in repo.list_orders() if (now - o.created_on).days < days
+    )
     relevant = (o for o in by_date if o.status in CONSUMABLE_STATI)
     counter = {}
     for order in relevant:

tests/test_repo.py

@@ -42,12 +42,12 @@ def example_orders():
     ]
 
 
-def test_sql_repo_add(session, example_orders):
+def test_sql_repo_add_order(session, example_orders):
     from ordr3.repo import SqlAlchemyRepository
     from ordr3.models import OrderItem
 
     repo = SqlAlchemyRepository(session)
-    repo.add(example_orders[0])
+    repo.add_order(example_orders[0])
     session.flush()
 
     order = session.query(OrderItem).first()
@@ -55,24 +55,24 @@ def test_sql_repo_add(session, example_orders):
     assert order == example_orders[0]
 
 
-def test_sql_repo_get(session, example_orders):
+def test_sql_repo_get_order(session, example_orders):
     from ordr3.repo import SqlAlchemyRepository
 
     repo = SqlAlchemyRepository(session)
-    repo.add(example_orders[0])
-    repo.add(example_orders[1])
+    repo.add_order(example_orders[0])
+    repo.add_order(example_orders[1])
     session.flush()
 
-    assert example_orders[1] == repo.get(2)
+    assert example_orders[1] == repo.get_order(2)
 
 
-def test_sql_repo_list(session, example_orders):
+def test_sql_repo_list_orders(session, example_orders):
     from ordr3.repo import SqlAlchemyRepository
 
     earlier, later = example_orders
     repo = SqlAlchemyRepository(session)
-    repo.add(earlier)
-    repo.add(later)
+    repo.add_order(earlier)
+    repo.add_order(later)
     session.flush()
 
-    assert repo.list() == [later, earlier]
+    assert repo.list_orders() == [later, earlier]

tests/test_services.py

@@ -11,15 +11,15 @@ class FakeOrderRepository(AbstractOrderRepository):
     def __init__(self, session):
         self._orders = set()
 
-    def add(self, order):
+    def add_order(self, order):
         """ add an order to the datastore """
         self._orders.add(order)
 
-    def get(self, reference):
+    def get_order(self, reference):
         """ retrieve an order from the datastore """
         return next(o for o in self._orders if o.id == reference)
 
-    def list(self):
+    def list_orders(self):
         return sorted(self._orders, reverse=True, key=lambda x: x.created_on)
 
 
@@ -48,23 +48,23 @@ def prefilled_repo():
 
     repo = FakeOrderRepository(session=None)
     # should be consumables
-    repo.add(_create_order(1, today - month * 1, OrderStatus.ORDERED))
-    repo.add(_create_order(1, today - month * 2, OrderStatus.ORDERED))
-    repo.add(_create_order(1, today - month * 3, OrderStatus.COMPLETED))
-    repo.add(_create_order(2, today - month * 1, OrderStatus.ORDERED))
-    repo.add(_create_order(2, today - month * 2, OrderStatus.ORDERED))
-    repo.add(_create_order(2, today - month * 3, OrderStatus.COMPLETED))
+    repo.add_order(_create_order(1, today - month * 1, OrderStatus.ORDERED))
+    repo.add_order(_create_order(1, today - month * 2, OrderStatus.ORDERED))
+    repo.add_order(_create_order(1, today - month * 3, OrderStatus.COMPLETED))
+    repo.add_order(_create_order(2, today - month * 1, OrderStatus.ORDERED))
+    repo.add_order(_create_order(2, today - month * 2, OrderStatus.ORDERED))
+    repo.add_order(_create_order(2, today - month * 3, OrderStatus.COMPLETED))
     # no consumable, only two repeats
-    repo.add(_create_order(3, today - month * 1, OrderStatus.ORDERED))
-    repo.add(_create_order(3, today - month * 2, OrderStatus.ORDERED))
+    repo.add_order(_create_order(3, today - month * 1, OrderStatus.ORDERED))
+    repo.add_order(_create_order(3, today - month * 2, OrderStatus.ORDERED))
     # no consumable, only two repeats in the last two years
-    repo.add(_create_order(4, today - month * 1, OrderStatus.ORDERED))
-    repo.add(_create_order(4, today - month * 2, OrderStatus.ORDERED))
-    repo.add(_create_order(4, today - month * 50, OrderStatus.ORDERED))
+    repo.add_order(_create_order(4, today - month * 1, OrderStatus.ORDERED))
+    repo.add_order(_create_order(4, today - month * 2, OrderStatus.ORDERED))
+    repo.add_order(_create_order(4, today - month * 50, OrderStatus.ORDERED))
     # no consumable, one order on hold
-    repo.add(_create_order(5, today - month * 1, OrderStatus.ORDERED))
-    repo.add(_create_order(5, today - month * 2, OrderStatus.ORDERED))
-    repo.add(_create_order(5, today - month * 3, OrderStatus.HOLD))
+    repo.add_order(_create_order(5, today - month * 1, OrderStatus.ORDERED))
+    repo.add_order(_create_order(5, today - month * 2, OrderStatus.ORDERED))
+    repo.add_order(_create_order(5, today - month * 3, OrderStatus.HOLD))
 
     return repo
 
@@ -82,7 +82,7 @@ def test_create_log_entry(prefilled_repo):
     from ordr3.services import create_log_entry
     from ordr3.models import OrderStatus, User
 
-    order = prefilled_repo.get(1)
+    order = prefilled_repo.get_order(1)
     user = User(*list("ABCDEFG"))
 
     create_log_entry(order, OrderStatus.APPROVAL, user)