def setUp(self):
helpers.patch_environ(self)
test_utils.set_up_pyfakefs(self)
os.environ['JOB_NAME'] = 'libfuzzer_asan_test'
self.fuzzer_binary_name = 'test_fuzzer'
self.name = 'myplugin'
self.plugins_root_dir = '/plugins'
os.environ['MUTATOR_PLUGINS_DIR'] = self.plugins_root_dir
self.fs.create_dir(self.plugins_root_dir)
self.plugin_getter = mutator_plugin.PluginGetter(self.fuzzer_binary_name)
self.plugins_archives_dir = os.path.join(self.plugins_root_dir, 'archives')
self.plugin_archive_filename = '%s-%s-%s.zip' % (
self.name, os.environ['JOB_NAME'], self.fuzzer_binary_name)
self.plugin_archive_path = os.path.join(self.plugins_archives_dir,
self.plugin_archive_filename)
self.plugins_dir = os.path.join(self.plugins_root_dir, 'plugins')
helpers.patch(self, [
'google_cloud_utils.storage.copy_file_from',
'bot.fuzzers.mutator_plugin._get_mutator_plugins_from_bucket',
])
def mocked_copy_file_from(gcs_url, file_path):
expected_url = '%s/%s' % (mutator_plugin._get_mutator_plugins_bucket_url(
), self.plugin_archive_filename)
self.assertEqual(expected_url, gcs_url)
self.assertEqual(file_path, self.plugin_archive_path)
return file_path
self.mock.copy_file_from.side_effect = mocked_copy_file_from
def setUp(self):
helpers.patch_environ(self)
test_utils.set_up_pyfakefs(self)
self.fs.create_dir('/input')
self.fs.create_dir('/output')
helpers.patch(self, [
'bot.fuzzers.libFuzzer.fuzzer.LibFuzzer.run',
'metrics.fuzzer_logs.get_bucket',
'google_cloud_utils.blobs.write_blob',
])
self.fuzzer = data_types.Fuzzer(revision=1,
file_size='builtin',
source='builtin',
name='libFuzzer',
max_testcases=4,
builtin=True)
self.fuzzer.put()
self.fuzzer_directory = os.path.join(environment.get_value('ROOT_DIR'),
'src', 'python', 'bot', 'fuzzers',
'libFuzzer')
# Needed since local config is not available with fakefs.
self.mock.get_bucket.return_value = None
self.mock.write_blob.return_value = 'sample'
environment.set_value('JOB_NAME', 'job')
environment.set_value('INPUT_DIR', '/input')
def setUp(self):
real_cwd = os.path.realpath(os.getcwd())
test_utils.set_up_pyfakefs(self)
self.fs.add_real_directory(os.path.join(real_cwd, "src", "appengine"),
read_only=False)
self.fs.add_real_directory(os.path.join(real_cwd, "src", "go",
"server"),
read_only=False)
helpers.patch_environ(self)
helpers.patch(
self,
[
"local.butler.common.execute",
"local.butler.common.Gcloud.run",
"local.butler.common.has_file_in_path",
"local.butler.deploy.now",
"os.remove",
],
)
self.mock.execute.side_effect = self._mock_execute
self.mock.has_file_in_path.return_value = True
self.deploy_failure_count = 0
os.environ["ROOT_DIR"] = "."
self.mock.now.return_value = datetime.datetime(2017, 1, 3, 12, 1)
def setUp(self):
test_helpers.patch(self, [
'bot.untrusted_runner.host.stub',
])
test_helpers.patch_environ(self)
test_utils.set_up_pyfakefs(self)
def setUp(self):
"""Setup for get last saved model test."""
# Set up fake filesystem.
test_utils.set_up_pyfakefs(self)
# Create model directory.
self.fs.create_dir(MODEL_DIR)
# Create fake index file and data file.
# Model_1 has two complete files.
self.model_1_data_path = os.path.join(MODEL_DIR,
'model_1.data-00000-of-00001')
self.model_1_index_path = os.path.join(MODEL_DIR, 'model_1.index')
# Create two files for model_1.
self.fs.create_file(self.model_1_data_path)
self.fs.create_file(self.model_1_index_path)
# Update timestamp.
os.utime(self.model_1_data_path, (1330711140, 1330711160))
os.utime(self.model_1_index_path, (1330711140, 1330711160))
# Model_2 has two complete files.
self.model_2_data_path = os.path.join(MODEL_DIR,
'model_2.data-00000-of-00001')
self.model_2_index_path = os.path.join(MODEL_DIR, 'model_2.index')
# Create two files for model_2.
self.fs.create_file(self.model_2_data_path)
self.fs.create_file(self.model_2_index_path)
# Update timestamp. Make sure they are newer than model_1.
os.utime(self.model_2_data_path, (1330713340, 1330713360))
os.utime(self.model_2_index_path, (1330713340, 1330713360))
def setUp(self):
real_cwd = os.path.realpath(os.getcwd())
test_utils.set_up_pyfakefs(self)
self.fs.add_real_directory(os.path.join(real_cwd, 'src', 'appengine'),
read_only=False)
self.fs.add_real_directory(os.path.join(real_cwd, 'src', 'go',
'server'),
read_only=False)
helpers.patch_environ(self)
helpers.patch(self, [
'local.butler.common.execute',
'local.butler.common.Gcloud.run',
'local.butler.common.has_file_in_path',
'local.butler.deploy.now',
'os.remove',
])
self.mock.execute.side_effect = self._mock_execute
self.mock.has_file_in_path.return_value = True
self.deploy_failure_count = 0
os.environ['ROOT_DIR'] = '.'
self.mock.now.return_value = datetime.datetime(2017, 1, 3, 12, 1)
self.manifest_target = 'clusterfuzz-source.manifest'
if sys.version_info.major == 3:
self.manifest_target += '.3'
def setUp(self):
test_utils.set_up_pyfakefs(self)
helpers.patch_environ(self)
self.data_bundles_dir = '/data-bundles'
os.mkdir(self.data_bundles_dir)
environment.set_value('DATA_BUNDLES_DIR', self.data_bundles_dir)
def setUp(self):
test_helpers.patch_environ(self)
test_utils.set_up_pyfakefs(self)
environment.set_value('CACHE_DIR', '/tmp/test-cache')
persistent_cache.initialize()
self.cache = memoize.FifoOnDisk(5)
def setUp(self):
# FIXME: Add support for Windows.
if not environment.is_posix():
self.skipTest(
'Process tests are only applicable for posix platforms.')
test_utils.set_up_pyfakefs(self)
def setUp(self):
test_helpers.patch(self, [
'tempfile.gettempdir',
])
self.mock.gettempdir.return_value = '/tmp'
test_utils.set_up_pyfakefs(self)
def setUp(self):
test_utils.set_up_pyfakefs(self)
helpers.patch_environ(self)
helpers.patch(self, [
'google_cloud_utils.storage.copy_file_to',
])
os.environ['CORPUS_BUCKET'] = 'corpus'
fuzz_target = data_types.FuzzTarget(
id='libFuzzer_test_project_test_fuzzer')
fuzz_target.binary = 'test_fuzzer'
fuzz_target.project = 'test_project'
fuzz_target.engine = 'libFuzzer'
fuzz_target.put()
self.testcase = data_types.Testcase()
self.testcase.fuzzer_name = 'libFuzzer'
self.testcase.overridden_fuzzer_name = 'libFuzzer_test_project_test_fuzzer'
self.testcase.job_type = 'job'
self.testcase.bug_information = '123'
self.testcase.open = False
self.testcase.put()
self.testcase_file_path = '/testcase'
self.fs.create_file(self.testcase_file_path, contents='A')
def setUp(self):
helpers.patch_environ(self)
helpers.patch(self, [
'bot.fuzzers.engine_common.current_timestamp',
'bot.tasks.fuzz_task.GcsCorpus.sync_from_gcs',
'bot.tasks.fuzz_task.GcsCorpus.upload_files',
'build_management.revisions.get_component_list',
'bot.testcase_manager.upload_log',
'bot.testcase_manager.upload_testcase',
'metrics.fuzzer_stats.upload_stats',
])
test_utils.set_up_pyfakefs(self)
os.environ['FUZZ_INPUTS'] = '/fuzz-inputs'
os.environ['FUZZ_INPUTS_DISK'] = '/fuzz-inputs-disk'
os.environ['BUILD_DIR'] = '/build_dir'
self.fs.create_file('/build_dir/test_target')
self.fs.create_file(
'/build_dir/test_target.labels', contents='label1\nlabel2')
self.fs.create_file(
'/build_dir/test_target.owners', contents='*****@*****.**')
self.fs.create_file(
'/build_dir/test_target.components', contents='component1\ncomponent2')
self.fs.create_file('/input')
self.mock.sync_from_gcs.return_value = True
self.mock.upload_files.return_value = True
self.mock.get_component_list.return_value = [{
'component': 'component',
'link_text': 'rev',
}]
self.mock.current_timestamp.return_value = 0.0
def setUp(self):
test_helpers.patch_environ(self)
test_utils.set_up_pyfakefs(self)
test_helpers.patch(self, [
'bot.fuzzers.engine.get',
'bot.fuzzers.engine_common.find_fuzzer_path',
'crash_analysis.stack_parsing.stack_analyzer.get_crash_data',
'system.process_handler.run_process',
'system.process_handler.terminate_stale_application_instances',
])
os.environ['CRASH_RETRIES'] = '3'
os.environ['FAIL_RETRIES'] = '3'
os.environ['BOT_TMPDIR'] = '/bot/tmp'
os.environ['USER_PROFILE_ROOT_DIR'] = '/user-profiles'
os.environ['APP_NAME'] = 'app_name'
os.environ['APP_PATH'] = '/build_dir/app_name'
os.environ['BUILD_DIR'] = os.environ['APP_DIR'] = '/build_dir'
os.environ['CRASH_STACKTRACES_DIR'] = '/crashes'
os.environ['INPUT_DIR'] = '/input'
os.environ['FUZZER_DIR'] = '/fuzzer'
os.environ['WARMUP_TIMEOUT'] = '120'
self.testcase = data_types.Testcase(crash_state='state')
self.mock.find_fuzzer_path.return_value = '/build_dir/target'
self.mock.run_process.return_value = (0, 0, 'output')
self.mock.get.return_value = None
self.mock.get_crash_data.side_effect = mock_get_crash_data
self.fs.create_file('/flags-testcase', contents='target -arg1 -arg2')
self.fs.create_dir('/bot/tmp')
def setUp(self):
test_helpers.patch_environ(self)
test_helpers.patch(self,
["system.new_process.ProcessRunner.run_and_wait"])
test_utils.set_up_pyfakefs(self)
self.gsutil_runner_obj = gsutil.GSUtilRunner()
def setUp(self):
# Set up fake filesystem.
test_helpers.patch_environ(self)
test_utils.set_up_pyfakefs(self)
self.fs.create_dir("/corpus")
self.fs.create_dir("/fuzz-inputs")
self.fs.create_dir("/fake")
self.fs.create_file("/target")
self.fs.add_real_directory(TEST_DIR)
test_helpers.patch(
self,
[
"bot.fuzzers.libFuzzer.engine._is_multistep_merge_supported",
"bot.fuzzers.libfuzzer.LibFuzzerRunner.fuzz",
"bot.fuzzers.libfuzzer.LibFuzzerRunner.merge",
"os.getpid",
],
)
os.environ["JOB_NAME"] = "libfuzzer_asan_job"
os.environ["FUZZ_INPUTS_DISK"] = "/fuzz-inputs"
self.mock._is_multistep_merge_supported = (True) # pylint: disable=protected-access
self.mock.getpid.return_value = 9001
self.maxDiff = None # pylint: disable=invalid-name
def setUp(self):
# Set up fake filesystem.
test_helpers.patch_environ(self)
test_utils.set_up_pyfakefs(self)
test_helpers.patch(self, [
'bot.fuzzers.engine_common.unpack_seed_corpus_if_needed',
])
self.fs.create_dir('/inputs')
self.fs.create_file('/path/target')
self.fs.create_file('/path/blah.dict')
self.fs.create_file('/path/target_seed_corpus.zip')
self.fs.create_file('/path/target.options',
contents=('[libfuzzer]\n'
'max_len=31337\n'
'timeout=11\n'
'dict=blah.dict\n'))
os.environ['FUZZ_INPUTS_DISK'] = '/inputs'
test_helpers.patch(self,
['bot.fuzzers.libFuzzer.launcher.pick_strategies'])
self.mock.pick_strategies.return_value = launcher.StrategyInfo(
fuzzing_strategies=['strategy1', 'strategy2'],
arguments=['-arg1'],
additional_corpus_dirs=['/new_corpus_dir'],
extra_env={'extra_env': '1'},
use_dataflow_tracing=False,
is_mutations_run=True)
def setUp(self):
"""Setup for upload testcase output test."""
test_helpers.patch_environ(self)
test_utils.set_up_pyfakefs(self)
self.testcase_path = '/test/fuzzer/testcase'
self.fs.create_file(self.testcase_path, contents='')
environment.set_value('FUZZ_LOGS_BUCKET', 'fake-gcs-logs')
environment.set_value('FUZZER_NAME', 'fuzzer')
environment.set_value('JOB_NAME', 'job')
environment.set_value('APP_REVISION', '123')
# To be used for generation of date and time when uploading a log.
fake_utcnow = datetime.datetime(2017, 5, 15, 16, 10, 28, 374119)
# Original utcfromtimestamp needs to be preserved, as test_helpres does not
# allow to patch only datetime.datetime.utcnow.
orig_utcfromtimestamp = datetime.datetime.utcfromtimestamp
test_helpers.patch(self, [
'build_management.revisions.get_component_range_list',
'google_cloud_utils.storage.write_data',
'datetime.datetime',
])
self.mock.datetime.utcnow.return_value = fake_utcnow
self.mock.datetime.utcfromtimestamp.side_effect = orig_utcfromtimestamp
self.mock.get_component_range_list.return_value = [{
'component': 'Component',
'link_text': 'REVISION',
}, {
'component': 'Component2',
'link_text': 'REVISION2',
}]
def setUp(self):
helpers.patch(self, [
'chrome.crash_uploader.get_symbolized_stack_bytes',
'bot.tasks.task_creation.create_tasks',
'bot.tasks.setup.archive_testcase_and_dependencies_in_gcs',
'crash_analysis.stack_parsing.stack_analyzer.get_crash_data',
'build_management.revisions.get_real_revision',
'fuzzing.tests.get_command_line_for_application',
'fuzzing.tests.test_for_reproducibility',
'base.utils.get_crash_stacktrace_output',
'crash_analysis.crash_analyzer.ignore_stacktrace',
'crash_analysis.crash_analyzer.is_security_issue',
'datastore.data_handler.get_issue_tracker_name',
'datastore.data_handler.get_project_name',
'google.appengine.api.app_identity.get_application_id',
'google_cloud_utils.big_query.Client.insert',
'google_cloud_utils.big_query.get_api_client', 'time.sleep', 'time.time'
])
test_utils.set_up_pyfakefs(self)
self.mock.time.return_value = 987
self.mock.get_issue_tracker_name.return_value = 'some_issue_tracker'
self.mock.get_project_name.return_value = 'some_project'
self.mock.archive_testcase_and_dependencies_in_gcs.return_value = (
'fuzzed_key', True, 'absolute_path', 'archive_filename')
def setUp(self):
helpers.patch(self, [
'chrome.crash_uploader.FileMetadataInfo',
'bot.tasks.setup.archive_testcase_and_dependencies_in_gcs',
'crash_analysis.stack_parsing.stack_analyzer.get_crash_data',
'fuzzing.tests.get_command_line_for_application',
'base.utils.get_crash_stacktrace_output',
'crash_analysis.crash_analyzer.ignore_stacktrace',
'crash_analysis.crash_analyzer.is_security_issue',
])
helpers.patch_environ(self)
test_utils.set_up_pyfakefs(self)
self.mock.get_command_line_for_application.return_value = 'cmd'
dummy_state = stack_analyzer.StackAnalyzerState()
dummy_state.crash_type = 'type'
dummy_state.crash_address = 'address'
dummy_state.crash_state = 'state'
dummy_state.crash_stacktrace = 'orig_trace'
dummy_state.frames = ['frame 1', 'frame 2']
self.mock.get_crash_data.return_value = dummy_state
self.mock.get_crash_stacktrace_output.return_value = 'trace'
self.mock.archive_testcase_and_dependencies_in_gcs.return_value = (
'fuzzed_key', True, 'absolute_path', 'archive_filename')
environment.set_value('FILTER_FUNCTIONAL_BUGS', False)
with open('/stack_file_path', 'w') as f:
f.write('unsym')
def setUp(self):
test_helpers.patch_environ(self)
test_helpers.patch(self, [
'base.utils.utcnow',
'config.local_config.ProjectConfig.get',
'datastore.locks.acquire_lock',
'datastore.locks.release_lock',
'google_cloud_utils.gsutil.GSUtilRunner',
'google_cloud_utils.storage.list_blobs',
'google_cloud_utils.storage.read_data',
'google_cloud_utils.storage.write_data',
])
test_utils.set_up_pyfakefs(self)
self.mock.write_data.return_value = True
self.mock.utcnow.side_effect = lambda: datetime.datetime(
2018, 11, 1, 0, 0)
FakeGSUtilRunner.rsync_calls = []
self.mock.GSUtilRunner.side_effect = FakeGSUtilRunner
self.mock.get.side_effect = _mock_config_get
os.environ['BOT_NAME'] = 'test-bot'
os.environ['BOT_TMPDIR'] = '/tmp'
os.environ['FAIL_RETRIES'] = '1'
def setUp(self):
test_utils.set_up_pyfakefs(self)
self.fs.CreateFile('/test/small1', contents='aaa')
self.fs.CreateFile('/test/small2', contents='aaa')
self.fs.CreateFile('/test/dir1/small3', contents='aaa')
self.fs.CreateFile('/test/dir1/small4', contents='aaa')
self.fs.CreateFile('/test/dir1/dir1/small5', contents='aaa')
self.fs.CreateFile('/test/dir2/small6', contents='aaa')
def setUp(self):
test_utils.set_up_pyfakefs(self)
for file_num in range(self.NUM_FILES):
self.fs.create_file(os.path.join(self.INPUT_DIR, str(file_num)))
test_helpers.patch(self, ['bot.fuzzers.engine_common.is_lpm_fuzz_target'])
self.mock.is_lpm_fuzz_target.return_value = True
self.strategies = launcher.FuzzingStrategies(None)
def setUp(self):
test_utils.set_up_pyfakefs(self)
helpers.patch_environ(self)
os.environ['ROOT_DIR'] = '/root'
os.environ['FAIL_RETRIES'] = '1'
monitor.metrics_store().reset_for_testing()
def setUp(self):
test_utils.set_up_pyfakefs(self)
self.fs.create_file("/test/small1", contents="aaa")
self.fs.create_file("/test/small2", contents="aaa")
self.fs.create_file("/test/dir1/small3", contents="aaa")
self.fs.create_file("/test/dir1/small4", contents="aaa")
self.fs.create_file("/test/dir1/dir1/small5", contents="aaa")
self.fs.create_file("/test/dir2/small6", contents="aaa")
def setUp(self):
test_helpers.patch_environ(self)
test_utils.set_up_pyfakefs(self)
os.environ['FAIL_WAIT'] = '0'
os.environ['FAIL_RETRIES'] = '1'
self.fs.create_file('/fuzz-testcase')
def setUp(self):
test_helpers.patch(self, [
'bot.fuzzers.engine_common.is_lpm_fuzz_target',
'random.SystemRandom.randint',
])
self.mock.is_lpm_fuzz_target.return_value = False
test_utils.set_up_pyfakefs(self)
self.fs.create_dir('/path/corpus')
self.fs.create_file('/path/target')
def setUp(self):
test_utils.set_up_pyfakefs(self)
helpers.patch_environ(self)
os.environ['FUZZ_DATA'] = '/data'
os.environ['FUZZERS_DIR'] = '/fuzzers'
os.environ['INPUT_DIR'] = '/input'
self.fs.create_file(os.path.join('/input', 'valid.txt'),
contents='valid file')
self.fs.create_file(os.path.join('/input', 'unreadable.txt'),
contents='unreadable file')
os.chmod(os.path.join('/input', 'unreadable.txt'), 0)
def setUp(self):
"""Setup for request handler test."""
test_utils.set_up_pyfakefs(self, allow_root_user=False)
helpers.patch_environ(self)
os.environ['FUZZ_DATA'] = '/data'
os.environ['FUZZERS_DIR'] = '/fuzzers'
os.environ['INPUT_DIR'] = '/input'
self.fs.create_file(
os.path.join('/input', 'valid.txt'), contents='valid file')
self.fs.create_file(
os.path.join('/input', 'unreadable.txt'), contents='unreadable file')
os.chmod(os.path.join('/input', 'unreadable.txt'), 0)
def setUp(self):
test_utils.set_up_pyfakefs(self)
self.fs.CreateDirectory(self.INPUT_DIR)
if not os.path.exists(self.TEMP_DIR):
self.fs.CreateDirectory(self.TEMP_DIR)
self._create_file(fuzzer.AFL_DUMMY_INPUT)
test_helpers.patch(self, [
'bot.fuzzers.utils.get_temp_dir',
])
self.mock.get_temp_dir.return_value = self.TEMP_DIR
dont_use_strategies(self)
def setUp(self):
"""Setup for recommended dictionary test."""
# FIXME: Add support for Windows.
if not environment.is_posix():
self.skipTest(
'Process tests are only applicable for posix platforms.')
self.data_directory = os.path.join(os.path.dirname(__file__), 'data')
dictionaries_directory = os.path.join(self.data_directory,
'dictionaries')
self.dictionary_from_repository_data = read_data_from_file(
os.path.join(dictionaries_directory,
'dictionary_from_repository.dict'))
self.expected_merged_dictionary_data = read_data_from_file(
os.path.join(dictionaries_directory,
'expected_merged_dictionary.dict'))
self.expected_gcs_only_merged_dictionary_data = read_data_from_file(
os.path.join(dictionaries_directory,
'expected_gcs_only_merged_dictionary.dict'))
self.fake_gcs_dictionary_data = read_data_from_file(
os.path.join(dictionaries_directory, 'fake_gcs_dictionary.dict'))
test_helpers.patch(self, [
'bot.fuzzers.dictionary_manager.DictionaryManager.'
'download_recommended_dictionary_from_gcs',
'os.getpid',
])
self.mock.download_recommended_dictionary_from_gcs.side_effect = (
self.mock_download_recommended_dictionary_from_gcs)
self.mock.getpid.return_value = 1337
test_utils.set_up_pyfakefs(self)
self.work_directory_path = '/fake/fuzzers/'
self.fuzz_inputs_path = '/fake/fuzzers/inputs'
self.fuzz_inputs_disk_path = '/fake/fuzzers/inputs-disk'
self.fs.create_dir(self.work_directory_path)
self.fs.create_dir(self.fuzz_inputs_path)
self.fs.create_dir(self.fuzz_inputs_disk_path)
self.local_dictionaries_dir = os.path.join(self.work_directory_path,
'dicts')
self.fs.create_dir(self.local_dictionaries_dir)
self.fuzzer_name = 'test_fuzzer'
self.fuzzer_path = os.path.join(self.work_directory_path,
self.fuzzer_name)
test_helpers.patch_environ(self)
environment.set_value('FAIL_RETRIES', '1')
environment.set_value('FUZZ_INPUTS', self.fuzz_inputs_path)
environment.set_value('FUZZ_INPUTS_DISK', self.fuzz_inputs_disk_path)
