Create wrapped and unwrapped versions of internal event getter methods

and use them where appropriate

[ci integration]

Author: jomuel

raiden/api/python.py

@@ -673,7 +673,7 @@ def transfer_async(
         )
         return async_result
 
-    def get_raiden_events_payment_history(
+    def get_raiden_events_payment_history_with_timestamps(
             self,
             token_address: typing.TokenAddress = None,
             target_address: typing.Address = None,
@@ -701,11 +701,11 @@ def get_raiden_events_payment_history(
 
         events = [
             event
-            for event in self.raiden.wal.storage.get_events(
+            for event in self.raiden.wal.storage.get_events_with_timestamps(
                 limit=limit,
                 offset=offset,
             ) if event_filter_for_payments(
-                event,
+                event.wrapped_event,
                 self.address,
                 token_network_identifier,
                 target_address,
@@ -714,8 +714,24 @@ def get_raiden_events_payment_history(
 
         return events
 
-    def get_raiden_internal_events(self, limit: int = None, offset: int = None):
-        return self.raiden.wal.storage.get_events(limit=limit, offset=offset)
+    def get_raiden_events_payment_history(
+            self,
+            token_address: typing.TokenAddress = None,
+            target_address: typing.Address = None,
+            limit: int = None,
+            offset: int = None,
+    ):
+        timestamped_events = self.get_raiden_events_payment_history_with_timestamps(
+            token_address,
+            target_address,
+            limit,
+            offset,
+        )
+
+        return [event.wrapped_event for event in timestamped_events]
+
+    def get_raiden_internal_events_with_timestamps(self, limit: int = None, offset: int = None):
+        return self.raiden.wal.storage.get_events_with_timestamps(limit=limit, offset=offset)
 
     transfer = transfer_and_wait
 

raiden/api/rest.py

@@ -784,7 +784,7 @@ def get_blockchain_events_token_network(
         except (InvalidBlockNumberInput, InvalidAddress) as e:
             return api_error(str(e), status_code=HTTPStatus.CONFLICT)
 
-    def get_raiden_events_payment_history(
+    def get_raiden_events_payment_history_with_timestamps(
             self,
             token_address: typing.TokenAddress = None,
             target_address: typing.Address = None,
@@ -797,7 +797,7 @@ def get_raiden_events_payment_history(
             target_address=optional_address_to_string(target_address),
         )
         try:
-            raiden_service_result = self.raiden_api.get_raiden_events_payment_history(
+            service_result = self.raiden_api.get_raiden_events_payment_history_with_timestamps(
                 token_address=token_address,
                 target_address=target_address,
                 limit=limit,
@@ -807,23 +807,26 @@ def get_raiden_events_payment_history(
             return api_error(str(e), status_code=HTTPStatus.CONFLICT)
 
         result = []
-        for event in raiden_service_result:
-            if isinstance(event, EventPaymentSentSuccess):
+        for event in service_result:
+            if isinstance(event.wrapped_event, EventPaymentSentSuccess):
                 serialized_event = self.sent_success_payment_schema.dump(event)
-            elif isinstance(event, EventPaymentSentFailed):
+            elif isinstance(event.wrapped_event, EventPaymentSentFailed):
                 serialized_event = self.failed_payment_schema.dump(event)
-            elif isinstance(event, EventPaymentReceivedSuccess):
+            elif isinstance(event.wrapped_event, EventPaymentReceivedSuccess):
                 serialized_event = self.received_success_payment_schema.dump(event)
             else:
-                log.warning('Unexpected event', unexpected_event=event)
+                log.warning('Unexpected event', unexpected_event=event.wrapped_event)
 
             result.append(serialized_event.data)
         return api_response(result=result)
 
-    def get_raiden_internal_events(self, limit, offset):
+    def get_raiden_internal_events_with_timestamps(self, limit, offset):
         return [
             str(e)
-            for e in self.raiden_api.raiden.wal.storage.get_events(limit=limit, offset=offset)
+            for e in self.raiden_api.raiden.wal.storage.get_events_with_timestamps(
+                limit=limit,
+                offset=offset,
+            )
         ]
 
     def get_blockchain_events_channel(

raiden/api/v1/resources.py

@@ -149,7 +149,7 @@ class RaidenInternalEventsResource(BaseResource):
 
     @use_kwargs(get_schema, locations=('query',))
     def get(self, token_address, partner_address=None, limit=None, offset=None):
-        return self.rest_api.get_raiden_internal_events(
+        return self.rest_api.get_raiden_internal_events_with_timestamps(
             token_address=token_address,
             partner_address=partner_address,
             limit=limit,
@@ -218,7 +218,7 @@ def get(
             limit: int = None,
             offset: int = None,
     ):
-        return self.rest_api.get_raiden_events_payment_history(
+        return self.rest_api.get_raiden_events_payment_history_with_timestamps(
             token_address=token_address,
             target_address=target_address,
             limit=limit,

raiden/storage/sqlite.py

@@ -176,12 +176,7 @@ def get_statechanges_by_identifier(self, from_identifier, to_identifier):
 
         return result
 
-    def _wrap_event(self, event, log_time):
-        if isinstance(event, EventWithLogTime):
-            return TimestampedEvent(event, log_time)
-        return event
-
-    def get_events(self, limit: int = None, offset: int = None):
+    def _query_events(self, limit: int = None, offset: int = None):
         if limit is not None and (not isinstance(limit, int) or limit < 0):
             raise InvalidNumberInput('limit must be a positive integer')
 
@@ -201,11 +196,19 @@ def get_events(self, limit: int = None, offset: int = None):
             (limit, offset),
         )
 
+        return cursor.fetchall()
+
+    def get_events_with_timestamps(self, limit: int = None, offset: int = None):
+        entries = self._query_events(limit, offset)
         result = [
-            self._wrap_event(self.serializer.deserialize(entry[0]), entry[1])
-            for entry in cursor.fetchall()
+            TimestampedEvent(self.serializer.deserialize(entry[0]), entry[1])
+            for entry in entries
         ]
         return result
 
+    def get_events(self, limit: int = None, offset: int = None):
+        entries = self._query_events(limit, offset)
+        return [self.serializer.deserialize(entry[0]) for entry in entries]
+
     def __del__(self):
         self.conn.close()

raiden/tests/unit/test_wal.py

@@ -168,7 +168,7 @@ def test_write_read_events():
             '2018-08-31T17:38:00.000',
         )
 
-    previous_events = wal.storage.get_events()
+    previous_events = wal.storage.get_events_with_timestamps()
 
     log_time = '2018-09-07T20:02:35.0000'
     state_change_id = wal.storage.write_state_change('statechangedata')
@@ -178,7 +178,7 @@ def test_write_read_events():
         log_time,
     )
 
-    new_events = wal.storage.get_events()
+    new_events = wal.storage.get_events_with_timestamps()
     assert len(previous_events) + 1 == len(new_events)
 
     latest_event = new_events[-1]