async def test_create_post(client: AsyncClient, admin: Mapping) -> None:
published_at = datetime.now(timezone.utc) + timedelta(minutes=1)
new_post = CreatePost(
title='Ещё одна заметка',
text={
"time": 1605425931108,
"blocks": [{
"type": "paragraph",
"data": {
"text": "test"
}
}],
"version": "2.19.0",
},
slug='new-test-post',
published_at=published_at,
)
response = await client.post(
'/posts/',
content=new_post.json(),
headers=create_auth_header(admin['username']),
)
assert response.status_code == status.HTTP_200_OK
assert Post.validate(response.json())
async def test_get_current_user(client: AsyncClient, admin: Mapping) -> None:
response = await client.get(
'/users/me',
headers=create_auth_header(admin['username']),
)
assert response.status_code == status.HTTP_200_OK
assert MyUser.validate(response.json())
async def test_delete_channel(
client: AsyncClient,
channel_to_be_deleted: typing.Mapping,
admin: typing.Mapping,
) -> None:
auth_headers = create_auth_header(admin['username'])
response = await client.delete(
f'/channels/{channel_to_be_deleted["slug"]}', headers=auth_headers)
assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_delete_post(
client: AsyncClient,
posts: List[Mapping],
admin: dict,
) -> None:
response = await client.delete(
f'/posts/{posts[0]["slug"]}',
headers=create_auth_header(admin['username']),
)
assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_delete_channel_by_user(
client: AsyncClient,
channel_to_be_deleted: typing.Mapping,
user: typing.Mapping,
) -> None:
auth_headers = create_auth_header(user['username'])
response = await client.delete(
f'/channels/{channel_to_be_deleted["slug"]}',
headers=auth_headers,
)
assert response.status_code == status.HTTP_403_FORBIDDEN
async def test_patch_group(
client: AsyncClient,
dj: Mapping,
group: Mapping,
admin: Mapping,
) -> None:
"""
Изменение членов группы
:param client:
:param dj:
:param group:
:param admin:
:return:
"""
auth_headers = create_auth_header(admin['username'])
response = await client.patch(
f'/djs/{group["slug"]}',
headers=auth_headers,
json={'is_group': False},
)
data = response.json()
assert response.status_code == status.HTTP_200_OK
assert data['group_members'] == []
assert not data['is_group']
assert not await dj_crud.get_groups_members([group['id']])
new_data = {'is_group': True, 'group_members': [dj['id']]}
response = await client.patch(
f'/djs/{group["slug"]}',
headers=auth_headers,
json=new_data,
)
data = response.json()
assert response.status_code == status.HTTP_200_OK
assert data['group_members'] == [dj['slug']]
assert data['is_group']
assert await dj_crud.get_groups_members([group['id']])
new_data = {'group_members': []}
response = await client.patch(
f'/djs/{group["slug"]}',
headers=auth_headers,
json=new_data,
)
data = response.json()
assert response.status_code == status.HTTP_200_OK
assert not data['group_members']
assert data['is_group']
assert not await dj_crud.get_groups_members([group['id']])
async def test_remove_livestream(
client: AsyncClient,
livestream: Mapping,
admin: Mapping,
) -> None:
headers = create_auth_header(admin['username'])
response = await client.delete(
f'/livestreams/{livestream["id"]}:{livestream["slug"]}',
headers=headers,
)
assert response.status_code == status.HTTP_204_NO_CONTENT
assert not await livestream_crud.find_one(livestream['id'])
async def test_change_password(client: AsyncClient, admin: Mapping) -> None:
data = {
'new_password': {
'password': '******',
'password_confirm': 'newpassword',
},
'old_password': '******',
}
response = await client.put(
'/users/password',
headers=create_auth_header(admin['username']),
json=data,
)
assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_prohibit_delete(client: AsyncClient, user: Mapping,
dj: Mapping) -> None:
"""
Запрет удаления DJ
:param client:
:param user:
:param dj:
:return:
"""
headers = create_auth_header(user['username'])
user_response = await client.delete(f'/djs/{dj["slug"]}', headers=headers)
guest_response = await client.delete(f'/djs/{dj["slug"]}')
assert user_response.status_code == status.HTTP_403_FORBIDDEN
assert guest_response.status_code == status.HTTP_401_UNAUTHORIZED
assert await dj_crud.find(id_=dj['id'])
async def test_create_livestream(
client: AsyncClient,
livestream_data: dict,
admin: Mapping,
) -> None:
headers = create_auth_header(admin['username'])
response = await client.post(
'/livestreams',
json=livestream_data,
headers=headers,
)
assert response.status_code == status.HTTP_201_CREATED
data = response.json()
assert LiveStream.validate(data)
assert await livestream_crud.find_one(data['id'])
async def test_delete(
client: AsyncClient,
admin: Mapping,
dj: Mapping,
) -> None:
"""
Удаление DJ
:param client:
:param admin:
:param dj:
:return:
"""
headers = create_auth_header(admin['username'])
response = await client.delete(f'/djs/{dj["slug"]}', headers=headers)
assert response.status_code == status.HTTP_204_NO_CONTENT
assert await dj_crud.find(id_=dj['id']) is None
async def test_prohibit_adding_by_user(
client: AsyncClient,
dj_data: dict,
user: Mapping,
) -> None:
"""
Запрет создания DJ пользователям
:param client:
:param dj_data:
:param user:
:return:
"""
auth_headers = create_auth_header(user['username'])
response = await client.post('/djs', json=dj_data, headers=auth_headers)
assert response.status_code == status.HTTP_403_FORBIDDEN
assert await dj_crud.find(name=dj_data['name']) is None
async def test_delete_group(
client: AsyncClient,
admin: Mapping,
group: Mapping,
) -> None:
"""
Удаление группы
:param client:
:param admin:
:param group:
:return:
"""
headers = create_auth_header(admin['username'])
response = await client.delete(f'/djs/{group["slug"]}', headers=headers)
group_members = await dj_crud.get_groups_members(ids=[group['id']])
assert response.status_code == status.HTTP_204_NO_CONTENT
assert await dj_crud.find(id_=group['id']) is None
assert not len(group_members)
async def test_removal_without_privileges(
client: AsyncClient,
livestream: Mapping,
user: Mapping,
) -> None:
response = await client.delete(
f'/livestreams/{livestream["id"]}:{livestream["slug"]}',
)
assert response.status_code == status.HTTP_401_UNAUTHORIZED
assert await livestream_crud.find_one(livestream['id'])
headers = create_auth_header(user['username'])
response = await client.delete(
f'/livestreams/{livestream["id"]}:{livestream["slug"]}',
headers=headers,
)
assert response.status_code == status.HTTP_403_FORBIDDEN
assert await livestream_crud.find_one(livestream['id'])
async def test_create_dj(
client: AsyncClient,
dj_data: dict,
admin: Mapping,
) -> None:
"""
Создание пользователя
:param client:
:param dj_data:
:param admin:
:return:
"""
auth_headers = create_auth_header(admin['username'])
response = await client.post('/djs', json=dj_data, headers=auth_headers)
data = response.json()
assert response.status_code == status.HTTP_201_CREATED
assert await dj_crud.find(data['id'])
assert DJ.validate(data)
for k, v in dj_data.items():
assert data[k] == v
async def test_create_group(
client: AsyncClient,
group_data: dict,
admin: Mapping,
dj: Mapping,
) -> None:
"""
Создание группы
:param client:
:param group_data:
:param admin:
:return:
"""
auth_headers = create_auth_header(admin['username'])
response = await client.post('/djs', json=group_data, headers=auth_headers)
data = response.json()
assert response.status_code == status.HTTP_201_CREATED
assert await dj_crud.find(data['id'])
assert DJ.validate(data)
assert data['is_group']
assert data['group_members']
async def test_disallow_creation_livestream_without_privileges(
client: AsyncClient,
livestream_data: dict,
user: Mapping,
) -> None:
headers = create_auth_header(user['username'])
response = await client.post(
'/livestreams',
json=livestream_data,
headers=headers,
)
assert response.status_code == status.HTTP_403_FORBIDDEN
assert not await livestream_crud.find_one(title=livestream_data['title'])
response = await client.post(
'/livestreams',
json=livestream_data,
)
assert response.status_code == status.HTTP_401_UNAUTHORIZED
assert not await livestream_crud.find_one(title=livestream_data['title'])
async def test_update_livestream(
client: AsyncClient,
livestream: Mapping,
admin: Mapping,
) -> None:
headers = create_auth_header(admin['username'])
stream = dict(livestream)
stream['title'] = 'Новое название'
stream['start_time'] = stream['start_time'].isoformat()
stream['end_time'] = None
response = await client.put(
f'/livestreams/{livestream["id"]}:{livestream["slug"]}',
headers=headers,
json=stream,
)
assert response.status_code == status.HTTP_200_OK
data = response.json()
assert LiveStream.validate(data)
db_stream = cast(Mapping, await livestream_crud.find_one(livestream['id']))
assert db_stream['slug'] == data['slug']
assert db_stream['title'] == stream['title']
async def test_prohibit_patch(
client: AsyncClient,
dj: Mapping,
user: Mapping,
) -> None:
"""
Проверка прав на изменение DJ
:param client:
:param dj:
:param user:
:return:
"""
new_data = {'name': 'New name'}
auth_headers = create_auth_header(user['username'])
response = await client.patch(
f'/djs/{dj["slug"]}',
headers=auth_headers,
json=new_data,
)
db_dj = await dj_crud.find(dj['id'])
assert response.status_code == status.HTTP_403_FORBIDDEN
assert db_dj['name'] == dj['name']
async def test_update_without_privileges(
client: AsyncClient,
livestream: Mapping,
user: Mapping,
) -> None:
headers = create_auth_header(user['username'])
response = await client.put(
f'/livestreams/{livestream["id"]}:{livestream["slug"]}',
headers=headers,
json={'title': 'Новый заголовок'},
)
assert response.status_code == status.HTTP_403_FORBIDDEN
db_stream = cast(Mapping, await livestream_crud.find_one(livestream['id']))
assert db_stream['title'] == livestream['title']
response = await client.put(
f'/livestreams/{livestream["id"]}:{livestream["slug"]}',
json={'title': 'Новый заголовок'},
)
assert response.status_code == status.HTTP_401_UNAUTHORIZED
db_stream = cast(Mapping, await livestream_crud.find_one(livestream['id']))
assert db_stream['title'] == livestream['title']
async def test_patch(client: AsyncClient, dj: Mapping, admin: Mapping) -> None:
"""
Изменение DJ
:param client:
:param dj:
:return:
"""
auth_headers = create_auth_header(admin['username'])
new_data = {
'name': f'new{dj["name"]}',
'real_name': f'new{dj["real_name"]}'
}
response = await client.patch(
f'/djs/{dj["slug"]}',
headers=auth_headers,
json=new_data,
)
data = response.json()
assert response.status_code == status.HTTP_200_OK
assert data['slug'] == dj['slug']
assert data['name'] == new_data['name']
db_dj = await dj_crud.find(name=new_data['name'])
assert db_dj['slug'] == dj['slug']