def test_send_link_messages(self): """test sending link messages""" MOCKCLIENTS = TESTCLIENTS.copy() MOCKMESSAGES = TESTMESSAGES.copy() MOCKSESSION = UnifiedAlchemyMagicMock() TESTMESSAGE = { USER:'******', ID:'003', MESSAGE:'This is a link https://www.google.com/', } EXPECTEDMESSAGES = [ MOCKMESSAGES[0], MOCKMESSAGES[1], MOCKMESSAGES[2], { USER:'******', MESSAGE:("This is a link <a href='https://www.google.com/' " + "target='_blank'>https://www.google.com/</a> "), TIMESTAMP: datetime.now(TIME_ZONE).strftime("%H:%M %m/%d/%y") } ] with mock.patch("app.socketio.emit", mock_emit): with mock.patch("app.clients", MOCKCLIENTS): with mock.patch("app.messages", MOCKMESSAGES): with mock.patch("app.db.session", MOCKSESSION): fill_mock_db(MOCKSESSION) response =on_send_message(TESTMESSAGE) self.assertTrue(response[RESPONSE] == 'messages updated') self.assertEqual(response[DATA][MESSAGES], EXPECTEDMESSAGES) MOCKDB = MOCKSESSION.query(models.Messages).all() for i in range(0,len(MOCKDB)): self.assertEqual(MOCKDB[i].name, EXPECTEDMESSAGES[i][USER]) self.assertEqual(MOCKDB[i].message, EXPECTEDMESSAGES[i][MESSAGE]) self.assertEqual(MOCKDB[i].time, EXPECTEDMESSAGES[i][TIMESTAMP])
def test_calls_my_method(self): """ ExampleClass module calls my_method twice """ # with \ # patch('sqlalchemy.or_') as m_or_,\ # patch('sqlalchemy.and_') as m_and_,\ # patch('sqlalchemy.func') as m_func,\ # patch('sqlalchemy.not_') as m_not_: from airflow_maintenance_dags.db_cleanup.airflow_db_cleanup \ import _get_entries_to_delete # mock the data: # TODO: this is non-functional example copied from # https://pypi.org/project/alchemy-mock/ session = UnifiedAlchemyMagicMock(data=[ ([ mock.call.query(DagRun), mock.call.filter(DagRun.foo == 5, DagRun.bar > 10) ], [DagRun(foo=5, bar=11)]), ([ mock.call.query(DagRun), mock.call.filter(DagRun.note == 'hello world') ], [DagRun(note='hello world')]), ([ mock.call.query(DAG), mock.call.filter(DagRun.foo == 5, DagRun.bar > 10) ], [DAG(foo=5, bar=17)]), ]) query = session.query(DagRun).options(load_only(DagRun.execution_date)) result = _get_entries_to_delete(query, DagRun, False, DagRun.execution_date, DagRun.dag_id, "2019-07-29", ['dag_ignore_list']) import pdb pdb.set_trace() self.assertEqual(query, False)
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_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_emit_cards_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): session.query( models.Flashcards).all.return_value = self.mocked_cards() with mock.patch("flask_socketio.SocketIO.emit", self.mock_emit): print(app.emit_flashcards(test[KEY_INPUT][KEY_DATA]))
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_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 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_send_bot_messages_with_known_results(self): """test sending simple bot messages""" BOT_COMMANDS = ['!! about', '!! help', '!! fakeCommand'] BOT_RESPONSES = [ ('Hi, I am BobbyBot. I am a pretty fun guy. If there is something you need from me '+ 'let me know. To find out what I am capable of type !! help'), ('!! about - learn about me<br>!! help - shows this screen<br>!! funtranslate '+ '{message} - translate message to {language}<br>!! flip - flip a coin<br>!! '+ 'bitcoin - I will tell you bitcoins price'), "I don't know how to do that" ] for bot in range(0,len(BOT_COMMANDS)): MOCKCLIENTS = TESTCLIENTS.copy() MOCKMESSAGES = TESTMESSAGES.copy() MOCKSESSION = UnifiedAlchemyMagicMock() TESTMESSAGE = { USER:'******', ID:'003', MESSAGE:BOT_COMMANDS[bot], } EXPECTEDMESSAGES = [ MOCKMESSAGES[0], MOCKMESSAGES[1], MOCKMESSAGES[2], { USER:'******', MESSAGE:BOT_COMMANDS[bot] + ' ', TIMESTAMP: datetime.now(TIME_ZONE).strftime("%H:%M %m/%d/%y") }, { USER:'******', MESSAGE:BOT_RESPONSES[bot], TIMESTAMP: datetime.now(TIME_ZONE).strftime("%H:%M %m/%d/%y") } ] with mock.patch("app.socketio.emit", mock_emit): with mock.patch("app.clients", MOCKCLIENTS): with mock.patch("app.messages", MOCKMESSAGES): with mock.patch("app.db.session", MOCKSESSION): fill_mock_db(MOCKSESSION) response =on_send_message(TESTMESSAGE) self.assertTrue(response[RESPONSE] == 'messages updated') self.assertEqual(response[DATA][MESSAGES], EXPECTEDMESSAGES) MOCKDB = MOCKSESSION.query(models.Messages).all() for i in range(0,len(MOCKDB)): self.assertEqual(MOCKDB[i].name, EXPECTEDMESSAGES[i][USER]) self.assertEqual(MOCKDB[i].message, EXPECTEDMESSAGES[i][MESSAGE]) self.assertEqual(MOCKDB[i].time, EXPECTEDMESSAGES[i][TIMESTAMP])
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_new_cards_success(self, mock_flash): session = UnifiedAlchemyMagicMock() for test in self.success_test_params: mock_flash.request.sid = test[KEY_INPUT][KEY_SID] app.new_cards.room = test[KEY_INPUT][KEY_DATA][0][KEY_ROOM] with mock.patch("models.DB.session", session): with mock.patch('app.get_room', self.mock_get_room): app.new_cards(test[KEY_INPUT][KEY_DATA]) query = session.query(models.Flashcards).all()[0] expected = test[KEY_EXPECTED] self.assertEqual(query.room, expected[2]) self.assertEqual(query.answer, expected[1]) self.assertEqual(query.question, expected[0])
def test_the_change_token_revoking_method_of_user_repository(app): """ GIVEN the TokenRepository instance WHEN the save() method is call THEN check session method calls and the token revoke value """ from app.model import TokenRepository, Token token_repository = TokenRepository() token_repository.session = UnifiedAlchemyMagicMock() token = Token() token.id = 1 token.jti = "27d1b1a3-45b4-4a5f-83ed-b823f5ea1dbe" token.token_type = "access" token.user_identity = "test" token.revoked = False token.expires = datetime.now() token_repository.session.add(token) token_repository.session.commit() token_repository.change_token_revoking(1, "test", True) (token_repository.session.query.return_value.filter_by. assert_called_once_with(id=1, user_identity="test")) assert token.revoked == True
def test_cheapest(self, mocker): mocker.patch('delivery.views.route.Route.validate_cheapest_input') mocker.patch('delivery.views.route.Route.calculate_expenses') expected = RouteModel(**self.mock_data) input = {} input.update(self.mock_data) input['gas_price'] = 1 input['truck_autonomy'] = 1 session = UnifiedAlchemyMagicMock(data=[ ( [mock.call.query(RouteModel), mock.call.filter(RouteModel.map == self.mock_data['map'])], [expected] ), ]) route = Route(session) result = route.cheapest(input) route.calculate_expenses.assert_called_once() assert list(result.keys()) == ['route', 'cost'] assert self.mock_data['origin'] in list(result['route']) assert self.mock_data['destination'] in list(result['route'])
def test_start(self): """test start function""" MOCKSESSION = UnifiedAlchemyMagicMock() with mock.patch("app.db.session", MOCKSESSION): with mock.patch("flask.render_template", mock_render): response = start() self.assertEqual(response, "Successfully rendered index.html")
def mock_get_session(*args) -> UnifiedAlchemyMagicMock: """ return a session with a bare minimum database that should be good for most unit tests. """ prediction_model = PredictionModel( id=1, abbreviation='GDPS', projection='latlon.15x.15', name='Global Deterministic Prediction System') prediction_model_run = PredictionModelRunTimestamp( id=1, prediction_model_id=1, prediction_run_timestamp=time_utils.get_utc_now(), prediction_model=prediction_model, complete=True) session = UnifiedAlchemyMagicMock( data=[( [ mock.call.query(PredictionModel), mock.call.filter( PredictionModel.abbreviation == 'GDPS', PredictionModel.projection == 'latlon.15x.15') ], [prediction_model], ), ([mock.call.query(PredictionModelRunTimestamp)], [prediction_model_run])]) return session
def test_the_update_method_of_user_repository(app): """ GIVEN the UserRepository class WHEN the method update(user) is called THEN check session method calls and user data """ from app.model import UserRepository, User user_repository = UserRepository() user_repository.session = UnifiedAlchemyMagicMock() user = User(username=get_unique_username(), password="******") user_repository.session.add(user) user_repository.session.commit() # updating username_edited = get_unique_username() user.password = "******" user.username = username_edited user_repository.update(user) # user_repository.session.commit.assert_called_once_with() assert check_password_hash(user.password, "1234") assert user.username == username_edited assert user.serialize() == { 'id': str(user.id), 'username': username_edited } assert str(user) == '<User %r>' % (username_edited)
def test_the_is_invalid_method_of_user_repository_with_username_already_in_use( app): """ GIVEN the UserRepository class WHEN the method is_invalid(user) is called with a invalid user THEN check return True """ from app.model import UserRepository, User user_repository = UserRepository() user_repository.session = UnifiedAlchemyMagicMock() user = User() user.id = 1 user.username = '******' user.password = '******' user_repository.session.add(user) user_repository.session.commit() user = User() user.username = '******' is_invalid = user_repository.is_invalid(user) assert is_invalid assert {"username": "******"} in is_invalid
def test_the_is_token_revoked_method_of_user_repository(app, mocker): """ GIVEN the TokenRepository instance WHEN the is_token_revoked() method is call THEN check session method calls """ from app.model import TokenRepository, Token token_repository = TokenRepository() token_repository.session = UnifiedAlchemyMagicMock() token = Token() token.id = 1 token.jti = "27d1b1a3-45b4-4a5f-83ed-b823f5ea1dbe" token.token_type = "access" token.user_identity = "test" token.revoked = True token.expires = datetime.now() token_repository.session.add(token) token_repository.session.commit() decoded_token = mocker.MagicMock() decoded_token['jti'] = token.jti result = token_repository.is_token_revoked(decoded_token) assert result (token_repository.session.query.return_value.filter_by. assert_called_once_with(jti=decoded_token['jti']))
def test_the_authenticate_method_of_user_repository(app): """ GIVEN the UserRepository class WHEN the method authenticate(username, password) is called THEN check the method returning """ from app.model import UserRepository, User user_repository = UserRepository() user_repository.session = UnifiedAlchemyMagicMock() user = User(username=get_unique_username(), password=generate_password_hash("123")) user_repository.session.add(user) user_repository.session.commit() # correct data result = user_repository.authenticate(user.username, "123") assert result # wrong password result = user_repository.authenticate(user.username, "1234") assert not result # wrong username result = user_repository.authenticate("wrong_username", "123") assert result
def test_the_is_invalid_method_of_user_repository_with_corrent_data_of_existent_user( app): """ GIVEN the UserRepository class WHEN the method is_invalid(user) is called with a valid user THEN check return True """ from app.model import UserRepository, User user_repository = UserRepository() user_repository.session = UnifiedAlchemyMagicMock() user = User() user.id = 1 user.username = '******' user.password = '******' user_repository.session.add(user) user_repository.session.commit() # update user.username = '******' user.password = '******' is_invalid = user_repository.is_invalid(user) assert not is_invalid
def test_get_review(client): DB.session = UnifiedAlchemyMagicMock() rsp = client.get( "/get_review/review_abc", content_type="application/json", ) assert rsp.status_code == 404
def setup_repo(self, mocker): store = mocker.patch('experimentum.Storage.SQLAlchemy.Store') store.session = UnifiedAlchemyMagicMock() Repository.__relationships__ = {} repo = Repository() Repository.store = store repo.store = store return repo
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_select_task(self): session = UnifiedAlchemyMagicMock() data = { "selectedTask": ["Landing Page"], "email": "jake", } with mock.patch("app.db.session", session): app.on_select_task(data) session.query.assert_called_once()
def test_app_on_connect(self, mocked_flask): session = UnifiedAlchemyMagicMock() for test in self.test_on_stroke_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): app.on_drawing_stroke(test[KEY_INPUT][KEY_DATA]) self.assertDictEqual(self.hold, test[KEY_EXPECTED])
def setup_method(self): # Replace server functions with mocks server.preprocess_str2vec = mock_preprocess_str2vec # Push app context for every test ctx = app.app_context() ctx.push() # Create fake resources self.q_classes = 12 self.mock_data = pd.Series(["text{}".format(_) for _ in range(10)]) self.mock_ids = np.array(range(10)) self.mock_database_connection = UnifiedAlchemyMagicMock() self.mock_model = MockCombinedClassifierWrapper( q_classes=self.q_classes) # Assign to app context global g.con = self.mock_database_connection g.data = self.mock_data g.ids = self.mock_ids g.multilabel_model = self.mock_model self.not_dict_input = "this is a string" self.sent = { "GenSendID": 0, "Overskrift": "arbejde med strøm", "NoteProjektBeskriv": "strømarbejde", "NoteForudsaet": "hz", "NoteSafetyK": "strøm", } self.junk = { "GenSendID": 0, "Overskrift": "a", "NoteProjektBeskriv": "b", "NoteForudsaet": "c", "NoteSafetyK": "d", } self.empty = { "GenSendID": 0, "Overskrift": " ", "NoteProjektBeskriv": "", "NoteForudsaet": "\n", "NoteSafetyK": "\n\n", } self.half_empty = { "GenSendID": 0, "Overskrift": "abc", "NoteProjektBeskriv": " ", "NoteForudsaet": " ", "NoteSafetyK": "", }
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 mock_database_session(monkeypatch): """ Mock out the database session. """ session = UnifiedAlchemyMagicMock() # pylint: disable=unused-argument def mock_get_session(*args): """ Return a mock database session """ logger.info('MOCK database session') return session monkeypatch.setattr(app.db.database, 'get_session', mock_get_session) return session
class TestCrud(TestCase): def setUp(self): self.sess = UnifiedAlchemyMagicMock() def test_simple_create(self): mock_qs = views_schema.Queryset(name="foobar", loa="priogrid_month", operations=[]) crud.create_queryset(self.sess, mock_qs) result = self.sess.query(models.Queryset).all() self.assertEqual(len(result), 1) def test_create(self): queryset = views_schema.Queryset( name="my_queryset", loa="country_month", themes=["my_theme", "my_other_theme"], operations=[ [ views_schema.Operation( namespace="trf", name="operation.my_transform", arguments=[10], ), views_schema.Operation(namespace="base", name="priogrid_month.my_variable", arguments=["max"]) ], [ views_schema.Operation(namespace="base", name="country_month.my_variable", arguments=["values"]) ], ]) crud.create_queryset(self.sess, queryset) result = self.sess.query(models.Queryset).all() self.assertEqual(len(result), 1)