def test_app_on_get_whiteboard(self, mocked_flask):
session = UnifiedAlchemyMagicMock()
for test in self.test_on_get_whiteboard_params:
mocked_flask.request.sid = test[KEY_INPUT][KEY_SID]
with mock.patch("flask_socketio.SocketIO.emit", self.mock_emit):
with mock.patch("models.DB.session", session):
session.add(models.Whiteboards(*test[KEY_INPUT][BOARD_DATA]))
session.commit()
app.on_get_whiteboard()
self.assertDictEqual(self.hold, test[KEY_EXPECTED])
def test_app_get_board(self, mocked_flask):
session = UnifiedAlchemyMagicMock()
for test in self.test_get_board_params:
mocked_flask.request.sid = test[KEY_INPUT][KEY_SID]
with mock.patch("flask_socketio.SocketIO.emit", self.mock_emit):
with mock.patch("models.DB.session", session):
session.add(
models.WhiteboardConnections(
*test[KEY_INPUT][KEY_CONNECTION]))
session.commit()
self.assertEqual(app.get_board(test[KEY_INPUT][KEY_SID]),
test[KEY_EXPECTED])
def test_app_on_forced_save(self, mocked_flask):
session = UnifiedAlchemyMagicMock()
for test in self.test_on_forced_save_params:
mocked_flask.request.sid = test[KEY_INPUT][KEY_SID]
with mock.patch("flask_socketio.SocketIO.emit", self.mock_emit):
with mock.patch("models.DB.session", session):
temp_row=models.Whiteboards(*test[KEY_INPUT][KEY_BOARD][:2])
temp_row.save_num = test[KEY_INPUT][KEY_BOARD][2]
session.add(temp_row)
session.add(models.WhiteboardConnections(*test[KEY_INPUT][KEY_CONNECTION]))
session.commit()
app.on_forced_save({"blob":bytes([1,5,2,5,3,2,1])})
self.assertDictEqual(self.hold, test[KEY_EXPECTED])
def test_google_login_success(self, mock_flask):
session = UnifiedAlchemyMagicMock()
for test in self.success_test_params:
mock_flask.request.sid = test[KEY_INPUT][KEY_SID]
with mock.patch("models.DB.session", session):
session.add(
models.CurrentConnections(mock_flask.request.sid, 1))
session.commit()
print("Mocked Login")
app.accept_google_login(test[KEY_INPUT][KEY_DATA])
def test_on_disconnect_whiteboard_board(self, mocked_print, mocked_flask):
session = UnifiedAlchemyMagicMock()
for test in self.test_on_disconnect_whiteboard_params:
mocked_flask.request.sid = test[KEY_INPUT][KEY_SID]
with mock.patch("flask_socketio.leave_room",
self.mock_leave_group):
with mock.patch("models.DB.session", session):
for connect in test[KEY_INPUT][KEY_CONNECTION]:
temp_row = models.WhiteboardConnections(*connect)
temp_row.id = 1
session.add(temp_row)
session.commit()
app.on_disconnect_whiteboard()
mocked_print.assert_called_with(test[KEY_EXPECTED])
def test_emit_all_messages_success(self, mock_flask):
session = UnifiedAlchemyMagicMock()
for test in self.success_test_params:
mock_flask.request.sid = test[KEY_INPUT][KEY_SID]
with mock.patch("models.DB.session", session):
session.add(models.EnteredRooms(1, 1))
session.add(models.EnteredRooms(2, 1))
session.commit()
with mock.patch("flask_socketio.SocketIO.emit",
self.mock_emit):
with mock.patch("app.get_room", self.mock_get_room):
app.emit_all_messages(test[KEY_INPUT][KEY_SID])
def test_on_join_whiteboard_other(self, mocked_flask):
session = UnifiedAlchemyMagicMock()
for test in self.test_on_join_whiteboard_other:
mocked_flask.request.sid = test[KEY_INPUT][KEY_SID]
with mock.patch("flask_socketio.SocketIO.emit", self.mock_emit):
with mock.patch("flask_socketio.join_room", self.mock_join_room):
with mock.patch("models.DB.session", session):
temp_row=models.WhiteboardConnections(*test[KEY_INPUT][BOARD_DATA])
temp_row.id = 1
session.add(temp_row)
session.commit()
app.on_join_whiteboard(test[KEY_INPUT][KEY_DATA])
self.assertDictEqual(self.hold, test[KEY_EXPECTED])
def test_on_join_whiteboard(self, mocked_flask):
session = UnifiedAlchemyMagicMock()
for test in self.test_on_join_whiteboard_params:
mocked_flask.request.sid = test[KEY_INPUT][KEY_SID]
with mock.patch("flask_socketio.SocketIO.emit", self.mock_emit):
with mock.patch("flask_socketio.join_room", self.mock_join_room):
with mock.patch("models.DB.session", session):
temp_row=models.Whiteboards(test[KEY_INPUT][BOARD_DATA]["room"],test[KEY_INPUT][BOARD_DATA]["name"])
temp_row.id=test[KEY_INPUT][BOARD_DATA]["id"]
temp_row.save_num=test[KEY_INPUT][BOARD_DATA]["save_num"]
session.add(temp_row)
session.commit()
app.on_join_whiteboard(test[KEY_INPUT][KEY_DATA])
self.assertDictEqual(self.hold, test[KEY_EXPECTED])
def test_app_on_disconnect(self, mocked_flask):
for test in self.test_on_disconnect_params:
session = UnifiedAlchemyMagicMock()
mocked_flask.request.sid = test[KEY_INPUT][KEY_SID]
with mock.patch('models.DB.session', session):
session.add(
models.CurrentConnections(test[KEY_INPUT][KEY_SID], 1))
session.add(
models.AuthUser(models.AuthUserType.GOOGLE, 'nrw41',
'meail', 'pciina'))
session.commit()
#with mock.patch('app.print', self.mock_print):
# with mock.patch('app.emit_all_users', self.mock_emit_all_users):
with mock.patch('app.get_room', self.mock_get_room):
app.on_disconnect()
self.assertEqual(len(self.emit_list) + 1, len(test[KEY_EXPECTED]))
for i in range(len(self.emit_list)):
self.assertEqual(self.emit_list[i]['opp'],
test[KEY_EXPECTED][i]['opp'])
def test_new_room_creation_success(self, mock_flash):
session = UnifiedAlchemyMagicMock()
for test in self.success_test_params:
mock_flash.request.sid = test[KEY_INPUT][KEY_SID]
with mock.patch("models.DB.session", session):
print("Rooms:", session.query(models.JoinedRooms).count())
session.add(
models.CurrentConnections(test[KEY_INPUT][KEY_SID], 1))
session.commit()
with mock.patch("flask_socketio.SocketIO.emit",
self.mock_emit):
app.on_new_room_creation(test[KEY_INPUT][KEY_DATA])
response = {
KEY_JOINED: session.query(models.JoinedRooms).count(),
KEY_ROOMS: session.query(models.Rooms).count()
}
expected = test[KEY_EXPECTED]
self.assertDictEqual(response, expected)
def test_create_new_user(app):
"""
GIVEN a User model
WHEN a new User is created
THEN check the id, username, password, serialization and string representation
"""
username = get_unique_username()
password = '******'
from app.model.models import User
session = UnifiedAlchemyMagicMock()
user = User(username=username, password=password)
session.add(user)
session.commit()
query = session.query(User).first()
assert query.username == username
assert query.password == password
assert query.serialize() == {'id': str(user.id), 'username': username}
assert str(query) == '<User %r>' % (username)
def test_create_new_token(app):
"""
GIVEN a Token model
WHEN a new token is created
THEN check the id, jti, token_type, user_identity, revoked,
expires serialization and string representation
"""
from app.model.models import Token
jti = "27d1b1a3-45b4-4a5f-83ed-b823f5ea1dbe"
token_type = "access"
user_identity = "test"
revoked = True
expires = datetime.now()
session = UnifiedAlchemyMagicMock()
token = Token(jti, token_type, user_identity, revoked, expires)
session.add(token)
session.commit()
serialized_data = {
'id': str(token.id),
'jti': jti,
'token_type': token_type,
'user_identity': user_identity,
'revoked': revoked,
'expires': expires
}
query = session.query(Token).first()
assert query.jti == jti
assert query.token_type == token_type
assert query.user_identity == user_identity
assert query.revoked == revoked
assert query.expires == expires
assert query.serialize() == serialized_data
assert str(query) == '<Token %r>' % (jti)