def run_server(self, name=None):
self.server.bind((self.server_ip, self.server_port))
self.server.listen(3)
s, p = self.server.accept()
siz = nfb.get_byte_size_of_file(self.path, self.file)
send = True
if name is not None:
command, src_des, temp_data = nfb.extract_tcp_message(s)
self.assertEqual(nfb.DownloadData.command, command)
name = nfb.extract_download_data(temp_data)
if not self.file == name:
send = False
if send:
temp_info = nfb.prepare_file_info(name='test', partNums=4)
rsp_found = nfb.prepare_response_data(nfb.FOUND_RESPONSE_TEXT,
bytearray(temp_info,
nfb.ENCODE_MODE,
nfb.ERROR_ENCODING))
s.send(nfb.ResponseData(rsp_found,
nfb.AddressIp(self.server_ip,
self.server_port,
None,
None),
nfb.AddressIp('127.14.0.9',
12546,
None,
None)
).get_data()
)
for i in range(siz):
temp = nfb.get_ith_mb_from(self.path, self.file, i)
rsp_data = nfb.prepare_response_data(f'{self.file}_part{i}', temp)
rsp_mes = nfb.ResponseData(rsp_data, nfb.AddressIp(self.server_ip,
self.server_port,
None, None),
self.client)
s.send(rsp_mes.get_data())
rsp_done = nfb.prepare_response_data(f'{nfb.SENDING_WAS_FINISHED}',
bytearray(2))
s.send(nfb.ResponseData(rsp_done,
nfb.AddressIp(self.server_ip,
self.server_port,
None,
None),
nfb.AddressIp('127.0.0.9',
12546,
None,
None)
).get_data()
)
sleep(2)
s.close()
self.server.close()
def test_update_proxy_of_server(self):
addr = [nfb.AddressIp(IP, 4000, None, None),
nfb.AddressIp('127.0.1.24', 2545, None, None)]
node_ip = nfb.AddressIp('my ip', 200, None, None)
dict_temp = {IP: addr[0],
'127.0.1.24': addr[1]}
nfb.update_proxy_of_server(dict_temp, node_ip)
self.assertTrue(node_ip.__eq__(nfb.AddressIp('my ip', 200, IP, 4000)))
def test_AddressIp(self):
ip = nfb.AddressIp(IP, 12323, None, None)
ip2 = nfb.AddressIp(IP, 12323, None, None)
ip3 = nfb.AddressIp('127.2.6.4', 4561, IP, None)
ip4 = nfb.AddressIp('127.2.6.4', 4561, IP, 5523)
self.assertEqual(ip, ip2)
print(ip.get_file_format())
print(ip2.get_file_format())
print(ip3.get_file_format())
print(ip4.get_file_format())
def client_discovery(self):
src = self.client
addr = [nfb.AddressIp(IP, 4000, None, None),
nfb.AddressIp('127.0.1.24', 2545, None, None),
self.udp.host_info]
dict_temp = {addr[0].ip: addr[0],
addr[1].ip: addr[1],
addr[2].ip: addr[2]}
send, hub = nfb.is_there_next_des(src, self.udp.host_info)
nfb.send_directory_message_to(dict_temp,
src,
self.udp.host_info,
hub)
def test_prepare_directory_message(self):
test = {'amir': nfb.AddressIp('amir', 232, 'io3232', 54645, 'node_name'),
'ali': nfb.AddressIp('ali', 545, None, None, 'node_name1')}
test_str = '{ip}, {portNum}, {ipp}, {ppn}, {name}|{ip1}, {portNum1}, {ipp1}, {ppn1}, {name1}'.format(
ip='amir',
portNum=232,
ipp='io3232',
ppn=54645,
ip1='ali',
portNum1=545,
ipp1=None,
ppn1=None,
name='node_name',
name1='node_name1'
)
print(test['amir'])
print(test['amir'].get_file_format())
print(test['amir'].get_format())
print(test_str)
mes = nfb.prepare_directory_message(test)
self.assertEqual(mes, test_str)
def test_discovery(self):
self.udp.start()
sleep(.2)
self.client_discovery()
addr = [nfb.AddressIp(IP, 4000, None, None),
nfb.AddressIp('127.0.1.24', 2545, None, None),
self.client]
dict_temp = {addr[0].ip: addr[0],
addr[1].ip: addr[1],
addr[2].ip: addr[2]}
sleep(.2)
self.assertDictEqual(dict_temp, self.udp.dis_dict)
temp_udp_address = nfb.AddressIp(self.udp.host_info.ip,
self.udp.host_info.pn,
IP,
4000)
self.assertTrue(temp_udp_address.__eq__(self.udp.host_info))
self.udp.stop()
def test_extract_get_response_data(self):
temp_data = b'name:<TEST>|tcp_addr:127.0.0.5,'
temp_data += b' 2000, 192.168.0.2, 5000,'
temp_data += b' node0|service_mode:READY|asp:0.25'
temp_info = nfb.extract_get_response_data(bytearray(temp_data))
print(temp_info)
self.assertEqual('<TEST>', temp_info['name'])
addr = nfb.extract_address_ip_format(temp_info['tcp_addr'], is_bytes=False)[0]
test_addr = nfb.AddressIp('127.0.0.5',
2000,
'192.168.0.2',
5000,
'node0')
self.assertEqual(0.25, float(temp_info['asp']))
self.assertEqual(nfb.SERVICE_MODE_READY, temp_info['service_mode'])
self.assertEqual(test_addr, addr)
def test_download_file_from(self):
t = threading.Thread(target=self.run_server)
t.start()
sleep(1)
server = nfb.AddressIp(self.server_ip, self.server_port, None, None)
state, name, path = nfb.download_file_from(self.file,
self.client,
server,
TEST_PATH + os.sep + 'test_download_file_from')
self.assertTrue(state)
self.assertEqual(self.file + '_part0', name)
self.assertTrue(name in os.listdir(TEST_PATH + os.sep + 'test_download_file_from'))
if state:
i = name.rfind('_', 0, len(name))
main_name = name[:i]
nfb.assemble_files(path, name, path, main_name, start_zero=True)
class TestDownload(ut.TestCase):
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_port = 40000
server_ip = '127.0.0.5'
path = BASE_FILES_PATH
file = TEST_FILE_NAME['MUSIC']
client = nfb.AddressIp('127.0.0.9', 12546, None, None)
def run_server(self, name=None):
self.server.bind((self.server_ip, self.server_port))
self.server.listen(3)
s, p = self.server.accept()
siz = nfb.get_byte_size_of_file(self.path, self.file)
send = True
if name is not None:
command, src_des, temp_data = nfb.extract_tcp_message(s)
self.assertEqual(nfb.DownloadData.command, command)
name = nfb.extract_download_data(temp_data)
if not self.file == name:
send = False
if send:
temp_info = nfb.prepare_file_info(name='test', partNums=4)
rsp_found = nfb.prepare_response_data(nfb.FOUND_RESPONSE_TEXT,
bytearray(temp_info,
nfb.ENCODE_MODE,
nfb.ERROR_ENCODING))
s.send(nfb.ResponseData(rsp_found,
nfb.AddressIp(self.server_ip,
self.server_port,
None,
None),
nfb.AddressIp('127.14.0.9',
12546,
None,
None)
).get_data()
)
for i in range(siz):
temp = nfb.get_ith_mb_from(self.path, self.file, i)
rsp_data = nfb.prepare_response_data(f'{self.file}_part{i}', temp)
rsp_mes = nfb.ResponseData(rsp_data, nfb.AddressIp(self.server_ip,
self.server_port,
None, None),
self.client)
s.send(rsp_mes.get_data())
rsp_done = nfb.prepare_response_data(f'{nfb.SENDING_WAS_FINISHED}',
bytearray(2))
s.send(nfb.ResponseData(rsp_done,
nfb.AddressIp(self.server_ip,
self.server_port,
None,
None),
nfb.AddressIp('127.0.0.9',
12546,
None,
None)
).get_data()
)
sleep(2)
s.close()
self.server.close()
def test_recv_data(self):
t = threading.Thread(target=self.run_server)
t.start()
sleep(1)
skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
skt.connect((self.server_ip, self.server_port))
nfb.extract_tcp_message(skt)
state, name, path = nfb.recv_data(skt,
TEST_PATH + os.sep + 'test_recv_data')
skt.close()
if state:
i = name.rfind('_', 0, len(name))
main_name = name[:i]
nfb.assemble_files(path, name, path, main_name, start_zero=True)
self.assertTrue(state)
def test_download_file_from(self):
t = threading.Thread(target=self.run_server)
t.start()
sleep(1)
server = nfb.AddressIp(self.server_ip, self.server_port, None, None)
state, name, path = nfb.download_file_from(self.file,
self.client,
server,
TEST_PATH + os.sep + 'test_download_file_from')
self.assertTrue(state)
self.assertEqual(self.file + '_part0', name)
self.assertTrue(name in os.listdir(TEST_PATH + os.sep + 'test_download_file_from'))
if state:
i = name.rfind('_', 0, len(name))
main_name = name[:i]
nfb.assemble_files(path, name, path, main_name, start_zero=True)
class TestSocketFunction(ut.TestCase):
address = socket.gethostbyname(socket.gethostname())
# udp
udp_server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp_client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp_server_port = 6000
udp_client_port = 6010
# tcp
tcp_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcp_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcp_server_port = 4000
tcp_client_port = 4010
udp_address_list = [nfb.AddressIp(address, udp_server_port, None, None),
nfb.AddressIp('127.0.0.5', udp_client_port, None, None)]
udp_address_src_des_dict = {nfb.SRC: udp_address_list[1],
nfb.DES: udp_address_list[0]}
tcp_address_list = [nfb.AddressIp(address, tcp_server_port, None, None),
nfb.AddressIp('127.0.1.5', tcp_client_port, None, None)]
tcp_address_src_des_dict = {nfb.SRC: tcp_address_list[0],
nfb.DES: tcp_address_list[1]}
test_txt = '<TEST>'
test_udp_data = bytearray(b'\x12\x34')
test_tcp_data = bytearray(list((2 ** x) - 1 for x in range(1, 9)))
def test_all(self):
self.test_extract_udp_message()
self.test_extract_tcp_message()
def initialize_tcp_server(self):
self.tcp_server.bind((self.address, self.tcp_server_port))
def initialize_udp_server(self):
self.udp_server.bind((self.address, self.udp_server_port))
def start_listening(self):
self.tcp_server.listen(3)
s, t = self.tcp_server.accept()
mes = nfb.Message(self.test_tcp_data,
self.tcp_address_src_des_dict[nfb.SRC],
self.tcp_address_src_des_dict[nfb.DES])
s.send(mes.get_data())
s.close()
self.tcp_server.close()
def test_initialize(self):
self.initialize_udp_server()
self.initialize_tcp_server()
def test_extract_udp_message(self):
self.initialize_udp_server()
temp_mes = nfb.prepare_response_data(self.test_txt, self.test_udp_data)
self.test_message = nfb.ResponseData(temp_mes,
self.udp_address_list[1],
self.udp_address_list[0])
s_data = self.test_message.get_data() + bytearray(500 * 100 - len(self.test_message.get_data()))
self.udp_client.sendto(s_data,
(self.address,
self.udp_server_port))
command, src_des, raw_data = nfb.extract_udp_message(self.udp_server)
self.assertEqual(command, nfb.ResponseData.command)
self.assertDictEqual(src_des, self.udp_address_src_des_dict)
txt, b_data = nfb.extract_response_data(raw_data)
self.assertEqual(txt, self.test_txt)
self.assertEqual(b_data, self.test_udp_data)
self.udp_server.close()
self.udp_client.close()
def test_extract_tcp_message(self):
self.initialize_tcp_server()
t = threading.Thread(target=self.start_listening)
t.start()
sleep(1)
server = self.tcp_address_src_des_dict[nfb.SRC]
self.tcp_client.connect((server.ip, server.pn))
command, src_des, temp_data = nfb.extract_tcp_message(self.tcp_client)
self.assertEqual(nfb.Message.command, command)
self.assertDictEqual(self.tcp_address_src_des_dict, src_des)
self.assertEqual(self.test_tcp_data, temp_data)
self.tcp_client.close()
class TestFunctions(ut.TestCase):
test_address_list = [nfb.AddressIp('amir', 232, 'io3232', 54645),
nfb.AddressIp('ali', 545, None, None)]
test_address_dict = {test_address_list[0].ip: test_address_list[0],
test_address_list[1].ip: test_address_list[1]}
test_address_str = " 'amir' , 232, 'io3232', 54645 | 'ali', 545, 'None', 'None'"
test_address_encoded = test_address_str.encode(nfb.ENCODE_MODE, nfb.ERROR_ENCODING)
test_src_des_str = " 'amir' , 232, 'io3232', 54645 | 'ali', 545, 'None', 'None'"
test_src_des_encoded = test_src_des_str.encode(nfb.ENCODE_MODE, nfb.ERROR_ENCODING)
test_address_src_des_dict = {nfb.SRC: test_address_list[0],
nfb.DES: test_address_list[1]}
def test_AddressIp(self):
ip = nfb.AddressIp(IP, 12323, None, None)
ip2 = nfb.AddressIp(IP, 12323, None, None)
ip3 = nfb.AddressIp('127.2.6.4', 4561, IP, None)
ip4 = nfb.AddressIp('127.2.6.4', 4561, IP, 5523)
self.assertEqual(ip, ip2)
print(ip.get_file_format())
print(ip2.get_file_format())
print(ip3.get_file_format())
print(ip4.get_file_format())
def test_all(self):
self.test_get_size_of_file()
self.test_get_ith_mb_from()
self.test_assemble_files()
self.test_extract_address_ip_format()
self.test_extract_source_and_destination()
self.test_make_directory_dictionary()
self.test_filter_directory_dictionary()
self.test_prepare_directory_message()
self.test_extract_response_data()
self.test_prepare_response_data()
self.test_prepare_get_response()
self.test_extract_download_data()
self.test_update_proxy_of_server()
self.test_prepare_list_of_files()
self.test_extract_list_of_files_data()
self.test_prepare_download_message_data()
self.test_extract_file_info()
self.test_prepare_file_info()
def test_get_size_of_file(self):
size = ceil(7902383 / (10 ** 6))
file_size = nfb.get_byte_size_of_file(BASE_FILES_PATH, 'Awaken.mp3')
self.assertEqual(size, file_size, msg='Error in test_get_size_of_file')
def test_get_ith_mb_from(self):
name = 'download'
path = TEST_PATH + os.sep + self.test_get_ith_mb_from.__name__
des = nfb.File(name, path)
size = nfb.get_byte_size_of_file(BASE_FILES_PATH, TEST_FILE_NAME['MUSIC'])
for i in range(size):
temp_data = nfb.get_ith_mb_from(BASE_FILES_PATH, TEST_FILE_NAME['MUSIC'], i)
des.save_data(temp_data)
self.assertTrue(len(os.listdir(path)), size)
def test_assemble_files(self):
name = 'download'
new_name = 'music.mp3'
path = TEST_PATH + os.sep + self.test_assemble_files.__name__
des = nfb.File(name, path)
size = nfb.get_byte_size_of_file(BASE_FILES_PATH, TEST_FILE_NAME['MUSIC'])
for i in range(size):
temp_data = nfb.get_ith_mb_from(BASE_FILES_PATH, TEST_FILE_NAME['MUSIC'], i)
des.save_data(temp_data)
nfb.assemble_files(path,
name,
path,
new_name)
self.assertTrue(check_two_file(path,
new_name,
BASE_FILES_PATH,
TEST_FILE_NAME['MUSIC']))
def test_extract_address_ip_format(self):
test_list = nfb.extract_address_ip_format(self.test_address_encoded)
self.assertListEqual(test_list, self.test_address_list)
def test_extract_source_and_destination(self):
test_dict = nfb.extract_source_and_destination(bytearray(self.test_address_encoded))
self.assertDictEqual(test_dict, self.test_address_src_des_dict)
def test_make_directory_dictionary(self):
temp = (self.test_address_str.encode('utf-8', 'ignore'))
temp_res = nfb.make_directory_dictionary(temp)
self.assertDictEqual(temp_res, self.test_address_dict)
test_list = " 'amir' , 232, 'io3232', 546,45 | 'ali', 545, 'None', 'None'"
def test_filter_directory_dictionary(self):
d = {self.test_address_list[1].ip: self.test_address_list[1]}
d = nfb.filter_directory_dictionary(self.test_address_list[1],
self.test_address_list[0],
d)
self.assertDictEqual({self.test_address_list[0].ip: self.test_address_list[0]},
d)
def test_prepare_directory_message(self):
test = {'amir': nfb.AddressIp('amir', 232, 'io3232', 54645, 'node_name'),
'ali': nfb.AddressIp('ali', 545, None, None, 'node_name1')}
test_str = '{ip}, {portNum}, {ipp}, {ppn}, {name}|{ip1}, {portNum1}, {ipp1}, {ppn1}, {name1}'.format(
ip='amir',
portNum=232,
ipp='io3232',
ppn=54645,
ip1='ali',
portNum1=545,
ipp1=None,
ppn1=None,
name='node_name',
name1='node_name1'
)
print(test['amir'])
print(test['amir'].get_file_format())
print(test['amir'].get_format())
print(test_str)
mes = nfb.prepare_directory_message(test)
self.assertEqual(mes, test_str)
def test_extract_response_data(self):
test_mes = b'\x0A\x00\x00\x02h123456789\x12\x34'
txt, raw_data = nfb.extract_response_data(bytearray(test_mes))
self.assertEqual(txt, 'h123456789')
self.assertEqual(raw_data, b'\x12\x34')
def test_extract_get_response_data(self):
temp_data = b'name:<TEST>|tcp_addr:127.0.0.5,'
temp_data += b' 2000, 192.168.0.2, 5000,'
temp_data += b' node0|service_mode:READY|asp:0.25'
temp_info = nfb.extract_get_response_data(bytearray(temp_data))
print(temp_info)
self.assertEqual('<TEST>', temp_info['name'])
addr = nfb.extract_address_ip_format(temp_info['tcp_addr'], is_bytes=False)[0]
test_addr = nfb.AddressIp('127.0.0.5',
2000,
'192.168.0.2',
5000,
'node0')
self.assertEqual(0.25, float(temp_info['asp']))
self.assertEqual(nfb.SERVICE_MODE_READY, temp_info['service_mode'])
self.assertEqual(test_addr, addr)
def test_prepare_response_data(self):
test_txt = '<TEST>'
test_data = bytearray(b'\x12\x74')
test_message = nfb.prepare_response_data(test_txt, test_data)
test_data = b'\x06\x00\x00\x02<TEST>\x12\x74'
self.assertEqual(test_message, test_data)
def test_prepare_get_response(self):
test_txt = '<TEST>'
test_message = nfb.prepare_get_response(test_txt, TEST_SRC, 0.25, nfb.SERVICE_MODE_READY)
temp1 = f'name:{test_txt}|tcp_addr:{TEST_SRC.get_format()}|service_mode:{nfb.SERVICE_MODE_READY}|'
temp1 += f'apg:0.25'
test_data = bytearray(temp1, nfb.ENCODE_MODE, nfb.ERROR_ENCODING)
self.assertEqual(test_data, test_message)
def test_extract_download_data(self):
name = '<DOWNLOAD>'
name_len = int.to_bytes(len(name),
2,
'big',
signed=False)
dd = bytearray(name_len) + name.encode(nfb.ENCODE_MODE, nfb.ERROR_ENCODING)
self.assertEqual(name, nfb.extract_download_data(dd))
def test_update_proxy_of_server(self):
addr = [nfb.AddressIp(IP, 4000, None, None),
nfb.AddressIp('127.0.1.24', 2545, None, None)]
node_ip = nfb.AddressIp('my ip', 200, None, None)
dict_temp = {IP: addr[0],
'127.0.1.24': addr[1]}
nfb.update_proxy_of_server(dict_temp, node_ip)
self.assertTrue(node_ip.__eq__(nfb.AddressIp('my ip', 200, IP, 4000)))
def test_prepare_list_of_files(self):
name_list = ['jack.mkv', 'hello.txt', 'music']
test_data = bytearray('|'.join(name_list), nfb.ENCODE_MODE, nfb.ERROR_ENCODING)
temp_data = nfb.prepare_list_of_files(name_list)
self.assertEqual(test_data, temp_data)
def test_extract_list_of_files_data(self):
txt = 'name1|name2|name3|name4'
txt_byte = txt.encode(nfb.ENCODE_MODE, nfb.ERROR_ENCODING)
txt_list = ['name1', 'name2', 'name3', 'name4']
self.assertListEqual(txt_list, nfb.extract_list_of_files_data(bytearray(txt_byte)))
def test_prepare_download_message_data(self):
name = 'Test file'
bi_name = bytearray(b'\x00\x09') + bytearray(name, nfb.ENCODE_MODE, nfb.ERROR_ENCODING)
self.assertEqual(bi_name, nfb.prepare_download_message_data(name))
def test_prepare_file_info(self):
info = nfb.prepare_file_info(name='<name>',
partNums=5,
not_valid_key=55,
tcp_addr='127.0.2.3',
apg=.25)
print(info)
self.assertEqual('name:<name>|partNums:5|tcp_addr:127.0.2.3|apg:0.25', info)
def test_extract_file_info(self):
info = 'name:<name>|partNums:5|tcp_addr:127.0.2.3|apg:0.25'
temp_data = nfb.extract_file_info(bytearray(info.encode(nfb.ENCODE_MODE, nfb.ERROR_ENCODING)))
temp_dict = {'name': '<name>', 'partNums': '5', 'apg': '0.25', 'tcp_addr': '127.0.2.3'}
self.assertDictEqual(temp_dict, temp_data)
class TestUdpServer(ut.TestCase):
server_ip = '127.0.1.16'
server_port = 48856
tcp = nfb.TcpServer(TEST_PATH + os.sep + 'TestTcpServer', server_ip)
client = nfb.AddressIp('127.0.1.14', 44533, None, None)
dict_list = {}
udp = nfb.UdpServer(TEST_PATH + os.sep + 'TestUdpServer',
dict_list,
threading.Lock(),
server_ip,
server_port,
tcp)
def test_start_and_stop(self):
self.udp.start()
sleep(2)
self.udp.stop()
sleep(1)
def client_server(self):
skt = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
skt.bind((self.client.ip, self.client.pn))
nfb.send_message_to_get_file('hello.txt',
self.client,
self.udp.host_info,
(self.udp.host_info.ip, self.udp.host_info.pn))
existence_file = 'BACKGROUND FULL HD (5).JPG'
nfb.send_message_to_get_file(existence_file,
self.client,
self.udp.host_info,
(self.udp.host_info.ip, self.udp.host_info.pn))
nfb.send_message_to_get_file('Test.txt',
self.client,
self.udp.host_info,
(self.udp.host_info.ip, self.udp.host_info.pn))
cmd, src_des, temp_data = nfb.extract_udp_message(skt)
self.assertEqual(nfb.ResponseData.command, cmd)
txt, temp_data = nfb.extract_response_data(temp_data)
temp_dict = nfb.extract_get_response_data(temp_data)
self.assertEqual(nfb.FOUND_RESPONSE_TEXT, txt)
self.assertEqual(self.tcp.host_info, temp_dict['tcp_addr'])
self.assertEqual(existence_file, temp_dict['name'])
md, src_des, temp_data = nfb.extract_udp_message(skt)
self.assertEqual(nfb.ResponseData.command, cmd)
txt, temp_data = nfb.extract_response_data(temp_data)
temp_dict = nfb.extract_get_response_data(temp_data)
self.assertEqual(nfb.FOUND_RESPONSE_TEXT, txt)
self.assertEqual(self.tcp.host_info, temp_dict['tcp_addr'])
self.assertEqual('Test.txt', temp_dict['name'])
skt.close()
def client_discovery(self):
src = self.client
addr = [nfb.AddressIp(IP, 4000, None, None),
nfb.AddressIp('127.0.1.24', 2545, None, None),
self.udp.host_info]
dict_temp = {addr[0].ip: addr[0],
addr[1].ip: addr[1],
addr[2].ip: addr[2]}
send, hub = nfb.is_there_next_des(src, self.udp.host_info)
nfb.send_directory_message_to(dict_temp,
src,
self.udp.host_info,
hub)
def test_discovery(self):
self.udp.start()
sleep(.2)
self.client_discovery()
addr = [nfb.AddressIp(IP, 4000, None, None),
nfb.AddressIp('127.0.1.24', 2545, None, None),
self.client]
dict_temp = {addr[0].ip: addr[0],
addr[1].ip: addr[1],
addr[2].ip: addr[2]}
sleep(.2)
self.assertDictEqual(dict_temp, self.udp.dis_dict)
temp_udp_address = nfb.AddressIp(self.udp.host_info.ip,
self.udp.host_info.pn,
IP,
4000)
self.assertTrue(temp_udp_address.__eq__(self.udp.host_info))
self.udp.stop()
def test_get_message_handler(self):
self.udp.start()
self.client_server()
self.udp.stop()
def test_find_file(self):
path = TEST_PATH + os.sep + 'TestUdpServer'
dir_temp = {}
ip = '127.0.1.17'
temp_tcp = nfb.TcpServer(path, ip)
temp_udp = nfb.UdpServer(path, dir_temp, threading.Lock(), ip, 40000, temp_tcp)
temp_tcp.start()
temp_udp.start()
self.udp.start()
sleep(2)
self.udp.dis_dict.update({temp_udp.host_info.ip: temp_udp.host_info})
state = self.udp.find_file('BACKGROUND FULL HD (5).JPG')
self.assertIsNotNone(state)
state = self.udp.find_file('BACKGROUND.JPG')
self.assertIsNone(state)
state = self.udp.find_file('BACKGROUND FULL HD (5).JPG')
self.assertIsNotNone(state)
temp_udp.stop()
self.udp.stop()
temp_tcp.stop()
class TestTcpServer(ut.TestCase):
path = TEST_PATH + os.sep + 'TestTcpServer'
client = nfb.AddressIp('127.0.0.16', 4433, None, None)
tcp = nfb.TcpServer(path, IP)
file = 'File'
def test_start_and_stop(self):
self.tcp.start()
sleep(2)
self.tcp.stop()
sleep(1)
def download_file(self, name, isfile):
dn = nfb.prepare_download_message_data(name)
dn = nfb.DownloadData(dn, self.client, self.tcp.host_info)
skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
skt.connect((self.tcp.host_info.ip, self.tcp.host_info.pn))
skt.send(dn.get_data())
cmd, src_des, temp_data = nfb.extract_tcp_message(skt)
if isfile:
self.assertEqual(nfb.ResponseData.command, cmd)
self.assertDictEqual({nfb.SRC: self.tcp.host_info,
nfb.DES: self.client}, src_des)
txt, temp_data = nfb.extract_response_data(temp_data)
temp_dict = nfb.extract_get_response_data(temp_data)
self.assertEqual(nfb.FOUND_RESPONSE_TEXT, txt)
self.assertEqual(name, temp_dict['name'])
nfb.recv_data(skt, self.tcp.path)
else:
self.assertEqual(nfb.ResponseData.command, cmd)
self.assertDictEqual({nfb.SRC: self.tcp.host_info,
nfb.DES: self.client}, src_des)
txt, temp_data = nfb.extract_response_data(temp_data)
print(temp_data)
temp_dict = nfb.extract_get_response_data(temp_data)
self.assertEqual(nfb.NOT_FOUND_RESPONSE_TEXT, txt)
self.assertEqual(name, temp_dict['name'])
skt.close()
def test_response(self):
self.tcp.start()
sleep(1)
self.download_file(self.file, False)
sleep(1)
name = 'BACKGROUND FULL HD (5).JPG'
self.download_file(name, True)
sleep(0.2)
self.tcp.stop()
def test_download(self):
self.tcp.start()
name = 'BACKGROUND FULL HD (5).JPG'
sleep(0.2)
temp = nfb.download_file_from(name,
self.tcp.host_info,
self.tcp.host_info,
self.tcp.path + os.sep + 'test_download')
self.assertTrue(temp[0])
self.assertEqual('F:\\Amir\\University\\Computer Network\\Project\\NetWolf\\Test\\TestTcpServer\\test_download',
temp[2])
self.tcp.stop()
import os
import socket
import threading
from time import sleep
from math import ceil
LIST_TEST_PATH = ['F:', 'Amir', 'University', 'Computer Network', 'Project', 'NetWolf', 'Test']
LIST_BASE_FILES_PATH = ['F:', 'Amir', 'University', 'Computer Network', 'Project', 'NetWolf', 'Files_for_testing']
TEST_PATH = f'{os.sep}'.join(LIST_TEST_PATH)
BASE_FILES_PATH = f'{os.sep}'.join(LIST_BASE_FILES_PATH)
IP = socket.gethostbyname(socket.gethostname())
TEST_FILE_NAME = {'MUSIC': 'Awaken.mp3', 'PICTURE': 'BACKGROUND FULL HD (5).JPG'}
TEST_SRC = nfb.AddressIp('127.0.0.5', 2000, '192.168.0.2', 5000)
TEST_DES = nfb.AddressIp('127.0.0.8', 2000, '192.168.0.2', 5000)
def check_two_file(path1: str, name1: str, path2: str, name2: str):
siz1 = nfb.get_byte_size_of_file(path1, name1)
siz2 = nfb.get_byte_size_of_file(path2, name2)
if not siz1 == siz2:
return False
for part in range(siz1):
temp1 = nfb.get_ith_mb_from(path1, name1, part)
temp2 = nfb.get_ith_mb_from(path2, name2, part)
if not temp1 == temp2:
return False
