def create_mongo_sink(topic, collection): data = { 'name': f'mongo-sink-{topic}', 'config': { 'connector.class': 'com.mongodb.kafka.connect.MongoSinkConnector', 'tasks.max': 1, 'topics': topic, 'connection.uri': mongo_url, 'database': mongo_db_name, 'collection': collection, 'key.converter': 'org.apache.kafka.connect.storage.StringConverter', 'value.converter': 'io.confluent.connect.json.JsonSchemaConverter', 'value.converter.schema.registry.url': schema_registry_url, 'value.converter.schemas.enable': True, 'errors.tolerance': 'all', 'errors.log.enable': 'true', 'errors.log.include.messages': 'true', 'errors.deadletterqueue.topic.name': f'dlq.mongo.{mongo_db_name}.{collection}', 'errors.deadletterqueue.context.headers.enable': 'true', 'errors.deadletterqueue.topic.replication.factor': 1, }, } httpx.delete(f'{kafka_connect_url}/connectors/mongo-sink-{topic}') res = httpx.post(f'{kafka_connect_url}/connectors', json=data) print(res.json()) res.raise_for_status()
async def api_delete_accounts(): admin_access_token = await api_access_token(admin_login_name, admin_password) admin_auth_header = api_auth_header(admin_access_token) for user in await api_get_users(): if user['role'] == 'admin': continue httpx.delete(api_url + '/accounts/' + user['account_id'], headers=admin_auth_header)
async def test_asset_bad_requests(async_client, batch_client, httpd): """""" _, logs = batch_client # Add a dataset, version, and default asset dataset = "test_bad_requests" version = "v1.1.1" _ = await create_default_asset(dataset, version, async_client=async_client, execute_batch_jobs=False) # Flush requests list so we're starting fresh httpx.delete(f"http://localhost:{httpd.server_port}") # Try adding a non-default raster tile set asset with an extra field "foo" asset_payload = { "asset_type": "Raster tile set", "is_managed": True, "foo": "foo", # The extra field "creation_options": { "data_type": "uint16", "pixel_meaning": "gfw_fid", "grid": "90/27008", "resampling": "nearest", "overwrite": True, "subset": "90N_000E", }, } create_asset_resp = await async_client.post( f"/dataset/{dataset}/{version}/assets", json=asset_payload) resp_json = create_asset_resp.json() assert resp_json["status"] == "failed" assert resp_json["message"] == [{ "loc": ["body", "foo"], "msg": "extra fields not permitted", "type": "value_error.extra", }] # Try adding a non-default raster tile set asset missing the # "creation_options" field (and toss the extra "foo" field from before) del asset_payload["foo"] del asset_payload["creation_options"] create_asset_resp = await async_client.post( f"/dataset/{dataset}/{version}/assets", json=asset_payload) resp_json = create_asset_resp.json() assert resp_json["status"] == "failed" assert resp_json["message"] == [{ "loc": ["body", "creation_options"], "msg": "field required", "type": "value_error.missing", }]
def delete_file( repo: Optional[str], package: Optional[str], version: Optional[str], filename: Optional[str], ): username, header = get_auth_header_and_username() if not username: return if not repo: repo = repositories.select_from_available_repo(subject=username) if not package: package = packages_core.select_from_available_packages( subject=username, repo=repo) if not version: version = select_from_available_versions(subject=username, repo=repo, package=package, filename=filename) if not filename: filename = select_from_available_files(subject=username, repo=repo, package=package, version=version) print_message(f"Deleting file {filename} version {version}") url = get_url(f"/{username}/{repo}/{package}/{version}/{filename}") password = typer.prompt("Password", hide_input=True) response = httpx.delete(url=url, auth=httpx.BasicAuth(username=username, password=password)) response_handler(response=response, return_model=FileDeleteResponseModel) return
def load_vocab(vocab: Path, guri): authdetails = None try: authdetails = (os.environ["DB_USERNAME"], os.environ["DB_PASSWORD"]) except: pass context = "{}/rdf4j-server/repositories/{}/statements?context=<{}>".format(RDF4JSERVER, REPO, quote_plus(guri)) r = httpx.delete( # "http://"+os.environ["VOCAB_HOST"] + "/rdf4j-server/repositories/ogc-na" , context, auth=authdetails ) # print ( r.status_code ) r = httpx.post( #"http://"+os.environ["VOCAB_HOST"] + "/rdf4j-server/repositories/ogc-na" , context, params={"graph": guri }, headers={"Content-Type": "application/x-turtle;charset=UTF-8"}, content=open(vocab, "rb").read(), auth= authdetails ) assert 200 <= r.status_code <= 300, "Status code was {}".format(r.status_code) # add_to_vocab_index(vocab, get_graph_uri_for_vocab(vocab)) return context
async def test_delete_a_skill_as_an_admin(): await api_delete_skills() admin_headers = await api_admin_auth_headers() r = api_create_skill('python', admin_headers) skill_id = r.json()['id'] r = httpx.delete(api_url + '/skills/' + skill_id, headers=admin_headers) assert r.status_code == 204
def test_rabbitmq_chained(self): # trigger queue create resp = httpx.post(MGMT + '/async/producers/chain2-on-demand', verify=False) resp.raise_for_status() resp = httpx.post(MGMT + '/async/producers/chain2-reactive', verify=False) resp.raise_for_status() # TODO: make it detect the moment when queues are created time.sleep(10) # wait for consumers to subscribe # clean the log resp = httpx.delete(MGMT + '/async/consumers/chain2-validating', verify=False) resp.raise_for_status() resp = httpx.post(MGMT + '/async/producers/chain2-on-demand', verify=False) resp.raise_for_status() for _ in range(30): resp = httpx.get(MGMT + '/async/consumers/chain2-validating', verify=False) resp.raise_for_status() msgs = resp.json()['log']['entries'] if not msgs: time.sleep(1) continue self.assertEqual(1, len(msgs)) break else: self.fail("Did not capture the message")
def delete_notification(*, client: Client, id: str) -> bool: url = "{}/v0b/notifications/{id}".format(client.base_url, id=id) response = httpx.delete(url=url, headers=client.get_headers()) if response.status_code == 204: return True raise ApiResponseError(code=response.status_code, detail=response.json())
def _test_traffic_log(self, root): self.test_urlencoded() # ensure httpx are there # clear log resp = httpx.delete(root + '/traffic-log', verify=False) json = self._valid_har(resp) self.assertFalse(json['log']['entries']) self.assertFalse(json['log']['_enabled']) # enable log resp = httpx.post(root + '/traffic-log', data={"enable": "true"}, verify=False) resp.raise_for_status() # check resp = httpx.get(root + '/traffic-log', verify=False) json = self._valid_har(resp) self.assertFalse(json['log']['entries']) self.assertTrue(json['log']['_enabled']) # make httpx self.test_multipart() # fetch log resp = httpx.get(root + '/traffic-log', verify=False) json = self._valid_har(resp) self.assertTrue(json['log']['entries']) # disable log resp = httpx.post(root + '/traffic-log', data={"enable": "false"}, verify=False) resp.raise_for_status() # clear resp = httpx.delete(root + '/traffic-log', verify=False) resp.raise_for_status() self.test_urlencoded() # ensure httpx are made # validate cleared resp = httpx.get(root + '/traffic-log', verify=False) json = self._valid_har(resp) self.assertFalse(json['log']['entries']) self.assertFalse(json['log']['_enabled'])
def test_create_deployment(): resp = httpx.post( f"{URL}/deployments/hdoupe/ccc-widget/", json={ "tag": "fix-iframe-link3", "deployment_name": "test" }, ) assert resp.status_code == 200, f"Got code: {resp.status_code} {resp.text}" now = datetime.now() max_wait = 120 success = False while (datetime.now() - now).seconds < max_wait: resp = httpx.get(f"{URL}/deployments/hdoupe/ccc-widget/test/") assert resp.status_code == 200, f"Got code: {resp.status_code} {resp.text}" data = resp.json() print(resp, data) if (data["deployment"]["ready"] and data["svc"]["ready"] and data["ingressroute"]["ready"]): print(data) success = True break time.sleep(1) if not success: raise Exception( f"Deployment not ready in less than {max_wait} seconds: {data}") server = Server( project=PROJECT, owner="hdoupe", title="ccc-widget", tag="fix-iframe-link3", model_config=ModelConfig(PROJECT, CS_URL), callable_name="dash", deployment_name="test", namespace="default", incluster=False, ) assert server.ready_stats() == data resp = httpx.delete(f"{URL}/deployments/hdoupe/ccc-widget/test/") assert resp.status_code == 200, f"Got code: {resp.status_code} {resp.text}" assert resp.json() == { "deployment": { "deleted": True }, "svc": { "deleted": True }, "ingressroute": { "deleted": True }, }
def delete(self, endpoint, status_code=200, **kwargs): if "auth" not in kwargs and self._authorized: kwargs.update(auth=self.creds) logger.info(f"Getting {endpoint}...") r = requests.delete(self.url + endpoint, **kwargs) logger.info("done") assert r.status_code == status_code, (r.status_code, status_code, r.text) return r
async def test_http_methods(client): async with respx.mock: url = "https://foo.bar" route = respx.get(url, path="/") % 404 respx.post(url, path="/").respond(200) respx.post(url, path="/").respond(201) respx.put(url, path="/").respond(202) respx.patch(url, path="/").respond(500) respx.delete(url, path="/").respond(204) respx.head(url, path="/").respond(405) respx.options(url, path="/").respond(status_code=501) respx.request("GET", url, path="/baz/").respond(status_code=204) url += "/" response = httpx.get(url) assert response.status_code == 404 response = await client.get(url) assert response.status_code == 404 response = httpx.get(url + "baz/") assert response.status_code == 204 response = await client.get(url + "baz/") assert response.status_code == 204 response = httpx.post(url) assert response.status_code == 201 response = await client.post(url) assert response.status_code == 201 response = httpx.put(url) assert response.status_code == 202 response = await client.put(url) assert response.status_code == 202 response = httpx.patch(url) assert response.status_code == 500 response = await client.patch(url) assert response.status_code == 500 response = httpx.delete(url) assert response.status_code == 204 response = await client.delete(url) assert response.status_code == 204 response = httpx.head(url) assert response.status_code == 405 response = await client.head(url) assert response.status_code == 405 response = httpx.options(url) assert response.status_code == 501 response = await client.options(url) assert response.status_code == 501 assert route.called is True assert respx.calls.call_count == 8 * 2
def delete_object_and_orgfuncs(uuid: str, mox_base: str, object_type: str, dry_run: bool = False): assert object_type in ("bruger", "organisationenhed") rel = "tilknyttedebrugere" if object_type == "bruger" else "tilknyttedeenheder" response = httpx.get( f"{mox_base}/organisation/organisationfunktion?{rel}={uuid}") response.raise_for_status() org_funcs = response.json()["results"][0] if dry_run: return org_funcs for org_func_uuid in org_funcs: r = httpx.delete( f"{mox_base}/organisation/organisationfunktion/{org_func_uuid}") r.raise_for_status() r = httpx.delete(f"{mox_base}/organisation/{object_type}/{uuid}") r.raise_for_status()
def delete_record(msgs): if msgs: option = int(input("choose the option: ")) if len(msgs) > 1 else 0 msg = msgs[option] if httpx.delete(f'{base_url}/{msg["id"]}', headers=headers).json()['success']: print('Deleted') logger.info(f'DELETED | {eval(req_msg)}') else: print(f'Record not found: {name}')
def test_fallback(self): resp = httpx.delete(SRV7 + '/sub/__admin/unhandled') resp.raise_for_status() resp = httpx.post(SRV7 + '/sub/__admin/unhandled', json=True) resp.raise_for_status() resp = httpx.get(SRV7 + '/') self.assertEqual(200, resp.status_code) self.assertEqual("no fallback", resp.text) resp = httpx.get( SRV7 + '/Changelog.html') # '/parameterized1/fallback/subval' self.assertEqual(200, resp.status_code) resp = httpx.get(SRV7 + '/img/logo.png') self.assertEqual(200, resp.status_code) self.assertEqual('image/png', resp.headers.get('content-type')) resp = httpx.get(SRV7 + '/not-exists') self.assertEqual(404, resp.status_code) resp = httpx.get(SRV7 + '/sub/__admin/unhandled') resp.raise_for_status() exp = { 'services': [{ 'endpoints': [{ 'method': 'GET', 'path': '/Changelog.html', 'response': { 'status': 200 } }, { 'method': 'GET', 'path': '/not-exists', 'response': { 'status': 404 } }], 'name': 'Service with fallback', 'port': 8007 }] } rdata = resp.json() endps = rdata['services'][0]['endpoints'] self.assertIn('<html', endps[0]['response'].pop('body')) endps[1]['response'].pop('body') endps[0]['response'].pop('headers') endps[1]['response'].pop('headers') self.assertEqual(exp, rdata) resp = httpx.post(SRV7 + '/sub/__admin/unhandled', json=False) resp.raise_for_status()
def test_resources_global(self): resp = httpx.get(MGMT + '/resources', verify=False) resp.raise_for_status() files = resp.json()['files'] logging.info("Files: %s", files) self.assertIn('subdir/empty_schema.json', files) self.assertIn('cors.html', files) self.assertIn('subdir/image.png', files) self.assertNotIn('/etc/hosts', files) self.assertEqual(len(files), len(set(files))) for file in files: # test that all files reported can be read and written resp = httpx.get(MGMT + '/resources?path=%s' % file, verify=False) resp.raise_for_status() resp = httpx.post(MGMT + '/resources', files={file: resp.content}, verify=False) resp.raise_for_status() resp = httpx.get(MGMT + '/resources?path=cors.html', verify=False) resp.raise_for_status() self.assertIn('<html ', resp.text) orig_content = resp.text resp = httpx.delete(MGMT + '/resources?path=cors.html', verify=False) resp.raise_for_status() with self.assertRaises(httpx.HTTPError): resp = httpx.get(MGMT + '/resources?path=cors.html', verify=False) resp.raise_for_status() marker = "<!-- %s -->" % time.time() resp = httpx.post(MGMT + '/resources', files={"cors.html": orig_content + marker}, verify=False) resp.raise_for_status() resp = httpx.get(MGMT + '/resources?path=cors.html', verify=False) resp.raise_for_status() self.assertTrue(resp.text.endswith(marker)) resp = httpx.post(MGMT + '/resources', files={"cors.html": orig_content}, verify=False) resp.raise_for_status() with self.assertRaises(httpx.HTTPError): resp = httpx.get(MGMT + '/resources?path=/etc/hosts', verify=False) resp.raise_for_status() with self.assertRaises(httpx.HTTPError): resp = httpx.get(MGMT + '/resources?path=__init__.py', verify=False) resp.raise_for_status()
def delete_repo(repo: Optional[str], is_operation_confirmed: Optional[bool] = False): username, headers = get_auth_header_and_username() if not username: return if not repo: repo = select_from_available_repo(subject=username) if not is_operation_confirmed and not is_operation_confirm(): return url: str = get_url(f"/repo/{username}/{repo}") response = httpx.delete(url=url, headers=headers) return response_handler(response, RepoDeleteResponseModel)
def DeleteRole(RoleID: str): r = httpx.delete( 'https://discord.com/api/{}/guilds/{}/roles/{}'.format(api, guild, RoleID), proxies=getProxyDict(), headers=headers ) if r.status_code in [200, 201, 204]: util.log('[!]', 'Deleted {}{}'.format(Fore.LIGHTCYAN_EX, RoleID)) elif r.status_code == 429: util.log('[!]', 'Ratelimited for {}{}'.format(Fore.LIGHTCYAN_EX, r.json()['retry_after'])) DeleteChannel(ChannelID) return(True)
def update_labels(github_event_data: dict, release_info: typing.Optional[ReleaseInfo]): labels_to_add = {"bot:has-release-file"} labels_to_remove: typing.Set[str] = set() new_release_label = None if release_info is None: labels_to_remove = labels_to_add labels_to_add = set() else: new_release_label = f"bot:release-type-{release_info.change_type.value}" labels_to_add.add(new_release_label) labels_url = get_labels_link(github_event_data) current_labels_url_by_name = { label["name"]: label["url"] for label in github_event_data["pull_request"]["labels"] } current_labels = set(current_labels_url_by_name.keys()) release_labels_to_remove = [ label for label in current_labels if label.startswith("bot:release-type-") and label != new_release_label ] labels_to_remove.update(release_labels_to_remove) print("current_labels", current_labels, "labels_to_remove", labels_to_remove) if not current_labels.issuperset(labels_to_add): request = httpx.post( labels_url, headers={"Authorization": f"token {GITHUB_TOKEN}"}, json={"labels": list(labels_to_add)}, ) if request.status_code >= 400: print(request.text) print(request.status_code) if current_labels.issuperset(labels_to_remove): for label in labels_to_remove: request = httpx.delete( current_labels_url_by_name[label], headers={"Authorization": f"token {GITHUB_TOKEN}"}, ) if request.status_code >= 400: print(request.text) print(request.status_code)
def sync_detailed( *, client: Client, conn_id: str, ) -> Response[ConnectionModuleResponse]: kwargs = _get_kwargs( client=client, conn_id=conn_id, ) response = httpx.delete(**kwargs, ) return _build_response(response=response)
def delete_device( mac_address: str, is_operation_confirmed: bool = False, ) -> None: username, header = get_auth_header_and_username() if not username: return if not is_operation_confirmed and not is_operation_confirm(): return url = get_url(f"/devices/{mac_address}") response = httpx.delete(url=url, headers=header) response_handler(response=response, return_model=DeviceDeleteResponseModel)
def sync_detailed( *, client: Client, name: str, ) -> Response[Union[ApiResponse, None]]: kwargs = _get_kwargs( client=client, name=name, ) response = httpx.delete(**kwargs, ) return _build_response(response=response)
def sync_detailed( *, client: AuthenticatedClient, name: str, ) -> Response[Union[None, ErrorMessage, ErrorMessage, HTTPValidationError]]: kwargs = _get_kwargs( client=client, name=name, ) response = httpx.delete(**kwargs, ) return _build_response(response=response)
def sync_detailed( *, client: AuthenticatedClient, id: int, ) -> Response[None]: kwargs = _get_kwargs( client=client, id=id, ) response = httpx.delete(**kwargs, ) return _build_response(response=response)
def delete(self, payload: typing.Any = None, endpoint: str = "") -> httpx.Response: r = httpx.delete( url=f"{self.url}{endpoint}", auth=self.auth, params=payload, timeout=self.timeout, ) if self.debug: print(f"DELETE {r.url}") print(json.dumps(r.json(), indent=4, sort_keys=True)) if r.is_error: r.raise_for_status() return r
async def test_http_methods(client): async with respx.HTTPXMock() as httpx_mock: url = "https://foo.bar/" m = httpx_mock.get(url, status_code=404) httpx_mock.post(url, status_code=201) httpx_mock.put(url, status_code=202) httpx_mock.patch(url, status_code=500) httpx_mock.delete(url, status_code=204) httpx_mock.head(url, status_code=405) httpx_mock.options(url, status_code=501) response = httpx.get(url) assert response.status_code == 404 response = await client.get(url) assert response.status_code == 404 response = httpx.post(url) assert response.status_code == 201 response = await client.post(url) assert response.status_code == 201 response = httpx.put(url) assert response.status_code == 202 response = await client.put(url) assert response.status_code == 202 response = httpx.patch(url) assert response.status_code == 500 response = await client.patch(url) assert response.status_code == 500 response = httpx.delete(url) assert response.status_code == 204 response = await client.delete(url) assert response.status_code == 204 response = httpx.head(url) assert response.status_code == 405 response = await client.head(url) assert response.status_code == 405 response = httpx.options(url) assert response.status_code == 501 response = await client.options(url) assert response.status_code == 501 assert m.called is True assert httpx_mock.stats.call_count == 7 * 2
def terminate_filtered_employees(dry_run): settings = load_settings() filter_ids = settings.get("integrations.opus.units.filter_ids", []) mox_base = settings.get("mox.base", "localhost:8080") latest_date, opus_dump = opus_helpers.get_latest_dump() file_diffs = opus_helpers.file_diff(None, opus_dump) # Get every id of filtered units all_ids = opus_helpers.find_all_filtered_ids(opus_dump, filter_ids) # find all engagements to a filtered unit in latest opus-file filtered_employees = list( filter(lambda emp: emp.get("orgUnit") in all_ids, file_diffs["employees"])) diff = OpusDiffImport(latest_date, ad_reader=None, employee_mapping={}) # Check if any engagements exist that should have been filtered eng_info = [ diff._find_engagement(e["@id"], "Engagement", present=False) for e in filtered_employees ] eng_info = list(filter(lambda x: x is not None, eng_info)) if dry_run: print( f"There are {len(eng_info)} engagements that should have been terminated." ) return eng_info for eng_uuid in tqdm(eng_info, desc="Deleting filtered engagements"): r = httpx.delete( f"{mox_base}/organisation/organisationfunktion/{eng_uuid}") r.raise_for_status() # Check users in MO - if no engagements are left then delete the user and all details to it. user_cprs = set(map(opus_helpers.read_cpr, filtered_employees)) users = [diff.helper.read_user(user_cpr=cpr) for cpr in user_cprs] users = filter(lambda x: x, users) user_uuids = set(map(itemgetter("uuid"), users)) user_engagements = { user_uuid: diff.helper.read_user_engagements(user_uuid, read_all=True) for user_uuid in user_uuids } delete_users = dict(filter(lambda x: x[1] == [], user_engagements.items())) for user_uuid in tqdm(delete_users, desc="Deleting users with no other engagements"): delete_object_and_orgfuncs(uuid=user_uuid, mox_base=mox_base, object_type="bruger", dry_run=dry_run)
def DeleteChannel(ChannelID: str) -> bool: try: r = httpx.delete( 'https://discord.com/api/{}/channels/{}'.format(api, ChannelID), #proxies=getProxyDict(), headers=headers ) if r.status_code in [200, 201, 204]: util.log('[!]', 'Deleted {}{}'.format(Fore.LIGHTCYAN_EX, ChannelID)) elif r.status_code == 429: util.log('[!]', 'Ratelimited for {}{}'.format(Fore.LIGHTCYAN_EX, r.json()['retry_after'])) NukeFunctions.DeleteChannel(ChannelID) return(True) except: return(NukeFunctions.DeleteChannel(ChannelID))
async def remove_schema_by_id(schema_id: str) -> None: """Remove schema from trust registry by id Args: actor_id (str): identifier of the schema to remove Raises: TrustRegistryException: If an error occurred while removing the schema """ remove_response = httpx.delete( f"{TRUST_REGISTRY_URL}/registry/schemas/{schema_id}") if remove_response.is_error: raise TrustRegistryException( f"Error removing schema from trust registry: {remove_response.text}", remove_response.status_code, )
def stop_run( *, client: "AuthenticatedClient", auto_test_id: "int", run_id: "int", extra_parameters: Mapping[str, str] = None, ) -> Union[None, ]: """Delete an AutoTest run, this makes it possible to edit the AutoTest. This also clears the rubric categories filled in by the AutoTest.""" url = "{}/api/v1/auto_tests/{autoTestId}/runs/{runId}".format( client.base_url, autoTestId=auto_test_id, runId=run_id) headers: Dict[str, Any] = client.get_headers() params: Dict[str, Any] = { "no_course_in_assignment": "true", "no_role_name": "true", "no_assignment_in_case": "true", "extended": "true", } if extra_parameters: params.update(extra_parameters) response = httpx.delete( url=url, headers=headers, params=params, ) if response_code_matches(response.status_code, 204): return None if response_code_matches(response.status_code, 400): raise BaseError.from_dict(cast(Dict[str, Any], response.json())) if response_code_matches(response.status_code, 409): raise BaseError.from_dict(cast(Dict[str, Any], response.json())) if response_code_matches(response.status_code, 401): raise BaseError.from_dict(cast(Dict[str, Any], response.json())) if response_code_matches(response.status_code, 403): raise BaseError.from_dict(cast(Dict[str, Any], response.json())) if response_code_matches(response.status_code, "5XX"): raise BaseError.from_dict(cast(Dict[str, Any], response.json())) else: raise ApiResponseError(response=response)