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)