From b5a1b44a94006a4373cef0634c212a190eda7a82 Mon Sep 17 00:00:00 2001 From: Jonathan Metzman Date: Wed, 3 Jul 2024 13:19:58 -0400 Subject: [PATCH 1/5] Move fuzzer time tracking to another module. This is part of an effort to make fuzz_task easier to understand. --- .../_internal/bot/tasks/utasks/fuzz_task.py | 110 +++--------------- .../bot/tasks/utasks/track_fuzz_time.py | 95 +++++++++++++++ 2 files changed, 112 insertions(+), 93 deletions(-) create mode 100644 src/clusterfuzz/_internal/bot/tasks/utasks/track_fuzz_time.py diff --git a/src/clusterfuzz/_internal/bot/tasks/utasks/fuzz_task.py b/src/clusterfuzz/_internal/bot/tasks/utasks/fuzz_task.py index dab5a1fb7a..4240fbbe55 100644 --- a/src/clusterfuzz/_internal/bot/tasks/utasks/fuzz_task.py +++ b/src/clusterfuzz/_internal/bot/tasks/utasks/fuzz_task.py @@ -37,6 +37,7 @@ from clusterfuzz._internal.bot.tasks import task_creation from clusterfuzz._internal.bot.tasks import trials from clusterfuzz._internal.bot.tasks.utasks import fuzz_task_knobs +from clusterfuzz._internal.bot.tasks.utasks import track_fuzz_time from clusterfuzz._internal.bot.tasks.utasks import uworker_handle_errors from clusterfuzz._internal.bot.tasks.utasks import uworker_io from clusterfuzz._internal.build_management import build_manager @@ -390,85 +391,6 @@ def _should_create_testcase(group: uworker_msg_pb2.FuzzTaskCrashGroup, return False -class _TrackFuzzTime: - """Track the actual fuzzing time (e.g. excluding preparing binary).""" - - def __init__(self, fuzzer_name, job_type, time_module=time): - self.fuzzer_name = fuzzer_name - self.job_type = job_type - self.time = time_module - - def __enter__(self): - self.start_time = self.time.time() - self.timeout = False - return self - - def __exit__(self, exc_type, value, traceback): - duration = self.time.time() - self.start_time - monitoring_metrics.FUZZER_TOTAL_FUZZ_TIME.increment_by( - int(duration), { - 'fuzzer': self.fuzzer_name, - 'timeout': self.timeout - }) - monitoring_metrics.JOB_TOTAL_FUZZ_TIME.increment_by( - int(duration), { - 'job': self.job_type, - 'timeout': self.timeout - }) - - -def _track_fuzzer_run_result(fuzzer_name, generated_testcase_count, - expected_testcase_count, return_code): - """Track fuzzer run result""" - if expected_testcase_count > 0: - ratio = float(generated_testcase_count) / expected_testcase_count - monitoring_metrics.FUZZER_TESTCASE_COUNT_RATIO.add(ratio, - {'fuzzer': fuzzer_name}) - - def clamp(val, minimum, maximum): - return max(minimum, min(maximum, val)) - - # Clamp return code to max, min int 32-bit, otherwise it can get detected as - # type long and we will exception out in infra_libs parsing pipeline. - min_int32 = -(2**31) - max_int32 = 2**31 - 1 - - return_code = int(clamp(return_code, min_int32, max_int32)) - - monitoring_metrics.FUZZER_RETURN_CODE_COUNT.increment({ - 'fuzzer': fuzzer_name, - 'return_code': return_code, - }) - - -def _track_build_run_result(job_type, _, is_bad_build): - """Track build run result.""" - # FIXME: Add support for |crash_revision| as part of state. - monitoring_metrics.JOB_BAD_BUILD_COUNT.increment({ - 'job': job_type, - 'bad_build': is_bad_build - }) - - -def _track_testcase_run_result(fuzzer, job_type, new_crash_count, - known_crash_count): - """Track testcase run result.""" - monitoring_metrics.FUZZER_KNOWN_CRASH_COUNT.increment_by( - known_crash_count, { - 'fuzzer': fuzzer, - }) - monitoring_metrics.FUZZER_NEW_CRASH_COUNT.increment_by( - new_crash_count, { - 'fuzzer': fuzzer, - }) - monitoring_metrics.JOB_KNOWN_CRASH_COUNT.increment_by(known_crash_count, { - 'job': job_type, - }) - monitoring_metrics.JOB_NEW_CRASH_COUNT.increment_by(new_crash_count, { - 'job': job_type, - }) - - def _last_sync_time(sync_file_path): """Read and parse the last sync file for the GCS corpus.""" if not os.path.exists(sync_file_path): @@ -697,8 +619,8 @@ def upload_job_run_stats(fuzzer_name: str, job_type: str, revision: int, known_crash_count, groups) fuzzer_stats.upload_stats([job_run]) - _track_testcase_run_result(fuzzer_name, job_type, new_crash_count, - known_crash_count) + track_fuzz_time.track_testcase_run_result(fuzzer_name, job_type, + new_crash_count, known_crash_count) def store_fuzzer_run_results(testcase_file_paths, fuzzer, fuzzer_command, @@ -1431,8 +1353,9 @@ def generate_blackbox_testcases(self, fuzzer, fuzzer_directory, testcase_count if fuzzer_run_results: self.fuzz_task_output.fuzzer_run_results.CopyFrom(fuzzer_run_results) - _track_fuzzer_run_result(fuzzer_name, generated_testcase_count, - testcase_count, fuzzer_return_code) + track_fuzz_time.track_fuzzer_run_result( + fuzzer_name, generated_testcase_count, testcase_count, + fuzzer_return_code) # Make sure that there are testcases generated. If not, set the error flag. success = bool(testcase_file_paths) @@ -1624,8 +1547,8 @@ def do_blackbox_fuzzing(self, fuzzer, fuzzer_directory, job_type): time.sleep(thread_delay) - with _TrackFuzzTime(self.fully_qualified_fuzzer_name, - job_type) as tracker: + with track_fuzz_time.TrackFuzzTime(self.fully_qualified_fuzzer_name, + job_type) as tracker: tracker.timeout = utils.wait_until_timeout(threads, thread_timeout) # Allow for some time to finish processing before terminating the @@ -1749,8 +1672,8 @@ def run(self): # TODO(https://github.com/google/clusterfuzz/issues/3008): Move this to # postprocess. testcase_manager.update_build_metadata(self.job_type, build_data) - _track_build_run_result(self.job_type, crash_revision, - build_data.is_bad_build) + track_fuzz_time.track_build_run_result(self.job_type, crash_revision, + build_data.is_bad_build) if build_data.is_bad_build: return uworker_msg_pb2.Output( # pylint: disable=no-member error_type=uworker_msg_pb2.ErrorType.UNHANDLED) # pylint: disable=no-member @@ -1881,18 +1804,19 @@ def _upload_testcase_run_jsons(testcase_run_jsons): def handle_fuzz_build_setup_failure(output): - _track_fuzzer_run_result(output.uworker_input.fuzzer_name, 0, 0, - FuzzErrorCode.BUILD_SETUP_FAILED) + track_fuzz_time.track_fuzzer_run_result(output.uworker_input.fuzzer_name, 0, + 0, FuzzErrorCode.BUILD_SETUP_FAILED) def handle_fuzz_data_bundle_setup_failure(output): - _track_fuzzer_run_result(output.uworker_input.fuzzer_name, 0, 0, - FuzzErrorCode.DATA_BUNDLE_SETUP_FAILED) + track_fuzz_time.track_fuzzer_run_result( + output.uworker_input.fuzzer_name, 0, 0, + FuzzErrorCode.DATA_BUNDLE_SETUP_FAILED) def handle_fuzz_no_fuzzer(output): - _track_fuzzer_run_result(output.uworker_input.fuzzer_name, 0, 0, - FuzzErrorCode.FUZZER_SETUP_FAILED) + track_fuzz_time.track_fuzzer_run_result(output.uworker_input.fuzzer_name, 0, + 0, FuzzErrorCode.FUZZER_SETUP_FAILED) def utask_main(uworker_input): diff --git a/src/clusterfuzz/_internal/bot/tasks/utasks/track_fuzz_time.py b/src/clusterfuzz/_internal/bot/tasks/utasks/track_fuzz_time.py new file mode 100644 index 0000000000..ac0e4766ab --- /dev/null +++ b/src/clusterfuzz/_internal/bot/tasks/utasks/track_fuzz_time.py @@ -0,0 +1,95 @@ +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Helper module for fuzz_task that tracks fuzzing time.""" +import time + +from clusterfuzz._internal.metrics import monitoring_metrics + + +class _TrackFuzzTime: + """Track the actual fuzzing time (e.g. excluding preparing binary).""" + + def __init__(self, fuzzer_name, job_type): + self.fuzzer_name = fuzzer_name + self.job_type = job_type + + def __enter__(self): + self.start_time = time.time() + self.timeout = False + return self + + def __exit__(self, exc_type, value, traceback): + duration = time.time() - self.start_time + monitoring_metrics.FUZZER_TOTAL_FUZZ_TIME.increment_by( + int(duration), { + 'fuzzer': self.fuzzer_name, + 'timeout': self.timeout + }) + monitoring_metrics.JOB_TOTAL_FUZZ_TIME.increment_by( + int(duration), { + 'job': self.job_type, + 'timeout': self.timeout + }) + + +def track_fuzzer_run_result(fuzzer_name, generated_testcase_count, + expected_testcase_count, return_code): + """Tracks fuzzer run result.""" + if expected_testcase_count > 0: + ratio = float(generated_testcase_count) / expected_testcase_count + monitoring_metrics.FUZZER_TESTCASE_COUNT_RATIO.add(ratio, + {'fuzzer': fuzzer_name}) + + def clamp(val, minimum, maximum): + return max(minimum, min(maximum, val)) + + # Clamp return code to max, min int 32-bit, otherwise it can get detected as + # type long and we will exception out in infra_libs parsing pipeline. + min_int32 = -(2**31) + max_int32 = 2**31 - 1 + + return_code = int(clamp(return_code, min_int32, max_int32)) + + monitoring_metrics.FUZZER_RETURN_CODE_COUNT.increment({ + 'fuzzer': fuzzer_name, + 'return_code': return_code, + }) + + +def _track_build_run_result(job_type, _, is_bad_build): + """Track build run result.""" + # FIXME: Add support for |crash_revision| as part of state. + monitoring_metrics.JOB_BAD_BUILD_COUNT.increment({ + 'job': job_type, + 'bad_build': is_bad_build + }) + + +def _track_testcase_run_result(fuzzer, job_type, new_crash_count, + known_crash_count): + """Track testcase run result.""" + monitoring_metrics.FUZZER_KNOWN_CRASH_COUNT.increment_by( + known_crash_count, { + 'fuzzer': fuzzer, + }) + monitoring_metrics.FUZZER_NEW_CRASH_COUNT.increment_by( + new_crash_count, { + 'fuzzer': fuzzer, + }) + monitoring_metrics.JOB_KNOWN_CRASH_COUNT.increment_by(known_crash_count, { + 'job': job_type, + }) + monitoring_metrics.JOB_NEW_CRASH_COUNT.increment_by(new_crash_count, { + 'job': job_type, + }) From 1ef002ac3f0139379185d583044493590100f804 Mon Sep 17 00:00:00 2001 From: Jonathan Metzman Date: Wed, 3 Jul 2024 13:49:11 -0400 Subject: [PATCH 2/5] Fix --- .../bot/tasks/utasks/track_fuzz_time.py | 15 +- .../core/bot/tasks/utasks/fuzz_task_test.py | 132 --------------- .../bot/tasks/utasks/track_fuzz_time_test.py | 153 ++++++++++++++++++ 3 files changed, 161 insertions(+), 139 deletions(-) create mode 100644 src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/track_fuzz_time_test.py diff --git a/src/clusterfuzz/_internal/bot/tasks/utasks/track_fuzz_time.py b/src/clusterfuzz/_internal/bot/tasks/utasks/track_fuzz_time.py index ac0e4766ab..b4320ba98d 100644 --- a/src/clusterfuzz/_internal/bot/tasks/utasks/track_fuzz_time.py +++ b/src/clusterfuzz/_internal/bot/tasks/utasks/track_fuzz_time.py @@ -17,20 +17,21 @@ from clusterfuzz._internal.metrics import monitoring_metrics -class _TrackFuzzTime: +class TrackFuzzTime: """Track the actual fuzzing time (e.g. excluding preparing binary).""" - def __init__(self, fuzzer_name, job_type): + def __init__(self, fuzzer_name, job_type, time_module=time): self.fuzzer_name = fuzzer_name self.job_type = job_type + self.time = time_module def __enter__(self): - self.start_time = time.time() + self.start_time = self.time.time() self.timeout = False return self def __exit__(self, exc_type, value, traceback): - duration = time.time() - self.start_time + duration = self.time.time() - self.start_time monitoring_metrics.FUZZER_TOTAL_FUZZ_TIME.increment_by( int(duration), { 'fuzzer': self.fuzzer_name, @@ -67,7 +68,7 @@ def clamp(val, minimum, maximum): }) -def _track_build_run_result(job_type, _, is_bad_build): +def track_build_run_result(job_type, _, is_bad_build): """Track build run result.""" # FIXME: Add support for |crash_revision| as part of state. monitoring_metrics.JOB_BAD_BUILD_COUNT.increment({ @@ -76,8 +77,8 @@ def _track_build_run_result(job_type, _, is_bad_build): }) -def _track_testcase_run_result(fuzzer, job_type, new_crash_count, - known_crash_count): +def track_testcase_run_result(fuzzer, job_type, new_crash_count, + known_crash_count): """Track testcase run result.""" monitoring_metrics.FUZZER_KNOWN_CRASH_COUNT.increment_by( known_crash_count, { diff --git a/src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/fuzz_task_test.py b/src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/fuzz_task_test.py index 18629ffb96..70894cb50c 100644 --- a/src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/fuzz_task_test.py +++ b/src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/fuzz_task_test.py @@ -49,110 +49,6 @@ from clusterfuzz.fuzz import engine -class TrackFuzzerRunResultTest(unittest.TestCase): - """Test _track_fuzzer_run_result.""" - - def setUp(self): - monitor.metrics_store().reset_for_testing() - - def test_fuzzer_run_result(self): - """Ensure _track_fuzzer_run_result set the right metrics.""" - fuzz_task._track_fuzzer_run_result('name', 10, 100, 2) - fuzz_task._track_fuzzer_run_result('name', 100, 200, 2) - fuzz_task._track_fuzzer_run_result('name', 1000, 2000, 2) - fuzz_task._track_fuzzer_run_result('name', 1000, 500, 0) - fuzz_task._track_fuzzer_run_result('name', 0, 1000, -1) - fuzz_task._track_fuzzer_run_result('name', 0, 0, 2) - - self.assertEqual( - 4, - monitoring_metrics.FUZZER_RETURN_CODE_COUNT.get({ - 'fuzzer': 'name', - 'return_code': 2 - })) - self.assertEqual( - 1, - monitoring_metrics.FUZZER_RETURN_CODE_COUNT.get({ - 'fuzzer': 'name', - 'return_code': 0 - })) - self.assertEqual( - 1, - monitoring_metrics.FUZZER_RETURN_CODE_COUNT.get({ - 'fuzzer': 'name', - 'return_code': -1 - })) - - testcase_count_ratio = ( - monitoring_metrics.FUZZER_TESTCASE_COUNT_RATIO.get({ - 'fuzzer': 'name' - })) - self.assertEqual(3.1, testcase_count_ratio.sum) - self.assertEqual(5, testcase_count_ratio.count) - - expected_buckets = [0 for _ in range(22)] - expected_buckets[1] = 1 - expected_buckets[3] = 1 - expected_buckets[11] = 2 - expected_buckets[21] = 1 - self.assertListEqual(expected_buckets, testcase_count_ratio.buckets) - - -class TrackBuildRunResultTest(unittest.TestCase): - """Test _track_build_run_result.""" - - def setUp(self): - monitor.metrics_store().reset_for_testing() - - def test_build_run_result(self): - """Ensure _track_build_run_result set the right metrics.""" - fuzz_task._track_build_run_result('name', 10000, True) - fuzz_task._track_build_run_result('name', 10001, True) - fuzz_task._track_build_run_result('name', 10002, False) - - self.assertEqual( - 2, - monitoring_metrics.JOB_BAD_BUILD_COUNT.get({ - 'job': 'name', - 'bad_build': True - })) - self.assertEqual( - 1, - monitoring_metrics.JOB_BAD_BUILD_COUNT.get({ - 'job': 'name', - 'bad_build': False - })) - - -class TrackTestcaseRunResultTest(unittest.TestCase): - """Test _track_testcase_run_result.""" - - def setUp(self): - monitor.metrics_store().reset_for_testing() - - def test_testcase_run_result(self): - """Ensure _track_testcase_run_result sets the right metrics.""" - fuzz_task._track_testcase_run_result('fuzzer', 'job', 2, 5) - fuzz_task._track_testcase_run_result('fuzzer', 'job', 5, 10) - - self.assertEqual(7, - monitoring_metrics.JOB_NEW_CRASH_COUNT.get({ - 'job': 'job' - })) - self.assertEqual( - 15, monitoring_metrics.JOB_KNOWN_CRASH_COUNT.get({ - 'job': 'job' - })) - self.assertEqual( - 7, monitoring_metrics.FUZZER_NEW_CRASH_COUNT.get({ - 'fuzzer': 'fuzzer' - })) - self.assertEqual( - 15, monitoring_metrics.FUZZER_KNOWN_CRASH_COUNT.get({ - 'fuzzer': 'fuzzer' - })) - - class TruncateFuzzerOutputTest(unittest.TestCase): """Truncate fuzzer output tests.""" @@ -174,34 +70,6 @@ def test_error(self): '', fuzz_task.truncate_fuzzer_output('123456xxxxxx54321', 10)) -class TrackFuzzTimeTest(unittest.TestCase): - """Test _TrackFuzzTime.""" - - def setUp(self): - monitor.metrics_store().reset_for_testing() - - def _test(self, timeout): - """Test helper.""" - time_module = helpers.MockTime() - with fuzz_task._TrackFuzzTime('fuzzer', 'job', time_module) as tracker: - time_module.advance(5) - tracker.timeout = timeout - - fuzzer_total_time = monitoring_metrics.FUZZER_TOTAL_FUZZ_TIME.get({ - 'fuzzer': 'fuzzer', - 'timeout': timeout - }) - self.assertEqual(5, fuzzer_total_time) - - def test_success(self): - """Test report metrics.""" - self._test(False) - - def test_timeout(self): - """Test timeout.""" - self._test(True) - - class GetFuzzerMetadataFromOutputTest(unittest.TestCase): """Test get_fuzzer_metadata_from_output.""" diff --git a/src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/track_fuzz_time_test.py b/src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/track_fuzz_time_test.py new file mode 100644 index 0000000000..a5ff102946 --- /dev/null +++ b/src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/track_fuzz_time_test.py @@ -0,0 +1,153 @@ +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Helper module for fuzz_task that tracks fuzzing time.""" + +import unittest + +from clusterfuzz._internal.metrics import monitor +from clusterfuzz._internal.metrics import monitoring_metrics +from clusterfuzz._internal.tests.test_libs import helpers + +from clusterfuzz._internal.bot.tasks.utasks import track_fuzz_time + +class TrackFuzzerRunResultTest(unittest.TestCase): + """Test track_fuzzer_run_result.""" + + def setUp(self): + monitor.metrics_store().reset_for_testing() + + def test_fuzzer_run_result(self): + """Ensure track_fuzzer_run_result set the right metrics.""" + track_fuzz_time.track_fuzzer_run_result('name', 10, 100, 2) + track_fuzz_time.track_fuzzer_run_result('name', 100, 200, 2) + track_fuzz_time.track_fuzzer_run_result('name', 1000, 2000, 2) + track_fuzz_time.track_fuzzer_run_result('name', 1000, 500, 0) + track_fuzz_time.track_fuzzer_run_result('name', 0, 1000, -1) + track_fuzz_time.track_fuzzer_run_result('name', 0, 0, 2) + + self.assertEqual( + 4, + monitoring_metrics.FUZZER_RETURN_CODE_COUNT.get({ + 'fuzzer': 'name', + 'return_code': 2 + })) + self.assertEqual( + 1, + monitoring_metrics.FUZZER_RETURN_CODE_COUNT.get({ + 'fuzzer': 'name', + 'return_code': 0 + })) + self.assertEqual( + 1, + monitoring_metrics.FUZZER_RETURN_CODE_COUNT.get({ + 'fuzzer': 'name', + 'return_code': -1 + })) + + testcase_count_ratio = ( + monitoring_metrics.FUZZER_TESTCASE_COUNT_RATIO.get({ + 'fuzzer': 'name' + })) + self.assertEqual(3.1, testcase_count_ratio.sum) + self.assertEqual(5, testcase_count_ratio.count) + + expected_buckets = [0 for _ in range(22)] + expected_buckets[1] = 1 + expected_buckets[3] = 1 + expected_buckets[11] = 2 + expected_buckets[21] = 1 + self.assertListEqual(expected_buckets, testcase_count_ratio.buckets) + + +class TrackBuildRunResultTest(unittest.TestCase): + """Test track_build_run_result.""" + + def setUp(self): + monitor.metrics_store().reset_for_testing() + + def test_build_run_result(self): + """Ensure track_build_run_result set the right metrics.""" + track_fuzz_time.track_build_run_result('name', 10000, True) + track_fuzz_time.track_build_run_result('name', 10001, True) + track_fuzz_time.track_build_run_result('name', 10002, False) + + self.assertEqual( + 2, + monitoring_metrics.JOB_BAD_BUILD_COUNT.get({ + 'job': 'name', + 'bad_build': True + })) + self.assertEqual( + 1, + monitoring_metrics.JOB_BAD_BUILD_COUNT.get({ + 'job': 'name', + 'bad_build': False + })) + + +class TrackTestcaseRunResultTest(unittest.TestCase): + """Test track_testcase_run_result.""" + + def setUp(self): + monitor.metrics_store().reset_for_testing() + + def test_testcase_run_result(self): + """Ensure track_testcase_run_result sets the right metrics.""" + track_fuzz_time.track_testcase_run_result('fuzzer', 'job', 2, 5) + track_fuzz_time.track_testcase_run_result('fuzzer', 'job', 5, 10) + + self.assertEqual(7, + monitoring_metrics.JOB_NEW_CRASH_COUNT.get({ + 'job': 'job' + })) + self.assertEqual( + 15, monitoring_metrics.JOB_KNOWN_CRASH_COUNT.get({ + 'job': 'job' + })) + self.assertEqual( + 7, monitoring_metrics.FUZZER_NEW_CRASH_COUNT.get({ + 'fuzzer': 'fuzzer' + })) + self.assertEqual( + 15, monitoring_metrics.FUZZER_KNOWN_CRASH_COUNT.get({ + 'fuzzer': 'fuzzer' + })) + + +class TrackFuzzTimeTest(unittest.TestCase): + """Test TrackFuzzTime.""" + + def setUp(self): + monitor.metrics_store().reset_for_testing() + + def _test(self, timeout): + """Test helper.""" + time_module = helpers.MockTime() + with track_fuzz_time.TrackFuzzTime('fuzzer', 'job', time_module) as tracker: + time_module.advance(5) + tracker.timeout = timeout + + fuzzer_total_time = monitoring_metrics.FUZZER_TOTAL_FUZZ_TIME.get({ + 'fuzzer': 'fuzzer', + 'timeout': timeout + }) + self.assertEqual(5, fuzzer_total_time) + + def test_success(self): + """Test report metrics.""" + self._test(False) + + def test_timeout(self): + """Test timeout.""" + self._test(True) From 4534d7bf9f3eff726ae9103c138d659f89d49314 Mon Sep 17 00:00:00 2001 From: Jonathan Metzman Date: Mon, 5 Aug 2024 16:12:48 -0400 Subject: [PATCH 3/5] reduce size of fuzz_task --- .../tests/core/bot/tasks/utasks/track_fuzz_time_test.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/track_fuzz_time_test.py b/src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/track_fuzz_time_test.py index a5ff102946..7f80c8fe15 100644 --- a/src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/track_fuzz_time_test.py +++ b/src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/track_fuzz_time_test.py @@ -11,7 +11,8 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. -"""Helper module for fuzz_task that tracks fuzzing time.""" +"""Tests for track_fuzz_time a helper module for fuzz_task that tracks fuzzing +time.""" import unittest @@ -21,6 +22,7 @@ from clusterfuzz._internal.bot.tasks.utasks import track_fuzz_time + class TrackFuzzerRunResultTest(unittest.TestCase): """Test track_fuzzer_run_result.""" From b43f4d69446ca033938fd48ee91ad27960c2d7bc Mon Sep 17 00:00:00 2001 From: Jonathan Metzman Date: Mon, 5 Aug 2024 16:20:04 -0400 Subject: [PATCH 4/5] fix --- .../tests/core/bot/tasks/utasks/track_fuzz_time_test.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/track_fuzz_time_test.py b/src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/track_fuzz_time_test.py index 7f80c8fe15..9023b7e362 100644 --- a/src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/track_fuzz_time_test.py +++ b/src/clusterfuzz/_internal/tests/core/bot/tasks/utasks/track_fuzz_time_test.py @@ -16,12 +16,11 @@ import unittest +from clusterfuzz._internal.bot.tasks.utasks import track_fuzz_time from clusterfuzz._internal.metrics import monitor from clusterfuzz._internal.metrics import monitoring_metrics from clusterfuzz._internal.tests.test_libs import helpers -from clusterfuzz._internal.bot.tasks.utasks import track_fuzz_time - class TrackFuzzerRunResultTest(unittest.TestCase): """Test track_fuzzer_run_result.""" From b29b5dd647558ca28a0d159bece55c48ae257ec8 Mon Sep 17 00:00:00 2001 From: Jonathan Metzman Date: Wed, 21 Aug 2024 13:44:27 -0400 Subject: [PATCH 5/5] fmt --- src/local/butler/deploy.py | 2 +- src/local/butler/package.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/local/butler/deploy.py b/src/local/butler/deploy.py index 05102b5ace..8e2f25901f 100644 --- a/src/local/butler/deploy.py +++ b/src/local/butler/deploy.py @@ -23,11 +23,11 @@ import tempfile import time +from clusterfuzz._internal.base import utils from local.butler import appengine from local.butler import common from local.butler import constants from local.butler import package -from clusterfuzz._internal.base import utils from src.clusterfuzz._internal.config import local_config from src.clusterfuzz._internal.system import environment diff --git a/src/local/butler/package.py b/src/local/butler/package.py index 5a1cf79f19..c1162a398a 100644 --- a/src/local/butler/package.py +++ b/src/local/butler/package.py @@ -97,7 +97,8 @@ def package(revision, target_zip_name = constants.LEGACY_ZIP_NAME if platform_name: - target_zip_name = utils.get_platform_deployment_filename(platform_name, release) + target_zip_name = utils.get_platform_deployment_filename( + platform_name, release) target_zip_path = os.path.join(target_zip_dir, target_zip_name) _clear_zip(target_zip_path)