def test_fuzzer_can_boot_and_run_reproducer(self): """Tests running a testcase that should cause a fast, predictable crash.""" environment.set_value('FUZZ_TARGET', 'example-fuzzers/overflow_fuzzer') environment.set_value('JOB_NAME', 'libfuzzer_asan_fuchsia') build_manager.setup_build() testcase_path, _ = setup_testcase_and_corpus('fuchsia_crash', 'empty_corpus') engine_impl = engine.LibFuzzerEngine() result = engine_impl.reproduce('example-fuzzers/overflow_fuzzer', testcase_path, ['-timeout=25', '-rss_limit_mb=2560'], 30) self.assertIn('ERROR: AddressSanitizer: heap-buffer-overflow on address', result.output) self.assertIn('Running: data/fuchsia_crash', result.output)
def _update_environment_for_testcase(testcase, build_directory): """Update environment variables that depend on the test case.""" commands.update_environment_for_job(testcase.job_definition) environment.set_value('JOB_NAME', testcase.job_type) fuzzer_directory = setup.get_fuzzer_directory(testcase.fuzzer_name) environment.set_value('FUZZER_DIR', fuzzer_directory) task_name = environment.get_value('TASK_NAME') setup.prepare_environment_for_testcase(testcase, testcase.job_type, task_name) build_manager.set_environment_vars( [environment.get_value('FUZZER_DIR'), build_directory]) _verify_target_exists(build_directory)
def test_fuzzer_can_boot_and_run(self): """Tests running a single round of fuzzing on a Fuchsia target, using 'echo' in place of a fuzzing command.""" # TODO(flowerhack): Fuchsia's `fuzz` only calls 'echo running on fuchsia!' # right now by default, but we'll call it explicitly in here as we # diversity `fuzz`'s functionality build_manager.setup_fuchsia_build() environment.set_value('FUZZ_TARGET', 'example_fuzzers/toy_fuzzer') testcase_path = setup_testcase_and_corpus('aaaa', 'empty_corpus', fuzz=True) output = run_launcher(testcase_path, 'test_fuzzer') self.assertIn( 'localhost run \'fuchsia-pkg://fuchsia.com/example_fuzzers#meta/' 'toy_fuzzer.cmx\'', output)
def setUp(self): android_helpers.AndroidTest.setUp(self) BaseIntegrationTest.setUp(self) if android.settings.get_sanitizer_tool_name() != 'hwasan': raise Exception('Device is not set up with HWASan.') environment.set_value('BUILD_DIR', ANDROID_DATA_DIR) environment.set_value('JOB_NAME', 'libfuzzer_hwasan_android_device') environment.reset_current_memory_tool_options() self.crash_dir = TEMP_DIR self.adb_path = android.adb.get_adb_path() self.hwasan_options = 'HWASAN_OPTIONS="%s"' % quote( environment.get_value('HWASAN_OPTIONS'))
def setUp(self): test_helpers.patch_environ(self) environment.set_value('FUZZER_NAME', 'fuzzer_1') environment.set_value('JOB_NAME', 'fake_job') # To be used for generation of date and time when uploading a log. self.fake_utcnow = datetime.datetime(2017, 3, 21, 11, 15, 13, 666666) self.fake_log_time = datetime.datetime(2017, 4, 22, 12, 16, 14, 777777) test_helpers.patch(self, [ 'datetime.datetime', 'google_cloud_utils.storage.write_data', ]) self.mock.datetime.utcnow.return_value = self.fake_utcnow
def _handle_response(build, response): """Handle build setup response.""" if not response.result: _clear_env() return False _update_env_from_response(response) if not environment.get_value('APP_PATH'): fuzzer_directory = environment.get_value('FUZZER_DIR') if fuzzer_directory: build_manager.set_environment_vars([fuzzer_directory]) environment.set_value('APP_REVISION', build.revision) return True
def _connect(): """Initial connect to the worker.""" worker_assignment = _get_host_worker_assignment() assert worker_assignment is not None assert worker_assignment.worker_name is not None assert worker_assignment.project_name is not None root_cert = _get_root_cert(worker_assignment.project_name) if not root_cert: logs.log_warn('TLS certs not yet generated.') time.sleep(WAIT_TLS_CERT_SECONDS) sys.exit(0) environment.set_value( 'QUEUE_OVERRIDE', untrusted.platform_name(worker_assignment.project_name, 'linux')) server_name = worker_assignment.worker_name if not environment.get_value('LOCAL_DEVELOPMENT'): server_name += untrusted.internal_network_domain() _host_state.worker_bot_name = worker_assignment.worker_name credentials = grpc.ssl_channel_credentials(root_cert) _host_state.channel = grpc.secure_channel( '%s:%d' % (server_name, config.PORT), credentials=credentials, options=config.GRPC_OPTIONS) _host_state.stub = UntrustedRunnerStub(_host_state.channel) logs.log('Connecting to worker %s...' % server_name) _host_state.channel.subscribe( _channel_connectivity_changed, try_to_connect=True) channel_state = _check_channel_state(config.INITIAL_CONNECT_TIMEOUT_SECONDS) if channel_state == ChannelState.INCONSISTENT: logs.log_warn('Worker inconsistent on initial connect.') monitoring_metrics.HOST_INCONSISTENT_COUNT.increment() host_exit_no_return(return_code=0) if channel_state != ChannelState.READY: raise untrusted.HostException('Failed to connect to worker.') environment.set_value('WORKER_BOT_NAME', worker_assignment.worker_name) _host_state.heartbeat_thread = threading.Thread(target=_do_heartbeat) _host_state.heartbeat_thread.daemon = True _host_state.heartbeat_thread.start()
def _download_testcase(testcase_id, testcase, configuration): """Download the test case and return its path.""" testcase_download_url = '{url}?id={id}'.format( url=configuration.get('testcase_download_url'), id=testcase_id) response, content = http_utils.request(testcase_download_url, method=http_utils.GET_METHOD, configuration=configuration) if response.status != 200: raise errors.ReproduceToolUnrecoverableError( 'Unable to download test case.') # Create a temporary directory where we can store the test case. bot_absolute_filename = response['x-goog-meta-filename'] testcase_directory = os.path.join(environment.get_value('ROOT_DIR'), 'current-testcase') shell.create_directory(testcase_directory) environment.set_value('FUZZ_INPUTS', testcase_directory) testcase_path = os.path.join(testcase_directory, os.path.basename(bot_absolute_filename)) utils.write_data_to_file(content, testcase_path) # Unpack the test case if it's archived. # TODO(mbarbella): Rewrite setup.unpack_testcase and share this code. if testcase.minimized_keys and testcase.minimized_keys != 'NA': mask = data_types.ArchiveStatus.MINIMIZED else: mask = data_types.ArchiveStatus.FUZZED if testcase.archive_state & mask: archive.unpack(testcase_path, testcase_directory) file_list = archive.get_file_list(testcase_path) testcase_path = None for file_name in file_list: if testcase.absolute_path.endswith(file_name): testcase_path = os.path.join(testcase_directory, file_name) break if not testcase_path: raise errors.ReproduceToolUnrecoverableError( 'Test case file was not found in archive.\n' 'Original filename: {absolute_path}.\n' 'Archive contents: {file_list}'.format( absolute_path=testcase.absolute_path, file_list=file_list)) return testcase_path
def setUp(self): """Set up.""" super(MinimizeTaskTestUntrusted, self).setUp() environment.set_value('JOB_NAME', 'libfuzzer_asan_job') helpers.patch(self, [ 'datastore.data_handler.get_data_bundle_bucket_name', ]) patcher = mock.patch( 'bot.fuzzers.libFuzzer.fuzzer.LibFuzzer.fuzzer_directory', new_callable=mock.PropertyMock) mock_fuzzer_directory = patcher.start() self.addCleanup(patcher.stop) mock_fuzzer_directory.return_value = os.path.join( environment.get_value('ROOT_DIR'), 'src', 'python', 'bot', 'fuzzers', 'libFuzzer') job = data_types.Job( name='libfuzzer_asan_job', environment_string=( 'APP_NAME = launcher.py\n' 'RELEASE_BUILD_BUCKET_PATH = ' 'gs://clusterfuzz-test-data/test_libfuzzer_builds/' 'test-libfuzzer-build-([0-9]+).zip\n' 'REVISION_VARS_URL = https://commondatastorage.googleapis.com/' 'clusterfuzz-test-data/test_libfuzzer_builds/' 'test-libfuzzer-build-%s.srcmap.json\n')) job.put() data_types.FuzzTarget(engine='libFuzzer', binary='test_fuzzer', project='test-project').put() data_types.FuzzTargetJob(fuzz_target_name='libFuzzer_test_fuzzer', engine='libFuzzer', job='libfuzzer_asan_job').put() environment.set_value('USE_MINIJAIL', True) data_types.Fuzzer(revision=1, file_size='builtin', source='builtin', name='libFuzzer', max_testcases=4, builtin=True).put() self.temp_dir = tempfile.mkdtemp( dir=environment.get_value('FUZZ_INPUTS'))
def test_minimize_testcase(self): """Tests running a testcase that should be able to minimize.""" environment.set_value('FUZZ_TARGET', 'example-fuzzers/trap_fuzzer') environment.set_value('JOB_NAME', 'libfuzzer_asan_fuchsia') build_manager.setup_build() testcase_path, _ = setup_testcase_and_corpus('fuchsia_overlong_crash', 'empty_corpus') minimize_output_path = os.path.join(TEMP_DIR, 'output') engine_impl = engine.LibFuzzerEngine() result = engine_impl.minimize_testcase('example-fuzzers/trap_fuzzer', ['-runs=1000000'], testcase_path, minimize_output_path, 30) with open(minimize_output_path) as f: result = f.read() self.assertEqual('HI!', result)
def setUp(self): test_helpers.patch_environ(self) # Set Android specific environment variables like DEVICE_TMP_DIR, etc. environment.set_value('OS_OVERRIDE', 'ANDROID') environment.set_bot_environment() # Clear and create temporary directory on device. self.device_temp_dir = adb.DEVICE_TMP_DIR adb.remove_directory(self.device_temp_dir, recreate=True) # Create local temp directory. self.local_temp_dir = tempfile.mkdtemp() # Run adb as root. adb.run_as_root()
def setUp(self): super(AflRunnerTest, self).setUp() test_helpers.patch_environ(self) test_helpers.patch(self, ['bot.fuzzers.engine_common.is_lpm_fuzz_target']) self.mock.is_lpm_fuzz_target.return_value = True environment.set_value('HARD_TIMEOUT_OVERRIDE', 600) config = launcher.AflConfig.from_target_path(self.TARGET_PATH) self.runner = launcher.AflRunner(self.TARGET_PATH, config, self.TESTCASE_FILE_PATH, self.INPUT_DIR) self.fuzz_result = new_process.ProcessResult() self.args = ['-iinput1', '-ooutput', '123', '456'] self.times_called = 0
def test_weighted_strategy_pool(self): """Tests whether a proper strategy pool is returned by the multi armed bandit selection implementation with medium temperature. Based on deterministic strategy selection. Mutator plugin is patched to be included in our strategy pool.""" environment.set_value('STRATEGY_SELECTION_METHOD', 'multi_armed_bandit') strategy_pool = strategy_selection.generate_weighted_strategy_pool( strategy_list=strategy.AFL_STRATEGY_LIST, use_generator=True, engine_name='afl') self.assertTrue( strategy_pool.do_strategy(strategy.CORPUS_MUTATION_ML_RNN_STRATEGY)) self.assertFalse( strategy_pool.do_strategy(strategy.CORPUS_MUTATION_RADAMSA_STRATEGY)) self.assertTrue(strategy_pool.do_strategy(strategy.CORPUS_SUBSET_STRATEGY))
def test_corpus_sync(self): """Test syncing corpus.""" environment.set_value('CORPUS_BUCKET', 'clusterfuzz-test-data') corpus = corpus_manager.RemoteFuzzTargetCorpus('corpus_test_fuzzer', 'child_fuzzer') worker_root = environment.get_value('WORKER_ROOT_DIR') test_corpus_directory = os.path.join(worker_root, 'corpus') os.mkdir(test_corpus_directory) try: self.assertTrue(corpus.rsync_to_disk(test_corpus_directory)) self.assertItemsEqual( os.listdir(test_corpus_directory), ['123', '456', 'abc']) finally: if os.path.exists(test_corpus_directory): shutil.rmtree(test_corpus_directory, ignore_errors=True)
def __init__(self, target_path, config, testcase_file_path, input_directory, afl_tools_path=None): """Inits the AflRunner. Args: target_path: Path to the fuzz target. config: AflConfig object. testcase_file_path: File to write crashes to. input_directory: Corpus directory passed to afl-fuzz. afl_tools_path: Path that is used to locate afl-* tools. """ self.target_path = target_path self.config = config self.testcase_file_path = testcase_file_path self._input_directory = input_directory if afl_tools_path is None: afl_tools_path = os.path.dirname(target_path) # Set paths to afl tools. self.afl_fuzz_path = os.path.join(afl_tools_path, 'afl-fuzz') self.afl_showmap_path = os.path.join(afl_tools_path, 'afl-showmap') self._afl_input = None self._afl_output = None self.strategies = FuzzingStrategies() # Set this to None so we can tell if it has never been set or if it's just # empty. self._fuzzer_stderr = None self.initial_max_total_time = 0 for env_var, value in config.additional_env_vars.iteritems(): environment.set_value(env_var, value) self.showmap_output_path = os.path.join(fuzzer_utils.get_temp_dir(), self.SHOWMAP_FILENAME) self.merge_timeout = engine_common.get_merge_timeout( DEFAULT_MERGE_TIMEOUT) self.showmap_no_output_logged = False
def setUp(self): """Set up.""" super().setUp() environment.set_value('JOB_NAME', 'libfuzzer_asan_job') job = data_types.Job( name='libfuzzer_asan_job', environment_string=( 'RELEASE_BUILD_BUCKET_PATH = ' 'gs://clusterfuzz-test-data/test_libfuzzer_builds/' 'test-libfuzzer-build-([0-9]+).zip\n' 'REVISION_VARS_URL = https://commondatastorage.googleapis.com/' 'clusterfuzz-test-data/test_libfuzzer_builds/' 'test-libfuzzer-build-%s.srcmap.json\n')) job.put() self.temp_dir = tempfile.mkdtemp(dir=environment.get_value('FUZZ_INPUTS'))
def test_preemptible(self): """Test preemptible bot tasks.""" environment.set_value('PREEMPTIBLE', True) environment.set_value('THREAD_MULTIPLIER', 1) tasks.add_task('test', 'high', 'job', queue='high-end-jobs-linux', wait_time=0) tasks.add_task('test', 'normal', 'job', queue='jobs-linux', wait_time=0) task = tasks.get_task() self.assertIsNone(task)
def test_minimize(self): """Test minimize.""" testcase_file_path = os.path.join(self.temp_dir, 'testcase') with open(testcase_file_path, 'wb') as f: f.write('EEE') with open(testcase_file_path) as f: fuzzed_keys = blobs.write_blob(f) testcase_path = os.path.join(self.temp_dir, 'testcase') testcase = data_types.Testcase( crash_type='Null-dereference WRITE', crash_address='', crash_state='Foo\n', crash_stacktrace='', crash_revision=1337, fuzzed_keys=fuzzed_keys, fuzzer_name='libFuzzer', overridden_fuzzer_name='libFuzzer_test_fuzzer', job_type='libfuzzer_asan_job', original_absolute_path=testcase_path, absolute_path=testcase_path, minimized_arguments='%TESTCASE% test_fuzzer') testcase.put() data_types.FuzzTarget(engine='libFuzzer', binary='test_fuzzer').put() fuzzers_init.run() self._setup_env(job_type='libfuzzer_asan_job') environment.set_value('APP_ARGS', testcase.minimized_arguments) environment.set_value('LIBFUZZER_MINIMIZATION_ROUNDS', 3) minimize_task.execute_task(testcase.key.id(), 'libfuzzer_asan_job') testcase = data_handler.get_testcase_by_id(testcase.key.id()) self.assertNotEqual('', testcase.minimized_keys) self.assertNotEqual('NA', testcase.minimized_keys) self.assertNotEqual(testcase.fuzzed_keys, testcase.minimized_keys) self.assertEqual({'ASAN_OPTIONS': {}}, testcase.get_metadata('env')) blobs.read_blob_to_disk(testcase.minimized_keys, testcase_path) with open(testcase_path) as f: self.assertEqual(1, len(f.read()))
def test_fuzzer_can_boot_and_run_reproducer(self): """Tests running a testcase that should cause a fast, predictable crash.""" environment.set_value("FUZZ_TARGET", "example_fuzzers/overflow_fuzzer") environment.set_value("JOB_NAME", "libfuzzer_asan_fuchsia") build_manager.setup_build() testcase_path, _ = setup_testcase_and_corpus("fuchsia_crash", "empty_corpus") engine_impl = engine.LibFuzzerEngine() result = engine_impl.reproduce( "example_fuzzers/overflow_fuzzer", testcase_path, ["-timeout=25", "-rss_limit_mb=2560"], 30, ) self.assertIn("ERROR: AddressSanitizer: heap-buffer-overflow on address", result.output) self.assertIn("Running: data/fuchsia_crash", result.output)
def update_environment_for_job(environment_string): """Process the environment variable string included with a job.""" # Now parse the job's environment definition. environment_values = ( environment.parse_environment_definition(environment_string)) for key, value in six.iteritems(environment_values): environment.set_value(key, value) # If we share the build with another job type, force us to be a custom binary # job type. if environment.get_value('SHARE_BUILD_WITH_JOB_TYPE'): environment.set_value('CUSTOM_BINARY', True) if environment.is_trusted_host(): environment_values['JOB_NAME'] = environment.get_value('JOB_NAME') from bot.untrusted_runner import environment as worker_environment worker_environment.update_environment(environment_values)
def test_libfuzzer_testcase_with_default_help_format(self): """Test the function with a libfuzzer test case, with HELP_FORMAT set in environment.""" environment.set_value( 'HELP_FORMAT', '-%TESTCASE%\\n-%FUZZER_NAME%\\n-%FUZZ_TARGET%\\n-%PROJECT%\\n' '-%REVISION%\\n') testcase = data_types.Testcase() testcase.fuzzer_name = 'simple_fuzzer' testcase.job_type = 'job_without_help_format' testcase.crash_revision = 1337 testcase.put() self.assertEquals( data_handler.get_formatted_reproduction_help(testcase), '-{id}\n-simple_fuzzer\n-\n-test_project\n-1337\n'.format( id=testcase.key.id()))
def _set_random_fuzz_target_for_fuzzing_if_needed(fuzz_targets, target_weights): """Sets a random fuzz target for fuzzing.""" if not environment.is_engine_fuzzer_job(): return # TODO(ochang): Untie this dependency on knowledge of the current task. task_name = environment.get_value('TASK_NAME') if task_name != 'fuzz': return fuzz_targets = list(fuzz_targets) if not fuzz_targets: logs.log_error('No fuzz targets found. Unable to pick random one.') return fuzz_target = fuzzer_selection.select_fuzz_target(fuzz_targets, target_weights) environment.set_value('FUZZ_TARGET', fuzz_target) logs.log('Picked fuzz target %s for fuzzing.' % fuzz_target)
def test_blackbox_fuzzer_testcase_with_default_help_format(self): """Test the function with a blackbox fuzzer test case, with HELP_FORMAT set in environment.""" environment.set_value( 'HELP_FORMAT', '-%TESTCASE%\\n-%FUZZER_NAME%\\n-%FUZZ_TARGET%\\n-%PROJECT%\\n' '-%REVISION%\\n-%ENGINE%\\n-%SANITIZER%\\n%ARGS%\\n') testcase = data_types.Testcase() testcase.fuzzer_name = 'simple_fuzzer' testcase.job_type = 'ubsan_job_without_help_format' testcase.crash_revision = 1337 testcase.put() self.assertEquals( data_handler.get_formatted_reproduction_help(testcase), ('-{id}\n-simple_fuzzer\n-NA\n-test_project\n-1337\n' '-NA\n-UBSAN\n--disable-logging --disable-experiments\n').format( id=testcase.key.id()))
def test_regular(self): """Test regular tasks.""" environment.set_value('THREAD_MULTIPLIER', 1) tasks.add_task('test', 'high', 'job', queue='high-end-jobs-linux', wait_time=0) tasks.add_task('test', 'normal', 'job', queue='jobs-linux', wait_time=0) task = tasks.get_task() self.assertEqual('test', task.command) self.assertEqual('normal', task.argument) self.assertEqual('job', task.job) self.assertEqual('test normal job', task.payload())
def setup_additional_args_for_app(): """Select additional args for the specified app at random.""" # Convert the app_name to lowercase. Case may vary by platform. app_name = environment.get_value('APP_NAME', '').lower() # Hack: strip file extensions that may be appended on various platforms. extensions_to_strip = ['.exe', '.apk'] for extension in extensions_to_strip: app_name = utils.strip_from_right(app_name, extension) trials = data_types.Trial.query(data_types.Trial.app_name == app_name) trial = select_trial(trials) if not trial or not trial.app_args: return current_app_args = environment.get_value('APP_ARGS', '').rstrip() environment.set_value('APP_ARGS', '%s %s' % (current_app_args, trial.app_args)) environment.set_value('TRIAL_APP_ARGS', trial.app_args)
def setUp(self): """Put data in the local ndb table the tests to query from.""" test_helpers.patch_environ(self) test_helpers.patch( self, ['bot.fuzzers.engine_common.decide_with_probability']) self.mock.decide_with_probability.return_value = True data = [] strategy1 = data_types.FuzzStrategyProbability() strategy1.strategy_name = 'corpus_mutations_ml_rnn,corpus_subset,' strategy1.probability = 1 strategy1.engine = 'afl' data.append(strategy1) ndb.put_multi(data) distribution = fuzz_task.get_strategy_distribution_from_ndb() environment.set_value('USE_BANDIT_STRATEGY_SELECTION', True) environment.set_value('STRATEGY_SELECTION_DISTRIBUTION', distribution)
def _setup_x(): """Start Xvfb and blackbox before running the test application.""" if environment.platform() != 'LINUX': return [] environment.set_value('DISPLAY', DISPLAY) print('Starting Xvfb...') xvfb_runner = new_process.ProcessRunner('/usr/bin/Xvfb') xvfb_process = xvfb_runner.run(additional_args=[ DISPLAY, '-screen', '0', '1280x1024x24', '-ac', '-nolisten', 'tcp' ]) time.sleep(5) # Allow some time for Xvfb to start. print('Starting blackbox...') blackbox_runner = new_process.ProcessRunner('/usr/bin/blackbox') blackbox_process = blackbox_runner.run() time.sleep(5) # Allow some time for blackbox to start. # Return all handles we create so they can be terminated properly at exit. return [xvfb_process, blackbox_process]
def test_weighted_strategy_pool(self): """Tests whether a proper strategy pool is returned by the multi armed bandit selection implementation with medium temperature. Based on deterministic strategy selection. Mutator plugin is patched to be included in our strategy pool.""" environment.set_value('STRATEGY_SELECTION_METHOD', 'multi_armed_bandit') strategy_pool = strategy_selection.generate_weighted_strategy_pool( strategy_list=strategy.LIBFUZZER_STRATEGY_LIST, use_generator=True, engine_name='libFuzzer') self.assertTrue( strategy_pool.do_strategy(strategy.CORPUS_MUTATION_ML_RNN_STRATEGY)) self.assertTrue( strategy_pool.do_strategy(strategy.RANDOM_MAX_LENGTH_STRATEGY)) self.assertTrue(strategy_pool.do_strategy(strategy.VALUE_PROFILE_STRATEGY)) self.assertTrue( strategy_pool.do_strategy(strategy.RECOMMENDED_DICTIONARY_STRATEGY)) self.assertFalse( strategy_pool.do_strategy(strategy.CORPUS_MUTATION_RADAMSA_STRATEGY)) self.assertFalse(strategy_pool.do_strategy(strategy.FORK_STRATEGY))
def test_setup_regular_build_fuzz_target(self): """Test setting up a regular build.""" environment.set_value('TASK_NAME', 'fuzz') environment.set_value('TASK_ARGUMENT', 'libFuzzer') launcher_dir = os.path.join('src', 'python', 'bot', 'fuzzers', 'libFuzzer') environment.set_value('FUZZER_DIR', os.path.join(os.environ['ROOT_DIR'], launcher_dir)) self._setup_env(job_type='libfuzzer_asan_job') build = build_manager.setup_build(target_weights={}) self.assertIsNotNone(build) worker_root_dir = os.environ['WORKER_ROOT_DIR'] expected_build_dir = os.path.join( worker_root_dir, 'bot', 'builds', 'clusterfuzz-test-data_test_libfuzzer_builds_' '41a87efdd470c6f00e8babf61548bf6c7de57137', 'revisions') expected_app_dir = os.path.join(worker_root_dir, launcher_dir) self.assertEqual( os.path.join(expected_app_dir, 'launcher.py'), os.environ['APP_PATH']) self.assertEqual('1337', os.environ['APP_REVISION']) self.assertEqual('', os.environ['APP_PATH_DEBUG']) self.assertEqual(expected_build_dir, os.environ['BUILD_DIR']) self.assertEqual(expected_app_dir, os.environ['APP_DIR']) self.assertEqual('test_fuzzer', os.environ['FUZZ_TARGET'])
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")