def test_successful_group_add(self):
# Setup
group_list = GroupList(groups=['testgroup'])
contact_list = ContactList(
nicks=["contact_{}".format(n) for n in range(21)])
group = group_list.get_group('testgroup')
group.members = contact_list.contacts[:19]
settings = Settings()
queues = {COMMAND_PACKET_QUEUE: Queue(), MESSAGE_PACKET_QUEUE: Queue()}
o_input = builtins.input
builtins.input = lambda x: 'Yes'
# Test
m_to_add = ["*****@*****.**"]
self.assertIsNone(
group_add_member('testgroup', m_to_add, group_list, contact_list,
settings, queues))
group2 = group_list.get_group('testgroup')
self.assertEqual(len(group2), 20)
for c in group2:
self.assertIsInstance(c, Contact)
self.assertEqual(queues[COMMAND_PACKET_QUEUE].qsize(), 1)
self.assertEqual(queues[MESSAGE_PACKET_QUEUE].qsize(), 20)
# Teardown
builtins.input = o_input
while not queues[COMMAND_PACKET_QUEUE].empty():
queues[COMMAND_PACKET_QUEUE].get()
while not queues[COMMAND_PACKET_QUEUE].empty():
queues[MESSAGE_PACKET_QUEUE].get()
time.sleep(0.2)
def test_successful_group_add(self) -> None:
# Setup
contact_list = ContactList(nicks=[str(n) for n in range(21)])
group_lst = GroupList(groups=['test_group'])
group = group_lst.get_group('test_group')
group.members = contact_list.contacts[:19]
cmd_data = group_name_to_group_id('test_group') + nick_to_pub_key('20')
# Test
self.assertIsNone(group_add(cmd_data, self.ts, self.window_list, contact_list, group_lst, self.settings))
group2 = group_lst.get_group('test_group')
self.assertEqual(len(group2), 20)
for c in group2:
self.assertIsInstance(c, Contact)
class TestGroupRemove(TFCTestCase):
def setUp(self) -> None:
"""Pre-test actions."""
self.ts = datetime.datetime.now()
self.window_list = WindowList()
self.contact_list = ContactList(nicks=[f"contact_{n}" for n in range(21)])
self.group_list = GroupList(groups=['test_group'])
self.group = self.group_list.get_group('test_group')
self.group.members = self.contact_list.contacts[:19]
self.settings = Settings()
def test_unknown_group_id_raises_soft_error(self) -> None:
# Setup
group_list = GroupList(groups=['test_group'])
contact_list = ContactList(nicks=[str(n) for n in range(21)])
cmd_data = group_name_to_group_id('test_group2') + nick_to_pub_key('20')
# Test
self.assert_se("Error: No group with ID '2e7mHQznTMsP6' found.",
group_remove, cmd_data, self.ts, self.window_list, contact_list, group_list)
def test_successful_member_removal(self) -> None:
self.cmd_data = group_name_to_group_id('test_group') + b''.join([nick_to_pub_key('contact_18'),
nick_to_pub_key('contact_20')])
self.assertIsNone(group_remove(self.cmd_data, self.ts, self.window_list, self.contact_list, self.group_list))
def test_group_msg(self):
# Setup
ts = datetime.datetime.now()
apct_list = self.create_message_apct(ORIGIN_CONTACT_HEADER,
b'testmessage',
group_name=b'testgroup')
contact_list = ContactList(nicks=['Alice', 'Bob', 'local'])
key_list = KeyList(nicks=['Alice', 'Bob', 'local'])
keyset = key_list.get_keyset('*****@*****.**')
keyset.rx_harac = 1
keyset.rx_key = 32 * b'\x01'
keyset.rx_hek = 32 * b'\x01'
group_list = GroupList(groups=['testgroup'])
group = group_list.get_group('testgroup')
group.log_messages = True
settings = Settings()
packet_list = PacketList(contact_list=contact_list, settings=settings)
window_list = WindowList(contact_list=contact_list,
group_list=group_list,
packet_list=packet_list,
settings=settings)
master_key = MasterKey()
# Test
for p in apct_list:
self.assertIsNone(
process_message(ts, p, window_list, packet_list, contact_list,
key_list, group_list, settings, master_key))
# Teardown
cleanup()
def test_enable_logging_group(self):
# Setup
cmd_data = b'e' + US_BYTE + b'testgroup'
ts = datetime.datetime.now()
contact_list = ContactList(nicks=['Bob'])
window_list = WindowList(windows=[
RxMWindow(type='group', name='testgroup', uid='testgroup')
])
group_list = GroupList(groups=['testgroup'])
setting_type = 'L'
# Test
group_list.get_group('testgroup').log_messages = False
self.assertIsNone(
contact_setting(cmd_data, ts, window_list, contact_list,
group_list, setting_type))
self.assertTrue(group_list.get_group('testgroup').log_messages)
def test_successful_group_add(self):
# Setup
ts = datetime.datetime.now()
contact_list = ContactList(nicks=["contact_{}".format(n) for n in range(21)])
group_list = GroupList(groups=['testgroup'])
group = group_list.get_group('testgroup')
group.members = contact_list.contacts[:19]
settings = Settings()
cmd_data = US_BYTE.join([b'testgroup', b'*****@*****.**'])
window_list = WindowList()
# Test
self.assertIsNone(group_add_member(cmd_data, ts, window_list, contact_list, group_list, settings))
group2 = group_list.get_group('testgroup')
self.assertEqual(len(group2), 20)
for c in group2:
self.assertIsInstance(c, Contact)
def test_too_large_final_member_list_raises_soft_error(self) -> None:
# Setup
contact_list = ContactList(nicks=[str(n) for n in range(51)])
group_list = GroupList(groups=['testgroup'])
group = group_list.get_group('testgroup')
group.members = contact_list.contacts[:49]
# Test
m_to_add = [nick_to_pub_key("49"), nick_to_pub_key("50")]
self.assert_se("Error: TFC settings only allow 50 members per group.", group_add_member,
'testgroup', m_to_add, contact_list, group_list, self.settings, self.queues, self.master_key)
def test_class(self):
# Setup
contact_list = ContactList(['Alice'])
group_list = GroupList(groups=['testgroup'])
settings = Settings()
window = Window(contact_list, group_list)
queue_dict = {WINDOW_SELECT_QUEUE: Queue(),
COMMAND_PACKET_QUEUE: Queue()}
window.group = group_list.get_group('testgroup')
window.type = 'group'
# Test
window.name = 'testgroup'
self.assertIsNone(window.update_group_win_members(group_list))
window.name = 'testgroup2'
self.assertIsNone(window.update_group_win_members(group_list))
window.name = 'testgroup'
self.assertTrue(window.is_selected())
self.assertIsNone(window.select_tx_window(settings, queue_dict, '*****@*****.**'))
self.assertTrue(window.is_selected())
settings.session_trickle = True
window.uid = '*****@*****.**'
self.assertFR("Can't change window during trickle connection.", window.select_tx_window, settings, queue_dict, 'testgroup', cmd=True)
settings.session_trickle = False
self.assertIsNone(window.select_tx_window(settings, queue_dict, 'testgroup', cmd=True))
self.assertEqual(len(window), 2)
settings.session_trickle = True
self.assertFR("Can't change window during trickle connection.", window.select_tx_window, settings, queue_dict, '*****@*****.**', cmd=True)
self.assertFR("Error: No contact/group was found.", window.select_tx_window, settings, queue_dict, '*****@*****.**', cmd=True)
user_input = UserInput('invalid')
self.assertFR("Invalid recipient.", select_window, user_input, window, settings, queue_dict)
for c in window:
self.assertIsInstance(c, Contact)
self.assertIsNone(window.deselect())
self.assertIsNone(window.group)
self.assertIsNone(window.contact)
self.assertIsNone(window.name)
self.assertIsNone(window.type)
self.assertIsNone(window.uid)
self.assertIsNone(window.imc_name)
o_input = builtins.input
builtins.input = lambda x: '*****@*****.**'
self.assertIsNone(window.select_tx_window(settings, queue_dict))
time.sleep(1)
# Teardown
builtins.input = o_input
def test_too_large_final_member_list_raises_soft_error(self) -> None:
# Setup
group_list = GroupList(groups=['test_group'])
contact_list = ContactList(nicks=[str(n) for n in range(51)])
group = group_list.get_group('test_group')
group.members = contact_list.contacts[:50]
cmd_data = group_name_to_group_id('test_group') + nick_to_pub_key('50')
# Test
self.assert_se("Error: TFC settings only allow 50 members per group.",
group_add, cmd_data, self.ts, self.window_list, contact_list, group_list, self.settings)
def test_too_many_purp_accounts_raises_soft_error(self) -> None:
# Setup
create_list = [nick_to_pub_key(str(n)) for n in range(51)]
cmd_data = self.group_id + b'test_group' + US_BYTE + b''.join(create_list)
group_list = GroupList(groups=['test_group'])
contact_list = ContactList(nicks=[str(n) for n in range(51)])
group = group_list.get_group('test_group')
group.members = contact_list.contacts
# Test
self.assert_se("Error: TFC settings only allow 50 members per group.",
group_create, cmd_data, self.ts, self.window_list, contact_list, group_list, self.settings)
def test_successful_group_creation(self) -> None:
# Setup
group_list = GroupList(groups=['test_group'])
cmd_data = group_name_to_group_id('test_group') + b'test_group2' + US_BYTE + nick_to_pub_key('Bob')
contact_list = ContactList(nicks=['Alice', 'Bob'])
window_list = WindowList(nicks =['Alice', 'Bob'],
contact_list=contact_list,
group_lis =group_list,
packet_list =None,
settings =Settings)
# Test
self.assertIsNone(group_create(cmd_data, self.ts, window_list, contact_list, group_list, self.settings))
self.assertEqual(len(group_list.get_group('test_group')), 2)
def test_too_large_final_member_list_raises_fr(self):
# Setup
ts = datetime.datetime.now()
group_list = GroupList(groups=['testgroup'])
contact_list = ContactList(nicks=["contact_{}".format(n) for n in range(21)])
group = group_list.get_group('testgroup')
group.members = contact_list.contacts[:20]
settings = Settings()
cmd_data = US_BYTE.join([b'testgroup', b'*****@*****.**'])
window_list = WindowList()
# Test
self.assertFR("Error: TFC settings only allow 20 members per group.", group_add_member, cmd_data, ts, window_list, contact_list, group_list, settings)
def test_enable_logging_all(self):
# Setup
cmd_data = b'E'
ts = datetime.datetime.now()
contact_list = ContactList(nicks=['Alice', 'Bob', 'Charlie'])
window_list = WindowList(windows=[
RxMWindow(type='group', name='testgroup', uid='testgroup')
])
group_list = GroupList(groups=['testgroup'])
setting_type = 'L'
# Test
for c in contact_list:
c.log_messages = False
group_list.get_group('testgroup').log_messages = False
self.assertIsNone(
contact_setting(cmd_data, ts, window_list, contact_list,
group_list, setting_type))
self.assertTrue(group_list.get_group('testgroup').log_messages)
for c in contact_list:
self.assertTrue(c.log_messages)
def test_too_many_purp_accounts_raises_fr(self):
# Setup
group_list = GroupList(groups=['testgroup'])
contact_list = ContactList(
nicks=["contact_{}".format(n) for n in range(21)])
group = group_list.get_group('testgroup')
group.members = contact_list.contacts
# Test
cl_str = ["contact_{}@jabber.org".format(n) for n in range(21)]
self.assertFR("Error: TFC settings only allow 20 members per group.",
group_create, 'testgroup_21', cl_str, group_list,
contact_list, self.settings, self.queues,
self.master_key)
def test_too_large_final_member_list_raises_fr(self):
# Setup
group_list = GroupList(groups=['testgroup'])
contact_list = ContactList(
nicks=["contact_{}".format(n) for n in range(21)])
group = group_list.get_group('testgroup')
group.members = contact_list.contacts[:19]
# Test
m_to_add = ["*****@*****.**", "*****@*****.**"]
self.assertFR("Error: TFC settings only allow 20 members per group.",
group_add_member, 'testgroup', m_to_add, group_list,
contact_list, self.settings, self.queues,
self.master_key)
def test_successful_group_add(self):
# Setup
group_list = GroupList(groups=['testgroup'])
contact_list = ContactList(
nicks=["contact_{}".format(n) for n in range(21)])
group = group_list.get_group('testgroup')
group.members = contact_list.contacts[:19]
# Test
m_to_add = ["*****@*****.**"]
self.assertIsNone(
group_add_member('testgroup', m_to_add, group_list, contact_list,
self.settings, self.queues, self.master_key))
time.sleep(0.1)
group2 = group_list.get_group('testgroup')
self.assertEqual(len(group2), 20)
for c in group2:
self.assertIsInstance(c, Contact)
self.assertEqual(self.queues[COMMAND_PACKET_QUEUE].qsize(), 1)
self.assertEqual(self.queues[MESSAGE_PACKET_QUEUE].qsize(), 20)
def test_too_many_purp_accounts_raises_fr(self):
# Setup
ts = datetime.datetime.now()
cl = ["contact_{}@jabber.org".format(n).encode() for n in range(21)]
cmd_data = US_BYTE.join([b'testgroup2'] + cl)
group_list = GroupList(groups=['testgroup'])
contact_list = ContactList(nicks=["contact_{}".format(n) for n in range(21)])
group = group_list.get_group('testgroup')
group.members = contact_list.contacts
settings = Settings()
window_list = WindowList()
# Test
self.assertFR("Error: TFC settings only allow 20 members per group.", group_create, cmd_data, ts, window_list, contact_list, group_list, settings)
def test_function(self):
# Setup
cmd_data = US_BYTE.join([b'testgroup', b'*****@*****.**', b'*****@*****.**'])
ts = datetime.datetime.now()
window_list = WindowList()
contact_list = ContactList(nicks=["contact_{}".format(n) for n in range(21)])
group_list = GroupList(groups=['testgroup'])
group = group_list.get_group('testgroup')
group.members = contact_list.contacts[:19]
# Test
self.assertIsNone(group_rm_member(cmd_data, ts, window_list, contact_list, group_list))
members = [c.rx_account for c in group.members]
self.assertFalse(b'*****@*****.**' in members)
def test_successful_group_creation(self):
# Setup
group_list = GroupList(groups=['test_group'])
cmd_data = US_BYTE.join([b'test_group_2', b'*****@*****.**'])
contact_list = ContactList(nicks=['Alice', 'Bob'])
window_list = WindowList(nicks=['Alice', 'Bob'],
contact_list=contact_list,
group_lis=group_list,
packet_list=None,
settings=Settings)
# Test
self.assertIsNone(
group_create(cmd_data, self.ts, window_list, contact_list,
group_list, self.settings))
self.assertEqual(len(group_list.get_group('test_group')), 2)
class TestGroupRename(TFCTestCase):
def setUp(self):
"""Pre-test actions."""
self.queues = gen_queue_dict()
self.settings = Settings()
self.contact_list = ContactList()
self.group_list = GroupList(groups=['test_group'])
self.window = TxWindow()
self.args = self.window, self.contact_list, self.group_list, self.settings, self.queues
def tearDown(self):
"""Post-test actions."""
tear_queues(self.queues)
def test_contact_window_raises_fr(self):
# Setup
self.window.type = WIN_TYPE_CONTACT
# Test
self.assert_fr("Error: Selected window is not a group window.",
group_rename, "window", *self.args)
def test_invalid_group_name_raises_fr(self):
# Setup
self.window.type = WIN_TYPE_GROUP
self.window.group = self.group_list.get_group('test_group')
# Test
self.assert_fr("Error: Group name must be printable.", group_rename,
"window\x1f", *self.args)
@mock.patch('time.sleep', return_value=None)
def test_successful_group_change(self, _):
# Setup
group = create_group('test_group')
self.window.type = WIN_TYPE_GROUP
self.window.uid = group.group_id
self.window.group = group
# Test
self.assert_fr("Renamed group 'test_group' to 'window'.", group_rename,
"window", *self.args)
self.assertEqual(self.queues[COMMAND_PACKET_QUEUE].qsize(), 1)
class TestGroupRMMember(unittest.TestCase):
def setUp(self):
self.ts = datetime.datetime.now()
self.window_list = WindowList()
self.cmd_data = US_BYTE.join([
b'test_group', b'*****@*****.**', b'*****@*****.**'
])
self.contact_list = ContactList(
nicks=["contact_{}".format(n) for n in range(21)])
self.group_list = GroupList(groups=['test_group'])
self.group = self.group_list.get_group('test_group')
self.group.members = self.contact_list.contacts[:19]
def test_function(self):
self.assertIsNone(
group_rm_member(self.cmd_data, self.ts, self.window_list,
self.contact_list, self.group_list))
self.assertFalse(
b'*****@*****.**' in self.group.get_list_of_member_accounts())
def test_disable_notifications_for_group(self):
# Setup
user_input = UserInput('notify off')
contact_list = ContactList(nicks=['Alice'])
group_list = GroupList(groups=['testgroup'])
settings = Settings()
c_queue = Queue()
group = group_list.get_group('testgroup')
group.notifications = True
window = Window(uid='testgroup',
type='group',
group=group,
window_contacts=group.members)
# Test
self.assertTrue(group.notifications)
self.assertIsNone(
contact_setting(user_input, window, contact_list, group_list,
settings, c_queue))
time.sleep(0.2)
self.assertFalse(group.notifications)
def test_enable_logging_for_group(self):
# Setup
user_input = UserInput('logging on')
contact_list = ContactList(nicks=['Alice'])
group_list = GroupList(groups=['testgroup'])
settings = Settings()
c_queue = Queue()
group = group_list.get_group('testgroup')
group.log_messages = False
window = Window(uid='testgroup',
type='group',
group=group,
window_contacts=group.members)
# Test
self.assertFalse(group.log_messages)
self.assertIsNone(
contact_setting(user_input, window, contact_list, group_list,
settings, c_queue))
time.sleep(0.2)
self.assertTrue(group.log_messages)
def test_successful_removal_of_last_member_of_active_group(self):
# Setup
o_input = builtins.input
builtins.input = lambda x: 'Yes'
user_input = UserInput('rm Alice')
contact_list = ContactList(nicks=['Alice'])
window = Window(window_contacts=[contact_list.get_contact('Alice')],
type='group',
name='testgroup')
group_list = GroupList(groups=['testgroup'])
group = group_list.get_group('testgroup')
group.members = [contact_list.get_contact('*****@*****.**')]
settings = Settings()
queues = {KEY_MANAGEMENT_QUEUE: Queue(), COMMAND_PACKET_QUEUE: Queue()}
# Test
for g in group_list:
self.assertIsInstance(g, Group)
self.assertTrue(g.has_member('*****@*****.**'))
self.assertIsNone(
remove_contact(user_input, window, contact_list, group_list,
settings, queues))
self.assertEqual(queues[COMMAND_PACKET_QUEUE].qsize(), 1)
km_data = queues[KEY_MANAGEMENT_QUEUE].get()
self.assertEqual(km_data, ('REM', '*****@*****.**'))
self.assertFalse(contact_list.has_contact('*****@*****.**'))
for g in group_list:
self.assertIsInstance(g, Group)
self.assertFalse(g.has_member('*****@*****.**'))
# Teardown
builtins.input = o_input
queues[KEY_MANAGEMENT_QUEUE].close()
queues[COMMAND_PACKET_QUEUE].close()
def test_disable_file_reception_for_group(self):
# Setup
user_input = UserInput('store off')
contact_list = ContactList(nicks=['Alice'])
group_list = GroupList(groups=['testgroup'])
settings = Settings()
c_queue = Queue()
group = group_list.get_group('testgroup')
window = Window(uid='testgroup',
type='group',
group=group,
window_contacts=group.members)
for m in group:
m.file_reception = True
# Test
for m in group:
self.assertTrue(m.file_reception)
self.assertIsNone(
contact_setting(user_input, window, contact_list, group_list,
settings, c_queue))
time.sleep(0.2)
for m in group:
self.assertFalse(m.file_reception)
class TestChContactSetting(TFCTestCase):
def setUp(self):
self.ts = datetime.fromtimestamp(1502750000)
self.contact_list = ContactList(nicks=['Alice', 'Bob'])
self.group_list = GroupList(groups=['test_group', 'test_group2'])
self.window_list = WindowList(contact_list=self.contact_list,
group_list=self.group_list)
self.args = self.ts, self.window_list, self.contact_list, self.group_list
def test_invalid_window_raises_fr(self):
# Setup
cmd_data = ENABLE + nick_to_pub_key("Bob")
header = CH_LOGGING
self.contact_list = ContactList(nicks=['Alice'])
self.window_list = WindowList(contact_list=self.contact_list,
group_list=self.group_list)
# Test
self.assert_fr(f"Error: Found no window for '{nick_to_short_address('Bob')}'.",
ch_contact_s, cmd_data, *self.args, header)
def test_setting_change_contact(self):
# Setup
self.window = self.window_list.get_window(nick_to_pub_key("Bob"))
self.window.type = WIN_TYPE_CONTACT
self.window.type_print = 'contact'
self.window.window_contacts = self.contact_list.contacts
bob = self.contact_list.get_contact_by_address_or_nick("Bob")
# Test
for attr, header in [('log_messages', CH_LOGGING),
('notifications', CH_NOTIFY),
('file_reception', CH_FILE_RECV)]:
for s in [ENABLE, ENABLE, DISABLE, DISABLE]:
cmd_data = s + nick_to_pub_key("Bob")
self.assertIsNone(ch_contact_s(cmd_data, *self.args, header))
self.assertEqual(bob.__getattribute__(attr), (s == ENABLE))
def test_setting_change_group(self):
# Setup
self.window = self.window_list.get_window(group_name_to_group_id('test_group'))
self.window.type = WIN_TYPE_GROUP
self.window.type_print = 'group'
self.window.window_contacts = self.group_list.get_group('test_group').members
# Test
for attr, header in [('log_messages', CH_LOGGING),
('notifications', CH_NOTIFY),
('file_reception', CH_FILE_RECV)]:
for s in [ENABLE, ENABLE, DISABLE, DISABLE]:
cmd_data = s + group_name_to_group_id('test_group')
self.assertIsNone(ch_contact_s(cmd_data, *self.args, header))
if header in [CH_LOGGING, CH_NOTIFY]:
self.assertEqual(self.group_list.get_group('test_group').__getattribute__(attr), (s == ENABLE))
if header == CH_FILE_RECV:
for m in self.group_list.get_group('test_group').members:
self.assertEqual(m.file_reception, (s == ENABLE))
def test_setting_change_all(self):
# Setup
self.window = self.window_list.get_window(nick_to_pub_key("Bob"))
self.window.type = WIN_TYPE_CONTACT
self.window.type_print = 'contact'
self.window.window_contacts = self.contact_list.contacts
# Test
for attr, header in [('log_messages', CH_LOGGING),
('notifications', CH_NOTIFY),
('file_reception', CH_FILE_RECV)]:
for s in [ENABLE, ENABLE, DISABLE, DISABLE]:
cmd_data = s.upper() + US_BYTE
self.assertIsNone(ch_contact_s(cmd_data, *self.args, header))
if header in [CH_LOGGING, CH_NOTIFY]:
for c in self.contact_list.get_list_of_contacts():
self.assertEqual(c.__getattribute__(attr), (s == ENABLE))
for g in self.group_list.groups:
self.assertEqual(g.__getattribute__(attr), (s == ENABLE))
if header == CH_FILE_RECV:
for c in self.contact_list.get_list_of_contacts():
self.assertEqual(c.__getattribute__(attr), (s == ENABLE))
class TestContactSetting(TFCTestCase):
def setUp(self) -> None:
"""Pre-test actions."""
self.contact_list = ContactList(nicks=['Alice', 'Bob'])
self.group_list = GroupList(groups=['test_group'])
self.settings = Settings()
self.queues = gen_queue_dict()
self.pub_key = nick_to_pub_key("Alice")
self.args = self.contact_list, self.group_list, self.settings, self.queues
def tearDown(self) -> None:
"""Post-test actions."""
tear_queues(self.queues)
def test_invalid_command_raises_soft_error(self) -> None:
self.assert_se("Error: Invalid command.", contact_setting, UserInput('loging on'), None, *self.args)
def test_missing_parameter_raises_soft_error(self) -> None:
self.assert_se("Error: Invalid command.", contact_setting, UserInput(''), None, *self.args)
def test_invalid_extra_parameter_raises_soft_error(self) -> None:
self.assert_se("Error: Invalid command.", contact_setting, UserInput('logging on al'), None, *self.args)
def test_enable_logging_for_user(self) -> None:
# Setup
contact = self.contact_list.get_contact_by_address_or_nick('Alice')
contact.log_messages = False
window = TxWindow(uid=self.pub_key,
type=WIN_TYPE_CONTACT,
contact=contact)
# Test
self.assertFalse(contact.log_messages)
self.assertIsNone(contact_setting(UserInput('logging on'), window, *self.args))
self.assertEqual(self.queues[COMMAND_PACKET_QUEUE].qsize(), 1)
self.assertEqual(self.queues[LOG_SETTING_QUEUE].qsize(), 0)
self.assertTrue(contact.log_messages)
def test_enable_logging_for_user_during_traffic_masking(self) -> None:
# Setup
contact = self.contact_list.get_contact_by_address_or_nick('Alice')
contact.log_messages = False
window = TxWindow(uid=self.pub_key,
type=WIN_TYPE_CONTACT,
contact=contact,
log_messages=False)
self.settings.traffic_masking = True
# Test
self.assertFalse(contact.log_messages)
self.assertFalse(window.log_messages)
self.assertIsNone(contact_setting(UserInput('logging on'), window, *self.args))
self.assertEqual(self.queues[TM_COMMAND_PACKET_QUEUE].qsize(), 1)
self.assertTrue(self.queues[LOG_SETTING_QUEUE].get())
self.assertTrue(window.log_messages)
self.assertTrue(contact.log_messages)
def test_enable_logging_for_group(self) -> None:
# Setup
group = self.group_list.get_group('test_group')
group.log_messages = False
window = TxWindow(uid=group_name_to_group_id('test_group'),
type=WIN_TYPE_GROUP,
group=group,
window_contacts=group.members)
# Test
self.assertFalse(group.log_messages)
self.assertIsNone(contact_setting(UserInput('logging on'), window, *self.args))
self.assertTrue(group.log_messages)
def test_enable_logging_for_all_users(self) -> None:
# Setup
contact = self.contact_list.get_contact_by_address_or_nick("Alice")
window = TxWindow(uid=self.pub_key,
type=WIN_TYPE_CONTACT,
contact=contact,
window_contacts=[contact])
for c in self.contact_list:
c.log_messages = False
for g in self.group_list:
g.log_messages = False
# Test
for c in self.contact_list:
self.assertFalse(c.log_messages)
for g in self.group_list:
self.assertFalse(g.log_messages)
self.assertIsNone(contact_setting(UserInput('logging on all'), window, *self.args))
for c in self.contact_list:
self.assertTrue(c.log_messages)
for g in self.group_list:
self.assertTrue(g.log_messages)
def test_disable_logging_for_user(self) -> None:
# Setup
contact = self.contact_list.get_contact_by_address_or_nick('Alice')
contact.log_messages = True
window = TxWindow(uid=self.pub_key,
type=WIN_TYPE_CONTACT,
contact=contact,
window_contacts=[contact])
# Test
self.assertTrue(contact.log_messages)
self.assertIsNone(contact_setting(UserInput('logging off'), window, *self.args))
self.assertFalse(contact.log_messages)
def test_disable_logging_for_group(self) -> None:
# Setup
group = self.group_list.get_group('test_group')
group.log_messages = True
window = TxWindow(uid=group_name_to_group_id('test_group'),
type=WIN_TYPE_GROUP,
group=group,
window_contacts=group.members)
# Test
self.assertTrue(group.log_messages)
self.assertIsNone(contact_setting(UserInput('logging off'), window, *self.args))
self.assertFalse(group.log_messages)
def test_disable_logging_for_all_users(self) -> None:
# Setup
contact = self.contact_list.get_contact_by_address_or_nick("Alice")
window = TxWindow(uid=self.pub_key,
type=WIN_TYPE_CONTACT,
contact=contact,
window_contacts=[contact])
for c in self.contact_list:
c.log_messages = True
for g in self.group_list:
g.log_messages = True
# Test
for c in self.contact_list:
self.assertTrue(c.log_messages)
for g in self.group_list:
self.assertTrue(g.log_messages)
self.assertIsNone(contact_setting(UserInput('logging off all'), window, *self.args))
for c in self.contact_list:
self.assertFalse(c.log_messages)
for g in self.group_list:
self.assertFalse(g.log_messages)
def test_enable_file_reception_for_user(self) -> None:
# Setup
contact = self.contact_list.get_contact_by_address_or_nick('Alice')
contact.file_reception = False
window = TxWindow(uid=self.pub_key,
type=WIN_TYPE_CONTACT,
contact=contact,
window_contacts=[contact])
# Test
self.assertFalse(contact.file_reception)
self.assertIsNone(contact_setting(UserInput('store on'), window, *self.args))
self.assertTrue(contact.file_reception)
def test_enable_file_reception_for_group(self) -> None:
# Setup
group = self.group_list.get_group('test_group')
window = TxWindow(uid=group_name_to_group_id('test_group'),
type=WIN_TYPE_GROUP,
group=group,
window_contacts=group.members)
for m in group:
m.file_reception = False
# Test
for m in group:
self.assertFalse(m.file_reception)
self.assertIsNone(contact_setting(UserInput('store on'), window, *self.args))
for m in group:
self.assertTrue(m.file_reception)
def test_enable_file_reception_for_all_users(self) -> None:
# Setup
contact = self.contact_list.get_contact_by_address_or_nick("Alice")
window = TxWindow(uid=self.pub_key,
type=WIN_TYPE_CONTACT,
contact=contact,
window_contacts=[contact])
for c in self.contact_list:
c.file_reception = False
# Test
for c in self.contact_list:
self.assertFalse(c.file_reception)
self.assertIsNone(contact_setting(UserInput('store on all'), window, *self.args))
for c in self.contact_list:
self.assertTrue(c.file_reception)
def test_disable_file_reception_for_user(self) -> None:
# Setup
contact = self.contact_list.get_contact_by_address_or_nick('Alice')
contact.file_reception = True
window = TxWindow(uid=self.pub_key,
type=WIN_TYPE_CONTACT,
contact=contact,
window_contacts=[contact])
# Test
self.assertTrue(contact.file_reception)
self.assertIsNone(contact_setting(UserInput('store off'), window, *self.args))
self.assertFalse(contact.file_reception)
def test_disable_file_reception_for_group(self) -> None:
# Setup
group = self.group_list.get_group('test_group')
window = TxWindow(uid=group_name_to_group_id('test_group'),
type=WIN_TYPE_GROUP,
group=group,
window_contacts=group.members)
for m in group:
m.file_reception = True
# Test
for m in group:
self.assertTrue(m.file_reception)
self.assertIsNone(contact_setting(UserInput('store off'), window, *self.args))
for m in group:
self.assertFalse(m.file_reception)
def test_disable_file_reception_for_all_users(self) -> None:
# Setup
contact = self.contact_list.get_contact_by_address_or_nick("Alice")
window = TxWindow(uid=self.pub_key,
type=WIN_TYPE_CONTACT,
contact=contact,
window_contacts=[contact])
for c in self.contact_list:
c.file_reception = True
# Test
for c in self.contact_list:
self.assertTrue(c.file_reception)
self.assertIsNone(contact_setting(UserInput('store off all'), window, *self.args))
for c in self.contact_list:
self.assertFalse(c.file_reception)
def test_enable_notifications_for_user(self) -> None:
# Setup
contact = self.contact_list.get_contact_by_address_or_nick('Alice')
contact.notifications = False
window = TxWindow(uid=self.pub_key,
type=WIN_TYPE_CONTACT,
contact=contact)
# Test
self.assertFalse(contact.notifications)
self.assertIsNone(contact_setting(UserInput('notify on'), window, *self.args))
self.assertTrue(contact.notifications)
def test_enable_notifications_for_group(self) -> None:
# Setup
user_input = UserInput('notify on')
group = self.group_list.get_group('test_group')
group.notifications = False
window = TxWindow(uid=group_name_to_group_id('test_group'),
type=WIN_TYPE_GROUP,
group=group,
window_contacts=group.members)
# Test
self.assertFalse(group.notifications)
self.assertIsNone(contact_setting(user_input, window, *self.args))
self.assertTrue(group.notifications)
def test_enable_notifications_for_all_users(self) -> None:
# Setup
contact = self.contact_list.get_contact_by_address_or_nick("Alice")
window = TxWindow(uid=self.pub_key,
type=WIN_TYPE_CONTACT,
contact=contact,
window_contacts=[contact])
for c in self.contact_list:
c.notifications = False
for g in self.group_list:
g.notifications = False
# Test
for c in self.contact_list:
self.assertFalse(c.notifications)
for g in self.group_list:
self.assertFalse(g.notifications)
self.assertIsNone(contact_setting(UserInput('notify on all'), window, *self.args))
for c in self.contact_list:
self.assertTrue(c.notifications)
for g in self.group_list:
self.assertTrue(g.notifications)
def test_disable_notifications_for_user(self) -> None:
# Setup
contact = self.contact_list.get_contact_by_address_or_nick('Alice')
contact.notifications = True
window = TxWindow(uid=self.pub_key,
type=WIN_TYPE_CONTACT,
contact=contact,
window_contacts=[contact])
# Test
self.assertTrue(contact.notifications)
self.assertIsNone(contact_setting(UserInput('notify off'), window, *self.args))
self.assertFalse(contact.notifications)
def test_disable_notifications_for_group(self) -> None:
# Setup
group = self.group_list.get_group('test_group')
group.notifications = True
window = TxWindow(uid=group_name_to_group_id('test_group'),
type=WIN_TYPE_GROUP,
group=group,
window_contacts=group.members)
# Test
self.assertTrue(group.notifications)
self.assertIsNone(contact_setting(UserInput('notify off'), window, *self.args))
self.assertFalse(group.notifications)
def test_disable_notifications_for_all_users(self) -> None:
# Setup
contact = self.contact_list.get_contact_by_address_or_nick("Alice")
window = TxWindow(uid=self.pub_key,
type=WIN_TYPE_CONTACT,
contact=contact,
window_contacts=[contact])
for c in self.contact_list:
c.notifications = True
for g in self.group_list:
g.notifications = True
# Test
for c in self.contact_list:
self.assertTrue(c.notifications)
for g in self.group_list:
self.assertTrue(g.notifications)
self.assertIsNone(contact_setting(UserInput('notify off all'), window, *self.args))
for c in self.contact_list:
self.assertFalse(c.notifications)
for g in self.group_list:
self.assertFalse(g.notifications)
class TestRemoveContact(TFCTestCase):
def setUp(self) -> None:
"""Pre-test actions."""
self.unit_test_dir = cd_unit_test()
self.contact_list = ContactList(nicks=['Alice'])
self.group_list = GroupList(groups=['test_group'])
self.settings = Settings()
self.queues = gen_queue_dict()
self.master_key = MasterKey()
self.pub_key = nick_to_pub_key('Alice')
self.args = self.contact_list, self.group_list, self.settings, self.queues, self.master_key
def tearDown(self) -> None:
"""Post-test actions."""
cleanup(self.unit_test_dir)
tear_queues(self.queues)
def test_contact_removal_during_traffic_masking_raises_soft_error(self) -> None:
# Setup
self.settings.traffic_masking = True
# Test
self.assert_se("Error: Command is disabled during traffic masking.",
remove_contact, UserInput(), None, *self.args)
def test_missing_account_raises_soft_error(self) -> None:
self.assert_se("Error: No account specified.", remove_contact, UserInput('rm '), None, *self.args)
@mock.patch('time.sleep', return_value=None)
@mock.patch('shutil.get_terminal_size', return_value=[150, 150])
@mock.patch('builtins.input', return_value='Yes')
def test_invalid_account_raises_soft_error(self, *_: Any) -> None:
# Setup
user_input = UserInput(f'rm {nick_to_onion_address("Alice")[:-1]}')
window = TxWindow(window_contacts=[self.contact_list.get_contact_by_address_or_nick('Alice')],
type=WIN_TYPE_CONTACT,
uid=self.pub_key)
# Test
self.assert_se("Error: Invalid selection.", remove_contact, user_input, window, *self.args)
@mock.patch('time.sleep', return_value=None)
@mock.patch('shutil.get_terminal_size', return_value=[150, 150])
@mock.patch('builtins.input', return_value='No')
def test_user_abort_raises_soft_error(self, *_: Any) -> None:
# Setup
user_input = UserInput(f'rm {nick_to_onion_address("Alice")}')
# Test
self.assert_se("Removal of contact aborted.", remove_contact, user_input, None, *self.args)
@mock.patch('builtins.input', return_value='Yes')
def test_successful_removal_of_contact(self, _: Any) -> None:
# Setup
window = TxWindow(window_contacts=[self.contact_list.get_contact_by_address_or_nick('Alice')],
type=WIN_TYPE_CONTACT,
uid=self.pub_key)
# Test
for g in self.group_list:
self.assertIsInstance(g, Group)
self.assertTrue(g.has_member(self.pub_key))
self.assertIsNone(remove_contact(UserInput('rm Alice'), window, *self.args))
self.assertEqual(self.queues[COMMAND_PACKET_QUEUE].qsize(), 1)
km_data = self.queues[KEY_MANAGEMENT_QUEUE].get()
self.assertEqual(km_data, (KDB_REMOVE_ENTRY_HEADER, self.pub_key))
self.assertFalse(self.contact_list.has_pub_key(self.pub_key))
for g in self.group_list:
self.assertIsInstance(g, Group)
self.assertFalse(g.has_member(self.pub_key))
@mock.patch('builtins.input', return_value='Yes')
def test_successful_removal_of_last_member_of_active_group(self, _: Any) -> None:
# Setup
user_input = UserInput('rm Alice')
window = TxWindow(window_contacts=[self.contact_list.get_contact_by_address_or_nick("Alice")],
type=WIN_TYPE_GROUP,
name='test_group')
group = self.group_list.get_group('test_group')
group.members = [self.contact_list.get_contact_by_address_or_nick("Alice")]
pub_key = nick_to_pub_key('Alice')
# Test
for g in self.group_list:
self.assertIsInstance(g, Group)
self.assertTrue(g.has_member(pub_key))
self.assertEqual(len(group), 1)
self.assertIsNone(remove_contact(user_input, window, *self.args))
for g in self.group_list:
self.assertIsInstance(g, Group)
self.assertFalse(g.has_member(pub_key))
self.assertFalse(self.contact_list.has_pub_key(pub_key))
self.assertEqual(self.queues[COMMAND_PACKET_QUEUE].qsize(), 1)
km_data = self.queues[KEY_MANAGEMENT_QUEUE].get()
self.assertEqual(km_data, (KDB_REMOVE_ENTRY_HEADER, pub_key))
@mock.patch('shutil.get_terminal_size', return_value=[150, 150])
@mock.patch('builtins.input', return_value='Yes')
def test_no_contact_found_on_transmitter(self, *_: Any) -> None:
# Setup
user_input = UserInput(f'rm {nick_to_onion_address("Charlie")}')
contact_list = ContactList(nicks=['Bob'])
window = TxWindow(window_contact=[contact_list.get_contact_by_address_or_nick('Bob')],
type=WIN_TYPE_GROUP)
# Test
self.assertIsNone(remove_contact(user_input, window, *self.args))
self.assertEqual(self.queues[COMMAND_PACKET_QUEUE].qsize(), 1)
self.assertEqual(self.queues[RELAY_PACKET_QUEUE].qsize(), 1)
command_packet = self.queues[COMMAND_PACKET_QUEUE].get()
self.assertIsInstance(command_packet, bytes)
class TestProcessMessagePacket(TFCTestCase):
def setUp(self) -> None:
"""Pre-test actions."""
self.unit_test_dir = cd_unit_test()
self.msg = ("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean condimentum consectetur purus quis"
" dapibus. Fusce venenatis lacus ut rhoncus faucibus. Cras sollicitudin commodo sapien, sed bibendu"
"m velit maximus in. Aliquam ac metus risus. Sed cursus ornare luctus. Integer aliquet lectus id ma"
"ssa blandit imperdiet. Ut sed massa eget quam facilisis rutrum. Mauris eget luctus nisl. Sed ut el"
"it iaculis, faucibus lacus eget, sodales magna. Nunc sed commodo arcu. In hac habitasse platea dic"
"tumst. Integer luctus aliquam justo, at vestibulum dolor iaculis ac. Etiam laoreet est eget odio r"
"utrum, vel malesuada lorem rhoncus. Cras finibus in neque eu euismod. Nulla facilisi. Nunc nec ali"
"quam quam, quis ullamcorper leo. Nunc egestas lectus eget est porttitor, in iaculis felis sceleris"
"que. In sem elit, fringilla id viverra commodo, sagittis varius purus. Pellentesque rutrum loborti"
"s neque a facilisis. Mauris id tortor placerat, aliquam dolor ac, venenatis arcu.")
self.ts = datetime.now()
self.master_key = MasterKey()
self.settings = Settings(log_file_masking=True)
self.file_name = f'{DIR_USER_DATA}{self.settings.software_operation}_logs'
self.contact_list = ContactList(nicks=['Alice', 'Bob', 'Charlie', LOCAL_ID])
self.key_list = KeyList( nicks=['Alice', 'Bob', 'Charlie', LOCAL_ID])
self.group_list = GroupList( groups=['test_group'])
self.packet_list = PacketList(contact_list=self.contact_list, settings=self.settings)
self.window_list = WindowList(contact_list=self.contact_list, settings=self.settings,
group_list=self.group_list, packet_list=self.packet_list)
self.group_id = group_name_to_group_id('test_group')
self.file_keys = dict()
self.log_file = f'{DIR_USER_DATA}{self.settings.software_operation}_logs'
self.tfc_log_database = MessageLog(self.log_file, self.master_key.master_key)
self.group_list.get_group('test_group').log_messages = True
self.args = (self.window_list, self.packet_list, self.contact_list, self.key_list,
self.group_list, self.settings, self.file_keys, self.tfc_log_database)
ensure_dir(DIR_USER_DATA)
def tearDown(self) -> None:
"""Post-test actions."""
cleanup(self.unit_test_dir)
# Invalid packets
@mock.patch('time.sleep', return_value=None)
def test_invalid_origin_header_raises_soft_error(self, _: Any) -> None:
# Setup
invalid_origin_header = b'e'
packet = nick_to_pub_key('Alice') + invalid_origin_header + MESSAGE_LENGTH * b'm'
# Test
self.assert_se("Error: Received packet had an invalid origin-header.",
process_message_packet, self.ts, packet, *self.args)
@mock.patch('time.sleep', return_value=None)
def test_masqueraded_command_raises_soft_error(self, _: Any) -> None:
for origin_header in [ORIGIN_USER_HEADER, ORIGIN_CONTACT_HEADER]:
# Setup
packet = LOCAL_PUBKEY + origin_header + MESSAGE_LENGTH * b'm'
# Test
self.assert_se("Warning! Received packet masqueraded as a command.",
process_message_packet, self.ts, packet, *self.args)
# Private messages
@mock.patch('time.sleep', return_value=None)
def test_private_msg_from_contact(self, _: Any) -> None:
# Setup
assembly_ct_list = assembly_packet_creator(MESSAGE, self.msg, origin_header=ORIGIN_CONTACT_HEADER,
encrypt_packet=True, onion_pub_key=nick_to_pub_key('Alice'))
# Test
for p in assembly_ct_list:
self.assertIsNone(process_message_packet(self.ts, p, *self.args))
@mock.patch('time.sleep', return_value=None)
def test_private_msg_from_user(self, _: Any) -> None:
# Setup
assembly_ct_list = assembly_packet_creator(MESSAGE, self.msg, origin_header=ORIGIN_USER_HEADER,
encrypt_packet=True, onion_pub_key=nick_to_pub_key('Alice'))
# Test
for p in assembly_ct_list:
self.assertIsNone(process_message_packet(self.ts, p, *self.args))
# Whispered messages
@mock.patch('time.sleep', return_value=None)
def test_whisper_msg_from_contact(self, _: Any) -> None:
# Setup
assembly_ct_list = assembly_packet_creator(MESSAGE, self.msg, origin_header=ORIGIN_CONTACT_HEADER,
encrypt_packet=True, onion_pub_key=nick_to_pub_key('Alice'),
whisper_header=bool_to_bytes(True))
# Test
for p in assembly_ct_list[:-1]:
self.assertIsNone(process_message_packet(self.ts, p, *self.args))
for p in assembly_ct_list[-1:]:
self.assert_se("Whisper message complete.",
process_message_packet, self.ts, p, *self.args)
@mock.patch('time.sleep', return_value=None)
def test_whisper_msg_from_user(self, _: Any) -> None:
# Setup
assembly_ct_list = assembly_packet_creator(MESSAGE, self.msg, origin_header=ORIGIN_USER_HEADER,
encrypt_packet=True, onion_pub_key=nick_to_pub_key('Alice'),
whisper_header=bool_to_bytes(True))
# Test
for p in assembly_ct_list[:-1]:
self.assertIsNone(process_message_packet(self.ts, p, *self.args))
for p in assembly_ct_list[-1:]:
self.assert_se("Whisper message complete.", process_message_packet, self.ts, p, *self.args)
@mock.patch('time.sleep', return_value=None)
def test_empty_whisper_msg_from_user(self, _: Any) -> None:
# Setup
assembly_ct_list = assembly_packet_creator(MESSAGE, '', origin_header=ORIGIN_USER_HEADER,
encrypt_packet=True, onion_pub_key=nick_to_pub_key('Alice'),
whisper_header=bool_to_bytes(True))
# Test
for p in assembly_ct_list[:-1]:
self.assertIsNone(process_message_packet(self.ts, p, *self.args))
for p in assembly_ct_list[-1:]:
self.assert_se("Whisper message complete.", process_message_packet, self.ts, p, *self.args)
# File key messages
@mock.patch('time.sleep', return_value=None)
def test_user_origin_raises_soft_error(self, _: Any) -> None:
assembly_ct_list = assembly_packet_creator(MESSAGE, ' ', origin_header=ORIGIN_USER_HEADER,
encrypt_packet=True, onion_pub_key=nick_to_pub_key('Alice'),
message_header=FILE_KEY_HEADER)
for p in assembly_ct_list[-1:]:
self.assert_se("File key message from the user.", process_message_packet, self.ts, p, *self.args)
@mock.patch('time.sleep', return_value=None)
def test_invalid_file_key_data_raises_soft_error(self, _: Any) -> None:
assembly_ct_list = assembly_packet_creator(MESSAGE, ' ', origin_header=ORIGIN_CONTACT_HEADER,
encrypt_packet=True, onion_pub_key=nick_to_pub_key('Alice'),
message_header=FILE_KEY_HEADER)
for p in assembly_ct_list[-1:]:
self.assert_se("Error: Received an invalid file key message.",
process_message_packet, self.ts, p, *self.args)
@mock.patch('time.sleep', return_value=None)
def test_too_large_file_key_data_raises_soft_error(self, _: Any) -> None:
assembly_ct_list = assembly_packet_creator(MESSAGE, base64.b85encode(BLAKE2_DIGEST_LENGTH * b'a'
+ SYMMETRIC_KEY_LENGTH * b'b'
+ b'a').decode(),
origin_header=ORIGIN_CONTACT_HEADER,
encrypt_packet=True, onion_pub_key=nick_to_pub_key('Alice'),
message_header=FILE_KEY_HEADER)
for p in assembly_ct_list[-1:]:
self.assert_se("Error: Received an invalid file key message.",
process_message_packet, self.ts, p, *self.args)
@mock.patch('time.sleep', return_value=None)
def test_valid_file_key_message(self, _: Any) -> None:
assembly_ct_list = assembly_packet_creator(MESSAGE, base64.b85encode(BLAKE2_DIGEST_LENGTH * b'a'
+ SYMMETRIC_KEY_LENGTH * b'b').decode(),
origin_header=ORIGIN_CONTACT_HEADER,
encrypt_packet=True, onion_pub_key=nick_to_pub_key('Alice'),
message_header=FILE_KEY_HEADER)
for p in assembly_ct_list[-1:]:
self.assert_se("Received file decryption key from Alice",
process_message_packet, self.ts, p, *self.args)
# Group messages
@mock.patch('time.sleep', return_value=None)
def test_invalid_message_header_raises_soft_error(self, _: Any) -> None:
# Setup
assembly_ct_list = assembly_packet_creator(MESSAGE, 'test_message', origin_header=ORIGIN_CONTACT_HEADER,
encrypt_packet=True, onion_pub_key=nick_to_pub_key('Alice'),
message_header=b'Z')
# Test
self.assert_se("Error: Message from contact had an invalid header.",
process_message_packet, self.ts, assembly_ct_list[0], *self.args)
@mock.patch('time.sleep', return_value=None)
def test_invalid_window_raises_soft_error(self, _: Any) -> None:
# Setup
assembly_ct_list = assembly_packet_creator(MESSAGE, 'test_message', origin_header=ORIGIN_CONTACT_HEADER,
encrypt_packet=True, onion_pub_key=nick_to_pub_key('Alice'),
group_id=self.group_id)
self.group_list.get_group('test_group').group_id = GROUP_ID_LENGTH * b'a'
# Test
self.assert_se("Error: Received message to an unknown group.",
process_message_packet, self.ts, assembly_ct_list[0], *self.args)
@mock.patch('time.sleep', return_value=None)
def test_invalid_message_raises_soft_error(self, _: Any) -> None:
# Setup
assembly_ct_list = assembly_packet_creator(MESSAGE, ' ', origin_header=ORIGIN_CONTACT_HEADER,
encrypt_packet=True, onion_pub_key=nick_to_pub_key('Alice'),
group_id=self.group_id, tamper_plaintext=True)
# Test
self.assert_se("Error: Received an invalid group message.",
process_message_packet, self.ts, assembly_ct_list[0], *self.args)
@mock.patch('time.sleep', return_value=None)
def test_invalid_whisper_header_raises_soft_error(self, _: Any) -> None:
# Setup
assembly_ct_list = assembly_packet_creator(MESSAGE, '', origin_header=ORIGIN_CONTACT_HEADER,
encrypt_packet=True, onion_pub_key=nick_to_pub_key('Alice'),
whisper_header=b'', message_header=b'')
# Test
self.assert_se("Error: Message from contact had an invalid whisper header.",
process_message_packet, self.ts, assembly_ct_list[0], *self.args)
@mock.patch('time.sleep', return_value=None)
def test_contact_not_in_group_raises_soft_error(self, _: Any) -> None:
# Setup
assembly_ct_list = assembly_packet_creator(MESSAGE, 'test_message', origin_header=ORIGIN_CONTACT_HEADER,
encrypt_packet=True, group_id=self.group_id,
onion_pub_key=nick_to_pub_key('Charlie'))
# Test
self.assert_se("Error: Account is not a member of the group.",
process_message_packet, self.ts, assembly_ct_list[0], *self.args)
@mock.patch('time.sleep', return_value=None)
def test_normal_group_msg_from_contact(self, _: Any) -> None:
# Setup
assembly_ct_list = assembly_packet_creator(MESSAGE, self.msg, origin_header=ORIGIN_CONTACT_HEADER,
group_id=self.group_id, encrypt_packet=True,
onion_pub_key=nick_to_pub_key('Alice'))
for p in assembly_ct_list:
self.assertIsNone(process_message_packet(self.ts, p, *self.args))
@mock.patch('time.sleep', return_value=None)
def test_normal_group_msg_from_user(self, _: Any) -> None:
# Setup
assembly_ct_list = assembly_packet_creator(MESSAGE, self.msg, origin_header=ORIGIN_USER_HEADER,
group_id=self.group_id, encrypt_packet=True,
onion_pub_key=nick_to_pub_key('Alice'))
for p in assembly_ct_list:
self.assertIsNone(process_message_packet(self.ts, p, *self.args))
# Files
@mock.patch('time.sleep', return_value=None)
def test_file(self, _: Any) -> None:
# Setup
assembly_ct_list = assembly_packet_creator(FILE, origin_header=ORIGIN_CONTACT_HEADER,
encrypt_packet=True, onion_pub_key=nick_to_pub_key('Alice'))
# Test
for p in assembly_ct_list[:-1]:
self.assertIsNone(process_message_packet(self.ts, p, *self.args))
for p in assembly_ct_list[-1:]:
self.assert_se("File storage complete.",
process_message_packet, self.ts, p, *self.args)
@mock.patch('time.sleep', return_value=None)
def test_file_when_reception_is_disabled(self, _: Any) -> None:
# Setup
assembly_ct_list = assembly_packet_creator(FILE, origin_header=ORIGIN_CONTACT_HEADER,
encrypt_packet=True, onion_pub_key=nick_to_pub_key('Alice'))
self.contact_list.get_contact_by_pub_key(nick_to_pub_key('Alice')).file_reception = False
# Test
self.assert_se("Alert! File transmission from Alice but reception is disabled.",
process_message_packet, self.ts, assembly_ct_list[0], *self.args)
class TestGroupCreate(TFCTestCase):
def setUp(self):
"""Pre-test actions."""
self.contact_list = ContactList(nicks=['Alice', 'Bob'])
self.group_list = GroupList()
self.settings = Settings()
self.queues = gen_queue_dict()
self.master_key = MasterKey()
self.account_list = None
self.args = self.contact_list, self.group_list, self.settings, self.queues, self.settings
def tearDown(self):
"""Post-test actions."""
tear_queues(self.queues)
def configure_groups(self, no_contacts: int) -> None:
"""Configure group list."""
self.contact_list = ContactList(
nicks=[str(n) for n in range(no_contacts)])
self.group_list = GroupList(groups=['test_group'])
self.group = self.group_list.get_group('test_group')
self.group.members = self.contact_list.contacts
self.account_list = [
nick_to_pub_key(str(n)) for n in range(no_contacts)
]
def test_invalid_group_name_raises_fr(self):
# Setup
self.configure_groups(no_contacts=21)
# Test
self.assert_fr("Error: Group name must be printable.", group_create,
'test_group\x1f', self.account_list, *self.args)
def test_too_many_purp_accounts_raises_fr(self):
# Setup
self.configure_groups(no_contacts=60)
# Test
cl_str = [nick_to_pub_key(str(n)) for n in range(51)]
self.assert_fr("Error: TFC settings only allow 50 members per group.",
group_create, 'test_group_50', cl_str,
self.contact_list, self.group_list, self.settings,
self.queues, self.master_key)
def test_full_group_list_raises_fr(self):
# Setup
self.group_list = GroupList(
groups=[f"testgroup_{n}" for n in range(50)])
# Test
self.assert_fr("Error: TFC settings only allow 50 groups.",
group_create, 'testgroup_50',
[nick_to_pub_key("Alice")], self.contact_list,
self.group_list, self.settings, self.queues,
self.master_key)
@mock.patch('builtins.input', return_value='Yes')
def test_successful_group_creation(self, _):
# Test
self.assertIsNone(
group_create('test_group_2', [nick_to_pub_key("Alice")],
*self.args))
self.assertEqual(self.queues[COMMAND_PACKET_QUEUE].qsize(), 1)
self.assertEqual(self.queues[RELAY_PACKET_QUEUE].qsize(), 1)
def test_successful_empty_group_creation(self):
self.assertIsNone(group_create('test_group_2', [], *self.args))
self.assertEqual(self.queues[COMMAND_PACKET_QUEUE].qsize(), 1)
self.assertEqual(self.queues[RELAY_PACKET_QUEUE].qsize(), 0)
