def test_remove_group_not_on_txm(self):
# Setup
o_input = builtins.input
builtins.input = lambda x: 'Yes'
queues = {COMMAND_PACKET_QUEUE: Queue()}
settings = Settings()
group_list = GroupList()
# Test
self.assertFR("TxM has no group testgroup to remove.", group_rm_member,
'testgroup', [], group_list, None, settings, queues)
self.assertEqual(queues[COMMAND_PACKET_QUEUE].qsize(), 1)
# Teardown
builtins.input = o_input
while not queues[COMMAND_PACKET_QUEUE].empty():
queues[COMMAND_PACKET_QUEUE].get()
time.sleep(0.2)
def test_short_message(self):
# Setup
account = '*****@*****.**'
contact = create_contact('Alice')
origin = ORIGIN_USER_HEADER
type_ = 'message'
settings = Settings()
packet = Packet(account, contact, origin, type_, settings)
message = "Lorem ipsum dolor sit amet, consectetur adipiscing elit"
packets = self.mock_message_preprocessor(message)
# Test
for p in packets:
packet.add_packet(p)
message = packet.assemble_message_packet()
message = message[1:].decode()
self.assertEqual(message, message)
def setUp(self) -> None:
"""Pre-test actions."""
self.unit_test_dir = cd_unit_test()
self.ts = datetime.now()
self.settings = Settings()
self.master_key = MasterKey()
self.group_list = GroupList()
self.exit_queue = Queue()
self.gateway = Gateway()
self.window_list = WindowList(nicks=[LOCAL_ID])
self.contact_list = ContactList(nicks=[LOCAL_ID])
self.packet_list = PacketList(self.settings, self.contact_list)
self.key_list = KeyList(nicks=[LOCAL_ID])
self.key_set = self.key_list.get_keyset(LOCAL_PUBKEY)
self.args = (self.window_list, self.packet_list, self.contact_list,
self.key_list, self.group_list, self.settings,
self.master_key, self.gateway, self.exit_queue)
def test_cancel_file_during_traffic_masking(self) -> None:
# Setup
user_input = UserInput('cf')
settings = Settings(traffic_masking=True)
window = TxWindow()
window.window_contacts = [create_contact('Alice')]
self.queues[TM_FILE_PACKET_QUEUE].put(('testfile1', {
nick_to_pub_key("Alice"): False
}))
self.queues[TM_FILE_PACKET_QUEUE].put(('testfile2', {
nick_to_pub_key("Alice"): False
}))
# Test
self.assertIsNone(
cancel_packet(user_input, window, settings, self.queues))
self.assertEqual(self.queues[TM_FILE_PACKET_QUEUE].qsize(), 1)
def setUp(self) -> None:
"""Pre-test actions."""
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 test_invalid_account_crashes(self):
# Setup
settings = Settings()
gateway = Gateway()
l_queue = Queue()
key_list = KeyList()
key_list.keysets = [create_keyset('Alice')]
# Check that in case where internal error caused bytestring (possible key material)
# to end up in account strings, System raises some error that prevents output of packet.
# In this case the error comes from unsuccessful encoding of string (AttributeError)
# or KeyList lookup error when bytes are used (StopIteration). These errors are not catched.
with self.assertRaises(StopIteration):
send_packet(bytes(256), key_list, settings, gateway, l_queue,
b'*****@*****.**', '*****@*****.**', True)
with self.assertRaises(AttributeError):
send_packet(bytes(256), key_list, settings, gateway, l_queue,
'*****@*****.**', b'*****@*****.**', True)
def test_function(self):
# Setup
ts = datetime.datetime.now()
no_msg = int_to_bytes(1)
cmd_data = b'*****@*****.**' + US_BYTE + no_msg
window_list = WindowList()
contact_list = ContactList()
settings = Settings()
master_key = MasterKey()
write_log_entry(F_S_HEADER + bytes(255), '*****@*****.**', settings,
master_key)
# Test
self.assertIsNone(
export_logs(cmd_data, ts, window_list, contact_list, settings,
master_key))
os.remove('Unittest - Plaintext log (None)')
cleanup()
def setUp(self):
if 'TRAVIS' not in os.environ or not os.environ['TRAVIS'] == 'true':
self.o_getrandom = os.getrandom
self.o_input = builtins.input
self.o_urandom = os.urandom
self.gateway = Gateway()
self.settings = Settings(disable_gui_dialog=True)
self.contact_list = ContactList()
self.group_list = GroupList()
self.master_key = MasterKey()
self.queues = {MESSAGE_PACKET_QUEUE: Queue(),
FILE_PACKET_QUEUE: Queue(),
COMMAND_PACKET_QUEUE: Queue(),
NH_PACKET_QUEUE: Queue(),
LOG_PACKET_QUEUE: Queue(),
EXIT_QUEUE: Queue(),
NOISE_PACKET_QUEUE: Queue(),
NOISE_COMMAND_QUEUE: Queue(),
KEY_MANAGEMENT_QUEUE: Queue(),
WINDOW_SELECT_QUEUE: Queue()}
input_list = ['', # NH Bypass start
'61', # Enter confirmation code
'', # NH Bypass end
'*****@*****.**', # Enter rx-account for new contact
'*****@*****.**', # Enter tx-account for new contact
'', # Enter for auto-nick
'', # Enter to default for X25519
'5JZB2s2RCtRUunKiqMbb6rAj3Z' # Enter public key for contact
'7TkJwa8zknL1cfTFpWoQArd6n',
'Yes', # Accept key fingerprints for Alice
'Alice', # Select Alice as recipient
'Test', # Send test message
'/file', # Open file selection prompt
'', # Give empty string to abort
'/exit'] # Enter exit command
gen = iter(input_list)
builtins.input = lambda _: str(next(gen))
if 'TRAVIS' not in os.environ or not os.environ['TRAVIS'] == 'true':
os.getrandom = lambda n, flags: n * b'a'
os.urandom = lambda n: n * b'a'
self.o_exit_tfc = src.tx.commands.exit_tfc
src.tx.commands.exit_tfc = lambda *_: (_ for _ in ()).throw(SystemExit)
def test_class(self):
# Setup
contact_list = ContactList(nicks=['Alice', 'Bob', 'local'])
contact = contact_list.get_contact('Alice')
contact.notifications = True
group_list = GroupList(groups=['testgroup'], contact_list=contact_list)
settings = Settings()
window1 = Window('*****@*****.**', contact_list, group_list, settings)
window2 = Window('local', contact_list, group_list, settings)
window3 = Window('testgroup', contact_list, group_list, settings)
# Test
with self.assertRaises(ValueError):
Window('charlie', contact_list, group_list, settings)
self.assertEqual(len(window1), 0)
window1.message_log = ['a', 'b']
for m in window1:
self.assertIsInstance(m, str)
window3.remove_contacts(['*****@*****.**'])
self.assertEqual(len(window3.window_contacts), 1)
self.assertFalse(window3.has_contact('*****@*****.**'))
window3.add_contacts(['*****@*****.**'])
self.assertEqual(len(window3.window_contacts), 2)
self.assertTrue(window3.has_contact('*****@*****.**'))
self.assertIsNone(window1.clear_window())
self.assertEqual(len(window1), 2)
self.assertIsNone(window1.reset_window())
self.assertEqual(len(window1), 0)
ts = datetime.datetime.now()
window3.previous_msg_ts = datetime.datetime.strptime('01/01/2017', '%d/%m/%Y')
self.assertIsNone(window3.print_new(ts, 20 * 'test message', '*****@*****.**', print_=True))
self.assertIsNone(window3.print_new(ts, 'test message', '*****@*****.**', print_=True))
window2.is_active = True
self.assertIsNone(window2.print_new(ts, 'test message', print_=True))
window3.message_log = []
self.assertIsNone(window2.redraw())
self.assertIsNone(window3.redraw())
def test_function_allows_control_of_noise_packets_based_on_log_setting_queue(
self) -> None:
# Setup
settings = Settings(log_file_masking=True, traffic_masking=True)
master_key = MasterKey()
queues = gen_queue_dict()
noise_tuple = (nick_to_pub_key('Alice'),
P_N_HEADER + bytes(PADDING_LENGTH), True, True,
master_key)
def queue_delayer() -> None:
"""Place packets to log into queue after delay."""
for _ in range(5):
queues[LOG_PACKET_QUEUE].put(
noise_tuple
) # Not logged because logging_state is False by default
time.sleep(SLEEP_DELAY)
queues[LOG_SETTING_QUEUE].put(True)
for _ in range(2):
queues[LOG_PACKET_QUEUE].put(noise_tuple) # Log two packets
time.sleep(SLEEP_DELAY)
queues[LOG_SETTING_QUEUE].put(False)
for _ in range(3):
queues[LOG_PACKET_QUEUE].put(
noise_tuple) # Not logged because logging_state is False
time.sleep(SLEEP_DELAY)
queues[UNIT_TEST_QUEUE].put(EXIT)
queues[LOG_SETTING_QUEUE].put(True)
queues[LOG_PACKET_QUEUE].put(noise_tuple) # Log third packet
# Test
threading.Thread(target=queue_delayer).start()
self.assertIsNone(
log_writer_loop(queues, settings, self.message_log,
unit_test=True))
# Teardown
tear_queues(queues)
def test_class(self):
# Setup
o_input = builtins.input
input_list = [
'/', '', 'testmessage', '/file', '/nick Alice', 'testmessage',
'/nick Alice', ' '
]
gen = iter(input_list)
def mock_input(_):
return str(next(gen))
builtins.input = mock_input
window = Window(name='Alice',
type='contact',
window_contacts=[create_contact('Alice')])
settings = Settings()
# Test
user_input = UserInput(window, settings)
self.assertEqual(user_input.plaintext, 'testmessage')
self.assertEqual(user_input.type, 'message')
user_input = UserInput(window, settings)
self.assertEqual(user_input.plaintext, '/file')
self.assertEqual(user_input.type, 'file')
user_input = UserInput(window, settings)
self.assertEqual(user_input.plaintext, 'nick Alice')
self.assertEqual(user_input.type, 'command')
window = Window(name='Testgroup', type='group', window_contacts=[])
user_input = UserInput(window, settings)
self.assertEqual(user_input.plaintext, 'nick Alice')
self.assertEqual(user_input.type, 'command')
user_input = UserInput(window, settings)
self.assertEqual(user_input.plaintext, 'clear')
self.assertEqual(user_input.type, 'command')
# Teardown
builtins.input = o_input
def test_normal_contact(self):
# Setup
settings = Settings()
m_queue = Queue()
window = Window(type='contact',
window_contacts=[create_contact('Alice')],
uid='*****@*****.**')
# Short messages
user_input = UserInput(
plaintext=binascii.hexlify(os.urandom(125)).decode())
self.assertIsNone(queue_message(user_input, window, settings, m_queue))
p, s, ra, ta, ls, wu = m_queue.get()
self.assertIsInstance(p, bytes)
self.assertEqual(len(p), 256)
self.assertIsInstance(s, Settings)
self.assertEqual(ra, '*****@*****.**')
self.assertEqual(ta, '*****@*****.**')
self.assertEqual(ls, True)
self.assertEqual(wu, '*****@*****.**')
# Long messages
user_input = UserInput(
plaintext=binascii.hexlify(os.urandom(250)).decode())
self.assertIsNone(queue_message(user_input, window, settings, m_queue))
self.assertEqual(m_queue.qsize(), 2)
while not m_queue.empty():
p, s, ra, ta, ls, wu = m_queue.get()
self.assertIsInstance(p, bytes)
self.assertEqual(len(p), 256)
self.assertIsInstance(s, Settings)
self.assertEqual(ra, '*****@*****.**')
self.assertEqual(ta, '*****@*****.**')
self.assertEqual(ls, True)
self.assertEqual(wu, '*****@*****.**')
# Teardown
time.sleep(0.2)
m_queue.close()
def test_invalid_long_file_header_raises_fr(self):
# Setup
account = '*****@*****.**'
contact = create_contact('Alice')
origin = ORIGIN_CONTACT_HEADER
type_ = 'file'
settings = Settings()
packet = Packet(account, contact, origin, type_, settings)
file_data = os.urandom(10000)
compressed = zlib.compress(file_data, level=9)
file_key = os.urandom(32)
encrypted = encrypt_and_sign(compressed, key=file_key)
encrypted += file_key
encoded = base64.b85encode(encrypted)
file_data = US_BYTE.join([b'testfile.txt', b'11.0B', encoded])
packets = self.mock_file_preprocessor(file_data)
# Test
self.assertFR("Received packet had an invalid header.", packet.add_packet, packets[0])
def test_remove_group_and_notify(self):
# Setup
o_input = builtins.input
builtins.input = lambda x: 'Yes'
queues = {COMMAND_PACKET_QUEUE: Queue(), MESSAGE_PACKET_QUEUE: Queue()}
settings = Settings()
group_list = GroupList(groups=['testgroup'])
# Test
self.assertFR("Removed group testgroup.", group_rm_member, 'testgroup',
[], group_list, None, settings, queues)
self.assertEqual(queues[COMMAND_PACKET_QUEUE].qsize(), 1)
self.assertEqual(queues[MESSAGE_PACKET_QUEUE].qsize(), 2)
# Teardown
builtins.input = o_input
while not queues[COMMAND_PACKET_QUEUE].empty():
queues[COMMAND_PACKET_QUEUE].get()
time.sleep(0.2)
def test_get_contact(self):
# Setup
contact1 = Contact('*****@*****.**', '*****@*****.**', 'Alice',
32 * b'\x01', 32 * b'\x02', True, True, True)
contact2 = Contact('*****@*****.**', '*****@*****.**', 'Charlie',
32 * b'\x01', 32 * b'\x02', True, True, True)
settings = Settings()
master_k = MasterKey()
contact_l = ContactList(master_k, settings)
contact_l.contacts = [contact1, contact2]
# Test
co1 = contact_l.get_contact('*****@*****.**')
self.assertIsInstance(co1, Contact)
self.assertEqual(co1.rx_account, '*****@*****.**')
co2 = contact_l.get_contact('Alice')
self.assertIsInstance(co2, Contact)
self.assertEqual(co2.rx_account, '*****@*****.**')
def test_cancel_group_message_during_normal(self):
# Setup
window = Window(name='testgroup', type='group', uid='testgroup')
user_input = UserInput('cm')
window.window_contacts = [create_contact('Alice')]
settings = Settings()
queues = {MESSAGE_PACKET_QUEUE: Queue(), FILE_PACKET_QUEUE: Queue()}
# Test
queues[MESSAGE_PACKET_QUEUE].put(
('testmessage1', settings, '*****@*****.**', '*****@*****.**',
False, 'testgroup'))
queues[MESSAGE_PACKET_QUEUE].put(
('testmessage2', settings, '*****@*****.**', '*****@*****.**',
False, 'testgroup'))
time.sleep(0.2)
self.assertIsNone(cancel_packet(user_input, window, settings, queues))
time.sleep(0.2)
self.assertEqual(queues[MESSAGE_PACKET_QUEUE].qsize(), 1)
def test_cancel_message_during_trickle(self):
# Setup
user_input = UserInput('cm')
window = Window()
window.window_contacts = [create_contact('Alice')]
settings = Settings(session_trickle=True)
queues = {MESSAGE_PACKET_QUEUE: Queue(), FILE_PACKET_QUEUE: Queue()}
# Test
queues[MESSAGE_PACKET_QUEUE].put(('testmessage1', {
'*****@*****.**': False
}))
queues[MESSAGE_PACKET_QUEUE].put(('testmessage2', {
'*****@*****.**': False
}))
time.sleep(0.2)
self.assertIsNone(cancel_packet(user_input, window, settings, queues))
time.sleep(0.2)
self.assertEqual(queues[MESSAGE_PACKET_QUEUE].qsize(), 1)
def test_valid_message_packet(self):
# Setup
settings = Settings(long_packet_rand_d=True)
gateway = Gateway()
l_queue = Queue()
key_list = KeyList(master_key=bytes(32))
key_list.keysets = [
create_keyset(tx_hek=32 * b'\x01', tx_key=32 * b'\x02', tx_harac=8)
]
# Test
self.assertIsNone(
send_packet(bytes(256), key_list, settings, gateway, l_queue,
'*****@*****.**', '*****@*****.**', True))
self.assertEqual(len(gateway.packets), 1)
self.assertEqual(len(gateway.packets[0]), 396)
time.sleep(0.2)
self.assertFalse(l_queue.empty())
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_enable_notifications_for_user(self):
# Setup
user_input = UserInput('notify on')
contact_list = ContactList(nicks=['Alice'])
group_list = GroupList()
settings = Settings()
c_queue = Queue()
contact = contact_list.get_contact('Alice')
contact.notifications = False
window = Window(uid='*****@*****.**',
type='contact',
contact=contact)
# Test
self.assertFalse(contact.notifications)
self.assertIsNone(
contact_setting(user_input, window, contact_list, group_list,
settings, c_queue))
time.sleep(0.2)
self.assertTrue(contact.notifications)
def test_file_queue_long_normal(self):
# Setup
input_data = os.urandom(200000)
with open('testfile.txt', 'wb+') as f:
f.write(input_data)
settings = Settings(session_trickle=False,
disable_gui_dialog=True,
confirm_sent_files=True)
window = Window(name='Alice',
type='contact',
uid='*****@*****.**',
window_contacts=[create_contact('Alice')])
gateway = Gateway(delay=0.02)
f_queue = Queue()
input_list = ['./testfile.txt', 'Yes']
gen = iter(input_list)
def mock_input(_):
return str(next(gen))
builtins.input = mock_input
# Test
self.assertIsNone(queue_file(window, settings, f_queue, gateway))
time.sleep(1)
self.assertEqual(f_queue.qsize(), 982)
while not f_queue.empty():
p, s, ra, ta, lm, wu = f_queue.get()
self.assertIsInstance(p, bytes)
self.assertIsInstance(s, Settings)
self.assertEqual(ra, '*****@*****.**')
self.assertEqual(ta, '*****@*****.**')
self.assertEqual(wu, '*****@*****.**')
self.assertTrue(lm)
# Teardown
os.remove('testfile.txt')
time.sleep(0.5)
f_queue.close()
time.sleep(0.5)
def test_rxm_command(self):
# Setup
user_input = UserInput("passwd rx")
contact_list = ContactList()
group_list = GroupList()
settings = Settings()
queues = {COMMAND_PACKET_QUEUE: Queue()}
master_key = MasterKey()
# Test
self.assertIsNone(
change_master_key(user_input, contact_list, group_list, settings,
queues, master_key))
# Teardown
while not queues[COMMAND_PACKET_QUEUE].empty():
queues[COMMAND_PACKET_QUEUE].get()
time.sleep(0.2)
def test_loop(self):
# Setup
queues = gen_queue_dict()
settings = Settings(traffic_masking=True,
tm_static_delay=0.001,
tm_random_delay=0.001)
gateway = Gateway()
key_list = KeyList(nicks=['Alice', LOCAL_ID])
window = TxWindow(log_messages=True)
contact_list = ContactList(nicks=['Alice', LOCAL_ID])
window.contact_list = contact_list
window.window_contacts = [
contact_list.get_contact_by_address_or_nick('Alice')
]
user_input = UserInput(plaintext='test')
def queue_delayer():
"""Place packets to queue after delay."""
time.sleep(0.01)
queues[WINDOW_SELECT_QUEUE].put(window.window_contacts)
time.sleep(0.01)
queue_command(b'test', settings, queues) # 1
queue_message(user_input, window, settings, queues) # 2
queue_message(user_input, window, settings, queues) # 3
queue_command(b'test', settings, queues) # 4
queues[TM_NOISE_COMMAND_QUEUE].put(
(C_N_HEADER + bytes(PADDING_LENGTH))) # 5
queue_to_nc(UNENCRYPTED_DATAGRAM_HEADER + UNENCRYPTED_EXIT_COMMAND,
queues[RELAY_PACKET_QUEUE]) # 6
queue_to_nc(UNENCRYPTED_DATAGRAM_HEADER + UNENCRYPTED_WIPE_COMMAND,
queues[RELAY_PACKET_QUEUE]) # 7
queues[SENDER_MODE_QUEUE].put(settings)
# Test
threading.Thread(target=queue_delayer).start()
self.assertIsInstance(
traffic_masking_loop(queues, settings, gateway, key_list),
Settings)
self.assertEqual(len(gateway.packets), 7)
# Teardown
tear_queues(queues)
def test_function(self):
# Setup
user_input = UserInput('about')
window = Window()
settings = Settings()
queues = {COMMAND_PACKET_QUEUE: Queue()}
contact_list = ContactList()
group_list = GroupList()
gateway = Gateway()
master_key = MasterKey()
# Test
self.assertIsNone(
process_command(user_input, window, settings, queues, contact_list,
group_list, gateway, master_key))
user_input = UserInput('abou')
self.assertFR("Invalid command 'abou'.", process_command, user_input,
window, settings, queues, contact_list, group_list,
gateway, master_key)
def test_log_printing_all(self):
# Test
user_input = UserInput("history")
window = Window(uid='*****@*****.**')
contact_list = ContactList()
settings = Settings()
c_queue = Queue()
master_key = MasterKey()
# Test
self.assertFR("Error: Could not find 'user_data/ut_logs'.", print_logs,
user_input, window, contact_list, settings, c_queue,
master_key)
self.assertEqual(c_queue.qsize(), 1)
# Teardown
while not c_queue.empty():
c_queue.get()
time.sleep(0.2)
cleanup()
def test_keyboard_interrupt_raises_fr(self, *_):
# Setup
input_data = os.urandom(2000)
with open('testfile.txt', 'wb+') as f:
f.write(input_data)
window = TxWindow(name='Alice',
type=WIN_TYPE_CONTACT,
type_print='contact',
uid=nick_to_pub_key("Alice"),
window_contacts=[create_contact('Alice')],
log_messages=True)
settings = Settings(traffic_masking=True,
disable_gui_dialog=True,
confirm_sent_files=True,
multi_packet_random_delay=True)
# Test
self.assert_fr("File selection aborted.", queue_file, window, settings, self.queues)
self.assertEqual(self.queues[RELAY_PACKET_QUEUE].qsize(), 0)
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_disable_file_reception_for_user(self):
# Setup
user_input = UserInput('store off')
contact_list = ContactList(nicks=['Alice'])
group_list = GroupList()
settings = Settings()
c_queue = Queue()
contact = contact_list.get_contact('Alice')
contact.file_reception = True
window = Window(uid='*****@*****.**',
type='contact',
contact=contact,
window_contacts=[contact])
# Test
self.assertTrue(contact.file_reception)
self.assertIsNone(
contact_setting(user_input, window, contact_list, group_list,
settings, c_queue))
time.sleep(0.2)
self.assertFalse(contact.file_reception)
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_file_queue_long_normal(self, *_: Any) -> None:
# Setup
input_data = os.urandom(2000)
with open('testfile.txt', 'wb+') as f:
f.write(input_data)
window = TxWindow(name='Alice',
type=WIN_TYPE_CONTACT,
type_print='contact',
uid=nick_to_pub_key("Alice"),
window_contacts=[create_contact('Alice')],
log_messages=True)
settings = Settings(traffic_masking=False,
disable_gui_dialog=True,
confirm_sent_files=True,
multi_packet_random_delay=True)
# Test
self.assertIsNone(queue_file(window, settings, self.queues))
self.assertEqual(self.queues[RELAY_PACKET_QUEUE].qsize(), 1)
