def setUp(self): test_helpers.patch_environ(self) flaskapp = flask.Flask('testflask') flaskapp.add_url_rule( '/apply-ccs', view_func=oss_fuzz_apply_ccs.Handler.as_view('/apply-ccs')) self.app = webtest.TestApp(flaskapp) data_types.ExternalUserPermission( email='*****@*****.**', entity_name='job', entity_kind=data_types.PermissionEntityKind.JOB, is_prefix=False, auto_cc=data_types.AutoCCType.ALL).put() data_types.ExternalUserPermission( email='*****@*****.**', entity_name='job', entity_kind=data_types.PermissionEntityKind.JOB, is_prefix=False, auto_cc=data_types.AutoCCType.ALL).put() test_helpers.patch(self, [ 'clusterfuzz._internal.base.utils.utcnow', 'handlers.base_handler.Handler.is_cron', 'libs.issue_management.issue_tracker.IssueTracker.get_original_issue', 'libs.issue_management.issue_tracker_policy.get', 'libs.issue_management.issue_tracker_utils.' 'get_issue_tracker_for_testcase', ]) self.itm = IssueTrackerManager('oss-fuzz') self.mock.get_issue_tracker_for_testcase.return_value = ( monorail.IssueTracker(self.itm)) self.mock.utcnow.return_value = datetime.datetime(2016, 1, 1) self.mock.get.return_value = OSS_FUZZ_POLICY self.mock.get_original_issue.side_effect = get_original_issue self.job = data_types.Job(name='job', environment_string='') self.job.put() data_types.Testcase(open=True, status='Processed', bug_information='1337', job_type='job').put() data_types.Testcase(open=True, status='Processed', bug_information='1338', job_type='job').put() data_types.Testcase(open=True, status='Processed', bug_information='1339', job_type='job').put() data_types.Testcase(open=True, status='Processed', bug_information='1340', job_type='job').put()
def test_regular_queue(self): """Test testcase with regular queue.""" t = data_types.Testcase(job_type='job_linux', queue='old') self.assertEqual('jobs-linux', tasks.queue_for_testcase(t)) t = data_types.Testcase(job_type='job_project', queue='old') self.assertEqual('jobs-project-linux-lib', tasks.queue_for_testcase(t))
def test_high_end_queue(self): """Test testcase with high end queue.""" t = data_types.Testcase(job_type='job_linux', queue='high-end-jobs') self.assertEqual('high-end-jobs-linux', tasks.queue_for_testcase(t)) t = data_types.Testcase(job_type='job_project', queue='high-end-jobs') self.assertEqual('high-end-jobs-project-linux-lib', tasks.queue_for_testcase(t))
def setUp(self): flaskapp = flask.Flask('testflask') flaskapp.add_url_rule( '/schedule-open-reproducible-testcase-tasks', view_func=recurring_tasks.OpenReproducibleTestcaseTasksScheduler. as_view('/schedule-open-reproducible-testcase-tasks')) self.app = webtest.TestApp(flaskapp) self.testcase_0 = data_types.Testcase( open=True, one_time_crasher_flag=False, status='Processed', job_type='job', queue='jobs-linux') self.testcase_0.put() self.testcase_1 = data_types.Testcase( open=False, one_time_crasher_flag=False, status='Processed', job_type='job', queue='jobs-linux') self.testcase_1.put() self.testcase_2 = data_types.Testcase( open=True, one_time_crasher_flag=True, status='Processed', job_type='job', queue='jobs-linux') self.testcase_2.put() self.testcase_3 = data_types.Testcase( open=True, one_time_crasher_flag=False, status='NA', job_type='job', queue='jobs-linux') self.testcase_3.put() self.testcase_4 = data_types.Testcase( open=True, one_time_crasher_flag=False, status='Processed', job_type='job_windows', queue='jobs-windows') self.testcase_4.put() data_types.Job(name='job', environment_string='', platform='LINUX').put() data_types.Job( name='job_windows', environment_string='', platform='WINDOWS').put() helpers.patch(self, [ 'handlers.base_handler.Handler.is_cron', ])
def setUp(self): helpers.patch_environ(self) helpers.patch(self, [ 'clusterfuzz._internal.google_cloud_utils.blobs.read_key', ]) self.mock.read_key.return_value = b'reproducer' self.client = pubsub.PubSubClient() self.topic = pubsub.topic_name('proj', 'repro') self.client.create_topic(self.topic) self.subscription = pubsub.subscription_name('proj', 'repro') self.client.create_subscription(self.subscription, self.topic) data_types.Job( name='libfuzzer_asan_blah_external', platform='LINUX', environment_string= ('RELEASE_BUILD_BUCKET_PATH = gs://bucket/a/b/release-([0-9]+).zip\n' 'PROJECT_NAME = proj\n'), external_reproduction_topic=self.topic, external_updates_subscription='projects/proj/subscriptions/updates' ).put() data_types.Job( name='libfuzzer_msan_blah_external', platform='LINUX', environment_string=( 'FUZZ_TARGET_BUILD_BUCKET_PATH = ' 'gs://bucket/a/b/%TARGET%/release-([0-9]+).zip\n' 'PROJECT_NAME = proj\n'), external_reproduction_topic=self.topic, external_updates_subscription='projects/proj/subscriptions/updates' ).put() data_types.FuzzTarget(id='libFuzzer_abc', engine='libFuzzer', binary='abc').put() self.testcase_0 = data_types.Testcase( fuzzer_name='libFuzzer', overridden_fuzzer_name='libFuzzer_abc', crash_revision=1336, minimized_keys='key') self.testcase_0.set_metadata('last_tested_revision', 1337) self.testcase_0.put() self.testcase_1 = data_types.Testcase( fuzzer_name='libFuzzer', overridden_fuzzer_name='libFuzzer_abc', crash_revision=1336, fuzzed_keys='key') self.testcase_1.put()
def test_non_chromium(self): """Test put(). It should tokenize certain fields.""" testcase = data_types.Testcase() testcase.impact_version_indices = ['head'] testcase.impact_stable_version = '4.5.6' testcase.impact_beta_version = '1.2.3' testcase.impact_stable_version_indices = ['s'] testcase.impact_beta_version_indices = ['b'] testcase.impact_stable_version_likely = True testcase.impact_beta_version_likely = True testcase.is_impact_set_flag = True testcase.project_name = 'cobalt' testcase.put() testcase = testcase.key.get() self.assertEqual([], testcase.impact_stable_version_indices) self.assertEqual([], testcase.impact_beta_version_indices) self.assertEqual([], testcase.impact_version_indices) # We only clear the indices. The original data is kept. self.assertEqual('1.2.3', testcase.impact_beta_version) self.assertEqual('4.5.6', testcase.impact_stable_version) self.assertTrue(testcase.is_impact_set_flag) self.assertTrue(testcase.impact_stable_version_likely) self.assertTrue(testcase.impact_beta_version_likely)
def create_generic_testcase(created_days_ago=28): """Create a simple test case.""" testcase = data_types.Testcase() # Add more values here as needed. Intended to be the bare minimum for what we # need to simulate a test case. testcase.absolute_path = '/a/b/c/test.html' testcase.crash_address = '0xdeadbeef' testcase.crash_revision = 1 testcase.crash_state = 'crashy_function()' testcase.crash_stacktrace = testcase.crash_state testcase.crash_type = 'fake type' testcase.comments = 'Fuzzer: test' testcase.fuzzed_keys = 'abcd' testcase.minimized_keys = 'efgh' testcase.fuzzer_name = 'fuzzer1' testcase.open = True testcase.one_time_crasher_flag = False testcase.job_type = 'test_content_shell_drt' testcase.status = 'Processed' testcase.timestamp = CURRENT_TIME - datetime.timedelta( days=created_days_ago) testcase.project_name = 'project' testcase.platform = 'linux' testcase.put() return testcase
def setUp(self): test_helpers.patch(self, [ 'clusterfuzz._internal.datastore.data_handler.get_issue_description', 'clusterfuzz._internal.datastore.data_handler.get_issue_summary', 'clusterfuzz._internal.datastore.data_handler.get_stacktrace', 'clusterfuzz._internal.datastore.data_handler.update_group_bug', 'libs.helpers.get_issue_tracker_for_testcase', 'libs.auth.get_current_user', 'handlers.testcase_detail.show.get_testcase_detail', 'libs.access.get_access', 'libs.issue_management.issue_tracker_policy.get', 'libs.issue_management.issue_filer.get_memory_tool_labels', ]) self.mock.get_access.return_value = access.UserAccess.Allowed self.mock.get_testcase_detail.return_value = {'testcase': 'yes'} self.mock.get_current_user().email = '*****@*****.**' self.mock.get.return_value = CHROMIUM_POLICY flaskapp = flask.Flask('testflask') flaskapp.add_url_rule('/', view_func=update_issue.Handler.as_view('/')) self.app = webtest.TestApp(flaskapp) self.testcase = data_types.Testcase() self.testcase.bug_information = '' self.testcase.crash_state = 'fake_crash_state' self.testcase.put()
def setUp(self): helpers.patch(self, [ 'clusterfuzz._internal.build_management.build_manager.setup_production_build', 'clusterfuzz._internal.system.environment.get_value', 'clusterfuzz._internal.bot.testcase_manager.get_command_line_for_application', 'clusterfuzz._internal.bot.testcase_manager.test_for_crash_with_retries', ]) self.env = { 'APP_PATH': 'app', 'TEST_TIMEOUT': '9', 'JOB_NAME': 'linux_asan_chrome', 'TOOL_NAME': 'ASAN' } self.result = mock.Mock() self.result.is_crash = mock.Mock() self.result.get_stacktrace = mock.Mock() self.mock.setup_production_build.return_value = ( build_manager.ProductionBuild('/base', '52', None, 'stable')) self.mock.get_value.side_effect = self.env.get self.mock.test_for_crash_with_retries.return_value = self.result self.result.is_crash.return_value = True self.result.get_stacktrace.return_value = 'crashed-trace' self.testcase = data_types.Testcase()
def setUp(self): helpers.patch(self, [ 'clusterfuzz._internal.bot.tasks.impact_task.get_impact_on_build', 'clusterfuzz._internal.bot.tasks.impact_task.get_impacts_from_url', 'clusterfuzz._internal.bot.testcase_manager.get_command_line_for_application', 'clusterfuzz._internal.chrome.build_info.get_build_to_revision_mappings', ]) self.mock.get_build_to_revision_mappings.return_value = { 'stable': { 'revision': '398287', 'version': '74.0.1345.34' }, 'beta': { 'revision': '399171', 'version': '75.0.1353.43' }, 'canary': { 'revision': '400000', 'version': '76.0.1234.43' } } self.impacts = impact_task.Impacts( stable=impact_task.Impact('s', False), beta=impact_task.Impact('b', True), extended_stable=impact_task.Impact('es', False), head=impact_task.Impact('76.0.1234.43', False)) self.testcase = data_types.Testcase() self.testcase.job_type = 'job' self.testcase.impact_extended_stable_version = 'es-ver' self.testcase.impact_stable_version = 's-ver' self.testcase.impact_beta_version = 'b-ver' self.testcase.regression = '123:456'
def setUp(self): helpers.patch(self, [ 'clusterfuzz._internal.base.utils.is_chromium', 'clusterfuzz._internal.bot.tasks.impact_task.get_impacts_from_url', 'clusterfuzz._internal.bot.tasks.impact_task.get_impacts_on_prod_builds', 'clusterfuzz._internal.bot.tasks.setup.setup_testcase', 'clusterfuzz._internal.build_management.build_manager.is_custom_binary', 'clusterfuzz._internal.build_management.build_manager.has_production_builds', 'clusterfuzz._internal.bot.testcase_manager.get_command_line_for_application', 'clusterfuzz._internal.base.tasks.add_task', ]) impacts = impact_task.Impacts( stable=impact_task.Impact('stable', False, 'trace-stable'), beta=impact_task.Impact('beta', True, 'trace-beta'), extended_stable=impact_task.Impact('extended stable', False, 'trace-extended-stable'), head=impact_task.Impact('head', False, 'trace-head')) self.mock.is_chromium.return_value = True self.mock.is_custom_binary.return_value = False self.mock.has_production_builds.return_value = True self.mock.get_impacts_from_url.return_value = impacts self.mock.setup_testcase.return_value = (['a'], None, 'path') self.mock.get_impacts_on_prod_builds.return_value = impacts self.testcase = data_types.Testcase() self.testcase.is_impact_set_flag = False self.testcase.status = 'Processed' self.testcase.crash_stacktrace = 'trace' self.testcase.regression = '123:456' self.testcase.job_type = 'job2' self.testcase.project_name = 'chromium' self.testcase.put()
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): self.testcase_ids = [] for i in range(100): testcase = data_types.Testcase() testcase.timestamp = datetime.datetime.fromtimestamp(i) testcase.put() self.testcase_ids.append(testcase.key.id())
def test_no_issue_url(self): """Test no issue url.""" self.mock.get_testcase.return_value = data_types.Testcase() self.mock.get_issue_url.return_value = '' response = self.app.get('/issue/12345', expect_errors=True) self.assertEqual(404, response.status_int)
def setUp(self): test_helpers.patch(self, [ 'libs.access._is_domain_allowed', 'libs.auth.get_current_user', 'clusterfuzz._internal.config.db_config.get', 'libs.issue_management.issue_tracker.IssueTracker.get_original_issue', 'libs.issue_management.issue_tracker_utils.' 'get_issue_tracker_for_testcase', 'libs.issue_management.monorail.issue_tracker_manager.' 'IssueTrackerManager', ]) self.itm = issue_tracker_manager.IssueTrackerManager('test') self.itm.project_name = 'test-project' self.mock.get_issue_tracker_for_testcase.return_value = ( monorail.IssueTracker(self.itm)) self.get_issue = self.itm.get_issue self.email = '*****@*****.**' self.mock.get_current_user.return_value = auth.User(self.email) self.bug = issue.Issue() self.bug.id = 1234 self.bug.itm = self.itm self.original_bug = issue.Issue() self.original_bug.id = 5678 self.original_bug.itm = self.itm self.testcase = data_types.Testcase() self.mock.get.return_value = (data_types.Config( relax_testcase_restrictions=True)) self.mock._is_domain_allowed.return_value = False
def test_setup_testcase(self): """Test setup_testcase.""" job_type = 'job' self._setup_env(job_type=job_type) fuzz_inputs = os.environ['FUZZ_INPUTS'] testcase = data_types.Testcase() testcase.job_type = job_type testcase.absolute_path = os.path.join(fuzz_inputs, 'testcase.ext') with tempfile.NamedTemporaryFile() as f: f.write(b'contents') f.seek(0) testcase.fuzzed_keys = blobs.write_blob(f) testcase.put() file_list, input_directory, testcase_file_path = (setup.setup_testcase( testcase, job_type)) six.assertCountEqual(self, file_list, [ testcase.absolute_path, ]) self.assertEqual(input_directory, fuzz_inputs) self.assertEqual(testcase_file_path, testcase.absolute_path) worker_fuzz_inputs = file_host.rebase_to_worker_root(fuzz_inputs) self.assert_dirs_equal(fuzz_inputs, worker_fuzz_inputs)
def setUp(self): test_helpers.patch(self, [ 'clusterfuzz._internal.base.external_users._allowed_entities_for_user', 'clusterfuzz._internal.base.external_users._get_permissions_query_for_user', 'libs.access.get_user_job_type', 'libs.access.has_access', 'libs.helpers.get_user_email', ]) flaskapp = flask.Flask('testflask') flaskapp.add_url_rule('/', view_func=testcase_list.JsonHandler.as_view('/')) self.app = webtest.TestApp(flaskapp) self.testcases = [] for i in range(10): t = data_types.Testcase() t.crash_type = '' t.crash_state = '' t.status = 'Processed' t.security_flag = True t.is_a_duplicate_flag = False t.one_time_crasher_flag = False t.open = True t.is_leader = True t.timestamp = datetime.datetime.fromtimestamp(100 - i) t.put() self.testcases.append(t)
def test_bazel_test_args(self): """Test bazel test args with a libFuzzer test case""" environment.set_value('HELP_FORMAT', 'bazel test %BAZEL_TEST_ARGS%') testcase = data_types.Testcase() testcase.fuzzer_name = 'libFuzzer' testcase.overridden_fuzzer_name = 'libFuzzer_test_project_test_fuzzer' testcase.job_type = 'ubsan_job_without_help_format' testcase.crash_revision = 1337 testcase.minimized_arguments = ( '%TESTCASE% test_fuzzer -arg1=val1 -arg2="val2 val3"') testcase.put() testcase.set_metadata( 'env', { 'ASAN_OPTIONS': { 'handle_abort': 1, 'symbolize': 0, 'redzone': 512, }, 'UBSAN_OPTIONS': { 'halt_on_error': 1, 'symbolize': 0, }, 'OTHER_OPTIONS': { 'symbolize': 1 } }) self.assertEqual( data_handler.get_formatted_reproduction_help(testcase), 'bazel test ' '--test_env=ASAN_OPTIONS="handle_abort=1:redzone=512" ' '--test_env=UBSAN_OPTIONS="halt_on_error=1" ' '--test_arg=-arg1=val1 ' '--test_arg=\'-arg2=val2 val3\'')
def test_none(self): """Test none.""" testcase = data_types.Testcase() testcase.bug_information = None testcase.group_bug_information = None self.assertListEqual( [], search_tokenizer.tokenize_bug_information(testcase))
def test_empty(self): """Test empty.""" testcase = data_types.Testcase() testcase.bug_information = '' testcase.group_bug_information = 0 self.assertListEqual( [], search_tokenizer.tokenize_bug_information(testcase))
def test_set(self): """Test set everything.""" os.environ['FAIL_RETRIES'] = '3' os.environ['FAIL_WAIT'] = '3' os.environ['BUILD_KEY'] = 'build_key_value' os.environ['BUILD_KEY'] = 'build_key_value' os.environ['BUILD_URL'] = 'build_url_value' os.environ['APP_DIR'] = 'app_dir_value' os.environ['GN_ARGS_PATH'] = 'app_dir_value/args.gn' self.fs.create_file( 'app_dir_value/args.gn', contents=('is_asan = true\n' 'goma_dir = /home/user/goma\n' 'use_goma = true\n' 'v8_enable_verify_heap = true')) testcase = data_types.Testcase() data_handler.set_initial_testcase_metadata(testcase) metadata = json.loads(testcase.additional_metadata) self.assertEqual('build_key_value', metadata['build_key']) self.assertEqual('build_url_value', metadata['build_url']) self.assertEqual( 'is_asan = true\nuse_goma = true\nv8_enable_verify_heap = true', metadata['gn_args'])
def setUp(self): """Prepare testcases to file to GitHub.""" data_types.Job(name='job1', environment_string=JOB1_ENVIRONMENT, platform='linux').put() data_types.Job(name='job2', environment_string=JOB2_ENVIRONMENT, platform='linux').put() data_types.Job(name='job3', environment_string=JOB3_ENVIRONMENT, platform='linux').put() data_types.Job(name='job4', environment_string=JOB4_ENVIRONMENT, platform='linux').put() testcase_args1 = { 'bug_information': '300', } testcase_args2 = { 'bug_information': '300', 'github_repo_id': GITHUB_REPO_ID, 'github_issue_num': GITHUB_ISSUE_NUM, } self.testcase1 = data_types.Testcase(job_type='job1', **testcase_args1) self.testcase1.put() self.testcase2 = data_types.Testcase(job_type='job2', **testcase_args1) self.testcase2.put() self.testcase3 = data_types.Testcase(job_type='job3', **testcase_args1) self.testcase3.put() self.testcase4 = data_types.Testcase(job_type='job1', **testcase_args2) self.testcase4.put() self.testcase5 = data_types.Testcase(job_type='job4', **testcase_args1) self.testcase5.put() test_helpers.patch(self, [ 'clusterfuzz._internal.config.db_config.get_value', ]) self.mock.get_value.return_value = GITHUB_ACCESS_TOKEN
def test_tokenize(self): """Test tokenize.""" testcase = data_types.Testcase() testcase.bug_information = '123' testcase.group_bug_information = 456 self.assertListEqual( ['123', '456'], search_tokenizer.tokenize_bug_information(testcase))
def test_no_earlier_revisions(self): """Make sure we don't throw exceptions if nothing is before min revision.""" testcase = data_types.Testcase() testcase.put() self.mock._testcase_reproduces_in_revision.return_value = False result = regression_task.validate_regression_range( testcase, '/a/b', 'job_type', [0], 0) self.assertTrue(result)
def test_one_earlier_revision(self): """Test a corner-case with few revisions earlier than min revision.""" testcase = data_types.Testcase() testcase.put() self.mock._testcase_reproduces_in_revision.return_value = False result = regression_task.validate_regression_range( testcase, '/a/b', 'job_type', [0, 1, 2], 1) self.assertTrue(result)
def test_valid_range(self): """Ensure that we handle valid ranges correctly.""" testcase = data_types.Testcase() testcase.put() self.mock._testcase_reproduces_in_revision.return_value = False result = regression_task.validate_regression_range( testcase, '/a/b', 'job_type', [0, 1, 2, 3, 4], 4) self.assertTrue(result)
def test_get_issue_url_no_bug(self): """Test for a case when testcase has no bugs associated with it.""" testcase = data_types.Testcase() test_issue_tracker = issue_tracker.IssueTracker() self.mock.get_issue_tracker_for_testcase.return_value = test_issue_tracker issue_tracker_utils.get_issue_url(testcase) self.assertEqual(0, self.mock.issue_url.call_count)
def test_get_issue_url_group_bug(self): """Test for a case when testcase is associated with a group bug.""" testcase = data_types.Testcase() testcase.group_bug_information = 31337 test_issue_tracker = issue_tracker.IssueTracker() self.mock.get_issue_tracker_for_testcase.return_value = test_issue_tracker issue_tracker_utils.get_issue_url(testcase) self.mock.issue_url.assert_called_with(test_issue_tracker, '31337')
def test_forbidden(self): """Test forbidden testcase.""" self.mock.can_user_access_testcase.return_value = False data_types.Testcase().put() with self.assertRaises(helpers.EarlyExitException) as cm: show.get_testcase_detail_by_id(2) self.assertEqual(cm.exception.status, 403) self.assertEqual(str(cm.exception), '')
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')