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)