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, [
'clusterfuzz._internal.build_management.revisions.get_component_range_list',
'clusterfuzz._internal.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):
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):
"""Setup for upload tests to cloud storage test."""
test_helpers.patch_environ(self)
test_helpers.patch(self, [
'clusterfuzz._internal.base.utils.utcnow',
'clusterfuzz._internal.config.local_config.ProjectConfig.get',
'clusterfuzz._internal.datastore.locks.acquire_lock',
'clusterfuzz._internal.datastore.locks.release_lock',
'clusterfuzz._internal.google_cloud_utils.gsutil.GSUtilRunner',
'clusterfuzz._internal.google_cloud_utils.storage.list_blobs',
'clusterfuzz._internal.google_cloud_utils.storage.read_data',
'clusterfuzz._internal.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)
helpers.patch_environ(self)
helpers.patch(self, [
'clusterfuzz._internal.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):
# 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):
"""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):
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(self, [
'clusterfuzz._internal.bot.untrusted_runner.host.stub',
])
test_helpers.patch_environ(self)
test_utils.set_up_pyfakefs(self)
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_environ(self)
test_helpers.patch(self, [
'clusterfuzz._internal.system.new_process.ProcessRunner.run_and_wait',
])
test_utils.set_up_pyfakefs(self)
self.gsutil_runner_obj = gsutil.GSUtilRunner()
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_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)
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, [
'clusterfuzz._internal.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):
"""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):
"""Setup for launcher test base."""
test_helpers.patch_environ(self)
os.environ['FAIL_RETRIES'] = '1'
os.environ['BUILD_DIR'] = self.BUILD_DIR
test_utils.set_up_pyfakefs(self)
self.fs.create_dir(self.INPUT_DIR)
if not os.path.exists(self.TEMP_DIR):
self.fs.create_dir(self.TEMP_DIR)
self._create_file(fuzzer.AFL_DUMMY_INPUT)
test_helpers.patch(self, [
'clusterfuzz._internal.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 fuzz target corpus test."""
test_helpers.patch_environ(self)
os.environ['GSUTIL_PATH'] = '/gsutil_path'
os.environ['CORPUS_BUCKET'] = 'bucket'
test_helpers.patch(self, [
'clusterfuzz._internal.fuzzing.corpus_manager._count_corpus_files',
'multiprocessing.cpu_count',
'subprocess.Popen',
])
self.mock.Popen.return_value.poll.return_value = 0
self.mock.Popen.return_value.communicate.return_value = (None, None)
self.mock.cpu_count.return_value = 2
self.mock._count_corpus_files.return_value = 1 # pylint: disable=protected-access
test_utils.set_up_pyfakefs(self)
self.fs.create_dir('/dir')
def setUp(self):
"""Setup for testcase running test."""
test_helpers.patch_environ(self)
test_utils.set_up_pyfakefs(self)
test_helpers.patch(self, [
'clusterfuzz._internal.bot.fuzzers.engine_common.find_fuzzer_path',
'clusterfuzz._internal.crash_analysis.stack_parsing.stack_analyzer.get_crash_data',
'clusterfuzz._internal.system.process_handler.run_process',
'clusterfuzz._internal.system.process_handler.'
'terminate_stale_application_instances',
'clusterfuzz.fuzz.engine.get',
'clusterfuzz._internal.metrics.logs.log',
])
os.environ['CRASH_RETRIES'] = '3'
os.environ['FAIL_RETRIES'] = '3'
os.environ['BOT_TMPDIR'] = '/bot/tmp'
os.environ['TEST_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'
os.environ['BOT_NAME'] = 'bot_name'
data_types.FuzzTarget(engine='engine', project=None,
binary='target').put()
self.blackbox_testcase = data_types.Testcase(
crash_state='state', overridden_fuzzer_name='fuzzer')
self.greybox_testcase = data_types.Testcase(
crash_state='state', overridden_fuzzer_name='engine_target')
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='-arg1 -arg2')
self.fs.create_dir('/bot/tmp')
def setUp(self):
"""Setup for unpack seed corpus if needed test."""
self.data_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)), 'data')
zip_seed_corpus_path = os.path.join(self.data_path, 'seed_corpus.zip')
with open(zip_seed_corpus_path, 'rb') as zip_seed_corpus_handle:
self.zip_seed_corpus_contents = zip_seed_corpus_handle.read()
targz_seed_corpus_path = os.path.join(self.data_path,
'seed_corpus.tar.gz')
with open(targz_seed_corpus_path, 'rb') as targz_seed_corpus_handle:
self.targz_seed_corpus_contents = targz_seed_corpus_handle.read()
seed_corpus_with_subdirectories_path = os.path.join(
self.data_path, 'seed_corpus_with_subdirectories.zip')
with open(seed_corpus_with_subdirectories_path,
'rb') as seed_corpus_handle:
self.seed_corpus_subdirs_contents = seed_corpus_handle.read()
test_utils.set_up_pyfakefs(self)
self.fs.create_dir(self.CORPUS_DIRECTORY)
def setUp(self):
"""Setup for corpus backup test."""
test_helpers.patch_environ(self)
test_utils.set_up_pyfakefs(self)
self.fs.create_dir('/dir')
os.environ['GSUTIL_PATH'] = '/gsutil_path'
os.environ['CORPUS_BUCKET'] = 'bucket'
test_helpers.patch(self, [
'clusterfuzz._internal.base.utils.utcnow',
'clusterfuzz._internal.google_cloud_utils.storage.copy_blob',
'clusterfuzz._internal.google_cloud_utils.storage.copy_file_to',
'multiprocessing.cpu_count',
'shutil.make_archive',
])
self.mock.copy_blob.return_value = True
self.mock.copy_file_to.return_value = True
self.mock.cpu_count.return_value = 2
self.mock.make_archive.side_effect = self._mock_make_archive
self.mock.utcnow.return_value = datetime.datetime(2017, 1, 1)
def setUp(self):
"""Setup for base engine fuzzer test."""
helpers.patch_environ(self)
helpers.patch(self, [
'clusterfuzz._internal.base.utils.default_project_name',
'clusterfuzz._internal.bot.fuzzers.builtin.fuzzers_utils.get_fuzz_targets'
])
test_utils.set_up_pyfakefs(self)
self.fs.create_dir('/input')
self.fs.create_dir('/output')
environment.set_value('BUILD_DIR', '/build_dir')
environment.set_value('FAIL_RETRIES', 1)
environment.set_value('PROJECT_NAME', 'proj')
self.mock.default_project_name.return_value = 'default-proj'
self.mock.get_fuzz_targets.return_value = [
'/build_dir/target',
]
self.fs.create_file(
'/build_dir/target.owners',
contents='[email protected]\[email protected]')
def setUp(self):
"""Setup for deploy test."""
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)
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)
self.corpus = launcher.Corpus()
self.guard = 0
def setUp(self):
self.provider = storage.FileSystemProvider('/local')
test_utils.set_up_pyfakefs(self)
def setUp(self):
test_utils.set_up_pyfakefs(self)
def setUp(self): test_utils.set_up_pyfakefs(self) helpers.patch_environ(self)
def setUp(self):
test_utils.set_up_pyfakefs(self)
self.test_file = '/test'
def setUp(self):
test_helpers.patch_environ(self)
test_utils.set_up_pyfakefs(self)
environment.set_value('FAIL_RETRIES', 1)
def setUp(self):
test_utils.set_up_pyfakefs(self)
self.fs.create_dir(self.DIRECTORY)
self.fs.create_file(self.FILE_PATH, contents=self.FILE_CONTENTS)
def setUp(self):
test_utils.set_up_pyfakefs(self)
helpers.patch_environ(self)
os.environ['ROOT_DIR'] = '/root'
os.environ['FAIL_RETRIES'] = '1'
