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_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_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 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_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_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_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_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_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_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 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_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 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_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_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_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_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_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_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 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
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_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_validate_map_exception(self):
expected = []
session = UnifiedAlchemyMagicMock(data=[
(
[mock.call.query(RouteModel.id),
mock.call.filter(RouteModel.map == self.mock_data['map']),
],
expected,
),
])
route = Route(session)
with pytest.raises(ValueError, match='This map does not exists.'):
route.validate_map(self.mock_data['map'])
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])
