[dvslib] Improve support for assert logging (#1258)

Signed-off-by: Danny Allen <[email protected]>

Author: daall

tests/dvslib/dvs_common.py

@@ -37,23 +37,26 @@ def wait_for_result(polling_function, polling_config):
                 not, as well as some return value.
 
         Returns:
-            Any: The output of the polling function, if it is succesful,
-            None otherwise.
+            (bool, Any): If the polling function succeeds, then this method
+            will return True and the output of the polling function. If it
+            does not succeed within the provided timeout, it will return False
+            and whatever the output of the polling function was on the final
+            attempt.
     """
     if polling_config.polling_interval == 0:
         iterations = 1
     else:
         iterations = int(polling_config.timeout // polling_config.polling_interval) + 1
 
     for _ in range(iterations):
-        (status, result) = polling_function()
+        status, result = polling_function()
 
         if status:
-            return result
+            return (True, result)
 
         time.sleep(polling_config.polling_interval)
 
     if polling_config.strict:
-        assert False
+        assert False, "Operation timed out after {}s".format(polling_config.timeout)
 
-    return None
+    return (False, result)

tests/dvslib/dvs_database.py

@@ -119,7 +119,14 @@ def _access_function():
             fv_pairs = self.get_entry(table_name, key)
             return (bool(fv_pairs), fv_pairs)
 
-        return wait_for_result(_access_function, polling_config)
+        status, result = wait_for_result(_access_function,
+                                         self._disable_strict_polling(polling_config))
+
+        if not status:
+            assert not polling_config.strict, \
+                "Entry not found: key=\"{}\", table=\"{}\"".format(key, table_name)
+
+        return result
 
     def wait_for_field_match(self,
                              table_name,
@@ -131,9 +138,6 @@ def wait_for_field_match(self,
             at `key` in the specified table. This method will wait for the
             fields to exist.
 
-            Note:
-                This method does not check for an exact match.
-
             Args:
                 table_name (str): The name of the table where the entry is
                     stored.
@@ -152,12 +156,57 @@ def _access_function():
             fv_pairs = self.get_entry(table_name, key)
             return (all(fv_pairs.get(k) == v for k, v in expected_fields.items()), fv_pairs)
 
-        return wait_for_result(_access_function, polling_config)
+        status, result = wait_for_result(_access_function,
+                                         self._disable_strict_polling(polling_config))
+
+        if not status:
+            assert not polling_config.strict, \
+                "Expected fields not found: expected={}, received={}, \
+                key=\"{}\", table=\"{}\"".format(expected_fields, result, key, table_name)
 
-    def wait_for_empty_entry(self,
+        return result
+
+    def wait_for_exact_match(self,
                              table_name,
                              key,
+                             expected_entry,
                              polling_config=DEFAULT_POLLING_CONFIG):
+        """
+            Checks if the provided entry matches the entry stored at `key`
+            in the specified table. This method will wait for the exact entry
+            to exist.
+
+            Args:
+                table_name (str): The name of the table where the entry is
+                    stored.
+                key (str): The key that maps to the entry being checked.
+                expected_entry (dict): The entry we expect to see.
+                polling_config (PollingConfig): The parameters to use to poll
+                    the db.
+
+            Returns:
+                Dict[str, str]: The entry stored at `key`. If no entry is found,
+                then an empty Dict will be returned.
+        """
+
+        def _access_function():
+            fv_pairs = self.get_entry(table_name, key)
+            return (fv_pairs == expected_entry, fv_pairs)
+
+        status, result = wait_for_result(_access_function,
+                                         self._disable_strict_polling(polling_config))
+
+        if not status:
+            assert not polling_config.strict, \
+                "Exact match not found: expected={}, received={}, \
+                key=\"{}\", table=\"{}\"".format(expected_entry, result, key, table_name)
+
+        return result
+
+    def wait_for_deleted_entry(self,
+                               table_name,
+                               key,
+                               polling_config=DEFAULT_POLLING_CONFIG):
         """
             Checks if there is any entry stored at `key` in the specified
             table. This method will wait for the entry to be empty.
@@ -169,14 +218,23 @@ def wait_for_empty_entry(self,
                     the db.
 
             Returns:
-                bool: True if no entry exists at `key`, False otherwise.
+                Dict[str, str]: The entry stored at `key`. If no entry is found,
+                then an empty Dict will be returned.
         """
 
         def _access_function():
             fv_pairs = self.get_entry(table_name, key)
             return (not bool(fv_pairs), fv_pairs)
 
-        return wait_for_result(_access_function, polling_config)
+        status, result = wait_for_result(_access_function,
+                                         self._disable_strict_polling(polling_config))
+
+        if not status:
+            assert not polling_config.strict, \
+                "Entry still exists: entry={}, key=\"{}\", table=\"{}\""\
+                .format(result, key, table_name)
+
+        return result
 
     def wait_for_n_keys(self,
                         table_name,
@@ -203,7 +261,15 @@ def _access_function():
             keys = self.get_keys(table_name)
             return (len(keys) == num_keys, keys)
 
-        return wait_for_result(_access_function, polling_config)
+        status, result = wait_for_result(_access_function,
+                                         self._disable_strict_polling(polling_config))
+
+        if not status:
+            assert not polling_config.strict, \
+                "Unexpected number of keys: expected={}, received={} ({}), table=\"{}\""\
+                .format(num_keys, len(result), result, table_name)
+
+        return result
 
     def wait_for_matching_keys(self,
                                table_name,
@@ -230,7 +296,15 @@ def _access_function():
             keys = self.get_keys(table_name)
             return (all(key in keys for key in expected_keys), keys)
 
-        return wait_for_result(_access_function, polling_config)
+        status, result = wait_for_result(_access_function,
+                                         self._disable_strict_polling(polling_config))
+
+        if not status:
+            assert not polling_config.strict, \
+                "Expected keys not found: expected={}, received={}, table=\"{}\""\
+                .format(expected_keys, result, table_name)
+
+        return result
 
     def wait_for_deleted_keys(self,
                               table_name,
@@ -257,4 +331,19 @@ def _access_function():
             keys = self.get_keys(table_name)
             return (all(key not in keys for key in deleted_keys), keys)
 
-        return wait_for_result(_access_function, polling_config)
+        status, result = wait_for_result(_access_function,
+                                         self._disable_strict_polling(polling_config))
+
+        if not status:
+            assert not polling_config.strict, \
+                "Unexpected keys found: expected={}, received={}, table=\"{}\""\
+                .format(deleted_keys, result, table_name)
+
+        return result
+
+    @staticmethod
+    def _disable_strict_polling(polling_config):
+        disabled_config = PollingConfig(polling_interval=polling_config.polling_interval,
+                                        timeout=polling_config.timeout,
+                                        strict=False)
+        return disabled_config