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_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_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)
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)
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_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_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_sendImageMessages(self):
"""test sending image messages"""
MOCKCLIENTS = TESTCLIENTS.copy()
MOCKMESSAGES = TESTMESSAGES.copy()
MOCKSESSION = UnifiedAlchemyMagicMock()
TESTMESSAGE = {
USER:'******',
ID:'003',
MESSAGE:('This is an image https://upload.wikimedia.org/wikipedia/commons/'+
'thumb/3/3e/Tokyo_Sky_Tree_2012.JPG/220px-Tokyo_Sky_Tree_2012.jpg'),
}
EXPECTEDMESSAGES = [
MOCKMESSAGES[0],
MOCKMESSAGES[1],
MOCKMESSAGES[2],
{
USER:'******',
MESSAGE:("This is an image <img src='https://upload.wikimedia.org/wikipedia/"+
"commons/thumb/3/3e/Tokyo_Sky_Tree_2012.JPG/220px-Tokyo_Sky_Tree_2012.jpg'"+
" class='msgImg'/> "),
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_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)
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_send_bot_messages_with_unknown_results(self):
"""test sending complex bot messages"""
BOT_COMMANDS = ['!! flip', '!! funtranslate I like apples.']
BOT_RESPONSES = [
[
'The coin landed HEADS up',
'The coin landed TAILS up'
],
[
'I-way ike-lay apples-way.',
'Sorry the limit for translations has been reached'
]
]
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][0],
TIMESTAMP: datetime.now(TIME_ZONE).strftime("%H:%M %m/%d/%y")
}
],[
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][1],
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.assertTrue((response[DATA][MESSAGES] == EXPECTEDMESSAGES[0])
or (response[DATA][MESSAGES] == EXPECTEDMESSAGES[1]))
MOCKDB = MOCKSESSION.query(models.Messages).all()
for i in range(0,len(MOCKDB)):
self.assertEqual(MOCKDB[i].name, EXPECTEDMESSAGES[0][i][USER])
self.assertTrue((MOCKDB[i].message==EXPECTEDMESSAGES[0][i][MESSAGE]
or MOCKDB[i].message==EXPECTEDMESSAGES[1][i][MESSAGE]))
self.assertEqual(MOCKDB[i].time, EXPECTEDMESSAGES[0][i][TIMESTAMP])
def test_get_none(self):
session = UnifiedAlchemyMagicMock()
result = session.query(Token).all()
return self.assertEqual(len(result), 0)
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_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)
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)
