def test_move_sms_from_folder_to_folder(self):
# add a thread to inbox_folder
t = self.provider.add_thread(
Thread(get_tz_aware_now(), '+3643445333', folder=inbox_folder))
# add two sms to t1
sms1 = self.provider.add_sms(
Message(number='+3443545333', text='test_list_sms',
_datetime=get_tz_aware_now(), thread=t))
sms2 = self.provider.add_sms(
Message(number='+3443545333', text='test_list_sms 2',
_datetime=get_tz_aware_now(), thread=t))
# sms1 and sms2 should be present in thread
messages = list(self.provider.list_from_thread(t))
self.assertIn(sms1, messages)
self.assertIn(sms2, messages)
# now create a new folder and move sms2 there
folder = self.provider.add_folder(Folder("Test 6"))
self.provider.move_to_folder(sms2, folder)
# now only sms1 should be present in original thread
inbox_messages = list(self.provider.list_from_thread(t))
new_thread = list(self.provider.list_from_folder(folder))[0]
folder_messages = list(self.provider.list_from_thread(new_thread))
self.assertIn(sms1, inbox_messages)
self.assertNotIn(sms2, inbox_messages)
# and sms2 should be present in folder_messages
self.assertIn(sms2, folder_messages)
self.assertNotIn(sms1, folder_messages)
# leave it as we found it
self.provider.delete_folder(folder)
self.provider.delete_thread(t)
def test_delete_thread_with_sms_attached(self):
# add a thread to inbox
t = self.provider.add_thread(
Thread(get_tz_aware_now(), '+3443545332', folder=inbox_folder))
# add a message attached to that thread and make sure its present
sms = self.provider.add_sms(
Message(number='+3443545332', text='how is it going then?',
_datetime=get_tz_aware_now(), thread=t))
self.assertIn(sms, list(self.provider.list_sms()))
# delete the thread and both the thread and SMS should be gone
self.provider.delete_thread(t)
self.assertNotIn(sms, list(self.provider.list_sms()))
def test_list_threads(self):
# add two threads to the inbox folder
t1 = self.provider.add_thread(
Thread(get_tz_aware_now(), '+3643445333', folder=inbox_folder))
t2 = self.provider.add_thread(
Thread(get_tz_aware_now(), '+3443545333', folder=inbox_folder))
# make sure they are present if we list them
threads = list(self.provider.list_threads())
self.assertIn(t1, threads)
self.assertIn(t2, threads)
# leave it as we found it
self.provider.delete_thread(t1)
self.provider.delete_thread(t2)
def test_delete_sms(self):
# add a thread to inbox
t = self.provider.add_thread(
Thread(get_tz_aware_now(), '+3443545333', folder=inbox_folder))
# add a message attached to that thread and make sure its present
sms = self.provider.add_sms(
Message(number='+3443545333', text='how is it going then?',
_datetime=get_tz_aware_now(), thread=t))
self.assertIn(sms, list(self.provider.list_sms()))
# delete it and make sure its gone
self.provider.delete_sms(sms)
self.assertNotIn(sms, list(self.provider.list_sms()))
# leave it as we found it
self.provider.delete_thread(t)
def test_list_from_folder(self):
# add a folder and attach a thread to it
folder = self.provider.add_folder(Folder("Test 3"))
t = self.provider.add_thread(
Thread(get_tz_aware_now(), '+3443545333', folder=folder))
# add a thread attached to inbox
t2 = self.provider.add_thread(
Thread(get_tz_aware_now(), '+3443545333', folder=inbox_folder))
# t should be present in threads, but not t2
threads = list(self.provider.list_from_folder(folder))
self.assertIn(t, threads)
self.assertNotIn(t2, threads)
# leave it as we found it
self.provider.delete_folder(folder)
self.provider.delete_thread(t2)
def test_update_sms_flags(self):
"""test that update_sms_flags works as expected"""
# add a thread to inbox_folder
number = '+3243242323'
t = self.provider.add_thread(
Thread(get_tz_aware_now(), number, folder=inbox_folder))
# add one sms to t1
sms1 = self.provider.add_sms(
Message(number=number, text='test_update_sms_flags',
_datetime=get_tz_aware_now(), thread=t))
self.assertEqual(sms1.flags, READ)
# now mark sms1 as unread
sms1 = self.provider.update_sms_flags(sms1, UNREAD)
self.assertEqual(sms1.flags, UNREAD)
# leave it as we found it
self.provider.delete_thread(t)
def test_list_sms(self):
# add a thread to inbox and attach a couple of messages to it
t = self.provider.add_thread(
Thread(get_tz_aware_now(), '+3443545333', folder=inbox_folder))
sms1 = self.provider.add_sms(
Message(number='+3443545333', text='test_list_sms',
_datetime=get_tz_aware_now(), thread=t))
sms2 = self.provider.add_sms(
Message(number='+3443545333', text='test_list_sms',
_datetime=get_tz_aware_now(), thread=t))
# sms1 and sms2 should be present in messages
messages = list(self.provider.list_sms())
self.assertIn(sms1, messages)
self.assertIn(sms2, messages)
# leave it as we found it
self.provider.delete_thread(t)
def test_list_from_thread(self):
"""test for list_from_thread"""
t = self.provider.add_thread(
Thread(get_tz_aware_now(), '+3443545333', folder=inbox_folder))
sms1 = self.provider.add_sms(
Message(number='+3443545333', text='test_list_from_thread sms1',
_datetime=get_tz_aware_now(), thread=t))
sms2 = self.provider.add_sms(
Message(number='+3443545333', text='test_list_from_thread sms2',
_datetime=get_tz_aware_now(), thread=t))
# sms1 and sms2 should be present in messages
messages = list(self.provider.list_from_thread(t))
self.assertIn(sms1, messages)
self.assertIn(sms2, messages)
# leave it as we found it
self.provider.delete_thread(t)
def test_add_sms(self):
sms = Message('+3243243223', 'hey how are you?',
_datetime=get_tz_aware_now())
sms = self.provider.add_sms(sms)
self.assertIn(sms, list(self.provider.list_sms()))
# leave everything as found
self.provider.delete_sms(sms)
self.assertNotIn(sms, list(self.provider.list_sms()))
def test_delete_folder_with_threads_attached(self):
# add a folder
folder = self.provider.add_folder(Folder("Test 2"))
self.assertIn(folder, list(self.provider.list_folders()))
# attach a couple of threads to the folder
t1 = self.provider.add_thread(
Thread(get_tz_aware_now(), '+322323233', index=5, folder=folder))
t2 = self.provider.add_thread(
Thread(get_tz_aware_now(), '+322323233', index=6, folder=folder))
# make sure they appear
self.assertIn(t1, list(self.provider.list_threads()))
self.assertIn(t2, list(self.provider.list_threads()))
# delete the folder and threads should be gone
self.provider.delete_folder(folder)
self.assertNotIn(folder, list(self.provider.list_folders()))
self.assertNotIn(t1, list(self.provider.list_threads()))
self.assertNotIn(t2, list(self.provider.list_threads()))
def test_add_usage_item(self):
now = get_tz_aware_now()
later = now + timedelta(minutes=30)
umts, bytes_recv, bytes_sent = True, 12345460, 12333211
item = self.provider.add_usage_item(now, later, bytes_recv,
bytes_sent, umts)
usage_items = self.provider.get_usage_for_day(date.today())
self.assertIn(item, usage_items)
self.provider.delete_usage_item(item)
def test_delete_thread(self):
# add a thread to inbox and make sure its there
t = self.provider.add_thread(
Thread(get_tz_aware_now(), '+3443545333', index=3,
folder=inbox_folder))
self.assertIn(t, list(self.provider.list_threads()))
# delete it and make sure its gone
self.provider.delete_thread(t)
self.assertNotIn(t, list(self.provider.list_threads()))
def test_delete_usage_item(self):
now = get_tz_aware_now()
later = now + timedelta(minutes=60)
umts, bytes_recv, bytes_sent = True, 12345470, 12333212
item = self.provider.add_usage_item(now, later, bytes_recv,
bytes_sent, umts)
usage_items = self.provider.get_usage_for_day(date.today())
self.assertIn(item, usage_items)
self.provider.delete_usage_item(item)
# now check that it is indeed gone
usage_items = self.provider.get_usage_for_day(date.today())
self.assertNotIn(item, usage_items)
def test_get_tz_aware_mtime(self):
text = os.urandom(2000)
path = 'mtime.test'
fobj = open(path, 'w')
fobj.write(text)
fobj.close()
now1 = get_tz_aware_now()
now2 = get_tz_aware_mtime(path)
self.assertNotEqual(now2.tzinfo, None)
self.failIf(abs(now2 - now1).seconds > 5)
# tidy up
os.remove(path)
def test_move_thread_from_folder_to_folder(self):
# add a thread to inbox_folder and check its present
t1 = self.provider.add_thread(
Thread(get_tz_aware_now(), '+3643445333', folder=inbox_folder))
threads = list(self.provider.list_from_folder(inbox_folder))
self.assertIn(t1, threads)
# create a new folder, move t1 to it and check its there
folder = self.provider.add_folder(Folder("Test 4"))
self.provider.move_to_folder(t1, folder)
threads = list(self.provider.list_from_folder(folder))
self.assertIn(t1, threads)
self.provider.delete_folder(folder)
# leave it as we found it
threads = list(self.provider.list_threads())
self.assertNotIn(t1, threads)
def test_get_usage_for_day(self):
# add one usage item for today (45m)
now1 = get_tz_aware_now()
later1 = now1 + timedelta(minutes=45)
umts1, bytes_recv1, bytes_sent1 = True, 1200034, 124566
item1 = self.provider.add_usage_item(now1, later1, bytes_recv1,
bytes_sent1, umts1)
# add another usage item for today (17m) 55 minutes later
now2 = get_tz_aware_now() + timedelta(minutes=55)
later2 = now1 + timedelta(minutes=17)
umts2, bytes_recv2, bytes_sent2 = True, 12000, 1245
item2 = self.provider.add_usage_item(now2, later2, bytes_recv2,
bytes_sent2, umts2)
# add another usage item for tomorrow (25m)
now3 = get_tz_aware_now() + timedelta(days=1)
later3 = now3 + timedelta(minutes=25)
umts3, bytes_recv3, bytes_sent3 = True, 14000, 1785
item3 = self.provider.add_usage_item(now3, later3, bytes_recv3,
bytes_sent3, umts3)
# now get the usage for today
today_items = self.provider.get_usage_for_day(date.today())
self.assertIn(item1, today_items)
self.assertIn(item2, today_items)
self.assertNotIn(item3, today_items)
# get the usage for tomorrow
tomorrow = date.today() + timedelta(days=1)
tomorrow_items = self.provider.get_usage_for_day(tomorrow)
self.assertNotIn(item1, tomorrow_items)
self.assertNotIn(item2, tomorrow_items)
self.assertIn(item3, tomorrow_items)
# leave it as we found it
for i in [item1, item2, item3]:
self.provider.delete_usage_item(i)
def test_list_from_folder_and_the_results_order(self):
"""test that list_from_folder returns a correctly ordered result"""
now = get_tz_aware_now()
five_min_ago = now - timedelta(minutes=5)
# add a couple of threads to inbox_folder, one of them
# just got updated/created and the other five minuts ago
t = self.provider.add_thread(
Thread(now, '+3443545333', folder=inbox_folder))
t2 = self.provider.add_thread(
Thread(five_min_ago, '+3443545331', folder=inbox_folder))
# if we list from inbox, t should appear before t2
threads = list(self.provider.list_from_folder(inbox_folder))
self.assertEqual(threads[0], t)
self.assertEqual(threads[1], t2)
# leave it as we found it
self.provider.delete_thread(t)
self.provider.delete_thread(t2)
def get_thread_by_number(self, number, folder=inbox_folder):
"""
Returns the :class:`Thread` that belongs to ``number`` under ``folder``
:rtype: :class:`Thread`
"""
c = self.conn.cursor()
sql = "select * from thread where number like ? and folder_id=?"
c.execute(sql, ("%%%s%%" % number, folder.index))
if c.rowcount == 1:
# there already exists a thread for this number under folder
return Thread.from_row(c.fetchone())
elif c.rowcount < 1:
# create thread for this number
thread = Thread(get_tz_aware_now(), number, folder=folder)
return self.add_thread(thread)
elif c.rowcount > 1:
raise DBError("Too many threads associated to number %s" % number)
raise DBError("No thread found for number %s" % number)
def test_list_from_thread_and_the_results_order(self):
"""test that list_from_thread returns a correctly ordered result"""
number = '+3443545333'
now = get_tz_aware_now()
five_min_ago = now - timedelta(minutes=5)
# add a thread and attach two messages to it, one just sent
# and the other is five minutes older
t = self.provider.add_thread(
Thread(now, number, folder=inbox_folder))
sms1 = self.provider.add_sms(
Message(number=number, text='test_list_from_thread sms1',
_datetime=now, thread=t))
sms2 = self.provider.add_sms(
Message(number=number, text='test_list_from_thread sms2',
_datetime=five_min_ago, thread=t))
# sms1 and sms2 should be present in messages
messages = list(self.provider.list_from_thread(t))
self.assertEqual(messages[0], sms1)
self.assertEqual(messages[1], sms2)
# leave it as we found it
self.provider.delete_thread(t)
def from_pdu(cls, pdu):
"""
Converts ``pdu`` to a :class:`Message` object
:param pdu: The PDU to convert
:rtype: ``Message``
"""
ret = SmsDeliver(pdu).data
if 'date' not in ret:
# XXX: Should we really fake a date?
_datetime = get_tz_aware_now()
else:
# SmsDeliver dates are UTC but naive
_datetime = ret['date'].replace(tzinfo=timezone('UTC'))
m = cls(ret['number'], _datetime=_datetime, csca=ret['csca'],
ref=ret.get('ref'), cnt=ret.get('cnt'), seq=ret.get('seq', 0),
fmt=ret.get('fmt'))
m.type = ret.get('type')
m.add_text_fragment(ret['text'], ret.get('seq', 0))
return m
def test_get_tz_aware_now(self):
now1 = get_tz_aware_now()
now2 = datetime.now(timezone('Europe/Paris'))
self.assertNotEqual(now1.tzinfo, None)
self.failIf(abs(now2 - now1).seconds > 5)
