async def test_site_root_remove_domain_root(
self,
client: AsyncClient,
global_root_user: models.User,
global_domain_root_user: models.User,
global_domain_0: models.Domain,
) -> None:
url = app.url_path_for(
self.url_base,
domain=global_domain_0.url,
user=global_domain_root_user.id,
)
response = await do_api_request(client, "DELETE", url,
global_root_user)
assert response.status_code == 200
res = response.json()
assert res["errorCode"] == ErrorCode.Success
url = app.url_path_for(
TestDomainUserGet.url_base,
domain=global_domain_0.url,
user=global_domain_root_user.id,
)
response = await do_api_request(client, "GET", url, global_root_user)
assert response.status_code == 200
res = response.json()
assert res["errorCode"] == ErrorCode.DomainUserNotFoundError
async def test_list_records_no_filter(
self,
client: AsyncClient,
user: models.User,
global_domain_0: models.Domain,
record_0: models.Record,
record_1: models.Record,
record_2: models.Record,
) -> None:
url = app.url_path_for(self.url_base, domain=global_domain_0.url)
response = await do_api_request(client, "GET", url, user)
assert response.status_code == 200
res = response.json()
res = res["data"]
assert res["count"] == 3
assert len(res["results"]) == 3
assert (len(
list(filter(lambda x: x["id"] == str(record_0.id),
res["results"]))) == 1)
assert (len(
list(filter(lambda x: x["id"] == str(record_1.id),
res["results"]))) == 1)
assert (len(
list(filter(lambda x: x["id"] == str(record_2.id),
res["results"]))) == 1)
async def test_jwt(self, client: AsyncClient, user: models.User) -> None:
url = app.url_path_for("jwt_decoded")
response = await do_api_request(client, "GET", url, user)
assert response.status_code == 200
res = response.json()
assert "data" in res
res_jwt_dict = res["data"]
access_token = user_access_tokens[user.id]
header_jwt_dict = jwt.decode(
access_token,
key=settings.jwt_secret,
verify=False,
algorithms=[settings.jwt_algorithm],
)
for key in [
"sub",
"iat",
"nbf",
"exp",
"type",
"fresh",
"csrf",
"category",
"username",
"email",
"studentId",
"realName",
"role",
"oauthName",
"isActive",
]:
assert res_jwt_dict.get(key) == header_jwt_dict.get(key)
class TestDomainList:
url = app.url_path_for("list_domains")
async def list_domain_helper(self, client: AsyncClient, user: models.User,
ordering: str) -> Any:
response = await do_api_request(client, "GET", self.url, user,
{"ordering": ordering})
assert response.status_code == 200
res = response.json()
res = res["data"]
assert res["count"] == GLOBAL_DOMAIN_COUNT + 2
assert len(res["results"]) == GLOBAL_DOMAIN_COUNT + 2
return res
@pytest.mark.parametrize("user", [lazy_fixture("global_root_user")])
async def test_list_domain_asc(self, client: AsyncClient,
user: models.User) -> None:
await self.list_domain_helper(client, user, "updated_at")
@pytest.mark.parametrize("user", [lazy_fixture("global_root_user")])
async def test_list_domain_desc(self, client: AsyncClient,
user: models.User) -> None:
await self.list_domain_helper(client, user, "-updated_at")
@pytest.mark.parametrize("user", [lazy_fixture("global_root_user")])
async def test_list_domain_illegal_field(self, client: AsyncClient,
user: models.User) -> None:
response = await do_api_request(client, "GET", self.url, user,
{"ordering": "error_field"})
assert response.status_code == 200
res = response.json()
assert res["errorCode"] == ErrorCode.IllegalFieldError
async def test_version(self, client: AsyncClient,
user: models.User) -> None:
url = app.url_path_for("version")
response = await do_api_request(client, "GET", url, user)
assert response.status_code == 200
res = response.json()
assert res["version"] == get_version()
assert res["git"] == get_git_version()
async def test_delete(
self,
client: AsyncClient,
user: models.User,
domain: models.Domain,
) -> None:
url = app.url_path_for("delete_domain", domain=domain.url)
response = await do_api_request(client, "DELETE", url, user)
assert response.status_code == 200
res = response.json()
assert res["errorCode"] == ErrorCode.APINotImplementedError
async def validate_update(
self,
client: AsyncClient,
user: models.User,
domain: models.Domain,
data: Dict[str, str],
) -> None:
url = app.url_path_for(self.url_base, domain=domain.url)
response = await do_api_request(client, "PATCH", url, user, data=data)
domain.update_from_dict(data)
await validate_test_domain(response, user, domain)
async def test_domain_not_exist(
self,
client: AsyncClient,
user: models.User,
domain: models.Domain,
) -> None:
url = app.url_path_for(self.url_base, domain=domain.url + "_not_exist")
response = await do_api_request(client, "GET", url, user)
assert response.status_code == 200
res = response.json()
assert res["errorCode"] == ErrorCode.DomainNotFoundError
async def test_global_domains(
self,
client: AsyncClient,
user: models.User,
domain: models.Domain,
url_type: str,
) -> None:
domain_path = get_path_by_url_type(domain, url_type)
url = app.url_path_for(self.url_base, domain=domain_path)
response = await do_api_request(client, "GET", url, user)
await validate_test_domain(response, user, domain)
async def validate_update(self, client: AsyncClient, user: User,
data: Dict[str, str]) -> None:
url = app.url_path_for(self.url_base)
response = await do_api_request(
client,
"PATCH",
url,
user,
data=data,
)
user.update_from_dict(data)
validate_user_profile(response, user)
async def api_test_helper(
self,
client: AsyncClient,
user: models.User,
added_user: models.User,
domain: models.Domain,
role: str = "",
) -> Response:
data = {"user": str(added_user.id)}
if role:
data["role"] = role
url = app.url_path_for(self.url_base, domain=domain.url)
response = await do_api_request(client, "POST", url, user, data=data)
return response
async def test_url_duplicate(
self,
client: AsyncClient,
global_root_user: models.User,
global_domain_0: models.Domain,
global_domain_1: models.Domain,
) -> None:
data = {"url": global_domain_1.url}
url = app.url_path_for(self.url_base, domain=global_domain_0.url)
response = await do_api_request(client,
"PATCH",
url,
global_root_user,
data=data)
assert response.status_code == 200
res = response.json()
assert res["errorCode"] == ErrorCode.IntegrityError
async def api_test_helper(self, request: Any, client: AsyncClient,
domain: models.Domain, name: str) -> None:
task = self.tasks.get(name)
assert task
user, target_user, error_code = task
user_model: models.User = request.getfixturevalue(user)
target_user_model: models.User = request.getfixturevalue(target_user)
url = app.url_path_for(self.url_base, domain=domain.url)
data = {"target_user": str(target_user_model.id)}
response = await do_api_request(client,
"POST",
url,
user_model,
data=data)
if error_code == ErrorCode.Success:
domain.owner_id = target_user_model.id
await validate_test_domain(response, target_user_model, domain)
else:
assert response.status_code == 200
res = response.json()
assert res["errorCode"] == error_code
async def test_jwt_decoded_unauthorized(self, client: AsyncClient) -> None:
url = app.url_path_for("jwt_decoded")
response = await client.request(method="GET", url=url)
assert response.status_code == 401
res = response.json()
assert res["detail"] == "Unauthorized"
