def test_olx_service_request_error():
category = "cars"
service = Olx(category=category)
url = f"https://www.olx.com.br/{CATEGORIES[category]['category']}"
route = respx.get(url)
route.return_value = Response(500)
with pytest.raises(OlxRequestError):
service.fetch_all()
def _report_device(update, _res: Response):
key, item = update
if _res.is_error:
print(f"FAIL: create device {item['hostname']}: {_res.text}")
return
print(f"CREATE:OK: device {item['hostname']} ... creating primary IP ... ")
nb_col.source_records.append(_res.json())
def _parse_response(
*,
response: httpx.Response) -> Optional[PaginatedDockerImageBuildList]:
if response.status_code == 200:
response_200 = PaginatedDockerImageBuildList.from_dict(response.json())
return response_200
return None
async def send(
self,
request: Request,
verify: VerifyTypes = None,
cert: CertTypes = None,
timeout: TimeoutTypes = None,
) -> Response:
if request.url.path.startswith("/echo_cookies"):
body = json.dumps({
"cookies": request.headers.get("Cookie")
}).encode()
return Response(200, content=body, request=request)
elif request.url.path.startswith("/set_cookie"):
headers = {"set-cookie": "example-name=example-value"}
return Response(200, headers=headers, request=request)
else:
raise NotImplementedError # pragma: no cover
def _parse_response(
*, response: httpx.Response
) -> Optional[Union[List[AModel], HTTPValidationError]]:
if response.status_code == 200:
response_200 = []
_response_200 = response.json()
for response_200_item_data in _response_200:
response_200_item = AModel.from_dict(response_200_item_data)
response_200.append(response_200_item)
return response_200
if response.status_code == 422:
response_422 = HTTPValidationError.from_dict(response.json())
return response_422
return None
def __validate_response(
self, response: Response
) -> Result[JsonResponse, DataProviderFailureDetails]:
http_status = HttpStatus(response.status_code)
if http_status in [HttpStatus.OK, HttpStatus.CREATED]:
return Success(response.json())
return Failure(
DataProviderFailureDetails(
dataprovider_type="REST",
reason=http_status.name,
attributes={
"origin": "HTTP_STATUS",
"http_status_code": http_status.value,
"response": response.json(),
},
)
)
async def test_get_name(weibo):
profile_router = respx.get(
"https://m.weibo.cn/api/container/getIndex?containerid=1005056279793937"
)
profile_router.mock(
return_value=Response(200, json=get_json("weibo_ak_profile.json")))
name = await weibo.get_target_name("6279793937")
assert name == "明日方舟Arknights"
async def test_parse_long(weibo):
detail_router = respx.get("https://m.weibo.cn/detail/4645748019299849")
detail_router.mock(return_value=Response(
200, text=get_file("weibo_detail_4645748019299849")))
raw_post = get_json("weibo_ak_list_1.json")["data"]["cards"][0]
post = await weibo.parse(raw_post)
assert not "全文" in post.text
assert detail_router.called
async def test_persistence_get_all():
respx.get(PERSISTENCE_URL + ENTRY).mock(
return_value=Response(200, text=allSkillData)
)
service = PersistenceService(PERSISTENCE_URL)
result = await service.get_all()
assert result == {"data": {"attrs": {"attr1": "value1", "attr2": "value2"}}}
def _parse_response(
*,
response: httpx.Response) -> Optional[TestInlineObjectsResponse_200]:
if response.status_code == 200:
response_200 = TestInlineObjectsResponse_200.from_dict(response.json())
return response_200
return None
async def test_persistence_get_not_authorized():
respx.get(PERSISTENCE_URL + DATA).mock(
return_value=Response(401, text="Not Authorized")
)
service = PersistenceService(PERSISTENCE_URL)
with pytest.raises(HTTPError):
await service.get()
async def test_persistence_get_invalid_data():
respx.get(PERSISTENCE_URL + DATA).mock(
return_value=Response(200, text=skillData[:50])
)
service = PersistenceService(PERSISTENCE_URL)
with pytest.raises(json.JSONDecodeError):
await service.get()
async def test_persistence_set():
respx.post(PERSISTENCE_URL + ENTRY).mock(
return_value=Response(200, text=setResponse)
)
service = PersistenceService(PERSISTENCE_URL)
result = await service.set(json.loads(skillData))
assert result.json() == json.loads(setResponse)
def _raise_error(response: httpx.Response,
expected_codes: Optional[Set[int]] = None):
"""
Handle raising of errors based on response from LE. If the error code is an expected
code, then pass on the error code as is and retrieve the message from LE. If the
error was unexpected send a 502 with raw upstreamError.
"""
error_details = {"upstreamError": response.text}
status_code = 502
try:
if expected_codes and response.status_code in expected_codes:
error_details = response.json().get("error", {}).get("message")
status_code = response.status_code
else:
error_details = {"upstreamError": response.json()}
finally:
raise HTTPException(status_code=status_code, detail=error_details)
def app(request):
content = json.dumps({
"method": request.method,
"path": request.url.path,
"body": request.content.decode(),
}).encode()
headers = {"Content-Length": str(len(content))}
return Response(200, headers=headers, content=content)
def fake_send(request: Request):
nonlocal requests
requests.append(request)
return Response(
200,
content='{"success": true, "message": "OK"}'.encode("ascii"),
request=request,
)
async def test_send_defer_message_failed(dispike_object: Dispike, ):
route = respx.patch(
"https://discord.com/api/v8/webhooks/APPID/FAKETOKEN/messages/@original",
).mock(return_value=Response(500, ), )
_sample_interaction = IncomingDiscordSlashInteraction(
**{
"channel_id": "123123",
"data": {
"id": "12312312",
"name": "sample",
"options": [{
"name": "message",
"value": "test"
}],
},
"guild_id": "123123",
"id": "123123123132",
"member": {
"deaf":
False,
"is_pending":
False,
"joined_at":
"2019-05-12T18:36:16.878000+00:00",
"mute":
False,
"nick":
None,
"pending":
False,
"permissions":
"2147483647",
"premium_since":
None,
"roles": [
"123123",
"123123",
"1231233",
"1231233133",
"12412412414",
],
"user": {
"avatar": "b723979992a56",
"discriminator": "3333",
"id": "234234213122123",
"public_flags": 768,
"username": "******",
},
},
"token": "FAKETOKEN",
"type": 2,
"version": 1,
})
with pytest.raises(httpx.HTTPError):
await dispike_object.send_deferred_message(
original_context=_sample_interaction,
new_message=DiscordResponse(content="working"),
)
async def test_add_with_target_no_cat(app: App):
from nonebot.adapters.onebot.v11.event import Sender
from nonebot.adapters.onebot.v11.message import Message
from nonebot_bison.config import Config
from nonebot_bison.config_manager import add_sub_matcher, common_platform
from nonebot_bison.platform import platform_manager
from nonebot_bison.platform.ncm_artist import NcmArtist
config = Config()
config.user_target.truncate()
ncm_router = respx.get("https://music.163.com/api/artist/albums/32540734")
ncm_router.mock(return_value=Response(200, json=get_json("ncm_siren.json")))
async with app.test_matcher(add_sub_matcher) as ctx:
bot = ctx.create_bot()
event_1 = fake_group_message_event(
message=Message("添加订阅"),
sender=Sender(card="", nickname="test", role="admin"),
to_me=True,
)
ctx.receive_event(bot, event_1)
ctx.should_pass_rule()
ctx.should_call_send(
event_1,
Message(BotReply.add_reply_on_platform(platform_manager, common_platform)),
True,
)
event_3 = fake_group_message_event(
message=Message("ncm-artist"), sender=fake_admin_user
)
ctx.receive_event(bot, event_3)
ctx.should_call_send(
event_3,
Message(BotReply.add_reply_on_id(NcmArtist)),
True,
)
event_4_ok = fake_group_message_event(
message=Message("32540734"), sender=fake_admin_user
)
ctx.receive_event(bot, event_4_ok)
ctx.should_call_send(
event_4_ok,
BotReply.add_reply_on_target_confirm("ncm-artist", "塞壬唱片-MSR", "32540734"),
True,
)
ctx.should_call_send(
event_4_ok, BotReply.add_reply_subscribe_success("塞壬唱片-MSR"), True
)
ctx.should_finished()
subs = config.list_subscribe(10000, "group")
assert len(subs) == 1
sub = subs[0]
assert sub["target"] == "32540734"
assert sub["tags"] == []
assert sub["cats"] == []
assert sub["target_type"] == "ncm-artist"
assert sub["target_name"] == "塞壬唱片-MSR"
def load_results(self, response: Response) -> "Page":
results = response.json(parse_float=Decimal)
self.results = []
self.results = [self.type().json(r) for r in results.get(self.key)]
self.page = results.get("page", 0)
self.pages = results.get("pages", 0)
self.total = results.get("total", 0)
self._index = 0
return self
async def test_error(self):
respx.get(re.compile(f"^{PROFILE_ENDPOINT}")).mock(
Response(400, json={"error": "message"}))
with pytest.raises(GetIdEmailError) as excinfo:
await client.get_id_email("TOKEN")
assert type(excinfo.value.args[0]) == dict
assert excinfo.value.args[0] == {"error": "message"}
async def test_url(
self,
resp: httpx.Response,
data: Dict[str, Any],
query: Dict[str, Any], # pylint: disable=unused-argument
):
"""Test for a successful Tesla URL.
https://tesla-api.timdorr.com/api-basics/authentication#step-2-obtain-an-authorization-code
Args:
resp (httpx.Response): The httpx response.
data (Dict[str, Any]): Dictionary of all post data captured through proxy with overwrites for duplicate keys.
query (Dict[str, Any]): Dictionary of all query data with overwrites for duplicate keys.
Returns
Optional[Union[URL, str]]: URL for a http 302 redirect or str to display on success. None indicates test did not pass.
"""
code: str = ""
if resp.url.path == "/void/callback":
code = resp.url.query.get("code")
if resp.url.path == "/static/404.html":
code = URL(str(resp.history[-1].url)).query.get("code")
if code:
username = data.get("identity")
self._callback_url = self.init_query.get("callback_url")
self.waf_retry = 0
_LOGGER.debug("Success! Oauth code %s for %s captured.", code,
username)
await self.session.aclose()
# 302 redirect
return URL(self._callback_url).update_query({
"code":
code,
"username":
username,
"domain":
self._host_url.host
})
if get_content_type(resp) == "text/html":
text = resp.text
if "<noscript>Please enable JavaScript to view the page content." in text:
_LOGGER.debug("WAF discovered %s times in a row.",
self.waf_retry)
self.waf_retry += 1
return return_timer_countdown_refresh_html(
max(30 * (self.waf_retry - self.waf_limit), 120)
if self.waf_retry > self.waf_limit else
random.random() * self.waf_retry + 10,
f"Detected Tesla web application firewall block #{self.waf_retry}. Please wait and then reload the page or wait for the auto reload.",
False,
)
self.waf_retry = 0
if get_content_type(resp) == "application/json":
text = resp.json()
_LOGGER.debug("Json response: %s", text)
def test_get_workspace_handles_error_responses(client: StructurizrClient,
mocker: MockerFixture):
"""Test that response code other than 200 raise an exception."""
mocker.patch.object(client._client, "send", return_value=Response(403))
with pytest.raises(
StructurizrClientException,
match="Failed .* workspace 19.\nResponse 403 - Forbidden",
):
client.get_workspace()
async def test_delete(self):
"""Should delete provisioning profile via API."""
rsps = respx.delete(f'{PROVISIONING_API_URL}/users/current/provisioning-profiles/id') \
.mock(return_value=Response(200))
await provisioning_client.delete_provisioning_profile('id')
assert rsps.calls[0].request.url == \
f'{PROVISIONING_API_URL}/users/current/provisioning-profiles/id'
assert rsps.calls[0].request.headers[
'auth-token'] == 'header.payload.sign'
def send(
self,
request: Request,
verify: VerifyTypes = None,
cert: CertTypes = None,
timeout: TimeoutTypes = None,
) -> Response:
if request.url.path == "/streaming_response":
return Response(200, content=streaming_body(), request=request)
elif request.url.path == "/echo_request_body":
content = request.read()
return Response(200, content=content, request=request)
elif request.url.path == "/echo_request_body_streaming":
content = b"".join([part for part in request.stream()])
return Response(200, content=content, request=request)
else:
body = json.dumps({"hello": "world"}).encode()
return Response(200, content=body, request=request)
async def app(request):
method = request.method
path = request.url.path
body = b"".join([part async for part in request.stream])
content = json.dumps(
{"method": method, "path": path, "body": body.decode()}
).encode()
headers = {"Content-Length": str(len(content))}
return Response(200, headers=headers, content=content, request=request)
def send(
self,
request: Request,
verify: VerifyTypes = None,
cert: CertTypes = None,
timeout: TimeoutTypes = None,
http_versions: HTTPVersionTypes = None,
) -> Response:
return Response(200, content=request.read())
def __handle_response(self, response: httpx.Response) -> None:
"""Handles the response."""
try:
self.__output = json.dumps(response.json(),
indent=2,
sort_keys=False,
ensure_ascii=False)
except TypeError:
self.__output = response.text
def test_raising_decode_error(client, token_method, mock_http_client):
response = Response(status_code=418, text="Wrong json")
mock_http_client.request.return_value = response
client.bot.sync_client.http_client = mock_http_client
botx_request = client.bot.sync_client.build_request(token_method)
with pytest.raises(BotXJSONDecodeError):
client.bot.sync_client.execute(botx_request)
def __init__(self, action: str, service_response: Response) -> None:
try:
error_data = service_response.json()
except LookupError:
error_data = service_response.text
self.detail = (f"Can't {action}. Getter respond: {error_data}"
f" (status code: {service_response.status_code})")
self.response = service_response
self.status_code = 400
def get_item_list(response: Response, response_type: str,
endpoint: str) -> set[int]:
item_type = endpoint.split("/")[1]
if response_type == "raw":
if item_type in RAW_MAIN_ITEM:
main_item = RAW_MAIN_ITEM[item_type]
else:
raise ValueError
return {item[main_item]["id"] for item in response.json()}
else:
if item_type in ("servant", "equip", "buff", "svt", "skill", "NP",
"item"):
id_name = "id"
elif item_type == "function":
id_name = "funcId"
else:
raise ValueError
return {item[id_name] for item in response.json()}
