From 0b39803cff295c651403907af641ed7ff8a3144f Mon Sep 17 00:00:00 2001 From: TeachMeTW Date: Fri, 18 Oct 2024 09:56:59 -0700 Subject: [PATCH] Toned back comments --- .../tests/storageTests/TestStatsQueries.py | 53 ++++++++----------- 1 file changed, 23 insertions(+), 30 deletions(-) diff --git a/emission/tests/storageTests/TestStatsQueries.py b/emission/tests/storageTests/TestStatsQueries.py index e35ed03ec..0d04f6726 100644 --- a/emission/tests/storageTests/TestStatsQueries.py +++ b/emission/tests/storageTests/TestStatsQueries.py @@ -34,27 +34,25 @@ def verify_stats_entries(self, expected_entries: list[tuple[str, str, float]]): :param expected_entries: A list of tuples containing (key, name, expected_elapsed_ms). """ - # Log the number of entries expected to exist in the database. logging.debug(f"Ensuring {len(expected_entries)} entries exist in DB.") - # Extract the keys from the expected entries for querying the database. + # Prepare keys for database query based on expected entries. key_list = [key for (key, _, _) in expected_entries] - # Retrieve the stored entries from the database matching the keys. + # Fetch matching entries from the timeseries database. stored_entrys = list(self.timeseries_db.find_entries(key_list)) - # Assert that the number of stored entries matches the number of expected entries. + # Check if the number of retrieved entries matches expectations. self.assertEqual(len(stored_entrys), len(expected_entries)) - # Iterate over each expected entry to verify its correctness. + # Validate each stored entry against the expected data. for i in range(len(expected_entries)): stored_entry = stored_entrys[i] expected_key, expected_name, expected_reading = expected_entries[i] - # Log the comparison between expected and stored entries. logging.debug(f"Comparing expected {expected_entries[i]} " + f"with stored {stored_entry['metadata']['key']} {stored_entry['data']}") - # Assert that the stored key matches the expected key. + # Verify the key matches. self.assertEqual(stored_entry['metadata']['key'], expected_key) - # Assert that the stored name matches the expected name. + # Verify the name matches. self.assertEqual(stored_entry['data']['name'], expected_name) - # Assert that the stored reading (elapsed time) matches the expected value. + # Verify the elapsed time is as expected. self.assertEqual(stored_entry['data']['reading'], expected_reading) def test_single_function_timing(self): @@ -68,14 +66,14 @@ def sample_function(): time.sleep(2) # Simulate processing time by sleeping for 2 seconds. return True - # Use the Timer context manager to measure the execution time of 'sample_function'. + # Measure the execution time of 'sample_function'. with ect.Timer() as timer: sample_function() - # Store the timing information in the database under the key 'sample_function'. + # Record the timing data in the database. esdsq.store_dashboard_time("sample_function", timer) - # Verify that the timing entry was stored correctly in the database. + # Confirm the timing was recorded correctly. self.verify_stats_entries([ ("stats/dashboard_time", "sample_function", timer.elapsed_ms) ]) @@ -96,31 +94,29 @@ def function_two(): # Simulate processing time by sleeping for 1.5 seconds. return time.sleep(1.5) - # Start the overall timer for both functions. + # Track the total time for both functions. with ect.Timer() as timer_both: - # Start and stop the timer for 'function_one'. + # Time 'function_one' execution. with ect.Timer() as timer_one: function_one() - # Store the timing information for 'function_one'. + # Record 'function_one' timing. esdsq.store_dashboard_time("function_one", timer_one) - # Start and stop the timer for 'function_two'. + # Time 'function_two' execution. with ect.Timer() as timer_two: function_two() - # Store the timing information for 'function_two'. + # Record 'function_two' timing. esdsq.store_dashboard_time("function_two", timer_two) - # Store the combined timing information for both functions. + # Record the combined timing for both functions. esdsq.store_dashboard_time("functions_one_and_two", timer_both) - # Assert that the elapsed time for 'function_one' is approximately 1000ms (1 second). + # Validate individual and combined timings. self.assertAlmostEqual(timer_one.elapsed_ms, 1000, delta=100) - # Assert that the elapsed time for 'function_two' is approximately 1500ms (1.5 seconds). self.assertAlmostEqual(timer_two.elapsed_ms, 1500, delta=100) - # Assert that the combined elapsed time is approximately 2500ms (2.5 seconds). self.assertAlmostEqual(timer_both.elapsed_ms, 2500, delta=100) - # Verify that all timing entries were stored correctly in the database. + # Ensure all timing entries are correctly stored. self.verify_stats_entries([ ("stats/dashboard_time", "function_one", timer_one.elapsed_ms), ("stats/dashboard_time", "function_two", timer_two.elapsed_ms), @@ -139,26 +135,23 @@ def faulty_function(): raise ValueError("Simulated error in faulty_function") try: - # Attempt to execute the faulty function while timing its execution. + # Attempt to execute and time the faulty function. with ect.Timer() as timer: faulty_function() except ValueError as e: - # Catch the expected ValueError exception. + # Handle the expected exception and record the timing as an error. logging.info(f"Caught expected error: {e}") - # Store the timing information as an error in the database under 'faulty_function'. esdsq.store_dashboard_error('faulty_function', timer) - # Pass to continue execution after handling the exception. + # Continue after handling the exception. pass - # Verify that the error timing entry was stored correctly in the database. + # Verify that the error timing was recorded. self.verify_stats_entries([ ("stats/dashboard_error", "faulty_function", timer.elapsed_ms) ]) + if __name__ == '__main__': - # Configure logging settings before running the tests. etc.configLogging() - # Run all the test cases defined in the TestFunctionTiming class. unittest.main() - \ No newline at end of file