def setUp(self):
helpers.patch_environ(self)
job = data_types.Job()
job.name = 'job_with_help_format'
job.environment_string = (
'HELP_FORMAT = -%TESTCASE%\\n-%FUZZER_NAME%\\n-%FUZZ_TARGET%\\n'
'-%PROJECT%\\n-%REVISION%\\n-%ENGINE%\\n-%SANITIZER%\\n%ARGS%\\n'
'%SANITIZER_OPTIONS%\n'
'PROJECT_NAME = test_project')
job.put()
job = data_types.Job()
job.name = 'ubsan_job_without_help_format'
job.environment_string = (
'PROJECT_NAME = test_project\n'
'APP_ARGS = '
'--disable-logging --disable-experiments --testcase=%TESTCASE_HTTP_URL%'
)
job.put()
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()
def setUp(self):
test_helpers.patch(self, [
'libs.auth.get_current_user',
'libs.auth.is_current_user_admin',
'handlers.fuzzer_stats.build_results',
])
self.mock.build_results.return_value = json.dumps({})
flaskapp = flask.Flask('testflask')
flaskapp.add_url_rule(
'/fuzzer-stats/load',
view_func=fuzzer_stats.LoadHandler.as_view('/fuzzer-stats/load'))
self.app = webtest.TestApp(flaskapp)
data_types.ExternalUserPermission(
email='*****@*****.**',
entity_kind=data_types.PermissionEntityKind.JOB,
entity_name='job1',
is_prefix=False,
auto_cc=data_types.AutoCCType.ALL).put()
data_types.ExternalUserPermission(
email='*****@*****.**',
entity_kind=data_types.PermissionEntityKind.JOB,
entity_name='job2',
is_prefix=False,
auto_cc=data_types.AutoCCType.ALL).put()
data_types.Job(name='job1').put()
data_types.Job(name='job2').put()
data_types.Job(name='job3').put()
def setUp(self):
job_1 = data_types.Job()
job_1.name = 'job_1'
job_1.environment_string = 'test = 1'
job_1.put()
job_2 = data_types.Job()
job_2.name = 'job_2'
job_2.environment_string = 'test = 2'
job_2.put()
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_record_fuzz_target_ossfuzz(self, binary_name):
"""Test that record_fuzz_target works with OSS-Fuzz projects."""
self.mock.is_oss_fuzz.return_value = True
data_types.Job(name='job', environment_string='PROJECT_NAME = proj\n').put()
data_handler.record_fuzz_target('libFuzzer', binary_name, 'job')
fuzz_target = ndb.Key(data_types.FuzzTarget, 'libFuzzer_proj_child').get()
self.assertDictEqual({
'binary': binary_name,
'engine': 'libFuzzer',
'project': 'proj',
}, fuzz_target.to_dict())
job_mapping = ndb.Key(data_types.FuzzTargetJob,
'libFuzzer_proj_child/job').get()
self.assertDictEqual({
'fuzz_target_name': 'libFuzzer_proj_child',
'job': 'job',
'engine': 'libFuzzer',
'last_run': datetime.datetime(2018, 1, 1, 0, 0),
'weight': 1.0,
}, job_mapping.to_dict())
self.assertEqual('libFuzzer_proj_child', fuzz_target.fully_qualified_name())
self.assertEqual('proj_child', fuzz_target.project_qualified_name())
def setUp(self):
self.maxDiff = None # pylint: disable=invalid-name
test_helpers.patch_environ(self)
test_helpers.patch(self, [
'clusterfuzz._internal.google_cloud_utils.blobs.get_blob_info',
'clusterfuzz._internal.google_cloud_utils.blobs.write_blob',
'libs.access.has_access',
'libs.helpers.get_user_email',
'clusterfuzz._internal.base.utils.current_date_time',
'clusterfuzz._internal.base.utils.utcnow',
])
self.mock.get_blob_info.return_value.filename = 'input'
self.mock.get_blob_info.return_value.key.return_value = 'blob_key'
self.mock.write_blob.return_value = 'blob_key'
self.mock.has_access.return_value = True
self.mock.current_date_time.return_value = '2021-01-01 00:00:00 UTC'
self.mock.utcnow.return_value = datetime.datetime(2021, 1, 1)
self.mock.get_user_email.return_value = 'uploader@email'
data_types.FuzzTarget(engine='libFuzzer',
project='test-project',
binary='binary').put()
data_types.Job(name='libfuzzer_proj_external',
environment_string='PROJECT_NAME = proj',
platform='LINUX',
external_reproduction_topic='topic',
external_updates_subscription='sub').put()
self.app = flask.Flask('testflask')
self.app.add_url_rule(
'/', view_func=upload_testcase.UploadHandlerOAuth.as_view(''))
def setUp(self):
BaseTest.setUp(self)
self.fuchsia_corpus_dir = os.path.join(self.corpus_bucket, 'fuchsia')
shutil.copytree(os.path.join(TEST_DIR, 'fuchsia'),
self.fuchsia_corpus_dir)
self.temp_dir = tempfile.mkdtemp()
builds_dir = os.path.join(self.temp_dir, 'builds')
os.mkdir(builds_dir)
urls_dir = os.path.join(self.temp_dir, 'urls')
os.mkdir(urls_dir)
environment.set_value('BUILDS_DIR', builds_dir)
environment.set_value('BUILD_URLS_DIR', urls_dir)
environment.set_value('QUEUE_OVERRIDE', 'FUCHSIA')
environment.set_value('OS_OVERRIDE', 'FUCHSIA')
env_string = ('RELEASE_BUILD_BUCKET_PATH = '
'gs://clusterfuchsia-builds-test/libfuzzer/'
'fuchsia-([0-9]+).zip')
commands.update_environment_for_job(env_string)
data_types.Job(name='libfuzzer_asan_fuchsia',
platform='FUCHSIA',
environment_string=env_string).put()
data_types.FuzzTarget(binary='example-fuzzers/crash_fuzzer',
engine='libFuzzer',
project='fuchsia').put()
environment.set_value('UNPACK_ALL_FUZZ_TARGETS_AND_FILES', True)
helpers.patch(self, [
'clusterfuzz._internal.system.shell.clear_temp_directory',
])
def setUp(self):
helpers.patch_environ(self)
helpers.patch(self, [
'clusterfuzz._internal.base.persistent_cache.get_value',
'clusterfuzz._internal.base.persistent_cache.set_value',
'clusterfuzz._internal.base.utils.utcnow',
'time.sleep',
])
self.mock.get_value.return_value = None
self.mock.sleep.return_value = None
data_types.Job(name='job').put()
client = pubsub.PubSubClient()
topic = pubsub.topic_name('test-clusterfuzz', 'jobs-linux')
client.create_topic(topic)
client.create_subscription(
pubsub.subscription_name('test-clusterfuzz', 'jobs-linux'), topic)
topic = pubsub.topic_name('test-clusterfuzz', 'high-end-jobs-linux')
client.create_topic(topic)
client.create_subscription(
pubsub.subscription_name('test-clusterfuzz',
'high-end-jobs-linux'), topic)
self.mock.utcnow.return_value = test_utils.CURRENT_TIME.replace(
microsecond=0)
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_get_from_job(self):
"""Test getting from job."""
data_types.Job(
name='job',
environment_string=('ISSUE_TRACKER = from_job\n'
'HELP_URL = help_url\n')).put()
self.assertEqual('from_job', data_handler.get_issue_tracker_name('job'))
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_get_from_job(self):
"""Test getting from job."""
data_types.Job(
name='job',
environment_string=('PROJECT_NAME = from_internal_project\n'
'HELP_URL = help_url\n')).put()
self.assertEqual('from_internal_project',
data_handler.get_project_name('job'))
def test_not_found(self):
"""Test target not found."""
data_types.Job(name='job', environment_string='').put()
with self.assertRaises(helpers.EarlyExitException):
self.assertEqual(
(None, None),
upload_testcase.find_fuzz_target('libFuzzer', 'notfound',
'job'))
def test_without_project_prefix(self):
"""Test find_fuzz_target with a target_name that isn't prefixed with the
project."""
data_types.Job(name='job',
environment_string='PROJECT_NAME = proj\n').put()
self.assertEqual(
('libFuzzer_proj_binary', 'binary'),
upload_testcase.find_fuzz_target('libFuzzer', 'binary', 'job'))
def test_no_mappings(self):
"""Ensure that we do nothing if a job has no mappings."""
job = data_types.Job()
job.name = 'no_mappings'
job.put()
fuzzer_selection.update_mappings_for_job(job, [])
self.assertEqual(_get_fuzzer_list_for_job(job), [])
def setUp(self):
helpers.patch_environ(self)
data_types.Job(
name='linux_asan_chrome',
environment_string=('APP_ARGS = --orig-arg1 --orig-arg2')).put()
data_types.Job(
name='linux_msan_chrome_variant',
environment_string=(
'APP_ARGS = --arg1 --arg2 --arg3="--flag1 --flag2"')).put()
data_types.Job(name='libfuzzer_asan_chrome',
environment_string=('')).put()
data_types.Job(name='libfuzzer_msan_chrome_variant',
environment_string=('')).put()
data_types.Job(name='afl_asan_chrome_variant',
environment_string=('')).put()
self.testcase = test_utils.create_generic_testcase()
def test_new_addition(self):
"""Ensure that we add mappings for a new job."""
job = data_types.Job()
job.name = 'new_addition'
job.put()
fuzzer_selection.update_mappings_for_job(job, ['fuzzer_1', 'fuzzer_2'])
mappings = _get_fuzzer_list_for_job(job)
self.assertIn('fuzzer_1', mappings)
self.assertIn('fuzzer_2', mappings)
def test_get_components_list_no_exact_matches(self):
"""Test get_components_list (no exact matches)."""
data_types.Job(
name='libfuzzer_asan_php',
environment_string=('PROJECT_NAME = php\n'
'HELP_URL = help_url\n')).put()
revisions_dict = {
'/src/afl': {
'type': 'git',
'url': 'https://github.com/AFLplusplus/AFLplusplus.git',
'rev': '7cfa690d1c677e04e0935d6ac3c6b94b5fed50ad'
},
'/src/PHP-src': {
'type': 'git',
'url': 'https://github.com/php/php-src.git',
'rev': '853b7945bc6c97d7d1643f5f8b22851e323829cd'
},
'/src/php-src/oniguruma': {
'type': 'git',
'url': 'https://github.com/kkos/oniguruma.git',
'rev': '2b7b94122c696ffb5ed7fbe9a42c73d4563e3498'
},
}
expected_components_list = [
'/src/PHP-src', '/src/afl', '/src/php-src/oniguruma'
]
actual_components_list = revisions.get_components_list(
revisions_dict, 'libfuzzer_asan_php')
self.assertEqual(expected_components_list, actual_components_list)
revisions_dict = {
'/src/afl': {
'type': 'git',
'url': 'https://github.com/AFLplusplus/AFLplusplus.git',
'rev': '7cfa690d1c677e04e0935d6ac3c6b94b5fed50ad'
},
'/src/php-src': {
'type': 'git',
'url': 'https://github.com/php/php-src.git',
'rev': '853b7945bc6c97d7d1643f5f8b22851e323829cd'
},
'/src/php': {
'type': 'git',
'url': 'https://github.com/kkos/oniguruma.git',
'rev': '2b7b94122c696ffb5ed7fbe9a42c73d4563e3498'
},
}
expected_components_list = ['/src/php', '/src/afl', '/src/php-src']
actual_components_list = revisions.get_components_list(
revisions_dict, 'libfuzzer_asan_php')
self.assertEqual(expected_components_list, actual_components_list)
def setUp(self):
job = data_types.Job(name='test_job',
environment_string='X = 1\nY = 2\n')
job.put()
testcase = data_types.Testcase()
testcase.status = 'Pending'
testcase.open = True
testcase.job_type = 'test_job'
testcase.put()
self.testcase = testcase
def setUp(self):
flaskapp = flask.Flask('testflask')
flaskapp.add_url_rule(
'/external-update', view_func=external_update.Handler.as_view(''))
self.app = webtest.TestApp(flaskapp)
test_helpers.patch(self, [
'clusterfuzz._internal.base.utils.utcnow',
'google.oauth2.id_token.verify_oauth2_token',
])
self.mock.verify_oauth2_token.return_value = {
'email_verified': True,
'email': '*****@*****.**',
}
self.mock.utcnow.return_value = datetime.datetime(2021, 1, 1)
data_types.Job(
name='libfuzzer_external_job',
external_reproduction_topic='topic',
external_updates_subscription='subscription').put()
data_types.Job(name='job').put()
data_types.FuzzTarget(engine='libFuzzer', binary='fuzzer').put()
self.testcase = data_types.Testcase(
open=True,
status='Processed',
fuzzer_name='libFuzzer',
overridden_fuzzer_name='libFuzzer_fuzzer',
job_type='libfuzzer_external_job',
crash_state=('blink::InputTypeView::element\n'
'blink::TextFieldInputType::didSetValueByUserEdit\n'
'blink::TextFieldInputType::subtreeHasChanged\n'),
crash_revision=1336,
crash_stacktrace='original',
last_tested_crash_stacktrace='last_tested',
crash_type='',
security_flag=True)
self.testcase.put()
def setUp(self):
helpers.patch_environ(self)
helpers.patch(self, [
'clusterfuzz._internal.base.utils.default_project_name',
'clusterfuzz._internal.base.memoize.FifoOnDisk.get',
'clusterfuzz._internal.base.memoize.FifoOnDisk.put',
'clusterfuzz._internal.config.local_config.ProjectConfig',
])
self.mock.get.return_value = None
self.mock.default_project_name.return_value = 'project'
self.mock.ProjectConfig.return_value = mock_config.MockConfig({
'env': {
'REVISION_VARS_URL':
'https://chromium.googlesource.com/chromium/src/+/%s/DEPS'
'?format=text'
}
})
os.environ['REVISION_VARS_URL'] = (
'https://chromium.googlesource.com/chromium/src/+/%s/DEPS?format=text')
data_types.Job(
name=ANDROID_JOB_TYPE,
environment_string=(
'HELP_URL = help_url\n'
'REVISION_VARS_URL = https://commondatastorage.googleapis.com/'
'chrome-test-builds/android/revisions/%s')).put()
data_types.Job(
name=BASIC_JOB_TYPE,
environment_string=('HELP_URL = help_url\n')).put()
data_types.Job(
name=SRCMAP_JOB_TYPE,
environment_string=(
'PROJECT_NAME = libass\n'
'HELP_URL = help_url\n'
'REVISION_VARS_URL = https://commondatastorage.googleapis.com/'
'blah-%s.srcmap.json')).put()
data_types.Job(
name=CUSTOM_BINARY_JOB_TYPE,
environment_string=('CUSTOM_BINARY = True\n')).put()
def test_mapping_removed(self):
"""Ensure that mappings are removed properly."""
job = data_types.Job()
job.name = 'remove_fuzzer'
job.put()
self.fuzzer_1.jobs.append('remove_fuzzer')
self.fuzzer_1.put()
fuzzer_selection.update_mappings_for_job(job, [])
mappings = _get_fuzzer_list_for_job(job)
self.assertEqual([], mappings)
def setUp(self):
test_helpers.patch_environ(self)
flaskapp = flask.Flask('testflask')
flaskapp.add_url_rule(
'/schedule-ml-train-tasks',
view_func=ml_train.Handler.as_view('/schedule-ml-train-tasks'))
self.app = webtest.TestApp(flaskapp)
test_helpers.patch(self, [
'clusterfuzz._internal.base.tasks.add_task',
'handlers.base_handler.Handler.is_cron',
'clusterfuzz._internal.metrics.logs.log_error'
])
# Create fake jobs.
data_types.Job(
name='libfuzzer_asan',
environment_string='ML_MODELS_TO_USE = rnn_generator').put()
data_types.Job(name='libfuzzer_msan', environment_string='').put()
data_types.Job(name='afl_asan', environment_string='').put()
data_types.Job(
name='libfuzzer_asan_invalid',
environment_string='ML_MODELS_TO_USE = invalid_model\n').put()
# Create fake fuzzers.
data_types.Fuzzer(name='afl', jobs=['afl_asan']).put()
# Create fake child fuzzers.
data_types.FuzzTarget(engine='libFuzzer',
binary='fake_fuzzer',
project='test-project').put()
data_types.FuzzTargetJob(fuzz_target_name='libFuzzer_fake_fuzzer',
job='libfuzzer_asan').put()
data_types.FuzzTarget(engine='afl',
binary='fake_fuzzer',
project='test-project').put()
data_types.FuzzTargetJob(fuzz_target_name='afl_fake_fuzzer',
job='afl_asan').put()
def setUp(self):
helpers.patch_environ(self)
helpers.patch(self, [
'clusterfuzz._internal.build_management.build_manager.get_primary_bucket_path',
'clusterfuzz._internal.build_management.build_manager.get_revisions_list',
'clusterfuzz._internal.build_management.revisions.get_component_range_list',
'clusterfuzz._internal.config.local_config.ProjectConfig',
'clusterfuzz._internal.google_cloud_utils.blobs.read_key',
'clusterfuzz._internal.google_cloud_utils.pubsub.PubSubClient.publish',
])
self.mock.ProjectConfig.return_value = mock_config.MockConfig({
'env': {
'PROJECT_NAME': 'test-project',
},
'bisect_service': {
'pubsub_topic': '/projects/project/topics/topic',
}
})
data_types.FuzzTarget(id='libFuzzer_proj_target',
engine='libFuzzer',
project='proj',
binary='target').put()
self.testcase = data_types.Testcase(
timestamp=datetime.datetime(2021, 1, 1),
crash_type='crash-type',
crash_state='A\nB\nC',
security_flag=True,
bug_information='1337',
job_type='libfuzzer_asan_proj',
fuzzer_name='libFuzzer',
overridden_fuzzer_name='libFuzzer_proj_target',
regression='123:456',
fixed='123:456',
crash_revision=3,
security_severity=data_types.SecuritySeverity.MEDIUM,
additional_metadata='{"last_tested_crash_revision": 4}')
self.testcase.put()
data_types.Job(
name='libfuzzer_asan_proj',
environment_string='MAIN_REPO = https://repo_url').put()
self.mock.read_key.return_value = b'reproducer'
self.mock.get_component_range_list.return_value = [
{
'link_text': 'old:new',
},
]
def setUp(self):
"""Set up."""
super(UntrustedRunnerIntegrationTest, self).setUp()
data_types.Config().put()
environment_string = ('APP_NAME = app\n'
'RELEASE_BUILD_BUCKET_PATH = '
'gs://clusterfuzz-test-data/test_builds/'
'test-build-([0-9]+).zip\n')
data_types.Job(name='job', environment_string=environment_string).put()
environment_string = (
'RELEASE_BUILD_BUCKET_PATH = '
'gs://clusterfuzz-test-data/test_libfuzzer_builds/'
'test-libfuzzer-build-([0-9]+).zip\n'
'UNPACK_ALL_FUZZ_TARGETS_AND_FILES = True')
data_types.Job(name='libfuzzer_asan_job',
environment_string=environment_string).put()
data_types.Fuzzer(name='fuzzer', data_bundle_name='bundle').put()
data_types.DataBundle(name='bundle',
is_local=True,
sync_to_worker=True).put()
def _create_job(self,
name,
environment_string,
description='',
platform='LINUX'):
"""Create a test job."""
job = data_types.Job()
job.name = name
if environment_string.strip():
job.environment_string = environment_string
job.platform = platform
job.descripton = description
job.put()
return job
def test_mapping_added(self):
"""Ensure that we properly add mappings for existing jobs."""
job = data_types.Job()
job.name = 'adding_fuzzers'
job.put()
fuzzer_selection.update_mappings_for_job(job, ['fuzzer_1'])
mappings = _get_fuzzer_list_for_job(job)
self.assertIn('fuzzer_1', mappings)
self.assertNotIn('fuzzer_2', mappings)
fuzzer_selection.update_mappings_for_job(job, ['fuzzer_1', 'fuzzer_2'])
mappings = _get_fuzzer_list_for_job(job)
self.assertIn('fuzzer_1', mappings)
self.assertIn('fuzzer_2', mappings)
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_mapping_substituted(self):
"""Ensure that mappings are substituted properly."""
job = data_types.Job()
job.name = 'substitute_fuzzers'
job.put()
fuzzer_selection.update_mappings_for_job(job, ['fuzzer_1'])
mappings = _get_fuzzer_list_for_job(job)
self.assertIn('fuzzer_1', mappings)
self.assertNotIn('fuzzer_2', mappings)
fuzzer_selection.update_mappings_for_job(job, ['fuzzer_2'])
mappings = _get_fuzzer_list_for_job(job)
self.assertNotIn('fuzzer_1', mappings)
self.assertIn('fuzzer_2', mappings)
