class TestResetScreen(unittest.TestCase): def setUp(self) -> None: """Pre-test actions.""" self.cmd_data = nick_to_pub_key("Alice") self.window_list = WindowList() self.window_list.windows = [ RxWindow(uid=nick_to_pub_key("Alice"), name='Alice'), RxWindow(uid=nick_to_pub_key("Bob"), name='Bob') ] self.window = self.window_list.get_window(nick_to_pub_key("Alice")) self.window.message_log = [(datetime.now(), 'Hi Bob', nick_to_pub_key("Alice"), ORIGIN_CONTACT_HEADER)] @mock.patch('os.system', return_value=None, create_autospec=True) def test_screen_reset(self, reset) -> None: # Ensure there is a message to be removed from the ephemeral message log self.assertEqual(len(self.window.message_log), 1) reset_screen(self.cmd_data, self.window_list) # Test that screen is reset by the command reset.assert_called_with(RESET) # Test that the ephemeral message log is empty after the command self.assertEqual(len(self.window.message_log), 0)
class TestChNick(TFCTestCase): def setUp(self): self.ts = datetime.now() self.contact_list = ContactList(nicks=['Alice']) self.window_list = WindowList(contact_list=self.contact_list) self.group_list = GroupList() self.args = self.ts, self.window_list, self.contact_list self.window = self.window_list.get_window(nick_to_pub_key("Alice")) self.window.type = WIN_TYPE_CONTACT def test_unknown_account_raises_fr(self): # Setup cmd_data = nick_to_pub_key("Bob") + b'Bob_' # Test trunc_addr = nick_to_short_address('Bob') self.assert_fr(f"Error: Receiver has no contact '{trunc_addr}' to rename.", ch_nick, cmd_data, *self.args) def test_nick_change(self): # Setup cmd_data = nick_to_pub_key("Alice") + b'Alice_' # Test self.assertIsNone(ch_nick(cmd_data, *self.args)) self.assertEqual(self.contact_list.get_contact_by_pub_key(nick_to_pub_key("Alice")).nick, 'Alice_') self.assertEqual(self.window.name, 'Alice_')
class TestLocalKeyRdy(TFCTestCase): def setUp(self): self.ts = datetime.fromtimestamp(1502750000) @mock.patch('time.sleep', return_value=None) def test_local_key_installed_no_contacts(self, _): # Setup self.window_list = WindowList(nicks=[LOCAL_ID]) self.contact_list = ContactList(nicks=[LOCAL_ID]) # Test self.assert_prints( f"""\ {BOLD_ON} Successfully completed the local key setup. {NORMAL_TEXT} {CLEAR_ENTIRE_SCREEN+CURSOR_LEFT_UP_CORNER} {BOLD_ON} Waiting for new contacts {NORMAL_TEXT} """, local_key_rdy, self.ts, self.window_list, self.contact_list) @mock.patch('time.sleep', return_value=None) def test_local_key_installed_existing_contact(self, _): # Setup self.window_list = WindowList(nicks=[LOCAL_ID, 'Alice']) self.contact_list = ContactList(nicks=[LOCAL_ID, 'Alice']) self.window_list.active_win = self.window_list.get_window( nick_to_pub_key('Alice')) self.window_list.active_win.type = WIN_TYPE_CONTACT # Test self.assertIsNone( local_key_rdy(self.ts, self.window_list, self.contact_list))
class TestLogCommand(TFCTestCase): def setUp(self) -> None: """Pre-test actions.""" self.unit_test_dir = cd_unit_test() self.cmd_data = int_to_bytes(1) + nick_to_pub_key("Bob") self.ts = datetime.now() self.window_list = WindowList(nicks=['Alice', 'Bob']) self.window = self.window_list.get_window(nick_to_pub_key("Bob")) self.window.type_print = WIN_TYPE_CONTACT self.window.name = 'Bob' self.window.type = WIN_TYPE_CONTACT self.contact_list = ContactList(nicks=['Alice', 'Bob']) self.group_list = GroupList() self.settings = Settings(software_operation=RX) self.master_key = MasterKey(operation=RX, local_test=True) self.args = (self.ts, self.window_list, self.contact_list, self.group_list, self.settings, self.master_key) 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) time_float = struct.unpack('<L', bytes.fromhex('08ceae02'))[0] self.time = datetime.fromtimestamp(time_float).strftime("%H:%M:%S.%f")[:-4] def tearDown(self) -> None: """Post-test actions.""" cleanup(self.unit_test_dir) with ignored(OSError): os.remove('Receiver - Plaintext log (None)') def test_print(self) -> None: # Setup os.remove(self.log_file) # Test self.assert_se(f"No log database available.", log_command, self.cmd_data, *self.args) @mock.patch('struct.pack', return_value=bytes.fromhex('08ceae02')) def test_export(self, _) -> None: # Setup for p in assembly_packet_creator(MESSAGE, 'A short message'): write_log_entry(p, nick_to_pub_key("Bob"), self.tfc_log_database, origin=ORIGIN_CONTACT_HEADER) # Test self.assertIsNone(log_command(self.cmd_data, *self.args)) with open('Receiver - Plaintext log (Bob)') as f: data = f.read() self.assertEqual(data, f"""\ Log file of 1 most recent message(s) to/from contact Bob ════════════════════════════════════════════════════════════════════════════════ {self.time} Bob: A short message <End of log file> """)
class TestLogCommand(TFCTestCase): def setUp(self): self.cmd_data = b'*****@*****.**' + US_BYTE + int_to_bytes(1) self.ts = datetime.now() self.window_list = WindowList(nicks=['Alice', 'Bob']) self.window = self.window_list.get_window('*****@*****.**') self.window.type_print = 'contact' self.contact_list = ContactList(nicks=['Alice', 'Bob']) self.group_list = GroupList() self.settings = Settings() self.master_key = MasterKey() self.time = datetime.fromtimestamp( struct.unpack('<L', binascii.unhexlify('08ceae02'))[0]).strftime('%H:%M') self.o_struct_pack = struct.pack struct.pack = lambda *_: binascii.unhexlify('08ceae02') def tearDown(self): struct.pack = self.o_struct_pack cleanup() with ignored(OSError): os.remove('UtM - Plaintext log (None)') def test_print(self): self.assertFR(f"Error: Could not find log database.", log_command, self.cmd_data, None, self.window_list, self.contact_list, self.group_list, self.settings, self.master_key) def test_export(self): # Setup for p in assembly_packet_creator(MESSAGE, b'A short message'): write_log_entry(p, '*****@*****.**', self.settings, self.master_key, origin=ORIGIN_CONTACT_HEADER) # Test self.assertIsNone( log_command(self.cmd_data, self.ts, self.window_list, self.contact_list, self.group_list, self.settings, self.master_key)) with open('UtM - Plaintext log (None)') as f: data = f.read() self.assertEqual( data, f"""\ Logfile of 1 most recent message to/from None ════════════════════════════════════════════════════════════════════════════════ {self.time} Bob: A short message <End of logfile> """)
class TestResetActiveWindow(unittest.TestCase): def setUp(self): self.cmd_data = b'*****@*****.**' self.window_list = WindowList() self.window_list.windows = [ RxWindow(uid='*****@*****.**', name='Alice'), RxWindow(uid='*****@*****.**', name='Bob') ] self.window = self.window_list.get_window('*****@*****.**') self.window.message_log = [(datetime.now(), 'Hi Bob', '*****@*****.**', ORIGIN_CONTACT_HEADER)] def test_screen_reset(self): self.assertEqual(len(self.window.message_log), 1) self.assertIsNone(reset_active_window(self.cmd_data, self.window_list)) self.assertEqual(len(self.window.message_log), 0)
class TestChangeNick(TFCTestCase): def setUp(self): self.ts = datetime.now() self.contact_list = ContactList(nicks=['Alice']) self.window_list = WindowList(contact_list=self.contact_list) self.group_list = GroupList() def test_nick_change(self): # Setup cmd_data = b'*****@*****.**' + US_BYTE + b'Alice_' # Test self.assertIsNone( change_nick(cmd_data, self.ts, self.window_list, self.contact_list)) self.assertEqual( self.contact_list.get_contact('*****@*****.**').nick, 'Alice_') self.assertEqual( self.window_list.get_window('*****@*****.**').name, 'Alice_')
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 ProcessAssembledFile(TFCTestCase): def setUp(self) -> None: """Pre-test actions.""" self.unit_test_dir = cd_unit_test() self.ts = datetime.now() self.onion_pub_key = nick_to_pub_key('Alice') self.nick = 'Alice' self.settings = Settings() self.window_list = WindowList(nick=['Alice', 'Bob']) self.key = os.urandom(SYMMETRIC_KEY_LENGTH) self.args = self.onion_pub_key, self.nick, self.settings, self.window_list def tearDown(self) -> None: """Post-test actions.""" cleanup(self.unit_test_dir) def test_invalid_structure_raises_soft_error(self) -> None: # Setup payload = b'testfile.txt' # Test self.assert_se("Error: Received file had an invalid structure.", process_assembled_file, self.ts, payload, *self.args) def test_invalid_encoding_raises_soft_error(self) -> None: # Setup payload = UNDECODABLE_UNICODE + US_BYTE + b'file_data' # Test self.assert_se("Error: Received file name had an invalid encoding.", process_assembled_file, self.ts, payload, *self.args) def test_invalid_name_raises_soft_error(self) -> None: # Setup payload = b'\x01filename' + US_BYTE + b'file_data' # Test self.assert_se("Error: Received file had an invalid name.", process_assembled_file, self.ts, payload, *self.args) def test_slash_in_file_name_raises_soft_error(self) -> None: # Setup payload = b'file/name' + US_BYTE + b'file_data' # Test self.assert_se("Error: Received file had an invalid name.", process_assembled_file, self.ts, payload, *self.args) def test_invalid_key_raises_soft_error(self) -> None: # Setup payload = b'testfile.txt' + US_BYTE + b'file_data' # Test self.assert_se("Error: Received file had an invalid key.", process_assembled_file, self.ts, payload, *self.args) def test_decryption_fail_raises_soft_error(self) -> None: # Setup file_data = encrypt_and_sign(b'file_data', self.key)[::-1] payload = b'testfile.txt' + US_BYTE + file_data # Test self.assert_se("Error: Decryption of file data failed.", process_assembled_file, self.ts, payload, *self.args) def test_invalid_compression_raises_soft_error(self) -> None: # Setup compressed = zlib.compress(b'file_data', level=COMPRESSION_LEVEL)[::-1] file_data = encrypt_and_sign(compressed, self.key) + self.key payload = b'testfile.txt' + US_BYTE + file_data # Test self.assert_se("Error: Decompression of file data failed.", process_assembled_file, self.ts, payload, *self.args) def test_successful_reception(self) -> None: # Setup compressed = zlib.compress(b'file_data', level=COMPRESSION_LEVEL) file_data = encrypt_and_sign(compressed, self.key) + self.key payload = b'testfile.txt' + US_BYTE + file_data # Test self.assertIsNone(process_assembled_file(self.ts, payload, *self.args)) self.assertTrue(os.path.isfile(f'{DIR_RECV_FILES}Alice/testfile.txt')) def test_successful_reception_during_traffic_masking(self) -> None: # Setup self.settings.traffic_masking = True self.window_list.active_win = self.window_list.get_window(nick_to_pub_key('Bob')) compressed = zlib.compress(b'file_data', level=COMPRESSION_LEVEL) file_data = encrypt_and_sign(compressed, self.key) + self.key payload = b'testfile.txt' + US_BYTE + file_data # Test self.assertIsNone(process_assembled_file(self.ts, payload, *self.args)) self.assertEqual(self.window_list.get_window(nick_to_pub_key('Bob')).message_log[0][1], "Stored file from Alice as 'testfile.txt'.") self.assertTrue(os.path.isfile(f'{DIR_RECV_FILES}Alice/testfile.txt'))
class TestProcessFile(TFCTestCase): def setUp(self) -> None: """Pre-test actions.""" self.unit_test_dir = cd_unit_test() self.ts = datetime.now() self.account = nick_to_pub_key('Alice') self.file_key = SYMMETRIC_KEY_LENGTH*b'a' self.file_ct = encrypt_and_sign(50 * b'a', key=self.file_key) self.contact_list = ContactList(nicks=['Alice']) self.window_list = WindowList() self.settings = Settings() self.args = self.file_key, self.contact_list, self.window_list, self.settings def tearDown(self) -> None: """Post-test actions.""" cleanup(self.unit_test_dir) def test_invalid_key_raises_soft_error(self) -> None: self.file_key = SYMMETRIC_KEY_LENGTH * b'f' self.args = self.file_key, self.contact_list, self.window_list, self.settings self.assert_se("Error: Decryption key for file from Alice was invalid.", process_file, self.ts, self.account, self.file_ct, *self.args) def test_invalid_compression_raises_soft_error(self) -> None: compressed = zlib.compress(b'file_data', level=COMPRESSION_LEVEL)[::-1] file_data = encrypt_and_sign(compressed, self.file_key) self.assert_se("Error: Failed to decompress file from Alice.", process_file, self.ts, self.account, file_data, *self.args) @mock.patch('time.sleep', return_value=None) def test_invalid_file_name_raises_soft_error(self, _: Any) -> None: compressed = zlib.compress(UNDECODABLE_UNICODE + b'file_data', level=COMPRESSION_LEVEL) file_data = encrypt_and_sign(compressed, self.file_key) self.assert_se("Error: Name of file from Alice had an invalid encoding.", process_file, self.ts, self.account, file_data, *self.args) @mock.patch('time.sleep', return_value=None) def test_non_printable_name_raises_soft_error(self, _: Any) -> None: compressed = zlib.compress(str_to_bytes("file\x01") + b'file_data', level=COMPRESSION_LEVEL) file_data = encrypt_and_sign(compressed, self.file_key) self.assert_se("Error: Name of file from Alice was invalid.", process_file, self.ts, self.account, file_data, *self.args) @mock.patch('time.sleep', return_value=None) def test_slash_in_name_raises_soft_error(self, _: Any) -> None: compressed = zlib.compress(str_to_bytes("Alice/file.txt") + b'file_data', level=COMPRESSION_LEVEL) file_data = encrypt_and_sign(compressed, self.file_key) self.assert_se("Error: Name of file from Alice was invalid.", process_file, self.ts, self.account, file_data, *self.args) @mock.patch('time.sleep', return_value=None) def test_successful_storage_of_file(self, _: Any) -> None: compressed = zlib.compress(str_to_bytes("test_file.txt") + b'file_data', level=COMPRESSION_LEVEL) file_data = encrypt_and_sign(compressed, self.file_key) self.assertIsNone(process_file(self.ts, self.account, file_data, *self.args)) @mock.patch('time.sleep', return_value=None) def test_successful_storage_during_traffic_masking(self, _: Any) -> None: # Setup self.settings.traffic_masking = True self.window_list.active_win = self.window_list.get_window(nick_to_pub_key('Bob')) compressed = zlib.compress(str_to_bytes("testfile.txt") + b'file_data', level=COMPRESSION_LEVEL) file_data = encrypt_and_sign(compressed, self.file_key) self.assertIsNone(process_file(self.ts, self.account, file_data, *self.args)) self.assertEqual(self.window_list.get_window(nick_to_pub_key('Bob')).message_log[0][1], "Stored file from Alice as 'testfile.txt'.") self.assertTrue(os.path.isfile(f'{DIR_RECV_FILES}Alice/testfile.txt'))
class TestProcessLocalKey(TFCTestCase): kek = os.urandom(SYMMETRIC_KEY_LENGTH) new_kek = os.urandom(SYMMETRIC_KEY_LENGTH) def setUp(self): self.contact_list = ContactList(nicks=[LOCAL_ID, 'Alice']) self.key_list = KeyList(nicks=[LOCAL_ID, 'Alice']) self.window_list = WindowList(nicks=[LOCAL_ID, 'Alice']) self.settings = Settings() self.ts = datetime.now() self.kdk_hashes = list() self.packet_hashes = list() self.l_queue = Queue() self.key = os.urandom(SYMMETRIC_KEY_LENGTH) self.hek = os.urandom(SYMMETRIC_KEY_LENGTH) self.conf_code = os.urandom(CONFIRM_CODE_LENGTH) self.packet = encrypt_and_sign(self.key + self.hek + self.conf_code, key=self.kek) self.args = (self.window_list, self.contact_list, self.key_list, self.settings, self.kdk_hashes, self.packet_hashes, self.l_queue) def tearDown(self): tear_queue(self.l_queue) @mock.patch('tkinter.Tk', return_value=MagicMock()) @mock.patch('time.sleep', return_value=None) @mock.patch( 'builtins.input', return_value='5KfgdgUvseWfNkoUPWSvxMPNStu5wBBxyjz1zpZtLEjk7ZvwEAT') def test_invalid_decryption_key_raises_fr(self, *_): # Setup packet = b'' self.key_list.keysets = [] # Test self.assert_fr("Error: Incorrect key decryption key.", process_local_key, self.ts, packet, *self.args) @mock.patch('tkinter.Tk', return_value=MagicMock()) @mock.patch('time.sleep', return_value=None) @mock.patch('builtins.input', side_effect=[ '5KfgdgUvseWfNkoUPWSvxMPNStu5wBBxyjz1zpZtLEjk7ZvwEAT', b58encode(kek) ]) def test_successful_local_key_processing_with_existing_local_key(self, *_): self.assert_fr("Error: Incorrect key decryption key.", process_local_key, self.ts, self.packet, *self.args) self.assertIsNone(process_local_key(self.ts, self.packet, *self.args)) @mock.patch('tkinter.Tk', return_value=MagicMock()) @mock.patch('time.sleep', return_value=None) @mock.patch('builtins.input', return_value=b58encode(kek)) def test_successful_local_key_processing_existing_bootstrap(self, *_): # Setup self.key_list.keysets = [] # Test self.assertIsNone(process_local_key(self.ts, self.packet, *self.args)) self.assertEqual(self.window_list.active_win.uid, WIN_UID_LOCAL) @mock.patch('tkinter.Tk', return_value=MagicMock()) @mock.patch('time.sleep', return_value=None) @mock.patch('builtins.input', side_effect=KeyboardInterrupt) def test_keyboard_interrupt_raises_fr(self, *_): # Setup self.window_list.active_win = self.window_list.get_window( nick_to_pub_key('Alice')) # Test self.assert_fr("Local key setup aborted.", process_local_key, self.ts, bytes(SYMMETRIC_KEY_LENGTH), *self.args) @mock.patch('tkinter.Tk', return_value=MagicMock()) @mock.patch('os.system', return_value=None) @mock.patch('time.sleep', return_value=None) @mock.patch('builtins.input', side_effect=[ b58encode(kek), b58encode(kek), b58encode(kek), b58encode(new_kek) ]) def test_old_local_key_packet_raises_fr(self, *_): # Setup self.key_list.keysets = [] new_key = os.urandom(SYMMETRIC_KEY_LENGTH) new_hek = os.urandom(SYMMETRIC_KEY_LENGTH) new_conf_code = os.urandom(CONFIRM_CODE_LENGTH) new_packet = encrypt_and_sign(new_key + new_hek + new_conf_code, key=self.new_kek) # Test self.assertIsNone(process_local_key(self.ts, self.packet, *self.args)) self.assert_fr("Error: Received old local key packet.", process_local_key, self.ts, self.packet, *self.args) self.assertIsNone(process_local_key(self.ts, new_packet, *self.args)) @mock.patch( 'tkinter.Tk', side_effect=[ MagicMock( clipboard_get=MagicMock(return_value=b58encode(new_kek)), clipboard_clear=MagicMock(side_effect=[tkinter.TclError])) ]) @mock.patch('os.system', return_value=None) @mock.patch('time.sleep', return_value=None) @mock.patch('builtins.input', side_effect=[b58encode(new_kek)]) def test_loading_local_key_from_queue(self, *_): # Setup self.key_list.keysets = [] new_key = os.urandom(SYMMETRIC_KEY_LENGTH) new_hek = os.urandom(SYMMETRIC_KEY_LENGTH) new_conf_code = os.urandom(CONFIRM_CODE_LENGTH) new_packet = encrypt_and_sign(new_key + new_hek + new_conf_code, key=self.new_kek) next_packet = os.urandom(len(new_packet)) first_packet = os.urandom(len(new_packet)) self.l_queue.put((datetime.now(), first_packet)) self.l_queue.put((datetime.now(), new_packet)) self.l_queue.put((datetime.now(), next_packet)) # Test self.assertEqual(self.l_queue.qsize(), 3) self.assertIsNone(process_local_key(self.ts, self.packet, *self.args)) self.assertEqual(self.l_queue.qsize(), 1)
class TestContactSetting(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) def test_invalid_window_raises_fr(self): # Setup cmd_data = ENABLE + US_BYTE + b'*****@*****.**' header = CHANGE_LOGGING_HEADER self.contact_list = ContactList(nicks=['Alice']) self.window_list = WindowList(contact_list=self.contact_list, group_list=self.group_list) # Test self.assertFR("Error: Found no window for '*****@*****.**'", contact_setting, cmd_data, self.ts, self.window_list, self.contact_list, self.group_list, header) def test_setting_change_contact(self): # Setup self.window = self.window_list.get_window('*****@*****.**') 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', CHANGE_LOGGING_HEADER), ('notifications', CHANGE_NOTIFY_HEADER), ('file_reception', CHANGE_FILE_R_HEADER)]: for s in [ENABLE, ENABLE, DISABLE, DISABLE]: cmd_data = s + US_BYTE + b'*****@*****.**' self.assertIsNone( contact_setting(cmd_data, self.ts, self.window_list, self.contact_list, self.group_list, header)) self.assertEqual( self.contact_list.get_contact( '*****@*****.**').__getattribute__(attr), (s == ENABLE)) def test_setting_change_group(self): # Setup self.window = self.window_list.get_window('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', CHANGE_LOGGING_HEADER), ('notifications', CHANGE_NOTIFY_HEADER), ('file_reception', CHANGE_FILE_R_HEADER)]: for s in [ENABLE, ENABLE, DISABLE, DISABLE]: cmd_data = s + US_BYTE + b'test_group' self.assertIsNone( contact_setting(cmd_data, self.ts, self.window_list, self.contact_list, self.group_list, header)) if header in [CHANGE_LOGGING_HEADER, CHANGE_NOTIFY_HEADER]: self.assertEqual( self.group_list.get_group( 'test_group').__getattribute__(attr), (s == ENABLE)) if header == CHANGE_FILE_R_HEADER: 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('*****@*****.**') 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', CHANGE_LOGGING_HEADER), ('notifications', CHANGE_NOTIFY_HEADER), ('file_reception', CHANGE_FILE_R_HEADER)]: for s in [ENABLE, ENABLE, DISABLE, DISABLE]: cmd_data = s.upper() + US_BYTE self.assertIsNone( contact_setting(cmd_data, self.ts, self.window_list, self.contact_list, self.group_list, header)) if header in [CHANGE_LOGGING_HEADER, CHANGE_NOTIFY_HEADER]: 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 == CHANGE_FILE_R_HEADER: for c in self.contact_list.get_list_of_contacts(): self.assertEqual(c.__getattribute__(attr), (s == ENABLE))