def test_update_users(self, update_mock):
alice = User(('Alice', 0, 0, '{}'))
bob = User(('Bob', 4, 1, '{}'))
dan = User(('Dan', 5, 5, '{}'))
users = {
'Alice': alice,
'Bob': bob,
'Dan': dan,
}
def get_user_from_id_return_values(user_id):
return users[user_id]
self.db_mock.get_all_unnotified_users.return_value = [alice, bob, dan]
self.db_mock.get_user_from_id.side_effect = get_user_from_id_return_values
self.db_mock.get_latest_spoiler_id.return_value = 5
calls = [mock.call(alice), mock.call(bob)]
webhook.update_users()
update_mock.assert_has_calls(calls, any_order=True)
self.assertEqual(update_mock.call_count, len(calls))
def test_get_all_users(self):
mock_users = [
User(('Alice', 0, 0, '{}')),
User(('Bob', 1, 1, '{}')),
User(('Carol', 2, 2, '{}')),
]
for user in mock_users:
self.insert_user(user)
self.assertCountEqual(mock_users, self.test_db.get_all_users())
def test_handle_message_send_when_subbed(self, spoil_mock, send_mock):
alice = User(('Alice', 5, 5, '{}'))
spoiler1 = Spoiler(('spoila', 'attach1', '2019-01-01', None))
spoiler2 = Spoiler(('spoilb', 'attach2', '2019-01-01', None))
spoiler3 = Spoiler(('spoilc', 'attach3', '2019-01-01', None))
self.db_mock.user_exists.return_value = True
self.db_mock.get_user_from_id.return_value = User(
('Alice', 5, 5, '{}'))
latest_spoiler = 8
self.db_mock.get_latest_spoiler_id.return_value = latest_spoiler
self.db_mock.get_spoilers_later_than.return_value = []
sender_psid = 1234
# no new spoilers
webhook.handle_message(sender_psid, msbot.constants.SEND_CMD)
send_mock.assert_called_once_with(
sender_psid,
webhook.text_quick_reply_response(
msbot.constants.RESP_UPDATE_UPDATED, [webhook.RECENT_BUTTON]))
# new spoilers
send_mock.reset_mock()
self.db_mock.get_spoilers_later_than.return_value = [
spoiler1,
spoiler2,
spoiler3,
]
webhook.handle_message(sender_psid, msbot.constants.SEND_CMD)
calls = [
mock.call(alice, spoiler1),
mock.call(alice, spoiler2),
mock.call(alice, spoiler3),
]
spoil_mock.assert_has_calls(calls, any_order=True)
self.assertEqual(spoil_mock.call_count, len(calls))
send_mock.assert_called_once_with(
sender_psid,
webhook.to_text_response(msbot.constants.RESP_UPDATE_COMPLETE))
self.db_mock.update_user.assert_called_once_with(
alice.user_id,
last_updated=latest_spoiler,
last_spoiled=latest_spoiler)
def test_get_all_unnotified_users(self):
alice = User(('Alice', 0, 2, '{}'))
bob = User(('Bob', 1, 0, '{}'))
carol = User(('Carol', 2, 1, '{}'))
mock_users = [alice, bob, carol]
mock_spoilers = [
Spoiler(('test1', 'attach1', None, None)),
Spoiler(('test2', 'attach2', None, None)),
]
for user in mock_users:
self.insert_user(user)
for spoiler in mock_spoilers:
self.insert_spoiler(spoiler)
self.assertCountEqual(self.test_db.get_all_unnotified_users(),
[alice, bob])
def test_handle_message_recent_when_subbed(self, spoil_mock, send_mock):
alice = User(('Alice', 8, 8, '{}'))
latest_date = '2019-02-02'
spoiler1 = Spoiler(('spoil1', 'attach1', latest_date, None))
spoiler2 = Spoiler(('spoil2', 'attach2', latest_date, None))
self.db_mock.user_exists.return_value = True
self.db_mock.get_user_from_id.return_value = User(
('Alice', 8, 8, '{}'))
latest_spoiler = 8
self.db_mock.get_latest_spoiler_id.return_value = latest_spoiler
self.db_mock.get_latest_spoiler_date.return_value = latest_date
self.db_mock.get_all_spoilers_on_date.return_value = [
spoiler1,
spoiler2,
]
sender_psid = 1234
# new spoilers
webhook.handle_message(sender_psid, msbot.constants.RECENT_CMD)
calls = [
mock.call(alice, spoiler1),
mock.call(alice, spoiler2),
]
spoil_mock.assert_has_calls(calls, any_order=True)
self.assertEqual(spoil_mock.call_count, len(calls))
send_mock.assert_called_once_with(
sender_psid,
webhook.to_text_response(
msbot.constants.RESP_LAST_SPOILER_INFO.format(
date_string=latest_date)))
self.db_mock.update_user.assert_called_once_with(
alice.user_id,
last_updated=latest_spoiler,
last_spoiled=latest_spoiler)
def test_handle_message_options_when_subbed_duplicates_on(self, send_mock):
self.db_mock.user_exists.return_value = True
options_dict = {msbot.constants.DUPLICATES: True}
sender_psid = 1234
self.db_mock.get_user_from_id.return_value = User(
(sender_psid, 0, 0, json.dumps(options_dict)))
webhook.handle_message(sender_psid, msbot.constants.OPTIONS_CMD)
send_mock.assert_called_once_with(
sender_psid,
webhook.text_quick_reply_response(
msbot.constants.RESP_OPTIONS_PROMPT.format(
duplicate_status=msbot.constants.ON),
webhook.OPTIONS_PROMPT_BUTTONS))
def test_filter_spoilers_by_user_duplicates_on(self):
options_dict = {msbot.constants.DUPLICATES: True}
options_json = json.dumps(options_dict)
test_user = User((1234, 0, 0, options_json))
spoilers = [
Spoiler(('test.jpg', 1, '2019-01-01', None)),
Spoiler(('test1.jpg', 2, '2019-01-01', None)),
Spoiler(('test2.jpg', 3, '2019-01-01', None)),
Spoiler(('other.jpg', 4, '2019-01-01', None)),
]
self.assertCountEqual(
spoilers, webhook.filter_spoilers_by_user(spoilers, test_user))
def test_send_spoiler_to(self, send_mock):
test_user = User((1234, 0, 0, '{}'))
test_spoiler = Spoiler(('test', 123456, '2019-01-01', None))
test_response = {
'attachment': {
'type': 'image',
'payload': {
'attachment_id': test_spoiler.attach_id
}
}
}
webhook.send_spoiler_to(test_user, test_spoiler)
send_mock.assert_called_once_with(test_user.user_id, test_response)
def test_handle_message_mode_when_subbed(self, send_mock):
self.db_mock.user_exists.return_value = True
sender_psid = 1234
self.db_mock.get_user_from_id.return_value = User(
('Alice', 0, 0,
json.dumps(
{msbot.constants.UPDATE_MODE:
msbot.constants.POLL_MODE_CMD})))
text = msbot.constants.RESP_MODE_PROMPT.format(
update_mode=msbot.constants.POLL_MODE_CMD)
webhook.handle_message(sender_psid, msbot.constants.MODE_CMD)
send_mock.assert_called_once_with(
sender_psid,
webhook.text_quick_reply_response(text,
webhook.UPDATE_MODE_BUTTONS))
def test_handle_message_duplicate_when_subbed_toggles_false(
self, send_mock):
self.db_mock.user_exists.return_value = True
sender_psid = 1234
self.db_mock.get_user_from_id.return_value = User(
('Alice', 0, 0, json.dumps({msbot.constants.DUPLICATES: False})))
text = msbot.constants.RESP_DUPLICATE_TOGGLE_COMPLETE.format(
duplicate_status=msbot.constants.ON)
webhook.handle_message(sender_psid, msbot.constants.DUPLICATES_CMD)
self.db_mock.update_user.assert_called_once_with(
sender_psid, options={msbot.constants.DUPLICATES: True})
send_mock.assert_called_once_with(
sender_psid,
webhook.to_text_response(
msbot.constants.RESP_DUPLICATE_TOGGLE_COMPLETE.format(
duplicate_status=msbot.constants.ON)))
def test_update_user(self):
user = User(('Alice', 0, 0, '{}'))
self.insert_user(user)
self.assertEqual(self.test_db.get_user_from_id('Alice'), user)
# last_updated
user = User(('Bob', 0, 0, '{}'))
self.insert_user(user)
self.test_db.update_user('Bob', last_updated=10)
user.last_updated = 10
self.assertEqual(self.test_db.get_user_from_id('Bob'), user)
# last_spoiled
user = User(('Carol', 0, 0, '{}'))
self.insert_user(user)
self.test_db.update_user('Carol', last_spoiled=10)
user.last_spoiled = 10
self.assertEqual(self.test_db.get_user_from_id('Carol'), user)
# options - update_mode, no previous update_mode
user = User(('Dan', 0, 0, '{}'))
self.insert_user(user)
mock_options = {
msbot.constants.UPDATE_MODE: msbot.constants.POLL_MODE_CMD
}
self.test_db.update_user('Dan', options=mock_options)
user.options.update_mode = msbot.constants.POLL_MODE_CMD
self.assertEqual(self.test_db.get_user_from_id('Dan'), user)
# options - update_mode, existing update_mode
mock_options = {
msbot.constants.UPDATE_MODE: msbot.constants.POLL_MODE_CMD
}
user = User(('Erin', 0, 0, json.dumps(mock_options)))
self.insert_user(user)
mock_options = {
msbot.constants.UPDATE_MODE: msbot.constants.ASAP_MODE_CMD
}
self.test_db.update_user('Erin', options=mock_options)
user.options.update_mode = msbot.constants.ASAP_MODE_CMD
self.assertEqual(self.test_db.get_user_from_id('Erin'), user)
# options - duplicates, no previous duplicates
user = User(('Frank', 0, 0, '{}'))
self.insert_user(user)
mock_options = {msbot.constants.DUPLICATES: False}
self.test_db.update_user('Frank', options=mock_options)
user.options.duplicates = False
self.assertEqual(self.test_db.get_user_from_id('Frank'), user)
# options - duplicates, existing duplicates
mock_options = {msbot.constants.DUPLICATES: False}
user = User(('Grace', 0, 0, json.dumps(mock_options)))
self.insert_user(user)
mock_options = {msbot.constants.DUPLICATES: True}
self.test_db.update_user('Grace', options=mock_options)
user.options.duplicates = True
self.assertEqual(self.test_db.get_user_from_id('Grace'), user)
def test_get_user_from_id(self):
user = User(('Alice', 0, 0, '{}'))
self.insert_user(user)
self.assertEqual(user, self.test_db.get_user_from_id('Alice'))
def test_update_user(self, send_update_mock, send_spoiler_mock):
spoil1 = Spoiler(('one.jpg', 'attach1', '2019-01-01', None))
spoil2 = Spoiler(('one1.jpg', 'attach2', '2019-01-01', None))
spoil3 = Spoiler(('one2.jpg', 'attach2', '2019-01-01', None))
self.db_mock.get_spoilers_later_than.return_value = [
spoil1,
spoil2,
]
# poll user duplicates on
options_dict = {msbot.constants.DUPLICATES: True}
alice = User(('Alice', 0, 0, json.dumps(options_dict)))
self.db_mock.get_latest_spoiler_id.return_value = 2
webhook.update_user(alice)
send_update_mock.assert_called_once_with(
alice.user_id, msbot.constants.RESP_UPDATE.format(num_spoilers=2))
self.db_mock.update_user.assert_called_once_with(alice.user_id,
last_updated=2)
# poll user duplicates off
send_update_mock.reset_mock()
self.db_mock.update_user.reset_mock()
options_dict = {msbot.constants.DUPLICATES: False}
alice = User(('Alice', 0, 0, json.dumps(options_dict)))
self.db_mock.get_latest_spoiler_id.return_value = 2
webhook.update_user(alice)
send_update_mock.assert_called_once_with(
alice.user_id, msbot.constants.RESP_UPDATE.format(num_spoilers=1))
self.db_mock.update_user.assert_called_once_with(alice.user_id,
last_updated=2)
# poll user duplicates off spoilers all duplicates
send_update_mock.reset_mock()
self.db_mock.update_user.reset_mock()
self.db_mock.get_spoilers_later_than.return_value = [spoil2, spoil3]
options_dict = {msbot.constants.DUPLICATES: False}
alice = User(('Alice', 0, 0, json.dumps(options_dict)))
self.db_mock.get_latest_spoiler_id.return_value = 2
webhook.update_user(alice)
send_update_mock.assert_not_called()
self.db_mock.update_user.assert_called_once_with(alice.user_id,
last_updated=2)
# asap user duplicates on
self.db_mock.update_user.reset_mock()
self.db_mock.get_spoilers_later_than.return_value = [
spoil1,
spoil2,
]
options_dict = {msbot.constants.DUPLICATES: True}
alice = User(('Alice', 0, 0, json.dumps(options_dict)))
alice.options.update_mode = msbot.constants.ASAP_MODE_CMD
webhook.update_user(alice)
calls = [
mock.call(alice, spoil1),
mock.call(alice, spoil2),
]
send_spoiler_mock.assert_has_calls(calls, any_order=True)
self.assertEqual(send_spoiler_mock.call_count, len(calls))
self.db_mock.update_user.assert_called_once_with(alice.user_id,
last_spoiled=2,
last_updated=2)
# asap user duplicates off
self.db_mock.update_user.reset_mock()
send_spoiler_mock.reset_mock()
self.db_mock.get_spoilers_later_than.return_value = [
spoil1,
spoil2,
]
options_dict = {msbot.constants.DUPLICATES: False}
alice = User(('Alice', 0, 0, json.dumps(options_dict)))
alice.options.update_mode = msbot.constants.ASAP_MODE_CMD
webhook.update_user(alice)
calls = [
mock.call(alice, spoil1),
]
send_spoiler_mock.assert_has_calls(calls, any_order=True)
self.assertEqual(send_spoiler_mock.call_count, len(calls))
self.db_mock.update_user.assert_called_once_with(alice.user_id,
last_spoiled=2,
last_updated=2)
# asap user duplicates off spoilers all duplicates
self.db_mock.update_user.reset_mock()
send_spoiler_mock.reset_mock()
self.db_mock.get_spoilers_later_than.return_value = [
spoil2,
spoil3,
]
options_dict = {msbot.constants.DUPLICATES: False}
alice = User(('Alice', 0, 0, json.dumps(options_dict)))
alice.options.update_mode = msbot.constants.ASAP_MODE_CMD
webhook.update_user(alice)
send_spoiler_mock.assert_not_called()
self.db_mock.update_user.assert_called_once_with(alice.user_id,
last_spoiled=2,
last_updated=2)
# unsupported mode
send_update_mock.reset_mock()
self.db_mock.update_user.reset_mock()
options_dict = {msbot.constants.DUPLICATES: True}
alice = User(('Alice', 0, 0, json.dumps(options_dict)))
self.db_mock.get_latest_spoiler_id.return_value = 2
alice.options.update_mode = 'UNSUPPORTED'
webhook.update_user(alice)
send_update_mock.assert_called_once_with(
alice.user_id, msbot.constants.RESP_UPDATE.format(num_spoilers=2))
self.db_mock.update_user.assert_called_once_with(alice.user_id,
last_updated=2)
def get_all_unnotified_users(self):
sql = "SELECT * FROM users WHERE last_updated < {last_spoiled}".format(last_spoiled=self.get_latest_spoiler_id())
self.query(sql)
return [ User(row) for row in self.fetchall() ]
def get_all_users(self):
sql = 'SELECT * FROM users'
self.query(sql)
return [ User(row) for row in self.fetchall() ]
def get_user_from_id(self, user_id):
sql = "SELECT * FROM users WHERE id = '{user_id}'".format(user_id=user_id)
self.query(sql)
return User(self.fetchone())
