def index():
"""Данная функция генерирует главную страницу для пользователя
:return: Главная страница с чатами пользователя, является ли человек \
в сессии, формой входа(Если человек не зарегистрирован, заголовок чата
"""
find_chat_form = FindChatForm()
chat_create_form = CreateChatForm()
login_form = LoginForm()
if login_form.validate_on_submit():
User.login(login_form.login.data)
if chat_create_form.validate_on_submit():
name = chat_create_form.name.data
code_type = chat_create_form.code_type.data
code = chat_create_form.code.data
access_key = chat_create_form.access_key.data
if chat_create_form.is_file_valid():
code = chat_create_form.file.data.read()
chat_id = Chat.create(name, code, code_type, access_key)
return redirect('/chat/' + str(chat_id))
return render_template('index.html',
chats=Chat.find(find_chat_form.chat_title.data),
login_form=login_form,
chat_create_form=chat_create_form,
find_chat_form=find_chat_form,
login=User.get_login(),
allowed_ex=",".join([
'.' + i
for i in app.config["ALLOWED_EXTENSIONS"]
]),
allowed_languages=app.config["ALLOWED_LANGUAGES"])
def __create_mock_chats(self, count):
db.session.remove()
db.drop_all()
db.create_all()
langs = app.config['ALLOWED_LANGUAGES']
for i in xrange(count):
Chat.create('Chat name', 'Chat code', langs[i % len(langs)]['type'])
def test_change_chat_name(self):
new_chat_name = CHAT_NAME * 2
chat_id = Chat.create(CHAT_NAME, CHAT_CODE, CODE_TYPE, CHAT_ACCESS_KEY)
chat = Chat.get(chat_id)
chat.set_name(new_chat_name)
chat = Chat.get(chat_id)
self.assertEqual(chat.name, MarkdownMixin.decode(new_chat_name))
def test_set_chat_name_return(self):
new_chat_name = CHAT_NAME * 2
chat_id = Chat.create(CHAT_NAME, CHAT_CODE, CODE_TYPE, CHAT_ACCESS_KEY)
chat = Chat.get(chat_id)
set_chat_name_return = chat.set_name(new_chat_name)
self.assertIsInstance(set_chat_name_return, dict)
self.assertEqual(set_chat_name_return.get('original', None), chat.name)
self.assertNotEqual(set_chat_name_return.get('plain', None), None)
self.assertNotEqual(set_chat_name_return.get('escaped', None), None)
def test_form_required_handler(self):
chat_id = Chat.create(CHAT_NAME, CHAT_CODE, CODE_TYPE)
response = self.app.get(MESSAGES_GET_PAGE_URL.format(chat_id=chat_id))
self.assertEqual(response.status_code, 200)
response = self.app.get(
MESSAGES_GET_PAGE_URL.format(chat_id=chat_id + 1))
self.assertEqual(response.status_code, 400)
def test_find_with_page(self):
CHAT_COUNT = 6
LIMIT = 5
PAGE = 2
self.__create_mock_chats(CHAT_COUNT)
chats = Chat.find('', limit=LIMIT, page=PAGE)
self.assertEqual(len(chats), CHAT_COUNT - LIMIT)
def test_get_last_messages(self):
chat = Chat.get(self.chat_id)
old_message = Message.send(self.chat_id, MESSAGE, MESSAGE_TYPE)
new_message = Message.send(self.chat_id, MESSAGE, MESSAGE_TYPE)
got_last_messages = chat.get_last_messages(old_message.id)
self.assertEqual(len(got_last_messages), 1)
self.assertEqual(got_last_messages[0].get('id'), new_message.id)
def test_get_last_messages(self):
chat_id = Chat.create(CHAT_NAME, CHAT_CODE, CODE_TYPE)
last_message = Message.send(chat_id, MESSAGE, MESSAGE_TYPE)
url = MESSAGES_GET_LAST_PAGE_URL.format(
chat_id=chat_id, last_message_id=last_message.id)
response = self.app.get(url)
self.assertEqual(response.status_code, 200)
def chat_page(chat_id):
"""Данная функция возвращает пользователю страницу чата по номеру
:param chat_id: Номер чата
:return: Страница чата
"""
chat_create_form = CreateChatForm()
login_form = LoginForm()
chat = Chat.get(chat_id)
if not chat:
return redirect('/')
auth_form = AuthChatForm()
if auth_form.validate_on_submit():
access_key = auth_form.password.data
User.set_access_key(chat_id, access_key)
return render_template(
'chat.html',
chat_id=chat.id,
socket_mode=(app.config['SOCKET_MODE'] == 'True'),
chat_info=chat.get_info(),
login=User.get_login(),
login_form=login_form,
chat_create_form=chat_create_form,
have_access=chat.is_access_key_valid(User.get_access_key(chat_id)),
auth_form=auth_form,
allowed_ex=",".join(
['.' + i for i in app.config["ALLOWED_EXTENSIONS"]]),
allowed_languages=app.config["ALLOWED_LANGUAGES"])
def test_get_all_messages(self):
second_message = Message.send(self.chat_id, MESSAGE, MESSAGE_TYPE)
third_message = Message.send(self.chat_id, MESSAGE, MESSAGE_TYPE)
chat = Chat.get(self.chat_id)
got_messages = chat.get_last_messages()
self.assertEqual(len(got_messages), 3)
self.assertEqual(got_messages[1].get('id'), second_message.id)
self.assertEqual(got_messages[2].get('id'), third_message.id)
def test_access_required_handler(self):
chat_id = Chat.create(CHAT_NAME, CHAT_CODE, CODE_TYPE, CHAT_ACCESS_KEY)
self.real.get_access_key.return_value = CHAT_INCORRECT_ACCESS_KEY
response = self.app.get(MESSAGES_GET_PAGE_URL.format(chat_id=chat_id))
self.assertEqual(response.status_code, 403)
self.real.get_access_key.return_value = CHAT_ACCESS_KEY
response = self.app.get(MESSAGES_GET_PAGE_URL.format(chat_id=chat_id))
self.assertEqual(response.status_code, 200)
def set_chat_name():
"""Изменение названия чата
:return: успешность сохранения названия
"""
chat_name_form = ChatNameForm()
chat = Chat.get(chat_name_form.chat.data)
chat_name = chat.set_name(chat_name_form.name.data)
return dumps({"success": True, "error": "", "data": chat_name})
def get_messages():
"""Запрос получения новых сообщений в чате
:return: Принято ли сообщение
"""
get_messages_form = GetMessagesForm(request.args)
chat_id = get_messages_form.chat.data
last_message_id = get_messages_form.last_message_id.data
chat = Chat.get(chat_id)
return dumps(chat.get_last_messages(last_message_id))
def test_send_code(self):
chat_id = Chat.create(CHAT_NAME, CHAT_CODE, CODE_TYPE)
params = {
"chat": chat_id,
"code": CODE,
"parent": 1,
"cname": COMMIT_MESSAGE
}
response = self.app.post(CODE_SEND_PAGE_URL, data=params)
self.assertEqual(response.status_code, 200)
def api_chat_list():
"""Получение списка созданных чатов
:return: список созданных чатов
"""
search = request.args.get('search', '')
limit = int(request.args.get('limit', 0))
page = int(request.args.get('page', 1))
chats = Chat.find(search, limit, page)
data = [chat.to_dict() for chat in chats]
return jsonify(data)
def access_check(*args, **kwargs):
"""Функция возвращает ошибку, если ключ доступа к чату невалиден"""
if request.method == "POST":
chat_form = ChatForm()
else:
chat_form = ChatForm(request.args)
chat_id = chat_form.chat.data
chat = Chat.get(chat_id)
if chat.is_access_key_valid(User.get_access_key(chat_id)):
return func(*args, **kwargs)
return dumps({"success": False, "error": "Access error"}), 403
def api_create_chat():
"""Данная функция создаёт чат по параметрам, используется для api
:return: Адрес новой страницы чата
"""
form = CreateChatForm()
name = form.name.data
code = form.code.data
code_type = form.code_type.data
access_key = form.access_key.data
chat_id = Chat.create(name, code, code_type, access_key)
return '/chat/' + str(chat_id)
def create_chat():
user = current_user
try:
chat = Chat.from_chat(request.json)
except KeyError as e:
return jsonify(f'Missing key: {e.args[0]}'), 400
db.session.commit()
chat.users.append(user)
db.session.add(chat)
db.session.commit()
return jsonify(chat.to_chat()), 200
def test_access_chat_page(self):
chat_id = Chat.create(CHAT_NAME, CHAT_CODE, CODE_TYPE)
chat_page_url = CHAT_PAGE_URL.format(chat_id=chat_id)
response = self.app.get(chat_page_url)
self.assertEqual(response.status_code, 200)
def test_find_chat_by_name(self):
search_name = CHAT_NAME[2:-2]
found_chat_list = Chat.find(search_name)
self.assertGreaterEqual(len(found_chat_list), 1)
self.assertIn(search_name, found_chat_list[0].name)
def setUp(self):
BaseTestModel.setUp(self)
self.chat_id = Chat.create(CHAT_NAME, CHAT_CODE, CODE_TYPE)
self.message = Message.send(self.chat_id, MESSAGE, MESSAGE_TYPE)
def test_find_chat_all(self):
CHAT_COUNT = 15
INFINITELY_LIMIT = 0
self.__create_mock_chats(CHAT_COUNT)
chats = Chat.find('', limit=INFINITELY_LIMIT)
self.assertEqual(len(chats), CHAT_COUNT)
def test_find_chat_by_id(self):
search_id = str(self.chat_id)
found_chat_list = Chat.find(search_id)
self.assertEqual(len(found_chat_list), 1)
self.assertEqual(found_chat_list[0].id, int(search_id))
def chat_required(form, field):
"""Проверка чата на существование"""
if not Chat.get(field.data):
raise ValidationError
def test_find_with_limit(self):
CHAT_COUNT = 10
LIMIT = 5
self.__create_mock_chats(CHAT_COUNT)
chats = Chat.find('', limit=LIMIT)
self.assertEqual(len(chats), LIMIT)
def test_get_code(self):
chat_id = Chat.create(CHAT_NAME, CHAT_CODE, CODE_TYPE)
code_id = Code.send(chat_id, CODE, 1, COMMIT_MESSAGE)
response = self.app.get(CODE_GET_PAGE_URL.format(code_id=code_id))
self.assertEqual(response.status_code, 200)
def test_set_chat_name(self):
chat_id = Chat.create(CHAT_NAME, CHAT_CODE, CODE_TYPE)
params = {"chat": chat_id, "name": MESSAGE}
response = self.app.post(SET_CHAT_NAME_PAGE_URL, data=params)
self.assertEqual(response.status_code, 200)
def test_get_tree(self):
chat_id = Chat.create(CHAT_NAME, CHAT_CODE, CODE_TYPE)
response = self.app.get(TREE_PAGE_URL.format(chat_id=chat_id))
self.assertEqual(response.status_code, 200)
def test_send_message(self):
chat_id = Chat.create(CHAT_NAME, CHAT_CODE, CODE_TYPE)
params = {"chat": chat_id, "message": MESSAGE}
response = self.app.post(MESSAGE_SEND_PAGE_URL, data=params)
self.assertEqual(response.status_code, 200)
def test_get_messages(self):
chat_id = Chat.create(CHAT_NAME, CHAT_CODE, CODE_TYPE)
response = self.app.get(MESSAGES_GET_PAGE_URL.format(chat_id=chat_id))
self.assertEqual(response.status_code, 200)
