def test_chats_list(self):
self.init_main_user()
self.register_users(3)
User.create_chat(1, 2)
User.create_chat(1, 3)
db.session.commit()
self.assertEqual(db.session.query(chats).count(), 2)
response = self.test_client.get('/api/chats', headers=self.bearer_auth_header)
self.assertEqual(response.status_code, 200)
data = response.json
self.assertEqual(data['user_id'], 1)
self.assertEqual(len(data['data']), 2)
chat1, chat2 = data['data']
self.assertTrue(chat1['chat_id'] == 1 and chat1['user1_id'] == 1 and chat1['user2_id'] == 2)
self.assertTrue(chat2['chat_id'] == 2 and chat2['user1_id'] == 1 and chat2['user2_id'] == 3)
response = self.test_client.post('/api/chats', json={'companion_id': 4}, headers=self.bearer_auth_header)
self.assertEqual(response.status_code, 201)
self.assertEqual(db.session.query(chats).count(), 3)
data = response.json
self.assertTrue(data['user_id'] == 1 and data['companion_id'] == 4 and data['chat_id'] == 3)
response = self.test_client.get('/api/chats', headers=self.bearer_auth_header)
self.assertEqual(response.status_code, 200)
data = response.json
self.assertEqual(len(data['data']), 3)
chat3 = data['data'][2]
self.assertTrue(chat3['chat_id'] == 3 and chat3['user1_id'] == 1 and chat3['user2_id'] == 4)
response = self.test_client.post('/api/chats', json={'companion_id': 4}, headers=self.bearer_auth_header)
self.assertEqual(response.status_code, 400)
def test_chat_messages_list_post(self):
self.init_main_user()
self.register_users(1)
User.create_chat(1, 2)
db.session.commit()
self.assertEqual(db.session.query(Message).count(), 0)
response = self.test_client.post('/api/chats/1/messages', json={'texts': ['first']},
headers=self.basic_auth_header)
self.assertEqual(response.status_code, 201)
data = response.json
self.assertTrue(data['user_id'] == 1 and data['chat_id'] == 1)
self.assertEqual(db.session.query(Message).count(), 1)
message = Message.query.first()
self.assertTrue(
message.text == 'first' and message.sender_id == 1 and message.receiver_id == 2 and message.chat_id == 1)
response = self.test_client.post('/api/chats/1/messages', json={'texts': ['second', 'third', 'fourth']},
headers=self.bearer_auth_header)
self.assertEqual(response.status_code, 201)
data = response.json
self.assertTrue(data['user_id'] == 1 and data['chat_id'] == 1)
self.assertEqual(db.session.query(Message).count(), 4)
new_messages = Message.query.all()[1:]
self.assertTrue(
new_messages[0].text == 'second' and new_messages[1].text == 'third' and new_messages[2].text == 'fourth')
def test_return_chat_or_abort(self):
users = init_users(2)
User.create_chat(1, 2)
db.session.add_all(users)
db.session.commit()
chat = return_chat_or_abort(1)
self.assertEqual(chat.user1_id, 1)
self.assertEqual(chat.user2_id, 2)
with self.assertRaises(NotFound):
return_chat_or_abort(2)
def test_abort_if_not_a_participant(self):
users = init_users(3)
User.create_chat(1, 2)
User.create_chat(2, 3)
db.session.add_all(users)
with self.assertRaises(Forbidden):
abort_if_not_a_participant(1, return_chat_or_abort(2))
try:
abort_if_not_a_participant(2, return_chat_or_abort(2))
except Forbidden:
self.fail(msg="403 error must not have been raised")
def test_get_more_messages(self):
messages_limit = self.app.config['MESSAGES_PER_LOAD_EVENT']
with self.app.test_client() as client1, self.app.test_client() as client2:
self.init_two_clients(client1, client2)
socket_io_client1, socket_io_client2 = self.get_socket_io_clients(client1, client2)
socket_io_client1.emit('enter_room', namespace=self.events_namespace)
socket_io_client2.emit('enter_room', namespace=self.events_namespace)
User.create_chat(1, 2)
# erase status messages
socket_io_client1.get_received(namespace=self.events_namespace)
socket_io_client2.get_received(namespace=self.events_namespace)
number_of_messages = 15
db.session.add_all(
[Message(text=str(figure), sender_id=1, receiver_id=2) for figure in range(number_of_messages)])
db.session.commit()
self.assertEqual(len(Message.query.all()), number_of_messages)
for messages_offset in range(0, number_of_messages):
socket_io_client1.emit('get_more_messages', {'messages_offset': messages_offset},
namespace=self.events_namespace)
received1 = socket_io_client1.get_received(self.events_namespace)
received2 = socket_io_client2.get_received(self.events_namespace)
self.assertEqual(len(received2), 0)
self.assertEqual(len(received1), 1)
received_data = received1[0]['args'][0]
self.assertTrue(received_data['messages_number'] <= messages_limit)
self.assertEqual(received_data['messages_number'],
number_of_messages - messages_offset if number_of_messages - messages_offset <= messages_limit else messages_limit)
messages_offset = 10
socket_io_client1.emit('get_more_messages', {'messages_offset': messages_offset},
namespace=self.events_namespace)
received1 = socket_io_client1.get_received(self.events_namespace)
received_messages = received1[0]['args'][0]['messages']
for message, message_text in zip(received_messages, reversed(range(
number_of_messages - messages_offset if number_of_messages - messages_offset <= messages_limit else messages_limit))):
self.assertTrue(message['is_current_user'])
self.assertEqual(message['message_text'], str(message_text))
messages_offset = 10
socket_io_client2.emit('get_more_messages', {'messages_offset': messages_offset},
namespace=self.events_namespace)
received2 = socket_io_client2.get_received(self.events_namespace)
received_messages = received2[0]['args'][0]['messages']
for message in received_messages:
self.assertFalse(message['is_current_user'])
def __init__(self, *args, **kwargs):
sender_id = kwargs.get('sender_id')
receiver_id = kwargs.get('receiver_id')
if not User.is_chat_between(sender_id, receiver_id):
logger.info('Message __init__ is making a chat between users')
User.create_chat(sender_id, receiver_id)
if 'chat_id' not in kwargs:
self.chat_id = User.get_chat_id_by_users_ids(
sender_id, receiver_id)
else:
if not kwargs.get('chat_id') == User.get_chat_id_by_users_ids(
sender_id, receiver_id):
logger.critical(
"Chat id in message __init__ turned out to be wrong somehow"
)
raise AssertionError
super().__init__(*args, **kwargs)
def test_get_user_chats_and_last_messages(self):
users = init_users(5)
User.create_chat(1, 2)
User.create_chat(1, 3)
User.create_chat(1, 4)
User.create_chat(2, 3)
db.session.add_all(users)
m1 = Message(text='m1', sender_id=1, receiver_id=2)
m2 = Message(text='m2', sender_id=2, receiver_id=1)
m3 = Message(text='m3', sender_id=1, receiver_id=2)
m4 = Message(text='m4', sender_id=1, receiver_id=3)
m5 = Message(text='m5', sender_id=3, receiver_id=1)
m6 = Message(text='m6', sender_id=1, receiver_id=4)
m7 = Message(text='m7', sender_id=2, receiver_id=3)
m8 = Message(text='m8', sender_id=3, receiver_id=2)
db.session.add_all([m1, m2, m3, m4, m5, m6, m7, m8])
db.session.commit()
chats1 = get_uc(1).all()
self.assertEqual(len(chats1), 3)
self.assertEqual(chats1[0][0], 'user4')
self.assertEqual(chats1[1][0], 'user3')
self.assertEqual(chats1[2][0], 'user2')
self.assertEqual(chats1[0][2], 'm6')
self.assertEqual(chats1[1][2], 'm5')
self.assertEqual(chats1[2][2], 'm3')
chats2 = get_uc(2).all()
self.assertEqual(len(chats2), 2)
self.assertEqual(chats2[0][0], 'user3')
self.assertEqual(chats2[1][0], 'user1')
self.assertEqual(chats2[0][2], 'm8')
self.assertEqual(chats2[1][2], 'm3')
chats3 = get_uc(3).all()
self.assertEqual(len(chats3), 2)
self.assertEqual(chats3[0][0], 'user2')
self.assertEqual(chats3[1][0], 'user1')
self.assertEqual(chats3[0][2], 'm8')
self.assertEqual(chats3[1][2], 'm5')
chats4 = get_uc(4).all()
self.assertEqual(len(chats4), 1)
self.assertEqual(chats4[0][0], 'user1')
self.assertEqual(chats4[0][2], 'm6')
chats5 = get_uc(5).all()
self.assertEqual(len(chats5), 0)
def test_user_chats_list(self):
with self.test_client as client:
client.post('/authentication/register',
data={
'email': '*****@*****.**',
'username': '******',
'name': 'Ann1',
'password1': 'Who am I',
'password2': 'Who am I'
},
follow_redirects=True)
client.post('/authentication/register',
data={
'email': '*****@*****.**',
'username': '******',
'name': 'Ann2',
'password1': 'Who am I',
'password2': 'Who am I'
},
follow_redirects=True)
client.post('/authentication/login',
data={
'email': '*****@*****.**',
'password': '******'
},
follow_redirects=True)
User.create_chat(1, 2)
db.session.add(
Message(text='test_text', sender_id=1, receiver_id=2))
db.session.commit()
response = client.get('/chats/list')
self.assertEqual(response.status_code, 200)
response_data = response.data.decode()
self.assertTrue('<title>Chats list</title>' in response_data)
self.assertTrue('test_text' in response_data)
self.assertTrue('Ann2' in response_data)
self.assertTrue('test_user2' in response_data)
def post(self):
"""Creates a new chat between the current user and the users with the given in json id"""
parser = reqparse.RequestParser()
parser.add_argument('companion_id',
required=True,
type=int,
help='User\'s id to create a chat with')
args = parser.parse_args()
current_user_id = g.user.user_id
user_id = args.get('companion_id')
return_user_or_abort(user_id)
try:
User.create_chat(current_user_id, user_id)
except ChatAlreadyExistsError:
abort(400,
message=f'Your chat with the user {user_id} already exists')
db.session.commit()
return {
'user_id': current_user_id,
'companion_id': user_id,
'chat_id': User.get_chat_id_by_users_ids(current_user_id, user_id),
'message': 'Chat was successfully created'
}, 201
