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_helpers.patch(self, ['libs.handler.get_email_and_access_token']) flaskapp = flask.Flask('testflask') flaskapp.add_url_rule('/', view_func=OAuthHandler.as_view('/')) self.app = webtest.TestApp(flaskapp) test_helpers.patch_environ(self) os.environ['AUTH_DOMAIN'] = 'localhost'
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 setUp(self): helpers.patch(self, [ 'clusterfuzz._internal.metrics.crash_stats.get_last_successful_hour', 'clusterfuzz._internal.metrics.crash_stats.get', 'clusterfuzz._internal.base.utils.utcnow', ]) self.mock.utcnow.return_value = test_utils.CURRENT_TIME
def setUp(self): self.tmp_dir = tempfile.mkdtemp() os.environ['BOT_TMPDIR'] = os.path.join(self.tmp_dir, 'bot_tmpdir') test_helpers.patch(self, [ 'clusterfuzz._internal.datastore.data_handler.' 'get_data_bundle_bucket_name', 'clusterfuzz._internal.system.environment.' 'set_environment_parameters_from_file', ]) test_helpers.patch_environ(self) # Our tests write data/logs into subdirs of ROOT_DIR. Pivot the ROOT_DIR to # a temporary one. new_root = _create_test_root() os.environ['ROOT_DIR'] = new_root self.saved_cwd = os.getcwd() os.chdir(new_root) environment.set_bot_environment() fuzz_inputs = os.environ['FUZZ_INPUTS'] shell.remove_directory(fuzz_inputs, recreate=True) worker_fuzz_inputs = file_host.rebase_to_worker_root(fuzz_inputs) shell.remove_directory(worker_fuzz_inputs, recreate=True) environment.set_value('GSUTIL_PATH', os.path.dirname(_which('gsutil'))) test_utils.setup_pubsub('test-clusterfuzz') test_utils.create_pubsub_topic(pubsub.PubSubClient(), 'test-clusterfuzz', 'jobs-project-linux')
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 call_f(self, *args, **kwargs): test_helpers.patch(self, ['clusterfuzz._internal.metrics.logs.log_error']) result = f(self, *args, **kwargs) self.assertEqual(0, self.mock.log_error.call_count) return result
def test_syzkaller_kasan_android_with_env(self): """Test syzkaller kasan.""" environment.set_value('OS_OVERRIDE', 'ANDROID_KERNEL') environment.set_bot_environment() self._real_read_data_from_file = utils.read_data_from_file test_helpers.patch(self, [ 'clusterfuzz._internal.platforms.android.fetch_artifact.get', 'clusterfuzz._internal.platforms.android.kernel_utils.get_kernel_hash_and_build_id', 'clusterfuzz._internal.platforms.android.kernel_utils.get_kernel_name', 'clusterfuzz._internal.platforms.android.settings.get_product_brand', 'clusterfuzz._internal.google_cloud_utils.storage.get_file_from_cache_if_exists', 'clusterfuzz._internal.google_cloud_utils.storage.store_file_in_cache', 'clusterfuzz._internal.base.utils.write_data_to_file', 'clusterfuzz._internal.base.utils.read_data_from_file' ]) self.mock.get.side_effect = _mock_fetch_artifact_get self.mock.get_kernel_hash_and_build_id.return_value = '40e9b2ff3a2', '12345' self.mock.get_kernel_name.return_value = 'device_kernel' self.mock.get_product_brand.return_value = 'google' self.mock.get_file_from_cache_if_exists.return_value = False self.mock.store_file_in_cache.return_value = None self.mock.write_data_to_file = None self.mock.read_data_from_file.side_effect = self._mock_read_data_from_file data = self._read_test_data('kasan_syzkaller_android.txt') expected_stack = self._read_test_data( 'kasan_syzkaller_android_linkified.txt') actual_state = stack_analyzer.get_crash_data(data) self.assertEqual(actual_state.crash_stacktrace, expected_stack)
def setUp(self): test_helpers.patch(self, [ 'clusterfuzz._internal.build_management.build_manager.set_environment_vars', 'clusterfuzz._internal.bot.untrusted_runner.host.stub', ]) test_helpers.patch_environ(self)
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): 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(self, [ 'clusterfuzz._internal.build_management.revisions.get_start_and_end_revision', 'clusterfuzz._internal.build_management.revisions.get_component_range_list', 'clusterfuzz._internal.bot.testcase_manager.get_command_line_for_application', 'clusterfuzz._internal.system.environment.is_android', ])
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): 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 setUp(self): """Set up method for strategy pool generator tests with patch.""" test_helpers.patch_environ(self) test_helpers.patch(self, [ 'clusterfuzz._internal.bot.fuzzers.engine_common.decide_with_probability' ]) self.mock.decide_with_probability.return_value = True
def setUp(self): """Setup for upload tests to cloud storage test.""" test_helpers.patch_environ(self) test_helpers.patch(self, [ 'clusterfuzz._internal.base.utils.utcnow', 'clusterfuzz._internal.config.local_config.ProjectConfig.get', 'clusterfuzz._internal.datastore.locks.acquire_lock', 'clusterfuzz._internal.datastore.locks.release_lock', 'clusterfuzz._internal.google_cloud_utils.gsutil.GSUtilRunner', 'clusterfuzz._internal.google_cloud_utils.storage.list_blobs', 'clusterfuzz._internal.google_cloud_utils.storage.read_data', 'clusterfuzz._internal.google_cloud_utils.storage.write_data', ]) test_utils.set_up_pyfakefs(self) self.mock.write_data.return_value = True self.mock.utcnow.side_effect = lambda: datetime.datetime( 2018, 11, 1, 0, 0) FakeGSUtilRunner.rsync_calls = [] self.mock.GSUtilRunner.side_effect = FakeGSUtilRunner self.mock.get.side_effect = _mock_config_get os.environ['BOT_NAME'] = 'test-bot' os.environ['BOT_TMPDIR'] = '/tmp' os.environ['FAIL_RETRIES'] = '1'
def setUp(self): 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): os.environ['BUILD_DIR'] = DATA_DIRECTORY os.environ['FUZZ_INPUTS_DISK'] = TEMP_DIRECTORY os.environ['FAIL_RETRIES'] = '1' test_helpers.patch_environ(self) dont_use_strategies(self) # Make it easy to assert if things were logged. test_helpers.patch(self, [ 'clusterfuzz._internal.metrics.logs.log', 'os.getpid', 'clusterfuzz._internal.bot.fuzzers.afl.launcher.rand_cmplog_level', 'clusterfuzz._internal.bot.fuzzers.afl.launcher.rand_schedule' ]) self.mock.rand_cmplog_level.return_value = '2' self.mock.rand_schedule.return_value = 'fast' self.logged_messages = [] def mocked_log(message, **kwargs): # pylint: disable=unused-argument self.logged_messages.append(message) self.mock.log.side_effect = mocked_log self.mock.getpid.return_value = 1337 clear_temp_dir() create_temp_dir()
def setUp(self): """Setup for upload testcase output test.""" test_helpers.patch_environ(self) test_utils.set_up_pyfakefs(self) self.testcase_path = '/test/fuzzer/testcase' self.fs.create_file(self.testcase_path, contents='') environment.set_value('FUZZ_LOGS_BUCKET', 'fake-gcs-logs') environment.set_value('FUZZER_NAME', 'fuzzer') environment.set_value('JOB_NAME', 'job') environment.set_value('APP_REVISION', '123') # To be used for generation of date and time when uploading a log. fake_utcnow = datetime.datetime(2017, 5, 15, 16, 10, 28, 374119) # Original utcfromtimestamp needs to be preserved, as test_helpres does not # allow to patch only datetime.datetime.utcnow. orig_utcfromtimestamp = datetime.datetime.utcfromtimestamp test_helpers.patch(self, [ 'clusterfuzz._internal.build_management.revisions.get_component_range_list', 'clusterfuzz._internal.google_cloud_utils.storage.write_data', 'datetime.datetime', ]) self.mock.datetime.utcnow.return_value = fake_utcnow self.mock.datetime.utcfromtimestamp.side_effect = orig_utcfromtimestamp self.mock.get_component_range_list.return_value = [{ 'component': 'Component', 'link_text': 'REVISION', }, { 'component': 'Component2', 'link_text': 'REVISION2', }]
def setUp(self): test_helpers.patch_environ(self) test_helpers.patch(self, [ 'clusterfuzz._internal.base.utils.random_weighted_choice', ]) self.mock.random_weighted_choice.side_effect = _mock_random_weighted_choice
def setUp(self): helpers.patch(self, [ 'clusterfuzz._internal.base.utils.utcnow', 'libs.helpers.get_user_email', 'os.urandom', ]) self.mock.get_user_email.return_value = '*****@*****.**'
def setUp(self): test_helpers.patch( self, ['clusterfuzz._internal.base.utils.default_project_name']) # It's important to use chromium here to test they datastore key generation # logic which uses project qualified fuzz target names. self.mock.default_project_name.return_value = 'chromium'
def setUp(self): helpers.patch(self, [ 'clusterfuzz._internal.bot.untrusted_runner.host.stub', ]) helpers.patch_environ(self) os.environ['WORKER_ROOT_DIR'] = '/worker'
def setUp(self): test_helpers.patch(self, [ 'clusterfuzz._internal.base.utils.is_oss_fuzz', 'libs.auth.is_current_user_admin', ]) test_helpers.patch_environ(self) self.mock.is_oss_fuzz.return_value = False
def setUp(self): helpers.patch(self, [ 'libs.issue_management.jira.issue_tracker_manager.' 'IssueTrackerManager.get_watchers', 'libs.issue_management.jira.issue_tracker_manager.' 'IssueTrackerManager.get_issues', 'libs.issue_management.jira.IssueTracker.get_issue', 'libs.issue_management.jira.IssueTracker.new_issue', 'clusterfuzz._internal.config.db_config.get' ]) self.itm = issue_tracker_manager.IssueTrackerManager('VSEC') self.issue_tracker = jira.IssueTracker(self.itm) self.jira_issue = JiraIssue('VSEC-3112') self.mock.get_watchers.return_value = [] self.mock_issue = Issue(self.itm, self.jira_issue) self.mock_issue.title = 'summary' self.mock_issue.body = 'body' self.mock_issue.reporter = 'reporter' self.mock_issue.status = 'NOT STARTED' self.mock_issue.labels.add('label1') self.mock_issue.labels.add('label2') self.mock_issue.components.add('A>B') self.mock_issue.components.add('C>D') self.mock_issue.ccs.add('*****@*****.**')
def setUp(self): test_helpers.patch( self, ['clusterfuzz._internal.platforms.android.adb.run_command']) test_helpers.patch_environ(self) output = _read_data_file('get_device_codename_output.txt') self.mock.run_command.return_value = output
def setUp(self): helpers.patch(self, [ 'clusterfuzz._internal.system.environment.platform', 'clusterfuzz._internal.system.new_process.ChildProcess.kill' ]) self.mock.platform.return_value = 'LINUX' self.mock.kill.side_effect = mock_kill
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): """Setup for get impacts from url test.""" super().setUp() helpers.patch(self, [ 'clusterfuzz._internal.bot.tasks.impact_task.get_start_and_end_revision', 'clusterfuzz._internal.bot.tasks.impact_task.get_impact', 'clusterfuzz._internal.chrome.build_info.get_build_to_revision_mappings', 'clusterfuzz._internal.build_management.revisions.revision_to_branched_from', 'clusterfuzz._internal.datastore.data_handler.get_component_name', ]) self.mock.get_component_name.return_value = None self.mock.revision_to_branched_from.side_effect = ( self.mock_revision_to_branched_from) self.mock.get_start_and_end_revision.return_value = (1, 100) 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.mock.get_impact.side_effect = [ impact_task.Impact(), impact_task.Impact('s', False), impact_task.Impact('b', True), impact_task.Impact('c', False) ]