# stop the test return True class SendFileAndDisconnect (SendFileTest): def __init__(self, file, address_type, access_control, acces_control_param): FileTransferTest.__init__(self, file, address_type, access_control, acces_control_param) self._actions = [self.connect, self.set_ft_caps, self.check_ft_available, None, self.wait_for_ft_caps, None, self.request_ft_channel, self.provide_file, None, self.send_file, self.wait_for_completion, self.disconnect, None, self.close_channel, self.done] def disconnect(self): self.conn.Disconnect() if __name__ == '__main__': exec_file_transfer_test(SendFileAndDisconnect, \ ReceiveFileAndSenderDisconnectWhileTransfering)
def request_ft_channel(self): request = { cs.CHANNEL_TYPE: cs.CHANNEL_TYPE_FILE_TRANSFER, cs.TARGET_HANDLE_TYPE: cs.HT_CONTACT, cs.TARGET_HANDLE: self.handle, cs.FT_CONTENT_TYPE: self.file.content_type, cs.FT_FILENAME: self.file.name, cs.FT_SIZE: self.file.size, cs.FT_CONTENT_HASH_TYPE: self.file.hash_type, cs.FT_CONTENT_HASH: self.file.hash, cs.FT_DESCRIPTION: self.file.description, cs.FT_DATE: self.file.date, cs.FT_INITIAL_OFFSET: 0, cs.FT_SERVICE_NAME: self.service_name, cs.FT_METADATA: dbus.Dictionary(self.metadata, signature='sas')} call_async(self.q, self.conn.Requests, 'CreateChannel', request) # no support for metadata, soz self.q.expect('dbus-error', method='CreateChannel', name=cs.NOT_CAPABLE) return True if __name__ == '__main__': exec_file_transfer_test(SendFileNoMetadata, True) exec_file_transfer_test(ReceiveFileNoMetadata, True) exec_file_transfer_test(SendFileOddMetadata, True) exec_file_transfer_test(ReceiveFileOddMetadata, True) exec_file_transfer_test(SendFileBadProps, True) exec_file_transfer_test(SendFileBadContact, True)
from file_transfer_helper import exec_file_transfer_test, ReceiveFileTest from config import FILE_TRANSFER_ENABLED if not FILE_TRANSFER_ENABLED: print("NOTE: built with --disable-file-transfer") raise SystemExit(77) class ReceiveFileAndDisconnectTest(ReceiveFileTest): def receive_file(self): s = self.create_socket() s.connect(self.address) # return True so the test will be ended and the connection # disconnected return True if __name__ == '__main__': exec_file_transfer_test(ReceiveFileAndDisconnectTest)
def client_accept_file(self): # state is still Pending as remote didn't accept the transfer yet state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, "State") assert state == cs.FT_STATE_PENDING SendFileTest.client_accept_file(self) # Remote accepted the transfer e = self.q.expect("dbus-signal", signal="FileTransferStateChanged") state, reason = e.args assert state == cs.FT_STATE_ACCEPTED, state assert reason == cs.FT_STATE_CHANGE_REASON_NONE def provide_file(self): SendFileTest.provide_file(self) e = self.q.expect("dbus-signal", signal="InitialOffsetDefined") offset = e.args[0] assert offset == self.file.offset # Channel is open. We can start to send the file e = self.q.expect("dbus-signal", signal="FileTransferStateChanged") state, reason = e.args assert state == cs.FT_STATE_OPEN assert reason == cs.FT_STATE_CHANGE_REASON_REQUESTED if __name__ == "__main__": exec_file_transfer_test(SendFileTransferWaitToProvideTest)
# get data from bytestream data = '' while len(data) < to_receive: data += self.bytestream.get_data() assert data == self.file.data[self.file.offset:] if self.completed: # FileTransferStateChanged has already been received waiting = [] else: waiting = [EventPattern('dbus-signal', signal='FileTransferStateChanged')] events = self.bytestream.wait_bytestream_closed(waiting) # If not all the bytes transferred have been announced using # TransferredBytesChanged, wait for them while self.count < to_receive: self.q.expect('dbus-signal', signal='TransferredBytesChanged') assert self.count == to_receive if len(waiting) > 1: state, reason = events[0].args assert state == cs.FT_STATE_COMPLETED assert reason == cs.FT_STATE_CHANGE_REASON_NONE if __name__ == '__main__': exec_file_transfer_test(SendFileSendBeforeAccept)
path = self.channel.object_path, args=[cs.FT_STATE_CANCELLED, \ cs.FT_STATE_CHANGE_REASON_REMOTE_STOPPED]) self.close_channel() # stop the test return True class SendFileAndDisconnect(SendFileTest): def __init__(self, file, address_type, access_control, acces_control_param): FileTransferTest.__init__(self, file, address_type, access_control, acces_control_param) self._actions = [ self.connect, self.set_ft_caps, self.check_ft_available, None, self.wait_for_ft_caps, None, self.request_ft_channel, self.provide_file, None, self.send_file, self.wait_for_completion, self.disconnect, None, self.close_channel, self.done ] def disconnect(self): self.conn.Disconnect() if __name__ == '__main__': exec_file_transfer_test(SendFileAndDisconnect, \ ReceiveFileAndSenderDisconnectWhileTransfering)
while len(data) < to_receive: data += self.bytestream.get_data() assert data == self.file.data[self.file.offset:] if self.completed: # FileTransferStateChanged has already been received waiting = [] else: waiting = [ EventPattern('dbus-signal', signal='FileTransferStateChanged') ] events = self.bytestream.wait_bytestream_closed(waiting) # If not all the bytes transferred have been announced using # TransferredBytesChanged, wait for them while self.count < to_receive: self.q.expect('dbus-signal', signal='TransferredBytesChanged') assert self.count == to_receive if len(waiting) > 1: state, reason = events[0].args assert state == cs.FT_STATE_COMPLETED assert reason == cs.FT_STATE_CHANGE_REASON_NONE if __name__ == '__main__': exec_file_transfer_test(SendFileSendBeforeAccept)
import constants as cs from file_transfer_helper import SendFileTest, ReceiveFileTest, \ exec_file_transfer_test from config import JINGLE_FILE_TRANSFER_ENABLED if not JINGLE_FILE_TRANSFER_ENABLED: print "NOTE: built with --disable-file-transfer or --disable-voip" raise SystemExit(77) class ReceiveFileAndCancelWhileReceiving(ReceiveFileTest): def receive_file(self): # Connect to Gabble's socket s = self.create_socket() s.connect(self.address) # for some reason the socket is closed s.close() self.q.expect('dbus-signal', signal='FileTransferStateChanged', args=[ cs.FT_STATE_CANCELLED, cs.FT_STATE_CHANGE_REASON_LOCAL_ERROR ]) if __name__ == '__main__': exec_file_transfer_test(SendFileTest, ReceiveFileAndCancelWhileReceiving)
from file_transfer_helper import SendFileTest, ReceiveFileTest, \ exec_file_transfer_test from config import JINGLE_FILE_TRANSFER_ENABLED if not JINGLE_FILE_TRANSFER_ENABLED: print "NOTE: built with --disable-file-transfer or --disable-voip" raise SystemExit(77) class ReceiveFileAndDisconnectTest(ReceiveFileTest): def receive_file(self): s = self.create_socket() s.connect(self.address) # return True so the test will be ended and the connection # disconnected return True if __name__ == '__main__': exec_file_transfer_test(SendFileTest, ReceiveFileAndDisconnectTest)
reply['id'] = self.iq['id'] error = reply.addElement((None, 'error')) error['code'] = '403' error['type'] = 'cancel' error.addElement((ns.STANZA, 'forbidden')) error.addElement((ns.STANZA, 'text'), content='Offer Declined') self.stream.send(reply) e = self.q.expect('dbus-signal', signal='FileTransferStateChanged') state, reason = e.args assert state == cs.FT_STATE_CANCELLED, state assert reason == cs.FT_STATE_CHANGE_REASON_REMOTE_STOPPED transferred = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'TransferredBytes') # no byte has been transferred as the file was declined assert transferred == 0 # try to provide the file, assert that this finishes the test (e.g. # couldn't go further because of ipv6) or that it raises # cs.NOT_AVAILABLE try: assert self.provide_file() except dbus.DBusException as e: assert e.get_dbus_name() == cs.NOT_AVAILABLE # stop test return True if __name__ == '__main__': exec_file_transfer_test(SendFileDeclinedTest)
# URI is not set assertNoURI(self.ft_channel) ReceiveFileTest.accept_file(self) def close_channel(self): # Still no URI assertNoURI(self.ft_channel) ReceiveFileTest.close_channel(self) class SendFileNoURI(SendFileTest): def request_ft_channel(self): SendFileTest.request_ft_channel(self, False) def close_channel(self): # Still no URI assertNoURI(self.ft_channel) SendFileTest.close_channel(self) if __name__ == '__main__': # We don't define an URI before accepting the file and try to set it after exec_file_transfer_test(SetURIAfterAccepting, True) # Don't define any URI when receiving a file exec_file_transfer_test(ReceiveFileTestNoURI, True) # Don't define any URI when sending a file exec_file_transfer_test(SendFileNoURI, True)
raise SystemExit(77) print("FIXME: test is not stable enough.\n" + " https://bugs.freedesktop.org/show_bug.cgi?id=49595") raise SystemExit(77) class SendFileBeforeAccept(SendFileTest): def __init__(self, file, address_type, access_control, acces_control_param): FileTransferTest.__init__(self, file, address_type, access_control, acces_control_param) self._actions = [self.connect, self.set_ft_caps, self.check_ft_available, None, self.wait_for_ft_caps, None, self.request_ft_channel, self.provide_file, self.set_open, self.send_file, None, self.wait_for_completion, None, self.close_channel, self.done] def set_open(self): self.open = True self.offset_defined = True if __name__ == '__main__': exec_file_transfer_test(SendFileBeforeAccept, ReceiveFileTest)
if not FILE_TRANSFER_ENABLED: print("NOTE: built with --disable-file-transfer") raise SystemExit(77) class SendFileTransferToUnknownContactTest(SendFileTest): def __init__(self, bytestream_cls, file, address_type, access_control, acces_control_param): SendFileTest.__init__(self, bytestream_cls, file, address_type, access_control, acces_control_param) self._actions = [ self.connect, self.check_ft_available, self.my_request_ft_channel ] def my_request_ft_channel(self): self.contact_name = 'jean@localhost' self.handle = self.conn.get_contact_handle_sync(self.contact_name) try: self.request_ft_channel() except dbus.DBusException as e: assert e.get_dbus_name() == cs.OFFLINE else: assert False if __name__ == '__main__': exec_file_transfer_test(SendFileTransferToUnknownContactTest)
from file_transfer_helper import SendFileTest, exec_file_transfer_test from config import FILE_TRANSFER_ENABLED if not FILE_TRANSFER_ENABLED: print("NOTE: built with --disable-file-transfer") raise SystemExit(77) class SendFileAndCancelImmediatelyTest(SendFileTest): def provide_file(self): SendFileTest.provide_file(self) # cancel the transfer before the receiver accepts it self.channel.Close() e = self.q.expect('dbus-signal', signal='FileTransferStateChanged') state, reason = e.args assert state == cs.FT_STATE_CANCELLED assert reason == cs.FT_STATE_CHANGE_REASON_LOCAL_STOPPED self.q.expect('dbus-signal', signal='Closed') # XEP-0096 doesn't have a way to inform receiver we cancelled the # transfer... return True if __name__ == '__main__': exec_file_transfer_test(SendFileAndCancelImmediatelyTest)
assert e.get_dbus_name() == cs.NOT_AVAILABLE else: assert False self.close_channel() # stop the test return True class SendFileAndDisconnect(SendFileTest): def __init__(self, file, address_type, access_control, acces_control_param): FileTransferTest.__init__(self, file, address_type, access_control, acces_control_param) self._actions = [ self.connect, self.set_ft_caps, self.check_ft_available, None, self.wait_for_ft_caps, None, self.request_ft_channel, self.provide_file, self.disconnect, None, self.close_channel, self.done ] def disconnect(self): self.conn.Disconnect() if __name__ == '__main__': exec_file_transfer_test(SendFileAndDisconnect, \ ReceiveFileAndSenderDisconnectWhilePendingTest)
if not JINGLE_FILE_TRANSFER_ENABLED: print("NOTE: built with --disable-file-transfer or --disable-voip") raise SystemExit(77) print("FIXME: test is not stable enough.\n" + " https://bugs.freedesktop.org/show_bug.cgi?id=49595") raise SystemExit(77) class SendFileBeforeAccept(SendFileTest): def __init__(self, file, address_type, access_control, acces_control_param): FileTransferTest.__init__(self, file, address_type, access_control, acces_control_param) self._actions = [ self.connect, self.set_ft_caps, self.check_ft_available, None, self.wait_for_ft_caps, None, self.request_ft_channel, self.provide_file, self.set_open, self.send_file, None, self.wait_for_completion, None, self.close_channel, self.done ] def set_open(self): self.open = True self.offset_defined = True if __name__ == '__main__': exec_file_transfer_test(SendFileBeforeAccept, ReceiveFileTest)
raise SystemExit(77) class SendFileAndWaitToProvide(SendFileTest): def __init__(self, file, address_type, access_control, acces_control_param): FileTransferTest.__init__(self, file, address_type, access_control, acces_control_param) self._actions = [ self.connect, self.set_ft_caps, self.check_ft_available, None, self.wait_for_ft_caps, None, self.request_ft_channel, self.check_pending_state, None, self.check_accepted_state, self.provide_file, self.send_file, self.wait_for_completion, None, self.close_channel, self.done ] def check_pending_state(self): # state is still Pending as remote didn't accept the transfer yet state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'State') assert state == cs.FT_STATE_PENDING def check_accepted_state(self): # Remote accepted the transfer state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'State') assert state == cs.FT_STATE_ACCEPTED, state if __name__ == '__main__': exec_file_transfer_test(SendFileAndWaitToProvide, ReceiveFileTest)
import dbus import constants as cs from file_transfer_helper import SendFileTest, exec_file_transfer_test class SendFileTransferToUnknownContactTest(SendFileTest): def __init__(self, bytestream_cls, file, address_type, access_control, acces_control_param): SendFileTest.__init__(self, bytestream_cls, file, address_type, access_control, acces_control_param) self._actions = [self.connect, self.check_ft_available, self.my_request_ft_channel] def my_request_ft_channel(self): self.contact_name = 'jean@localhost' self.handle = self.conn.RequestHandles(cs.HT_CONTACT, [self.contact_name])[0] try: self.request_ft_channel() except dbus.DBusException, e: assert e.get_dbus_name() == cs.OFFLINE else: assert False if __name__ == '__main__': exec_file_transfer_test(SendFileTransferToUnknownContactTest)
import constants as cs from file_transfer_helper import SendFileTest, exec_file_transfer_test from config import FILE_TRANSFER_ENABLED if not FILE_TRANSFER_ENABLED: print "NOTE: built with --disable-file-transfer" raise SystemExit(77) class SendFileAndCancelImmediatelyTest(SendFileTest): def provide_file(self): SendFileTest.provide_file(self) # cancel the transfer before the receiver accepts it self.channel.Close() e = self.q.expect('dbus-signal', signal='FileTransferStateChanged') state, reason = e.args assert state == cs.FT_STATE_CANCELLED assert reason == cs.FT_STATE_CHANGE_REASON_LOCAL_STOPPED self.q.expect('dbus-signal', signal='Closed') # XEP-0096 doesn't have a way to inform receiver we cancelled the # transfer... return True if __name__ == '__main__': exec_file_transfer_test(SendFileAndCancelImmediatelyTest)
self.request_ft_channel, self.provide_file, None, self.check_declined, self.close_channel, self.done] def check_declined(self): state_event = self.q.expect('dbus-signal', signal='FileTransferStateChanged', path=self.channel.object_path) state, reason = state_event.args assert state == cs.FT_STATE_CANCELLED assert reason == cs.FT_STATE_CHANGE_REASON_REMOTE_STOPPED transferred = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'TransferredBytes') # no byte has been transferred as the file was declined assert transferred == 0 # try to provide the file try: self.provide_file() except dbus.DBusException, e: assert e.get_dbus_name() == cs.NOT_AVAILABLE else: assert False if __name__ == '__main__': exec_file_transfer_test(SendFileDeclined, ReceiveFileDecline)
import constants as cs from file_transfer_helper import exec_file_transfer_test, ReceiveFileTest class ReceiveFileAndCancelWhileReceiving(ReceiveFileTest): def receive_file(self): # Connect to Gabble's socket s = self.create_socket() s.connect(self.address) # for some reason the socket is closed s.close() # we receive one more byte from the sender self.bytestream.send_data(self.file.data[2:3]) self.q.expect('dbus-signal', signal='FileTransferStateChanged', args=[cs.FT_STATE_CANCELLED, cs.FT_STATE_CHANGE_REASON_LOCAL_ERROR]) self.channel.Close() self.q.expect('dbus-signal', signal='Closed') return True if __name__ == '__main__': exec_file_transfer_test(ReceiveFileAndCancelWhileReceiving)
access_control, acces_control_param): FileTransferTest.__init__(self, file, address_type, access_control, acces_control_param) self._actions = [self.connect, self.set_ft_caps, self.check_ft_available, None, self.wait_for_ft_caps, None, self.request_ft_channel, self.provide_file, None, self.close_and_check, None, self.close_channel, self.done] def close_and_check(self): self.channel.Close() state_event, _ = self.q.expect_many( EventPattern('dbus-signal', signal='FileTransferStateChanged', path=self.channel.object_path), EventPattern('dbus-signal', signal='Closed', path=self.channel.object_path)) state, reason = state_event.args assert state == cs.FT_STATE_CANCELLED assert reason == cs.FT_STATE_CHANGE_REASON_LOCAL_STOPPED if __name__ == '__main__': exec_file_transfer_test(SendFileAndClose, ReceiveFileStopped)
# -*- coding: utf-8 -*- from file_transfer_helper import SendFileTest, ReceiveFileTest, \ exec_file_transfer_test, File from config import JINGLE_FILE_TRANSFER_ENABLED if not JINGLE_FILE_TRANSFER_ENABLED: print("NOTE: built with --disable-file-transfer or --disable-voip") raise SystemExit(77) print( "FIXME: test is not working now and I have no idea how it was supposed to work.\n" + " Needs porting to normal Jingle Session from google session.") raise SystemExit(77) if __name__ == '__main__': file = File() file.offset = 5 file.name = "The greek foo δοκιμή.txt" exec_file_transfer_test(SendFileTest, ReceiveFileTest, file)
reply['id'] = self.iq['id'] error = reply.addElement((None, 'error')) error['code'] = '403' error['type'] = 'cancel' forbidden = error.addElement((ns.STANZA, 'forbidden')) text = error.addElement((ns.STANZA, 'text'), content='Offer Declined') self.stream.send(reply) e = self.q.expect('dbus-signal', signal='FileTransferStateChanged') state, reason = e.args assert state == cs.FT_STATE_CANCELLED, state assert reason == cs.FT_STATE_CHANGE_REASON_REMOTE_STOPPED transferred = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'TransferredBytes') # no byte has been transferred as the file was declined assert transferred == 0 # try to provide the file, assert that this finishes the test (e.g. # couldn't go further because of ipv6) or that it raises # cs.NOT_AVAILABLE try: assert self.provide_file() except dbus.DBusException, e: assert e.get_dbus_name() == cs.NOT_AVAILABLE # stop test return True if __name__ == '__main__': exec_file_transfer_test(SendFileDeclinedTest)
from file_transfer_helper import exec_file_transfer_test, ReceiveFileTest from config import FILE_TRANSFER_ENABLED if not FILE_TRANSFER_ENABLED: print "NOTE: built with --disable-file-transfer" raise SystemExit(77) class ReceiveFileAndDisconnectTest(ReceiveFileTest): def receive_file(self): s = self.create_socket() s.connect(self.address) # return True so the test will be ended and the connection # disconnected return True if __name__ == '__main__': exec_file_transfer_test(ReceiveFileAndDisconnectTest)
self.file.offset, byte_arrays=True) except dbus.DBusException, e: assert e.get_dbus_name() == cs.NOT_AVAILABLE else: assert False if SendFileTest.provide_file(self): return True # state is still Pending as remote didn't accept the transfer yet state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'State') assert state == cs.FT_STATE_PENDING def client_accept_file(self): SendFileTest.client_accept_file(self) e = self.q.expect('dbus-signal', signal='InitialOffsetDefined') offset = e.args[0] assert offset == self.file.offset # Channel is open. We can start to send the file e = self.q.expect('dbus-signal', signal='FileTransferStateChanged') state, reason = e.args assert state == cs.FT_STATE_OPEN assert reason == cs.FT_STATE_CHANGE_REASON_NONE if __name__ == '__main__': exec_file_transfer_test(SendFileTransferProvideImmediately)
import constants as cs from file_transfer_helper import SendFileTest, ReceiveFileTest, \ exec_file_transfer_test class ReceiveFileAndCancelWhileReceiving(ReceiveFileTest): def receive_file(self): # Connect to Gabble's socket s = self.create_socket() s.connect(self.address) # for some reason the socket is closed s.close() self.q.expect('dbus-signal', signal='FileTransferStateChanged', args=[cs.FT_STATE_CANCELLED, cs.FT_STATE_CHANGE_REASON_LOCAL_ERROR]) if __name__ == '__main__': exec_file_transfer_test(SendFileTest, ReceiveFileAndCancelWhileReceiving)
cs.TARGET_HANDLE: self.handle, cs.FT_CONTENT_TYPE: self.file.content_type, cs.FT_FILENAME: self.file.name, cs.FT_SIZE: self.file.size, cs.FT_CONTENT_HASH_TYPE: self.file.hash_type, cs.FT_CONTENT_HASH: self.file.hash, cs.FT_DESCRIPTION: self.file.description, cs.FT_DATE: self.file.date, cs.FT_INITIAL_OFFSET: 0, cs.FT_SERVICE_NAME: self.service_name, cs.FT_METADATA: dbus.Dictionary(self.metadata, signature='sas') } call_async(self.q, self.conn.Requests, 'CreateChannel', request) # no support for metadata, soz self.q.expect('dbus-error', method='CreateChannel', name=cs.NOT_CAPABLE) return True if __name__ == '__main__': exec_file_transfer_test(SendFileNoMetadata, True) exec_file_transfer_test(ReceiveFileNoMetadata, True) exec_file_transfer_test(SendFileOddMetadata, True) exec_file_transfer_test(ReceiveFileOddMetadata, True) exec_file_transfer_test(SendFileBadProps, True) exec_file_transfer_test(SendFileBadContact, True)
from file_transfer_helper import exec_file_transfer_test, ReceiveFileTest from config import FILE_TRANSFER_ENABLED if not FILE_TRANSFER_ENABLED: print "NOTE: built with --disable-file-transfer" raise SystemExit(77) if __name__ == '__main__': exec_file_transfer_test(ReceiveFileTest)
def accept_file(self): # The sender of the file disconnects presence = domish.Element(('jabber:client', 'presence')) presence['from'] = self.contact_full_jid presence['to'] = 'test@localhost/Resource' presence['type'] = 'unavailable' self.stream.send(presence) e = self.q.expect('dbus-signal', signal='FileTransferStateChanged') state, reason = e.args assert state == cs.FT_STATE_CANCELLED assert reason == cs.FT_STATE_CHANGE_REASON_REMOTE_STOPPED # We can't accept the transfer now try: # IPv4 is always guaranteed to be available self.ft_channel.AcceptFile(cs.SOCKET_ADDRESS_TYPE_IPV4, cs.SOCKET_ACCESS_CONTROL_LOCALHOST, "", 0) except dbus.DBusException, e: assert e.get_dbus_name() == cs.NOT_AVAILABLE else: assert False self.close_channel() # stop the test return True if __name__ == '__main__': exec_file_transfer_test(ReceiveFileAndSenderDisconnectWhilePendingTest)
from servicetest import EventPattern from twisted.words.xish import xpath import constants as cs from file_transfer_helper import ReceiveFileTest, exec_file_transfer_test class ReceiveFileDeclineTest(ReceiveFileTest): def accept_file(self): # decline FT self.channel.Close() state_event, iq_event = self.q.expect_many( EventPattern('dbus-signal', signal='FileTransferStateChanged'), EventPattern('stream-iq', iq_type='error')) error_node = xpath.queryForNodes('/iq/error', iq_event.stanza)[0] assert error_node['code'] == '403' state, reason = state_event.args assert state == cs.FT_STATE_CANCELLED assert reason == cs.FT_STATE_CHANGE_REASON_LOCAL_STOPPED self.q.expect('dbus-signal', signal='Closed') # stop test return True if __name__ == '__main__': exec_file_transfer_test(ReceiveFileDeclineTest)
class SendFileAndWaitToProvide (SendFileTest): def __init__(self, file, address_type, access_control, acces_control_param): FileTransferTest.__init__(self, file, address_type, access_control, acces_control_param) self._actions = [self.connect, self.set_ft_caps, self.check_ft_available, None, self.wait_for_ft_caps, None, self.request_ft_channel, self.check_pending_state, None, self.check_accepted_state, self.provide_file, self.send_file, self.wait_for_completion, None, self.close_channel, self.done] def check_pending_state(self): # state is still Pending as remote didn't accept the transfer yet state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'State') assert state == cs.FT_STATE_PENDING def check_accepted_state(self): # Remote accepted the transfer state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'State') assert state == cs.FT_STATE_ACCEPTED, state if __name__ == '__main__': exec_file_transfer_test(SendFileAndWaitToProvide, ReceiveFileTest)
print("NOTE: built with --disable-file-transfer") raise SystemExit(77) class ReceiveFileAndCancelWhileReceiving(ReceiveFileTest): def receive_file(self): # Connect to Gabble's socket s = self.create_socket() s.connect(self.address) # for some reason the socket is closed s.close() # we receive one more byte from the sender self.bytestream.send_data(self.file.data[2:3]) self.q.expect('dbus-signal', signal='FileTransferStateChanged', args=[ cs.FT_STATE_CANCELLED, cs.FT_STATE_CHANGE_REASON_LOCAL_ERROR ]) self.channel.Close() self.q.expect('dbus-signal', signal='Closed') return True if __name__ == '__main__': exec_file_transfer_test(ReceiveFileAndCancelWhileReceiving)
# -*- coding: utf-8 -*- from file_transfer_helper import SendFileTest, ReceiveFileTest, \ exec_file_transfer_test, File if __name__ == '__main__': file = File() file.offset = 5 file.name = "The greek foo δοκιμή.txt" exec_file_transfer_test(SendFileTest, ReceiveFileTest, file)
self.ft_channel.AcceptFile(self.address_type, self.access_control, self.access_control_param, self.file.offset, byte_arrays=True) except dbus.DBusException, e: assert e.get_dbus_name() == cs.NOT_AVAILABLE else: assert False if SendFileTest.provide_file(self): return True # state is still Pending as remote didn't accept the transfer yet state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'State') assert state == cs.FT_STATE_PENDING def client_accept_file(self): SendFileTest.client_accept_file(self) e = self.q.expect('dbus-signal', signal='InitialOffsetDefined') offset = e.args[0] assert offset == self.file.offset # Channel is open. We can start to send the file e = self.q.expect('dbus-signal', signal='FileTransferStateChanged') state, reason = e.args assert state == cs.FT_STATE_OPEN assert reason == cs.FT_STATE_CHANGE_REASON_NONE if __name__ == '__main__': exec_file_transfer_test(SendFileTransferProvideImmediately)
def client_accept_file(self): # state is still Pending as remote didn't accept the transfer yet state = self.ft_props.Get(cs.CHANNEL_TYPE_FILE_TRANSFER, 'State') assert state == cs.FT_STATE_PENDING SendFileTest.client_accept_file(self) # Remote accepted the transfer e = self.q.expect('dbus-signal', signal='FileTransferStateChanged') state, reason = e.args assert state == cs.FT_STATE_ACCEPTED, state assert reason == cs.FT_STATE_CHANGE_REASON_NONE def provide_file(self): if SendFileTest.provide_file(self): return True e = self.q.expect('dbus-signal', signal='InitialOffsetDefined') offset = e.args[0] assert offset == self.file.offset # Channel is open. We can start to send the file e = self.q.expect('dbus-signal', signal='FileTransferStateChanged') state, reason = e.args assert state == cs.FT_STATE_OPEN assert reason == cs.FT_STATE_CHANGE_REASON_REQUESTED if __name__ == '__main__': exec_file_transfer_test(SendFileTransferWaitToProvideTest)