def test_on_forgot_password(self, send_email):
session = UnifiedAlchemyMagicMock()
session.add(models.Users("Jake", "*****@*****.**", "password", "img", "xyzabc"))
with mock.patch("app.db.session", SessionObject2()):
app.on_forgot_password({"email": "*****@*****.**"})
app.create_and_send_email.assert_called_once_with(
"*****@*****.**", "\n Hello {},\n This is your password: a."
)
def emit_proj_list(self):
session = UnifiedAlchemyMagicMock()
session.add(
models.Projects(
"gc", "testProj", "Create HomePage using React, HTML, and CSS"
)
)
with mock.patch("app.db.session", session):
app.emit_proj_list(CHANNEL, "sid", ["gc"])
def test_database_values(self):
""" Mocked database initalization """
session = UnifiedAlchemyMagicMock()
session.add(
models.ChatHistory(user_name="mike",
pic_url="https://google.com",
message="hi"))
query = session.query(models.ChatHistory).first()
self.assertEqual(query.user_name, "mike")
self.assertEqual(query.pic_url, "https://google.com")
self.assertEqual(query.message, "hi")
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 mock_get_session(*args):
session = UnifiedAlchemyMagicMock()
dirname = os.path.dirname(os.path.realpath(__file__))
filename = os.path.join(dirname, 'test_noon_forecasts.json')
with open(filename) as data:
json_data = json.load(data)
for forecast in json_data:
forecast['weather_date'] = datetime.fromisoformat(
forecast['weather_date'])
forecast['created_at'] = datetime.fromisoformat(
forecast['created_at'])
session.add(NoonForecasts(**forecast))
return session
def test_on_complete(self):
session = UnifiedAlchemyMagicMock()
session.add(
models.Tasks(
"mockTitle", "test", "11-04-2020", "abc", "aarati", "completed"
)
)
data = {
"email": "jake",
"t": "true",
}
with mock.patch("app.db.session", session):
app.on_complete_task(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_create_project_success(self):
session = UnifiedAlchemyMagicMock()
session.add(models.Users("Jake", "*****@*****.**", "password", "img", "xyzabc"))
with mock.patch("app.db.session", SessionObject()):
with mock.patch("app.ssl", sslObj()):
with mock.patch("app.smtplib", smtplibObj()):
app.on_create_project(
{
"projectName": "testproject",
"projectDescription": "test",
"code": "xyzabc",
"selectedUsers": ["mike", "aarati", "jake", "devin"],
"email": "*****@*****.**",
}
)
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 get_session_with_data():
""" Create a session with some test data.
"""
session = UnifiedAlchemyMagicMock()
station_codes = [209, 322]
weather_values = []
for index, tmp in enumerate(mock_tmps):
weather_values.append({'tmp': tmp, 'rh': mock_rhs[index]})
for code in station_codes:
for value in weather_values:
session.add(
NoonForecast(station_code=code,
weather_date=weather_date,
created_at=time_utils.get_utc_now(),
temperature=value['tmp'],
relative_humidity=value['rh']))
return session
def test_on_data(self):
session = UnifiedAlchemyMagicMock()
session.add(models.Users("Jake", "email@email", "password", "role", "img"))
session.add(models.Participants("email@email", "gc"))
session.add(models.Projects("gc", "testName", "testDescription"))
session.add(
models.Tasks("testTitle", "testDescription", "date", "gc", "owner", "done")
)
with mock.patch("app.db.session", session):
with mock.patch("app.request", RequestObj()):
app.on_data({"email": "email@email"})
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)
def test_on_create_task_success(self, send_email):
session = UnifiedAlchemyMagicMock()
session.add(models.Participants("testEmail.edu", "gc"))
session.add(
models.Projects(
"gc", "testProj", "Create HomePage using React, HTML, and CSS"
)
)
with mock.patch("app.db.session", session):
with mock.patch("app.ssl", sslObj()):
with mock.patch("app.smtplib", smtplibObj()):
app.on_create_task(
{
"email": "testEmail.edu",
"title": "Create HomePage",
"description": "Create HomePage using React, HTML, and CSS",
"deadline": "2020-11-06",
"project": "testProj",
}
)
app.create_and_send_email.assert_called_once_with(
"testEmail.edu",
"\n Hello {},\n \n You have created a task on the Project Manager app!\n ",
)
class TestModels(TestCase):
"""
Tests for checking that database models match up with the views schema pydantic models.
The ORM model is a bit more complicated than the pydantic models, since it
needs to keep track of an ordered list (not trivial in SQL). The way I
solved this was by using a linked list approach, where each Operation
object points to the next one, or None.
This means that it's important to test basic serialization /
deserialization, since this conversion from list to LL is non-trivial.
"""
def setUp(self):
self.sess = UnifiedAlchemyMagicMock()
def test_operation_chaining(self):
"""
Test operation chaining when creating ORM representation.
"""
posted_model = views_schema.Queryset(
name="my_test_queryset",
loa="priogrid_month",
themes=["foo", "bar"],
description="A description...",
operations=[[
views_schema.TransformOperation(name="my.transform",
arguments=[]),
views_schema.DatabaseOperation(name="table.column",
arguments=["values"]),
]])
orm_model = models.Queryset.from_pydantic(self.sess, posted_model)
self.assertEqual(len(orm_model.op_chains()), 1)
self.assertEqual(len(orm_model.op_chains()[0]), 2)
def test_serialize_deserialize(self):
"""
Test serialization back and forth from ORM for equivalence
"""
pydantic_model = views_schema.Queryset(
name="pydantic_queryset",
loa="priogrid_month",
themes=["a", "b"],
description="My great description",
operations=[
[
views_schema.TransformOperation(name="some.transform",
arguments=[]),
views_schema.DatabaseOperation(name="t.c",
arguments=["values"])
],
[
views_schema.DatabaseOperation(name="t.c",
arguments=["values"])
],
])
orm_model = models.Queryset.from_pydantic(self.sess, pydantic_model)
reserialized = views_schema.Queryset(**orm_model.dict())
self.assertEqual(reserialized, pydantic_model)
def test_roundtrip(self):
pydantic_model = views_schema.Queryset(
name="send_me_to_db",
loa="country_month",
themes=[":)"],
description="This is a queryset used for testing.",
operations=[
[
views_schema.TransformOperation(name="alpha.beta",
arguments=["1", "2", "3"]),
views_schema.DatabaseOperation(name="my_table.my_column",
arguments=["values"])
],
[
views_schema.DatabaseOperation(
name="another_table.something", arguments=["values"])
],
])
self.sess.add(models.Queryset.from_pydantic(self.sess, pydantic_model))
retrieved = self.sess.query(models.Queryset).first()
reserialized = views_schema.Queryset(**retrieved.dict())
self.assertEqual(reserialized, pydantic_model)
def test_get_all(self):
session = UnifiedAlchemyMagicMock()
session.add(
Token(id=1, source_app='a', request_app='b', access_token='123'))
result = session.query(Token).all()
return self.assertEqual(len(result), 1)
def test_on_update_role(self):
session = UnifiedAlchemyMagicMock()
session.add(models.Users("Jake", "email@email", "password", "role", "img"))
with mock.patch("app.db.session", session):
app.on_update_role({"email": "email@email", "role": "role"})
def test_get_all(self):
session = UnifiedAlchemyMagicMock()
session.add(Tag(id=1, name='a', added_by='user'))
result = session.query(Tag).all()
return self.assertEqual(len(result), 1)
def test_get_all(self):
session = UnifiedAlchemyMagicMock()
session.add(Action(id=1, type='tag', login='******', description='123',
result='ok', timestamp='123'))
result = session.query(Action).all()
return self.assertEqual(len(result), 1)
def test_get_all(self):
session = UnifiedAlchemyMagicMock()
session.add(Place(id=1, name='a', type='b', description='123'))
result = session.query(Place).all()
return self.assertEqual(len(result), 1)
