def test_try_filetype_with_coverage_via_afl_fail( self, subprocess_check_output: unittest.mock.MagicMock): binary_path = "tshark" repo_path = "" max_timeout = 2500 memory_limit = "none" h = HeuristicConfigCreator(binary_path=binary_path, repo_path=repo_path, dummyfiles_path=os.getcwd()) h.MAX_TIMEOUT = max_timeout h.memory_limit = memory_limit h.FAILED_INVOCATIONS_THRESHOLD = 2 h.afl_cmin_path = "afl-cmin" mocked_return_value = "cmin-output" subprocess_check_output.return_value = bytes(mocked_return_value, encoding="utf-8") subprocess_check_output.side_effect = subprocess.CalledProcessError( returncode=-1, cmd="alja") h.try_filetype_with_coverage_via_afl("-f", os.getcwd(), file_type=".test") with self.assertRaises(helpers.exceptions.NoCoverageInformation): h.try_filetype_with_coverage_via_afl("-g", os.getcwd(), file_type=".test")
async def test_prepare( self, mock_instance_repo: unittest.mock.MagicMock, ) -> None: async def _run_sub_test( wait_for_containers: bool, expected_container_status: ContainerInstanceStatus, ) -> None: with patch.object( CppUnionPIDDataPreparerService, "prepare_on_container_async" ) as mock_prepare_on_container_async, patch.object( PIDStage, "update_instance_containers"): container = ContainerInstance( instance_id="123", ip_address="192.0.2.0", status=expected_container_status, ) mock_prepare_on_container_async.return_value = container stage = PIDPrepareStage( stage=UnionPIDStage.PUBLISHER_PREPARE, instance_repository=mock_instance_repo, storage_svc="STORAGE", # pyre-ignore onedocker_svc="ONEDOCKER", # pyre-ignore onedocker_binary_config=MagicMock( task_definition="offline-task:1#container", tmp_directory="/tmp/", binary_version="latest", ), ) res = await stage.prepare( instance_id="123", input_path="in", output_path="out", num_shards=1, wait_for_containers=wait_for_containers, ) self.assertEqual( PIDStage.get_stage_status_from_containers([container]), res, ) data_tests = ( (True, ContainerInstanceStatus.COMPLETED), (True, ContainerInstanceStatus.FAILED), (False, ContainerInstanceStatus.STARTED), ) for data_test in data_tests: with self.subTest( wait_for_containers=data_test[0], expected_container_status=data_test[1], ): # reset mocks for each subTests mock_instance_repo.reset_mock() await _run_sub_test( data_test[0], data_test[1], )
def test_check_and_wait_for_rate_limit( self, time_sleep: unittest.mock.MagicMock): with unittest.mock.patch('helpers.helpers.get_utc_now', return_value=datetime(2017, 10, 18, 1, 30, 0, 0)): utils.wait_for_rate_limit("2017-10-18T02:00:00Z") time_sleep.assert_called_once_with(30 * 60) self.assertEqual(time_sleep.call_count, 1)
def test_skips_already_installed_dependencies( self, subprocess_mock: unittest.mock.MagicMock ) -> None: unit = InstallSystemPackagesBuildUnit() # Definitely installed already unit.dependencies = ["python"] unit.build() subprocess_mock.assert_not_called()
def test_withManifest_succeeds(self, mock_ingest: unittest.mock.MagicMock) -> None: # Act request_args = {"manifest_path": "gs://fake-bucket/foo/manifest.yaml"} headers = {"X-Appengine-Cron": "test-cron"} response = self.client.get( "/ingest", query_string=request_args, headers=headers ) # Assert self.assertEqual(200, response.status_code) mock_ingest.assert_called_with( ANY, GcsfsFilePath(bucket_name="fake-bucket", blob_name="foo/manifest.yaml") )
def test_download_seed_to_folder(self, requests_get: unittest.mock.MagicMock): """ Test if the Building process works. """ chunks = [b"a", b"b", b"c"] md5_hash_chunk = "900150983cd24fb0d6963f7d28e17f72" # The md5 hash of all the chunks saved together as string response_mock = unittest.mock.MagicMock() response_mock.iter_content.return_value = iter(chunks) requests_get.return_value = response_mock tmp_dir = "tmp/" if os.path.isdir(tmp_dir): shutil.rmtree(tmp_dir) os.mkdir(tmp_dir) download_link = "somerandomlink" # Link not important, we have mocked the response filename = "Makefile" # This file should exists now: self.assertTrue( utils.download_seed_to_folder(download_link=download_link, to_directory=tmp_dir, filename=filename)) self.assertTrue(os.path.isfile(tmp_dir + "/" + filename)) self.assertEqual(utils.md5(tmp_dir + "/" + filename), md5_hash_chunk) # We are simulating a reponse that would be the exact same file again: Should not be downloaded. response_mock.iter_content.return_value = (chunks) self.assertFalse( utils.download_seed_to_folder(download_link=download_link, to_directory=tmp_dir, filename=filename + "_new")) self.assertFalse(os.path.exists(tmp_dir + "/" + filename + "_new")) shutil.rmtree(tmp_dir)
def test_build_jobs(self, mock_cpu_count: unittest.mock.MagicMock) -> None: """Tests that the number of build jobs comes out correctly.""" mock_cpu_count.return_value = 13 cases = [ # MAX_JOBS, USE_NINJA, IS_WINDOWS, want (( '8', True, False), ['-j', '8']), # noqa: E201,E241 (( None, True, False), None), # noqa: E201,E241 (( '7', False, False), ['-j', '7']), # noqa: E201,E241 (( None, False, False), ['-j', '13']), # noqa: E201,E241 (( '6', True, True), ['-j', '6']), # noqa: E201,E241 (( None, True, True), None), # noqa: E201,E241 (( '11', False, True), ['/p:CL_MPCount=11']), # noqa: E201,E241 (( None, False, True), ['/p:CL_MPCount=13']), # noqa: E201,E241 ] for (max_jobs, use_ninja, is_windows), want in cases: with self.subTest(MAX_JOBS=max_jobs, USE_NINJA=use_ninja, IS_WINDOWS=is_windows): with contextlib.ExitStack() as stack: stack.enter_context(env_var('MAX_JOBS', max_jobs)) stack.enter_context(unittest.mock.patch.object(tools.setup_helpers.cmake, 'USE_NINJA', use_ninja)) stack.enter_context(unittest.mock.patch.object(tools.setup_helpers.cmake, 'IS_WINDOWS', is_windows)) cmake = tools.setup_helpers.cmake.CMake() with unittest.mock.patch.object(cmake, 'run') as cmake_run: cmake.build({}) cmake_run.assert_called_once() call, = cmake_run.mock_calls build_args, _ = call.args if want is None: self.assertNotIn('-j', build_args) else: self.assert_contains_sequence(build_args, want)
def test_ingestFails_raisesError( self, mock_ingest: unittest.mock.MagicMock ) -> None: # Arrange mock_ingest.side_effect = ValueError("Malformed manifest") # Act request_args = {"manifest_path": "gs://fake-bucket/foo/manifest.yaml"} headers = {"X-Appengine-Cron": "test-cron"} with self.assertRaisesRegex(ValueError, "Malformed manifest"): self.client.get("/ingest", query_string=request_args, headers=headers) # Assert mock_ingest.assert_called_with( ANY, GcsfsFilePath(bucket_name="fake-bucket", blob_name="foo/manifest.yaml") )
def test_try_to_query_status_from_reputation( self, reputation_checker_path: unittest.mock.MagicMock ) -> None: """ Tests of the method that tries to define the status from the reputation checker. """ self.checker.subject = "192.168.1.1" reputation_checker_path.return_value = ReputationCheckerStatus( subject="192.168.1.1", idna_subject="192.168.1.1", status="SANE", status_source="REPUTATION", tested_at=datetime.utcnow(), ) self.checker.try_to_query_status_from_reputation() expected_status = None actual_status = self.checker.status.status self.assertEqual(expected_status, actual_status) reputation_checker_path.return_value = ReputationCheckerStatus( subject="192.168.1.1", idna_subject="192.168.1.1", status="MALICIOUS", status_source="REPUTATION", tested_at=datetime.utcnow(), ) self.checker.try_to_query_status_from_reputation() expected_status = "ACTIVE" actual_status = self.checker.status.status self.assertEqual(expected_status, actual_status) expected_source = "REPUTATION" actual_source = self.checker.status.status_source self.assertEqual(expected_source, actual_source)
def test_ingestFails_raisesError( self, mock_ingest: unittest.mock.MagicMock) -> None: # Arrange mock_ingest.side_effect = ValueError("Malformed manifest") # Act request_args = {"manifest_path": "gs://fake-bucket/foo/manifest.yaml"} headers = {"X-Appengine-Cron": "test-cron"} response = self.client.get("/ingest", query_string=request_args, headers=headers) # Assert self.assertEqual(500, response.status_code) self.assertEqual("Error ingesting data: 'Malformed manifest'", response.get_data().decode()) mock_ingest.assert_called_with( ANY, GcsfsFilePath(bucket_name="fake-bucket", blob_name="foo/manifest.yaml"))
def test_get_current(self, getcwd_path: unittest.mock.MagicMock) -> None: """ Tests the method which let us get the current directory. """ getcwd_path.return_value = "/hello/world" expected = "/hello/world" actual = self.helper.get_current() self.assertEqual(expected, actual)
def test_invoke_afl_cmin(self, subprocess_check_output: unittest.mock.MagicMock): binary_path = "tshark" repo_path = "" max_timeout = 2500 memory_limit = "none" h = HeuristicConfigCreator(binary_path=binary_path, repo_path=repo_path, dummyfile_path=__file__, dummyfiles_path=os.getcwd()) h.MAX_TIMEOUT = max_timeout h.memory_limit = memory_limit h.afl_cmin_path = "afl-cmin" mocked_return_value = "cmin-output" subprocess_check_output.return_value = bytes(mocked_return_value, encoding="utf-8") self.assertEqual(h.invoke_afl_cmin("-f", "tmp_dir"), mocked_return_value)
def test_query_dns_record_ptr( self, dns_query_patch: unittest.mock.MagicMock) -> None: """ Tests the method that let us query the (right) DNS record of the given subject. """ dns_query_patch.return_value = ["example.org"] given = "192.168.1.1" expected = {"PTR": ["example.org"]} self.checker.subject = given actual = self.checker.query_dns_record() self.assertEqual(expected, actual)
def test_get_info_gaierror(self, addrinfo_path: unittest.mock.MagicMock) -> None: """ Tests the method which let us get the information to work with for the case that we get an gaierror exception. """ def fake_hostbyaddr(*args, **kwargs): raise socket.gaierror("This is a test :-)") addrinfo_path.side_effect = fake_hostbyaddr given = "example.org" expected = dict() # pylint: disable=use-dict-literal actual = HostByAddrInfo(given).get_info() self.assertEqual(expected, actual)
def test_get_info_gaierror(self, addrinfo_path: unittest.mock.MagicMock) -> None: """ Tests the method which let us get the information to work with for the case that we get an gaierror exception. """ def fake_getattrinfo(*args, **kwargs): raise socket.gaierror("This is a test :-)") addrinfo_path.side_effect = fake_getattrinfo given = "example.org" expected = [] actual = AddressInfo(given).get_info() self.assertEqual(expected, actual)
def test_get_info(self, addrinfo_path: unittest.mock.MagicMock) -> None: """ Tests the method which let us get the information to work with. """ def fake_getattrinfo(*args, **kwargs): _ = args _ = kwargs return [("192.169.1.1", "10.20.30.40", ["10.55.0.32"])] addrinfo_path.side_effect = fake_getattrinfo given = "example.org" expected = ["10.55.0.32"] actual = AddressInfo(given).get_info() self.assertEqual(expected, actual)
def test_get_current_with_sep( self, getcwd_path: unittest.mock.MagicMock) -> None: """ Tests the method which let us get the current directory for the case that we want to have the directory separator at the end. """ getcwd_path.return_value = "/hello/world" if PlatformUtility.is_windows(): expected = "/hello/world\\" else: expected = "/hello/world/" actual = self.helper.get_current(with_end_sep=True) self.assertEqual(expected, actual)
def test_get_problem(self, requests_get_mock: unittest.mock.MagicMock): page = unittest.mock.MagicMock() page.status_code = 200 inputs = ["5 4\n3 2", "111 222\n555 2 -1 -7", "999 221\n22 1 0\n5 5 5"] outpus = ["1", "2\n", "2\n1 5 8\n2 5 6"] content = """ <div class="sample-test"> <div class="input"> <div class="title">Input</div> <pre>{0}</pre> </div> <div class="output"> <div class="title">Output</div> <pre>{1}</pre> </div> <div class="input"> <div class="title">Input</div> <pre>{2}</pre> </div> <div class="output"> <div class="title">Output</div> <pre>{3}</pre> </div> <div class="input"> <div class="title">Input</div> <pre>{4}</pre> </div> <div class="output"> <div class="title">Output</div> <pre>{5}</pre> </div> </div> """.format(*[pre_contents.replace("\n", "<br>") for input_output_pair in zip(inputs, outpus) for pre_contents in input_output_pair]) page.content = content.encode() requests_get_mock.return_value = page link = "http://codeforces.com/contest/839/problem/A" problem = fetch_cf_examples.Codeforces.get_problem(link) assert link == problem.problem_link assert len(problem.examples) == 3 assert problem.examples == [ fetch_cf_examples.Example(inputs[0], outpus[0]), fetch_cf_examples.Example(inputs[1], outpus[1]), fetch_cf_examples.Example(inputs[2], outpus[2])]
def test_query_dns_record_no_response( self, dns_query_patch: unittest.mock.MagicMock) -> None: """ Tests the method that let us query the (right) DNS record of the given subject. Here we test the case that there is systematically no (valid) response. """ dns_query_patch.return_value = [] given = "example.net" expected = dict() # pylint: disable=use-dict-literal self.checker.subject = given actual = self.checker.query_dns_record() self.assertEqual(expected, actual)
def test_query_dns_record_not_valid_subject( self, dns_query_patch: unittest.mock.MagicMock) -> None: """ Tests the method that let us query the (right) DNS record of the given subject. Here we test the case that the given subject is not correct. """ dns_query_patch.return_value = [] given = "a1" expected = dict() # pylint: disable=use-dict-literal self.checker.subject = given actual = self.checker.query_dns_record() self.assertEqual(expected, actual)
def test_build_jobs(self, mock_cpu_count: unittest.mock.MagicMock) -> None: """Tests that the number of build jobs comes out correctly.""" mock_cpu_count.return_value = 13 cases = [ # MAX_JOBS, USE_NINJA, IS_WINDOWS, want (("8", True, False), ["-j", "8"]), # noqa: E201,E241 ((None, True, False), None), # noqa: E201,E241 (("7", False, False), ["-j", "7"]), # noqa: E201,E241 ((None, False, False), ["-j", "13"]), # noqa: E201,E241 (("6", True, True), ["-j", "6"]), # noqa: E201,E241 ((None, True, True), None), # noqa: E201,E241 (("11", False, True), ["/p:CL_MPCount=11"]), # noqa: E201,E241 ((None, False, True), ["/p:CL_MPCount=13"]), # noqa: E201,E241 ] for (max_jobs, use_ninja, is_windows), want in cases: with self.subTest(MAX_JOBS=max_jobs, USE_NINJA=use_ninja, IS_WINDOWS=is_windows): with contextlib.ExitStack() as stack: stack.enter_context(env_var("MAX_JOBS", max_jobs)) stack.enter_context( unittest.mock.patch.object(tools.setup_helpers.cmake, "USE_NINJA", use_ninja)) stack.enter_context( unittest.mock.patch.object(tools.setup_helpers.cmake, "IS_WINDOWS", is_windows)) cmake = tools.setup_helpers.cmake.CMake() with unittest.mock.patch.object(cmake, "run") as cmake_run: cmake.build({}) cmake_run.assert_called_once() (call, ) = cmake_run.mock_calls build_args, _ = call.args if want is None: self.assertNotIn("-j", build_args) else: self.assert_contains_sequence(build_args, want)
def test_get_info(self, addrinfo_path: unittest.mock.MagicMock) -> None: """ Tests the method which let us get the information to work with. """ def fake_hostbyaddr(*args, **kwargs): _ = args _ = kwargs return [ "www.example.org", ["example.org", "example.net"], ["10.55.39.20"] ] addrinfo_path.side_effect = fake_hostbyaddr given = "example.org" expected = { "hostname": "www.example.org", "aliases": ["example.org", "example.net"], "ips": ["10.55.39.20"], } actual = HostByAddrInfo(given).get_info() self.assertEqual(expected, actual)
async def test_run( self, mock_onedocker_svc: unittest.mock.MagicMock, mock_instance_repo: unittest.mock.MagicMock, mock_storage_svc: unittest.mock.MagicMock, mock_wait_for_containers_async: unittest.mock.MagicMock, ) -> None: async def _run_sub_test(wait_for_containers: bool, ) -> None: ip = "192.0.2.0" container = ContainerInstance( instance_id="123", ip_address=ip, status=ContainerInstanceStatus.STARTED) mock_onedocker_svc.start_containers = MagicMock( return_value=[container]) mock_onedocker_svc.wait_for_pending_containers = AsyncMock( return_value=[container]) container.status = (ContainerInstanceStatus.COMPLETED if wait_for_containers else ContainerInstanceStatus.STARTED) mock_wait_for_containers_async.return_value = [container] stage = PIDPrepareStage( stage=UnionPIDStage.PUBLISHER_PREPARE, instance_repository=mock_instance_repo, storage_svc=mock_storage_svc, onedocker_svc=mock_onedocker_svc, onedocker_binary_config=MagicMock( task_definition="offline-task:1#container", tmp_directory="/tmp/", binary_version="latest", ), ) instance_id = "444" stage_input = PIDStageInput( input_paths=["in"], output_paths=["out"], num_shards=2, instance_id=instance_id, ) # Basic test: All good with patch.object(PIDPrepareStage, "files_exist") as mock_fe: mock_fe.return_value = True stage = PIDPrepareStage( stage=UnionPIDStage.PUBLISHER_PREPARE, instance_repository=mock_instance_repo, storage_svc=mock_storage_svc, onedocker_svc=mock_onedocker_svc, onedocker_binary_config=MagicMock( task_definition="offline-task:1#container", tmp_directory="/tmp/", binary_version="latest", ), ) status = await stage.run( stage_input, wait_for_containers=wait_for_containers) self.assertEqual( PIDStageStatus.COMPLETED if wait_for_containers else PIDStageStatus.STARTED, status, ) self.assertEqual( mock_onedocker_svc.start_containers.call_count, 2) if wait_for_containers: self.assertEqual(mock_wait_for_containers_async.call_count, 2) else: mock_wait_for_containers_async.assert_not_called() mock_instance_repo.read.assert_called_with(instance_id) self.assertEqual(mock_instance_repo.read.call_count, 4) self.assertEqual(mock_instance_repo.update.call_count, 4) with patch.object(PIDPrepareStage, "files_exist") as mock_fe, patch.object( PIDPrepareStage, "prepare") as mock_prepare: mock_fe.return_value = True status = await stage.run( stage_input, wait_for_containers=wait_for_containers) mock_prepare.assert_called_with(instance_id, "in", "out", 2, wait_for_containers, None) # Input not ready with patch.object(PIDPrepareStage, "files_exist") as mock_fe: mock_fe.return_value = False status = await stage.run( stage_input, wait_for_containers=wait_for_containers) self.assertEqual(PIDStageStatus.FAILED, status) # Multiple input paths (invariant exception) with patch.object(PIDPrepareStage, "files_exist") as mock_fe: with self.assertRaises(ValueError): mock_fe.return_value = True stage_input.input_paths = ["in1", "in2"] stage = PIDPrepareStage( stage=UnionPIDStage.PUBLISHER_PREPARE, instance_repository=mock_instance_repo, storage_svc=mock_storage_svc, onedocker_svc=mock_onedocker_svc, onedocker_binary_config=MagicMock( task_definition="offline-task:1#container", tmp_directory="/tmp/", binary_version="latest", ), ) status = await stage.run( stage_input, wait_for_containers=wait_for_containers) for data_test in data_test_run(): wait_for_containers = data_test["wait_for_containers"] with self.subTest( "Subtest with wait_for_containers: {wait_for_containers}", wait_for_containers=wait_for_containers, ): # reset mocks for each subTests mock_onedocker_svc.reset_mock() mock_instance_repo.reset_mock() mock_storage_svc.reset_mock() mock_wait_for_containers_async.reset_mock() await _run_sub_test(wait_for_containers)