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')
